Preliminary port of DataLogger. Parts of the GUI are definitely broken, but the file writes.
Preliminary port of DataLogger. Parts of the GUI are definitely broken, but the file writes.

file:a/AVOID_ConfigValue.cs (deleted)
//  
// AVOID_ConfigValue.cs  
//  
// Author:  
// toadicus <>  
//  
// Copyright (c) 2013 toadicus  
//  
// This program is free software: you can redistribute it and/or modify  
// it under the terms of the GNU General Public License as published by  
// 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,  
// but WITHOUT ANY WARRANTY; without even the implied warranty of  
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  
// GNU General Public License for more details.  
//  
// You should have received a copy of the GNU General Public License  
// along with this program. If not, see <http://www.gnu.org/licenses/>.  
using System;  
 
namespace VOID  
{  
 
}  
 
 
file:a/AVOID_Configurable.cs (deleted)
//  
// AVOID_Configurable.cs  
//  
// Author:  
// toadicus <>  
//  
// Copyright (c) 2013 toadicus  
//  
// This program is free software: you can redistribute it and/or modify  
// it under the terms of the GNU General Public License as published by  
// 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,  
// but WITHOUT ANY WARRANTY; without even the implied warranty of  
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the  
// GNU General Public License for more details.  
//  
// You should have received a copy of the GNU General Public License  
// along with this program. If not, see <http://www.gnu.org/licenses/>.  
using System;  
 
namespace VOID  
{  
[AttributeUsage(AttributeTargets.Method)]  
public class AVOID_Configurable : Attribute { }  
}  
 
 
// //
// IVOID_Module.cs // IVOID_Module.cs
// //
// Author: // Author:
// toadicus <> // toadicus <>
// //
// Copyright (c) 2013 toadicus // Copyright (c) 2013 toadicus
// //
// This program is free software: you can redistribute it and/or modify // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// This program is distributed in the hope that it will be useful, // This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details. // GNU General Public License for more details.
// //
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
using System; using System;
   
namespace VOID namespace VOID
{ {
public interface IVOID_Module public interface IVOID_Module
{ {
string Name { get; } string Name { get; }
bool hasConfigurables { get; }  
bool toggleActive { get; set; } bool toggleActive { get; set; }
bool guiRunning { get; } bool guiRunning { get; }
   
void DrawGUI(); void DrawGUI();
void StartGUI(); void StartGUI();
void StopGUI(); void StopGUI();
   
void DrawConfigurables(); void DrawConfigurables();
   
void LoadConfig(); void LoadConfig();
   
void SaveConfig(); void _SaveToConfig(KSP.IO.PluginConfiguration config);
  }
   
   
   
  public interface IVOID_BehaviorModule : IVOID_Module
  {
  void Update();
  void FixedUpdate();
} }
} }
   
file:a/Tools.cs -> file:b/Tools.cs
// //
// Tools.cs // Tools.cs
// //
// Author: // Author:
// toadicus // toadicus
// //
// Copyright (c) 2013 toadicus // Copyright (c) 2013 toadicus
// //
// This program is free software: you can redistribute it and/or modify // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// This program is distributed in the hope that it will be useful, // This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details. // GNU General Public License for more details.
// //
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
// //
// This software uses VesselSimulator and Engineer.Extensions from Engineer Redux. // This software uses VesselSimulator and Engineer.Extensions from Engineer Redux.
// Engineer Redux (c) 2013 cybutek // Engineer Redux (c) 2013 cybutek
// Used by permission. // Used by permission.
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
   
   
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using UnityEngine; using UnityEngine;
   
namespace VOID namespace VOID
{ {
public class VOIDLabels public static class VOIDLabels
{ {
public string void_primary; public static string void_primary = "Primary";
public string void_altitude_asl; public static string void_altitude_asl = "Altitude (ASL)";
public string void_velocity; public static string void_velocity = "Velocity";
public string void_apoapsis; public static string void_apoapsis = "Apoapsis";
public string void_periapsis; public static string void_periapsis = "Periapsis";
} }
   
public static class Tools public static class Tools
{ {
// Toadicus edit: Added re-implementation of the CBAttributeMap.GetAtt function that does not fire a debug message to the game screen. // Toadicus edit: Added re-implementation of the CBAttributeMap.GetAtt function that does not fire a debug message to the game screen.
public static CBAttributeMap.MapAttribute Toadicus_GetAtt(Vessel vessel) public static CBAttributeMap.MapAttribute Toadicus_GetAtt(Vessel vessel)
{ {
CBAttributeMap.MapAttribute mapAttribute; CBAttributeMap.MapAttribute mapAttribute;
   
try try
{ {
CBAttributeMap BiomeMap = vessel.mainBody.BiomeMap; CBAttributeMap BiomeMap = vessel.mainBody.BiomeMap;
double lat = vessel.latitude * Math.PI / 180d; double lat = vessel.latitude * Math.PI / 180d;
double lon = vessel.longitude * Math.PI / 180d; double lon = vessel.longitude * Math.PI / 180d;
   
lon -= Math.PI / 2d; lon -= Math.PI / 2d;
   
if (lon < 0d) if (lon < 0d)
{ {
lon += 2d * Math.PI; lon += 2d * Math.PI;
} }
   
float v = (float)(lat / Math.PI) + 0.5f; float v = (float)(lat / Math.PI) + 0.5f;
float u = (float)(lon / (2d * Math.PI)); float u = (float)(lon / (2d * Math.PI));
   
Color pixelBilinear = BiomeMap.Map.GetPixelBilinear (u, v); Color pixelBilinear = BiomeMap.Map.GetPixelBilinear (u, v);
mapAttribute = BiomeMap.defaultAttribute; mapAttribute = BiomeMap.defaultAttribute;
   
if (BiomeMap.Map != null) if (BiomeMap.Map != null)
{ {
if (BiomeMap.exactSearch) if (BiomeMap.exactSearch)
{ {
for (int i = 0; i < BiomeMap.Attributes.Length; ++i) for (int i = 0; i < BiomeMap.Attributes.Length; ++i)
{ {
if (pixelBilinear == BiomeMap.Attributes[i].mapColor) if (pixelBilinear == BiomeMap.Attributes[i].mapColor)
{ {
mapAttribute = BiomeMap.Attributes[i]; mapAttribute = BiomeMap.Attributes[i];
} }
} }
} }
else else
{ {
float zero = 0; float zero = 0;
float num = 1 / zero; float num = 1 / zero;
for (int j = 0; j < BiomeMap.Attributes.Length; ++j) for (int j = 0; j < BiomeMap.Attributes.Length; ++j)
{ {
Color mapColor = BiomeMap.Attributes [j].mapColor; Color mapColor = BiomeMap.Attributes [j].mapColor;
float sqrMagnitude = ((Vector4)(mapColor - pixelBilinear)).sqrMagnitude; float sqrMagnitude = ((Vector4)(mapColor - pixelBilinear)).sqrMagnitude;
if (sqrMagnitude < num) if (sqrMagnitude < num)
{ {
bool testCase = true; bool testCase = true;
if (BiomeMap.nonExactThreshold != -1) if (BiomeMap.nonExactThreshold != -1)
{ {
testCase = (sqrMagnitude < BiomeMap.nonExactThreshold); testCase = (sqrMagnitude < BiomeMap.nonExactThreshold);
} }
if (testCase) if (testCase)
{ {
mapAttribute = BiomeMap.Attributes[j]; mapAttribute = BiomeMap.Attributes[j];
num = sqrMagnitude; num = sqrMagnitude;
} }
} }
} }
} }
} }
} }
catch (NullReferenceException) catch (NullReferenceException)
{ {
mapAttribute = new CBAttributeMap.MapAttribute(); mapAttribute = new CBAttributeMap.MapAttribute();
mapAttribute.name = "N/A"; mapAttribute.name = "N/A";
} }
   
return mapAttribute; return mapAttribute;
} }
   
public static string GetLongitudeString(Vessel vessel, string format="F4") public static string GetLongitudeString(Vessel vessel, string format="F4")
{ {
string dir_long = "W"; string dir_long = "W";
double v_long = vessel.longitude; double v_long = vessel.longitude;
   
v_long = FixDegreeDomain(v_long); v_long = FixDegreeDomain(v_long);
   
if (v_long < -180d) if (v_long < -180d)
{ {
v_long += 360d; v_long += 360d;
} }
if (v_long >= 180) if (v_long >= 180)
{ {
v_long -= 360d; v_long -= 360d;
} }
   
if (v_long > 0) dir_long = "E"; if (v_long > 0) dir_long = "E";
   
return string.Format("{0}° {1}", Math.Abs(v_long).ToString(format), dir_long); return string.Format("{0}° {1}", Math.Abs(v_long).ToString(format), dir_long);
} }
   
public static string GetLatitudeString(Vessel vessel, string format="F4") public static string GetLatitudeString(Vessel vessel, string format="F4")
{ {
string dir_lat = "S"; string dir_lat = "S";
double v_lat = vessel.latitude; double v_lat = vessel.latitude;
if (v_lat > 0) dir_lat = "N"; if (v_lat > 0) dir_lat = "N";
   
return string.Format("{0}° {1}", Math.Abs(v_lat).ToString(format), dir_lat); return string.Format("{0}° {1}", Math.Abs(v_lat).ToString(format), dir_lat);
} }
   
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
   
//For MuMech_get_heading() //For MuMech_get_heading()
public class MuMech_MovingAverage public class MuMech_MovingAverage
{ {
private double[] store; private double[] store;
private int storeSize; private int storeSize;
private int nextIndex = 0; private int nextIndex = 0;
   
public double value public double value
{ {
get get
{ {
double tmp = 0; double tmp = 0;
foreach (double i in store) foreach (double i in store)
{ {
tmp += i; tmp += i;
} }
return tmp / storeSize; return tmp / storeSize;
} }
set set
{ {
store[nextIndex] = value; store[nextIndex] = value;
nextIndex = (nextIndex + 1) % storeSize; nextIndex = (nextIndex + 1) % storeSize;
} }
} }
   
public MuMech_MovingAverage(int size = 10, double startingValue = 0) public MuMech_MovingAverage(int size = 10, double startingValue = 0)
{ {
storeSize = size; storeSize = size;
store = new double[size]; store = new double[size];
force(startingValue); force(startingValue);
} }
   
public void force(double newValue) public void force(double newValue)
{ {
for (int i = 0; i < storeSize; i++) for (int i = 0; i < storeSize; i++)
{ {
store[i] = newValue; store[i] = newValue;
} }
} }
   
public static implicit operator double(MuMech_MovingAverage v) public static implicit operator double(MuMech_MovingAverage v)
{ {
return v.value; return v.value;
} }
   
public override string ToString() public override string ToString()
{ {
return value.ToString(); return value.ToString();
} }
   
public string ToString(string format) public string ToString(string format)
{ {
return value.ToString(format); return value.ToString(format);
} }
} }
   
//From http://svn.mumech.com/KSP/trunk/MuMechLib/VOID.vesselState.cs //From http://svn.mumech.com/KSP/trunk/MuMechLib/VOID.vesselState.cs
public static double MuMech_get_heading(Vessel vessel) public static double MuMech_get_heading(Vessel vessel)
{ {
Vector3d CoM = vessel.findWorldCenterOfMass(); Vector3d CoM = vessel.findWorldCenterOfMass();
Vector3d up = (CoM - vessel.mainBody.position).normalized; Vector3d up = (CoM - vessel.mainBody.position).normalized;
Vector3d north = Vector3d.Exclude(up, (vessel.mainBody.position + vessel.mainBody.transform.up * (float)vessel.mainBody.Radius) - CoM).normalized; Vector3d north = Vector3d.Exclude(up, (vessel.mainBody.position + vessel.mainBody.transform.up * (float)vessel.mainBody.Radius) - CoM).normalized;
   
Quaternion rotationSurface = Quaternion.LookRotation(north, up); Quaternion rotationSurface = Quaternion.LookRotation(north, up);
Quaternion rotationvesselSurface = Quaternion.Inverse(Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(vessel.transform.rotation) * rotationSurface); Quaternion rotationvesselSurface = Quaternion.Inverse(Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(vessel.transform.rotation) * rotationSurface);
MuMech_MovingAverage vesselHeading = new MuMech_MovingAverage(); MuMech_MovingAverage vesselHeading = new MuMech_MovingAverage();
vesselHeading.value = rotationvesselSurface.eulerAngles.y; vesselHeading.value = rotationvesselSurface.eulerAngles.y;
return vesselHeading.value * 10; // *10 by me return vesselHeading.value * 10; // *10 by me
} }
   
//From http://svn.mumech.com/KSP/trunk/MuMechLib/MuUtils.cs //From http://svn.mumech.com/KSP/trunk/MuMechLib/MuUtils.cs
public static string MuMech_ToSI(double d) public static string MuMech_ToSI(double d)
{ {
int digits = 2; int digits = 2;
double exponent = Math.Log10(Math.Abs(d)); double exponent = Math.Log10(Math.Abs(d));
if (Math.Abs(d) >= 1) if (Math.Abs(d) >= 1)
{ {
switch ((int)Math.Floor(exponent)) switch ((int)Math.Floor(exponent))
{ {
case 0: case 0:
case 1: case 1:
case 2: case 2:
return d.ToString("F" + digits); return d.ToString("F" + digits);
case 3: case 3:
case 4: case 4:
case 5: case 5:
return (d / 1e3).ToString("F" + digits) + "k"; return (d / 1e3).ToString("F" + digits) + "k";
case 6: case 6:
case 7: case 7:
case 8: case 8:
return (d / 1e6).ToString("F" + digits) + "M"; return (d / 1e6).ToString("F" + digits) + "M";
case 9: case 9:
case 10: case 10:
case 11: case 11:
return (d / 1e9).ToString("F" + digits) + "G"; return (d / 1e9).ToString("F" + digits) + "G";
case 12: case 12:
case 13: case 13:
case 14: case 14:
return (d / 1e12).ToString("F" + digits) + "T"; return (d / 1e12).ToString("F" + digits) + "T";
case 15: case 15:
case 16: case 16:
case 17: case 17:
return (d / 1e15).ToString("F" + digits) + "P"; return (d / 1e15).ToString("F" + digits) + "P";
case 18: case 18:
case 19: case 19:
case 20: case 20:
return (d / 1e18).ToString("F" + digits) + "E"; return (d / 1e18).ToString("F" + digits) + "E";
case 21: case 21:
case 22: case 22:
case 23: case 23:
return (d / 1e21).ToString("F" + digits) + "Z"; return (d / 1e21).ToString("F" + digits) + "Z";
default: default:
return (d / 1e24).ToString("F" + digits) + "Y"; return (d / 1e24).ToString("F" + digits) + "Y";
} }
} }
else if (Math.Abs(d) > 0) else if (Math.Abs(d) > 0)
{ {
switch ((int)Math.Floor(exponent)) switch ((int)Math.Floor(exponent))
{ {
case -1: case -1:
case -2: case -2:
case -3: case -3:
return (d * 1e3).ToString("F" + digits) + "m"; return (d * 1e3).ToString("F" + digits) + "m";
case -4: case -4:
case -5: case -5:
case -6: case -6:
return (d * 1e6).ToString("F" + digits) + "μ"; return (d * 1e6).ToString("F" + digits) + "μ";
case -7: case -7:
case -8: case -8:
case -9: case -9:
return (d * 1e9).ToString("F" + digits) + "n"; return (d * 1e9).ToString("F" + digits) + "n";
case -10: case -10:
case -11: case -11:
case -12: case -12:
return (d * 1e12).ToString("F" + digits) + "p"; return (d * 1e12).ToString("F" + digits) + "p";
case -13: case -13:
case -14: case -14:
case -15: case -15:
return (d * 1e15).ToString("F" + digits) + "f"; return (d * 1e15).ToString("F" + digits) + "f";
case -16: case -16:
case -17: case -17:
case -18: case -18:
return (d * 1e18).ToString("F" + digits) + "a"; return (d * 1e18).ToString("F" + digits) + "a";
case -19: case -19:
case -20: case -20:
case -21: case -21:
return (d * 1e21).ToString("F" + digits) + "z"; return (d * 1e21).ToString("F" + digits) + "z";
default: default:
return (d * 1e24).ToString("F" + digits) + "y"; return (d * 1e24).ToString("F" + digits) + "y";
} }
} }
else else
{ {
return "0"; return "0";
} }
} }
   
public static string ConvertInterval(double seconds) public static string ConvertInterval(double seconds)
{ {
string format_1 = "{0:D1}y {1:D1}d {2:D2}h {3:D2}m {4:D2}.{5:D1}s"; string format_1 = "{0:D1}y {1:D1}d {2:D2}h {3:D2}m {4:D2}.{5:D1}s";
string format_2 = "{0:D1}d {1:D2}h {2:D2}m {3:D2}.{4:D1}s"; string format_2 = "{0:D1}d {1:D2}h {2:D2}m {3:D2}.{4:D1}s";
string format_3 = "{0:D2}h {1:D2}m {2:D2}.{3:D1}s"; string format_3 = "{0:D2}h {1:D2}m {2:D2}.{3:D1}s";
   
TimeSpan interval; TimeSpan interval;
   
try try
{ {
interval = TimeSpan.FromSeconds(seconds); interval = TimeSpan.FromSeconds(seconds);
} }
catch (OverflowException) catch (OverflowException)
{ {
return "NaN"; return "NaN";
} }
   
int years = interval.Days / 365; int years = interval.Days / 365;
   
string output; string output;
if (years > 0) if (years > 0)
{ {
output = string.Format(format_1, output = string.Format(format_1,
years, years,
interval.Days - (years * 365), // subtract years * 365 for accurate day count interval.Days - (years * 365), // subtract years * 365 for accurate day count
interval.Hours, interval.Hours,
interval.Minutes, interval.Minutes,
interval.Seconds, interval.Seconds,
interval.Milliseconds.ToString().Substring(0, 1)); interval.Milliseconds.ToString().Substring(0, 1));
} }
else if (interval.Days > 0) else if (interval.Days > 0)
{ {
output = string.Format(format_2, output = string.Format(format_2,
interval.Days, interval.Days,
interval.Hours, interval.Hours,
interval.Minutes, interval.Minutes,
interval.Seconds, interval.Seconds,
interval.Milliseconds.ToString().Substring(0, 1)); interval.Milliseconds.ToString().Substring(0, 1));
} }
else else
{ {
output = string.Format(format_3, output = string.Format(format_3,
interval.Hours, interval.Hours,
interval.Minutes, interval.Minutes,
interval.Seconds, interval.Seconds,
interval.Milliseconds.ToString().Substring(0, 1)); interval.Milliseconds.ToString().Substring(0, 1));
} }
return output; return output;
} }
   
public static string UppercaseFirst(string s) public static string UppercaseFirst(string s)
{ {
if (string.IsNullOrEmpty(s)) if (string.IsNullOrEmpty(s))
{ {
return string.Empty; return string.Empty;
} }
char[] a = s.ToCharArray(); char[] a = s.ToCharArray();
a[0] = char.ToUpper(a[0]); a[0] = char.ToUpper(a[0]);
return new string(a); return new string(a);
} }
   
//transfer angles //transfer angles
   
public static double Nivvy_CalcTransferPhaseAngle(double r_current, double r_target, double grav_param) public static double Nivvy_CalcTransferPhaseAngle(double r_current, double r_target, double grav_param)
{ {
double T_target = (2 * Math.PI) * Math.Sqrt(Math.Pow((r_target / 1000), 3) / (grav_param / 1000000000)); double T_target = (2 * Math.PI) * Math.Sqrt(Math.Pow((r_target / 1000), 3) / (grav_param / 1000000000));
double T_transfer = (2 * Math.PI) * Math.Sqrt(Math.Pow((((r_target / 1000) + (r_current / 1000)) / 2), 3) / (grav_param / 1000000000)); double T_transfer = (2 * Math.PI) * Math.Sqrt(Math.Pow((((r_target / 1000) + (r_current / 1000)) / 2), 3) / (grav_param / 1000000000));
return 360 * (0.5 - (T_transfer / (2 * T_target))); return 360 * (0.5 - (T_transfer / (2 * T_target)));
} }
   
public static double Younata_DeltaVToGetToOtherBody(double mu, double r1, double r2) public static double Younata_DeltaVToGetToOtherBody(double mu, double r1, double r2)
{ {
/* /*
def deltaVToGetToOtherBody(mu, r1, r2): def deltaVToGetToOtherBody(mu, r1, r2):
# mu = gravity param of common orbiting body of r1 and r2 # mu = gravity param of common orbiting body of r1 and r2
# (e.g. for mun to minmus, mu is kerbin's gravity param # (e.g. for mun to minmus, mu is kerbin's gravity param
# r1 = initial body's orbit radius # r1 = initial body's orbit radius
# r2 = target body's orbit radius # r2 = target body's orbit radius
# return value is km/s # return value is km/s
sur1 = math.sqrt(mu / r1) sur1 = math.sqrt(mu / r1)
sr1r2 = math.sqrt(float(2*r2)/float(r1+r2)) sr1r2 = math.sqrt(float(2*r2)/float(r1+r2))
mult = sr1r2 - 1 mult = sr1r2 - 1
return sur1 * mult return sur1 * mult
*/ */
double sur1, sr1r2, mult; double sur1, sr1r2, mult;
sur1 = Math.Sqrt(mu / r1); sur1 = Math.Sqrt(mu / r1);
sr1r2 = Math.Sqrt((2 * r2) / (r1 + r2)); sr1r2 = Math.Sqrt((2 * r2) / (r1 + r2));
mult = sr1r2 - 1; mult = sr1r2 - 1;
return sur1 * mult; return sur1 * mult;
} }
   
public static double Younata_DeltaVToExitSOI(double mu, double r1, double r2, double v) public static double Younata_DeltaVToExitSOI(double mu, double r1, double r2, double v)
{ {
/* /*
def deltaVToExitSOI(mu, r1, r2, v): def deltaVToExitSOI(mu, r1, r2, v):
# mu = gravity param of current body # mu = gravity param of current body
# r1 = current orbit radius # r1 = current orbit radius
# r2 = SOI radius # r2 = SOI radius
# v = SOI exit velocity # v = SOI exit velocity
foo = r2 * (v**2) - 2 * mu foo = r2 * (v**2) - 2 * mu
bar = r1 * foo + (2 * r2 * mu) bar = r1 * foo + (2 * r2 * mu)
r = r1*r2 r = r1*r2
return math.sqrt(bar / r) return math.sqrt(bar / r)
*/ */
double foo = r2 * Math.Pow(v, 2) - 2 * mu; double foo = r2 * Math.Pow(v, 2) - 2 * mu;
double bar = r1 * foo + (2 * r2 * mu); double bar = r1 * foo + (2 * r2 * mu);
double r = r1 * r2; double r = r1 * r2;
return Math.Sqrt(bar / r); return Math.Sqrt(bar / r);
} }
   
public static double Younata_TransferBurnPoint(double r, double v, double angle, double mu) public static double Younata_TransferBurnPoint(double r, double v, double angle, double mu)
{ {
/* /*
def transferBurnPoint(r, v, angle, mu): def transferBurnPoint(r, v, angle, mu):
# r = parking orbit radius # r = parking orbit radius
# v = ejection velocity # v = ejection velocity
# angle = phase angle (from function phaseAngle()) # angle = phase angle (from function phaseAngle())
# mu = gravity param of current body. # mu = gravity param of current body.
epsilon = ((v**2)/2) - (mu / r) epsilon = ((v**2)/2) - (mu / r)
h = r * v * math.sin(angle) h = r * v * math.sin(angle)
e = math.sqrt(1 + ((2 * epsilon * h**2)/(mu**2))) e = math.sqrt(1 + ((2 * epsilon * h**2)/(mu**2)))
theta = math.acos(1.0 / e) theta = math.acos(1.0 / e)
degrees = theta * (180.0 / math.pi) degrees = theta * (180.0 / math.pi)
return 180 - degrees return 180 - degrees
*/ */
double epsilon, h, ee, theta, degrees; double epsilon, h, ee, theta, degrees;
epsilon = (Math.Pow(v, 2) / 2) - (mu / r); epsilon = (Math.Pow(v, 2) / 2) - (mu / r);
h = r * v * Math.Sin(angle); h = r * v * Math.Sin(angle);
ee = Math.Sqrt(1 + ((2 * epsilon * Math.Pow(h, 2)) / Math.Pow(mu, 2))); ee = Math.Sqrt(1 + ((2 * epsilon * Math.Pow(h, 2)) / Math.Pow(mu, 2)));
theta = Math.Acos(1.0 / ee); theta = Math.Acos(1.0 / ee);
degrees = theta * (180.0 / Math.PI); degrees = theta * (180.0 / Math.PI);
return 180 - degrees; return 180 - degrees;
// returns the ejection angle // returns the ejection angle
} }
   
public static double Adammada_CurrrentPhaseAngle(double body_LAN, double body_orbitPct, double origin_LAN, double origin_orbitPct) public static double Adammada_CurrrentPhaseAngle(double body_LAN, double body_orbitPct, double origin_LAN, double origin_orbitPct)
{ {
double angle = (body_LAN / 360 + body_orbitPct) - (origin_LAN / 360 + origin_orbitPct); double angle = (body_LAN / 360 + body_orbitPct) - (origin_LAN / 360 + origin_orbitPct);
if (angle > 1) angle = angle - 1; if (angle > 1) angle = angle - 1;
if (angle < 0) angle = angle + 1; if (angle < 0) angle = angle + 1;
if (angle > 0.5) angle = angle - 1; if (angle > 0.5) angle = angle - 1;
angle = angle * 360; angle = angle * 360;
return angle; return angle;
} }
   
public static double Adammada_CurrentEjectionAngle(double vessel_long, double origin_rotAngle, double origin_LAN, double origin_orbitPct) public static double Adammada_CurrentEjectionAngle(double vessel_long, double origin_rotAngle, double origin_LAN, double origin_orbitPct)
{ {
//double eangle = ((FlightGlobals.ActiveVOID.vessel.longitude + orbiting.rotationAngle) - (orbiting.orbit.LAN / 360 + orbiting.orbit.orbitPercent) * 360); //double eangle = ((FlightGlobals.ActiveVOID.vessel.longitude + orbiting.rotationAngle) - (orbiting.orbit.LAN / 360 + orbiting.orbit.orbitPercent) * 360);
double eangle = ((vessel_long + origin_rotAngle) - (origin_LAN / 360 + origin_orbitPct) * 360); double eangle = ((vessel_long + origin_rotAngle) - (origin_LAN / 360 + origin_orbitPct) * 360);
   
while (eangle < 0) eangle = eangle + 360; while (eangle < 0) eangle = eangle + 360;
while (eangle > 360) eangle = eangle - 360; while (eangle > 360) eangle = eangle - 360;
if (eangle < 270) eangle = 90 - eangle; if (eangle < 270) eangle = 90 - eangle;
else eangle = 450 - eangle; else eangle = 450 - eangle;
return eangle; return eangle;
} }
   
public static double mrenigma03_calcphase(Vessel vessel, CelestialBody target) //calculates phase angle between the current body and target body public static double mrenigma03_calcphase(Vessel vessel, CelestialBody target) //calculates phase angle between the current body and target body
{ {
Vector3d vecthis = new Vector3d(); Vector3d vecthis = new Vector3d();
Vector3d vectarget = new Vector3d(); Vector3d vectarget = new Vector3d();
vectarget = target.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime()); vectarget = target.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime());
   
if ((vessel.mainBody.name == "Sun") || (vessel.mainBody.referenceBody.referenceBody.name == "Sun")) if ((vessel.mainBody.name == "Sun") || (vessel.mainBody.referenceBody.referenceBody.name == "Sun"))
{ {
vecthis = vessel.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime()); vecthis = vessel.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime());
} }
else else
{ {
vecthis = vessel.mainBody.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime()); vecthis = vessel.mainBody.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime());
} }
   
