Changed all VOID_DataValue declarations to readonly.
[VOID.git] / VOID_VesselInfo.cs
blob:a/VOID_VesselInfo.cs -> blob:b/VOID_VesselInfo.cs
  // VOID
// //
// VOID_Orbital.cs // VOID_VesselInfo.cs
// //
// Author: // Copyright © 2014, toadicus
// toadicus <> // All rights reserved.
// //
// Copyright (c) 2013 toadicus // Redistribution and use in source and binary forms, with or without modification,
  // are permitted provided that the following conditions are met:
// //
// This program is free software: you can redistribute it and/or modify // 1. Redistributions of source code must retain the above copyright notice,
// it under the terms of the GNU General Public License as published by // this list of conditions and the following disclaimer.
// the Free Software Foundation, either version 3 of the License, or  
// (at your option) any later version.  
// //
// This program is distributed in the hope that it will be useful, // 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // materials provided with the distribution.
// GNU General Public License for more details.  
// //
// You should have received a copy of the GNU General Public License // 3. Neither the name of the copyright holder nor the names of its contributors may be used
// along with this program. If not, see <http://www.gnu.org/licenses/>. // to endorse or promote products derived from this software without specific prior written permission.
  //
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   
  using KerbalEngineer.VesselSimulator;
  using KerbalEngineer.Extensions;
using KSP; using KSP;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
  using ToadicusTools;
using UnityEngine; using UnityEngine;
using Engineer.VesselSimulator;  
using Engineer.Extensions;  
   
namespace VOID namespace VOID
{ {
public class VOID_VesselInfo : VOID_WindowModule public class VOID_VesselInfo : VOID_WindowModule
{ {
public VOID_VesselInfo() : base() public VOID_VesselInfo() : base()
{ {
this._Name = "Vessel Information"; this.Name = "Vessel Information";
   
this.WindowPos.x = Screen.width - 260; this.WindowPos.x = Screen.width - 260;
this.WindowPos.y = 450; this.WindowPos.y = 450;
} }
   
public override void ModuleWindow(int _) public override void ModuleWindow(int id)
{ {
base.ModuleWindow (_);  
   
if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate)) if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))
{ {
SimManager.Instance.RequestSimulation(); SimManager.RequestSimulation();
} }
   
GUILayout.BeginVertical(); GUILayout.BeginVertical();
   
GUILayout.Label( GUILayout.Label(
vessel.vesselName, Vessel.vesselName,
VOID_Core.Instance.LabelStyles["center_bold"], VOID_Styles.labelCenterBold,
GUILayout.ExpandWidth(true)); GUILayout.ExpandWidth(true));
   
Tools.PostDebugMessage("Starting VesselInfo window.");  
   
VOID_Data.geeForce.DoGUIHorizontal ("F2"); VOID_Data.geeForce.DoGUIHorizontal ("F2");
   
Tools.PostDebugMessage("GeeForce done.");  
   
VOID_Data.partCount.DoGUIHorizontal (); VOID_Data.partCount.DoGUIHorizontal ();
   
Tools.PostDebugMessage("PartCount done."); VOID_Data.totalMass.DoGUIHorizontal ("F3");
   
VOID_Data.totalMass.DoGUIHorizontal ("F1"); VOID_Data.stageResourceMass.DoGUIHorizontal("F2");
   
Tools.PostDebugMessage("TotalMass done."); VOID_Data.resourceMass.DoGUIHorizontal("F2");
   
VOID_Data.resourceMass.DoGUIHorizontal ("F1");  
   
Tools.PostDebugMessage("ResourceMass done.");  
   
VOID_Data.stageDeltaV.DoGUIHorizontal (3, false); VOID_Data.stageDeltaV.DoGUIHorizontal (3, false);
   
Tools.PostDebugMessage("Stage deltaV done.");  
   
VOID_Data.totalDeltaV.DoGUIHorizontal (3, false); VOID_Data.totalDeltaV.DoGUIHorizontal (3, false);
   
Tools.PostDebugMessage("Total deltaV done.");  
   
VOID_Data.mainThrottle.DoGUIHorizontal ("F0"); VOID_Data.mainThrottle.DoGUIHorizontal ("F0");
   
Tools.PostDebugMessage("MainThrottle done.");  
   
VOID_Data.currmaxThrust.DoGUIHorizontal (); VOID_Data.currmaxThrust.DoGUIHorizontal ();
   
Tools.PostDebugMessage("CurrMaxThrust done.");  
   
VOID_Data.currmaxThrustWeight.DoGUIHorizontal (); VOID_Data.currmaxThrustWeight.DoGUIHorizontal ();
   
Tools.PostDebugMessage("CurrMaxTWR done.");  
   
VOID_Data.surfaceThrustWeight.DoGUIHorizontal ("F2"); VOID_Data.surfaceThrustWeight.DoGUIHorizontal ("F2");
   
Tools.PostDebugMessage("surfaceTWR done.");  
   
VOID_Data.intakeAirStatus.DoGUIHorizontal(); VOID_Data.intakeAirStatus.DoGUIHorizontal();
   
Tools.PostDebugMessage("intakeAirStatus done.");  
   
GUILayout.EndVertical(); GUILayout.EndVertical();
   
Tools.PostDebugMessage("VesselInfo window done."); base.ModuleWindow(id);
   
GUI.DragWindow();  
} }
}  
   
