Initial commit (1.0_dev)
[VOID.git] / VOID_HUD.cs
blob:a/VOID_HUD.cs -> blob:b/VOID_HUD.cs
// // VOID
// VOID_Hud.cs //
// // VOID_HUD.cs
// Author: //
// toadicus <> // Copyright © 2014, toadicus
// // All rights reserved.
// Copyright (c) 2013 toadicus //
// // Redistribution and use in source and binary forms, with or without modification,
// This program is free software: you can redistribute it and/or modify // are permitted provided that the following conditions are met:
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or // 1. Redistributions of source code must retain the above copyright notice,
// (at your option) any later version. // this list of conditions and the following disclaimer.
// //
// 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. //
// // 3. Neither the name of the copyright holder nor the names of its contributors may be used
// You should have received a copy of the GNU General Public License // to endorse or promote products derived from this software without specific prior written permission.
// along with this program. If not, see <http://www.gnu.org/licenses/>. //
// // 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
using KSP; // DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
using UnityEngine; // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
using System; // SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
using System.Collections.Generic; // 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.
namespace VOID  
{ using KerbalEngineer.VesselSimulator;
public class VOID_HUD : IVOID_Module using KSP;
{ using System;
/* using System.Collections.Generic;
* Static Members using System.Text;
* */ using ToadicusTools;
protected static VOID_HUD _instance; using UnityEngine;
   
public static IVOID_Module Instance { namespace VOID
get { {
if (_instance == null) { public class VOID_HUD : VOID_Module, IVOID_Module
Tools.PostDebugMessage ("Instantiating VOID_HUD"); {
_instance = new VOID_HUD (); /*
} * Fields
Tools.PostDebugMessage ("Returning VOID_HUD instance."); * */
return _instance; [AVOID_SaveValue("colorIndex")]
} protected VOID_SaveValue<int> _colorIndex;
}  
  protected List<Color> textColors;
/*  
* Fields protected Rect leftHUDdefaultPos;
* */ protected Rect rightHUDdefaultPos;
protected List<Color> textColors = new List<Color>();  
  [AVOID_SaveValue("leftHUDPos")]
protected GUIStyle labelStyle; protected VOID_SaveValue<Rect> leftHUDPos;
  [AVOID_SaveValue("rightHUDPos")]
protected int _counterTextColor = 0; protected VOID_SaveValue<Rect> rightHUDPos;
   
protected Vessel vessel = null; [AVOID_SaveValue("positionsLocked")]
  protected VOID_SaveValue<bool> positionsLocked;
public bool guiRunning = false;  
  /*
/* * Properties
* Properties * */
* */ public int ColorIndex
public int ColorIndex {
{ get
get {
{ return this._colorIndex;
return this._counterTextColor; }
} set
set {
{ if (this._colorIndex >= this.textColors.Count - 1)
if (this._counterTextColor >= this.textColors.Count - 1) {
{ this._colorIndex = 0;
this._counterTextColor = 0; return;
return; }
}  
  this._colorIndex = value;
this._counterTextColor = value; }
} }
}  
  /*
/* * Methods
* Methods * */
* */ public VOID_HUD() : base()
private VOID_HUD() : base() {
{ this._Name = "Heads-Up Display";
Tools.PostDebugMessage ("Constructing VOID_HUD");  
try this.toggleActive = true;
{  
this.textColors.Add(Color.green); this._colorIndex = 0;
this.textColors.Add(Color.black);  
this.textColors.Add(Color.white); this.textColors = new List<Color>();
this.textColors.Add(Color.red);  
this.textColors.Add(Color.blue); this.textColors.Add(Color.green);
this.textColors.Add(Color.yellow); this.textColors.Add(Color.black);
this.textColors.Add(Color.gray); this.textColors.Add(Color.white);
this.textColors.Add(Color.cyan); this.textColors.Add(Color.red);
this.textColors.Add(Color.magenta); this.textColors.Add(Color.blue);
} this.textColors.Add(Color.yellow);
catch (NullReferenceException) this.textColors.Add(Color.gray);
{ this.textColors.Add(Color.cyan);
Tools.PostDebugMessage ("Caught NRE while adding colors."); this.textColors.Add(Color.magenta);
}  
  this.leftHUDdefaultPos = new Rect(Screen.width * .375f - 300f, 0f, 300f, 90f);
this.labelStyle = new GUIStyle (); this.leftHUDPos = new Rect(this.leftHUDdefaultPos);
this.labelStyle.normal.textColor = this.textColors [this.ColorIndex];  
  this.rightHUDdefaultPos = new Rect(Screen.width * .625f, 0f, 300f, 90f);
Tools.PostDebugMessage ("VOID_HUD Constructed."); this.rightHUDPos = new Rect(this.rightHUDdefaultPos);
}  
  this.positionsLocked = true;
~VOID_HUD()  
{ Tools.PostDebugMessage ("VOID_HUD: Constructed.");
Tools.PostDebugMessage ("Destructing VOID_HUD"); }
this.SaveConfig();  
System.Diagnostics.StackTrace trace = new System.Diagnostics.StackTrace(); protected void leftHUDWindow(int id)
  {
Tools.PostDebugMessage (trace.ToString ()); StringBuilder leftHUD;
}  
  leftHUD = new StringBuilder();
public void DrawGUI()  
{ VOID_Styles.labelHud.alignment = TextAnchor.UpperRight;
Tools.PostDebugMessage ("VOID_HUD: Drawing GUI.");  
if (vessel == null) if (this.core.powerAvailable)
{ {
vessel = VOIDFlightMaster.Instance.vessel; leftHUD.AppendFormat("Primary: {0} Inc: {1}",
} VOID_Data.primaryName.ValueUnitString(),
  VOID_Data.orbitInclination.ValueUnitString("F3")
if (vessel != FlightGlobals.ActiveVessel) );
{ leftHUD.AppendFormat("\nObt Alt: {0} Obt Vel: {1}",
return; VOID_Data.orbitAltitude.ToSIString(),
} VOID_Data.orbitVelocity.ToSIString()
  );
if (VOIDFlightMaster.Instance.power_toggle) leftHUD.AppendFormat("\nAp: {0} ETA {1}",
{ VOID_Data.orbitApoAlt.ToSIString(),
if (VOIDFlightMaster.Instance.power_available || VOIDFlightMaster.Instance.disable_power_usage) VOID_Data.timeToApo.ValueUnitString()
{ );
labelStyle.normal.textColor = textColors [ColorIndex]; leftHUD.AppendFormat("\nPe: {0} ETA {1}",
  VOID_Data.oribtPeriAlt.ToSIString(),
GUI.Label ( VOID_Data.timeToPeri.ValueUnitString()
new Rect ((Screen.width * .2083f), 0, 300f, 70f), );
"Obt Alt: " + Tools.MuMech_ToSI (vessel.orbit.altitude) + "m" + leftHUD.AppendFormat("\nTot Δv: {0} Stg Δv: {1}",
" Obt Vel: " + Tools.MuMech_ToSI (vessel.orbit.vel.magnitude) + "m/s" + VOID_Data.totalDeltaV.ToSIString(2),
"\nAp: " + Tools.MuMech_ToSI (vessel.orbit.ApA) + "m" + VOID_Data.stageDeltaV.ToSIString(2)
" ETA " + Tools.ConvertInterval (vessel.orbit.timeToAp) + );
"\nPe: " + Tools.MuMech_ToSI (vessel.orbit.PeA) + "m" + }
" ETA " + Tools.ConvertInterval (vessel.orbit.timeToPe) + else
"\nInc: " + vessel.orbit.inclination.ToString ("F3") + "°", {
labelStyle); VOID_Styles.labelHud.normal.textColor = Color.red;
// Toadicus edit: Added "Biome: " line to surf/atmo HUD leftHUD.Append(string.Intern("-- POWER LOST --"));
GUI.Label ( }
new Rect ((Screen.width * .625f), 0, 300f, 90f),  
"Srf Alt: " + Tools.MuMech_ToSI (Tools.TrueAltitude (vessel)) + "m" + GUILayout.Label(leftHUD.ToString(), VOID_Styles.labelHud, GUILayout.ExpandWidth(true));
" Srf Vel: " + Tools.MuMech_ToSI (vessel.srf_velocity.magnitude) + "m/s" +  
"\nVer: " + Tools.MuMech_ToSI (vessel.verticalSpeed) + "m/s" + if (!this.positionsLocked)
" Hor: " + Tools.MuMech_ToSI (vessel.horizontalSrfSpeed) + "m/s" + {
"\nLat: " + Tools.GetLatitudeString (vessel, "F3") + GUI.DragWindow();
" Lon: " + Tools.GetLongitudeString (vessel, "F3") + }
"\nHdg: " + Tools.MuMech_get_heading (vessel).ToString ("F2") + "° " +  
Tools.get_heading_text (Tools.MuMech_get_heading (vessel)) + GUI.BringWindowToBack(id);
"\nBiome: " + Tools.Toadicus_GetAtt (vessel).name, }
labelStyle);  
} protected void rightHUDWindow(int id)
else {
{ StringBuilder rightHUD;
labelStyle.normal.textColor = Color.red;  
GUI.Label (new Rect ((Screen.width * .2083f), 0, 300f, 70f), "-- POWER LOST --", labelStyle); rightHUD = new StringBuilder();
GUI.Label (new Rect ((Screen.width * .625f), 0, 300f, 70f), "-- POWER LOST --", labelStyle);  
} VOID_Styles.labelHud.alignment = TextAnchor.UpperLeft;
}  
} if (this.core.powerAvailable)
  {
public void StartGUI() rightHUD.AppendFormat("Biome: {0} Sit: {1}",
{ VOID_Data.currBiome.ValueUnitString(),
Tools.PostDebugMessage ("Adding VOID_HUD to the draw queue."); VOID_Data.expSituation.ValueUnitString()
RenderingManager.AddToPostDrawQueue (3, new Callback(this.DrawGUI)); );
this.guiRunning = true; rightHUD.AppendFormat("\nSrf Alt: {0} Srf Vel: {1}",
} VOID_Data.trueAltitude.ToSIString(),
  VOID_Data.surfVelocity.ToSIString()
public void StopGUI() );
{ rightHUD.AppendFormat("\nVer: {0} Hor: {1}",
Tools.PostDebugMessage ("Removing VOID_HUD from the draw queue."); VOID_Data.vertVelocity.ToSIString(),
RenderingManager.RemoveFromPostDrawQueue (3, new Callback(this.DrawGUI)); VOID_Data.horzVelocity.ToSIString()
this.guiRunning = false; );
} rightHUD.AppendFormat("\nLat: {0} Lon: {1}",
  VOID_Data.surfLatitude.ValueUnitString(),
public void SaveConfig() VOID_Data.surfLongitude.ValueUnitString()
{ );
Tools.PostDebugMessage ("VOID_HUD: Saving Config."); rightHUD.AppendFormat("\nHdg: {0} Pit: {1}",
var config = KSP.IO.PluginConfiguration.CreateForType<VOID_HUD> (); VOID_Data.vesselHeading.ValueUnitString(),
config.load (); VOID_Data.vesselPitch.ToSIString(2)
config.SetValue ("ColorIndex", this.ColorIndex); );
config.save ();  
} if (
  this.core.vessel.mainBody == this.core.HomeBody &&
public void LoadConfig() (
{ this.core.vessel.situation == Vessel.Situations.FLYING ||
Tools.PostDebugMessage ("VOID_HUD: Loading Config."); this.core.vessel.situation == Vessel.Situations.SUB_ORBITAL ||
var config = KSP.IO.PluginConfiguration.CreateForType<VOID_HUD> (); this.core.vessel.situation == Vessel.Situations.LANDED ||
config.load (); this.core.vessel.situation == Vessel.Situations.SPLASHED
this.ColorIndex = config.GetValue ("ColorIndex", 0); )
} )
} {
} rightHUD.AppendFormat("\nRange to KSC: {0}", VOID_Data.downrangeDistance.ValueUnitString(2));
  }
  }
  else
  {
  VOID_Styles.labelHud.normal.textColor = Color.red;
  rightHUD.Append(string.Intern("-- POWER LOST --"));
  }
   
   
  GUILayout.Label(rightHUD.ToString(), VOID_Styles.labelHud, GUILayout.ExpandWidth(true));
   
  if (!this.positionsLocked)
  {
  GUI.DragWindow();
  }
   
  GUI.BringWindowToBack(id);
  }
   
  public override void DrawGUI()
  {
  VOID_Styles.labelHud.normal.textColor = textColors [ColorIndex];
   
  GUI.skin = this.core.Skin;
   
  if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))
  {
  SimManager.RequestSimulation();
  }
   
  this.leftHUDPos.value = GUI.Window(
  this.core.windowID,
  this.leftHUDPos,
  VOID_Tools.GetWindowHandler(this.leftHUDWindow),
  GUIContent.none,
  GUIStyle.none
  );
   
  this.rightHUDPos.value = GUI.Window(
  this.core.windowID,
  this.rightHUDPos,
  VOID_Tools.GetWindowHandler(this.rightHUDWindow),
  GUIContent.none,
  GUIStyle.none
  );
  }
   
  public override void DrawConfigurables()
  {
  if (GUILayout.Button (string.Intern("Change HUD color"), GUILayout.ExpandWidth (false)))
  {
  ++this.ColorIndex;
  }
   
  if (GUILayout.Button(string.Intern("Reset HUD Positions"), GUILayout.ExpandWidth(false)))
  {
  this.leftHUDPos = new Rect(this.leftHUDdefaultPos);
  this.rightHUDPos = new Rect(this.rightHUDdefaultPos);
  }
   
  this.positionsLocked = GUILayout.Toggle(this.positionsLocked,
  string.Intern("Lock HUD Positions"),
  GUILayout.ExpandWidth(false));
  }
  }
  }