vecthis = Vector3d.Project(new Vector3d(vecthis.x, 0, vecthis.z), vecthis); vecthis = Vector3d.Project(new Vector3d(vecthis.x, 0, vecthis.z), vecthis);
vectarget = Vector3d.Project(new Vector3d(vectarget.x, 0, vectarget.z), vectarget); vectarget = Vector3d.Project(new Vector3d(vectarget.x, 0, vectarget.z), vectarget);
   
Vector3d prograde = new Vector3d(); Vector3d prograde = new Vector3d();
prograde = Quaternion.AngleAxis(90, Vector3d.forward) * vecthis; prograde = Quaternion.AngleAxis(90, Vector3d.forward) * vecthis;
   
double phase = Vector3d.Angle(vecthis, vectarget); double phase = Vector3d.Angle(vecthis, vectarget);
   
if (Vector3d.Angle(prograde, vectarget) > 90) phase = 360 - phase; if (Vector3d.Angle(prograde, vectarget) > 90) phase = 360 - phase;
   
return (phase + 360) % 360; return (phase + 360) % 360;
} }
   
public static double FixAngleDomain(double Angle, bool Degrees = false) public static double FixAngleDomain(double Angle, bool Degrees = false)
{ {
double Extent = 2d * Math.PI; double Extent = 2d * Math.PI;
if (Degrees) { if (Degrees) {
Extent = 360d; Extent = 360d;
} }
   
Angle = Angle % (Extent); Angle = Angle % (Extent);
if (Angle < 0d) if (Angle < 0d)
{ {
Angle += Extent; Angle += Extent;
} }
   
return Angle; return Angle;
} }
   
public static double FixDegreeDomain(double Angle) public static double FixDegreeDomain(double Angle)
{ {
return FixAngleDomain (Angle, true); return FixAngleDomain (Angle, true);
} }
   
public static double adjustCurrPhaseAngle(double transfer_angle, double curr_phase) public static double adjustCurrPhaseAngle(double transfer_angle, double curr_phase)
{ {
if (transfer_angle < 0) if (transfer_angle < 0)
{ {
if (curr_phase > 0) return (-1 * (360 - curr_phase)); if (curr_phase > 0) return (-1 * (360 - curr_phase));
else if (curr_phase < 0) return curr_phase; else if (curr_phase < 0) return curr_phase;
} }
else if (transfer_angle > 0) else if (transfer_angle > 0)
{ {
if (curr_phase > 0) return curr_phase; if (curr_phase > 0) return curr_phase;
else if (curr_phase < 0) return (360 + curr_phase); else if (curr_phase < 0) return (360 + curr_phase);
} }
return curr_phase; return curr_phase;
} }
   
public static double adjust_current_ejection_angle(double curr_ejection) public static double adjust_current_ejection_angle(double curr_ejection)
{ {
//curr_ejection WILL need to be adjusted once for all transfers as it returns values ranging -180 to 180 //curr_ejection WILL need to be adjusted once for all transfers as it returns values ranging -180 to 180
// need 0-360 instead // need 0-360 instead
// //
// ie i have -17 in the screenshot // ie i have -17 in the screenshot
// need it to show 343 // need it to show 343
// //
// do this // do this
// //
// if < 0, add curr to 360 // 360 + (-17) = 343 // if < 0, add curr to 360 // 360 + (-17) = 343
// else its good as it is // else its good as it is
   
if (curr_ejection < 0) return 360 + curr_ejection; if (curr_ejection < 0) return 360 + curr_ejection;
else return curr_ejection; else return curr_ejection;
   
} }
   
public static double adjust_transfer_ejection_angle(double trans_ejection, double trans_phase) public static double adjust_transfer_ejection_angle(double trans_ejection, double trans_phase)
{ {
// if transfer_phase_angle < 0 its a lower transfer // if transfer_phase_angle < 0 its a lower transfer
//180 + curr_ejection //180 + curr_ejection
// else if transfer_phase_angle > 0 its good as it is // else if transfer_phase_angle > 0 its good as it is
   
if (trans_phase < 0) return 180 + trans_ejection; if (trans_phase < 0) return 180 + trans_ejection;
else return trans_ejection; else return trans_ejection;
   
} }
   
public static double TrueAltitude(Vessel vessel) public static double TrueAltitude(Vessel vessel)
{ {
double trueAltitude = vessel.orbit.altitude - vessel.terrainAltitude; double trueAltitude = vessel.orbit.altitude - vessel.terrainAltitude;
   
// HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m. // HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m.
if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean ) if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean )
{ {
trueAltitude = vessel.orbit.altitude; trueAltitude = vessel.orbit.altitude;
} }
   
return trueAltitude; return trueAltitude;
} }
   
public static string get_heading_text(double heading) public static string get_heading_text(double heading)
{ {
if (heading > 348.75 || heading <= 11.25) return "N"; if (heading > 348.75 || heading <= 11.25) return "N";
else if (heading > 11.25 && heading <= 33.75) return "NNE"; else if (heading > 11.25 && heading <= 33.75) return "NNE";
else if (heading > 33.75 && heading <= 56.25) return "NE"; else if (heading > 33.75 && heading <= 56.25) return "NE";
else if (heading > 56.25 && heading <= 78.75) return "ENE"; else if (heading > 56.25 && heading <= 78.75) return "ENE";
else if (heading > 78.75 && heading <= 101.25) return "E"; else if (heading > 78.75 && heading <= 101.25) return "E";
else if (heading > 101.25 && heading <= 123.75) return "ESE"; else if (heading > 101.25 && heading <= 123.75) return "ESE";
else if (heading > 123.75 && heading <= 146.25) return "SE"; else if (heading > 123.75 && heading <= 146.25) return "SE";
else if (heading > 146.25 && heading <= 168.75) return "SSE"; else if (heading > 146.25 && heading <= 168.75) return "SSE";
else if (heading > 168.75 && heading <= 191.25) return "S"; else if (heading > 168.75 && heading <= 191.25) return "S";
else if (heading > 191.25 && heading <= 213.75) return "SSW"; else if (heading > 191.25 && heading <= 213.75) return "SSW";
else if (heading > 213.75 && heading <= 236.25) return "SW"; else if (heading > 213.75 && heading <= 236.25) return "SW";
else if (heading > 236.25 && heading <= 258.75) return "WSW"; else if (heading > 236.25 && heading <= 258.75) return "WSW";
else if (heading > 258.75 && heading <= 281.25) return "W"; else if (heading > 258.75 && heading <= 281.25) return "W";
else if (heading > 281.25 && heading <= 303.75) return "WNW"; else if (heading > 281.25 && heading <= 303.75) return "WNW";
else if (heading > 303.75 && heading <= 326.25) return "NW"; else if (heading > 303.75 && heading <= 326.25) return "NW";
else if (heading > 326.25 && heading <= 348.75) return "NNW"; else if (heading > 326.25 && heading <= 348.75) return "NNW";
else return ""; else return "";
} }
   
public static double[] ParseXYString(string s)  
{  
string[] xy = s.Split (','); public static void display_transfer_angles_SUN2PLANET(CelestialBody body, Vessel vessel)
if (xy.Length != 2) {
{ GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
throw new ArgumentException ("Argument must be of the format 'x,y'."); GUILayout.Label("Phase angle (curr/trans):");
} GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter).ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
double x = double.Parse (xy [0].Trim ());  
double y = double.Parse (xy [1].Trim ()); GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Transfer velocity:");
return new double[] { x, y }; GUILayout.Label((Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)) * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  }
   
  public static void display_transfer_angles_PLANET2PLANET(CelestialBody body, Vessel vessel)
  {
  double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000));
  double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1));
   
  double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000));
  double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent);
   
  double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360;
  double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent);
   
  double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle);
  double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle);
  double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle);
   
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Phase angle (curr/trans):");
  GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
   
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Ejection angle (curr/trans):");
  GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
   
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Transfer velocity:");
  GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  }
   
  public static void display_transfer_angles_PLANET2MOON(CelestialBody body, Vessel vessel)
  {
  double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000));
   
  double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter);
   
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Phase angle (curr/trans):");
  GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
   
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Transfer velocity:");
  GUILayout.Label((dv1 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  }
   
  public static void display_transfer_angles_MOON2MOON(CelestialBody body, Vessel vessel)
  {
  double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000));
  double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1));
  double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000));
   
  double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent);
  double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent);
   
  double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360;
   
  double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle);
  //double adj_ejection_angle = adjustCurrEjectionAngle(trans_phase_angle, curr_ejection_angle);
   
  //new stuff
  //
  double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle);
  double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle);
  //
  //
   
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Phase angle (curr/trans):");
  GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
   
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Ejection angle (curr/trans):");
  GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
   
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Transfer velocity:");
  GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
} }
private static ScreenMessage debugmsg = new ScreenMessage("", 2f, ScreenMessageStyle.UPPER_RIGHT); private static ScreenMessage debugmsg = new ScreenMessage("", 2f, ScreenMessageStyle.UPPER_RIGHT);
   
[System.Diagnostics.Conditional("DEBUG")] [System.Diagnostics.Conditional("DEBUG")]
public static void PostDebugMessage(string Msg) public static void PostDebugMessage(string Msg)
{ {
if (HighLogic.LoadedScene > GameScenes.SPACECENTER) if (HighLogic.LoadedScene > GameScenes.SPACECENTER)
{ {
debugmsg.message = Msg; debugmsg.message = Msg;
ScreenMessages.PostScreenMessage(debugmsg, true); ScreenMessages.PostScreenMessage(debugmsg, true);
} }
   
KSPLog.print(Msg); KSPLog.print(Msg);
} }
} }
} }
file:b/VOID.csproj (new)
  <?xml version="1.0" encoding="utf-8"?>
  <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
  <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
  <Platform Condition=" '$(Platform)' == '' ">x86</Platform>
  <ProductVersion>10.0.0</ProductVersion>
  <SchemaVersion>2.0</SchemaVersion>
  <ProjectGuid>{45ACC1CC-942C-4A66-BFC7-8BE375938B18}</ProjectGuid>
  <OutputType>Library</OutputType>
  <RootNamespace>VOID</RootNamespace>
  <AssemblyName>VOID</AssemblyName>
  <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' ">
  <DebugSymbols>true</DebugSymbols>
  <DebugType>full</DebugType>
  <Optimize>false</Optimize>
  <OutputPath>bin\Debug</OutputPath>
  <DefineConstants>DEBUG; TRACE</DefineConstants>
  <ErrorReport>prompt</ErrorReport>
  <WarningLevel>4</WarningLevel>
  <ConsolePause>false</ConsolePause>
  <CustomCommands>
  <CustomCommands>
  <Command type="AfterBuild" command="/usr/bin/cp -fv ${ProjectDir}/bin/Debug/VOID.dll /mnt/games/ssd/KSP_linux/GameData/VOID/Plugins/" />
  </CustomCommands>
  </CustomCommands>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' ">
  <Optimize>true</Optimize>
  <OutputPath>bin\Release</OutputPath>
  <ErrorReport>prompt</ErrorReport>
  <WarningLevel>4</WarningLevel>
  <ConsolePause>false</ConsolePause>
  <DefineConstants>TRACE</DefineConstants>
  </PropertyGroup>
  <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
  <ItemGroup>
  <Compile Include="Tools.cs" />
  <Compile Include="IVOID_Module.cs" />
  <Compile Include="VOIDFlightMaster.cs" />
  <Compile Include="VOID_Core.cs" />
  <Compile Include="VOID_Module.cs" />
  <Compile Include="VOID_HUD.cs" />
  <Compile Include="VOID_SaveValue.cs" />
  <Compile Include="VOID_Orbital.cs" />
  <Compile Include="VOID_SurfAtmo.cs" />
  <Compile Include="VOID_VesselInfo.cs" />
  <Compile Include="VOID_Transfer.cs" />
  <Compile Include="VOID_CBInfoBrowser.cs" />
  <Compile Include="VOID_Rendezvous.cs" />
  <Compile Include="VOID_VesselRegister.cs" />
  <Compile Include="VOID_DataLogger.cs" />
  </ItemGroup>
  <ItemGroup>
  <Reference Include="Assembly-CSharp">
  <HintPath>..\..\..\..\..\mnt\games-ssd\KSP_linux\KSP_Data\Managed\Assembly-CSharp.dll</HintPath>
  <Private>False</Private>
  </Reference>
  <Reference Include="UnityEngine">
  <HintPath>..\..\..\..\..\mnt\games-ssd\KSP_linux\KSP_Data\Managed\UnityEngine.dll</HintPath>
  <Private>False</Private>
  </Reference>
  <Reference Include="System">
  <HintPath>..\..\..\..\..\mnt\games-ssd\KSP_linux\KSP_Data\Managed\System.dll</HintPath>
  <Private>False</Private>
  </Reference>
  </ItemGroup>
  <ItemGroup>
  <ProjectReference Include="..\Engineer.Extensions\Engineer.Extensions.csproj">
  <Project>{2FCF882B-0771-4649-8D04-81D7AA76A486}</Project>
  <Name>Engineer.Extensions</Name>
  </ProjectReference>
  <ProjectReference Include="..\VesselSimulator\VesselSimulator.csproj">
  <Project>{30FD6C0B-D36E-462F-B0FF-F0FAC9C666CF}</Project>
  <Name>VesselSimulator</Name>
  </ProjectReference>
  </ItemGroup>
  <ProjectExtensions>
  <MonoDevelop>
  <Properties>
  <Policies>
  <StandardHeader Text=" &#xA; ${FileName}&#xA; &#xA; Author:&#xA; ${AuthorName} &lt;${AuthorEmail}&gt;&#xA;&#xA; Copyright (c) ${Year} ${CopyrightHolder}&#xA;&#xA; This program is free software: you can redistribute it and/or modify&#xA; it under the terms of the GNU General Public License as published by&#xA; the Free Software Foundation, either version 3 of the License, or&#xA; (at your option) any later version.&#xA;&#xA; This program is distributed in the hope that it will be useful,&#xA; but WITHOUT ANY WARRANTY; without even the implied warranty of&#xA; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the&#xA; GNU General Public License for more details.&#xA;&#xA; You should have received a copy of the GNU General Public License&#xA; along with this program. If not, see &lt;http://www.gnu.org/licenses/&gt;." IncludeInNewFiles="True" />
  </Policies>
  </Properties>
  </MonoDevelop>
  </ProjectExtensions>
  </Project>
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// //
// VOID - Vessel Orbital Information Display for Kerbal Space Program // VOID - Vessel Orbital Information Display for Kerbal Space Program
// Copyright (C) 2012 Iannic-ann-od // Copyright (C) 2012 Iannic-ann-od
// Copyright (C) 2013 Toadicus // Copyright (C) 2013 Toadicus
// //
// This program is free software: you can redistribute it and/or modify // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// This program is distributed in the hope that it will be useful, // This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details. // GNU General Public License for more details.
// //
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// //
// Much, much credit to Younata, Adammada, Nivvydaskrl and to all the authors // Much, much credit to Younata, Adammada, Nivvydaskrl and to all the authors
// behind MechJeb, RemoteTech Relay Network, ISA MapSat, and Protractor for some // behind MechJeb, RemoteTech Relay Network, ISA MapSat, and Protractor for some
// invaluable functions and making your nicely written code available to learn from. // invaluable functions and making your nicely written code available to learn from.
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// //
// This software uses VesselSimulator and Engineer.Extensions from Engineer Redux. // This software uses VesselSimulator and Engineer.Extensions from Engineer Redux.
// Engineer Redux (c) 2013 cybutek // Engineer Redux (c) 2013 cybutek
// Used by permission. // Used by permission.
// //
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
   
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using UnityEngine; using UnityEngine;
using Engineer.VesselSimulator; using Engineer.VesselSimulator;
   