public static partial class VOID_Data  
{  
public static readonly VOID_DoubleValue geeForce = new VOID_DoubleValue(  
"G-force",  
new Func<double>(() => VOID_Core.Instance.vessel.geeForce),  
"gees"  
);  
   
public static readonly VOID_IntValue partCount = new VOID_IntValue(  
"Parts",  
new Func<int>(() => VOID_Core.Instance.vessel.Parts.Count),  
""  
);  
   
public static readonly VOID_DoubleValue totalMass = new VOID_DoubleValue(  
"Total Mass",  
new Func<double> (() => SimManager.Instance.TryGetLastMass()),  
"tons"  
);  
   
public static readonly VOID_DoubleValue resourceMass = new VOID_DoubleValue(  
"Resource Mass",  
delegate()  
{  
double rscMass = 0;  
foreach (Part part in VOID_Core.Instance.vessel.Parts)  
{  
rscMass += part.GetResourceMass();  
}  
return rscMass;  
},  
"tons"  
);  
   
public static readonly VOID_DoubleValue stageDeltaV = new VOID_DoubleValue(  
"DeltaV (Current Stage)",  
delegate()  
{  
if (SimManager.Instance.Stages == null ||  
SimManager.Instance.Stages.Length <= Staging.lastStage  
)  
return double.NaN;  
return SimManager.Instance.Stages[Staging.lastStage].deltaV;  
},  
"m/s"  
);  
   
public static readonly VOID_DoubleValue totalDeltaV = new VOID_DoubleValue(  
"DeltaV (Total)",  
delegate()  
{  
if (SimManager.Instance.Stages == null)  
return double.NaN;  
return SimManager.Instance.LastStage.totalDeltaV;  
},  
"m/s"  
);  
   
public static readonly VOID_FloatValue mainThrottle = new VOID_FloatValue(  
"Throttle",  
new Func<float>(() => VOID_Core.Instance.vessel.ctrlState.mainThrottle * 100f),  
"%"  
);  
   
public static readonly VOID_StrValue currmaxThrust = new VOID_StrValue(  
"Thrust (curr/max)",  
delegate()  
{  
if (SimManager.Instance.Stages == null)  
return "N/A";  
   
double currThrust = SimManager.Instance.LastStage.actualThrust;  
double maxThrust = SimManager.Instance.LastStage.thrust;  
   
return string.Format(  
"{0} / {1}",  
currThrust.ToString("F1"),  
maxThrust.ToString("F1")  
);  
}  
);  
   
public static readonly VOID_StrValue currmaxThrustWeight = new VOID_StrValue(  
"T:W (curr/max)",  
delegate()  
{  
if (SimManager.Instance.Stages == null)  
return "N/A";  
   
double currThrust = SimManager.Instance.LastStage.actualThrust;  
double maxThrust = SimManager.Instance.LastStage.thrust;  
double mass = SimManager.Instance.TryGetLastMass();  
double gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /  
Math.Pow(  
VOID_Core.Instance.vessel.mainBody.Radius + VOID_Core.Instance.vessel.altitude,  
2  
);  
double weight = mass * gravity;  
   
return string.Format(  
"{0} / {1}",  
(currThrust / weight).ToString("F2"),  
(maxThrust / weight).ToString("F2")  
);  
}  
);  
   
public static readonly VOID_DoubleValue surfaceThrustWeight = new VOID_DoubleValue(  
"Max T:W @ surface",  
delegate()  
{  
if (SimManager.Instance.Stages == null)  
return double.NaN;  
   
double maxThrust = SimManager.Instance.LastStage.thrust;  
double mass = SimManager.Instance.TryGetLastMass();  
double gravity = (VOID_Core.Constant_G * VOID_Core.Instance.vessel.mainBody.Mass) /  
Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);  
double weight = mass * gravity;  
   
return maxThrust / weight;  
},  
""  
);  
   
public static readonly VOID_StrValue intakeAirStatus = new VOID_StrValue(  
"Intake Air (Curr / Req)",  
delegate()  
{  
double currentAmount;  
double currentRequirement;  
   
currentAmount = 0d;  
currentRequirement = 0d;  
   
foreach (Part part in VOID_Core.Instance.vessel.Parts)  
{  
if (part.HasModule<ModuleEngines>() && part.enabled)  
{  
foreach (Propellant propellant in part.GetModule<ModuleEngines>().propellants)  
{  
if (propellant.name == "IntakeAir")  
{  
// currentAmount += propellant.currentAmount;  
currentRequirement += propellant.currentRequirement / TimeWarp.fixedDeltaTime;  
break;  
}  
}  
}  
   
if (part.HasModule<ModuleResourceIntake>() && part.enabled)  
{  
ModuleResourceIntake intakeModule = part.GetModule<ModuleResourceIntake>();  
   
if (intakeModule.resourceName == "IntakeAir")  
{  
currentAmount += intakeModule.airFlow;  
}  
}  
}  
   
if (currentAmount == 0 && currentRequirement == 0)  
{  
return "N/A";  
}  
   
return string.Format("{0:F3} / {1:F3}", currentAmount, currentRequirement);  
}  
);  
} }
} }