namespace VOID namespace VOID
{ {
[KSPAddon(KSPAddon.Startup.Flight, false)] [KSPAddon(KSPAddon.Startup.Flight, false)]
public class VOIDFlightMaster : MonoBehaviour public class VOIDFlightMaster : MonoBehaviour
{ {
protected VOID_Core Core; protected VOID_Core Core;
   
public void Awake() public void Awake()
{ {
Tools.PostDebugMessage ("VOIDLightMaster: Waking up."); Tools.PostDebugMessage ("VOIDLightMaster: Waking up.");
this.Core = (VOID_Core)VOID_Core.Instance; this.Core = (VOID_Core)VOID_Core.Instance;
this.Core.StartGUI (); this.Core.StartGUI ();
Tools.PostDebugMessage ("VOIDFlightMaster: Awake."); Tools.PostDebugMessage ("VOIDFlightMaster: Awake.");
} }
   
public void Update() public void Update()
{ {
if (this.Core == null) if (this.Core == null)
{ {
return; return;
} }
   
this.Core.Update (); this.Core.Update ();
   
  if (this.Core.vessel != null)
  {
  SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter / Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);
  SimManager.Instance.TryStartSimulation();
  }
} }
   
public void FixedUpdate() public void FixedUpdate()
{ {
if (this.Core == null) if (this.Core == null)
{ {
return; return;
} }
   
this.Core.FixedUpdate (); this.Core.FixedUpdate ();
} }
   
// private bool debugging = false;  
//  
// private int window_base_id = -96518722;  
//  
// private double G_constant = .0000000000667;  
//  
// public Vessel vessel;  
// private VOIDLabels label_strings = new VOIDLabels();  
//  
// private List<CelestialBody> all_bodies = new List<CelestialBody>();  
// private List<VesselType> all_vessel_types = new List<VesselType>();  
//  
// //Windows  
// protected Rect main_window_pos = new Rect(Screen.width / 2, Screen.height / 2, 10f, 10f); //VOID main  
// protected Rect void_window_pos = new Rect((Screen.width / 2) - 20, (Screen.height / 2) - 10, 10, 10); //vessel orbital info  
// protected Rect atmo_window_pos = new Rect((Screen.width / 2) - 40, (Screen.height / 2) - 20, 10, 10); //atmospheric info  
// protected Rect transfer_window_pos = new Rect((Screen.width / 2) - 60, (Screen.height / 2) - 30, 10, 10); //transfer angle info  
// protected Rect vessel_register_window_pos = new Rect((Screen.width / 2) - 80, (Screen.height / 2) - 40, 10, 10); //neighboring vessels  
// protected Rect data_logging_window_pos = new Rect((Screen.width / 2) - 100, (Screen.height / 2) - 50, 10, 10); //data logging & time  
// protected Rect vessel_info_window_pos = new Rect((Screen.width / 2) - 120, (Screen.height / 2) - 60, 10, 10); //vessel info  
// protected Rect misc_window_pos = new Rect((Screen.width / 2) - 160, (Screen.height / 2) - 80, 10, 10); //miscellaneous  
// protected Rect body_op_window_pos = new Rect((Screen.width / 2) - 140, (Screen.height / 2) - 70, 10, 10); //body orbital/physical info  
// protected Rect rendezvous_info_window_pos = new Rect((Screen.width / 2) - 180, (Screen.height / 2) - 90, 10, 10); //target vessel info  
// protected Rect lab_window_pos = new Rect(0, 0, 10, 10); //The Lab  
//  
// //Icons  
//  
//  
// //GUI  
// private bool gui_running = false;  
// private int skin_index = 2;  
// private bool main_gui_minimized = false;  
// private bool gui_styles_set = false;  
//  
// //GUIStyles  
// //private GUIStyle label_txt_left;  
// private GUIStyle label_txt_center;  
// private GUIStyle label_txt_center_bold;  
// private GUIStyle label_txt_right; //needed for body OP alignment  
// //private GUIStyle button_txt_left;  
// //private GUIStyle button_txt_center;  
// //private GUIStyle button_txt_right;  
//  
// //private GUIStyle gs_tooltip;  
//  
// //Window toggles  
// private bool void_module = false;  
// private bool extended_orbital_info = false;  
// private bool tad_module = false;  
// private bool atmo_module = false;  
// private bool data_time_module = false;  
// private bool vessel_info_module = false;  
// private bool test_module = false;  
// private bool misc_module = false;  
// private bool vessel_register_module = false;  
// public bool toggleHUDModule = false;  
// private bool celestial_body_info_module = false;  
// private bool rendezvous_module = false;  
//  
// //Celestial body info window  
// private bool body_op_show_orbital = true;  
// private bool body_op_show_physical = true;  
// private int body_OP_body_1_index = 1;  
// private int body_OP_body_2_index = 2;  
// private CelestialBody body_OP_selected_body_1 = new CelestialBody();  
// private CelestialBody body_OP_selected_body_2 = new CelestialBody();  
//  
// //Data logging/time & cfg update  
// private bool csv_logging = false;  
// private List<string> csvList = new List<string>();  
// private float csvWriteTimer = 0;  
// private float csvCollectTimer = 0;  
// private bool first_write = true;  
// private float csv_log_interval;  
// private string csv_log_interval_str = "0.5";  
// private float cfg_update_timer = 0;  
// private double stopwatch1;  
// private bool stopwatch1_running = false;  
//  
// //Vessel Register  
// private Vector2 vessel_register_scroll_pos = new Vector2();  
// private Vessel vesreg_selected_vessel;  
// private bool target_vessel_extended_orbital_info = false;  
// private VesselType vessel_register_vessel_type = VesselType.Ship;  
// private string vessel_register_vessel_situation = "Orbiting";  
// private CelestialBody vessel_register_selected_body = null;  
// private int vessel_register_body_index = 0;  
// private int vessel_register_vessel_type_index = 0;  
// private bool hide_vesreg_info = false; //in rendezvous window  
//  
// //Miscellaneous window & http  
// private string version_name = "VOID ";  
// private string this_version = "0.9.9";  
// private int configVersion = 1;  
// private bool hide_on_pause = false;  
// private bool changing_icon_pos = false;  
// private bool show_tooltips = true;  
// public bool disable_power_usage = true;  
//  
// // Power consumption  
// private float power_request_amount = 0.01f;  
// public bool power_toggle = true;  
// public bool power_available = false;  
//  
// // VesselSimulator  
// Stage[] stages = new Stage[0];  
//  
// // Modules  
// VOID_HUD moduleHUD;  
//  
// //Debugging / limbo  
// private List<CelestialBody> tad_selected_bodies = new List<CelestialBody>(); //Bodies selected in Transfer Angle Info  
// private bool run_once = true; //for Update()  
// private string settings_path;  
//  
// private enum languages { EN };  
// private languages user_lang = languages.EN;  
// private int user_lang_index;  
//  
// public VOIDFlightMaster() : base()  
// {  
// Tools.PostDebugMessage ("Constructing VOID.");  
// }  
//  
// ~VOIDFlightMaster()  
// {  
// Tools.PostDebugMessage ("Destructing VOID.");  
// }  
//  
// private void Innsewerants_writeData(string[] csvArray)  
// {  
// var efile = KSP.IO.File.AppendText<VOIDFlightMaster>(vessel.vesselName + "_data.csv", null);  
// foreach (string line in csvArray)  
// {  
// efile.Write(line);  
// }  
// efile.Close();  
// }  
//  
// private void line_to_csvList()  
// {  
// //called if logging is on and interval has passed  
// //writes one line to the csvList  
//  
// string line = "";  
// if (first_write && !KSP.IO.File.Exists<VOIDFlightMaster>(vessel.vesselName + "_data.csv", null))  
// {  
// first_write = false;  
// line += "Mission Elapsed Time (s);Altitude ASL (m);Altitude above terrain (m);Orbital Velocity (m/s);Surface Velocity (m/s);Vertical Speed (m/s);Horizontal Speed (m/s);Gee Force (gees);Temperature (°C);Gravity (m/s²);Atmosphere Density (g/m³);\n";  
// }  
// //Mission time  
// line += vessel.missionTime.ToString("F3") + ";";  
// //Altitude ASL  
// line += vessel.orbit.altitude.ToString("F3") + ";";  
// //Altitude (true)  
// double alt_true = vessel.orbit.altitude - vessel.terrainAltitude;  
// if (vessel.terrainAltitude < 0) alt_true = vessel.orbit.altitude;  
// line += alt_true.ToString("F3") + ";";  
// //Orbital velocity  
// line += vessel.orbit.vel.magnitude.ToString("F3") + ";";  
// //surface velocity  
// line += vessel.srf_velocity.magnitude.ToString("F3") + ";";  
// //vertical speed  
// line += vessel.verticalSpeed.ToString("F3") + ";";  
// //horizontal speed  
// line += vessel.horizontalSrfSpeed.ToString("F3") + ";";  
// //gee force  
// line += vessel.geeForce.ToString("F3") + ";";  
// //temperature  
// line += vessel.flightIntegrator.getExternalTemperature().ToString("F2") + ";";  
// //gravity  
// double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass());  
// double g_vessel = (G_constant * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2);  
// line += g_vessel.ToString("F3") + ";";  
// //atm density  
// line += (vessel.atmDensity * 1000).ToString("F3") + ";";  
// line += "\n";  
// if (csvList.Contains(line) == false) csvList.Add(line);  
// csvCollectTimer = 0f;  
// }  
//  
// private void main_csv()  
// {  
// // CSV Logging  
// // from ISA MapSat  
// if (csv_logging)  
// {  
// //data logging is on  
// //increment timers  
// csvWriteTimer += Time.deltaTime;  
// csvCollectTimer += Time.deltaTime;  
// }  
// else  
// {  
// //data logging is off  
// //reset any timers and clear anything from csvList  
// csvWriteTimer = 0f;  
// csvCollectTimer = 0f;  
// if (csvList.Count > 0) csvList.Clear();  
// }  
//  
// if (csv_logging && csvCollectTimer >= csv_log_interval && vessel.situation != Vessel.Situations.PRELAUNCH)  
// {  
// //data logging is on, vessel is not prelaunch, and interval has passed  
// //write a line to the list  
// line_to_csvList(); //write to the csv  
// }  
//  
// if (csvList.Count != 0 && csvWriteTimer >= 15f && csv_logging)  
// {  
// // csvList is not empty and interval between writings to file has elapsed  
// //write it  
// string[] csvData;  
// csvData = (string[])csvList.ToArray();  
// Innsewerants_writeData(csvData);  
// csvList.Clear();  
// csvWriteTimer = 0f;  
// }  
// }  
//  
// private void load_language()  
// {  
// ConfigNode lang_node = ConfigNode.Load(settings_path + "lang.dat");  
//  
// if (lang_node != null)  
// {  
// if (lang_node.HasNode(user_lang.ToString()))  
// {  
// ConfigNode _lang = lang_node.GetNode(user_lang.ToString());  
//  
// if (_lang.HasValue("void_primary")) label_strings.void_primary = _lang.GetValue("void_primary");  
// if (_lang.HasValue("void_altitude_asl")) label_strings.void_altitude_asl = _lang.GetValue("void_altitude_asl");  
// if (_lang.HasValue("void_velocity")) label_strings.void_velocity = _lang.GetValue("void_velocity");  
// if (_lang.HasValue("void_apoapsis")) label_strings.void_apoapsis = _lang.GetValue("void_apoapsis");  
// if (_lang.HasValue("void_periapsis")) label_strings.void_periapsis = _lang.GetValue("void_periapsis");  
// }  
// }  
// else  
// {  
// //lang_node == null  
// // Toadicus edit: added settings_path to the debug message for extra verbosity  
// Debug.LogError("[VOID] Unable to load file " + settings_path + "lang.dat!");  
// }  
// }  
//  
// private void load_icons()  
// {  
// // Toadicus edit: changed the directory to VOID instead of RBR, because RBR seemed confusing.  
// string path_icon_on = "VOID/Textures/void_icon_on";  
// string path_icon_off = "VOID/Textures/void_icon_off";  
//  
// if (GameDatabase.Instance.ExistsTexture(path_icon_on) && GameDatabase.Instance.ExistsTexture(path_icon_off))  
// {  
// if (debugging) Debug.Log("icon textures exist, loading...");  
// void_icon_on = GameDatabase.Instance.GetTexture(path_icon_on, false);  
// void_icon_off = GameDatabase.Instance.GetTexture(path_icon_off, false);  
// if (main_gui_minimized) void_icon = void_icon_off;  
// else void_icon = void_icon_on;  
// }  
// else  
// {  
// if (debugging) Debug.LogError("[VOID] icon texture file(s) missing");  
// //void_icons_loaded = false;  
// }  
// }  
//  
// private void load_old_settings()  
// {  
// if (KSP.IO.File.Exists<VOIDFlightMaster>("VOID.cfg", null))  
// {  
// string[] data = KSP.IO.File.ReadAllLines<VOIDFlightMaster>("VOID.cfg", null);  
// string[] name_val;  
// string[] temp;  
// string name = "";  
// string val = "";  
//  
// foreach (string s in data)  
// {  
// name_val = s.Split('=');  
// name = name_val[0].Trim();  
// val = name_val[1].Trim();  
//  
// if (val != "")  
// {  
// if (name == "MAIN WINDOW POS")  
// {  
// temp = val.Split(',');  
// //window_0_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10, 10);  
// main_window_pos.x = Convert.ToSingle(temp[0].Trim());  
// main_window_pos.y = Convert.ToSingle(temp[1].Trim());  
// }  
// if (name == "VOID WINDOW POS")  
// {  
// temp = val.Split(',');  
// void_window_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10f, 10f);  
// }  
// if (name == "ATMO WINDOW POS")  
// {  
// temp = val.Split(',');  
// atmo_window_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10f, 10f);  
// }  
// if (name == "TAD WINDOW POS")  
// {  
// temp = val.Split(',');  
// transfer_window_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10f, 10f);  
// }  
// if (name == "VESREG WINDOW POS")  
// {  
// temp = val.Split(',');  
// vessel_register_window_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10f, 10f);  
// }  
// if (name == "DATATIME WINDOW POS")  
// {  
// temp = val.Split(',');  
// data_logging_window_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10f, 10f);  
// }  
// if (name == "VESINFO WINDOW POS")  
// {  
// temp = val.Split(',');  
// vessel_info_window_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10f, 10f);  
// }  
// if (name == "MISC WINDOW POS")  
// {  
// temp = val.Split(',');  
// misc_window_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10f, 10f);  
// }  
// if (name == "CELINFO WINDOW POS")  
// {  
// temp = val.Split(',');  
// body_op_window_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10f, 10f);  
// }  
// if (name == "RENDEZVOUS WINDOW POS")  
// {  
// temp = val.Split(',');  
// rendezvous_info_window_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 10f, 10f);  
// }  
// if (name == "ICON POS")  
// {  
// temp = val.Split(',');  
// main_icon_pos = new Rect(Convert.ToSingle(temp[0].Trim()), Convert.ToSingle(temp[1].Trim()), 30f, 30f);  
// }  
// if (name == "HUD MODULE") toggleHUDModule = Boolean.Parse(val);  
// if (name == "VOID MODULE") void_module = Boolean.Parse(val);  
// if (name == "ATMO MODULE") atmo_module = Boolean.Parse(val);  
// if (name == "TAD MODULE") tad_module = Boolean.Parse(val);  
// if (name == "VESREG MODULE") vessel_register_module = Boolean.Parse(val);  
// if (name == "DATATIME MODULE") data_time_module = Boolean.Parse(val);  
// if (name == "VESINFO MODULE") vessel_info_module = Boolean.Parse(val);  
// if (name == "MISC MODULE") misc_module = Boolean.Parse(val);  
// if (name == "CELINFO MODULE") celestial_body_info_module = Boolean.Parse(val);  
// if (name == "CELINFO SHOW OBTL") body_op_show_orbital = Boolean.Parse(val);  
// if (name == "CELINFO SHOW PHYS") body_op_show_physical = Boolean.Parse(val);  
// if (name == "MAIN GUI MINIMIZED") main_gui_minimized = Boolean.Parse(val);  
// if (name == "HIDE ON PAUSE") hide_on_pause = Boolean.Parse(val);  
// if (name == "SKIN INDEX") skin_index = Int32.Parse(val);  
// if (name == "DISABLE POWER USAGE") disable_power_usage = Boolean.Parse(val);  
// if (name == "SHOW TOOLTIPS") show_tooltips = Boolean.Parse(val);  
// if (name == "SHOW RENDEZVOUS INFO") rendezvous_module = Boolean.Parse(val);  
// if (name == "USE KSP TARGET") hide_vesreg_info = Boolean.Parse(val);  
// if (name == "USER LANG") user_lang = (languages)Enum.Parse(typeof(languages), val);  
// }  
// }  
// }  
// }  
//  
// private void load_settings()  
// {  
// Tools.PostDebugMessage ("VOID: Loading settings.");  
// var config = KSP.IO.PluginConfiguration.CreateForType<VOIDFlightMaster> ();  
// config.load ();  
//  
// int loadedConfigVersion = config.GetValue ("ConfigVersion", 0);  
//  
// if (loadedConfigVersion < 1 || true)  
// {  
// this.load_old_settings ();  
// // this.write_settings ();  
// // TODO: Enable this when the config update works for sure.  
// // KSP.IO.File.Delete<VOID> ("VOID.cfg");  
// return;  
// }  
//  
// this.main_window_pos = config.GetValue("MAIN_WINDOW_POS", main_window_pos);  
// this.void_window_pos = config.GetValue("VOID_WINDOW_POS", void_window_pos);  
// this.atmo_window_pos = config.GetValue("ATMO_WINDOW_POS", atmo_window_pos);  
// this.transfer_window_pos = config.GetValue("TAD_WINDOW_POS", transfer_window_pos);  
// this.vessel_register_window_pos = config.GetValue("VESREG_WINDOW_POS", vessel_register_window_pos);  
// this.data_logging_window_pos = config.GetValue("DATATIME_WINDOW_POS", data_logging_window_pos);  
// this.vessel_info_window_pos = config.GetValue("VESINFO_WINDOW_POS", vessel_info_window_pos);  
// this.misc_window_pos = config.GetValue("MISC_WINDOW_POS", misc_window_pos);  
// this.body_op_window_pos = config.GetValue("CELINFO_WINDOW_POS", body_op_window_pos);  
// this.rendezvous_info_window_pos = config.GetValue("RENDEZVOUS_WINDOW_POS", rendezvous_info_window_pos);  
// this.main_icon_pos = config.GetValue("ICON_POS", main_icon_pos);  
//  
// this.toggleHUDModule = config.GetValue("HUD_MODULE", false);  
// this.void_module = config.GetValue("VOID_MODULE", false);  
// this.atmo_module = config.GetValue("ATMO_MODULE", false);  
// this.tad_module = config.GetValue("TAD_MODULE", false);  
// this.vessel_register_module = config.GetValue("VESREG_MODULE", false);  
// this.data_time_module = config.GetValue("DATATIME_MODULE", false);  
// this.vessel_info_module = config.GetValue("VESINFO_MODULE", false);  
// this.misc_module = config.GetValue("MISC_MODULE", false);  
// this.celestial_body_info_module = config.GetValue("CELINFO_MODULE", false);  
// this.body_op_show_orbital = config.GetValue("CELINFO_SHOW_OBTL", false);  
// this.body_op_show_physical = config.GetValue("CELINFO_SHOW_PHYS", false);  
// this.main_gui_minimized = config.GetValue("MAIN_GUI_MINIMIZED", false);  
// this.hide_on_pause = config.GetValue("HIDE_ON_PAUSE", false);  
// this.disable_power_usage = config.GetValue("DISABLE_POWER_USAGE", true);  
// this.show_tooltips = config.GetValue("SHOW_TOOLTIPS", false);  
// this.rendezvous_module = config.GetValue("SHOW_RENDEZVOUS_INFO", false);  
// this.hide_vesreg_info = config.GetValue("USE_KSP_TARGET", false);  
//  
// this.skin_index = config.GetValue ("SKIN_INDEX", 0);  
//  
// this.user_lang = (languages)Enum.Parse(typeof(languages), config.GetValue ("USER_LANG", "EN"));  
// }  
//  
// private void write_settings()  
// {  
// Tools.PostDebugMessage ("VOID: Writing settings.");  
// try  
// {  
// var config = KSP.IO.PluginConfiguration.CreateForType<VOIDFlightMaster> ();  
// config.load ();  
//  
// /*  
// config.SetValue ("ConfigVersion", this.configVersion);  
// config.SetValue("MAIN_WINDOW_POS", main_window_pos);  
// config.SetValue("VOID_WINDOW_POS", void_window_pos);  
// config.SetValue("ATMO_WINDOW_POS", atmo_window_pos);  
// config.SetValue("TAD_WINDOW_POS", transfer_window_pos);  
// config.SetValue("VESREG_WINDOW_POS", vessel_register_window_pos);  
// config.SetValue("DATATIME_WINDOW_POS", data_logging_window_pos);  
// config.SetValue("VESINFO_WINDOW_POS", vessel_info_window_pos);  
// config.SetValue("MISC_WINDOW_POS", misc_window_pos);  
// config.SetValue("CELINFO_WINDOW_POS", body_op_window_pos);  
// config.SetValue("RENDEZVOUS_WINDOW_POS", rendezvous_info_window_pos);  
// config.SetValue("ICON_POS", main_icon_pos);  
// config.SetValue("HUD_MODULE", toggleHUDModule);  
// config.SetValue("VOID_MODULE", void_module);  
// config.SetValue("ATMO_MODULE", atmo_module);  
// config.SetValue("TAD_MODULE", tad_module);  
// config.SetValue("VESREG_MODULE", vessel_register_module);  
// config.SetValue("DATATIME_MODULE", data_time_module);  
// config.SetValue("VESINFO_MODULE", vessel_info_module);  
// config.SetValue("MISC_MODULE", misc_module);  
// config.SetValue("CELINFO_MODULE", celestial_body_info_module);  
// config.SetValue("CELINFO_SHOW_OBTL", body_op_show_orbital);  
// config.SetValue("CELINFO_SHOW_PHYS", body_op_show_physical);  
// config.SetValue("MAIN_GUI_MINIMIZED", main_gui_minimized);  
// config.SetValue("HIDE_ON_PAUSE", hide_on_pause);  
// config.SetValue("SKIN_INDEX", skin_index);  
// config.SetValue("DISABLE_POWER_USAGE", disable_power_usage);  
// config.SetValue("SHOW_TOOLTIPS", show_tooltips);  
// config.SetValue("SHOW_RENDEZVOUS_INFO", rendezvous_module);  
// config.SetValue("USE_KSP_TARGET", hide_vesreg_info);  
// config.SetValue("USER_LANG", user_lang);  
// */  
//  
// try  
// {  
// config.SetValue ("ConfigVersion", this.configVersion);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue (\"ConfigVersion\", this.configVersion);");  
// }  
// try  
// {  
// config.SetValue("MAIN_WINDOW_POS", main_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"MAIN_WINDOW_POS\", main_window_pos);");  
// }  
// try  
// {  
// config.SetValue("VOID_WINDOW_POS", void_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"VOID_WINDOW_POS\", void_window_pos);");  
// }  
// try  
// {  
// config.SetValue("ATMO_WINDOW_POS", atmo_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"ATMO_WINDOW_POS\", atmo_window_pos);");  
// }  
// try  
// {  
// config.SetValue("TAD_WINDOW_POS", transfer_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"TAD_WINDOW_POS\", transfer_window_pos);");  
// }  
// try  
// {  
// config.SetValue("VESREG_WINDOW_POS", vessel_register_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"VESREG_WINDOW_POS\", vessel_register_window_pos);");  
// }  
// try  
// {  
// config.SetValue("DATATIME_WINDOW_POS", data_logging_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"DATATIME_WINDOW_POS\", data_logging_window_pos);");  
// }  
// try  
// {  
// config.SetValue("VESINFO_WINDOW_POS", vessel_info_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"VESINFO_WINDOW_POS\", vessel_info_window_pos);");  
// }  
// try  
// {  
// config.SetValue("MISC_WINDOW_POS", misc_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"MISC_WINDOW_POS\", misc_window_pos);");  
// }  
// try  
// {  
// config.SetValue("CELINFO_WINDOW_POS", body_op_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"CELINFO_WINDOW_POS\", body_op_window_pos);");  
// }  
// try  
// {  
// config.SetValue("RENDEZVOUS_WINDOW_POS", rendezvous_info_window_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"RENDEZVOUS_WINDOW_POS\", rendezvous_info_window_pos);");  
// }  
// try  
// {  
// config.SetValue("ICON_POS", main_icon_pos);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"ICON_POS\", main_icon_pos);");  
// }  
// try  
// {  
// config.SetValue("HUD_MODULE", toggleHUDModule);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"HUD_MODULE\", toggleHUDModule);");  
// }  
// try  
// {  
// config.SetValue("VOID_MODULE", void_module);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"VOID_MODULE\", void_module);");  
// }  
// try  
// {  
// config.SetValue("ATMO_MODULE", atmo_module);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"ATMO_MODULE\", atmo_module);");  
// }  
// try  
// {  
// config.SetValue("TAD_MODULE", tad_module);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"TAD_MODULE\", tad_module);");  
// }  
// try  
// {  
// config.SetValue("VESREG_MODULE", vessel_register_module);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"VESREG_MODULE\", vessel_register_module);");  
// }  
// try  
// {  
// config.SetValue("DATATIME_MODULE", data_time_module);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"DATATIME_MODULE\", data_time_module);");  
// }  
// try  
// {  
// config.SetValue("VESINFO_MODULE", vessel_info_module);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"VESINFO_MODULE\", vessel_info_module);");  
// }  
// try  
// {  
// config.SetValue("MISC_MODULE", misc_module);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"MISC_MODULE\", misc_module);");  
// }  
// try  
// {  
// config.SetValue("CELINFO_MODULE", celestial_body_info_module);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"CELINFO_MODULE\", celestial_body_info_module);");  
// }  
// try  
// {  
// config.SetValue("CELINFO_SHOW_OBTL", body_op_show_orbital);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"CELINFO_SHOW_OBTL\", body_op_show_orbital);");  
// }  
// try  
// {  
// config.SetValue("CELINFO_SHOW_PHYS", body_op_show_physical);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"CELINFO_SHOW_PHYS\", body_op_show_physical);");  
// }  
// try  
// {  
// config.SetValue("MAIN_GUI_MINIMIZED", main_gui_minimized);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"MAIN_GUI_MINIMIZED\", main_gui_minimized);");  
// }  
// try  
// {  
// config.SetValue("HIDE_ON_PAUSE", hide_on_pause);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"HIDE_ON_PAUSE\", hide_on_pause);");  
// }  
// try  
// {  
// config.SetValue("SKIN_INDEX", skin_index);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"SKIN_INDEX\", skin_index);");  
// }  
// try  
// {  
// config.SetValue("DISABLE_POWER_USAGE", disable_power_usage);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"DISABLE_POWER_USAGE\", disable_power_usage);");  
// }  
// try  
// {  
// config.SetValue("SHOW_TOOLTIPS", show_tooltips);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"SHOW_TOOLTIPS\", show_tooltips);");  
// }  
// try  
// {  
// config.SetValue("SHOW_RENDEZVOUS_INFO", rendezvous_module);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"SHOW_RENDEZVOUS_INFO\", rendezvous_module);");  
// }  
// try  
// {  
// config.SetValue("USE_KSP_TARGET", hide_vesreg_info);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"USE_KSP_TARGET\", hide_vesreg_info);");  
// }  
// try  
// {  
// config.SetValue("USER_LANG", user_lang);  
// }  
// catch (NullReferenceException)  
// {  
// UnityEngine.Debug.LogError("config.SetValue(\"USER_LANG\", user_lang);");  
// }  
// config.save ();  
// }  
// catch (NullReferenceException)  
// {  
// return;  
// }  
//  
// /*  
// string settings = "";  
// settings += "MAIN WINDOW POS = " + main_window_pos.x + " , " + main_window_pos.y + "\n";  
// settings += "VOID WINDOW POS = " + void_window_pos.x + " , " + void_window_pos.y + "\n";  
// settings += "ATMO WINDOW POS = " + atmo_window_pos.x + " , " + atmo_window_pos.y + "\n";  
// settings += "TAD WINDOW POS = " + transfer_window_pos.x + " , " + transfer_window_pos.y + "\n";  
// settings += "VESREG WINDOW POS = " + vessel_register_window_pos.x + " , " + vessel_register_window_pos.y + "\n";  
// settings += "DATATIME WINDOW POS = " + data_logging_window_pos.x + " , " + data_logging_window_pos.y + "\n";  
// settings += "VESINFO WINDOW POS = " + vessel_info_window_pos.x + " , " + vessel_info_window_pos.y + "\n";  
// settings += "MISC WINDOW POS = " + misc_window_pos.x + " , " + misc_window_pos.y + "\n";  
// settings += "CELINFO WINDOW POS = " + body_op_window_pos.x + " , " + body_op_window_pos.y + "\n";  
// settings += "RENDEZVOUS WINDOW POS = " + rendezvous_info_window_pos.x + " , " + rendezvous_info_window_pos.y + "\n";  
// settings += "ICON POS = " + main_icon_pos.x + " , " + main_icon_pos.y + "\n";  
// settings += "HUD MODULE = " + toggleHUDModule + "\n";  
// settings += "VOID MODULE = " + void_module + "\n";  
// settings += "ATMO MODULE = " + atmo_module + "\n";  
// settings += "TAD MODULE = " + tad_module + "\n";  
// settings += "VESREG MODULE = " + vessel_register_module + "\n";  
// settings += "DATATIME MODULE = " + data_time_module + "\n";  
// settings += "VESINFO MODULE = " + vessel_info_module + "\n";  
// settings += "MISC MODULE = " + misc_module + "\n";  
// settings += "CELINFO MODULE = " + celestial_body_info_module + "\n";  
// settings += "CELINFO SHOW OBTL = " + body_op_show_orbital + "\n";  
// settings += "CELINFO SHOW PHYS = " + body_op_show_physical + "\n";  
// settings += "MAIN GUI MINIMIZED = " + main_gui_minimized + "\n";  
// settings += "HIDE ON PAUSE = " + hide_on_pause + "\n";  
// settings += "HUD COLOR = " + moduleHUD.ColorIndex + "\n";  
// settings += "SKIN INDEX = " + skin_index + "\n";  
// settings += "DISABLE POWER USAGE = " + disable_power_usage + "\n";  
// settings += "SHOW TOOLTIPS = " + show_tooltips + "\n";  
// settings += "SHOW RENDEZVOUS INFO = " + rendezvous_module + "\n";  
// settings += "USE KSP TARGET = " + hide_vesreg_info + "\n";  
// settings += "USER LANG = " + user_lang + "\n";  
// KSP.IO.File.WriteAllText<VOID>(settings, "VOID.cfg", null);  
// */  
// }  
//  
// private void start_GUI()  
// {  
// RenderingManager.AddToPostDrawQueue(3, new Callback(draw_GUI)); //start the GUI  
// if (this.moduleHUD != null && !this.moduleHUD.guiRunning)  
// {  
// this.moduleHUD.StopGUI();  
// }  
// gui_running = true;  
// }  
//  
// private void stop_GUI()  
// {  
// RenderingManager.RemoveFromPostDrawQueue(3, new Callback(draw_GUI)); //stop the GUI  
// if (this.moduleHUD != null && this.moduleHUD.guiRunning)  
// {  
// this.moduleHUD.StopGUI();  
// }  
// gui_running = false;  
// }  
//  
// private void consume_resources()  
// {  
// if (TimeWarp.deltaTime == 0) return; //do nothing if paused  
// if (vessel.vesselType == VesselType.EVA || disable_power_usage) power_available = true; //power always available when EVA  
// else  
// {  
// float recvd_amount = vessel.rootPart.RequestResource("ElectricCharge", power_request_amount * TimeWarp.fixedDeltaTime);  
// if (recvd_amount > 0) power_available = true; // doesn't always send 100% of demand so as long as it sends something  
// else power_available = false;  
// }  
// }  
//  
// private void set_gui_styles()  
// {  
// //label_txt_left = new GUIStyle(GUI.skin.label);  
// //label_txt_left.normal.textColor = Color.white;  
// //label_txt_left.alignment = TextAnchor.UpperLeft;  
//  
// label_txt_center = new GUIStyle(GUI.skin.label);  
// label_txt_center.normal.textColor = Color.white;  
// label_txt_center.alignment = TextAnchor.UpperCenter;  
//  
// label_txt_center_bold = new GUIStyle(GUI.skin.label);  
// label_txt_center_bold.normal.textColor = Color.white;  
// label_txt_center_bold.alignment = TextAnchor.UpperCenter;  
// label_txt_center_bold.fontStyle = FontStyle.Bold;  
//  
// label_txt_right = new GUIStyle(GUI.skin.label);  
// label_txt_right.normal.textColor = Color.white;  
// label_txt_right.alignment = TextAnchor.UpperRight;  
//  
// gui_styles_set = true;  
// }  
//  
// private void body_OP_show_orbital_info(CelestialBody body)  
// {  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label((body.orbit.ApA / 1000).ToString("##,#") + "km", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label(Tools.ConvertInterval(body.orbit.timeToAp), label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label((body.orbit.PeA / 1000).ToString("##,#") + "km", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label(Tools.ConvertInterval(body.orbit.timeToPe), label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label((body.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label(body.orbit.eccentricity.ToString("F4") + "", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label(Tools.ConvertInterval(body.orbit.period), label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label(Tools.ConvertInterval(body.rotationPeriod), label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label((body.orbit.orbitalSpeed / 1000).ToString("F2") + "km/s", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// // Toadicus edit: convert mean anomaly into degrees.  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label((body.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label(body.orbit.trueAnomaly.ToString("F3") + "°", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// // Toadicus edit: convert eccentric anomaly into degrees.  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label((body.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label(body.orbit.inclination.ToString("F3") + "°", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label(body.orbit.LAN.ToString("F3") + "°", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label(body.orbit.argumentOfPeriapsis.ToString("F3") + "°", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (body.bodyName == "Sun") GUILayout.Label("N/A", label_txt_right, GUILayout.ExpandWidth(true));  
// else  
// {  
// string body_tidally_locked = "No";  
// if (body.tidallyLocked) body_tidally_locked = "Yes";  
// GUILayout.Label(body_tidally_locked, label_txt_right, GUILayout.ExpandWidth(true));  
// }  
// //GUILayout.EndHorizontal();  
// }  
//  
// private void body_OP_show_physical_info(CelestialBody body)  
// {  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label((body.Radius / 1000).ToString("##,#") + "km", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(((Math.Pow((body.Radius), 2) * 4 * Math.PI) / 1000).ToString("0.00e+00") + "km²", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// // divide by 1000 to convert m to km  
// GUILayout.Label((((4d / 3) * Math.PI * Math.Pow(body.Radius, 3)) / 1000).ToString("0.00e+00") + "km³", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.Label(((4 / 3) * Math.PI * Math.Pow((vessel.mainBody.Radius / 1000), 3)).ToString(), txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(body.Mass.ToString("0.00e+00") + "kg", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// double p = body.Mass / (Math.Pow(body.Radius, 3) * (4d / 3) * Math.PI);  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(p.ToString("##,#") + "kg/m³", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (name == "Sun") GUILayout.Label(body.sphereOfInfluence.ToString(), label_txt_right, GUILayout.ExpandWidth(true));  
// else GUILayout.Label((body.sphereOfInfluence / 1000).ToString("##,#") + "km", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(body.orbitingBodies.Count.ToString(), label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //show # artificial satellites  
// int num_art_sats = 0;  
// foreach (Vessel v in FlightGlobals.Vessels)  
// {  
// if (v.mainBody == body && v.situation.ToString() == "ORBITING") num_art_sats++;  
// }  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(num_art_sats.ToString(), label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// double g_ASL = (G_constant * body.Mass) / Math.Pow(body.Radius, 2);  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(Tools.MuMech_ToSI(g_ASL) + "m/s²", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("≈ " + Tools.MuMech_ToSI(body.maxAtmosphereAltitude) + "m", label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// string O2 = "No";  
// if (body.atmosphereContainsOxygen == true) O2 = "Yes";  
// GUILayout.Label(O2, label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// string ocean = "No";  
// if (body.ocean == true) ocean = "Yes";  
// GUILayout.Label(ocean, label_txt_right, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
// }  
//  
// private void tad_targeting(CelestialBody body)  
// {  
// //Target Set/Unset buttons  
// if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() == null))  
// {  
// //No TGT set or TGT is a Body  
// if ((CelestialBody)FlightGlobals.fetch.VesselTarget != body)  
// {  
// if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))  
// {  
// FlightGlobals.fetch.SetVesselTarget(body);  
// if (debugging) Debug.Log("[VOID] KSP Target set to CelestialBody " + body.bodyName);  
// }  
// }  
// else if ((CelestialBody)FlightGlobals.fetch.VesselTarget == body)  
// {  
// if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false)))  
// {  
// FlightGlobals.fetch.SetVesselTarget(null);  
// if (debugging) Debug.Log("[VOID] KSP Target set to null");  
// }  
// }  
// }  
// else if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != null))  
// {  
// //No TGT or TGT is a vessel  
// if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))  
// {  
// FlightGlobals.fetch.SetVesselTarget(body);  
// if (debugging) Debug.Log("[VOID] KSP Target set to CelestialBody " + body.bodyName);  
// }  
// }  
// }  
//  
// private void display_transfer_angles_SUN2PLANET(CelestialBody body)  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Phase angle (curr/trans):");  
// GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter).ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Transfer velocity:");  
// GUILayout.Label((Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)) * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// }  
//  
// private void display_transfer_angles_PLANET2PLANET(CelestialBody body)  
// {  
// double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000));  
// double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1));  
//  
// double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000));  
// double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent);  
//  
// double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360;  
// double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent);  
//  
// double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle);  
// double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle);  
// double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle);  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Phase angle (curr/trans):");  
// GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Ejection angle (curr/trans):");  
// GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Transfer velocity:");  
// GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// }  
//  
// private void display_transfer_angles_PLANET2MOON(CelestialBody body)  
// {  
// double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000));  
//// double curr_phase_angle = Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, vessel.orbit.LAN, vessel.orbit.orbitPercent);  
// double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter);  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Phase angle (curr/trans):");  
// GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Transfer velocity:");  
// GUILayout.Label((dv1 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// }  
//  
// private void display_transfer_angles_MOON2MOON(CelestialBody body)  
// {  
// double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000));  
// double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1));  
// double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000));  
//  
// double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent);  
// double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent);  
//  
// double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360;  
//  
// double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle);  
// //double adj_ejection_angle = adjustCurrEjectionAngle(trans_phase_angle, curr_ejection_angle);  
//  
// //new stuff  
// //  
// double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle);  
// double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle);  
// //  
// //  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Phase angle (curr/trans):");  
// GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Ejection angle (curr/trans):");  
// GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Transfer velocity:");  
// GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// }  
//  
// // GUI  
// // Toadicus edit: added colons for each label_string.  
// private void void_gui(int window_id)  
// {  
// // Toadicus edit: added local sidereal longitude.  
// double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle;  
// LSL = Tools.FixDegreeDomain (LSL);  
//  
// GUILayout.BeginVertical();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(label_strings.void_primary + ":");  
// GUILayout.Label(vessel.mainBody.bodyName, GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(label_strings.void_altitude_asl + ":");  
// GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.altitude) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(label_strings.void_velocity + ":");  
// GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(label_strings.void_apoapsis + ":");  
// GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.ApA) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Time to Ap:");  
// GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToAp), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(label_strings.void_periapsis + ":");  
// GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.PeA) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Time to Pe:");  
// GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToPe), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Inclination:");  
// GUILayout.Label(vessel.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass());  
// double g_vessel = (G_constant * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2);  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Gravity:");  
// GUILayout.Label(Tools.MuMech_ToSI(g_vessel) + "m/s²", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// extended_orbital_info = GUILayout.Toggle(extended_orbital_info, "Extended info");  
//  
// if (extended_orbital_info)  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Period:");  
// GUILayout.Label(Tools.ConvertInterval(vessel.orbit.period), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Semi-major axis:");  
// GUILayout.Label((vessel.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Eccentricity:");  
// GUILayout.Label(vessel.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// // Toadicus edit: convert mean anomaly into degrees.  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Mean anomaly:");  
// GUILayout.Label((vessel.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("True anomaly:");  
// GUILayout.Label(vessel.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// // Toadicus edit: convert eccentric anomaly into degrees.  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Eccentric anomaly:");  
// GUILayout.Label((vessel.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Long. ascending node:");  
// GUILayout.Label(vessel.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Arg. of periapsis:");  
// GUILayout.Label(vessel.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// // Toadicus edit: added local sidereal longitude.  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Local Sidereal Longitude:");  
// GUILayout.Label(LSL.ToString("F3") + "°", label_txt_right);  
// GUILayout.EndHorizontal();  
// }  
//  
// GUILayout.EndVertical();  
// GUI.DragWindow();  
// }  
//  
// private void atmo_gui(int window_id)  
// {  
// GUILayout.BeginVertical();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Altitude (true):");  
// double alt_true = vessel.orbit.altitude - vessel.terrainAltitude;  
// // HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m.  
// if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean ) alt_true = vessel.orbit.altitude;  
// GUILayout.Label(Tools.MuMech_ToSI(alt_true) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal ();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Latitude:");  
// GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Longitude:");  
// GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Heading:");  
// GUILayout.Label(Tools.MuMech_get_heading(vessel).ToString("F2") + "° " + Tools.get_heading_text(Tools.MuMech_get_heading(vessel)), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Terrain elevation:");  
// GUILayout.Label(Tools.MuMech_ToSI(vessel.terrainAltitude) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Surface velocity:");  
// GUILayout.Label(Tools.MuMech_ToSI(vessel.srf_velocity.magnitude) + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Vertical speed:");  
// GUILayout.Label(Tools.MuMech_ToSI(vessel.verticalSpeed) + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Horizontal speed:");  
// GUILayout.Label(Tools.MuMech_ToSI(vessel.horizontalSrfSpeed) + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Temperature:");  
// GUILayout.Label(vessel.flightIntegrator.getExternalTemperature().ToString("F2") + "° C", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Atmosphere density:");  
// GUILayout.Label(Tools.MuMech_ToSI(vessel.atmDensity * 1000) + "g/m³", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Pressure:");  
// GUILayout.Label(vessel.staticPressure.ToString("F2") + " atms", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Atmosphere limit:");  
// GUILayout.Label("≈ " + Tools.MuMech_ToSI(vessel.mainBody.maxAtmosphereAltitude) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// // Toadicus edit: added Biome  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Biome:");  
// GUILayout.Label(Tools.Toadicus_GetAtt(vessel).name, label_txt_right);  
// GUILayout.EndHorizontal();  
//  
// GUILayout.EndVertical();  
// GUI.DragWindow();  
// }  
//  
// private void tad_gui(int window_id)  
// {  
// GUILayout.BeginVertical();  
//  
// if (vessel.mainBody.name == "Sun") //Vessel is orbiting the Sun  
// {  
// foreach (CelestialBody body in vessel.mainBody.orbitingBodies)  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button(body.bodyName))  
// {  
// //add or remove this body to this list of bodies to display more info on  
// if (tad_selected_bodies.Contains(body)) tad_selected_bodies.Remove(body);  
// else tad_selected_bodies.Add(body);  
// }  
// GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// if (tad_selected_bodies.Contains(body))  
// {  
// display_transfer_angles_SUN2PLANET(body); //show phase angles for each selected body  
// tad_targeting(body); //display Set/Unset Target button for each selected body  
// }  
// }  
// }  
// else if (vessel.mainBody.referenceBody.name == "Sun") //Vessel is orbiting a planet  
// {  
// foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies)  
// {  
// if (body.name != vessel.mainBody.name) // show other planets  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button(body.bodyName))  
// {  
// //add or remove this body to this list of bodies to display more info on  
// if (tad_selected_bodies.Contains(body)) tad_selected_bodies.Remove(body);  
// else tad_selected_bodies.Add(body);  
// }  
// GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// if (tad_selected_bodies.Contains(body))  
// {  
// display_transfer_angles_PLANET2PLANET(body);  
// tad_targeting(body); //display Set/Unset Target button  
// }  
// }  
// }  
// foreach (CelestialBody body in vessel.mainBody.orbitingBodies) // show moons  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button(body.bodyName))  
// {  
// //add or remove this body to this list of bodies to display more info on  
// if (tad_selected_bodies.Contains(body)) tad_selected_bodies.Remove(body);  
// else tad_selected_bodies.Add(body);  
// }  
// GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// if (tad_selected_bodies.Contains(body))  
// {  
// display_transfer_angles_PLANET2MOON(body);  
// tad_targeting(body); //display Set/Unset Target button  
// }  
// }  
// }  
// else if (vessel.mainBody.referenceBody.referenceBody.name == "Sun") // Vessel is orbiting a moon  
// {  
// foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies)  
// {  
// if (body.name != vessel.mainBody.name) // show other moons  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button(body.bodyName))  
// {  
// //add or remove this body to this list of bodies to display more info on  
// if (tad_selected_bodies.Contains(body)) tad_selected_bodies.Remove(body);  
// else tad_selected_bodies.Add(body);  
// }  
// GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// if (tad_selected_bodies.Contains(body))  
// {  
// display_transfer_angles_MOON2MOON(body);  
// tad_targeting(body); //display Set/Unset Target button  
// }  
// }  
// }  
// }  
// GUILayout.EndVertical();  
// GUI.DragWindow();  
// }  
//  
// private void test_gui(int window_id)  
// {  
// GUILayout.BeginVertical();  
//  
// GUILayout.Label("FlightGlobals.fetch.vesselTargetMode = " + FlightGlobals.fetch.vesselTargetMode.ToString());  
// //if (debugging) Debug.Log("[VOID] vesselTargetMode OK");  
// if (FlightGlobals.fetch.VesselTarget != null)  
// {  
// GUILayout.Label("VesselTarget == " + FlightGlobals.fetch.VesselTarget.ToString());  
// //if (debugging) Debug.Log("[VOID] VesselTarget OK");  
// GUILayout.Label("vesselTargetTransform == " + FlightGlobals.fetch.vesselTargetTransform.ToString());  
// //if (debugging) Debug.Log("[VOID] vesselTargetTransform OK");  
// GUILayout.Label("vesselTargetDirection == " + FlightGlobals.fetch.vesselTargetDirection.ToString());  
// //if (debugging) Debug.Log("[VOID] vesselTargetDirection OK");  
// GUILayout.Label("vesselTargetDelta == " + FlightGlobals.fetch.vesselTargetDelta.ToString());  
// //if (debugging) Debug.Log("[VOID] vesselTargetDelta OK");  
// }  
// else GUILayout.Label("VesselTarget == null");  
//  
//  
// //check whats in here  
// //GUI.skin.font.fontNames  
// //foreach (String f in GUI.skin.font.fontNames)  
// //{  
// // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// // GUILayout.Label(f);  
// // GUILayout.EndHorizontal();  
// //}  
//  
//  
//  
//  
// //fail  
// //if (Event.current.keyCode == KeyCode.Z)  
// //{  
// // FlightCtrlState s = new FlightCtrlState();  
// // vessel.FeedInputFeed();  
// // s.mainThrottle = 1;  
// //}  
//  
//  
//  
// //MapView.MapIsEnabled = false;  
// //fail  
//  
//  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label(DateTime.Now.ToString("d MMMM"));  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("situation:", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(vessel.situation.ToString(), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("vessel.missionTime:", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(vessel.missionTime.ToString(), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
// //Orbit target_orbit = new Orbit();  
// //target_orbit = FlightGlobals.fetch.VesselTarget.GetOrbit();  
//  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("target_orbit.altitude", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(target_orbit.altitude.ToString("F2"), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("vessel.packed", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(vessel.packed.ToString(), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
//  
// //q = 1/2 p v^2  
// //p = local air density  
// //v = velocity  
// //part.dynamicPressureAtm  
// double q = .5 * vessel.atmDensity * Math.Pow(vessel.orbit.vel.magnitude, 2);  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("dynamic pressure q:", GUILayout.ExpandWidth(true));  
// GUILayout.Label(q.ToString("F4"), label_txt_right);  
// GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("part.dynamicPressureAtm:", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(part.dynamicPressureAtm.ToString("F3"), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("part.staticPressureAtm:", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(part.staticPressureAtm.ToString("F3"), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("vessel.staticPressure:", GUILayout.ExpandWidth(true));  
// GUILayout.Label(vessel.staticPressure.ToString("F3"), label_txt_right);  
// GUILayout.EndHorizontal();  
//  
//  
//  
//  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("FlightLogger.getMissionStats():", GUILayout.ExpandWidth(true));  
// GUILayout.Label(FlightLogger.getMissionStats(), label_txt_right);  
// GUILayout.EndHorizontal();  
//  
// //parse this out  
// //"Total Distance Traveled: 552m"  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
//  
// string temp = FlightLogger.getMissionStats();  
// temp = temp.Substring(temp.IndexOf("Total Distance Traveled:"));  
// //GUILayout.Label(temp, GUILayout.ExpandWidth(true));  
// //int colon_pos = temp.IndexOf(":");  
// temp = temp.Substring(temp.IndexOf(":") + 1);  
// //GUILayout.Label(temp, GUILayout.ExpandWidth(true));  
// int m_pos = temp.IndexOf("m");  
// temp = temp.Substring(0, m_pos + 1);  
// temp = temp.Trim();  
//  
// GUILayout.Label("Distance traveled:", GUILayout.ExpandWidth(true));  
// GUILayout.Label(temp, label_txt_right);  
//  
// GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("power_request_interval:", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(power_request_interval.ToString(), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("power_request_amount:", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(power_request_amount.ToString(), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("Tools.MuMech_get_heading():", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(Tools.MuMech_get_heading().ToString("F2"), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// //GUILayout.Label("num_fixedupdate_calls:", GUILayout.ExpandWidth(true));  
// //GUILayout.Label(num_fixedupdate_calls.ToString(), label_txt_right);  
// //GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("vessel.flightIntegrator.currentDragForce:", GUILayout.ExpandWidth(true));  
// GUILayout.Label(vessel.flightIntegrator.currentDragForce.ToString(), label_txt_right);  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("vessel.flightIntegrator.drag:", GUILayout.ExpandWidth(true));  
// GUILayout.Label(vessel.flightIntegrator.drag.ToString(), label_txt_right);  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("vessel.flightIntegrator.dragArea:", GUILayout.ExpandWidth(true));  
// GUILayout.Label(vessel.flightIntegrator.dragArea.ToString(), label_txt_right);  
// GUILayout.EndHorizontal();  
//  
// //  
//  
// GUILayout.EndVertical();  
// GUI.DragWindow();  
// }  
//  
// private void celestial_body_info_gui(int window_id)  
// {  
// //print("starting celestial_body_info_gui()...");  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
//  
// GUILayout.BeginVertical(GUILayout.Width(150));  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("", GUILayout.ExpandWidth(true));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.EndVertical();  
//  
// GUILayout.BeginVertical(GUILayout.Width(150));  
//  
// body_OP_selected_body_1 = all_bodies[body_OP_body_1_index];  
// body_OP_selected_body_2 = all_bodies[body_OP_body_2_index];  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button("<", GUILayout.ExpandWidth(false)))  
// {  
// body_OP_body_1_index--;  
// if (body_OP_body_1_index < 0) body_OP_body_1_index = all_bodies.Count - 1;  
// }  
// GUILayout.Label(all_bodies[body_OP_body_1_index].bodyName, label_txt_center_bold, GUILayout.ExpandWidth(true));  
// if (GUILayout.Button(">", GUILayout.ExpandWidth(false)))  
// {  
// body_OP_body_1_index++;  
// if (body_OP_body_1_index > all_bodies.Count - 1) body_OP_body_1_index = 0;  
// }  
// GUILayout.EndHorizontal();  
// GUILayout.EndVertical();  
//  
// GUILayout.BeginVertical(GUILayout.Width(150));  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button("<", GUILayout.ExpandWidth(false)))  
// {  
// body_OP_body_2_index--;  
// if (body_OP_body_2_index < 0) body_OP_body_2_index = all_bodies.Count - 1;  
// }  
// GUILayout.Label(all_bodies[body_OP_body_2_index].bodyName, label_txt_center_bold, GUILayout.ExpandWidth(true));  
// if (GUILayout.Button(">", GUILayout.ExpandWidth(false)))  
// {  
// body_OP_body_2_index++;  
// if (body_OP_body_2_index > all_bodies.Count - 1) body_OP_body_2_index = 0;  
// }  
// GUILayout.EndHorizontal();  
// GUILayout.EndVertical();  
//  
// GUILayout.EndHorizontal();  
//  
// //}  
//  
// //toggle for orbital info chunk  
// if (GUILayout.Button("Orbital Characteristics", GUILayout.ExpandWidth(true))) body_op_show_orbital = !body_op_show_orbital;  
//  
// if (body_op_show_orbital)  
// {  
// //begin orbital into horizontal chunk  
// //print("begin orbital info section...");  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
//  
// //begin orbital value labels column  
// GUILayout.BeginVertical(GUILayout.Width(150));  
//  
// //print("printing row labels...");  
//  
// GUILayout.Label("Apoapsis:");  
// GUILayout.Label("Time to Ap:");  
// GUILayout.Label("Periapsis:");  
// GUILayout.Label("Time to Pe:");  
// GUILayout.Label("Semi-major axis:");  
// GUILayout.Label("Eccentricity:");  
// GUILayout.Label("Orbital period:");  
// GUILayout.Label("Rotational period:");  
// GUILayout.Label("Velocity:");  
// GUILayout.Label("Mean anomaly:");  
// GUILayout.Label("True anomaly:");  
// GUILayout.Label("Eccentric anomaly:");  
// GUILayout.Label("Inclination:");  
// GUILayout.Label("Long. ascending node:");  
// GUILayout.Label("Arg. of periapsis:");  
// GUILayout.Label("Tidally locked:");  
//  
// //end orbital value labels column  
// GUILayout.EndVertical();  
//  
// //begin primary orbital values column  
// GUILayout.BeginVertical(GUILayout.Width(150));  
//  
// body_OP_show_orbital_info(body_OP_selected_body_1);  
//  
// //end primary orbital values column  
// GUILayout.EndVertical();  
//  
// //begin secondary orbital values column  
// GUILayout.BeginVertical(GUILayout.Width(150));  
//  
// body_OP_show_orbital_info(body_OP_selected_body_2);  
//  
// //end secondary orbital values column  
// GUILayout.EndVertical();  
//  
// //end orbital info horizontal chunk  
// GUILayout.EndHorizontal();  
// }  
//  
// //toggle for physical info chunk  
// if (GUILayout.Button("Physical Characteristics", GUILayout.ExpandWidth(true))) body_op_show_physical = !body_op_show_physical;  
//  
// if (body_op_show_physical)  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
//  
// //begin physical info value label column  
// GUILayout.BeginVertical(GUILayout.Width(150));  
//  
// GUILayout.Label("Radius:");  
// GUILayout.Label("Surface area:");  
// GUILayout.Label("Volume:");  
// GUILayout.Label("Mass:");  
// GUILayout.Label("Density:");  
// GUILayout.Label("Sphere of influence:");  
// GUILayout.Label("Natural satellites:");  
// GUILayout.Label("Artificial satellites:");  
// GUILayout.Label("Surface gravity:");  
// GUILayout.Label("Atmosphere altitude:");  
// GUILayout.Label("Atmospheric O\u2082:");  
// GUILayout.Label("Has ocean:");  
//  
// //end physical info value label column  
// GUILayout.EndVertical();  
//  
// //begin primary physical values column  
// GUILayout.BeginVertical(GUILayout.Width(150));  
//  
// body_OP_show_physical_info(body_OP_selected_body_1);  
//  
// //end primary physical column  
// GUILayout.EndVertical();  
//  
// //begin secondary physical values column  
// GUILayout.BeginVertical(GUILayout.Width(150));  
//  
// body_OP_show_physical_info(body_OP_selected_body_2);  
//  
// //end target physical values column  
// GUILayout.EndVertical();  
//  
// //end physical value horizontal chunk  
// GUILayout.EndHorizontal();  
// }  
//  
// GUI.DragWindow();  
// }  
//  
// private void rendezvous_info_gui(int window_id)  
// {  
// Vessel rendezvessel = new Vessel();  
// CelestialBody rendezbody = new CelestialBody();  
//  
// GUILayout.BeginVertical();  
//  
// //display both  
// //Show Target Info  
// GUILayout.Label("Target:", label_txt_center_bold);  
// if (FlightGlobals.fetch.VesselTarget != null)  
// {  
// //a KSP Target (body or vessel) is selected  
// if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.Direction)  
// {  
// //a Body is selected  
// rendezbody = vessel.patchedConicSolver.targetBody;  
// display_rendezvous_info(null, rendezbody);  
// }  
// else if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.DirectionAndVelocity)  
// {  
// //a Vessel is selected  
// rendezvessel = FlightGlobals.fetch.VesselTarget.GetVessel();  
// display_rendezvous_info(rendezvessel, null);  
// }  
// //Show Unset button for both options above  
// if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false)))  
// {  
// FlightGlobals.fetch.SetVesselTarget(null);  
// if (debugging) Debug.Log("[VOID] KSP Target set to null");  
// }  
//  
// }  
// else  
// {  
// //no KSP Target selected  
// GUILayout.Label("No Target Selected", label_txt_center_bold);  
// }  
//  
// //Show Vessel Register vessel info  
// if (hide_vesreg_info == false)  
// {  
// GUILayout.Label("Vessel Register:", label_txt_center_bold);  
// if (vesreg_selected_vessel != null)  
// {  
// rendezvessel = vesreg_selected_vessel;  
// display_rendezvous_info(rendezvessel, null);  
//  
// //show set/unset buttons  
// if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != vesreg_selected_vessel))  
// {  
// //no Tgt set or Tgt is not this vessel  
// //show a Set button  
// if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))  
// {  
// FlightGlobals.fetch.SetVesselTarget(rendezvessel);  
// if (debugging) Debug.Log("[VOID] KSP Target set to " + rendezvessel.vesselName);  
// }  
// }  
// else if (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() == vesreg_selected_vessel)  
// {  
// //this VRegister Tgt is also set as KSP tgt  
// //show Unset button  
// //if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false)))  
// //{  
// // FlightGlobals.fetch.SetVesselTarget(null);  
// // if (debugging) Debug.Log("[VOID] KSP Target set to null");  
// // }  
// }  
// }  
// else  
// {  
// //vesreg Vessel is null  
// //targ = null;  
// GUILayout.Label("No Vessel Selected", label_txt_center_bold);  
// }  
// }  
//  
// hide_vesreg_info = GUILayout.Toggle(hide_vesreg_info, "Hide Vessel Register Info");  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(" ", GUILayout.ExpandWidth(true));  
// if (GUILayout.Button("Close", GUILayout.ExpandWidth(false))) rendezvous_module = false;  
// GUILayout.EndHorizontal();  
//  
// GUILayout.EndVertical();  
// GUI.DragWindow();  
// }  
//  
// private void display_rendezvous_info(Vessel v, CelestialBody cb)  
// {  
// if (cb == null && v != null)  
// {  
// //Display vessel rendezvous info  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(v.vesselName, label_txt_center_bold, GUILayout.ExpandWidth(true));  
// GUILayout.EndHorizontal();  
//  
// if (v.situation == Vessel.Situations.ESCAPING || v.situation == Vessel.Situations.FLYING || v.situation == Vessel.Situations.ORBITING || v.situation == Vessel.Situations.SUB_ORBITAL)  
// {  
// // Toadicus edit: added local sidereal longitude.  
// // Toadicus edit: added local sidereal longitude.  
// double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle;  
// LSL = Tools.FixDegreeDomain (LSL);  
//  
// //display orbital info for orbiting/flying/suborbital/escaping vessels only  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Ap/Pe:");  
// GUILayout.Label(Tools.MuMech_ToSI(v.orbit.ApA) + "m / " + Tools.MuMech_ToSI(v.orbit.PeA) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Altitude:");  
// GUILayout.Label(Tools.MuMech_ToSI(v.orbit.altitude) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Inclination:");  
// GUILayout.Label(v.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// if (vessel.mainBody == v.mainBody)  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Relative inclination:");  
// GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), v.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// }  
// //if (debugging) Debug.Log("[CHATR] v -> v relative incl OK");  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Velocity:");  
// GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Relative velocity:");  
// GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude - vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Distance:");  
// GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// //target_vessel_extended_orbital_info = GUILayout.Toggle(target_vessel_extended_orbital_info, "Extended info");  
//  
// if (target_vessel_extended_orbital_info)  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Period:");  
// GUILayout.Label(Tools.ConvertInterval(v.orbit.period), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Semi-major axis:");  
// GUILayout.Label((v.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Eccentricity:");  
// GUILayout.Label(v.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// // Toadicus edit: convert mean anomaly into degrees.  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Mean anomaly:");  
// GUILayout.Label((v.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("True anomaly:");  
// GUILayout.Label(v.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// // Toadicus edit: convert eccentric anomaly into degrees.  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Eccentric anomaly:");  
// GUILayout.Label((v.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Long. ascending node:");  
// GUILayout.Label(v.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Arg. of periapsis:");  
// GUILayout.Label(v.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// // Toadicus edit: added local sidereal longitude.  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Local Sidereal Longitude:");  
// GUILayout.Label(LSL.ToString("F3") + "°", label_txt_right);  
// GUILayout.EndHorizontal();  
// }  
// }  
// else  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Latitude:");  
// GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Longitude:");  
// GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Distance:");  
// GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// }  
// }  
// else if (cb != null && v == null)  
// {  
// //Display CelstialBody rendezvous info  
// GUILayout.Label(cb.bodyName, label_txt_center_bold);  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Ap/Pe:");  
// GUILayout.Label(Tools.MuMech_ToSI(cb.orbit.ApA) + "m / " + Tools.MuMech_ToSI(cb.orbit.PeA) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// //if (debugging) Debug.Log("[VOID] Ap/Pe OK");  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Inclination:");  
// GUILayout.Label(cb.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// //if (debugging) Debug.Log("[VOID] Inclination OK");  
//  
// if (cb.referenceBody == vessel.mainBody)  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Relative inclination:");  
// GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), cb.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// //if (debugging) Debug.Log("[VOID] cb Relative inclination OK");  
// }  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Distance:");  
// GUILayout.Label(Tools.MuMech_ToSI((vessel.mainBody.position - cb.position).magnitude) + "m", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// //if (debugging) Debug.Log("[VOID] Distance OK");  
//  
// //SUN2PLANET:  
// if (vessel.mainBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)  
// {  
// display_transfer_angles_SUN2PLANET(cb);  
// //if (debugging) Debug.Log("[VOID] SUN2PLANET OK");  
// }  
//  
// //PLANET2PLANET  
// else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)  
// {  
// display_transfer_angles_PLANET2PLANET(cb);  
// //if (debugging) Debug.Log("[VOID] PLANET2PLANET OK");  
// }  
//  
// //PLANET2MOON  
// else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)  
// {  
// display_transfer_angles_PLANET2MOON(cb);  
// //if (debugging) Debug.Log("[VOID] PLANET2MOON OK");  
// }  
//  
// //MOON2MOON  
// else if (vessel.mainBody.referenceBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)  
// {  
// display_transfer_angles_MOON2MOON(cb);  
// //if (debugging) Debug.Log("[VOID] MOON2MOON OK");  
// }  
//  
// //else GUILayout.Label("Transfer angle information\nunavailable for this target");  
//  
// }  
// }  
//  
// private void data_time_gui(int window_id)  
// {  
// GUIStyle txt_white = new GUIStyle(GUI.skin.label);  
// txt_white.normal.textColor = txt_white.focused.textColor = Color.white;  
// GUIStyle txt_green = new GUIStyle(GUI.skin.label);  
// txt_green.normal.textColor = txt_green.focused.textColor = Color.green;  
// GUIStyle txt_yellow = new GUIStyle(GUI.skin.label);  
// txt_yellow.normal.textColor = txt_yellow.focused.textColor = Color.yellow;  
//  
// GUILayout.BeginVertical();  
//  
// GUILayout.Label("System time: " + DateTime.Now.ToString("HH:mm:ss"));  
// GUILayout.Label(Tools.ConvertInterval(stopwatch1));  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button("Start"))  
// {  
// if (stopwatch1_running == false) stopwatch1_running = true;  
// }  
// if (GUILayout.Button("Stop"))  
// {  
// if (stopwatch1_running == true) stopwatch1_running = false;  
// }  
// if (GUILayout.Button("Reset"))  
// {  
// if (stopwatch1_running == true) stopwatch1_running = false;  
// stopwatch1 = 0;  
// }  
// GUILayout.EndHorizontal();  
//  
// GUIStyle label_style = txt_white;  
// string log_label = "Inactive";  
// if (csv_logging && vessel.situation.ToString() == "PRELAUNCH")  
// {  
// log_label = "Awaiting launch";  
// label_style = txt_yellow;  
// }  
// if (csv_logging && vessel.situation.ToString() != "PRELAUNCH")  
// {  
// log_label = "Active";  
// label_style = txt_green;  
// }  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// csv_logging = GUILayout.Toggle(csv_logging, "Data logging: ", GUILayout.ExpandWidth(false));  
// GUILayout.Label(log_label, label_style, GUILayout.ExpandWidth(true));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Interval: ", GUILayout.ExpandWidth(false));  
// csv_log_interval_str = GUILayout.TextField(csv_log_interval_str, GUILayout.ExpandWidth(true));  
// GUILayout.Label("s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// float new_log_interval;  
// if (Single.TryParse(csv_log_interval_str, out new_log_interval)) csv_log_interval = new_log_interval;  
//  
// GUILayout.EndVertical();  
// GUI.DragWindow();  
// }  
//  
// private void vessel_info_gui(int window_id)  
// {  
// GUILayout.BeginVertical();  
//  
// GUILayout.Label(vessel.vesselName, label_txt_center_bold, GUILayout.ExpandWidth(true));  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("G-force:");  
// GUILayout.Label(vessel.geeForce.ToString("F2") + " gees", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// int num_parts = 0;  
// double total_mass = vessel.GetTotalMass();  
// double resource_mass = 0;  
// double max_thrust = 0;  
// double final_thrust = 0;  
//  
// foreach (Part p in vessel.parts)  
// {  
// num_parts++;  
// resource_mass += p.GetResourceMass();  
//  
// foreach (PartModule pm in p.Modules)  
// {  
// if ((pm.moduleName == "ModuleEngines") && ((p.State == PartStates.ACTIVE) || ((Staging.CurrentStage > Staging.lastStage) && (p.inverseStage == Staging.lastStage))))  
// {  
// max_thrust += ((ModuleEngines)pm).maxThrust;  
// final_thrust += ((ModuleEngines)pm).finalThrust;  
// }  
// }  
// }  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Parts:");  
// GUILayout.Label(num_parts.ToString("F0"), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Total mass:");  
// GUILayout.Label(total_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Resource mass:");  
// GUILayout.Label(resource_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// if (stages.Length > Staging.lastStage)  
// {  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("DeltaV (Current Stage):");  
// GUILayout.Label(Tools.MuMech_ToSI(stages[Staging.lastStage].deltaV).ToString() + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// }  
//  
// if (stages.Length > 0)  
// {  
// double totalDeltaV = 0d;  
//  
// for (int i = 0; i < stages.Length; ++i)  
// {  
// totalDeltaV += stages [i].deltaV;  
// }  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("DeltaV (Total):");  
// GUILayout.Label(Tools.MuMech_ToSI(totalDeltaV).ToString() + "m/s", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
// }  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Throttle:");  
// GUILayout.Label((vessel.ctrlState.mainThrottle * 100f).ToString("F0") + "%", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Thrust (curr/max):");  
// GUILayout.Label(final_thrust.ToString("F1") + " / " + max_thrust.ToString("F1") + " kN", GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// double gravity = vessel.mainBody.gravParameter / Math.Pow(vessel.mainBody.Radius + vessel.altitude, 2);  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("T:W (curr/max):");  
// GUILayout.Label((final_thrust / (total_mass * gravity)).ToString("F2") + " / " + (max_thrust / (total_mass * gravity)).ToString("F2"), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// double g_ASL = (G_constant * vessel.mainBody.Mass) / Math.Pow(vessel.mainBody.Radius, 2);  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label("Max T:W @ surface:");  
// GUILayout.Label((max_thrust / (total_mass * g_ASL)).ToString("F2"), GUILayout.ExpandWidth(false));  
// GUILayout.EndHorizontal();  
//  
// GUILayout.EndVertical();  
// GUI.DragWindow();  
// }  
//  
// private void misc_info_gui(int window_id)  
// {  
// GUIContent _content = new GUIContent();  
// GUILayout.BeginVertical();  
//  
// //show_tooltips = GUILayout.Toggle(show_tooltips, "Show tooltips", GUILayout.ExpandWidth(true));  
// disable_power_usage = GUILayout.Toggle(disable_power_usage, "Disable power usage");  
// hide_on_pause = GUILayout.Toggle(hide_on_pause, "Hide windows on pause");  
// data_time_module = GUILayout.Toggle(data_time_module, "Data Logging & Time");  
//  
// //Language  
// languages[] languages_array = Enum.GetValues(typeof(languages)) as languages[];  
// List<languages> languages_list = new List<languages>();  
//  
// foreach (var val in languages_array)  
// {  
// languages_list.Add(val);  
// }  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
//  
// if (GUILayout.Button("◄"))  
// {  
// //need separate preset indices for chatter and each beep  
// user_lang_index--;  
// if (user_lang_index < 0) user_lang_index = languages_list.Count - 1;  
// if (debugging) Debug.Log("[VOID] user_lang_index = " + user_lang_index);  
// //user_lang = languages_list[user_lang_index];  
// //load_language();  
// }  
//  
// if (GUILayout.Button("[WIP]" + languages_list[user_lang_index].ToString()))  
// {  
// user_lang = languages_list[user_lang_index];  
// load_language();  
// }  
//  
// if (GUILayout.Button("►"))  
// {  
// user_lang_index++;  
// if (user_lang_index >= languages_list.Count) user_lang_index = 0;  
// if (debugging) Debug.Log("[VOID] user_lang_index = " + user_lang_index);  
// //user_lang = languages_list[user_lang_index];  
// //load_language();  
// }  
//  
// GUILayout.EndHorizontal();  
//  
// //Skin picker  
// GUISkin[] skin_array = AssetBase.FindObjectsOfTypeIncludingAssets(typeof(GUISkin)) as GUISkin[];  
// List<GUISkin> skin_list = new List<GUISkin>();  
//  
// foreach (GUISkin _skin in skin_array)  
// {  
// if (_skin.name != "PlaqueDialogSkin" && _skin.name != "FlagBrowserSkin" && _skin.name != "SSUITextAreaDefault") skin_list.Add(_skin);  
// }  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
//  
// GUILayout.Label("Skin:", GUILayout.ExpandWidth(false));  
//  
// _content.text = "◄";  
// _content.tooltip = "Select previous skin";  
// if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))  
// {  
// skin_index--;  
// if (skin_index < 0) skin_index = skin_list.Count;  
// if (debugging) Debug.Log("[VOID] new skin_index = " + skin_index + " :: skin_list.Count = " + skin_list.Count);  
// }  
//  
// string skin_name = "";  
// if (skin_index == 0) skin_name = "None";  
// else skin_name = skin_list[skin_index - 1].name;  
// _content.text = skin_name;  
// _content.tooltip = "Current skin";  
// GUILayout.Label(_content, label_txt_center, GUILayout.ExpandWidth(true));  
//  
// _content.text = "►";  
// _content.tooltip = "Select next skin";  
// if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))  
// {  
// skin_index++;  
// if (skin_index > skin_list.Count) skin_index = 0;  
// if (debugging) Debug.Log("[VOID] new skin_index = " + skin_index + " :: skin_list.Count = " + skin_list.Count);  
// }  
//  
// GUILayout.EndHorizontal();  
//  
// //Change icon position  
// if (changing_icon_pos == false)  
// {  
// _content.text = "Change icon position";  
// _content.tooltip = "Move icon anywhere on the screen";  
// if (GUILayout.Button(_content, GUILayout.ExpandWidth(false))) changing_icon_pos = true;  
// }  
// else GUILayout.Label("Click anywhere to set new icon position");  
//  
// //HUD color  
// if (GUILayout.Button("Change HUD color", GUILayout.ExpandWidth(false)) && this.moduleHUD != null)  
// {  
// Tools.PostDebugMessage ("VOID: Incrementing VOID_HUD ColorIndex.");  
// this.moduleHUD.ColorIndex++;  
//  
// }  
//  
// //if (show_tooltips && GUI.tooltip != "") tooltips(misc_window_pos);  
//  
// GUILayout.EndVertical();  
// GUI.DragWindow();  
// }  
//  
// private void vessel_register_gui(int window_id)  
// {  
// GUILayout.BeginVertical();  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button("<"))  
// {  
// vessel_register_body_index--;  
// if (vessel_register_body_index < 0) vessel_register_body_index = all_bodies.Count - 1;  
// }  
// GUILayout.Label(all_bodies[vessel_register_body_index].bodyName, label_txt_center_bold, GUILayout.ExpandWidth(true));  
// if (GUILayout.Button(">"))  
// {  
// vessel_register_body_index++;  
// if (vessel_register_body_index > all_bodies.Count - 1) vessel_register_body_index = 0;  
// }  
// GUILayout.EndHorizontal();  
//  
// vessel_register_selected_body = all_bodies[vessel_register_body_index];  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button("<"))  
// {  
// vessel_register_vessel_type_index--;  
// if (vessel_register_vessel_type_index < 0) vessel_register_vessel_type_index = all_vessel_types.Count - 1;  
// }  
// GUILayout.Label(all_vessel_types[vessel_register_vessel_type_index].ToString(), label_txt_center_bold, GUILayout.ExpandWidth(true));  
// if (GUILayout.Button(">"))  
// {  
// vessel_register_vessel_type_index++;  
// if (vessel_register_vessel_type_index > all_vessel_types.Count - 1) vessel_register_vessel_type_index = 0;  
// }  
// GUILayout.EndHorizontal();  
//  
// vessel_register_vessel_type = all_vessel_types[vessel_register_vessel_type_index];  
//  
// GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// if (GUILayout.Button("Landed", GUILayout.ExpandWidth(true))) vessel_register_vessel_situation = "Landed";  
// if (GUILayout.Button("Orbiting", GUILayout.ExpandWidth(true))) vessel_register_vessel_situation = "Orbiting";  
// GUILayout.EndHorizontal();  
//  
// //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));  
// GUILayout.Label(Tools.UppercaseFirst(vessel_register_vessel_situation) + " " + vessel_register_vessel_type.ToString() + "s @ " + vessel_register_selected_body.bodyName, label_txt_center, GUILayout.ExpandWidth(true));  
// //GUILayout.EndHorizontal();  
//  
// GUILayout.EndVertical();  
//  
// vessel_register_scroll_pos = GUILayout.BeginScrollView(vessel_register_scroll_pos, false, false);  
//  
// foreach (Vessel v in FlightGlobals.Vessels)  
// {  
// if (v != vessel && v.vesselType == vessel_register_vessel_type && v.mainBody == vessel_register_selected_body)  
// {  
// if ((vessel_register_vessel_situation == "Landed" && (v.situation == Vessel.Situations.LANDED || v.situation == Vessel.Situations.PRELAUNCH || v.situation == Vessel.Situations.SPLASHED)) || (vessel_register_vessel_situation == "Orbiting" && (v.situation == Vessel.Situations.ESCAPING || v.situation == Vessel.Situations.FLYING || v.situation == Vessel.Situations.ORBITING || v.situation == Vessel.Situations.SUB_ORBITAL)))  
// {  
// if (GUILayout.Button(v.vesselName, GUILayout.ExpandWidth(true)))  
// {  
// if (vesreg_selected_vessel != v)  
// {  
// vesreg_selected_vessel = v; //set clicked vessel as selected_vessel  
// rendezvous_module = true; //turn bool on to open the window if closed  
// }  
// else  
// {  
// vesreg_selected_vessel = null;  
// }  
// }  
// }  
// }  
// }  
//  
// GUILayout.EndScrollView();  
// GUI.DragWindow();  
// }  
//  
// //private void tooltips(Rect pos)  
// //{  
// // if (show_tooltips && GUI.tooltip != "")  
// // {  
// // float w = 5.5f * GUI.tooltip.Length;  
// // float x = (Event.current.mousePosition.x < pos.width / 2) ? Event.current.mousePosition.x + 10 : Event.current.mousePosition.x - 10 - w;  
// // GUI.Box(new Rect(x, Event.current.mousePosition.y, w, 25f), GUI.tooltip, gs_tooltip);  
// // }  
// //}  
//  
// private void main_gui(int window_id)  
// {  
// GUILayout.BeginVertical();  
//  
// if (power_available)  
// {  
// if (power_toggle)  
// {  
// //Show menu toggles only when power is turned on and available  
// vessel_info_module = GUILayout.Toggle(vessel_info_module, "Vessel Infomation");  
// void_module = GUILayout.Toggle(void_module, "Orbital Information");  
// atmo_module = GUILayout.Toggle(atmo_module, "Surface & Atmospheric Information");  
// tad_module = GUILayout.Toggle(tad_module, "Transfer Angle Information");  
// rendezvous_module = GUILayout.Toggle(rendezvous_module, "Rendezvous Information");  
// celestial_body_info_module = GUILayout.Toggle(celestial_body_info_module, "Celestial Body Information");  
// vessel_register_module = GUILayout.Toggle(vessel_register_module, "Vessel Register");  
// misc_module = GUILayout.Toggle(misc_module, "Miscellaneous");  
// toggleHUDModule = GUILayout.Toggle(toggleHUDModule, "Show HUD");  
// //test_module = GUILayout.Toggle(test_module, "The Lab");  
// }  
//  
// string str = "ON";  
// if (power_toggle) str = "OFF";  
// if (GUILayout.Button("Power " + str)) power_toggle = !power_toggle;  
// }  
// else  
// {  
// GUIStyle label_txt_red = new GUIStyle(GUI.skin.label);  
// label_txt_red.normal.textColor = Color.red;  
// label_txt_red.alignment = TextAnchor.MiddleCenter;  
// GUILayout.Label("-- POWER LOST --", label_txt_red);  
// }  
//  
// GUILayout.EndVertical();  
// GUI.DragWindow();  
// }  
//  
// protected void draw_GUI()  
// {  
// if (hide_on_pause == false || (hide_on_pause && PauseMenu.isOpen == false))  
// {  
// //Apply a skin if selected  
// if (skin_index == 0) GUI.skin = null;  
// else if (skin_index == 1) GUI.skin = AssetBase.GetGUISkin("KSP window 1");  
// else if (skin_index == 2) GUI.skin = AssetBase.GetGUISkin("KSP window 2");  
// else if (skin_index == 3) GUI.skin = AssetBase.GetGUISkin("KSP window 3");  
// else if (skin_index == 4) GUI.skin = AssetBase.GetGUISkin("KSP window 4");  
// else if (skin_index == 5) GUI.skin = AssetBase.GetGUISkin("KSP window 5");  
// else if (skin_index == 6) GUI.skin = AssetBase.GetGUISkin("KSP window 6");  
// else if (skin_index == 7) GUI.skin = AssetBase.GetGUISkin("KSP window 7");  
// else if (skin_index == 8) GUI.skin = AssetBase.GetGUISkin("OrbitMapSkin");  
//  
// if (gui_styles_set == false) set_gui_styles(); //set GUI styles once AFTER setting skin  
//  
// void_icon = void_icon_off; //icon off default  
// if (power_toggle) void_icon = void_icon_on; //or on if power_toggle==true  
// if (GUI.Button(new Rect(main_icon_pos), void_icon, new GUIStyle())) main_gui_minimized = !main_gui_minimized;  
//  
// int window_id = window_base_id;  
//  
// if (main_gui_minimized == false) main_window_pos = GUILayout.Window(window_id, main_window_pos, main_gui, version_name + this_version, GUILayout.Width(250), GUILayout.Height(50));  
// if (power_toggle && power_available)  
// {  
// //hide these windows if power is turned off or unavailable  
// if (void_module) void_window_pos = GUILayout.Window(++window_id, void_window_pos, void_gui, "Orbital Information", GUILayout.Width(250), GUILayout.Height(50));  
// if (atmo_module) atmo_window_pos = GUILayout.Window(++window_id, atmo_window_pos, atmo_gui, "Surface & Atmospheric Information", GUILayout.Width(250), GUILayout.Height(50));  
// if (tad_module) transfer_window_pos = GUILayout.Window(++window_id, transfer_window_pos, tad_gui, "Transfer Angle Information", GUILayout.Width(315), GUILayout.Height(50));  
// if (vessel_register_module) vessel_register_window_pos = GUILayout.Window(++window_id, vessel_register_window_pos, vessel_register_gui, "Vessel Register", GUILayout.Width(250), GUILayout.Height(375));  
// if (data_time_module) data_logging_window_pos = GUILayout.Window(++window_id, data_logging_window_pos, data_time_gui, "Data Logging & Time", GUILayout.Width(250), GUILayout.Height(50));  
// if (vessel_info_module)  
// {  
// if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))  
// {  
// SimManager.Instance.RequestSimulation();  
// }  
//  
// vessel_info_window_pos = GUILayout.Window(++window_id, vessel_info_window_pos, vessel_info_gui, "Vessel Information", GUILayout.Width(250), GUILayout.Height(50));  
// }  
// if (misc_module) misc_window_pos = GUILayout.Window(++window_id, misc_window_pos, misc_info_gui, "Miscellaneous", GUILayout.Width(275), GUILayout.Height(50));  
// if (test_module) lab_window_pos = GUILayout.Window(++window_id, lab_window_pos, test_gui, "The Lab", GUILayout.Width(350), GUILayout.Height(50));  
// if (rendezvous_module) rendezvous_info_window_pos = GUILayout.Window(++window_id, rendezvous_info_window_pos, rendezvous_info_gui, "Rendezvous Information", GUILayout.Width(315), GUILayout.Height(50));  
// if (celestial_body_info_module) body_op_window_pos = GUILayout.Window(++window_id, body_op_window_pos, celestial_body_info_gui, "Celestial Body Information", GUILayout.Width(420), GUILayout.Height(50));  
// }  
// }  
// }  
//  
// public void Awake()  
// {  
// settings_path = AssemblyLoader.loadedAssemblies.GetPathByType(typeof(VOIDFlightMaster)) + "/"; //returns "X:/full/path/to/GameData/RBR/Plugins/PluginData/VOID"  
// load_icons();  
// load_language();  
// load_settings();  
// }  
//  
// private UInt64 updateCounter = 0;  
// public void Update()  
// {  
// ++updateCounter;  
// Tools.PostDebugMessage (string.Format ("VOID: Update #{0}", updateCounter));  
// // Module Startups  
// if (this.toggleHUDModule && this.moduleHUD == null)  
// {  
// Tools.PostDebugMessage ("VOID: Getting VOID_HUD instance.");  
// this.moduleHUD = (VOID_HUD)VOID_HUD.Instance;  
// Tools.PostDebugMessage ("VOID: Loading VOID_HUD config.");  
// this.moduleHUD.LoadConfig ();  
// Tools.PostDebugMessage ("VOID: VOID_HUD All loaded.");  
// this.moduleHUD.StartGUI ();  
// }  
//  
// Tools.PostDebugMessage (string.Format("VOID: this.moduleHUD.ColorIndex = '{0}'.", this.moduleHUD.ColorIndex));  
//  
// //Icon relocation  
// if (changing_icon_pos && Input.GetMouseButtonDown(0))  
// {  
// main_icon_pos = new Rect(Input.mousePosition.x - 15f, Screen.height - Input.mousePosition.y - 15f, 30f, 30f);  
// changing_icon_pos = false;  
// }  
//  
// if (FlightGlobals.ActiveVessel != null)  
// {  
// vessel = FlightGlobals.ActiveVessel;  
//  
// if (run_once)  
// {  
// if (debugging) Debug.Log("[VOID] running run_once...");  
// all_bodies.AddRange(FlightGlobals.Bodies);  
// vessel_register_body_index = all_bodies.IndexOf(vessel.mainBody);  
//  
// Array va = System.Enum.GetValues(typeof(VesselType));  
// all_vessel_types = va.OfType<VesselType>().ToList();  
// vessel_register_vessel_type_index = all_vessel_types.IndexOf(vessel.vesselType);  
//  
// run_once = false;  
// }  
//  
// if (vessel == FlightGlobals.ActiveVessel)  
// {  
//  
// if (SimManager.Instance.Stages != null)  
// {  
// stages = SimManager.Instance.Stages;  
// }  
//  
// SimManager.Instance.Gravity = vessel.mainBody.gravParameter / Math.Pow(vessel.mainBody.Radius, 2);  
// SimManager.Instance.TryStartSimulation();  
// }  
//  
// if (gui_running == false) start_GUI();  
//  
// cfg_update_timer += 1;  
// if (cfg_update_timer >= 15f)  
// {  
// write_settings();  
// cfg_update_timer = 0f;  
// }  
//  
// if (power_available)  
// {  
// main_csv(); // a function to group together all the Data Logging/csv functions  
// if (stopwatch1_running) stopwatch1 += Time.deltaTime;  
// }  
// }  
// else  
// {  
// //activevessel == null  
// if (gui_running)  
// {  
// Tools.PostDebugMessage ("VOID: Stopping GUI because our vessel isn't the active vessel.");  
// stop_GUI();  
// }  
// }  
// }  
//  
// public void FixedUpdate()  
// {  
// if (power_toggle) consume_resources();  
// }  
} }
} }
   
  //
  // VOID_Orbital.cs
  //
  // Author:
  // toadicus <>
  //
  // Copyright (c) 2013 toadicus
  //
  // This program is free software: you can redistribute it and/or modify
  // it under the terms of the GNU General Public License as published by
  // 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,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program. If not, see <http://www.gnu.org/licenses/>.
  using KSP;
  using System;
  using System.Collections.Generic;
  using UnityEngine;
 
  namespace VOID
  {
  public class VOID_CBInfoBrowser : VOID_WindowModule
  {
  [AVOID_SaveValue("selectedBodyIdx1")]
  protected VOID_SaveValue<int> selectedBodyIdx1 = 1;
 
  [AVOID_SaveValue("selectedBodyIdx2")]
  protected VOID_SaveValue<int> selectedBodyIdx2 = 2;
 
  protected CelestialBody selectedBody1;
  protected CelestialBody selectedBody2;
 
  [AVOID_SaveValue("toggleOrbital")]
  protected VOID_SaveValue<bool> toggleOrbital = false;
 
  [AVOID_SaveValue("togglePhysical")]
  protected VOID_SaveValue<bool> togglePhysical = false;
 
  public VOID_CBInfoBrowser()
  {
  this._Name = "Celestial Body Information Browser";
  }
 
  public override void ModuleWindow(int _)
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 
  GUILayout.BeginVertical(GUILayout.Width(150));
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("", GUILayout.ExpandWidth(true));
  GUILayout.EndHorizontal();
 
  GUILayout.EndVertical();
 
  GUILayout.BeginVertical(GUILayout.Width(150));
 
  selectedBody1 = VOID_Core.Instance.allBodies[selectedBodyIdx1];
  selectedBody2 = VOID_Core.Instance.allBodies[selectedBodyIdx2];
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button("<", GUILayout.ExpandWidth(false)))
  {
  selectedBodyIdx1--;
  if (selectedBodyIdx1 < 0) selectedBodyIdx1 = VOID_Core.Instance.allBodies.Count - 1;
  }
  GUILayout.Label(VOID_Core.Instance.allBodies[selectedBodyIdx1].bodyName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true));
  if (GUILayout.Button(">", GUILayout.ExpandWidth(false)))
  {
  selectedBodyIdx1++;
  if (selectedBodyIdx1 > VOID_Core.Instance.allBodies.Count - 1) selectedBodyIdx1 = 0;
  }
  GUILayout.EndHorizontal();
  GUILayout.EndVertical();
 
  GUILayout.BeginVertical(GUILayout.Width(150));
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button("<", GUILayout.ExpandWidth(false)))
  {
  selectedBodyIdx2--;
  if (selectedBodyIdx2 < 0) selectedBodyIdx2 = VOID_Core.Instance.allBodies.Count - 1;
  }
  GUILayout.Label(VOID_Core.Instance.allBodies[selectedBodyIdx2].bodyName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true));
  if (GUILayout.Button(">", GUILayout.ExpandWidth(false)))
  {
  selectedBodyIdx2++;
  if (selectedBodyIdx2 > VOID_Core.Instance.allBodies.Count - 1) selectedBodyIdx2 = 0;
  }
  GUILayout.EndHorizontal();
  GUILayout.EndVertical();
 
  GUILayout.EndHorizontal();
 
  //}
 
  //toggle for orbital info chunk
  if (GUILayout.Button("Orbital Characteristics", GUILayout.ExpandWidth(true))) toggleOrbital = !toggleOrbital;
 
  if (toggleOrbital)
  {
  //begin orbital into horizontal chunk
  //print("begin orbital info section...");
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 
  //begin orbital value labels column
  GUILayout.BeginVertical(GUILayout.Width(150));
 
  //print("printing row labels...");
 
  GUILayout.Label("Apoapsis:");
  GUILayout.Label("Time to Ap:");
  GUILayout.Label("Periapsis:");
  GUILayout.Label("Time to Pe:");
  GUILayout.Label("Semi-major axis:");
  GUILayout.Label("Eccentricity:");
  GUILayout.Label("Orbital period:");
  GUILayout.Label("Rotational period:");
  GUILayout.Label("Velocity:");
  GUILayout.Label("Mean anomaly:");
  GUILayout.Label("True anomaly:");
  GUILayout.Label("Eccentric anomaly:");
  GUILayout.Label("Inclination:");
  GUILayout.Label("Long. ascending node:");
  GUILayout.Label("Arg. of periapsis:");
  GUILayout.Label("Tidally locked:");
 
  //end orbital value labels column
  GUILayout.EndVertical();
 
  //begin primary orbital values column
  GUILayout.BeginVertical(GUILayout.Width(150));
 
  body_OP_show_orbital_info(selectedBody1);
 
  //end primary orbital values column
  GUILayout.EndVertical();
 
  //begin secondary orbital values column
  GUILayout.BeginVertical(GUILayout.Width(150));
 
  body_OP_show_orbital_info(selectedBody2);
 
  //end secondary orbital values column
  GUILayout.EndVertical();
 
  //end orbital info horizontal chunk
  GUILayout.EndHorizontal();
  }
 
  //toggle for physical info chunk
  if (GUILayout.Button("Physical Characteristics", GUILayout.ExpandWidth(true))) togglePhysical = !togglePhysical;
 
  if (togglePhysical)
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
 
  //begin physical info value label column
  GUILayout.BeginVertical(GUILayout.Width(150));
 
  GUILayout.Label("Radius:");
  GUILayout.Label("Surface area:");
  GUILayout.Label("Volume:");
  GUILayout.Label("Mass:");
  GUILayout.Label("Density:");
  GUILayout.Label("Sphere of influence:");
  GUILayout.Label("Natural satellites:");
  GUILayout.Label("Artificial satellites:");
  GUILayout.Label("Surface gravity:");
  GUILayout.Label("Atmosphere altitude:");
  GUILayout.Label("Atmospheric O\u2082:");
  GUILayout.Label("Has ocean:");
 
  //end physical info value label column
  GUILayout.EndVertical();
 
  //begin primary physical values column
  GUILayout.BeginVertical(GUILayout.Width(150));
 
  body_OP_show_physical_info(selectedBody1);
 
  //end primary physical column
  GUILayout.EndVertical();
 
  //begin secondary physical values column
  GUILayout.BeginVertical(GUILayout.Width(150));
 
  body_OP_show_physical_info(selectedBody2);
 
  //end target physical values column
  GUILayout.EndVertical();
 
  //end physical value horizontal chunk
  GUILayout.EndHorizontal();
  }
 
  GUI.DragWindow();
  }
 
  private void body_OP_show_orbital_info(CelestialBody body)
  {
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label((body.orbit.ApA / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(Tools.ConvertInterval(body.orbit.timeToAp), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label((body.orbit.PeA / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(Tools.ConvertInterval(body.orbit.timeToPe), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label((body.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(body.orbit.eccentricity.ToString("F4") + "", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(Tools.ConvertInterval(body.orbit.period), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(Tools.ConvertInterval(body.rotationPeriod), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label((body.orbit.orbitalSpeed / 1000).ToString("F2") + "km/s", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  // Toadicus edit: convert mean anomaly into degrees.
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label((body.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(body.orbit.trueAnomaly.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  // Toadicus edit: convert eccentric anomaly into degrees.
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label((body.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(body.orbit.inclination.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(body.orbit.LAN.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(body.orbit.argumentOfPeriapsis.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else
  {
  string body_tidally_locked = "No";
  if (body.tidallyLocked) body_tidally_locked = "Yes";
  GUILayout.Label(body_tidally_locked, VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  }
  //GUILayout.EndHorizontal();
  }
 
  private void body_OP_show_physical_info(CelestialBody body)
  {
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label((body.Radius / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(((Math.Pow((body.Radius), 2) * 4 * Math.PI) / 1000).ToString("0.00e+00") + "km²", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  // divide by 1000 to convert m to km
  GUILayout.Label((((4d / 3) * Math.PI * Math.Pow(body.Radius, 3)) / 1000).ToString("0.00e+00") + "km³", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.Label(((4 / 3) * Math.PI * Math.Pow((vessel.mainBody.Radius / 1000), 3)).ToString(), txt_right, GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(body.Mass.ToString("0.00e+00") + "kg", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  double p = body.Mass / (Math.Pow(body.Radius, 3) * (4d / 3) * Math.PI);
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(p.ToString("##,#") + "kg/m³", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (body.bodyName == "Sun") GUILayout.Label(Tools.MuMech_ToSI(body.sphereOfInfluence), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  else GUILayout.Label(Tools.MuMech_ToSI(body.sphereOfInfluence), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(body.orbitingBodies.Count.ToString(), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //show # artificial satellites
  int num_art_sats = 0;
  foreach (Vessel v in FlightGlobals.Vessels)
  {
  if (v.mainBody == body && v.situation.ToString() == "ORBITING") num_art_sats++;
  }
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(num_art_sats.ToString(), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  double g_ASL = (VOID_Core.Constant_G * body.Mass) / Math.Pow(body.Radius, 2);
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(Tools.MuMech_ToSI(g_ASL) + "m/s²", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("≈ " + Tools.MuMech_ToSI(body.maxAtmosphereAltitude) + "m", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  string O2 = "No";
  if (body.atmosphereContainsOxygen == true) O2 = "Yes";
  GUILayout.Label(O2, VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
 
  //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  string ocean = "No";
  if (body.ocean == true) ocean = "Yes";
  GUILayout.Label(ocean, VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true));
  //GUILayout.EndHorizontal();
  }
  }
  }
// //
// VOID_Core.cs // VOID_Core.cs
// //
// Author: // Author:
// toadicus <> // toadicus <>
// //
// Copyright (c) 2013 toadicus // Copyright (c) 2013 toadicus
// //
// This program is free software: you can redistribute it and/or modify // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// This program is distributed in the hope that it will be useful, // This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details. // GNU General Public License for more details.
// //
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Reflection; using System.Reflection;
using KSP; using KSP;
using UnityEngine; using UnityEngine;
   
namespace VOID namespace VOID
{ {
public class VOID_Core : VOID_Module, IVOID_Module public class VOID_Core : VOID_Module, IVOID_Module
{ {
/* /*
* Static Members * Static Members
* */ * */
protected static bool _initialized = false; protected static bool _initialized = false;
public static bool Initialized public static bool Initialized
{ {
get get
{ {
return _initialized; return _initialized;
} }
} }
   
protected static VOID_Core _instance; protected static VOID_Core _instance;
public static VOID_Core Instance public static VOID_Core Instance
{ {
get get
{ {
if (_instance == null) if (_instance == null)
{ {
_instance = new VOID_Core(); _instance = new VOID_Core();
_initialized = true; _initialized = true;
} }
return _instance; return _instance;
} }
} }
   
  public static double Constant_G = 6.674e-11;
   
/* /*
* Fields * Fields
* */ * */
protected string VoidName = "VOID"; protected string VoidName = "VOID";
protected string VoidVersion = "0.9.9"; protected string VoidVersion = "0.9.9";
   
[AVOID_SaveValue("configValue")] [AVOID_SaveValue("configValue")]
protected VOID_SaveValue<int> configVersion = 1; protected VOID_SaveValue<int> configVersion = 1;
   
protected List<IVOID_Module> _modules = new List<IVOID_Module>(); protected List<IVOID_Module> _modules = new List<IVOID_Module>();
protected bool _modulesLoaded = false; protected bool _modulesLoaded = false;
   
protected List<Callback> _configurableCallbacks = new List<Callback>();  
   
[AVOID_SaveValue("mainWindowPos")] [AVOID_SaveValue("mainWindowPos")]
protected VOID_SaveValue<Rect> mainWindowPos = new Rect(Screen.width / 2, Screen.height / 2, 10f, 10f); protected VOID_SaveValue<Rect> mainWindowPos = new Rect(Screen.width / 2, Screen.height / 2, 10f, 10f);
   
[AVOID_SaveValue("mainGuiMinimized")] [AVOID_SaveValue("mainGuiMinimized")]
protected VOID_SaveValue<bool> mainGuiMinimized = false; protected VOID_SaveValue<bool> mainGuiMinimized = false;
   
[AVOID_SaveValue("configWindowPos")] [AVOID_SaveValue("configWindowPos")]
protected VOID_SaveValue<Rect> configWindowPos = new Rect(Screen.width / 2, Screen.height /2, 10f, 10f); protected VOID_SaveValue<Rect> configWindowPos = new Rect(Screen.width / 2, Screen.height /2, 10f, 10f);
   
[AVOID_SaveValue("configWindowMinimized")] [AVOID_SaveValue("configWindowMinimized")]
protected VOID_SaveValue<bool> configWindowMinimized = true; protected VOID_SaveValue<bool> configWindowMinimized = true;
   
[AVOID_SaveValue("VOIDIconPos")] [AVOID_SaveValue("VOIDIconPos")]
protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 30, 30f, 30f); protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 30, 30f, 30f);
protected Texture2D VOIDIconOff = new Texture2D(30, 30, TextureFormat.ARGB32, false); protected Texture2D VOIDIconOff = new Texture2D(30, 30, TextureFormat.ARGB32, false);
protected Texture2D VOIDIconOn = new Texture2D(30, 30, TextureFormat.ARGB32, false); protected Texture2D VOIDIconOn = new Texture2D(30, 30, TextureFormat.ARGB32, false);
protected Texture2D VOIDIconTexture; protected Texture2D VOIDIconTexture;
protected string VOIDIconOnPath = "VOID/Textures/void_icon_on"; protected string VOIDIconOnPath = "VOID/Textures/void_icon_on";
protected string VOIDIconOffPath = "VOID/Textures/void_icon_off"; protected string VOIDIconOffPath = "VOID/Textures/void_icon_off";
   
protected int windowBaseID = -96518722; protected int windowBaseID = -96518722;
  protected int _windowID = 0;
   
  protected bool GUIStylesLoaded = false;
   
  protected Dictionary<string, GUIStyle> _LabelStyles = new Dictionary<string, GUIStyle>();
   
[AVOID_SaveValue("togglePower")] [AVOID_SaveValue("togglePower")]
public VOID_SaveValue<bool> togglePower = true; public VOID_SaveValue<bool> togglePower = true;
   
public bool powerAvailable = true; public bool powerAvailable = true;
   
[AVOID_SaveValue("consumeResource")] [AVOID_SaveValue("consumeResource")]
protected VOID_SaveValue<bool> consumeResource = false; protected VOID_SaveValue<bool> consumeResource = false;
   
[AVOID_SaveValue("resourceName")] [AVOID_SaveValue("resourceName")]
protected VOID_SaveValue<string> resourceName = "ElectricCharge"; protected VOID_SaveValue<string> resourceName = "ElectricCharge";
   
[AVOID_SaveValue("resourceRate")] [AVOID_SaveValue("resourceRate")]
protected VOID_SaveValue<float> resourceRate = 0.2f; protected VOID_SaveValue<float> resourceRate = 0.2f;
   
  // Celestial Body Housekeeping
  protected List<CelestialBody> _allBodies = new List<CelestialBody>();
  protected bool bodiesLoaded = false;
   
  // Vessel Type Housekeeping
  protected List<VesselType> _allVesselTypes = new List<VesselType>();
  protected bool vesselTypesLoaded = false;
   
public float saveTimer = 0; public float saveTimer = 0;
   
protected string defaultSkin = "KSP window 2"; protected string defaultSkin = "KSP window 2";
protected VOID_SaveValue<string> _skin; protected VOID_SaveValue<string> _skin;
   
public bool configDirty; public bool configDirty;
   
/* /*
* Properties * Properties
* */ * */
public List<IVOID_Module> Modules public List<IVOID_Module> Modules
{ {
get get
{ {
return this._modules; return this._modules;
} }
} }
   
public GUISkin Skin public GUISkin Skin
{ {
get get
{ {
if (this._skin == null) if (this._skin == null)
{ {
this._skin = this.defaultSkin; this._skin = this.defaultSkin;
} }
return AssetBase.GetGUISkin(this._skin); return AssetBase.GetGUISkin(this._skin);
} }
} }
   
public Vessel vessel public int windowID
{ {
get get
{ {
return FlightGlobals.ActiveVessel; if (this._windowID == 0)
  {
  this._windowID = this.windowBaseID;
  }
  return this._windowID++;
  }
  }
   
  public Dictionary<string, GUIStyle> LabelStyles
  {
  get
  {
  return this._LabelStyles;
  }
  }
   
  public List<CelestialBody> allBodies
  {
  get
  {
  return this._allBodies;
  }
  }
   
  public List<VesselType> allVesselTypes
  {
  get
  {
  return this._allVesselTypes;
} }
} }
   
/* /*
* Methods * Methods
* */ * */
protected VOID_Core() protected VOID_Core()
{ {
this._Name = "VOID Core"; this._Name = "VOID Core";
   
this.VOIDIconOn = GameDatabase.Instance.GetTexture (this.VOIDIconOnPath, false); this.VOIDIconOn = GameDatabase.Instance.GetTexture (this.VOIDIconOnPath, false);
this.VOIDIconOff = GameDatabase.Instance.GetTexture (this.VOIDIconOffPath, false); this.VOIDIconOff = GameDatabase.Instance.GetTexture (this.VOIDIconOffPath, false);
   
this.LoadConfig (); this.LoadConfig ();
} }
   
protected void LoadModules() protected void LoadModules()
{ {
var types = AssemblyLoader.loadedAssemblies var types = AssemblyLoader.loadedAssemblies
.Select (a => a.assembly.GetExportedTypes ()) .Select (a => a.assembly.GetExportedTypes ())
.SelectMany (t => t) .SelectMany (t => t)
.Where (v => typeof(IVOID_Module).IsAssignableFrom (v) .Where (v => typeof(IVOID_Module).IsAssignableFrom (v)
&& !(v.IsInterface || v.IsAbstract) && && !(v.IsInterface || v.IsAbstract) &&
!typeof(VOID_Core).IsAssignableFrom (v) !typeof(VOID_Core).IsAssignableFrom (v)
); );
   
Tools.PostDebugMessage (string.Format ( Tools.PostDebugMessage (string.Format (
"{0}: Found {1} modules to check.", "{0}: Found {1} modules to check.",
this.GetType ().Name, this.GetType ().Name,
types.Count () types.Count ()
)); ));
foreach (var voidType in types) foreach (var voidType in types)
{ {
Tools.PostDebugMessage (string.Format ( Tools.PostDebugMessage (string.Format (
"{0}: found Type {1}", "{0}: found Type {1}",
this.GetType ().Name, this.GetType ().Name,
voidType.Name voidType.Name
)); ));
   
this.LoadModule(voidType); this.LoadModule(voidType);
} }
   
this._modulesLoaded = true; this._modulesLoaded = true;
   
Tools.PostDebugMessage (string.Format ("VOID_Core: Loaded {0} modules.", this.Modules.Count)); Tools.PostDebugMessage (string.Format ("VOID_Core: Loaded {0} modules.", this.Modules.Count));
} }
   
protected void LoadModule(Type T) protected void LoadModule(Type T)
{ {
var existingModules = this._modules.Where (mod => mod.GetType ().Name == T.Name); var existingModules = this._modules.Where (mod => mod.GetType ().Name == T.Name);
if (existingModules.Any()) if (existingModules.Any())
{ {
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: refusing to load {1}: already loaded", "{0}: refusing to load {1}: already loaded",
this.GetType().Name, this.GetType().Name,
T.Name T.Name
)); ));
return; return;
} }
IVOID_Module module = Activator.CreateInstance (T) as IVOID_Module; IVOID_Module module = Activator.CreateInstance (T) as IVOID_Module;
module.LoadConfig(); module.LoadConfig();
this._modules.Add (module); this._modules.Add (module);
   
Tools.PostDebugMessage(string.Format( Tools.PostDebugMessage(string.Format(
"{0}: loaded module {1}.", "{0}: loaded module {1}.",
this.GetType().Name, this.GetType().Name,
T.Name T.Name
)); ));
} }
   
public void Update() public void Update()
{ {
this.saveTimer += Time.deltaTime; this.saveTimer += Time.deltaTime;
   
  if (!this.bodiesLoaded)
  {
  this.LoadAllBodies();
  }
   
  if (!this.vesselTypesLoaded)
  {
  this.LoadVesselTypes();
  }
   
if (!this.guiRunning) if (!this.guiRunning)
{ {
this.StartGUI (); this.StartGUI ();
} }
   
if (!HighLogic.LoadedSceneIsFlight && this.guiRunning) if (!HighLogic.LoadedSceneIsFlight && this.guiRunning)
{ {
this.StopGUI (); this.StopGUI ();
} }
   
foreach (IVOID_Module module in this.Modules) foreach (IVOID_Module module in this.Modules)
{ {
if (!module.guiRunning && module.toggleActive) if (!module.guiRunning && module.toggleActive)
{ {
module.StartGUI (); module.StartGUI ();
} }
if (module.guiRunning && !module.toggleActive || !this.togglePower || !HighLogic.LoadedSceneIsFlight) if (module.guiRunning && !module.toggleActive || !this.togglePower || !HighLogic.LoadedSceneIsFlight)
{ {
module.StopGUI(); module.StopGUI();
} }
}  
  if (module is IVOID_BehaviorModule)
if (this.saveTimer > 15f) {
  ((IVOID_BehaviorModule)module).Update();
  }
  }
   
  if (this.saveTimer > 2f)
{ {
this.SaveConfig (); this.SaveConfig ();
this.saveTimer = 0; this.saveTimer = 0;
} }
} }
   
public void FixedUpdate() public void FixedUpdate()
{ {
if (this.consumeResource && if (this.consumeResource &&
this.vessel.vesselType != VesselType.EVA && this.vessel.vesselType != VesselType.EVA &&
TimeWarp.deltaTime != 0 TimeWarp.deltaTime != 0
) )
{ {
float powerReceived = this.vessel.rootPart.RequestResource(this.resourceName, float powerReceived = this.vessel.rootPart.RequestResource(this.resourceName,
this.resourceRate * TimeWarp.fixedDeltaTime); this.resourceRate * TimeWarp.fixedDeltaTime);
if (powerReceived > 0) if (powerReceived > 0)
{ {
this.powerAvailable = true; this.powerAvailable = true;
} }
else else
{ {
this.powerAvailable = false; this.powerAvailable = false;
} }
} }
   
  foreach (IVOID_BehaviorModule module in
  this._modules.OfType<IVOID_BehaviorModule>().Where(m => !m.GetType().IsAbstract))
  {
  module.FixedUpdate();
  }
  }
   
  protected void LoadGUIStyles()
  {
  this.LabelStyles["center"] = new GUIStyle(GUI.skin.label);
  this.LabelStyles["center"].normal.textColor = Color.white;
  this.LabelStyles["center"].alignment = TextAnchor.UpperCenter;
   
  this.LabelStyles["center_bold"] = new GUIStyle(GUI.skin.label);
  this.LabelStyles["center_bold"].normal.textColor = Color.white;
  this.LabelStyles["center_bold"].alignment = TextAnchor.UpperCenter;
  this.LabelStyles["center_bold"].fontStyle = FontStyle.Bold;
   
  this.LabelStyles["txt_right"] = new GUIStyle(GUI.skin.label);
  this.LabelStyles["txt_right"].normal.textColor = Color.white;
  this.LabelStyles["txt_right"].alignment = TextAnchor.UpperRight;
   
  this.GUIStylesLoaded = true;
  }
   
   
  protected void LoadAllBodies()
  {
  this._allBodies = FlightGlobals.Bodies;
  this.bodiesLoaded = true;
  }
   
  protected void LoadVesselTypes()
  {
  this._allVesselTypes = Enum.GetValues(typeof(VesselType)).OfType<VesselType>().ToList();
  this.vesselTypesLoaded = true;
} }
   
public void VOIDMainWindow(int _) public void VOIDMainWindow(int _)
{ {
GUILayout.BeginVertical(); GUILayout.BeginVertical();
if (this.powerAvailable) if (this.powerAvailable)
{ {
string str = "ON"; string str = "ON";
if (togglePower) str = "OFF"; if (togglePower) str = "OFF";
if (GUILayout.Button("Power " + str)) togglePower = !togglePower; if (GUILayout.Button("Power " + str)) togglePower = !togglePower;
if (togglePower) if (togglePower)
{ {
foreach (IVOID_Module module in this.Modules) foreach (IVOID_Module module in this.Modules)
{ {
module.toggleActive = GUILayout.Toggle (module.toggleActive, module.Name); module.toggleActive = GUILayout.Toggle (module.toggleActive, module.Name);
} }
} }
} }
else else
{ {
GUIStyle label_txt_red = new GUIStyle(GUI.skin.label); GUIStyle label_txt_red = new GUIStyle(GUI.skin.label);
label_txt_red.normal.textColor = Color.red; label_txt_red.normal.textColor = Color.red;
label_txt_red.alignment = TextAnchor.MiddleCenter; label_txt_red.alignment = TextAnchor.MiddleCenter;
GUILayout.Label("-- POWER LOST --", label_txt_red); GUILayout.Label("-- POWER LOST --", label_txt_red);
} }
   
this.configWindowMinimized = !GUILayout.Toggle (!this.configWindowMinimized, "Configuration"); this.configWindowMinimized = !GUILayout.Toggle (!this.configWindowMinimized, "Configuration");
   
GUILayout.EndVertical(); GUILayout.EndVertical();
GUI.DragWindow(); GUI.DragWindow();
} }
   
public void VOIDConfigWindow(int _) public void VOIDConfigWindow(int _)
{ {
GUILayout.BeginVertical (); GUILayout.BeginVertical ();
   
this.DrawConfigurables (); this.DrawConfigurables ();
   
GUILayout.EndVertical (); GUILayout.EndVertical ();
GUI.DragWindow (); GUI.DragWindow ();
} }
   
public override void DrawConfigurables() public override void DrawConfigurables()
{ {
this.consumeResource = GUILayout.Toggle (this.consumeResource, "Consume Resources"); this.consumeResource = GUILayout.Toggle (this.consumeResource, "Consume Resources");
   
foreach (IVOID_Module mod in this.Modules) foreach (IVOID_Module mod in this.Modules)
{ {
mod.DrawConfigurables (); mod.DrawConfigurables ();
} }
} }
   
public override void DrawGUI() public override void DrawGUI()
{ {
if (!this._modulesLoaded) if (!this._modulesLoaded)
{ {
this.LoadModules (); this.LoadModules ();
} }
   
  this._windowID = this.windowBaseID;
   
GUI.skin = this.Skin; GUI.skin = this.Skin;
   
int windowID = this.windowBaseID; if (!this.GUIStylesLoaded)
  {
  this.LoadGUIStyles ();
  }
   
this.VOIDIconTexture = this.VOIDIconOff; //icon off default this.VOIDIconTexture = this.VOIDIconOff; //icon off default
if (this.togglePower) this.VOIDIconTexture = this.VOIDIconOn; //or on if power_toggle==true if (this.togglePower) this.VOIDIconTexture = this.VOIDIconOn; //or on if power_toggle==true
if (GUI.Button(new Rect(VOIDIconPos), VOIDIconTexture, new GUIStyle())) if (GUI.Button(new Rect(VOIDIconPos), VOIDIconTexture, new GUIStyle()))
{ {
this.mainGuiMinimized = !this.mainGuiMinimized; this.mainGuiMinimized = !this.mainGuiMinimized;
} }
   
if (!this.mainGuiMinimized) if (!this.mainGuiMinimized)
{ {
Rect _mainWindowPos = this.mainWindowPos; Rect _mainWindowPos = this.mainWindowPos;
   
_mainWindowPos = GUILayout.Window ( _mainWindowPos = GUILayout.Window (
++windowID, this.windowID,
_mainWindowPos, _mainWindowPos,
this.VOIDMainWindow, this.VOIDMainWindow,
string.Join (" ", new string[] {this.VoidName, this.VoidVersion}), string.Join (" ", new string[] {this.VoidName, this.VoidVersion}),
GUILayout.Width (250), GUILayout.Width (250),
GUILayout.Height (50) GUILayout.Height (50)
); );
   
if (_mainWindowPos != this.mainWindowPos) if (_mainWindowPos != this.mainWindowPos)
{ {
this.mainWindowPos = _mainWindowPos; this.mainWindowPos = _mainWindowPos;
} }
} }
   
if (!this.configWindowMinimized) if (!this.configWindowMinimized)
{ {
Rect _configWindowPos = this.configWindowPos; Rect _configWindowPos = this.configWindowPos;
   
_configWindowPos = GUILayout.Window ( _configWindowPos = GUILayout.Window (
++windowID, this.windowID,
_configWindowPos, _configWindowPos,
this.VOIDConfigWindow, this.VOIDConfigWindow,
string.Join (" ", new string[] {this.VoidName, "Configuration"}), string.Join (" ", new string[] {this.VoidName, "Configuration"}),
GUILayout.Width (250), GUILayout.Width (250),
GUILayout.Height (50) GUILayout.Height (50)
); );
   
if (_configWindowPos != this.configWindowPos) if (_configWindowPos != this.configWindowPos)
{ {
this.configWindowPos = _configWindowPos; this.configWindowPos = _configWindowPos;
} }
} }
} }
   
public override void LoadConfig() public override void LoadConfig()
{ {
base.LoadConfig (); base.LoadConfig ();
   
foreach (IVOID_Module module in this.Modules) foreach (IVOID_Module module in this.Modules)
{ {
module.LoadConfig (); module.LoadConfig ();
} }
} }
   
public override void SaveConfig() public void SaveConfig()
{ {
if (!this.configDirty) if (!this.configDirty)
{ {
return; return;
} }
   
base.SaveConfig (); var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> ();
  config.load ();
   
  this._SaveToConfig(config);
   
foreach (IVOID_Module module in this.Modules) foreach (IVOID_Module module in this.Modules)
{ {
module.SaveConfig (); module._SaveToConfig (config);
} }
   
  config.save();
   
this.configDirty = false; this.configDirty = false;
} }
} }
} }
   
   
  //
  // VOID_Orbital.cs
  //
  // Author:
  // toadicus <>
  //
  // Copyright (c) 2013 toadicus
  //
  // This program is free software: you can redistribute it and/or modify
  // it under the terms of the GNU General Public License as published by
  // 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,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program. If not, see <http://www.gnu.org/licenses/>.
  using KSP;
  using System;
  using System.Collections.Generic;
  using UnityEngine;
 
  namespace VOID
  {
  public class VOID_DataLogger : VOID_WindowModule, IVOID_BehaviorModule
  {
  /*
  * Fields
  * */
  protected bool stopwatch1_running = false;
 
  protected bool csv_logging = false;
  protected bool first_write = true;
 
  protected double stopwatch1 = 0;
 
  protected string csv_log_interval_str = "0.5";
 
  protected float csv_log_interval;
 
  protected double csvWriteTimer = 0;
  protected double csvCollectTimer = 0;
 
  protected List<string> csvList = new List<string>();
 
  /*
  * Properties
  * */
 
 
  /*
  * Methods
  * */
  public VOID_DataLogger()
  {
  this._Name = "CSV Data Logger";
  }
 
  public override void ModuleWindow(int _)
  {
  GUIStyle txt_white = new GUIStyle(GUI.skin.label);
  txt_white.normal.textColor = txt_white.focused.textColor = Color.white;
  GUIStyle txt_green = new GUIStyle(GUI.skin.label);
  txt_green.normal.textColor = txt_green.focused.textColor = Color.green;
  GUIStyle txt_yellow = new GUIStyle(GUI.skin.label);
  txt_yellow.normal.textColor = txt_yellow.focused.textColor = Color.yellow;
 
  GUILayout.BeginVertical();
 
  GUILayout.Label("System time: " + DateTime.Now.ToString("HH:mm:ss"));
  GUILayout.Label(Tools.ConvertInterval(stopwatch1));
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button("Start"))
  {
  if (stopwatch1_running == false) stopwatch1_running = true;
  }
  if (GUILayout.Button("Stop"))
  {
  if (stopwatch1_running == true) stopwatch1_running = false;
  }
  if (GUILayout.Button("Reset"))
  {
  if (stopwatch1_running == true) stopwatch1_running = false;
  stopwatch1 = 0;
  }
  GUILayout.EndHorizontal();
 
  GUIStyle label_style = txt_white;
  string log_label = "Inactive";
  if (csv_logging && vessel.situation.ToString() == "PRELAUNCH")
  {
  log_label = "Awaiting launch";
  label_style = txt_yellow;
  }
  if (csv_logging && vessel.situation.ToString() != "PRELAUNCH")
  {
  log_label = "Active";
  label_style = txt_green;
  }
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  csv_logging = GUILayout.Toggle(csv_logging, "Data logging: ", GUILayout.ExpandWidth(false));
  GUILayout.Label(log_label, label_style, GUILayout.ExpandWidth(true));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Interval: ", GUILayout.ExpandWidth(false));
  csv_log_interval_str = GUILayout.TextField(csv_log_interval_str, GUILayout.ExpandWidth(true));
  GUILayout.Label("s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  float new_log_interval;
  if (Single.TryParse(csv_log_interval_str, out new_log_interval)) csv_log_interval = new_log_interval;
 
  GUILayout.EndVertical();
  GUI.DragWindow();
  }
 
  public void Update()
  {
  // CSV Logging
  // from ISA MapSat
  if (csv_logging)
  {
  //data logging is on
  //increment timers
  csvWriteTimer += Time.deltaTime;
  csvCollectTimer += Time.deltaTime;
  }
  else
  {
  //data logging is off
  //reset any timers and clear anything from csvList
  csvWriteTimer = 0f;
  csvCollectTimer = 0f;
  if (csvList.Count > 0) csvList.Clear();
  }
 
  if (csv_logging && csvCollectTimer >= csv_log_interval && vessel.situation != Vessel.Situations.PRELAUNCH)
  {
  //data logging is on, vessel is not prelaunch, and interval has passed
  //write a line to the list
  line_to_csvList(); //write to the csv
  }
 
  if (csvList.Count != 0 && csvWriteTimer >= 15f && csv_logging)
  {
  // csvList is not empty and interval between writings to file has elapsed
  //write it
  string[] csvData;
  csvData = (string[])csvList.ToArray();
  Innsewerants_writeData(csvData);
  csvList.Clear();
  csvWriteTimer = 0f;
  }
  }
 
  public void FixedUpdate() {}
 
  private void Innsewerants_writeData(string[] csvArray)
  {
  var efile = KSP.IO.File.AppendText<VOID_Core>(vessel.vesselName + "_data.csv", null);
  foreach (string line in csvArray)
  {
  efile.Write(line);
  }
  efile.Close();
  }
 
  private void line_to_csvList()
  {
  //called if logging is on and interval has passed
  //writes one line to the csvList
 
  string line = "";
  if (first_write && !KSP.IO.File.Exists<VOID_Core>(vessel.vesselName + "_data.csv", null))
  {
  first_write = false;
  line += "Mission Elapsed Time (s);Altitude ASL (m);Altitude above terrain (m);Orbital Velocity (m/s);Surface Velocity (m/s);Vertical Speed (m/s);Horizontal Speed (m/s);Gee Force (gees);Temperature (°C);Gravity (m/s²);Atmosphere Density (g/m³);\n";
  }
  //Mission time
  line += vessel.missionTime.ToString("F3") + ";";
  //Altitude ASL
  line += vessel.orbit.altitude.ToString("F3") + ";";
  //Altitude (true)
  double alt_true = vessel.orbit.altitude - vessel.terrainAltitude;
  if (vessel.terrainAltitude < 0) alt_true = vessel.orbit.altitude;
  line += alt_true.ToString("F3") + ";";
  //Orbital velocity
  line += vessel.orbit.vel.magnitude.ToString("F3") + ";";
  //surface velocity
  line += vessel.srf_velocity.magnitude.ToString("F3") + ";";
  //vertical speed
  line += vessel.verticalSpeed.ToString("F3") + ";";
  //horizontal speed
  line += vessel.horizontalSrfSpeed.ToString("F3") + ";";
  //gee force
  line += vessel.geeForce.ToString("F3") + ";";
  //temperature
  line += vessel.flightIntegrator.getExternalTemperature().ToString("F2") + ";";
  //gravity
  double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass());
  double g_vessel = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2);
  line += g_vessel.ToString("F3") + ";";
  //atm density
  line += (vessel.atmDensity * 1000).ToString("F3") + ";";
  line += "\n";
  if (csvList.Contains(line) == false) csvList.Add(line);
  csvCollectTimer = 0f;
  }
  }
  }
// //
// VOID_Hud.cs // VOID_Hud.cs
// //
// Author: // Author:
// toadicus <> // toadicus <>
// //
// Copyright (c) 2013 toadicus // Copyright (c) 2013 toadicus
// //
// This program is free software: you can redistribute it and/or modify // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// This program is distributed in the hope that it will be useful, // This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details. // GNU General Public License for more details.
// //
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
// //
   
using KSP; using KSP;
using UnityEngine; using UnityEngine;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
   
namespace VOID namespace VOID
{ {
public class VOID_HUD : VOID_Module, IVOID_Module public class VOID_HUD : VOID_Module, IVOID_Module
{ {
/* /*
* Fields * Fields
* */ * */
protected new bool _hasConfigurables = true;  
   
[AVOID_SaveValue("colorIndex")] [AVOID_SaveValue("colorIndex")]
protected VOID_SaveValue<int> _colorIndex = 0; protected VOID_SaveValue<int> _colorIndex = 0;
   
protected List<Color> textColors = new List<Color>(); protected List<Color> textColors = new List<Color>();
   
protected GUIStyle labelStyle; protected GUIStyle labelStyle;
   
protected Vessel vessel = null;  
   
/* /*
* Properties * Properties
* */ * */
public int ColorIndex public int ColorIndex
{ {
get get
{ {
return this._colorIndex; return this._colorIndex;
} }
set set
{ {
if (this._colorIndex >= this.textColors.Count - 1) if (this._colorIndex >= this.textColors.Count - 1)
{ {
this._colorIndex = 0; this._colorIndex = 0;
return; return;
} }
   
this._colorIndex = value; this._colorIndex = value;
} }
} }
   
/* /*
* Methods * Methods
* */ * */
public VOID_HUD() : base() public VOID_HUD() : base()
{ {
this._Name = "Heads-Up Display"; this._Name = "Heads-Up Display";
this.textColors.Add(Color.green); this.textColors.Add(Color.green);
this.textColors.Add(Color.black); this.textColors.Add(Color.black);
this.textColors.Add(Color.white); this.textColors.Add(Color.white);
this.textColors.Add(Color.red); this.textColors.Add(Color.red);
this.textColors.Add(Color.blue); this.textColors.Add(Color.blue);
this.textColors.Add(Color.yellow); this.textColors.Add(Color.yellow);
this.textColors.Add(Color.gray); this.textColors.Add(Color.gray);
this.textColors.Add(Color.cyan); this.textColors.Add(Color.cyan);
this.textColors.Add(Color.magenta); this.textColors.Add(Color.magenta);
   
this.labelStyle = new GUIStyle (); this.labelStyle = new GUIStyle ();
this.labelStyle.normal.textColor = this.textColors [this.ColorIndex]; this.labelStyle.normal.textColor = this.textColors [this.ColorIndex];
   
Tools.PostDebugMessage ("VOID_HUD: Constructed."); Tools.PostDebugMessage ("VOID_HUD: Constructed.");
} }
   
public override void DrawGUI() public override void DrawGUI()
{ {
Tools.PostDebugMessage ("VOID_HUD: Drawing GUI.");  
   
GUI.skin = VOID_Core.Instance.Skin; GUI.skin = VOID_Core.Instance.Skin;
   
if (vessel == null)  
{  
vessel = FlightGlobals.ActiveVessel;  
}  
   
if (vessel != FlightGlobals.ActiveVessel)  
{  
vessel = FlightGlobals.ActiveVessel;  
}  
   
if (VOID_Core.Instance.powerAvailable) if (VOID_Core.Instance.powerAvailable)
{ {
labelStyle.normal.textColor = textColors [ColorIndex]; labelStyle.normal.textColor = textColors [ColorIndex];
   
GUI.Label ( GUI.Label (
new Rect ((Screen.width * .2083f), 0, 300f, 70f), new Rect ((Screen.width * .2083f), 0, 300f, 70f),
"Obt Alt: " + Tools.MuMech_ToSI (vessel.orbit.altitude) + "m" + "Obt Alt: " + Tools.MuMech_ToSI (vessel.orbit.altitude) + "m" +
" Obt Vel: " + Tools.MuMech_ToSI (vessel.orbit.vel.magnitude) + "m/s" + " Obt Vel: " + Tools.MuMech_ToSI (vessel.orbit.vel.magnitude) + "m/s" +
"\nAp: " + Tools.MuMech_ToSI (vessel.orbit.ApA) + "m" + "\nAp: " + Tools.MuMech_ToSI (vessel.orbit.ApA) + "m" +
" ETA " + Tools.ConvertInterval (vessel.orbit.timeToAp) + " ETA " + Tools.ConvertInterval (vessel.orbit.timeToAp) +
"\nPe: " + Tools.MuMech_ToSI (vessel.orbit.PeA) + "m" + "\nPe: " + Tools.MuMech_ToSI (vessel.orbit.PeA) + "m" +
" ETA " + Tools.ConvertInterval (vessel.orbit.timeToPe) + " ETA " + Tools.ConvertInterval (vessel.orbit.timeToPe) +
"\nInc: " + vessel.orbit.inclination.ToString ("F3") + "°", "\nInc: " + vessel.orbit.inclination.ToString ("F3") + "°",
labelStyle); labelStyle);
// Toadicus edit: Added "Biome: " line to surf/atmo HUD // Toadicus edit: Added "Biome: " line to surf/atmo HUD
GUI.Label ( GUI.Label (
new Rect ((Screen.width * .625f), 0, 300f, 90f), new Rect ((Screen.width * .625f), 0, 300f, 90f),
"Srf Alt: " + Tools.MuMech_ToSI (Tools.TrueAltitude (vessel)) + "m" + "Srf Alt: " + Tools.MuMech_ToSI (Tools.TrueAltitude (vessel)) + "m" +
" Srf Vel: " + Tools.MuMech_ToSI (vessel.srf_velocity.magnitude) + "m/s" + " Srf Vel: " + Tools.MuMech_ToSI (vessel.srf_velocity.magnitude) + "m/s" +
"\nVer: " + Tools.MuMech_ToSI (vessel.verticalSpeed) + "m/s" + "\nVer: " + Tools.MuMech_ToSI (vessel.verticalSpeed) + "m/s" +
" Hor: " + Tools.MuMech_ToSI (vessel.horizontalSrfSpeed) + "m/s" + " Hor: " + Tools.MuMech_ToSI (vessel.horizontalSrfSpeed) + "m/s" +
"\nLat: " + Tools.GetLatitudeString (vessel, "F3") + "\nLat: " + Tools.GetLatitudeString (vessel, "F3") +
" Lon: " + Tools.GetLongitudeString (vessel, "F3") + " Lon: " + Tools.GetLongitudeString (vessel, "F3") +
"\nHdg: " + Tools.MuMech_get_heading (vessel).ToString ("F2") + "° " + "\nHdg: " + Tools.MuMech_get_heading (vessel).ToString ("F2") + "° " +
Tools.get_heading_text (Tools.MuMech_get_heading (vessel)) + Tools.get_heading_text (Tools.MuMech_get_heading (vessel)) +
"\nBiome: " + Tools.Toadicus_GetAtt (vessel).name, "\nBiome: " + Tools.Toadicus_GetAtt (vessel).name,
labelStyle); labelStyle);
} }
else else
{ {
labelStyle.normal.textColor = Color.red; labelStyle.normal.textColor = Color.red;
GUI.Label (new Rect ((Screen.width * .2083f), 0, 300f, 70f), "-- POWER LOST --", labelStyle); GUI.Label (new Rect ((Screen.width * .2083f), 0, 300f, 70f), "-- POWER LOST --", labelStyle);
GUI.Label (new Rect ((Screen.width * .625f), 0, 300f, 70f), "-- POWER LOST --", labelStyle); GUI.Label (new Rect ((Screen.width * .625f), 0, 300f, 70f), "-- POWER LOST --", labelStyle);
} }
} }
   
public override void DrawConfigurables() public override void DrawConfigurables()
{ {
if (GUILayout.Button ("Change HUD color", GUILayout.ExpandWidth (false))) if (GUILayout.Button ("Change HUD color", GUILayout.ExpandWidth (false)))
{ {
++this.ColorIndex; ++this.ColorIndex;
} }
} }
} }
} }
   
// //
// VOID_Module.cs // VOID_Module.cs
// //
// Author: // Author:
// toadicus <> // toadicus <>
// //
// Copyright (c) 2013 toadicus // Copyright (c) 2013 toadicus
// //
// This program is free software: you can redistribute it and/or modify // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// This program is distributed in the hope that it will be useful, // This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details. // GNU General Public License for more details.
// //
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using System.Reflection; using System.Reflection;
  using UnityEngine;
   
namespace VOID namespace VOID
{ {
public abstract class VOID_Module : IVOID_Module public abstract class VOID_Module : IVOID_Module
{ {
/* /*
* Fields * Fields
* */ * */
[AVOID_SaveValue("Active")] [AVOID_SaveValue("Active")]
protected VOID_SaveValue<bool> _Active = true; protected VOID_SaveValue<bool> _Active = true;
protected bool _Running = false; protected bool _Running = false;
protected bool _hasConfigurables = false;  
   
protected string _Name; protected string _Name;
   
/* /*
* Properties * Properties
* */ * */
public virtual bool hasConfigurables  
{  
get  
{  
return this._hasConfigurables;  
}  
}  
   
public virtual bool toggleActive public virtual bool toggleActive
{ {
get get
{ {
return this._Active; return this._Active;
} }
set set
{ {
this._Active = value; this._Active = value;
} }
} }
   
public virtual bool guiRunning public virtual bool guiRunning
{ {
get get
{ {
return this._Running; return this._Running;
} }
} }
   
public virtual string Name public virtual string Name
{ {
get get
{ {
return this._Name; return this._Name;
  }
  }
   
  public virtual Vessel vessel
  {
  get
  {
  return FlightGlobals.ActiveVessel;
} }
} }
   
/* /*
* Methods * Methods
* */ * */
public void StartGUI() public void StartGUI()
{ {
if (!this.toggleActive) if (!this.toggleActive)
{ {
return; return;
} }
   
Tools.PostDebugMessage (string.Format("Adding {0} to the draw queue.", this.GetType().Name)); Tools.PostDebugMessage (string.Format("Adding {0} to the draw queue.", this.GetType().Name));
RenderingManager.AddToPostDrawQueue (3, this.DrawGUI); RenderingManager.AddToPostDrawQueue (3, this.DrawGUI);
this._Running = true; this._Running = true;
} }
   
public void StopGUI() public void StopGUI()
{ {
Tools.PostDebugMessage (string.Format("Removing {0} from the draw queue.", this.GetType().Name)); Tools.PostDebugMessage (string.Format("Removing {0} from the draw queue.", this.GetType().Name));
RenderingManager.RemoveFromPostDrawQueue (3, this.DrawGUI); RenderingManager.RemoveFromPostDrawQueue (3, this.DrawGUI);
this._Running = false; this._Running = false;
} }
   
public abstract void DrawGUI(); public abstract void DrawGUI();
   
public virtual void DrawConfigurables() {} public virtual void DrawConfigurables() {}
   
public virtual void LoadConfig() public virtual void LoadConfig()
{ {
var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> (); var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> ();
config.load (); config.load ();
   
foreach (var field in this.GetType().GetFields( foreach (var field in this.GetType().GetFields(
BindingFlags.NonPublic | BindingFlags.NonPublic |
BindingFlags.Public | BindingFlags.Public |
BindingFlags.Instance BindingFlags.Instance |
  BindingFlags.FlattenHierarchy
)) ))
{ {
object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false); object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false);
   
if (attrs.Length == 0) { if (attrs.Length == 0) {
return; continue;
} }
   
AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue; AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue;
   
string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name); string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name);
   
object fieldValue = field.GetValue(this); object fieldValue = field.GetValue(this);
   
bool convertBack = false; bool convertBack = false;
if (fieldValue is IVOID_SaveValue) if (fieldValue is IVOID_SaveValue)
{ {
fieldValue = (fieldValue as IVOID_SaveValue).AsType; fieldValue = (fieldValue as IVOID_SaveValue).AsType;
convertBack = true; convertBack = true;
} }
   
fieldValue = config.GetValue(fieldName, fieldValue); fieldValue = config.GetValue(fieldName, fieldValue);
   
if (convertBack) if (convertBack)
{ {
Type type = typeof(VOID_SaveValue<>).MakeGenericType (fieldValue.GetType ()); Type type = typeof(VOID_SaveValue<>).MakeGenericType (fieldValue.GetType ());
IVOID_SaveValue convertValue = Activator.CreateInstance (type) as IVOID_SaveValue; IVOID_SaveValue convertValue = Activator.CreateInstance (type) as IVOID_SaveValue;
convertValue.SetValue (fieldValue); convertValue.SetValue (fieldValue);
fieldValue = convertValue; fieldValue = convertValue;
} }
   
field.SetValue (this, fieldValue); field.SetValue (this, fieldValue);
   
Tools.PostDebugMessage(string.Format("{0}: Loaded field {1}.", this.GetType().Name, fieldName)); Tools.PostDebugMessage(string.Format("{0}: Loaded field {1}.", this.GetType().Name, fieldName));
} }
} }
   
public virtual void SaveConfig() public virtual void _SaveToConfig(KSP.IO.PluginConfiguration config)
{ {
if (!VOID_Core.Instance.configDirty)  
{  
return;  
}  
   
var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> ();  
config.load ();  
   
foreach (var field in this.GetType().GetFields( foreach (var field in this.GetType().GetFields(
  BindingFlags.Instance |
BindingFlags.NonPublic | BindingFlags.NonPublic |
BindingFlags.Public | BindingFlags.Public |
BindingFlags.Instance BindingFlags.FlattenHierarchy
)) ))
{ {
object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false); object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false);
   
if (attrs.Length == 0) { if (attrs.Length == 0) {
return; continue;
} }
   
AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue; AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue;
   
string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name); string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name);
   
object fieldValue = field.GetValue(this); object fieldValue = field.GetValue(this);
   
if (fieldValue is IVOID_SaveValue) if (fieldValue is IVOID_SaveValue)
{ {
fieldValue = (fieldValue as IVOID_SaveValue).AsType; fieldValue = (fieldValue as IVOID_SaveValue).AsType;
} }
   
config.SetValue(fieldName, fieldValue); config.SetValue(fieldName, fieldValue);
   
Tools.PostDebugMessage(string.Format("{0}: Saved field {1}.", this.GetType().Name, fieldName)); Tools.PostDebugMessage(string.Format("{0}: Saved field {1}.", this.GetType().Name, fieldName));
} }
  }
config.save (); }
   
  public abstract class VOID_WindowModule : VOID_Module
  {
  [AVOID_SaveValue("WindowPos")]
  protected Rect WindowPos = new Rect(Screen.width / 2, Screen.height / 2, 10f, 10f);
   
  public abstract void ModuleWindow(int _);
   
  public override void DrawGUI()
  {
  Rect _Pos = this.WindowPos;
   
  _Pos = GUILayout.Window(
  VOID_Core.Instance.windowID,
  _Pos,
  this.ModuleWindow,
  this.Name, GUILayout.Width(250),
  GUILayout.Height(50));
   
  if (_Pos != this.WindowPos)
  {
  this.WindowPos = _Pos;
  VOID_Core.Instance.configDirty = true;
  }
} }
} }
} }
   
   
file:b/VOID_Orbital.cs (new)
  //
  // VOID_Orbital.cs
  //
  // Author:
  // toadicus <>
  //
  // Copyright (c) 2013 toadicus
  //
  // This program is free software: you can redistribute it and/or modify
  // it under the terms of the GNU General Public License as published by
  // 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,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program. If not, see <http://www.gnu.org/licenses/>.
  using KSP;
  using System;
  using UnityEngine;
 
  namespace VOID
  {
  public class VOID_Orbital : VOID_WindowModule
  {
  [AVOID_SaveValue("toggleExtended")]
  protected VOID_SaveValue<bool> toggleExtended = false;
 
  public VOID_Orbital()
  {
  this._Name = "Orbital Information";
  }
 
  public override void ModuleWindow(int _)
  {
  // Toadicus edit: added local sidereal longitude.
  double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle;
  LSL = Tools.FixDegreeDomain (LSL);
 
  GUILayout.BeginVertical();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(VOIDLabels.void_primary + ":");
  GUILayout.Label(vessel.mainBody.bodyName, GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(VOIDLabels.void_altitude_asl + ":");
  GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.altitude) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(VOIDLabels.void_velocity + ":");
  GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(VOIDLabels.void_apoapsis + ":");
  GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.ApA) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Time to Ap:");
  GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToAp), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(VOIDLabels.void_periapsis + ":");
  GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.PeA) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Time to Pe:");
  GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToPe), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Inclination:");
  GUILayout.Label(vessel.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass());
  double g_vessel = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2);
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Gravity:");
  GUILayout.Label(Tools.MuMech_ToSI(g_vessel) + "m/s²", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  this.toggleExtended = GUILayout.Toggle(this.toggleExtended, "Extended info");
 
  if (this.toggleExtended)
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Period:");
  GUILayout.Label(Tools.ConvertInterval(vessel.orbit.period), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Semi-major axis:");
  GUILayout.Label((vessel.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Eccentricity:");
  GUILayout.Label(vessel.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  // Toadicus edit: convert mean anomaly into degrees.
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Mean anomaly:");
  GUILayout.Label((vessel.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("True anomaly:");
  GUILayout.Label(vessel.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  // Toadicus edit: convert eccentric anomaly into degrees.
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Eccentric anomaly:");
  GUILayout.Label((vessel.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Long. ascending node:");
  GUILayout.Label(vessel.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Arg. of periapsis:");
  GUILayout.Label(vessel.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  // Toadicus edit: added local sidereal longitude.
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Local Sidereal Longitude:");
  GUILayout.Label(LSL.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"]);
  GUILayout.EndHorizontal();
  }
 
  GUILayout.EndVertical();
  GUI.DragWindow();
  }
  }
  }
 
 
  //
  // VOID_Orbital.cs
  //
  // Author:
  // toadicus <>
  //
  // Copyright (c) 2013 toadicus
  //
  // This program is free software: you can redistribute it and/or modify
  // it under the terms of the GNU General Public License as published by
  // 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,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program. If not, see <http://www.gnu.org/licenses/>.
  using KSP;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using UnityEngine;
 
  namespace VOID
  {
  public class VOID_Rendezvous : VOID_WindowModule
  {
  [AVOID_SaveValue("untoggleRegisterInfo")]
  protected VOID_SaveValue<bool> untoggleRegisterInfo = false;
 
  [AVOID_SaveValue("toggleExtendedOrbital")]
  protected VOID_SaveValue<bool> toggleExtendedOrbital = false;
 
  protected VOID_VesselRegister RegisterModule;
 
  public VOID_Rendezvous()
  {
  this._Name = "Rendezvous Information";
  }
 
  public override void ModuleWindow(int _)
  {
  Vessel rendezvessel = new Vessel();
  CelestialBody rendezbody = new CelestialBody();
 
  this.RegisterModule = VOID_Core.Instance.Modules.Where(m => typeof(VOID_VesselRegister).IsAssignableFrom(m.GetType())).FirstOrDefault() as VOID_VesselRegister;
 
  GUILayout.BeginVertical();
 
  //display both
  //Show Target Info
  GUILayout.Label("Target:", VOID_Core.Instance.LabelStyles["center_bold"]);
  if (FlightGlobals.fetch.VesselTarget != null)
  {
  //a KSP Target (body or vessel) is selected
  if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.Direction)
  {
  //a Body is selected
  rendezbody = vessel.patchedConicSolver.targetBody;
  display_rendezvous_info(null, rendezbody);
  }
  else if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.DirectionAndVelocity)
  {
  //a Vessel is selected
  rendezvessel = FlightGlobals.fetch.VesselTarget.GetVessel();
  display_rendezvous_info(rendezvessel, null);
  }
  //Show Unset button for both options above
  if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false)))
  {
  FlightGlobals.fetch.SetVesselTarget(null);
  Tools.PostDebugMessage("VOID_Rendezvous: KSP Target set to null");
  }
 
  }
  else
  {
  //no KSP Target selected
  GUILayout.Label("No Target Selected", VOID_Core.Instance.LabelStyles["center_bold"]);
  }
 
  //Show Vessel Register vessel info
  if (untoggleRegisterInfo == false && this.RegisterModule != default(IVOID_Module))
  {
  GUILayout.Label("Vessel Register:", VOID_Core.Instance.LabelStyles["center_bold"]);
  if (this.RegisterModule.selectedVessel != null)
  {
  rendezvessel = this.RegisterModule.selectedVessel;
  display_rendezvous_info(rendezvessel, null);
 
  //show set/unset buttons
  if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != this.RegisterModule.selectedVessel))
  {
  //no Tgt set or Tgt is not this vessel
  //show a Set button
  if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))
  {
  FlightGlobals.fetch.SetVesselTarget(rendezvessel);
  Tools.PostDebugMessage("[VOID] KSP Target set to " + rendezvessel.vesselName);
  }
  }
  }
  else
  {
  //vesreg Vessel is null
  //targ = null;
  GUILayout.Label("No Vessel Selected", VOID_Core.Instance.LabelStyles["center_bold"]);
  }
  }
 
  untoggleRegisterInfo = GUILayout.Toggle(untoggleRegisterInfo, "Hide Vessel Register Info");
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(" ", GUILayout.ExpandWidth(true));
  if (GUILayout.Button("Close", GUILayout.ExpandWidth(false))) this._Active = false;
  GUILayout.EndHorizontal();
 
  GUILayout.EndVertical();
  GUI.DragWindow();
  }
 
  private void display_rendezvous_info(Vessel v, CelestialBody cb)
  {
  if (cb == null && v != null)
  {
  //Display vessel rendezvous info
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(v.vesselName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true));
  GUILayout.EndHorizontal();
 
  if (v.situation == Vessel.Situations.ESCAPING || v.situation == Vessel.Situations.FLYING || v.situation == Vessel.Situations.ORBITING || v.situation == Vessel.Situations.SUB_ORBITAL)
  {
  // Toadicus edit: added local sidereal longitude.
  // Toadicus edit: added local sidereal longitude.
  double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle;
  LSL = Tools.FixDegreeDomain (LSL);
 
  //display orbital info for orbiting/flying/suborbital/escaping vessels only
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Ap/Pe:");
  GUILayout.Label(Tools.MuMech_ToSI(v.orbit.ApA) + "m / " + Tools.MuMech_ToSI(v.orbit.PeA) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Altitude:");
  GUILayout.Label(Tools.MuMech_ToSI(v.orbit.altitude) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Inclination:");
  GUILayout.Label(v.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  if (vessel.mainBody == v.mainBody)
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Relative inclination:");
  GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), v.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  }
  //if (debugging) Debug.Log("[CHATR] v -> v relative incl OK");
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Velocity:");
  GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Relative velocity:");
  GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude - vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Distance:");
  GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  //target_vessel_extended_orbital_info = GUILayout.Toggle(target_vessel_extended_orbital_info, "Extended info");
 
  if (toggleExtendedOrbital)
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Period:");
  GUILayout.Label(Tools.ConvertInterval(v.orbit.period), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Semi-major axis:");
  GUILayout.Label((v.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Eccentricity:");
  GUILayout.Label(v.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  // Toadicus edit: convert mean anomaly into degrees.
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Mean anomaly:");
  GUILayout.Label((v.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("True anomaly:");
  GUILayout.Label(v.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  // Toadicus edit: convert eccentric anomaly into degrees.
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Eccentric anomaly:");
  GUILayout.Label((v.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Long. ascending node:");
  GUILayout.Label(v.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Arg. of periapsis:");
  GUILayout.Label(v.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  // Toadicus edit: added local sidereal longitude.
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Local Sidereal Longitude:");
  GUILayout.Label(LSL.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"]);
  GUILayout.EndHorizontal();
  }
  }
  else
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Latitude:");
  GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Longitude:");
  GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Distance:");
  GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  }
  }
  else if (cb != null && v == null)
  {
  //Display CelstialBody rendezvous info
  GUILayout.Label(cb.bodyName, VOID_Core.Instance.LabelStyles["center_bold"]);
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Ap/Pe:");
  GUILayout.Label(Tools.MuMech_ToSI(cb.orbit.ApA) + "m / " + Tools.MuMech_ToSI(cb.orbit.PeA) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  //if (debugging) Debug.Log("[VOID] Ap/Pe OK");
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Inclination:");
  GUILayout.Label(cb.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  //if (debugging) Debug.Log("[VOID] Inclination OK");
 
  if (cb.referenceBody == vessel.mainBody)
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Relative inclination:");
  GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), cb.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  //if (debugging) Debug.Log("[VOID] cb Relative inclination OK");
  }
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Distance:");
  GUILayout.Label(Tools.MuMech_ToSI((vessel.mainBody.position - cb.position).magnitude) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  //if (debugging) Debug.Log("[VOID] Distance OK");
 
  //SUN2PLANET:
  if (vessel.mainBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)
  {
  Tools.display_transfer_angles_SUN2PLANET(cb, vessel);
  //if (debugging) Debug.Log("[VOID] SUN2PLANET OK");
  }
 
  //PLANET2PLANET
  else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)
  {
  Tools.display_transfer_angles_PLANET2PLANET(cb, vessel);
  //if (debugging) Debug.Log("[VOID] PLANET2PLANET OK");
  }
 
  //PLANET2MOON
  else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)
  {
  Tools.display_transfer_angles_PLANET2MOON(cb, vessel);
  //if (debugging) Debug.Log("[VOID] PLANET2MOON OK");
  }
 
  //MOON2MOON
  else if (vessel.mainBody.referenceBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)
  {
  Tools.display_transfer_angles_MOON2MOON(cb, vessel);
  //if (debugging) Debug.Log("[VOID] MOON2MOON OK");
  }
 
  //else GUILayout.Label("Transfer angle information\nunavailable for this target");
 
  }
  }
  }
  }
file:b/VOID_SurfAtmo.cs (new)
  //
  // VOID_Orbital.cs
  //
  // Author:
  // toadicus <>
  //
  // Copyright (c) 2013 toadicus
  //
  // This program is free software: you can redistribute it and/or modify
  // it under the terms of the GNU General Public License as published by
  // 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,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program. If not, see <http://www.gnu.org/licenses/>.
  using KSP;
  using System;
  using UnityEngine;
 
  namespace VOID
  {
  public class VOID_SurfAtmo : VOID_WindowModule
  {
  public VOID_SurfAtmo()
  {
  this._Name = "Surface & Atmospheric Information";
  }
 
  public override void ModuleWindow(int _)
  {
  GUILayout.BeginVertical();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Altitude (true):");
  double alt_true = vessel.orbit.altitude - vessel.terrainAltitude;
  // HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m.
  if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean ) alt_true = vessel.orbit.altitude;
  GUILayout.Label(Tools.MuMech_ToSI(alt_true) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal ();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Latitude:");
  GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Longitude:");
  GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Heading:");
  GUILayout.Label(Tools.MuMech_get_heading(vessel).ToString("F2") + "° " + Tools.get_heading_text(Tools.MuMech_get_heading(vessel)), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Terrain elevation:");
  GUILayout.Label(Tools.MuMech_ToSI(vessel.terrainAltitude) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Surface velocity:");
  GUILayout.Label(Tools.MuMech_ToSI(vessel.srf_velocity.magnitude) + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Vertical speed:");
  GUILayout.Label(Tools.MuMech_ToSI(vessel.verticalSpeed) + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Horizontal speed:");
  GUILayout.Label(Tools.MuMech_ToSI(vessel.horizontalSrfSpeed) + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Temperature:");
  GUILayout.Label(vessel.flightIntegrator.getExternalTemperature().ToString("F2") + "° C", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Atmosphere density:");
  GUILayout.Label(Tools.MuMech_ToSI(vessel.atmDensity * 1000) + "g/m³", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Pressure:");
  GUILayout.Label(vessel.staticPressure.ToString("F2") + " atms", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Atmosphere limit:");
  GUILayout.Label("≈ " + Tools.MuMech_ToSI(vessel.mainBody.maxAtmosphereAltitude) + "m", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  // Toadicus edit: added Biome
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Biome:");
  GUILayout.Label(Tools.Toadicus_GetAtt(vessel).name, VOID_Core.Instance.LabelStyles["txt_right"]);
  GUILayout.EndHorizontal();
 
  GUILayout.EndVertical();
  GUI.DragWindow();
  }
  }
  }
file:b/VOID_Transfer.cs (new)
  //
  // VOID_Orbital.cs
  //
  // Author:
  // toadicus <>
  //
  // Copyright (c) 2013 toadicus
  //
  // This program is free software: you can redistribute it and/or modify
  // it under the terms of the GNU General Public License as published by
  // 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,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program. If not, see <http://www.gnu.org/licenses/>.
  using KSP;
  using System;
  using System.Collections.Generic;
  using UnityEngine;
 
  namespace VOID
  {
  public class VOID_Transfer : VOID_WindowModule
  {
  [AVOID_SaveValue("toggleExtended")]
  protected VOID_SaveValue<bool> toggleExtended = false;
 
  protected List<CelestialBody> selectedBodies = new List<CelestialBody>();
 
  public VOID_Transfer()
  {
  this._Name = "Transfer Angle Information";
  }
 
  public override void ModuleWindow(int _)
  {
  GUILayout.BeginVertical();
 
  if (vessel.mainBody.name == "Sun") //Vessel is orbiting the Sun
  {
  foreach (CelestialBody body in vessel.mainBody.orbitingBodies)
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button(body.bodyName))
  {
  //add or remove this body to this list of bodies to display more info on
  if (selectedBodies.Contains(body)) selectedBodies.Remove(body);
  else selectedBodies.Add(body);
  }
  GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  if (selectedBodies.Contains(body))
  {
  Tools.display_transfer_angles_SUN2PLANET(body, vessel); //show phase angles for each selected body
  tad_targeting(body); //display Set/Unset Target button for each selected body
  }
  }
  }
  else if (vessel.mainBody.referenceBody.name == "Sun") //Vessel is orbiting a planet
  {
  foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies)
  {
  if (body.name != vessel.mainBody.name) // show other planets
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button(body.bodyName))
  {
  //add or remove this body to this list of bodies to display more info on
  if (selectedBodies.Contains(body)) selectedBodies.Remove(body);
  else selectedBodies.Add(body);
  }
  GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  if (selectedBodies.Contains(body))
  {
  Tools.display_transfer_angles_PLANET2PLANET(body, vessel);
  tad_targeting(body); //display Set/Unset Target button
  }
  }
  }
  foreach (CelestialBody body in vessel.mainBody.orbitingBodies) // show moons
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button(body.bodyName))
  {
  //add or remove this body to this list of bodies to display more info on
  if (selectedBodies.Contains(body)) selectedBodies.Remove(body);
  else selectedBodies.Add(body);
  }
  GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  if (selectedBodies.Contains(body))
  {
  Tools.display_transfer_angles_PLANET2MOON(body, vessel);
  tad_targeting(body); //display Set/Unset Target button
  }
  }
  }
  else if (vessel.mainBody.referenceBody.referenceBody.name == "Sun") // Vessel is orbiting a moon
  {
  foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies)
  {
  if (body.name != vessel.mainBody.name) // show other moons
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button(body.bodyName))
  {
  //add or remove this body to this list of bodies to display more info on
  if (selectedBodies.Contains(body)) selectedBodies.Remove(body);
  else selectedBodies.Add(body);
  }
  GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  if (selectedBodies.Contains(body))
  {
  Tools.display_transfer_angles_MOON2MOON(body, vessel);
  tad_targeting(body); //display Set/Unset Target button
  }
  }
  }
  }
  GUILayout.EndVertical();
  GUI.DragWindow();
  }
 
  private void tad_targeting(CelestialBody body)
  {
  //Target Set/Unset buttons
  if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() == null))
  {
  //No TGT set or TGT is a Body
  if ((CelestialBody)FlightGlobals.fetch.VesselTarget != body)
  {
  if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))
  {
  FlightGlobals.fetch.SetVesselTarget(body);
  Tools.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName);
  }
  }
  else if ((CelestialBody)FlightGlobals.fetch.VesselTarget == body)
  {
  if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false)))
  {
  FlightGlobals.fetch.SetVesselTarget(null);
  Tools.PostDebugMessage("[VOID] KSP Target set to null");
  }
  }
  }
  else if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != null))
  {
  //No TGT or TGT is a vessel
  if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))
  {
  FlightGlobals.fetch.SetVesselTarget(body);
  Tools.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName);
  }
  }
  }
  }
  }
 
 
  //
  // VOID_Orbital.cs
  //
  // Author:
  // toadicus <>
  //
  // Copyright (c) 2013 toadicus
  //
  // This program is free software: you can redistribute it and/or modify
  // it under the terms of the GNU General Public License as published by
  // 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,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program. If not, see <http://www.gnu.org/licenses/>.
  using KSP;
  using System;
  using UnityEngine;
 
  namespace VOID
  {
  public class VOID_VesselInfo : VOID_WindowModule
  {
  [AVOID_SaveValue("toggleExtended")]
  protected VOID_SaveValue<bool> toggleExtended = false;
 
  public VOID_VesselInfo()
  {
  this._Name = "Vessel Information";
  }
 
  public override void ModuleWindow(int _)
  {
  if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))
  {
  Engineer.VesselSimulator.SimManager.Instance.RequestSimulation();
  }
 
  Engineer.VesselSimulator.Stage[] stages = Engineer.VesselSimulator.SimManager.Instance.Stages;
 
  GUILayout.BeginVertical();
 
  GUILayout.Label(vessel.vesselName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true));
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("G-force:");
  GUILayout.Label(vessel.geeForce.ToString("F2") + " gees", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  int num_parts = 0;
  double total_mass = vessel.GetTotalMass();
  double resource_mass = 0;
  double max_thrust = 0;
  double final_thrust = 0;
 
  foreach (Part p in vessel.parts)
  {
  num_parts++;
  resource_mass += p.GetResourceMass();
 
  foreach (PartModule pm in p.Modules)
  {
  if ((pm.moduleName == "ModuleEngines") && ((p.State == PartStates.ACTIVE) || ((Staging.CurrentStage > Staging.lastStage) && (p.inverseStage == Staging.lastStage))))
  {
  max_thrust += ((ModuleEngines)pm).maxThrust;
  final_thrust += ((ModuleEngines)pm).finalThrust;
  }
  }
  }
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Parts:");
  GUILayout.Label(num_parts.ToString("F0"), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Total mass:");
  GUILayout.Label(total_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Resource mass:");
  GUILayout.Label(resource_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  if (stages.Length > Staging.lastStage)
  {
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("DeltaV (Current Stage):");
  GUILayout.Label(Tools.MuMech_ToSI(stages[Staging.lastStage].deltaV).ToString() + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  }
 
  if (stages.Length > 0)
  {
  double totalDeltaV = 0d;
 
  for (int i = 0; i < stages.Length; ++i)
  {
  totalDeltaV += stages [i].deltaV;
  }
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("DeltaV (Total):");
  GUILayout.Label(Tools.MuMech_ToSI(totalDeltaV).ToString() + "m/s", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
  }
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Throttle:");
  GUILayout.Label((vessel.ctrlState.mainThrottle * 100f).ToString("F0") + "%", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Thrust (curr/max):");
  GUILayout.Label(final_thrust.ToString("F1") + " / " + max_thrust.ToString("F1") + " kN", GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  double gravity = vessel.mainBody.gravParameter / Math.Pow(vessel.mainBody.Radius + vessel.altitude, 2);
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("T:W (curr/max):");
  GUILayout.Label((final_thrust / (total_mass * gravity)).ToString("F2") + " / " + (max_thrust / (total_mass * gravity)).ToString("F2"), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  double g_ASL = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(vessel.mainBody.Radius, 2);
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label("Max T:W @ surface:");
  GUILayout.Label((max_thrust / (total_mass * g_ASL)).ToString("F2"), GUILayout.ExpandWidth(false));
  GUILayout.EndHorizontal();
 
  GUILayout.EndVertical();
  GUI.DragWindow();
  }
  }
  }
 
 
  //
  // VOID_Orbital.cs
  //
  // Author:
  // toadicus <>
  //
  // Copyright (c) 2013 toadicus
  //
  // This program is free software: you can redistribute it and/or modify
  // it under the terms of the GNU General Public License as published by
  // 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,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program. If not, see <http://www.gnu.org/licenses/>.
  using KSP;
  using System;
  using System.Linq;
  using UnityEngine;
 
  namespace VOID
  {
  public class VOID_VesselRegister : VOID_WindowModule
  {
  [AVOID_SaveValue("selectedBodyIdx")]
  protected VOID_SaveValue<int> selectedBodyIdx = 0;
  protected CelestialBody seletedBody;
 
  [AVOID_SaveValue("selectedVesselTypeIdx")]
  protected VOID_SaveValue<int> selectedVesselTypeIdx = 0;
  protected VesselType selectedVesselType;
 
  protected string vesselSituation = "Orbiting";
 
  protected Vector2 selectorScrollPos = new Vector2();
 
  protected Vessel _selectedVessel;
 
  public Vessel selectedVessel
  {
  get
  {
  return this._selectedVessel;
  }
  }
 
  public VOID_VesselRegister()
  {
  this._Name = "Vessel Register";
  }
 
  public override void ModuleWindow(int _)
  {
  if (!VOID_Core.Instance.allVesselTypes.Any())
  {
  return;
  }
 
  GUILayout.BeginVertical();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button("<"))
  {
  selectedBodyIdx--;
  if (selectedBodyIdx < 0) selectedBodyIdx = VOID_Core.Instance.allBodies.Count - 1;
  }
  GUILayout.Label(VOID_Core.Instance.allBodies[selectedBodyIdx].bodyName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true));
  if (GUILayout.Button(">"))
  {
  selectedBodyIdx++;
  if (selectedBodyIdx > VOID_Core.Instance.allBodies.Count - 1) selectedBodyIdx = 0;
  }
  GUILayout.EndHorizontal();
 
  seletedBody = VOID_Core.Instance.allBodies[selectedBodyIdx];
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button("<"))
  {
  selectedVesselTypeIdx--;
  if (selectedVesselTypeIdx < 0) selectedVesselTypeIdx = VOID_Core.Instance.allVesselTypes.Count - 1;
  }
  GUILayout.Label(VOID_Core.Instance.allVesselTypes[selectedVesselTypeIdx].ToString(), VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true));
  if (GUILayout.Button(">"))
  {
  selectedVesselTypeIdx++;
  if (selectedVesselTypeIdx > VOID_Core.Instance.allVesselTypes.Count - 1) selectedVesselTypeIdx = 0;
  }
  GUILayout.EndHorizontal();
 
  selectedVesselType = VOID_Core.Instance.allVesselTypes[selectedVesselTypeIdx];
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  if (GUILayout.Button("Landed", GUILayout.ExpandWidth(true))) vesselSituation = "Landed";
  if (GUILayout.Button("Orbiting", GUILayout.ExpandWidth(true))) vesselSituation = "Orbiting";
  GUILayout.EndHorizontal();
 
  GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
  GUILayout.Label(
  Tools.UppercaseFirst(vesselSituation) + " " + selectedVesselType.ToString() + "s @ " + seletedBody.bodyName,
  VOID_Core.Instance.LabelStyles["center"],
  GUILayout.ExpandWidth(true));
  GUILayout.EndHorizontal();
 
  selectorScrollPos = GUILayout.BeginScrollView(selectorScrollPos, false, false);
 
  foreach (Vessel v in FlightGlobals.Vessels)
  {
  if (v != vessel && v.vesselType == selectedVesselType && v.mainBody == seletedBody)
  {
  if ((vesselSituation == "Landed" &&
  (v.situation == Vessel.Situations.LANDED ||
  v.situation == Vessel.Situations.PRELAUNCH ||
  v.situation == Vessel.Situations.SPLASHED)) ||
  (vesselSituation == "Orbiting" &&
  (v.situation == Vessel.Situations.ESCAPING ||
  v.situation == Vessel.Situations.FLYING ||
  v.situation == Vessel.Situations.ORBITING ||
  v.situation == Vessel.Situations.SUB_ORBITAL))
  )
  {
  if (GUILayout.Button(v.vesselName, GUILayout.ExpandWidth(true)))
  {
  if (_selectedVessel != v)
  {
  _selectedVessel = v; //set clicked vessel as selected_vessel
  this._Active = true; //turn bool on to open the window if closed
  }
  else
  {
  _selectedVessel = null;
  }
  }
  }
  }
  }
 
  GUILayout.EndScrollView();
 
  GUILayout.EndVertical();
 
  GUI.DragWindow();
  }
  }
  }