ToadGIT :: VOID.git/commitdiff

Major Surgery to change to the new copy-on-update access method for KER.

30 files changed: (show all)
IVOID_Module.cs
IntCollection.cs (deleted)
Properties/AssemblyInfo.cs (new)
Tools.cs (deleted)
VOID.csproj (new)
VOIDEditorMaster.cs
VOIDFlightMaster.cs
VOID_CBInfoBrowser.cs
VOID_CareerStatus.cs (new)
VOID_Core.cs
VOID_DataLogger.cs
VOID_DataValue.cs
VOID_EditorCore.cs
VOID_EditorHUD.cs
VOID_HUD.cs
VOID_HUDAdvanced.cs (new)
VOID_Localization.cs (new)
VOID_Module.cs
VOID_Orbital.cs
VOID_Rendezvous.cs
VOID_SaveValue.cs
VOID_SurfAtmo.cs
VOID_TWR.cs (new)
VOID_Tools.cs (new)
VOID_Transfer.cs
VOID_VesselInfo.cs
VOID_VesselRegister.cs
Wrapper/Properties/AssemblyInfo.cs (deleted)
Wrapper/ToolbarWrapper.cs (deleted)
Wrapper/Wrapper.csproj (deleted)

file:a/IVOID_Module.cs -> file:b/IVOID_Module.cs

	// VOID
//	//
// IVOID_Module.cs	// IVOID_Module.cs
//	//
// Author:	// Copyright © 2014, toadicus
// toadicus <>	// All rights reserved.
//	//
// Copyright (c) 2013 toadicus	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
//	//
// This program is free software: you can redistribute it and/or modify	// 1. Redistributions of source code must retain the above copyright notice,
// it under the terms of the GNU General Public License as published by	// this list of conditions and the following disclaimer.
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using System;	using System;

namespace VOID	namespace VOID
{	{
public interface IVOID_Module	public interface IVOID_Module
{	{
string Name { get; }	string Name { 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 _SaveToConfig(KSP.IO.PluginConfiguration config);	void _SaveToConfig(KSP.IO.PluginConfiguration config);
}	}

public interface IVOID_BehaviorModule : IVOID_Module	public interface IVOID_BehaviorModule : IVOID_Module
{	{
void Update();	void Update();
void FixedUpdate();	void FixedUpdate();
}	}

public interface IVOID_EditorModule : IVOID_Module {}	public interface IVOID_EditorModule : IVOID_Module {}
}	}

file:a/IntCollection.cs (deleted)

//
// IntCollection.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
{
public class IntCollection
{
public static implicit operator long(IntCollection c)
{
return c.collection;
}

protected long mask;

public long collection { get; protected set; }
public ushort maxCount { get; protected set; }
public ushort wordLength { get; protected set; }

public IntCollection (ushort wordLength = 4, long initialCollection = 0)
{
this.collection = initialCollection;
this.wordLength = wordLength;
this.maxCount = (ushort)((sizeof(long) * 8 - 1) / wordLength);
this.mask = ((1 << this.wordLength) - 1);
}

public ushort this[int idx]
{
get {
if (idx < 0) {
idx += this.maxCount;
}

if (idx >= maxCount \|\| idx < 0) {
throw new IndexOutOfRangeException ();
}

idx *= wordLength;

return (ushort)((this.collection & (this.mask << idx)) >> idx);
}
set {
if (idx < 0) {
idx += this.maxCount;
}

if (idx >= maxCount \|\| idx < 0) {
throw new IndexOutOfRangeException ();
}

idx *= wordLength;

long packvalue = value & this.mask;

this.collection &= ~(this.mask << idx);
this.collection \|= packvalue << idx;
}
}
}
}

file:b/Properties/AssemblyInfo.cs (new)

	// VOID
	//
	// AssemblyInfo.cs
	//
	// Copyright © 2014, toadicus
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice,
	// this list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation and/or other
	// materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	using System.Reflection;
	using System.Runtime.CompilerServices;

	[assembly: KSPAssemblyDependency("ToadicusTools", 0, 0)]
	[assembly: KSPAssemblyDependency("VesselSimulator", 0, 0)]

	// Information about this assembly is defined by the following attributes.
	// Change them to the values specific to your project.
	[assembly: AssemblyTitle("VOID")]
	[assembly: AssemblyDescription("A KSP mod that provides at-a-glance information about Vessels, Orbits, and their states.")]
	[assembly: AssemblyCopyright("toadicus")]
	// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
	// The form "{Major}.{Minor}.*" will automatically update the build and revision,
	// and "{Major}.{Minor}.{Build}.*" will update just the revision.
	[assembly: AssemblyVersion("0.14.*")]
	// The following attributes are used to specify the signing key for the assembly,
	// if desired. See the Mono documentation for more information about signing.
	//[assembly: AssemblyDelaySign(false)]
	//[assembly: AssemblyKeyFile("")]

file:a/Tools.cs (deleted)

//
// Tools.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/>.
//
// This software uses VesselSimulator and Engineer.Extensions from Engineer Redux.
// Engineer Redux (c) 2013 cybutek
// Used by permission.
//
///////////////////////////////////////////////////////////////////////////////

using System;
using System.Collections.Generic;
using UnityEngine;

namespace VOID
{
public static class VOIDLabels
{
public static string void_primary = "Primary";
public static string void_altitude_asl = "Altitude (ASL)";
public static string void_velocity = "Velocity";
public static string void_apoapsis = "Apoapsis";
public static string void_periapsis = "Periapsis";
}

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.
public static CBAttributeMap.MapAttribute Toadicus_GetAtt(Vessel vessel)
{
CBAttributeMap.MapAttribute mapAttribute;

try
{
CBAttributeMap BiomeMap = vessel.mainBody.BiomeMap;

double lat = vessel.latitude * Math.PI / 180d;
double lon = vessel.longitude * Math.PI / 180d;

mapAttribute = BiomeMap.GetAtt(lat, lon);

/*
lon -= Math.PI / 2d;

if (lon < 0d)
{
lon += 2d * Math.PI;
}

float v = (float)(lat / Math.PI) + 0.5f;
float u = (float)(lon / (2d * Math.PI));

Color pixelBilinear = BiomeMap.Map.GetPixelBilinear(u, v);
mapAttribute = BiomeMap.defaultAttribute;

if (BiomeMap.Map != null)
{
if (BiomeMap.exactSearch)
{
for (int i = 0; i < BiomeMap.Attributes.Length; ++i)
{
if (pixelBilinear == BiomeMap.Attributes[i].mapColor)
{
mapAttribute = BiomeMap.Attributes[i];
}
}
}
else
{
float zero = 0;
float num = 1 / zero;
for (int j = 0; j < BiomeMap.Attributes.Length; ++j)
{
Color mapColor = BiomeMap.Attributes[j].mapColor;
float sqrMagnitude = ((Vector4)(mapColor - pixelBilinear)).sqrMagnitude;
if (sqrMagnitude < num)
{
bool testCase = true;
if (BiomeMap.nonExactThreshold != -1)
{
testCase = (sqrMagnitude < BiomeMap.nonExactThreshold);
}
if (testCase)
{
mapAttribute = BiomeMap.Attributes[j];
num = sqrMagnitude;
}
}
}
}
}
*/
}
catch (NullReferenceException)
{
mapAttribute = new CBAttributeMap.MapAttribute();
mapAttribute.name = "N/A";
}

return mapAttribute;
}

public static string GetLongitudeString(Vessel vessel, string format = "F4")
{
string dir_long = "W";
double v_long = vessel.longitude;

v_long = FixDegreeDomain(v_long);

if (v_long < -180d)
{
v_long += 360d;
}
if (v_long >= 180)
{
v_long -= 360d;
}

if (v_long > 0)
dir_long = "E";

return string.Format("{0}° {1}", Math.Abs(v_long).ToString(format), dir_long);
}

public static string GetLatitudeString(Vessel vessel, string format = "F4")
{
string dir_lat = "S";
double v_lat = vessel.latitude;
if (v_lat > 0)
dir_lat = "N";

return string.Format("{0}° {1}", Math.Abs(v_lat).ToString(format), dir_lat);
}

/*
* MuMechLib Methods
* The methods below are adapted from MuMechLib, © 2013-2014 r4m0n
* The following methods are a derivative work of the code from MuMechLib in the MechJeb project.
* Used under license.
* */

// Derived from MechJeb2/VesselState.cs
public static Quaternion getSurfaceRotation(this Vessel vessel)
{
Vector3 CoM;

try
{
CoM = vessel.findWorldCenterOfMass();
}
catch
{
return new Quaternion();
}

Vector3 bodyPosition = vessel.mainBody.position;
Vector3 bodyUp = vessel.mainBody.transform.up;

Vector3 surfaceUp = (CoM - vessel.mainBody.position).normalized;
Vector3 surfaceNorth = Vector3.Exclude(
surfaceUp,
(bodyPosition + bodyUp * (float)vessel.mainBody.Radius) - CoM
).normalized;

Quaternion surfaceRotation = Quaternion.LookRotation(surfaceNorth, surfaceUp);

return Quaternion.Inverse(
Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(vessel.GetTransform().rotation) * surfaceRotation
);
}

// Derived from MechJeb2/VesselState.cs
public static double getSurfaceHeading(this Vessel vessel)
{
return vessel.getSurfaceRotation().eulerAngles.y;
}

// Derived from MechJeb2/VesselState.cs
public static double getSurfacePitch(this Vessel vessel)
{
Quaternion vesselSurfaceRotation = vessel.getSurfaceRotation();

return (vesselSurfaceRotation.eulerAngles.x > 180f) ?
(360f - vesselSurfaceRotation.eulerAngles.x) :
-vesselSurfaceRotation.eulerAngles.x;
}

// Derived from MechJeb2/MuUtils.cs
public static string MuMech_ToSI(
double d, int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue
)
{
float exponent = (float)Math.Log10(Math.Abs(d));
exponent = Mathf.Clamp(exponent, (float)MinMagnitude, (float)MaxMagnitude);

if (exponent >= 0)
{
switch ((int)Math.Floor(exponent))
{
case 0:
case 1:
case 2:
return d.ToString("F" + digits);
case 3:
case 4:
case 5:
return (d / 1e3).ToString("F" + digits) + "k";
case 6:
case 7:
case 8:
return (d / 1e6).ToString("F" + digits) + "M";
case 9:
case 10:
case 11:
return (d / 1e9).ToString("F" + digits) + "G";
case 12:
case 13:
case 14:
return (d / 1e12).ToString("F" + digits) + "T";
case 15:
case 16:
case 17:
return (d / 1e15).ToString("F" + digits) + "P";
case 18:
case 19:
case 20:
return (d / 1e18).ToString("F" + digits) + "E";
case 21:
case 22:
case 23:
return (d / 1e21).ToString("F" + digits) + "Z";
default:
return (d / 1e24).ToString("F" + digits) + "Y";
}
}
else if (exponent < 0)
{
switch ((int)Math.Floor(exponent))
{
case -1:
case -2:
case -3:
return (d * 1e3).ToString("F" + digits) + "m";
case -4:
case -5:
case -6:
return (d * 1e6).ToString("F" + digits) + "μ";
case -7:
case -8:
case -9:
return (d * 1e9).ToString("F" + digits) + "n";
case -10:
case -11:
case -12:
return (d * 1e12).ToString("F" + digits) + "p";
case -13:
case -14:
case -15:
return (d * 1e15).ToString("F" + digits) + "f";
case -16:
case -17:
case -18:
return (d * 1e18).ToString("F" + digits) + "a";
case -19:
case -20:
case -21:
return (d * 1e21).ToString("F" + digits) + "z";
default:
return (d * 1e24).ToString("F" + digits) + "y";
}
}
else
{
return "0";
}
}

/*
* END MuMecLib METHODS
* */

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_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";

TimeSpan interval;

try
{
interval = TimeSpan.FromSeconds(seconds);
}
catch (OverflowException)
{
return "NaN";
}

int years = interval.Days / 365;

string output;
if (years > 0)
{
output = string.Format(format_1,
years,
interval.Days - (years * 365), // subtract years * 365 for accurate day count
interval.Hours,
interval.Minutes,
interval.Seconds,
interval.Milliseconds.ToString().Substring(0, 1));
}
else if (interval.Days > 0)
{
output = string.Format(format_2,
interval.Days,
interval.Hours,
interval.Minutes,
interval.Seconds,
interval.Milliseconds.ToString().Substring(0, 1));
}
else
{
output = string.Format(format_3,
interval.Hours,
interval.Minutes,
interval.Seconds,
interval.Milliseconds.ToString().Substring(0, 1));
}
return output;
}

public static string UppercaseFirst(string s)
{
if (string.IsNullOrEmpty(s))
{
return string.Empty;
}
char[] a = s.ToCharArray();
a[0] = char.ToUpper(a[0]);
return new string(a);
}
//transfer angles
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_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)));
}

public static double Younata_DeltaVToGetToOtherBody(double mu, double r1, double r2)
{
/*
def deltaVToGetToOtherBody(mu, r1, r2):
# mu = gravity param of common orbiting body of r1 and r2
# (e.g. for mun to minmus, mu is kerbin's gravity param
# r1 = initial body's orbit radius
# r2 = target body's orbit radius

# return value is km/s
sur1 = math.sqrt(mu / r1)
sr1r2 = math.sqrt(float(2*r2)/float(r1+r2))
mult = sr1r2 - 1
return sur1 * mult
*/
double sur1, sr1r2, mult;
sur1 = Math.Sqrt(mu / r1);
sr1r2 = Math.Sqrt((2 * r2) / (r1 + r2));
mult = sr1r2 - 1;
return sur1 * mult;
}

public static double Younata_DeltaVToExitSOI(double mu, double r1, double r2, double v)
{
/*
def deltaVToExitSOI(mu, r1, r2, v):
# mu = gravity param of current body
# r1 = current orbit radius
# r2 = SOI radius
# v = SOI exit velocity
foo = r2 * (v*2) - 2 mu
bar = r1 * foo + (2 * r2 * mu)
r = r1*r2
return math.sqrt(bar / r)
*/
double foo = r2 * Math.Pow(v, 2) - 2 * mu;
double bar = r1 * foo + (2 * r2 * mu);
double r = r1 * r2;
return Math.Sqrt(bar / r);
}

public static double Younata_TransferBurnPoint(double r, double v, double angle, double mu)
{
/*
def transferBurnPoint(r, v, angle, mu):
# r = parking orbit radius
# v = ejection velocity
# angle = phase angle (from function phaseAngle())
# mu = gravity param of current body.
epsilon = ((v**2)/2) - (mu / r)
h = r * v * math.sin(angle)
e = math.sqrt(1 + ((2 * epsilon * h2)/(mu2)))
theta = math.acos(1.0 / e)
degrees = theta * (180.0 / math.pi)
return 180 - degrees
*/
double epsilon, h, ee, theta, degrees;
epsilon = (Math.Pow(v, 2) / 2) - (mu / r);
h = r * v * Math.Sin(angle);
ee = Math.Sqrt(1 + ((2 * epsilon * Math.Pow(h, 2)) / Math.Pow(mu, 2)));
theta = Math.Acos(1.0 / ee);
degrees = theta * (180.0 / Math.PI);
return 180 - degrees;
// returns the ejection angle
}

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);
if (angle > 1)
angle = angle - 1;
if (angle < 0)
angle = angle + 1;
if (angle > 0.5)
angle = angle - 1;
angle = angle * 360;
return angle;
}

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 = ((vessel_long + origin_rotAngle) - (origin_LAN / 360 + origin_orbitPct) * 360);

while (eangle < 0)
eangle = eangle + 360;
while (eangle > 360)
eangle = eangle - 360;
if (eangle < 270)
eangle = 90 - eangle;
else
eangle = 450 - eangle;
return eangle;
}

public static double mrenigma03_calcphase(Vessel vessel, CelestialBody target) //calculates phase angle between the current body and target body
{
Vector3d vecthis = new Vector3d();
Vector3d vectarget = new Vector3d();
vectarget = target.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime());

if ((vessel.mainBody.name == "Sun") \|\| (vessel.mainBody.referenceBody.referenceBody.name == "Sun"))
{
vecthis = vessel.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime());
}
else
{
vecthis = vessel.mainBody.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime());
}

vecthis = Vector3d.Project(new Vector3d(vecthis.x, 0, vecthis.z), vecthis);
vectarget = Vector3d.Project(new Vector3d(vectarget.x, 0, vectarget.z), vectarget);

Vector3d prograde = new Vector3d();
prograde = Quaternion.AngleAxis(90, Vector3d.forward) * vecthis;

double phase = Vector3d.Angle(vecthis, vectarget);

if (Vector3d.Angle(prograde, vectarget) > 90)
phase = 360 - phase;

return (phase + 360) % 360;
}

public static double FixAngleDomain(double Angle, bool Degrees = false)
{
double Extent = 2d * Math.PI;
if (Degrees)
{
Extent = 360d;
}

Angle = Angle % (Extent);
if (Angle < 0d)
{
Angle += Extent;
}

return Angle;
}

public static double FixDegreeDomain(double Angle)
{
return FixAngleDomain(Angle, true);
}

public static double adjustCurrPhaseAngle(double transfer_angle, double curr_phase)
{
if (transfer_angle < 0)
{
if (curr_phase > 0)
return (-1 * (360 - curr_phase));
else if (curr_phase < 0)
return curr_phase;
}
else if (transfer_angle > 0)
{
if (curr_phase > 0)
return curr_phase;
else if (curr_phase < 0)
return (360 + curr_phase);
}
return curr_phase;
}

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
// need 0-360 instead
//
// ie i have -17 in the screenshot
// need it to show 343
//
// do this
//
// if < 0, add curr to 360 // 360 + (-17) = 343
// else its good as it is

if (curr_ejection < 0)
return 360 + curr_ejection;
else
return curr_ejection;

}

public static double adjust_transfer_ejection_angle(double trans_ejection, double trans_phase)
{
// if transfer_phase_angle < 0 its a lower transfer
//180 + curr_ejection
// else if transfer_phase_angle > 0 its good as it is

if (trans_phase < 0)
return 180 + trans_ejection;
else
return trans_ejection;

}

public static double TrueAltitude(Vessel vessel)
{
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.
if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean)
{
trueAltitude = vessel.orbit.altitude;
}

return trueAltitude;
}

public static string get_heading_text(double heading)
{
if (heading > 348.75 \|\| heading <= 11.25)
return "N";
else if (heading > 11.25 && heading <= 33.75)
return "NNE";
else if (heading > 33.75 && heading <= 56.25)
return "NE";
else if (heading > 56.25 && heading <= 78.75)
return "ENE";
else if (heading > 78.75 && heading <= 101.25)
return "E";
else if (heading > 101.25 && heading <= 123.75)
return "ESE";
else if (heading > 123.75 && heading <= 146.25)
return "SE";
else if (heading > 146.25 && heading <= 168.75)
return "SSE";
else if (heading > 168.75 && heading <= 191.25)
return "S";
else if (heading > 191.25 && heading <= 213.75)
return "SSW";
else if (heading > 213.75 && heading <= 236.25)
return "SW";
else if (heading > 236.25 && heading <= 258.75)
return "WSW";
else if (heading > 258.75 && heading <= 281.25)
return "W";
else if (heading > 281.25 && heading <= 303.75)
return "WNW";
else if (heading > 303.75 && heading <= 326.25)
return "NW";
else if (heading > 326.25 && heading <= 348.75)
return "NNW";
else
return "";
}

public static void display_transfer_angles_SUN2PLANET(CelestialBody body, Vessel vessel)
{
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();
}

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();
}
// This implementation is adapted from FARGUIUtils.ClampToScreen
public static Rect ClampRectToScreen(Rect window, int xMargin, int yMargin)
{
window.x = Mathf.Clamp(window.x, xMargin - window.width, Screen.width - xMargin);
window.y = Mathf.Clamp(window.y, yMargin - window.height, Screen.height - yMargin);

return window;
}

public static Rect ClampRectToScreen(Rect window, int Margin)
{
return ClampRectToScreen(window, Margin, Margin);
}

public static Rect ClampRectToScreen(Rect window)
{
return ClampRectToScreen(window, 30);
}

public static Vector2 ClampV2ToScreen(Vector2 vec, uint xMargin, uint yMargin)
{
vec.x = Mathf.Clamp(vec.x, xMargin, Screen.width - xMargin);
vec.y = Mathf.Clamp(vec.y, yMargin, Screen.height - yMargin);

return vec;
}

public static Vector2 ClampV2ToScreen(Vector2 vec, uint Margin)
{
return ClampV2ToScreen(vec, Margin, Margin);
}

public static Vector2 ClampV2ToScreen(Vector2 vec)
{
return ClampV2ToScreen(vec, 15);
}
// UNDONE: This seems messy. Can we clean it up?
public static Rect DockToWindow(Rect icon, Rect window)
{
// We can't set the x and y of the center point directly, so build a new vector.
Vector2 center = new Vector2();

// If we are near the top or bottom of the screen...
if (window.yMax > Screen.height - icon.height \|\|
window.yMin < icon.height)
{
// If we are in a corner...
if (window.xMax > Screen.width - icon.width \|\|
window.xMin < icon.width)
{
// If it is a top corner, put the icon below the window.
if (window.yMax < Screen.height / 2)
{
center.y = window.yMax + icon.height / 2;
}
// If it is a bottom corner, put the icon above the window.
else
{
center.y = window.yMin - icon.height / 2;
}
}
// If we are not in a corner...
else
{
// If we are along the top edge, align the icon's top edge with the top edge of the window
if (window.yMax > Screen.height / 2)
{
center.y = window.yMax - icon.height / 2;
}
// If we are along the bottom edge, align the icon's bottom edge with the bottom edge of the window
else
{
center.y = window.yMin + icon.height / 2;
}
}

// At the top or bottom, if we are towards the right, put the icon to the right of the window
if (window.center.x < Screen.width / 2)
{
center.x = window.xMin - icon.width / 2;
}
// At the top or bottom, if we are towards the left, put the icon to the left of the window
else
{
center.x = window.xMax + icon.width / 2;
}

}
// If we are not along the top or bottom of the screen...
else
{
// By default, center the icon above the window
center.y = window.yMin - icon.height / 2;
center.x = window.center.x;

// If we are along a side...
if (window.xMax > Screen.width - icon.width \|\|
window.xMin < icon.width)
{
// UNDONE: I'm not sure I like the feel of this part.
// If we are along a side towards the bottom, put the icon below the window
if (window.center.y > Screen.height / 2)
{
center.y = window.yMax + icon.height / 2;
}

// Along the left side, align the left edge of the icon with the left edge of the window.
if (window.xMax > Screen.width - icon.width)
{
center.x = window.xMax - icon.width / 2;
}
// Along the right side, align the right edge of the icon with the right edge of the window.
else if (window.xMin < icon.width)
{
center.x = window.xMin + icon.width / 2;
}
}
}

// Assign the vector to the center of the rect.
icon.center = center;

// Return the icon's position.
return icon;
}

public static ExperimentSituations GetExperimentSituation(this Vessel vessel)
{
Vessel.Situations situation = vessel.situation;

switch (situation)
{
case Vessel.Situations.PRELAUNCH:
case Vessel.Situations.LANDED:
return ExperimentSituations.SrfLanded;
case Vessel.Situations.SPLASHED:
return ExperimentSituations.SrfSplashed;
case Vessel.Situations.FLYING:
if (vessel.altitude < (double)vessel.mainBody.scienceValues.flyingAltitudeThreshold)
{
return ExperimentSituations.FlyingLow;
}
else
{
return ExperimentSituations.FlyingHigh;
}
}

if (vessel.altitude < (double)vessel.mainBody.scienceValues.spaceAltitudeThreshold)
{
return ExperimentSituations.InSpaceLow;
}
else
{
return ExperimentSituations.InSpaceHigh;
}
}

public static double Radius(this Vessel vessel)
{
double radius;

radius = vessel.altitude;

if (vessel.mainBody != null)
{
radius += vessel.mainBody.Radius;
}

return radius;
}

public static double TryGetLastMass(this Engineer.VesselSimulator.SimManager simManager)
{
if (simManager.Stages == null \|\| simManager.Stages.Length <= Staging.lastStage)
{
return double.NaN;
}

return simManager.Stages[Staging.lastStage].totalMass;
}

public static string HumanString(this ExperimentSituations situation)
{
switch (situation)
{
case ExperimentSituations.FlyingHigh:
return "Upper Atmosphere";
case ExperimentSituations.FlyingLow:
return "Flying";
case ExperimentSituations.SrfLanded:
return "Surface";
case ExperimentSituations.InSpaceLow:
return "Near in Space";
case ExperimentSituations.InSpaceHigh:
return "High in Space";
case ExperimentSituations.SrfSplashed:
return "Splashed Down";
default:
return "Unknown";
}
}

private static ScreenMessage debugmsg = new ScreenMessage("", 2f, ScreenMessageStyle.UPPER_RIGHT);

[System.Diagnostics.Conditional("DEBUG")]
public static void PostDebugMessage(string Msg)
{
if (HighLogic.LoadedScene > GameScenes.SPACECENTER)
{
debugmsg.message = Msg;
ScreenMessages.PostScreenMessage(debugmsg, true);
}

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_win</Configuration>
	<ProductVersion>8.0.30703</ProductVersion>
	<SchemaVersion>2.0</SchemaVersion>
	<ProjectGuid>{45ACC1CC-942C-4A66-BFC7-8BE375938B18}</ProjectGuid>
	<OutputType>Library</OutputType>
	<RootNamespace>VOID</RootNamespace>
	<AssemblyName>VOID</AssemblyName>
	<CodePage>65001</CodePage>
	<UseMSBuildEngine>False</UseMSBuildEngine>
	<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
	<ReleaseVersion>0.11</ReleaseVersion>
	<SynchReleaseVersion>false</SynchReleaseVersion>
	</PropertyGroup>
	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Debug_win\|AnyCPU' ">
	<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="xcopy /Y ${TargetFile} ..\..\..\Games\KSP_win\GameData\VOID\Plugins\" />
	</CustomCommands>
	</CustomCommands>
	</PropertyGroup>
	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Release_win\|AnyCPU' ">
	<Optimize>false</Optimize>
	<OutputPath>bin\Release</OutputPath>
	<ErrorReport>prompt</ErrorReport>
	<WarningLevel>4</WarningLevel>
	<ConsolePause>false</ConsolePause>
	<DefineConstants>TRACE</DefineConstants>
	<CustomCommands>
	<CustomCommands>
	<Command type="AfterBuild" command="xcopy /Y ${TargetFile} ..\..\..\Games\KSP_win\GameData\VOID\Plugins\" />
	</CustomCommands>
	</CustomCommands>
	</PropertyGroup>
	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Debug_linux\|AnyCPU' ">
	<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="cp -afv ${TargetFile} /opt/games/KSP_linux/GameData/${ProjectName}/Plugins/" />
	</CustomCommands>
	</CustomCommands>
	</PropertyGroup>
	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Release_linux\|AnyCPU' ">
	<Optimize>false</Optimize>
	<OutputPath>bin\Release</OutputPath>
	<DefineConstants>TRACE</DefineConstants>
	<ErrorReport>prompt</ErrorReport>
	<WarningLevel>4</WarningLevel>
	<ConsolePause>false</ConsolePause>
	<CustomCommands>
	<CustomCommands>
	<Command type="AfterBuild" command="cp -afv ${TargetFile} /opt/games/KSP_linux/GameData/${ProjectName}/Plugins/" />
	</CustomCommands>
	</CustomCommands>
	</PropertyGroup>
	<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
	<ItemGroup>
	<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" />
	<Compile Include="VOID_EditorCore.cs" />
	<Compile Include="VOID_EditorHUD.cs" />
	<Compile Include="VOID_DataValue.cs" />
	<Compile Include="VOIDEditorMaster.cs" />
	<Compile Include="VOID_Tools.cs" />
	<Compile Include="VOID_Localization.cs" />
	<Compile Include="Properties\AssemblyInfo.cs" />
	<Compile Include="VOID_HUDAdvanced.cs" />
	<Compile Include="VOID_TWR.cs" />
	<Compile Include="VOID_CareerStatus.cs" />
	</ItemGroup>
	<ProjectExtensions>
	<MonoDevelop>
	<Properties>
	<Policies>
	<TextStylePolicy FileWidth="120" TabsToSpaces="False" EolMarker="Unix" inheritsSet="VisualStudio" inheritsScope="text/plain" scope="text/plain" />
	</Policies>
	</Properties>
	</MonoDevelop>
	</ProjectExtensions>
	<ItemGroup>
	<Reference Include="System">
	<HintPath>..\_KSPAssemblies\System.dll</HintPath>
	</Reference>
	<Reference Include="Assembly-CSharp">
	<HintPath>..\_KSPAssemblies\Assembly-CSharp.dll</HintPath>
	</Reference>
	<Reference Include="UnityEngine">
	<HintPath>..\_KSPAssemblies\UnityEngine.dll</HintPath>
	</Reference>
	</ItemGroup>
	<ItemGroup>
	<ProjectReference Include="..\ToadicusTools\ToadicusTools.csproj">
	<Project>{D48A5542-6655-4149-BC27-B27DF0466F1C}</Project>
	<Name>ToadicusTools</Name>
	</ProjectReference>
	<ProjectReference Include="..\VesselSimulator\VesselSimulator.csproj">
	<Project>{30FD6C0B-D36E-462F-B0FF-F0FAC9C666CF}</Project>
	<Name>VesselSimulator</Name>
	</ProjectReference>
	</ItemGroup>
	</Project>

file:a/VOIDEditorMaster.cs -> file:b/VOIDEditorMaster.cs

///////////////////////////////////////////////////////////////////////////////	// VOID
//	//
// VOID - Vessel Orbital Information Display for Kerbal Space Program	// VOIDEditorMaster.cs
// Copyright (C) 2012 Iannic-ann-od
// Copyright (C) 2013 Toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// Copyright © 2014, toadicus
// it under the terms of the GNU General Public License as published by	// All rights reserved.
// 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,	// Redistribution and use in source and binary forms, with or without modification,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// are permitted provided that the following conditions are met:
// 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	// 1. Redistributions of source code must retain the above copyright notice,
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// this list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation and/or other
	// materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//	//
///////////////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////////////
//	//
// 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 Engineer.VesselSimulator;
	using KSP;
using System;	using System;
	using ToadicusTools;
using UnityEngine;	using UnityEngine;
using Engineer.VesselSimulator;

namespace VOID	namespace VOID
{	{
[KSPAddon(KSPAddon.Startup.EditorAny, false)]	[KSPAddon(KSPAddon.Startup.EditorAny, false)]
public class VOIDEditorMaster : MonoBehaviour	public class VOIDEditorMaster : MonoBehaviour
{	{
protected VOID_EditorCore Core;	protected VOID_EditorCore Core;

public void Awake()	public void Awake()
{	{
Tools.PostDebugMessage ("VOIDEditorMaster: Waking up.");	Tools.PostDebugMessage ("VOIDEditorMaster: Waking up.");
this.Core = VOID_EditorCore.Instance;	this.Core = VOID_EditorCore.Instance;
this.Core.ResetGUI ();	this.Core.ResetGUI ();
SimManager.HardReset();
Tools.PostDebugMessage ("VOIDEditorMaster: Awake.");	Tools.PostDebugMessage ("VOIDEditorMaster: Awake.");
}	}

public void Update()	public void Update()
{	{
if (!HighLogic.LoadedSceneIsEditor && this.Core != null)	if (!HighLogic.LoadedSceneIsEditor && this.Core != null)
{	{
this.Core.SaveConfig ();	this.Core.SaveConfig ();
this.Core = null;	this.Core = null;
VOID_EditorCore.Reset();	VOID_EditorCore.Reset();
return;	return;
}	}

if (this.Core == null)	if (this.Core == null)
{	{
this.Awake();	this.Awake();
}	}

this.Core.Update ();	this.Core.Update ();

if (this.Core.factoryReset)	if (this.Core.factoryReset)
{	{
KSP.IO.File.Delete<VOID_EditorCore>("config.xml");	KSP.IO.File.Delete<VOID_EditorCore>("config.xml");
this.Core = null;	this.Core = null;
VOID_EditorCore.Reset();	VOID_EditorCore.Reset();
}	}
}	}

public void FixedUpdate()	public void FixedUpdate()
{	{
if (this.Core == null \|\| !HighLogic.LoadedSceneIsEditor)	if (this.Core == null \|\| !HighLogic.LoadedSceneIsEditor)
{	{
return;	return;
}	}

this.Core.FixedUpdate ();	this.Core.FixedUpdate ();
}	}

public void OnGUI()	public void OnGUI()
{	{
if (this.Core == null)	if (this.Core == null)
{	{
return;	return;
}	}

this.Core.OnGUI();	this.Core.OnGUI();
}	}
}	}
}	}

file:a/VOIDFlightMaster.cs -> file:b/VOIDFlightMaster.cs

///////////////////////////////////////////////////////////////////////////////	// VOID
//	//
// VOID - Vessel Orbital Information Display for Kerbal Space Program	// VOIDFlightMaster.cs
// Copyright (C) 2012 Iannic-ann-od
// Copyright (C) 2013 Toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// Copyright © 2014, toadicus
// it under the terms of the GNU General Public License as published by	// All rights reserved.
// 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,	// Redistribution and use in source and binary forms, with or without modification,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// are permitted provided that the following conditions are met:
// 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	// 1. Redistributions of source code must retain the above copyright notice,
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// this list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation and/or other
	// materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//	//
///////////////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////////////
//	//
// 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 UnityEngine;	using UnityEngine;
using Engineer.VesselSimulator;	using Engineer.VesselSimulator;
	using ToadicusTools;

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 ("VOIDFlightMaster: Waking up.");	Tools.PostDebugMessage ("VOIDFlightMaster: Waking up.");
this.Core = (VOID_Core)VOID_Core.Instance;	this.Core = (VOID_Core)VOID_Core.Instance;
this.Core.ResetGUI ();	this.Core.ResetGUI ();
SimManager.HardReset();
Tools.PostDebugMessage ("VOIDFlightMaster: Awake.");	Tools.PostDebugMessage ("VOIDFlightMaster: Awake.");
}	}

public void Update()	public void Update()
{	{
if (!HighLogic.LoadedSceneIsFlight && this.Core != null)	if (!HighLogic.LoadedSceneIsFlight && this.Core != null)
{	{
this.Core.SaveConfig ();	this.Core.SaveConfig ();
this.Core = null;	this.Core = null;
VOID_Core.Reset();	VOID_Core.Reset();
return;	return;
}	}

if (this.Core == null)	if (this.Core == null)
{	{
this.Awake();	this.Awake();
}	}

this.Core.Update ();	this.Core.Update ();

if (this.Core.factoryReset)	if (this.Core.factoryReset)
{	{
KSP.IO.File.Delete<VOID_Core>("config.xml");	KSP.IO.File.Delete<VOID_Core>("config.xml");
this.Core = null;	this.Core = null;
VOID_Core.Reset();	VOID_Core.Reset();
}	}
}	}

public void FixedUpdate()	public void FixedUpdate()
{	{
if (this.Core == null \|\| !HighLogic.LoadedSceneIsFlight)	if (this.Core == null \|\| !HighLogic.LoadedSceneIsFlight)
{	{
return;	return;
}	}

this.Core.FixedUpdate ();	this.Core.FixedUpdate ();
}	}

public void OnGUI()	public void OnGUI()
{	{
if (this.Core == null)	if (this.Core == null)
{	{
return;	return;
}	}

this.Core.OnGUI();	this.Core.OnGUI();
}	}
}	}
}	}

file:a/VOID_CBInfoBrowser.cs -> file:b/VOID_CBInfoBrowser.cs

file:b/VOID_CareerStatus.cs (new)

	// VOID
	//
	// VOID_CareerStatus.cs
	//
	// Copyright © 2014, toadicus
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice,
	// this list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation and/or other
	// materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	using KSP;
	using System;
	using System.Text;
	using ToadicusTools;
	using UnityEngine;

	namespace VOID
	{
	public class VOID_CareerStatus : VOID_WindowModule
	{
	public static VOID_CareerStatus Instance
	{
	get;
	private set;
	}

	public static string formatDelta(double delta)
	{
	if (delta > 0)
	{
	return string.Format("<color='green'>{0:#,#.##}↑</color>", delta);
	}
	else if (delta < 0)
	{
	return string.Format("<color='red'>{0:#,#.##}↓</color>", delta);
	}
	else
	{
	return string.Intern("0");
	}
	}

	public static string formatDelta(float delta)
	{
	return formatDelta((double)delta);
	}

	private GUIContent fundsContent;
	private GUIContent repContent;
	private GUIContent scienceContent;

	private Texture2D fundsIconGreen;
	private Texture2D fundsIconRed;
	private Texture2D reputationIconGreen;
	private Texture2D reputationIconRed;
	private Texture2D scienceIcon;

	public override bool toggleActive
	{
	get
	{
	switch (HighLogic.CurrentGame.Mode)
	{
	case Game.Modes.CAREER:
	case Game.Modes.SCIENCE_SANDBOX:
	return base.toggleActive;
	default:
	return false;
	}
	}
	set
	{
	switch (HighLogic.CurrentGame.Mode)
	{
	case Game.Modes.CAREER:
	case Game.Modes.SCIENCE_SANDBOX:
	base.toggleActive = value;
	break;
	default:
	return;
	}
	}
	}

	public double lastFundsChange
	{
	get;
	private set;
	}

	public float lastRepChange
	{
	get;
	private set;
	}

	public float lastScienceChange
	{
	get;
	private set;
	}

	public double currentFunds
	{
	get;
	private set;
	}

	public float currentReputation
	{
	get;
	private set;
	}

	public float currentScience
	{
	get;
	private set;
	}

	public override void ModuleWindow(int _)
	{
	GUILayout.BeginVertical();

	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
	GUILayout.Label(VOID_Data.fundingStatus.Label);
	GUILayout.FlexibleSpace();
	this.fundsContent.text = VOID_Data.fundingStatus.Value;
	GUILayout.Label(this.fundsContent, GUILayout.ExpandWidth(false));
	GUILayout.EndHorizontal();

	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
	GUILayout.Label(VOID_Data.reputationStatus.Label);
	GUILayout.FlexibleSpace();
	this.repContent.text = VOID_Data.reputationStatus.Value;
	GUILayout.Label(this.repContent, GUILayout.ExpandWidth(false));
	GUILayout.EndHorizontal();

	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
	GUILayout.Label(VOID_Data.scienceStatus.Label);
	GUILayout.FlexibleSpace();
	this.scienceContent.text = VOID_Data.scienceStatus.Value;
	GUILayout.Label(this.scienceContent, GUILayout.ExpandWidth(false));
	GUILayout.EndHorizontal();

	GUILayout.EndVertical();

	GUI.DragWindow();
	}

	private void onFundsChange(double newValue)
	{
	this.lastFundsChange = newValue - this.currentFunds;
	this.currentFunds = newValue;
	}

	private void onRepChange(float newValue)
	{
	this.lastRepChange = newValue - this.currentReputation;
	this.currentReputation = newValue;
	}

	private void onScienceChange(float newValue)
	{
	this.lastScienceChange = newValue - this.currentScience;
	this.currentScience = newValue;
	}

	/*
	* MissionRecoveryDialog::fundsIconGreen.name: UiElements_05
	* MissionRecoveryDialog::fundsIconRed.name: UiElements_06
	* MissionRecoveryDialog::reputationIconGreen.name: UiElements_07
	* MissionRecoveryDialog::reputationIconRed.name: UiElements_08
	* MissionRecoveryDialog::scienceIcon.name: UiElements_12
	* */
	public VOID_CareerStatus() : base()
	{
	VOID_CareerStatus.Instance = this;

	this._Name = "Career Status";

	GameEvents.OnFundsChanged.Add(this.onFundsChange);
	GameEvents.OnReputationChanged.Add(this.onRepChange);
	GameEvents.OnScienceChanged.Add(this.onScienceChange);

	bool texturesLoaded;

	texturesLoaded = IOTools.LoadTexture(out this.fundsIconGreen, "VOID/Textures/fundsgreen.png", 10, 18);
	texturesLoaded &= IOTools.LoadTexture(out this.fundsIconRed, "VOID/Textures/fundsred.png", 10, 18);
	texturesLoaded &= IOTools.LoadTexture(out this.reputationIconGreen, "VOID/Textures/repgreen.png", 16, 18);
	texturesLoaded &= IOTools.LoadTexture(out this.reputationIconRed, "VOID/Textures/repred.png", 16, 18);
	texturesLoaded &= IOTools.LoadTexture(out this.scienceIcon, "VOID/Textures/science.png", 16, 18);

	this.fundsContent = new GUIContent();
	this.repContent = new GUIContent();
	this.scienceContent = new GUIContent();

	if (texturesLoaded)
	{
	this.fundsContent.image = this.fundsIconGreen;
	this.repContent.image = this.reputationIconGreen;
	this.scienceContent.image = this.scienceIcon;
	}

	this.currentFunds = Funding.Instance != null ? Funding.Instance.Funds : double.NaN;
	this.currentReputation = Reputation.Instance != null ? Reputation.Instance.reputation : float.NaN;
	this.currentScience = ResearchAndDevelopment.Instance != null ?
	ResearchAndDevelopment.Instance.Science : float.NaN;
	}

	~VOID_CareerStatus()
	{
	GameEvents.OnFundsChanged.Remove(this.onFundsChange);
	GameEvents.OnReputationChanged.Remove(this.onRepChange);
	GameEvents.OnScienceChanged.Remove(this.onScienceChange);

	VOID_CareerStatus.Instance = null;
	}
	}

	public static partial class VOID_Data
	{
	public static readonly VOID_StrValue fundingStatus = new VOID_StrValue(
	string.Intern("Funds"),
	delegate()
	{
	if (VOID_CareerStatus.Instance == null)
	{
	return string.Empty;
	}

	return string.Format("{0} ({1})",
	VOID_CareerStatus.Instance.currentFunds.ToString("#,#.##"),
	VOID_CareerStatus.formatDelta(VOID_CareerStatus.Instance.lastFundsChange)
	);
	}
	);

	public static readonly VOID_StrValue reputationStatus = new VOID_StrValue(
	string.Intern("Reputation"),
	delegate()
	{
	if (VOID_CareerStatus.Instance == null)
	{
	return string.Empty;
	}

	return string.Format("{0} ({1})",
	VOID_CareerStatus.Instance.currentReputation.ToString("#,#.##"),
	VOID_CareerStatus.formatDelta(VOID_CareerStatus.Instance.lastRepChange)
	);
	}
	);

	public static readonly VOID_StrValue scienceStatus = new VOID_StrValue(
	string.Intern("Science"),
	delegate()
	{
	if (VOID_CareerStatus.Instance == null)
	{
	return string.Empty;
	}

	return string.Format("{0} ({1})",
	VOID_CareerStatus.Instance.currentScience.ToString("#,#.##"),
	VOID_CareerStatus.formatDelta(VOID_CareerStatus.Instance.lastScienceChange)
	);
	}
	);
	}
	}

file:a/VOID_Core.cs -> file:b/VOID_Core.cs

	// VOID
//	//
// VOID_Core.cs	// VOID_Core.cs
//	//
// Author:	// Copyright © 2014, toadicus
// toadicus <>	// All rights reserved.
//	//
// Copyright (c) 2013 toadicus	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
//	//
// This program is free software: you can redistribute it and/or modify	// 1. Redistributions of source code must retain the above copyright notice,
// it under the terms of the GNU General Public License as published by	// this list of conditions and the following disclaimer.
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	using Engineer.VesselSimulator;
	using KSP;
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using System.Linq;	using System.Linq;
using KSP;	using ToadicusTools;
using UnityEngine;	using UnityEngine;
using Engineer.VesselSimulator;

namespace VOID	namespace VOID
{	{
public class VOID_Core : VOID_Module, IVOID_Module	public class VOID_Core : VOID_Module, IVOID_Module
{	{
	#region Singleton Members
/*	/*
* 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 void Reset()	public static void Reset()
{	{
_instance.StopGUI();	_instance.StopGUI();
	_instance.Dispose();
_instance = null;	_instance = null;
_initialized = false;	_initialized = false;
}	}
	#endregion
public static double Constant_G = 6.674e-11;
	public static readonly double Constant_G = 6.674e-11;

/*	/*
* Fields	* Fields
* */	* */
protected string VoidName = "VOID";	protected string VoidName = "VOID";
protected string VoidVersion = "0.9.22";	protected string VoidVersion;

protected bool _factoryReset = false;	protected bool _factoryReset = false;

[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;

[AVOID_SaveValue("mainWindowPos")]	[AVOID_SaveValue("mainWindowPos")]
protected VOID_SaveValue<Rect> mainWindowPos = new Rect(475, 575, 10f, 10f);	protected VOID_SaveValue<Rect> mainWindowPos = new Rect(475, 575, 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(825, 625, 10f, 10f);	protected VOID_SaveValue<Rect> configWindowPos = new Rect(825, 625, 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 - 32, 32f, 32f);	protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 32, 32f, 32f);

protected Texture2D VOIDIconTexture;	protected Texture2D VOIDIconTexture;
protected string VOIDIconOnActivePath;	protected string VOIDIconOnActivePath;
protected string VOIDIconOnInactivePath;	protected string VOIDIconOnInactivePath;
protected string VOIDIconOffActivePath;	protected string VOIDIconOffActivePath;
protected string VOIDIconOffInactivePath;	protected string VOIDIconOffInactivePath;

protected bool VOIDIconLocked = true;	protected bool VOIDIconLocked = true;

protected GUIStyle iconStyle;	protected GUIStyle iconStyle;

protected int windowBaseID = -96518722;	protected int windowBaseID = -96518722;
protected int _windowID = 0;	protected int _windowID = 0;

protected bool GUIStylesLoaded = false;	protected bool GUIStylesLoaded = false;
protected Dictionary<string, GUIStyle> _LabelStyles = new Dictionary<string, GUIStyle>();	protected Dictionary<string, GUIStyle> _LabelStyles = new Dictionary<string, GUIStyle>();

protected CelestialBody _Kerbin;	protected CelestialBody _Kerbin;

[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;

[AVOID_SaveValue("updatePeriod")]	[AVOID_SaveValue("updatePeriod")]
protected VOID_SaveValue<double> _updatePeriod = 1001f / 15000f;	protected VOID_SaveValue<double> _updatePeriod = 1001f / 15000f;
protected float _updateTimer = 0f;	protected float _updateTimer = 0f;
protected string stringFrequency;	protected string stringFrequency;

	[AVOID_SaveValue("vesselSimActive")]
	protected VOID_SaveValue<bool> vesselSimActive;

// Vessel Type Housekeeping	// Vessel Type Housekeeping
protected List<VesselType> _allVesselTypes = new List<VesselType>();	protected List<VesselType> _allVesselTypes = new List<VesselType>();
protected bool vesselTypesLoaded = false;	protected bool vesselTypesLoaded = false;
public float saveTimer = 0;	public float saveTimer = 0;

protected string defaultSkin = "KSP window 2";	protected string defaultSkin = "KSP window 2";

[AVOID_SaveValue("defaultSkin")]	[AVOID_SaveValue("defaultSkin")]
protected VOID_SaveValue<string> _skinName;	protected VOID_SaveValue<string> _skinName;
protected int _skinIdx;	protected int _skinIdx;

protected Dictionary<string, GUISkin> validSkins;	protected Dictionary<string, GUISkin> validSkins;
protected string[] skinNames;	protected string[] skinNames;
protected string[] forbiddenSkins =	protected string[] forbiddenSkins =
{	{
"PlaqueDialogSkin",	"PlaqueDialogSkin",
"FlagBrowserSkin",	"FlagBrowserSkin",
"SSUITextAreaDefault",	"SSUITextAreaDefault",
"ExperimentsDialogSkin",	"ExperimentsDialogSkin",
"ExpRecoveryDialogSkin",	"ExpRecoveryDialogSkin",
"KSP window 5",	"KSP window 5",
"KSP window 6",	"KSP window 6",
"PartTooltipSkin"	"PartTooltipSkin"
};	};
protected bool skinsLoaded = false;	protected bool skinsLoaded = false;

public bool configDirty;	public bool configDirty;

[AVOID_SaveValue("UseBlizzyToolbar")]	[AVOID_SaveValue("UseBlizzyToolbar")]
protected VOID_SaveValue<bool> _UseToolbarManager;	protected VOID_SaveValue<bool> _UseToolbarManager;
internal IButton ToolbarButton;	internal IButton ToolbarButton;

	internal ApplicationLauncherButton AppLauncherButton;

/*	/*
* Properties	* Properties
* */	* */
public bool factoryReset	public bool factoryReset
{	{
get	get
{	{
return this._factoryReset;	return this._factoryReset;
}	}
}	}

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.skinsLoaded)	if (this.skinsLoaded)
{	{
try	try
{	{
return this.validSkins[this._skinName];	return this.validSkins[this._skinName];
}	}
catch	catch
{	{
}	}
}	}

return AssetBase.GetGUISkin(this.defaultSkin);	return AssetBase.GetGUISkin(this.defaultSkin);
}	}
}	}

public int windowID	public int windowID
{	{
get	get
{	{
if (this._windowID == 0)	if (this._windowID == 0)
{	{
this._windowID = this.windowBaseID;	this._windowID = this.windowBaseID;
}	}
return this._windowID++;	return this._windowID++;
}	}
}	}

public Dictionary<string, GUIStyle> LabelStyles	public Dictionary<string, GUIStyle> LabelStyles
{	{
get	get
{	{
return this._LabelStyles;	return this._LabelStyles;
}	}
}	}

public List<CelestialBody> allBodies	public List<CelestialBody> allBodies
{	{
get	get
{	{
return FlightGlobals.Bodies;	return FlightGlobals.Bodies;
}	}
}	}

public CelestialBody Kerbin	public CelestialBody Kerbin
{	{
get	get
{	{
if (this._Kerbin == null)	if (this._Kerbin == null)
{	{
if (FlightGlobals.Bodies != null)	if (FlightGlobals.Bodies != null)
{	{
this._Kerbin = FlightGlobals.Bodies.First(b => b.name == "Kerbin");	this._Kerbin = FlightGlobals.Bodies.First(b => b.name == "Kerbin");
}	}
}	}

return this._Kerbin;	return this._Kerbin;
}	}
}	}

public List<VesselType> allVesselTypes	public List<VesselType> allVesselTypes
{	{
get	get
{	{
return this._allVesselTypes;	return this._allVesselTypes;
}	}
}	}

public float updateTimer	public float updateTimer
{	{
get	get
{	{
return this._updateTimer;	return this._updateTimer;
}	}
}	}

public double updatePeriod	public double updatePeriod
{	{
get	get
{	{
return this._updatePeriod;	return this._updatePeriod;
}	}
}	}

	public Stage[] Stages
	{
	get;
	protected set;
	}

	public Stage LastStage
	{
	get
	{
	if (Stages != null && Stages.Count() > 0)
	{
	return Stages[0];
	}
	return null;
	}
	}

protected IconState powerState	protected IconState powerState
{	{
get	get
{	{
if (this.togglePower && this.powerAvailable)	if (this.togglePower && this.powerAvailable)
{	{
return IconState.PowerOn;	return IconState.PowerOn;
}	}
else	else
{	{
return IconState.PowerOff;	return IconState.PowerOff;
}	}

}	}
}	}

protected IconState activeState	protected IconState activeState
{	{
get	get
{	{
if (this.mainGuiMinimized)	if (this.mainGuiMinimized)
{	{
return IconState.Inactive;	return IconState.Inactive;
}	}
else	else
{	{
return IconState.Active;	return IconState.Active;
}	}

}	}
}	}

protected bool UseToolbarManager	protected bool UseToolbarManager
{	{
get	get
{	{
return _UseToolbarManager;	return _UseToolbarManager & ToolbarManager.ToolbarAvailable;
}	}
set	set
{	{
if (this._UseToolbarManager == value)	if (this._UseToolbarManager == value)
{	{
return;	return;
}	}

if (value == false && this.ToolbarButton != null)	if (value == false && this.ToolbarButton != null)
{	{
this.ToolbarButton.Destroy();	this.ToolbarButton.Destroy();
this.ToolbarButton = null;	this.ToolbarButton = null;
}	}
if (value == true)	if (value == true)
{	{
	if (this.AppLauncherButton != null)
	{
	ApplicationLauncher.Instance.RemoveModApplication(this.AppLauncherButton);
	this.AppLauncherButton = null;
	}

this.InitializeToolbarButton();	this.InitializeToolbarButton();
}	}

_UseToolbarManager.value = value;	_UseToolbarManager.value = value;
	}
	}

	protected virtual ApplicationLauncher.AppScenes appIconVisibleScenes
	{
	get
	{
	return ApplicationLauncher.AppScenes.FLIGHT;
}	}
}	}

/*	/*
* Methods	* Methods
* */	* */
public override void DrawGUI()	public override void DrawGUI()
{	{
this._windowID = this.windowBaseID;	this._windowID = this.windowBaseID;

if (!this._modulesLoaded)	if (!this._modulesLoaded)
{	{
this.LoadModulesOfType<IVOID_Module>();	this.LoadModulesOfType<IVOID_Module>();
}	}

if (!this.skinsLoaded)	if (!this.skinsLoaded)
{	{
this.LoadSkins();	this.LoadSkins();
}	}

GUI.skin = this.Skin;	GUI.skin = this.Skin;

if (!this.GUIStylesLoaded)	if (!this.GUIStylesLoaded)
{	{
this.LoadGUIStyles();	this.LoadGUIStyles();
}	}

if (!this.UseToolbarManager)	if (!this.UseToolbarManager)
{	{
if (GUI.Button(VOIDIconPos, VOIDIconTexture, this.iconStyle) && this.VOIDIconLocked)	if (this.AppLauncherButton == null)
{	{
this.ToggleMainWindow();	this.InitializeAppLauncherButton();
}	}
}	}
else if (this.ToolbarButton == null)	else if (this.ToolbarButton == null)
{	{
this.InitializeToolbarButton();	this.InitializeToolbarButton();
}	}

if (!this.mainGuiMinimized)	if (!this.mainGuiMinimized)
{	{

Rect _mainWindowPos = this.mainWindowPos;	Rect _mainWindowPos = this.mainWindowPos;

_mainWindowPos = GUILayout.Window(	_mainWindowPos = GUILayout.Window(
this.windowID,	this.windowID,
_mainWindowPos,	_mainWindowPos,
this.VOIDMainWindow,	VOID_Tools.GetWindowHandler(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)
);	);

_mainWindowPos = Tools.ClampRectToScreen(_mainWindowPos);	_mainWindowPos = Tools.ClampRectToScreen(_mainWindowPos);

if (_mainWindowPos != this.mainWindowPos)	if (_mainWindowPos != this.mainWindowPos)
{	{
this.mainWindowPos = _mainWindowPos;	this.mainWindowPos = _mainWindowPos;
}	}
}	}

if (!this.configWindowMinimized && !this.mainGuiMinimized)	if (!this.configWindowMinimized && !this.mainGuiMinimized)
{	{
Rect _configWindowPos = this.configWindowPos;	Rect _configWindowPos = this.configWindowPos;

_configWindowPos = GUILayout.Window(	_configWindowPos = GUILayout.Window(
this.windowID,	this.windowID,
_configWindowPos,	_configWindowPos,
this.VOIDConfigWindow,	VOID_Tools.GetWindowHandler(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)
);	);

_configWindowPos = Tools.ClampRectToScreen(_configWindowPos);	_configWindowPos = Tools.ClampRectToScreen(_configWindowPos);

if (_configWindowPos != this.configWindowPos)	if (_configWindowPos != this.configWindowPos)
{	{
this.configWindowPos = _configWindowPos;	this.configWindowPos = _configWindowPos;
}	}
}	}
}	}

public void OnGUI()	public virtual void OnGUI()
{	{
if (Event.current.type == EventType.Repaint)	if (Event.current.type == EventType.Repaint)
{	{
return;	return;
}	}

/*	/*
Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"Event.current.type: {0}" +	"Event.current.type: {0}" +
"\nthis.VOIDIconLocked: {1}" +	"\nthis.VOIDIconLocked: {1}" +
"\nEvent.current.mousePosition: {2}" +	"\nEvent.current.mousePosition: {2}" +
"\nVOIDIconPos: ({3}, {4}),({5}, {6})",	"\nVOIDIconPos: ({3}, {4}),({5}, {6})",
Event.current.type,	Event.current.type,
this.VOIDIconLocked,	this.VOIDIconLocked,
Event.current.mousePosition,	Event.current.mousePosition,
this.VOIDIconPos.value.xMin,	this.VOIDIconPos.value.xMin,
this.VOIDIconPos.value.yMin,	this.VOIDIconPos.value.yMin,
this.VOIDIconPos.value.xMax,	this.VOIDIconPos.value.xMax,
this.VOIDIconPos.value.yMax	this.VOIDIconPos.value.yMax
));	));
*/	*/

if (!this.VOIDIconLocked &&	if (!this.VOIDIconLocked &&
VOIDIconPos.value.Contains(Event.current.mousePosition)	VOIDIconPos.value.Contains(Event.current.mousePosition)
&& Event.current.type == EventType.mouseDrag)	&& Event.current.type == EventType.mouseDrag)
{	{
Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"Event.current.type: {0}" +	"Event.current.type: {0}" +
"\ndelta.x: {1}; delta.y: {2}",	"\ndelta.x: {1}; delta.y: {2}",
Event.current.type,	Event.current.type,
Event.current.delta.x,	Event.current.delta.x,
Event.current.delta.y	Event.current.delta.y
));	));

Rect tmp = new Rect(VOIDIconPos);	Rect tmp = new Rect(VOIDIconPos);

tmp.x = Event.current.mousePosition.x - tmp.width / 2;	tmp.x = Event.current.mousePosition.x - tmp.width / 2;
tmp.y = Event.current.mousePosition.y - tmp.height / 2;	tmp.y = Event.current.mousePosition.y - tmp.height / 2;

if (tmp.x > Screen.width - tmp.width)	if (tmp.x > Screen.width - tmp.width)
{	{
tmp.x = Screen.width - tmp.width;	tmp.x = Screen.width - tmp.width;
}	}

if (tmp.y > Screen.height - tmp.height)	if (tmp.y > Screen.height - tmp.height)
{	{
tmp.y = Screen.height - tmp.height;	tmp.y = Screen.height - tmp.height;
}	}

VOIDIconPos = tmp;	VOIDIconPos = tmp;
}	}
}	}

public void Update()	public virtual void Update()
{	{
this.LoadBeforeUpdate();	this.LoadBeforeUpdate();

if (this.vessel != null)	if (this.vessel != null && this.vesselSimActive)
{	{
SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /	Tools.PostDebugMessage(this, "Updating SimManager.");
Math.Pow(VOID_Core.Instance.vessel.Radius(), 2);	this.UpdateSimManager();
SimManager.Instance.TryStartSimulation();
}	}

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 \|\|	if (module.guiRunning && !module.toggleActive \|\|
!this.togglePower \|\|	!this.togglePower \|\|
!HighLogic.LoadedSceneIsFlight \|\|	!HighLogic.LoadedSceneIsFlight \|\|
this.factoryReset)	this.factoryReset)
{	{
module.StopGUI();	module.StopGUI();
}	}

if (module is IVOID_BehaviorModule)	if (module is IVOID_BehaviorModule)
{	{
((IVOID_BehaviorModule)module).Update();	((IVOID_BehaviorModule)module).Update();
}	}
}	}

this.CheckAndSave();	this.CheckAndSave();
this._updateTimer += Time.deltaTime;	this._updateTimer += Time.deltaTime;
}	}

public void FixedUpdate()	public virtual void FixedUpdate()
{	{
bool newPowerState = this.powerAvailable;	bool newPowerState = this.powerAvailable;

if (this.togglePower && this.consumeResource &&	if (this.togglePower && this.consumeResource &&
this.vessel.vesselType != VesselType.EVA &&	this.vessel.vesselType != VesselType.EVA &&
TimeWarp.deltaTime != 0)	TimeWarp.deltaTime != 0)
{	{
float powerReceived = this.vessel.rootPart.RequestResource(	float powerReceived = this.vessel.rootPart.RequestResource(
this.resourceName,	this.resourceName,
this.resourceRate * TimeWarp.fixedDeltaTime	this.resourceRate * TimeWarp.fixedDeltaTime
);	);

if (powerReceived > 0)	if (powerReceived > 0)
{	{
newPowerState = true;	newPowerState = true;
}	}
else	else
{	{
newPowerState = false;	newPowerState = false;
}	}

if (this.powerAvailable != newPowerState)	if (this.powerAvailable != newPowerState)
{	{
this.powerAvailable = newPowerState;	this.powerAvailable = newPowerState;
this.SetIconTexture(this.powerState \| this.activeState);	this.SetIconTexture(this.powerState \| this.activeState);
}	}
}	}

foreach (IVOID_BehaviorModule module in	foreach (IVOID_BehaviorModule module in
this._modules.OfType<IVOID_BehaviorModule>().Where(m => !m.GetType().IsAbstract))	this._modules.OfType<IVOID_BehaviorModule>().Where(m => !m.GetType().IsAbstract))
{	{
module.FixedUpdate();	module.FixedUpdate();
}	}
}	}

public void ResetGUI()	public void ResetGUI()
{	{
this.StopGUI();	this.StopGUI();

foreach (IVOID_Module module in this.Modules)	foreach (IVOID_Module module in this.Modules)
{	{
module.StopGUI();	module.StopGUI();
module.StartGUI();	module.StartGUI();
}	}

this.StartGUI();	this.StartGUI();
}	}

public void VOIDMainWindow(int _)	public void VOIDMainWindow(int _)
{	{
GUILayout.BeginVertical();	GUILayout.BeginVertical();

if (this.powerAvailable \|\| HighLogic.LoadedSceneIsEditor)	if (this.powerAvailable \|\| HighLogic.LoadedSceneIsEditor)
{	{
if (!HighLogic.LoadedSceneIsEditor)	if (!HighLogic.LoadedSceneIsEditor)
{	{
string str = string.Intern("ON");	string str = string.Intern("ON");
if (togglePower)	if (togglePower)
str = string.Intern("OFF");	str = string.Intern("OFF");
if (GUILayout.Button("Power " + str))	if (GUILayout.Button("Power " + str))
{	{
togglePower.value = !togglePower;	togglePower.value = !togglePower;
this.SetIconTexture(this.powerState \| this.activeState);	this.SetIconTexture(this.powerState \| this.activeState);
}	}
}	}

if (togglePower \|\| HighLogic.LoadedSceneIsEditor)	if (togglePower \|\| HighLogic.LoadedSceneIsEditor)
{	{
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
{	{
GUILayout.Label("-- POWER LOST --", this.LabelStyles["red"]);	GUILayout.Label("-- POWER LOST --", this.LabelStyles["red"]);
}	}

this.configWindowMinimized.value = !GUILayout.Toggle(!this.configWindowMinimized, "Configuration");	this.configWindowMinimized.value = !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()
{	{
GUIContent _content;	GUIContent _content;

if (HighLogic.LoadedSceneIsFlight)	if (HighLogic.LoadedSceneIsFlight)
{	{
this.consumeResource.value = GUILayout.Toggle(this.consumeResource, "Consume Resources");	this.consumeResource.value = GUILayout.Toggle(this.consumeResource, "Consume Resources");

this.VOIDIconLocked = GUILayout.Toggle(this.VOIDIconLocked, "Lock Icon Position");	this.VOIDIconLocked = GUILayout.Toggle(this.VOIDIconLocked, "Lock Icon Position");
}	}

this.UseToolbarManager = GUILayout.Toggle(this.UseToolbarManager, "Use Blizzy's Toolbar If Available");	this.UseToolbarManager = GUILayout.Toggle(this.UseToolbarManager, "Use Blizzy's Toolbar If Available");

	this.vesselSimActive.value = GUILayout.Toggle(this.vesselSimActive.value,
	"Enable Engineering Calculations");

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));

GUILayout.Label("Skin:", GUILayout.ExpandWidth(false));	GUILayout.Label("Skin:", GUILayout.ExpandWidth(false));

_content = new GUIContent();	_content = new GUIContent();

_content.text = "◄";	_content.text = "◄";
_content.tooltip = "Select previous skin";	_content.tooltip = "Select previous skin";
if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))	if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))
{	{
this.GUIStylesLoaded = false;	this.GUIStylesLoaded = false;
this._skinIdx--;	this._skinIdx--;
Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",	"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",
this.GetType().Name,	this.GetType().Name,
this._skinName,	this._skinName,
this.validSkins.Count	this.validSkins.Count
));	));
}	}

_content.text = this.Skin.name;	_content.text = this.Skin.name;
_content.tooltip = "Current skin";	_content.tooltip = "Current skin";
GUILayout.Label(_content, this.LabelStyles["center"], GUILayout.ExpandWidth(true));	GUILayout.Label(_content, this.LabelStyles["center"], GUILayout.ExpandWidth(true));

_content.text = "►";	_content.text = "►";
_content.tooltip = "Select next skin";	_content.tooltip = "Select next skin";
if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))	if (GUILayout.Button(_content, GUILayout.ExpandWidth(true)))
{	{
this.GUIStylesLoaded = false;	this.GUIStylesLoaded = false;
this._skinIdx++;	this._skinIdx++;
Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",	"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",
this.GetType().Name,	this.GetType().Name,
this._skinName,	this._skinName,
this.validSkins.Count	this.validSkins.Count
));	));
}	}

this._skinIdx %= this.skinNames.Length;	this._skinIdx %= this.skinNames.Length;
if (this._skinIdx < 0)	if (this._skinIdx < 0)
{	{
this._skinIdx += this.skinNames.Length;	this._skinIdx += this.skinNames.Length;
}	}

if (this._skinName != skinNames[this._skinIdx])	if (this._skinName != skinNames[this._skinIdx])
{	{
this._skinName.value = skinNames[this._skinIdx];	this._skinName.value = skinNames[this._skinIdx];
}	}

GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal();	GUILayout.BeginHorizontal();
GUILayout.Label("Update Rate (Hz):");	GUILayout.Label("Update Rate (Hz):");
if (this.stringFrequency == null)	if (this.stringFrequency == null)
{	{
this.stringFrequency = (1f / this.updatePeriod).ToString();	this.stringFrequency = (1f / this.updatePeriod).ToString();
}	}
this.stringFrequency = GUILayout.TextField(this.stringFrequency.ToString(), 5, GUILayout.ExpandWidth(true));	this.stringFrequency = GUILayout.TextField(this.stringFrequency.ToString(), 5, GUILayout.ExpandWidth(true));
// GUILayout.FlexibleSpace();	// GUILayout.FlexibleSpace();
if (GUILayout.Button("Apply"))	if (GUILayout.Button("Apply"))
{	{
double updateFreq = 1f / this.updatePeriod;	double updateFreq = 1f / this.updatePeriod;
double.TryParse(stringFrequency, out updateFreq);	double.TryParse(stringFrequency, out updateFreq);
this._updatePeriod = 1 / updateFreq;	this._updatePeriod = 1 / updateFreq;
}	}
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

foreach (IVOID_Module mod in this.Modules)	foreach (IVOID_Module mod in this.Modules)
{	{
mod.DrawConfigurables();	mod.DrawConfigurables();
}	}

this._factoryReset = GUILayout.Toggle(this._factoryReset, "Factory Reset");	this._factoryReset = GUILayout.Toggle(this._factoryReset, "Factory Reset");
}	}

	protected void UpdateSimManager()
	{
	if (SimManager.ResultsReady())
	{
	Tools.PostDebugMessage(this, "VesselSimulator results ready, setting Stages.");

	this.Stages = SimManager.Stages;

	if (HighLogic.LoadedSceneIsEditor)
	{
	SimManager.Gravity = VOID_Data.KerbinGee;
	}
	else
	{
	double radius = this.vessel.Radius();
	SimManager.Gravity = this.vessel.mainBody.gravParameter / (radius * radius);
	}

	SimManager.minSimTime = (long)(this.updatePeriod * 1000);

	SimManager.TryStartSimulation();
	}
	#if DEBUG
	else
	{
	Tools.PostDebugMessage(this, "VesselSimulator results not ready.");
	}
	#endif
	}

protected void LoadModulesOfType<T>()	protected void LoadModulesOfType<T>()
{	{
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(T).IsAssignableFrom(v)	.Where(v => typeof(T).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)
{	{
if (!HighLogic.LoadedSceneIsEditor &&	if (!HighLogic.LoadedSceneIsEditor &&
typeof(IVOID_EditorModule).IsAssignableFrom(voidType))	typeof(IVOID_EditorModule).IsAssignableFrom(voidType))
{	{
continue;	continue;
}	}

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(	Tools.PostDebugMessage(string.Format(
"{0}: Loaded {1} modules.",	"{0}: Loaded {1} modules.",
this.GetType().Name,	this.GetType().Name,
this.Modules.Count	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
));	));
}	}

protected void LoadSkins()	protected void LoadSkins()
{	{
Tools.PostDebugMessage("AssetBase has skins: \n" +	Tools.PostDebugMessage("AssetBase has skins: \n" +
string.Join("\n\t",	string.Join("\n\t",
Resources.FindObjectsOfTypeAll(typeof(GUISkin))	Resources.FindObjectsOfTypeAll(typeof(GUISkin))
.Select(s => s.ToString())	.Select(s => s.ToString())
.ToArray()	.ToArray()
)	)
);	);

this.validSkins = Resources.FindObjectsOfTypeAll(typeof(GUISkin))	this.validSkins = Resources.FindObjectsOfTypeAll(typeof(GUISkin))
.Where(s => !this.forbiddenSkins.Contains(s.name))	.Where(s => !this.forbiddenSkins.Contains(s.name))
.Select(s => s as GUISkin)	.Select(s => s as GUISkin)
.GroupBy(s => s.name)	.GroupBy(s => s.name)
.Select(g => g.First())	.Select(g => g.First())
.ToDictionary(s => s.name);	.ToDictionary(s => s.name);

Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"{0}: loaded {1} GUISkins.",	"{0}: loaded {1} GUISkins.",
this.GetType().Name,	this.GetType().Name,
this.validSkins.Count	this.validSkins.Count
));	));

this.skinNames = this.validSkins.Keys.ToArray();	this.skinNames = this.validSkins.Keys.ToArray();
Array.Sort(this.skinNames);	Array.Sort(this.skinNames);

int defaultIdx = int.MinValue;	int defaultIdx = int.MinValue;

for (int i = 0; i < this.skinNames.Length; i++)	for (int i = 0; i < this.skinNames.Length; i++)
{	{
if (this.skinNames[i] == this._skinName)	if (this.skinNames[i] == this._skinName)
{	{
this._skinIdx = i;	this._skinIdx = i;
}	}
if (this.skinNames[i] == this.defaultSkin)	if (this.skinNames[i] == this.defaultSkin)
{	{
defaultIdx = i;	defaultIdx = i;
}	}
if (this._skinIdx != int.MinValue && defaultIdx != int.MinValue)	if (this._skinIdx != int.MinValue && defaultIdx != int.MinValue)
{	{
break;	break;
}	}
}	}

if (this._skinIdx == int.MinValue)	if (this._skinIdx == int.MinValue)
{	{
this._skinIdx = defaultIdx;	this._skinIdx = defaultIdx;
}	}

Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"{0}: _skinIdx = {1}.",	"{0}: _skinIdx = {1}.",
this.GetType().Name,	this.GetType().Name,
this._skinName.ToString()	this._skinName.ToString()
));	));

this.skinsLoaded = true;	this.skinsLoaded = true;
}	}

protected void LoadGUIStyles()	protected void LoadGUIStyles()
{	{
this.LabelStyles["link"] = new GUIStyle(GUI.skin.label);	this.LabelStyles["link"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["link"].fontStyle = FontStyle.Bold;	this.LabelStyles["link"].fontStyle = FontStyle.Bold;

this.LabelStyles["center"] = new GUIStyle(GUI.skin.label);	this.LabelStyles["center"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["center"].normal.textColor = Color.white;	this.LabelStyles["center"].normal.textColor = Color.white;
this.LabelStyles["center"].alignment = TextAnchor.UpperCenter;	this.LabelStyles["center"].alignment = TextAnchor.UpperCenter;

this.LabelStyles["center_bold"] = new GUIStyle(GUI.skin.label);	this.LabelStyles["center_bold"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["center_bold"].normal.textColor = Color.white;	this.LabelStyles["center_bold"].normal.textColor = Color.white;
this.LabelStyles["center_bold"].alignment = TextAnchor.UpperCenter;	this.LabelStyles["center_bold"].alignment = TextAnchor.UpperCenter;
this.LabelStyles["center_bold"].fontStyle = FontStyle.Bold;	this.LabelStyles["center_bold"].fontStyle = FontStyle.Bold;

this.LabelStyles["right"] = new GUIStyle(GUI.skin.label);	this.LabelStyles["right"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["right"].normal.textColor = Color.white;	this.LabelStyles["right"].normal.textColor = Color.white;
this.LabelStyles["right"].alignment = TextAnchor.UpperRight;	this.LabelStyles["right"].alignment = TextAnchor.UpperRight;

this.LabelStyles["red"] = new GUIStyle(GUI.skin.label);	this.LabelStyles["red"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["red"].normal.textColor = Color.red;	this.LabelStyles["red"].normal.textColor = Color.red;
this.LabelStyles["red"].alignment = TextAnchor.MiddleCenter;	this.LabelStyles["red"].alignment = TextAnchor.MiddleCenter;

this.iconStyle = new GUIStyle(GUI.skin.button);	this.iconStyle = new GUIStyle(GUI.skin.button);
this.iconStyle.padding = new RectOffset(0, 0, 0, 0);	this.iconStyle.padding = new RectOffset(0, 0, 0, 0);
// this.iconStyle.margin = new RectOffset(0, 0, 0, 0);	// this.iconStyle.margin = new RectOffset(0, 0, 0, 0);
// this.iconStyle.contentOffset = new Vector2(0, 0);	// this.iconStyle.contentOffset = new Vector2(0, 0);
this.iconStyle.overflow = new RectOffset(0, 0, 0, 0);	this.iconStyle.overflow = new RectOffset(0, 0, 0, 0);
// this.iconStyle.border = new RectOffset(0, 0, 0, 0);	// this.iconStyle.border = new RectOffset(0, 0, 0, 0);

this.GUIStylesLoaded = true;	this.GUIStylesLoaded = true;
}	}

protected void LoadVesselTypes()	protected void LoadVesselTypes()
{	{
this._allVesselTypes = Enum.GetValues(typeof(VesselType)).OfType<VesselType>().ToList();	this._allVesselTypes = Enum.GetValues(typeof(VesselType)).OfType<VesselType>().ToList();
this.vesselTypesLoaded = true;	this.vesselTypesLoaded = true;
}	}

protected void LoadBeforeUpdate()	protected void LoadBeforeUpdate()
{	{
if (!this.vesselTypesLoaded)	if (!this.vesselTypesLoaded)
{	{
this.LoadVesselTypes();	this.LoadVesselTypes();
}	}
}	}

protected void InitializeToolbarButton()	protected void InitializeToolbarButton()
{	{
	// Do nothing if (the Toolbar is not available.
	if (!ToolbarManager.ToolbarAvailable)
	{
	return;
	}

this.ToolbarButton = ToolbarManager.Instance.add(this.VoidName, "coreToggle");	this.ToolbarButton = ToolbarManager.Instance.add(this.VoidName, "coreToggle");
this.ToolbarButton.Text = this.VoidName;	this.ToolbarButton.Text = this.VoidName;
this.SetIconTexture(this.powerState \| this.activeState);	this.SetIconTexture(this.powerState \| this.activeState);

this.ToolbarButton.Visibility = new GameScenesVisibility(GameScenes.EDITOR, GameScenes.FLIGHT, GameScenes.SPH);	this.ToolbarButton.Visibility = new GameScenesVisibility(GameScenes.EDITOR, GameScenes.FLIGHT, GameScenes.SPH);

this.ToolbarButton.OnClick +=	this.ToolbarButton.OnClick +=
(e) =>	(e) =>
{	{
this.ToggleMainWindow();	this.ToggleMainWindow();
};	};

Tools.PostDebugMessage(string.Format("{0}: Toolbar Button initialized.", this.GetType().Name));	Tools.PostDebugMessage(string.Format("{0}: Toolbar Button initialized.", this.GetType().Name));
	}

	protected void InitializeAppLauncherButton()
	{
	if (ApplicationLauncher.Ready)
	{
	this.AppLauncherButton = ApplicationLauncher.Instance.AddModApplication(
	this.ToggleMainWindow, this.ToggleMainWindow,
	this.appIconVisibleScenes,
	this.VOIDIconTexture
	);

	Tools.PostDebugMessage(
	this,
	"AppLauncherButton initialized in {0}",
	Enum.GetName(
	typeof(GameScenes),
	HighLogic.LoadedScene
	)
	);
	}
}	}

protected void ToggleMainWindow()	protected void ToggleMainWindow()
{	{
this.mainGuiMinimized = !this.mainGuiMinimized;	this.mainGuiMinimized = !this.mainGuiMinimized;
this.SetIconTexture(this.powerState \| this.activeState);	this.SetIconTexture(this.powerState \| this.activeState);
}	}

protected void SetIconTexture(IconState state)	protected void SetIconTexture(IconState state)
{	{
switch (state)	switch (state)
{	{
case (IconState.PowerOff \| IconState.Inactive):	case (IconState.PowerOff \| IconState.Inactive):
this.SetIconTexture(this.VOIDIconOffInactivePath);	this.SetIconTexture(this.VOIDIconOffInactivePath);
break;	break;
case (IconState.PowerOff \| IconState.Active):	case (IconState.PowerOff \| IconState.Active):
this.SetIconTexture(this.VOIDIconOffActivePath);	this.SetIconTexture(this.VOIDIconOffActivePath);
break;	break;
case (IconState.PowerOn \| IconState.Inactive):	case (IconState.PowerOn \| IconState.Inactive):
this.SetIconTexture(this.VOIDIconOnInactivePath);	this.SetIconTexture(this.VOIDIconOnInactivePath);
break;	break;
case (IconState.PowerOn \| IconState.Active):	case (IconState.PowerOn \| IconState.Active):
this.SetIconTexture(this.VOIDIconOnActivePath);	this.SetIconTexture(this.VOIDIconOnActivePath);
break;	break;
default:	default:
throw new NotImplementedException();	throw new NotImplementedException();
}	}
}	}

protected void SetIconTexture(string texturePath)	protected void SetIconTexture(string texturePath)
{	{
if (this.ToolbarButton != null)	if (this.ToolbarButton != null)
{	{
this.ToolbarButton.TexturePath = texturePath;	this.ToolbarButton.TexturePath = texturePath;
}	}

this.VOIDIconTexture = GameDatabase.Instance.GetTexture(texturePath, false);	this.VOIDIconTexture = GameDatabase.Instance.GetTexture(texturePath.Replace("icon", "appIcon"), false);

	if (this.AppLauncherButton != null)
	{
	this.AppLauncherButton.SetTexture(VOIDIconTexture);
	}
}	}

protected void CheckAndSave()	protected void CheckAndSave()
{	{
this.saveTimer += Time.deltaTime;	this.saveTimer += Time.deltaTime;

if (this.saveTimer > 2f)	if (this.saveTimer > 2f)
{	{
if (!this.configDirty)	if (!this.configDirty)
{	{
return;	return;
}	}

Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"{0}: Time to save, checking if configDirty: {1}",	"{0}: Time to save, checking if configDirty: {1}",
this.GetType().Name,	this.GetType().Name,
this.configDirty	this.configDirty
));	));

this.SaveConfig();	this.SaveConfig();
this.saveTimer = 0;	this.saveTimer = 0;
}	}
}	}

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 void SaveConfig()	public void SaveConfig()
{	{
var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core>();	var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core>();
config.load();	config.load();

this._SaveToConfig(config);	this._SaveToConfig(config);

foreach (IVOID_Module module in this.Modules)	foreach (IVOID_Module module in this.Modules)
{	{
module._SaveToConfig(config);	module._SaveToConfig(config);
}	}

config.save();	config.save();

this.configDirty = false;	this.configDirty = false;
}	}

protected VOID_Core()	protected VOID_Core()
{	{
this._Name = "VOID Core";	this._Name = "VOID Core";

this._Active.value = true;	System.Version version = this.GetType().Assembly.GetName().Version;

	this.VoidVersion = string.Format("{0}.{1}.{2}", version.Major, version.Minor, version.MajorRevision);

	this.toggleActive = true;

this._skinName = this.defaultSkin;	this._skinName = this.defaultSkin;
this._skinIdx = int.MinValue;	this._skinIdx = int.MinValue;

this.VOIDIconOnInactivePath = "VOID/Textures/void_icon_light_glow";	this.VOIDIconOnInactivePath = "VOID/Textures/void_icon_light_glow";
this.VOIDIconOnActivePath = "VOID/Textures/void_icon_dark_glow";	this.VOIDIconOnActivePath = "VOID/Textures/void_icon_dark_glow";
this.VOIDIconOffInactivePath = "VOID/Textures/void_icon_light";	this.VOIDIconOffInactivePath = "VOID/Textures/void_icon_light";
this.VOIDIconOffActivePath = "VOID/Textures/void_icon_dark";	this.VOIDIconOffActivePath = "VOID/Textures/void_icon_dark";

	this.vesselSimActive = true;

this.UseToolbarManager = false;	this.UseToolbarManager = false;

this.LoadConfig();	this.LoadConfig();

this.SetIconTexture(this.powerState \| this.activeState);	this.SetIconTexture(this.powerState \| this.activeState);
	}

	public virtual void Dispose()
	{
	if (this.AppLauncherButton != null)
	{
	ApplicationLauncher.Instance.RemoveModApplication(this.AppLauncherButton);
	this.AppLauncherButton = null;
	}
	if (this.ToolbarButton != null)
	{
	this.ToolbarButton.Destroy();
	this.ToolbarButton = null;
	}
}	}

protected enum IconState	protected enum IconState
{	{
PowerOff = 1,	PowerOff = 1,
PowerOn = 2,	PowerOn = 2,
Inactive = 4,	Inactive = 4,
Active = 8	Active = 8
}	}
}	}

public static partial class VOID_Data	public static partial class VOID_Data
{	{
public static VOID_Core core	public static VOID_Core core
{	{
get	get
{	{
return VOID_Core.Instance;	if (HighLogic.LoadedSceneIsEditor)
}	{
}	return VOID_EditorCore.Instance;
	}
public static Engineer.VesselSimulator.SimManager simManager	else
{	{
get	return VOID_Core.Instance;
{	}
return Engineer.VesselSimulator.SimManager.Instance;
}	}
}	}

public static double KerbinGee	public static double KerbinGee
{	{
get	get
{	{
return core.Kerbin.gravParameter / Math.Pow(core.Kerbin.Radius, 2);	if (kerbinGee == default(double))
}	{
}	kerbinGee = core.Kerbin.gravParameter / (core.Kerbin.Radius * core.Kerbin.Radius);
	}

	return kerbinGee;
	}
	}

	private static double kerbinGee;
}	}
}	}

file:a/VOID_DataLogger.cs -> file:b/VOID_DataLogger.cs

//	// VOID
// VOID_Orbital.cs	//
//	// VOID_DataLogger.cs
// Author:	//
// toadicus <>	// Copyright © 2014, toadicus
//	// All rights reserved.
// Copyright (c) 2013 toadicus	//
//	// Redistribution and use in source and binary forms, with or without modification,
// This program is free software: you can redistribute it and/or modify	// are permitted provided that the following conditions are met:
// it under the terms of the GNU General Public License as published by	//
// the Free Software Foundation, either version 3 of the License, or	// 1. Redistributions of source code must retain the above copyright notice,
// (at your option) any later version.	// this list of conditions and the following disclaimer.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.	//
//	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// You should have received a copy of the GNU General Public License	// to endorse or promote products derived from this software without specific prior written permission.
// along with this program. If not, see <http://www.gnu.org/licenses/>.	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using KSP;	using KSP;
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
	using ToadicusTools;
using UnityEngine;	using UnityEngine;

namespace VOID	namespace VOID
{	{
public class VOID_DataLogger : VOID_WindowModule, IVOID_BehaviorModule	public class VOID_DataLogger : VOID_WindowModule, IVOID_BehaviorModule
{	{
/*	/*
* Fields	* Fields
* */	* */
protected bool stopwatch1_running;	protected bool stopwatch1_running;

protected bool csv_logging;	protected bool csv_logging;
protected bool first_write;	protected bool first_write;

protected double stopwatch1;	protected double stopwatch1;

protected string csv_log_interval_str;	protected string csv_log_interval_str;

protected float csv_log_interval;	protected float csv_log_interval;

protected double csvWriteTimer;	protected double csvWriteTimer;
protected double csvCollectTimer;	protected double csvCollectTimer;

protected List<string> csvList = new List<string>();	protected List<string> csvList = new List<string>();

/*	/*
* Properties	* Properties
* */	* */


/*	/*
* Methods	* Methods
* */	* */
public VOID_DataLogger()	public VOID_DataLogger()
{	{
this._Name = "CSV Data Logger";	this._Name = "CSV Data Logger";

this.stopwatch1_running = false;	this.stopwatch1_running = false;

this.csv_logging = false;	this.csv_logging = false;
this.first_write = true;	this.first_write = true;

this.stopwatch1 = 0;	this.stopwatch1 = 0;
this.csv_log_interval_str = "0.5";	this.csv_log_interval_str = "0.5";

this.csvWriteTimer = 0;	this.csvWriteTimer = 0;
this.csvCollectTimer = 0;	this.csvCollectTimer = 0;

this.WindowPos.x = Screen.width - 520;	this.WindowPos.x = Screen.width - 520;
this.WindowPos.y = 85;	this.WindowPos.y = 85;
}	}

public override void ModuleWindow(int _)	public override void ModuleWindow(int _)
{	{
GUIStyle txt_white = new GUIStyle(GUI.skin.label);	GUIStyle txt_white = new GUIStyle(GUI.skin.label);
txt_white.normal.textColor = txt_white.focused.textColor = Color.white;	txt_white.normal.textColor = txt_white.focused.textColor = Color.white;
txt_white.alignment = TextAnchor.UpperRight;	txt_white.alignment = TextAnchor.UpperRight;
GUIStyle txt_green = new GUIStyle(GUI.skin.label);	GUIStyle txt_green = new GUIStyle(GUI.skin.label);
txt_green.normal.textColor = txt_green.focused.textColor = Color.green;	txt_green.normal.textColor = txt_green.focused.textColor = Color.green;
txt_green.alignment = TextAnchor.UpperRight;	txt_green.alignment = TextAnchor.UpperRight;
GUIStyle txt_yellow = new GUIStyle(GUI.skin.label);	GUIStyle txt_yellow = new GUIStyle(GUI.skin.label);
txt_yellow.normal.textColor = txt_yellow.focused.textColor = Color.yellow;	txt_yellow.normal.textColor = txt_yellow.focused.textColor = Color.yellow;
txt_yellow.alignment = TextAnchor.UpperRight;	txt_yellow.alignment = TextAnchor.UpperRight;

GUILayout.BeginVertical();	GUILayout.BeginVertical();

GUILayout.Label("System time: " + DateTime.Now.ToString("HH:mm:ss"));	GUILayout.Label("System time: " + DateTime.Now.ToString("HH:mm:ss"));
GUILayout.Label(Tools.ConvertInterval(stopwatch1));	GUILayout.Label(VOID_Tools.ConvertInterval(stopwatch1));

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
if (GUILayout.Button("Start"))	if (GUILayout.Button("Start"))
{	{
if (stopwatch1_running == false) stopwatch1_running = true;	if (stopwatch1_running == false) stopwatch1_running = true;
}	}
if (GUILayout.Button("Stop"))	if (GUILayout.Button("Stop"))
{	{
if (stopwatch1_running == true) stopwatch1_running = false;	if (stopwatch1_running == true) stopwatch1_running = false;
}	}
if (GUILayout.Button("Reset"))	if (GUILayout.Button("Reset"))
{	{
if (stopwatch1_running == true) stopwatch1_running = false;	if (stopwatch1_running == true) stopwatch1_running = false;
stopwatch1 = 0;	stopwatch1 = 0;
}	}
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUIStyle label_style = txt_white;	GUIStyle label_style = txt_white;
string log_label = "Inactive";	string log_label = "Inactive";
if (csv_logging && vessel.situation.ToString() == "PRELAUNCH")	if (csv_logging && vessel.situation.ToString() == "PRELAUNCH")
{	{
log_label = "Awaiting launch";	log_label = "Awaiting launch";
label_style = txt_yellow;	label_style = txt_yellow;
}	}
if (csv_logging && vessel.situation.ToString() != "PRELAUNCH")	if (csv_logging && vessel.situation.ToString() != "PRELAUNCH")
{	{
log_label = "Active";	log_label = "Active";
label_style = txt_green;	label_style = txt_green;
}	}
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
csv_logging = GUILayout.Toggle(csv_logging, "Data logging: ", GUILayout.ExpandWidth(false));	csv_logging = GUILayout.Toggle(csv_logging, "Data logging: ", GUILayout.ExpandWidth(false));
GUILayout.Label(log_label, label_style, GUILayout.ExpandWidth(true));	GUILayout.Label(log_label, label_style, GUILayout.ExpandWidth(true));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Interval: ", GUILayout.ExpandWidth(false));	GUILayout.Label("Interval: ", GUILayout.ExpandWidth(false));
csv_log_interval_str = GUILayout.TextField(csv_log_interval_str, GUILayout.ExpandWidth(true));	csv_log_interval_str = GUILayout.TextField(csv_log_interval_str, GUILayout.ExpandWidth(true));
GUILayout.Label("s", GUILayout.ExpandWidth(false));	GUILayout.Label("s", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

float new_log_interval;	float new_log_interval;
if (Single.TryParse(csv_log_interval_str, out new_log_interval)) csv_log_interval = new_log_interval;	if (Single.TryParse(csv_log_interval_str, out new_log_interval)) csv_log_interval = new_log_interval;

GUILayout.EndVertical();	GUILayout.EndVertical();
GUI.DragWindow();	GUI.DragWindow();
}	}

public void Update()	public void Update()
{	{
// CSV Logging	// CSV Logging
// from ISA MapSat	// from ISA MapSat
if (csv_logging)	if (csv_logging)
{	{
//data logging is on	//data logging is on
//increment timers	//increment timers
csvWriteTimer += Time.deltaTime;	csvWriteTimer += Time.deltaTime;
csvCollectTimer += Time.deltaTime;	csvCollectTimer += Time.deltaTime;

if (csvCollectTimer >= csv_log_interval && vessel.situation != Vessel.Situations.PRELAUNCH)	if (csvCollectTimer >= csv_log_interval && vessel.situation != Vessel.Situations.PRELAUNCH)
{	{
//data logging is on, vessel is not prelaunch, and interval has passed	//data logging is on, vessel is not prelaunch, and interval has passed
//write a line to the list	//write a line to the list
line_to_csvList(); //write to the csv	line_to_csvList(); //write to the csv
}	}

if (csvList.Count != 0 && csvWriteTimer >= 15f)	if (csvList.Count != 0 && csvWriteTimer >= 15f)
{	{
// csvList is not empty and interval between writings to file has elapsed	// csvList is not empty and interval between writings to file has elapsed
//write it	//write it
string[] csvData;	string[] csvData;
csvData = (string[])csvList.ToArray();	csvData = (string[])csvList.ToArray();
Innsewerants_writeData(csvData);	Innsewerants_writeData(csvData);
csvList.Clear();	csvList.Clear();
csvWriteTimer = 0f;	csvWriteTimer = 0f;
}	}
}	}
else	else
{	{
//data logging is off	//data logging is off
//reset any timers and clear anything from csvList	//reset any timers and clear anything from csvList
csvWriteTimer = 0f;	csvWriteTimer = 0f;
csvCollectTimer = 0f;	csvCollectTimer = 0f;
if (csvList.Count > 0) csvList.Clear();	if (csvList.Count > 0) csvList.Clear();
}	}

if (stopwatch1_running)	if (stopwatch1_running)
{	{
stopwatch1 += Time.deltaTime;	stopwatch1 += Time.deltaTime;
}	}
}	}

public void FixedUpdate() {}	public void FixedUpdate() {}

private void Innsewerants_writeData(string[] csvArray)	private void Innsewerants_writeData(string[] csvArray)
{	{
var efile = KSP.IO.File.AppendText<VOID_Core>(vessel.vesselName + "_data.csv", null);	var efile = KSP.IO.File.AppendText<VOID_Core>(vessel.vesselName + "_data.csv", null);
foreach (string line in csvArray)	foreach (string line in csvArray)
{	{
efile.Write(line);	efile.Write(line);
}	}
efile.Close();	efile.Close();
}	}

private void line_to_csvList()	private void line_to_csvList()
{	{
//called if logging is on and interval has passed	//called if logging is on and interval has passed
//writes one line to the csvList	//writes one line to the csvList

string line = "";	string line = "";
if (first_write && !KSP.IO.File.Exists<VOID_Core>(vessel.vesselName + "_data.csv", null))	if (first_write && !KSP.IO.File.Exists<VOID_Core>(vessel.vesselName + "_data.csv", null))
{	{
first_write = false;	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";	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	//Mission time
line += vessel.missionTime.ToString("F3") + ";";	line += vessel.missionTime.ToString("F3") + ";";
//Altitude ASL	//Altitude ASL
line += vessel.orbit.altitude.ToString("F3") + ";";	line += vessel.orbit.altitude.ToString("F3") + ";";
//Altitude (true)	//Altitude (true)
double alt_true = vessel.orbit.altitude - vessel.terrainAltitude;	double alt_true = vessel.orbit.altitude - vessel.terrainAltitude;
if (vessel.terrainAltitude < 0) alt_true = vessel.orbit.altitude;	if (vessel.terrainAltitude < 0) alt_true = vessel.orbit.altitude;
line += alt_true.ToString("F3") + ";";	line += alt_true.ToString("F3") + ";";
//Orbital velocity	//Orbital velocity
line += vessel.orbit.vel.magnitude.ToString("F3") + ";";	line += vessel.orbit.vel.magnitude.ToString("F3") + ";";
//surface velocity	//surface velocity
line += vessel.srf_velocity.magnitude.ToString("F3") + ";";	line += vessel.srf_velocity.magnitude.ToString("F3") + ";";
//vertical speed	//vertical speed
line += vessel.verticalSpeed.ToString("F3") + ";";	line += vessel.verticalSpeed.ToString("F3") + ";";
//horizontal speed	//horizontal speed
line += vessel.horizontalSrfSpeed.ToString("F3") + ";";	line += vessel.horizontalSrfSpeed.ToString("F3") + ";";
//gee force	//gee force
line += vessel.geeForce.ToString("F3") + ";";	line += vessel.geeForce.ToString("F3") + ";";
//temperature	//temperature
line += vessel.flightIntegrator.getExternalTemperature().ToString("F2") + ";";	line += vessel.flightIntegrator.getExternalTemperature().ToString("F2") + ";";
//gravity	//gravity
double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass());	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);	double g_vessel = (VOID_Core.Constant_G * vessel.mainBody.Mass) / (r_vessel * r_vessel);
line += g_vessel.ToString("F3") + ";";	line += g_vessel.ToString("F3") + ";";
//atm density	//atm density
line += (vessel.atmDensity * 1000).ToString("F3") + ";";	line += (vessel.atmDensity * 1000).ToString("F3") + ";";
line += "\n";	line += "\n";
if (csvList.Contains(line) == false) csvList.Add(line);	if (csvList.Contains(line) == false) csvList.Add(line);
csvCollectTimer = 0f;	csvCollectTimer = 0f;
}	}
}	}
}	}

file:a/VOID_DataValue.cs -> file:b/VOID_DataValue.cs

//	// VOID
// VOID_DataValue.cs	//
//	// VOID_DataValue.cs
// Author:	//
// toadicus <>	// Copyright © 2014, toadicus
//	// All rights reserved.
// Copyright (c) 2013 toadicus	//
//	// Redistribution and use in source and binary forms, with or without modification,
// This program is free software: you can redistribute it and/or modify	// are permitted provided that the following conditions are met:
// it under the terms of the GNU General Public License as published by	//
// the Free Software Foundation, either version 3 of the License, or	// 1. Redistributions of source code must retain the above copyright notice,
// (at your option) any later version.	// this list of conditions and the following disclaimer.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.	//
//	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// You should have received a copy of the GNU General Public License	// to endorse or promote products derived from this software without specific prior written permission.
// along with this program. If not, see <http://www.gnu.org/licenses/>.	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using System;	using System;
	using ToadicusTools;
using UnityEngine;	using UnityEngine;

namespace VOID	namespace VOID
{	{
public interface IVOID_DataValue	public interface IVOID_DataValue
{	{
void Refresh();	void Refresh();
string ValueUnitString();	string ValueUnitString();
void DoGUIHorizontal();	void DoGUIHorizontal();
}	}

public class VOID_DataValue<T> : IVOID_DataValue	public class VOID_DataValue<T> : IVOID_DataValue
{	{
/*	/*
* Static Members	* Static Members
* */	* */
public static implicit operator T(VOID_DataValue<T> v)	public static implicit operator T(VOID_DataValue<T> v)
{	{
return (T)v.Value;	return (T)v.Value;
}	}

/*	/*
* Instance Members	* Instance Members
* */	* */
/*	/*
* Fields	* Fields
* */	* */
protected T cache;	protected T cache;
protected Func<T> ValueFunc;	protected Func<T> ValueFunc;
protected float lastUpdate;	protected float lastUpdate;

/*	/*
* Properties	* Properties
* */	* */
public string Label { get; protected set; }	public string Label { get; protected set; }
public string Units { get; protected set; }	public string Units { get; protected set; }

public T Value	public T Value
{	{
get	get
{	{
if (	if (
	HighLogic.LoadedSceneIsEditor \|\|
(VOID_Core.Instance.updateTimer - this.lastUpdate > VOID_Core.Instance.updatePeriod) \|\|	(VOID_Core.Instance.updateTimer - this.lastUpdate > VOID_Core.Instance.updatePeriod) \|\|
(this.lastUpdate > VOID_Core.Instance.updateTimer)	(this.lastUpdate > VOID_Core.Instance.updateTimer)
)	)
{	{
this.Refresh();	this.Refresh();
}	}
return (T)this.cache;	return (T)this.cache;
}	}
}	}

/*	/*
* Methods	* Methods
* */	* */
public VOID_DataValue(string Label, Func<T> ValueFunc, string Units = "")	public VOID_DataValue(string Label, Func<T> ValueFunc, string Units = "")
{	{
this.Label = Label;	this.Label = Label;
this.Units = Units;	this.Units = Units;
this.ValueFunc = ValueFunc;	this.ValueFunc = ValueFunc;
this.lastUpdate = 0;	this.lastUpdate = 0;
}	}

public void Refresh()	public void Refresh()
{	{
this.cache = this.ValueFunc.Invoke ();	this.cache = this.ValueFunc.Invoke ();
this.lastUpdate = VOID_Core.Instance.updateTimer;	this.lastUpdate = VOID_Core.Instance.updateTimer;
}	}

public T GetFreshValue()	public T GetFreshValue()
{	{
this.Refresh ();	this.Refresh ();
return (T)this.cache;	return (T)this.cache;
}	}

public string ValueUnitString() {	public virtual string ValueUnitString() {
return this.Value.ToString() + this.Units;	return this.Value.ToString() + this.Units;
}	}

public virtual void DoGUIHorizontal()	public virtual void DoGUIHorizontal()
{	{
GUILayout.BeginHorizontal (GUILayout.ExpandWidth (true));	GUILayout.BeginHorizontal (GUILayout.ExpandWidth (true));
GUILayout.Label (this.Label + ":");	GUILayout.Label (this.Label + ":");
GUILayout.FlexibleSpace ();	GUILayout.FlexibleSpace ();
GUILayout.Label (this.ValueUnitString(), GUILayout.ExpandWidth (false));	GUILayout.Label (this.ValueUnitString(), GUILayout.ExpandWidth (false));
GUILayout.EndHorizontal ();	GUILayout.EndHorizontal ();
}	}

public override string ToString()	public override string ToString()
{	{
return string.Format (	return string.Format (
"{0}: {1}{2}",	"{0}: {1}{2}",
this.Label,	this.Label,
this.Value.ToString (),	this.Value.ToString (),
this.Units	this.Units
);	);
}	}
}	}

public abstract class VOID_NumValue<T> : VOID_DataValue<T>	public abstract class VOID_NumValue<T> : VOID_DataValue<T>
where T : IFormattable, IConvertible, IComparable	where T : IFormattable, IConvertible, IComparable
{	{
public static implicit operator Double(VOID_NumValue<T> v)	public static implicit operator Double(VOID_NumValue<T> v)
{	{
return v.ToDouble();	return v.ToDouble();
}	}

public static implicit operator Int32(VOID_NumValue<T> v)	public static implicit operator Int32(VOID_NumValue<T> v)
{	{
return v.ToInt32();	return v.ToInt32();
}	}


public static implicit operator Single(VOID_NumValue<T> v)	public static implicit operator Single(VOID_NumValue<T> v)
{	{
return v.ToSingle();	return v.ToSingle();
}	}


protected IFormatProvider formatProvider;	protected IFormatProvider formatProvider;

public VOID_NumValue(string Label, Func<T> ValueFunc, string Units = "") : base(Label, ValueFunc, Units)	public VOID_NumValue(string Label, Func<T> ValueFunc, string Units = "") : base(Label, ValueFunc, Units)
{	{
this.formatProvider = System.Globalization.CultureInfo.CurrentUICulture;	this.formatProvider = System.Globalization.CultureInfo.CurrentUICulture;
}	}

public virtual double ToDouble(IFormatProvider provider)	public virtual double ToDouble(IFormatProvider provider)
{	{
return this.Value.ToDouble(provider);	return this.Value.ToDouble(provider);
}	}

public virtual double ToDouble()	public virtual double ToDouble()
{	{
return this.ToDouble(this.formatProvider);	return this.ToDouble(this.formatProvider);
}	}

public virtual int ToInt32(IFormatProvider provider)	public virtual int ToInt32(IFormatProvider provider)
{	{
return this.Value.ToInt32(provider);	return this.Value.ToInt32(provider);
}	}

public virtual int ToInt32()	public virtual int ToInt32()
{	{
return this.ToInt32(this.formatProvider);	return this.ToInt32(this.formatProvider);
}	}

public virtual float ToSingle(IFormatProvider provider)	public virtual float ToSingle(IFormatProvider provider)
{	{
return this.Value.ToSingle(provider);	return this.Value.ToSingle(provider);
}	}

public virtual float ToSingle()	public virtual float ToSingle()
{	{
return this.ToSingle(this.formatProvider);	return this.ToSingle(this.formatProvider);
}	}

public virtual string ToString(string Format)	public virtual string ToString(string Format)
{	{
return string.Format (	return string.Format (
"{0}: {1}{2}",	"{0}: {1}{2}",
this.Label,	this.Label,
this.Value.ToString(Format, this.formatProvider),	this.Value.ToString(Format, this.formatProvider),
this.Units	this.Units
);	);
}	}

public virtual string ToSIString(int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue)	public virtual string ToSIString(int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue)
{	{
return string.Format (	return string.Format (
"{0}{1}",	"{0}{1}",
Tools.MuMech_ToSI (this, digits, MinMagnitude, MaxMagnitude),	Tools.MuMech_ToSI (this, digits, MinMagnitude, MaxMagnitude),
this.Units	this.Units
);	);
}	}

public virtual string ValueUnitString(string format)	public virtual string ValueUnitString(string format)
{	{
return this.Value.ToString(format, this.formatProvider) + this.Units;	return this.Value.ToString(format, this.formatProvider) + this.Units;
}	}

public virtual string ValueUnitString(int digits) {	public virtual string ValueUnitString(int digits) {
return Tools.MuMech_ToSI(this, digits) + this.Units;	return Tools.MuMech_ToSI(this, digits) + this.Units;
}	}

public virtual string ValueUnitString(int digits, int MinMagnitude, int MaxMagnitude)	public virtual string ValueUnitString(int digits, int MinMagnitude, int MaxMagnitude)
{	{
return Tools.MuMech_ToSI(this, digits, MinMagnitude, MaxMagnitude) + this.Units;	return Tools.MuMech_ToSI(this, digits, MinMagnitude, MaxMagnitude) + this.Units;
}	}

public virtual void DoGUIHorizontal(string format)	public virtual void DoGUIHorizontal(string format)
{	{
GUILayout.BeginHorizontal (GUILayout.ExpandWidth (true));	GUILayout.BeginHorizontal (GUILayout.ExpandWidth (true));
GUILayout.Label (this.Label + ":");	GUILayout.Label (this.Label + ":");
GUILayout.FlexibleSpace ();	GUILayout.FlexibleSpace ();
GUILayout.Label (this.ValueUnitString(format), GUILayout.ExpandWidth (false));	GUILayout.Label (this.ValueUnitString(format), GUILayout.ExpandWidth (false));
GUILayout.EndHorizontal ();	GUILayout.EndHorizontal ();
}	}

public virtual int DoGUIHorizontal(int digits, bool precisionButton = true)	public virtual int DoGUIHorizontal(int digits, bool precisionButton = true)
{	{
if (precisionButton)	if (precisionButton)
{	{
return this.DoGUIHorizontalPrec(digits);	return this.DoGUIHorizontalPrec(digits);
}	}

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label(this.Label + ":", GUILayout.ExpandWidth(true));	GUILayout.Label(this.Label + ":", GUILayout.ExpandWidth(true));
GUILayout.FlexibleSpace();	GUILayout.FlexibleSpace();
GUILayout.Label(this.ValueUnitString(digits), GUILayout.ExpandWidth(false));	GUILayout.Label(this.ValueUnitString(digits), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

return digits;	return digits;
}	}

public virtual int DoGUIHorizontalPrec(int digits)	public virtual int DoGUIHorizontalPrec(int digits)
{	{
float magnitude;	double magnitude;
float magLimit;	double magLimit;

magnitude = (float)Math.Log10(Math.Abs(this));	magnitude = Math.Log10(Math.Abs((double)this));

magLimit = Mathf.Max(magnitude, 6f);	magLimit = Math.Max(Math.Abs(magnitude), 3d) + 3d;
magLimit = Mathf.Round((float)Math.Ceiling(magLimit / 3f) * 3f);	magLimit = Math.Round(Math.Ceiling(magLimit / 3f)) * 3d;

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label(this.Label + "ⁱ:", GUILayout.ExpandWidth(true));	GUILayout.Label(this.Label + "ⁱ:", GUILayout.ExpandWidth(true));
GUILayout.FlexibleSpace();	GUILayout.FlexibleSpace();

GUILayout.Label(this.ValueUnitString(3, int.MinValue, (int)magnitude - digits), GUILayout.ExpandWidth(false));	if (magnitude >= 0)
	{
	GUILayout.Label(this.ValueUnitString(3, int.MinValue, (int)magnitude - digits), GUILayout.ExpandWidth(false));
	}
	else
	{
	GUILayout.Label(this.ValueUnitString(3, (int)magnitude + digits, int.MaxValue), GUILayout.ExpandWidth(false));
	}
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

if (Event.current.type == EventType.mouseUp)	if (Event.current.type == EventType.mouseUp)
{	{
Rect lastRect = GUILayoutUtility.GetLastRect();	Rect lastRect = GUILayoutUtility.GetLastRect();
if (lastRect.Contains(Event.current.mousePosition))	if (lastRect.Contains(Event.current.mousePosition))
{	{
	Tools.PostDebugMessage(string.Format("{0}: Changing digits from {1} within magLimit {2}.",
	this.GetType().Name,
	digits,
	magLimit));

if (Event.current.button == 0)	if (Event.current.button == 0)
{	{
digits = (digits + 3) % (int)magLimit;	digits = (digits + 3) % (int)magLimit;
}	}
else if (Event.current.button == 1)	else if (Event.current.button == 1)
{	{
digits = (digits - 3) % (int)magLimit;	digits = (digits - 3) % (int)magLimit;
if (digits < 0)
{
digits = (int)magLimit - 3;
}
}	}

	if (digits < 0)
	{
	digits += (int)magLimit;
	}

	Tools.PostDebugMessage(string.Format("{0}: Changed digits to {1}." +
	"\n\tNew minMagnitude: {2}, maxMagnitude: {3}" +
	"\n\tMagnitude: {4}",
	this.GetType().Name,
	digits,
	magnitude >= 0 ? int.MinValue : (int)magnitude - 4 + digits,
	magnitude >= 0 ? (int)magnitude - digits : int.MaxValue,
	magnitude
	));
}	}
}	}

return digits;	return digits;
}	}
}	}

public class VOID_DoubleValue : VOID_NumValue<double>	public class VOID_DoubleValue : VOID_NumValue<double>
{	{
public VOID_DoubleValue(string Label, Func<double> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}	public VOID_DoubleValue(string Label, Func<double> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}
}	}

public class VOID_FloatValue : VOID_NumValue<float>	public class VOID_FloatValue : VOID_NumValue<float>
{	{
public VOID_FloatValue(string Label, Func<float> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}	public VOID_FloatValue(string Label, Func<float> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}
}	}

public class VOID_IntValue : VOID_NumValue<int>	public class VOID_IntValue : VOID_NumValue<int>
{	{
public VOID_IntValue(string Label, Func<int> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}	public VOID_IntValue(string Label, Func<int> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}
}	}

public class VOID_StrValue : VOID_DataValue<string>	public class VOID_StrValue : VOID_DataValue<string>
{	{
public VOID_StrValue(string Label, Func<string> ValueFunc) : base(Label, ValueFunc, "") {}	public VOID_StrValue(string Label, Func<string> ValueFunc) : base(Label, ValueFunc, "") {}
}	}

	public class VOID_Vector3dValue : VOID_DataValue<Vector3d>
	{
	public VOID_Vector3dValue(string Label, Func<Vector3d> ValueFunc, string Units)
	: base(Label, ValueFunc, Units)
	{}

	public string ToString(string format)
	{
	return string.Format("{0}: {1}{2}",
	this.Label,
	this.Value.ToString(format),
	this.Units
	);
	}

	public string ValueUnitString(string format) {
	return this.Value.ToString(format) + this.Units;
	}
	}
}	}

file:a/VOID_EditorCore.cs -> file:b/VOID_EditorCore.cs

	// VOID
//	//
// VOID_EditorCore.cs	// VOID_EditorCore.cs
//	//
// Author:	// Copyright © 2014, toadicus
// toadicus <>	// All rights reserved.
//	//
// Copyright (c) 2013 toadicus	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
//	//
// This program is free software: you can redistribute it and/or modify	// 1. Redistributions of source code must retain the above copyright notice,
// it under the terms of the GNU General Public License as published by	// this list of conditions and the following disclaimer.
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using Engineer.VesselSimulator;	using Engineer.VesselSimulator;
using KSP;	using KSP;
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using System.Linq;	using System.Linq;
	using ToadicusTools;
using UnityEngine;	using UnityEngine;

namespace VOID	namespace VOID
{	{
public class VOID_EditorCore : VOID_Core	public class VOID_EditorCore : VOID_Core
{	{
/*	/*
* Static Members	* Static Members
* */	* */
protected new static bool _initialized = false;	protected new static bool _initialized = false;
public new static bool Initialized	public new static bool Initialized
{	{
get	get
{	{
return _initialized;	return _initialized;
}	}
}	}

protected new static VOID_EditorCore _instance;	protected new static VOID_EditorCore _instance;
public new static VOID_EditorCore Instance	public new static VOID_EditorCore Instance
{	{
get	get
{	{
if (_instance == null)	if (_instance == null)
{	{
_instance = new VOID_EditorCore();	_instance = new VOID_EditorCore();
_initialized = true;	_initialized = true;
}	}
return _instance;	return _instance;
}	}
}	}

public new static void Reset()	public new static void Reset()
{	{
if (_initialized)	if (_initialized)
{	{
_instance.StopGUI();	_instance.StopGUI();
_instance = null;	_instance = null;
_initialized = false;	_initialized = false;
}	}
}	}

	protected override ApplicationLauncher.AppScenes appIconVisibleScenes
	{
	get
	{
	return ApplicationLauncher.AppScenes.VAB \| ApplicationLauncher.AppScenes.SPH;
	}
	}

public VOID_EditorCore() : base()	public VOID_EditorCore() : base()
{	{
this._Name = "VOID Editor Core";	this._Name = "VOID Editor Core";
}	}

public new void OnGUI() {}	public override void OnGUI() {}

public override void DrawGUI()	public override void DrawGUI()
{	{
if (!this._modulesLoaded)	if (!this._modulesLoaded)
{	{
this.LoadModulesOfType<IVOID_EditorModule>();	this.LoadModulesOfType<IVOID_EditorModule>();
}	}

Rect _iconPos = Tools.DockToWindow (this.VOIDIconPos, this.mainWindowPos);	Rect _iconPos = Tools.DockToWindow (this.VOIDIconPos, this.mainWindowPos);

_iconPos = Tools.ClampRectToScreen (_iconPos, (int)_iconPos.width, (int)_iconPos.height);	_iconPos = Tools.ClampRectToScreen (_iconPos, (int)_iconPos.width, (int)_iconPos.height);

if (_iconPos != this.VOIDIconPos)	if (_iconPos != this.VOIDIconPos)
{	{
this.VOIDIconPos = _iconPos;	this.VOIDIconPos = _iconPos;
}	}

base.DrawGUI();	base.DrawGUI();
}	}

public new void Update()	public override void Update()
{	{
foreach (IVOID_EditorModule module in this.Modules)	foreach (IVOID_EditorModule module in this.Modules)
{	{
if (EditorLogic.startPod == null)	if (EditorLogic.startPod == null)
{	{
module.StopGUI();	module.StopGUI();
continue;	continue;
}	}
if (HighLogic.LoadedSceneIsEditor && module.toggleActive && EditorLogic.SortedShipList.Any())	if (HighLogic.LoadedSceneIsEditor && module.toggleActive && EditorLogic.SortedShipList.Any())
{	{
module.StartGUI();	module.StartGUI();
}	}
if (!HighLogic.LoadedSceneIsEditor \|\| !module.toggleActive \|\| !EditorLogic.SortedShipList.Any())	if (!HighLogic.LoadedSceneIsEditor \|\| !module.toggleActive \|\| !EditorLogic.SortedShipList.Any())
{	{
module.StopGUI();	module.StopGUI();
}	}
}	}

if (EditorLogic.startPod == null \|\| !HighLogic.LoadedSceneIsEditor)	if (EditorLogic.startPod == null \|\| !HighLogic.LoadedSceneIsEditor)
{	{
this.StopGUI();	this.StopGUI();
return;	return;
}	}
else if (!this.guiRunning && HighLogic.LoadedSceneIsEditor)	else if (!this.guiRunning && HighLogic.LoadedSceneIsEditor)
{	{
this.StartGUI();	this.StartGUI();
}	}

if (EditorLogic.SortedShipList.Count > 0)	if (EditorLogic.SortedShipList.Count > 0 && this.vesselSimActive)
{	{
SimManager.Instance.Gravity = VOID_Data.KerbinGee;	Tools.PostDebugMessage(this, "Updating SimManager.");
SimManager.Instance.TryStartSimulation();	this.UpdateSimManager();
}	}

this.CheckAndSave ();	this.CheckAndSave ();
}	}

public new void FixedUpdate() {}	public override void FixedUpdate() {}
}	}
}	}

file:a/VOID_EditorHUD.cs -> file:b/VOID_EditorHUD.cs

//	// VOID
// VOID_Hud.cs	//
//	// VOID_EditorHUD.cs
// Author:	//
// toadicus <>	// Copyright © 2014, toadicus
//	// All rights reserved.
// Copyright (c) 2013 toadicus	//
//	// Redistribution and use in source and binary forms, with or without modification,
// This program is free software: you can redistribute it and/or modify	// are permitted provided that the following conditions are met:
// it under the terms of the GNU General Public License as published by	//
// the Free Software Foundation, either version 3 of the License, or	// 1. Redistributions of source code must retain the above copyright notice,
// (at your option) any later version.	// this list of conditions and the following disclaimer.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.	//
//	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// You should have received a copy of the GNU General Public License	// to endorse or promote products derived from this software without specific prior written permission.
// along with this program. If not, see <http://www.gnu.org/licenses/>.	//
//	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using Engineer.VesselSimulator;	using Engineer.VesselSimulator;
using KSP;	using KSP;
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using System.Linq;	using System.Linq;
using System.Text;	using System.Text;
	using ToadicusTools;
using UnityEngine;	using UnityEngine;

namespace VOID	namespace VOID
{	{
public class VOID_EditorHUD : VOID_Module, IVOID_EditorModule	public class VOID_EditorHUD : VOID_Module, IVOID_EditorModule
{	{
/*	/*
* Fields	* Fields
* */	* */
[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 EditorVesselOverlays _vesselOverlays;	protected EditorVesselOverlays _vesselOverlays;

/*	/*
* 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;
}	}
}	}

protected EditorVesselOverlays vesselOverlays	protected EditorVesselOverlays vesselOverlays
{	{
get	get
{	{
if (this._vesselOverlays == null)	if (this._vesselOverlays == null)
{	{
this._vesselOverlays = (EditorVesselOverlays)Resources	this._vesselOverlays = (EditorVesselOverlays)Resources
.FindObjectsOfTypeAll(typeof(EditorVesselOverlays))	.FindObjectsOfTypeAll(typeof(EditorVesselOverlays))
.FirstOrDefault();	.FirstOrDefault();
}	}

return this._vesselOverlays;	return this._vesselOverlays;
}	}
}	}

protected EditorMarker_CoM CoMmarker	protected EditorMarker_CoM CoMmarker
{	{
get	get
{	{
if (this.vesselOverlays == null)	if (this.vesselOverlays == null)
{	{
return null;	return null;
}	}

return this.vesselOverlays.CoMmarker;	return this.vesselOverlays.CoMmarker;
}	}
}	}

protected EditorMarker_CoT CoTmarker	protected EditorMarker_CoT CoTmarker
{	{
get	get
{	{
if (this.vesselOverlays == null)	if (this.vesselOverlays == null)
{	{
return null;	return null;
}	}

return this.vesselOverlays.CoTmarker;	return this.vesselOverlays.CoTmarker;
}	}
}	}

/*	/*
* Methods	* Methods
* */	* */
public VOID_EditorHUD() : base()	public VOID_EditorHUD() : base()
{	{
this._Name = "Heads-Up Display";	this._Name = "Heads-Up Display";

this._Active.value = true;	this.toggleActive = true;

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.alignment = TextAnchor.UpperRight;	// this.labelStyle.alignment = TextAnchor.UpperRight;
this.labelStyle.normal.textColor = this.textColors [this.ColorIndex];	this.labelStyle.normal.textColor = this.textColors [this.ColorIndex];

Tools.PostDebugMessage (this.GetType().Name + ": Constructed.");	Tools.PostDebugMessage (this.GetType().Name + ": Constructed.");
}	}

public override void DrawGUI()	public override void DrawGUI()
{	{
SimManager.Instance.RequestSimulation();	SimManager.RequestSimulation();

if (SimManager.Instance.LastStage == null)	if (this.core.LastStage == null)
{	{
return;	return;
}	}

float hudLeft;	float hudLeft;
StringBuilder hudString;	StringBuilder hudString;

if (EditorLogic.fetch.editorScreen == EditorLogic.EditorScreen.Parts)	if (EditorLogic.fetch.editorScreen == EditorLogic.EditorScreen.Parts)
{	{
hudLeft = EditorPanels.Instance.partsPanelWidth + 10;	hudLeft = EditorPanels.Instance.partsPanelWidth + 10;
}	}
else if (EditorLogic.fetch.editorScreen == EditorLogic.EditorScreen.Actions)	else if (EditorLogic.fetch.editorScreen == EditorLogic.EditorScreen.Actions)
{	{
hudLeft = EditorPanels.Instance.actionsPanelWidth + 10;	hudLeft = EditorPanels.Instance.actionsPanelWidth + 10;
}	}
else	else
{	{
return;	return;
}	}

	GUI.skin = this.core.Skin;

Rect hudPos = new Rect (hudLeft, 48, 300, 32);	Rect hudPos = new Rect (hudLeft, 48, 300, 32);

hudString = new StringBuilder();	hudString = new StringBuilder();

// GUI.skin = AssetBase.GetGUISkin("KSP window 2");	// GUI.skin = AssetBase.GetGUISkin("KSP window 2");

labelStyle.normal.textColor = textColors [ColorIndex];	labelStyle.normal.textColor = textColors [ColorIndex];

hudString.Append("Total Mass: ");	hudString.Append("Total Mass: ");
hudString.Append(SimManager.Instance.LastStage.totalMass.ToString("F3"));	hudString.Append(this.core.LastStage.totalMass.ToString("F3"));
hudString.Append('t');	hudString.Append('t');

hudString.Append(' ');	hudString.Append(' ');

hudString.Append("Part Count: ");	hudString.Append("Part Count: ");
hudString.Append(EditorLogic.SortedShipList.Count);	hudString.Append(EditorLogic.SortedShipList.Count);

hudString.Append('\n');	hudString.Append('\n');

hudString.Append("Total Delta-V: ");	hudString.Append("Total Delta-V: ");
hudString.Append(Tools.MuMech_ToSI(SimManager.Instance.LastStage.totalDeltaV));	hudString.Append(Tools.MuMech_ToSI(this.core.LastStage.totalDeltaV));
hudString.Append("m/s");	hudString.Append("m/s");

hudString.Append('\n');	hudString.Append('\n');

hudString.Append("Bottom Stage Delta-V");	hudString.Append("Bottom Stage Delta-V");
hudString.Append(Tools.MuMech_ToSI(SimManager.Instance.LastStage.deltaV));	hudString.Append(Tools.MuMech_ToSI(this.core.LastStage.deltaV));
hudString.Append("m/s");	hudString.Append("m/s");

hudString.Append('\n');	hudString.Append('\n');

hudString.Append("Bottom Stage T/W Ratio: ");	hudString.Append("Bottom Stage T/W Ratio: ");
hudString.Append(SimManager.Instance.LastStage.thrustToWeight.ToString("F3"));	hudString.Append(this.core.LastStage.thrustToWeight.ToString("F3"));

if (this.CoMmarker.gameObject.activeInHierarchy && this.CoTmarker.gameObject.activeInHierarchy)	if (this.CoMmarker.gameObject.activeInHierarchy && this.CoTmarker.gameObject.activeInHierarchy)
{	{
hudString.Append('\n');	hudString.Append('\n');

hudString.Append("Thrust Offset: ");	hudString.Append("Thrust Offset: ");
hudString.Append(	hudString.Append(
Vector3.Cross(	Vector3.Cross(
this.CoTmarker.dirMarkerObject.transform.forward,	this.CoTmarker.dirMarkerObject.transform.forward,
this.CoMmarker.posMarkerObject.transform.position - this.CoTmarker.posMarkerObject.transform.position	this.CoMmarker.posMarkerObject.transform.position - this.CoTmarker.posMarkerObject.transform.position
).ToString("F3"));	).ToString("F3"));
}	}

GUI.Label (	GUI.Label (
hudPos,	hudPos,
hudString.ToString(),	hudString.ToString(),
labelStyle);	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;
}	}
}	}
}	}
}	}

file:a/VOID_HUD.cs -> file:b/VOID_HUD.cs

//	// VOID
// VOID_Hud.cs	//
//	// VOID_HUD.cs
// Author:	//
// toadicus <>	// Copyright © 2014, toadicus
//	// All rights reserved.
// Copyright (c) 2013 toadicus	//
//	// Redistribution and use in source and binary forms, with or without modification,
// This program is free software: you can redistribute it and/or modify	// are permitted provided that the following conditions are met:
// it under the terms of the GNU General Public License as published by	//
// the Free Software Foundation, either version 3 of the License, or	// 1. Redistributions of source code must retain the above copyright notice,
// (at your option) any later version.	// this list of conditions and the following disclaimer.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.	//
//	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// You should have received a copy of the GNU General Public License	// to endorse or promote products derived from this software without specific prior written permission.
// along with this program. If not, see <http://www.gnu.org/licenses/>.	//
//	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using Engineer.VesselSimulator;	using Engineer.VesselSimulator;
using KSP;	using KSP;
using UnityEngine;
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using System.Text;	using System.Text;
	using ToadicusTools;
	using UnityEngine;

namespace VOID	namespace VOID
{	{
public class VOID_HUD : VOID_Module, IVOID_Module	public class VOID_HUD : VOID_Module, IVOID_Module
{	{
/*	/*
* Fields	* Fields
* */	* */
[AVOID_SaveValue("colorIndex")]	[AVOID_SaveValue("colorIndex")]
protected VOID_SaveValue<int> _colorIndex;	protected VOID_SaveValue<int> _colorIndex;

protected List<Color> textColors;	protected List<Color> textColors;

protected Rect leftHUDdefaultPos;	protected Rect leftHUDdefaultPos;
protected Rect rightHUDdefaultPos;	protected Rect rightHUDdefaultPos;

[AVOID_SaveValue("leftHUDPos")]	[AVOID_SaveValue("leftHUDPos")]
protected VOID_SaveValue<Rect> leftHUDPos;	protected VOID_SaveValue<Rect> leftHUDPos;
[AVOID_SaveValue("rightHUDPos")]	[AVOID_SaveValue("rightHUDPos")]
protected VOID_SaveValue<Rect> rightHUDPos;	protected VOID_SaveValue<Rect> rightHUDPos;

[AVOID_SaveValue("positionsLocked")]	[AVOID_SaveValue("positionsLocked")]
protected VOID_SaveValue<bool> positionsLocked;	protected VOID_SaveValue<bool> positionsLocked;

/*	/*
* 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._Active.value = true;	this.toggleActive = true;

this._colorIndex = 0;	this._colorIndex = 0;

this.textColors = new List<Color>();	this.textColors = new List<Color>();

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.leftHUDdefaultPos = new Rect(Screen.width * .375f - 300f, 0f, 300f, 90f);	this.leftHUDdefaultPos = new Rect(Screen.width * .375f - 300f, 0f, 300f, 90f);
this.leftHUDPos = new Rect(this.leftHUDdefaultPos);	this.leftHUDPos = new Rect(this.leftHUDdefaultPos);

this.rightHUDdefaultPos = new Rect(Screen.width * .625f, 0f, 300f, 90f);	this.rightHUDdefaultPos = new Rect(Screen.width * .625f, 0f, 300f, 90f);
this.rightHUDPos = new Rect(this.rightHUDdefaultPos);	this.rightHUDPos = new Rect(this.rightHUDdefaultPos);

this.positionsLocked = true;	this.positionsLocked = true;

Tools.PostDebugMessage ("VOID_HUD: Constructed.");	Tools.PostDebugMessage ("VOID_HUD: Constructed.");
}	}

protected void leftHUDWindow(int id)	protected void leftHUDWindow(int id)
{	{
StringBuilder leftHUD;	StringBuilder leftHUD;

leftHUD = new StringBuilder();	leftHUD = new StringBuilder();

VOID_Core.Instance.LabelStyles["hud"].alignment = TextAnchor.UpperRight;	this.core.LabelStyles["hud"].alignment = TextAnchor.UpperRight;

if (VOID_Core.Instance.powerAvailable)	if (this.core.powerAvailable)
{	{
leftHUD.AppendFormat("Primary: {0} Inc: {1}",	leftHUD.AppendFormat("Primary: {0} Inc: {1}",
VOID_Data.primaryName.ValueUnitString(),	VOID_Data.primaryName.ValueUnitString(),
VOID_Data.orbitInclination.ValueUnitString("F3")	VOID_Data.orbitInclination.ValueUnitString("F3")
);	);
leftHUD.AppendFormat("\nObt Alt: {0} Obt Vel: {1}",	leftHUD.AppendFormat("\nObt Alt: {0} Obt Vel: {1}",
VOID_Data.orbitAltitude.ToSIString(),	VOID_Data.orbitAltitude.ToSIString(),
VOID_Data.orbitVelocity.ToSIString()	VOID_Data.orbitVelocity.ToSIString()
);	);
leftHUD.AppendFormat("\nAp: {0} ETA {1}",	leftHUD.AppendFormat("\nAp: {0} ETA {1}",
VOID_Data.orbitApoAlt.ToSIString(),	VOID_Data.orbitApoAlt.ToSIString(),
VOID_Data.timeToApo.ValueUnitString()	VOID_Data.timeToApo.ValueUnitString()
);	);
leftHUD.AppendFormat("\nPe: {0} ETA {1}",	leftHUD.AppendFormat("\nPe: {0} ETA {1}",
VOID_Data.oribtPeriAlt.ToSIString(),	VOID_Data.oribtPeriAlt.ToSIString(),
VOID_Data.timeToPeri.ValueUnitString()	VOID_Data.timeToPeri.ValueUnitString()
);	);
leftHUD.AppendFormat("\nTot Δv: {0} Stg Δv: {1}",	leftHUD.AppendFormat("\nTot Δv: {0} Stg Δv: {1}",
VOID_Data.totalDeltaV.ToSIString(2),	VOID_Data.totalDeltaV.ToSIString(2),
VOID_Data.stageDeltaV.ToSIString(2)	VOID_Data.stageDeltaV.ToSIString(2)
);	);
}	}
else	else
{	{
VOID_Core.Instance.LabelStyles["hud"].normal.textColor = Color.red;	this.core.LabelStyles["hud"].normal.textColor = Color.red;
leftHUD.Append(string.Intern("-- POWER LOST --"));	leftHUD.Append(string.Intern("-- POWER LOST --"));
}	}

GUILayout.Label(leftHUD.ToString(), VOID_Core.Instance.LabelStyles["hud"], GUILayout.ExpandWidth(true));	GUILayout.Label(leftHUD.ToString(), this.core.LabelStyles["hud"], GUILayout.ExpandWidth(true));

if (!this.positionsLocked)	if (!this.positionsLocked)
{	{
GUI.DragWindow();	GUI.DragWindow();
}	}

GUI.BringWindowToBack(id);	GUI.BringWindowToBack(id);
}	}

protected void rightHUDWindow(int id)	protected void rightHUDWindow(int id)
{	{
StringBuilder rightHUD;	StringBuilder rightHUD;

rightHUD = new StringBuilder();	rightHUD = new StringBuilder();

VOID_Core.Instance.LabelStyles["hud"].alignment = TextAnchor.UpperLeft;	this.core.LabelStyles["hud"].alignment = TextAnchor.UpperLeft;

if (VOID_Core.Instance.powerAvailable)	if (this.core.powerAvailable)
{	{
rightHUD.AppendFormat("Biome: {0} Sit: {1}",	rightHUD.AppendFormat("Biome: {0} Sit: {1}",
VOID_Data.currBiome.ValueUnitString(),	VOID_Data.currBiome.ValueUnitString(),
VOID_Data.expSituation.ValueUnitString()	VOID_Data.expSituation.ValueUnitString()
);	);
rightHUD.AppendFormat("\nSrf Alt: {0} Srf Vel: {1}",	rightHUD.AppendFormat("\nSrf Alt: {0} Srf Vel: {1}",
VOID_Data.trueAltitude.ToSIString(),	VOID_Data.trueAltitude.ToSIString(),
VOID_Data.surfVelocity.ToSIString()	VOID_Data.surfVelocity.ToSIString()
);	);
rightHUD.AppendFormat("\nVer: {0} Hor: {1}",	rightHUD.AppendFormat("\nVer: {0} Hor: {1}",
VOID_Data.vertVelocity.ToSIString(),	VOID_Data.vertVelocity.ToSIString(),
VOID_Data.horzVelocity.ToSIString()	VOID_Data.horzVelocity.ToSIString()
);	);
rightHUD.AppendFormat("\nLat: {0} Lon: {1}",	rightHUD.AppendFormat("\nLat: {0} Lon: {1}",
VOID_Data.surfLatitude.ValueUnitString(),	VOID_Data.surfLatitude.ValueUnitString(),
VOID_Data.surfLongitude.ValueUnitString()	VOID_Data.surfLongitude.ValueUnitString()
);	);
rightHUD.AppendFormat("\nHdg: {0} Pit: {1}",	rightHUD.AppendFormat("\nHdg: {0} Pit: {1}",
VOID_Data.vesselHeading.ValueUnitString(),	VOID_Data.vesselHeading.ValueUnitString(),
VOID_Data.vesselPitch.ToSIString(2)	VOID_Data.vesselPitch.ToSIString(2)
);	);
}	}
else	else
{	{
VOID_Core.Instance.LabelStyles["hud"].normal.textColor = Color.red;	this.core.LabelStyles["hud"].normal.textColor = Color.red;
rightHUD.Append(string.Intern("-- POWER LOST --"));	rightHUD.Append(string.Intern("-- POWER LOST --"));
}	}


GUILayout.Label(rightHUD.ToString(), VOID_Core.Instance.LabelStyles["hud"], GUILayout.ExpandWidth(true));	GUILayout.Label(rightHUD.ToString(), this.core.LabelStyles["hud"], GUILayout.ExpandWidth(true));

if (!this.positionsLocked)	if (!this.positionsLocked)
{	{
GUI.DragWindow();	GUI.DragWindow();
}	}

GUI.BringWindowToBack(id);	GUI.BringWindowToBack(id);
}	}

public override void DrawGUI()	public override void DrawGUI()
{	{
if (!VOID_Core.Instance.LabelStyles.ContainsKey("hud"))	if (!this.core.LabelStyles.ContainsKey("hud"))
{	{
VOID_Core.Instance.LabelStyles["hud"] = new GUIStyle(GUI.skin.label);	this.core.LabelStyles["hud"] = new GUIStyle(GUI.skin.label);
}	}

VOID_Core.Instance.LabelStyles["hud"].normal.textColor = textColors [ColorIndex];	this.core.LabelStyles["hud"].normal.textColor = textColors [ColorIndex];

	GUI.skin = this.core.Skin;

if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) \|\| (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))	if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) \|\| (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))
{	{
SimManager.Instance.RequestSimulation();	SimManager.RequestSimulation();
}	}

this.leftHUDPos.value = GUI.Window(	this.leftHUDPos.value = GUI.Window(
VOID_Core.Instance.windowID,	this.core.windowID,
this.leftHUDPos,	this.leftHUDPos,
this.leftHUDWindow,	this.leftHUDWindow,
GUIContent.none,	GUIContent.none,
GUIStyle.none	GUIStyle.none
);	);

this.rightHUDPos.value = GUI.Window(	this.rightHUDPos.value = GUI.Window(
VOID_Core.Instance.windowID,	this.core.windowID,
this.rightHUDPos,	this.rightHUDPos,
this.rightHUDWindow,	this.rightHUDWindow,
GUIContent.none,	GUIContent.none,
GUIStyle.none	GUIStyle.none
);	);
}	}

public override void DrawConfigurables()	public override void DrawConfigurables()
{	{
if (GUILayout.Button (string.Intern("Change HUD color"), GUILayout.ExpandWidth (false)))	if (GUILayout.Button (string.Intern("Change HUD color"), GUILayout.ExpandWidth (false)))
{	{
++this.ColorIndex;	++this.ColorIndex;
}	}

if (GUILayout.Button(string.Intern("Reset HUD Positions"), GUILayout.ExpandWidth(false)))	if (GUILayout.Button(string.Intern("Reset HUD Positions"), GUILayout.ExpandWidth(false)))
{	{
this.leftHUDPos = new Rect(this.leftHUDdefaultPos);	this.leftHUDPos = new Rect(this.leftHUDdefaultPos);
this.rightHUDPos = new Rect(this.rightHUDdefaultPos);	this.rightHUDPos = new Rect(this.rightHUDdefaultPos);
}	}

this.positionsLocked = GUILayout.Toggle(this.positionsLocked,	this.positionsLocked = GUILayout.Toggle(this.positionsLocked,
string.Intern("Lock HUD Positions"),	string.Intern("Lock HUD Positions"),
GUILayout.ExpandWidth(false));	GUILayout.ExpandWidth(false));
}	}
}	}

public static partial class VOID_Data	public static partial class VOID_Data
{	{
public static readonly VOID_StrValue expSituation = new VOID_StrValue(	public static readonly VOID_StrValue expSituation = new VOID_StrValue(
"Situation",	"Situation",
new Func<string> (() => VOID_Core.Instance.vessel.GetExperimentSituation().HumanString())	new Func<string> (() => core.vessel.GetExperimentSituation().HumanString())
);	);

public static readonly VOID_DoubleValue vesselPitch = new VOID_DoubleValue(	public static readonly VOID_DoubleValue vesselPitch = new VOID_DoubleValue(
"Pitch",	"Pitch",
() => core.vessel.getSurfacePitch(),	() => core.vessel.getSurfacePitch(),
"°"	"°"
);	);

public static readonly VOID_DoubleValue stageMassFlow = new VOID_DoubleValue(
"Stage Mass Flow",
delegate()
{
if (simManager.LastStage == null)
{
return double.NaN;
}

double stageIsp = simManager.LastStage.isp;
double stageThrust = simManager.LastStage.actualThrust;

return stageThrust / (stageIsp * KerbinGee);
},
"Mg/s"
);

public static readonly VOID_DoubleValue burnTimeCompleteAtNode = new VOID_DoubleValue(
"Full burn time to complete at node",
delegate()
{
if (simManager.LastStage == null)
{
return double.NaN;
}

double nextManeuverDV = core.vessel.patchedConicSolver.maneuverNodes[0].DeltaV.magnitude;
double stageThrust = simManager.LastStage.actualThrust;

return burnTime(nextManeuverDV, totalMass, stageMassFlow, stageThrust);
},
"s"
);

public static readonly VOID_DoubleValue burnTimeHalfDoneAtNode = new VOID_DoubleValue(
"Full burn time to be half done at node",
delegate()
{
if (simManager.LastStage == null)
{
return double.NaN;
}

double nextManeuverDV = core.vessel.patchedConicSolver.maneuverNodes[0].DeltaV.magnitude / 2d;
double stageThrust = simManager.LastStage.actualThrust;

return burnTime(nextManeuverDV, totalMass, stageMassFlow, stageThrust);
},
"s"
);

private static double burnTime(double deltaV, double initialMass, double massFlow, double thrust)
{
return initialMass / massFlow * (Math.Exp(deltaV * massFlow / thrust) - 1d);
}
}	}
}	}

file:b/VOID_HUDAdvanced.cs (new)

	// VOID
	//
	// VOID_HUD.cs
	//
	// Copyright © 2014, toadicus
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice,
	// this list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation and/or other
	// materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	using Engineer.VesselSimulator;
	using KSP;
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Text;
	using ToadicusTools;
	using UnityEngine;

	namespace VOID
	{
	public class VOID_HUDAdvanced : VOID_Module, IVOID_Module
	{
	/*
	* Fields
	* */
	protected VOID_HUD primaryHUD;

	protected Rect leftHUDdefaultPos;
	protected Rect rightHUDdefaultPos;

	[AVOID_SaveValue("leftHUDPos")]
	protected VOID_SaveValue<Rect> leftHUDPos;
	[AVOID_SaveValue("rightHUDPos")]
	protected VOID_SaveValue<Rect> rightHUDPos;

	[AVOID_SaveValue("positionsLocked")]
	protected VOID_SaveValue<bool> positionsLocked;

	/*
	* Properties
	* */
	public int ColorIndex
	{
	get
	{
	if (this.primaryHUD == null)
	{
	return 0;
	}

	return this.primaryHUD.ColorIndex;
	}
	}

	/*
	* Methods
	* */
	public VOID_HUDAdvanced() : base()
	{
	this._Name = "Advanced Heads-Up Display";

	this.toggleActive = true;

	this.leftHUDdefaultPos = new Rect(
	Screen.width * .5f - (float)GameSettings.UI_SIZE * .25f - 300f,
	Screen.height - 200f,
	300f, 90f
	);
	this.leftHUDPos = new Rect(this.leftHUDdefaultPos);

	this.rightHUDdefaultPos = new Rect(
	Screen.width * .5f + (float)GameSettings.UI_SIZE * .25f,
	Screen.height - 200f,
	300f, 90f
	);
	this.rightHUDPos = new Rect(this.rightHUDdefaultPos);

	this.positionsLocked = true;

	Tools.PostDebugMessage (this, "Constructed.");
	}

	protected void leftHUDWindow(int id)
	{
	StringBuilder leftHUD;

	leftHUD = new StringBuilder();

	this.core.LabelStyles["hud"].alignment = TextAnchor.UpperRight;

	if (this.core.powerAvailable)
	{
	leftHUD.AppendFormat(
	string.Intern("Mass: {0}\n"),
	VOID_Data.totalMass.ToSIString(2)
	);

	if (VOID_Data.vesselCrewCapacity > 0)
	{
	leftHUD.AppendFormat(
	string.Intern("Crew: {0} / {1}\n"),
	VOID_Data.vesselCrewCount.Value,
	VOID_Data.vesselCrewCapacity.Value
	);
	}

	leftHUD.AppendFormat(
	string.Intern("Acc: {0} T:W: {1}\n"),
	VOID_Data.vesselAccel.ToSIString(2),
	VOID_Data.currThrustWeight.Value.ToString("f2")
	);

	leftHUD.AppendFormat(
	string.Intern("Ang Vel: {0}\n"),
	VOID_Data.vesselAngularVelocity.ToSIString(2)
	);

	if (VOID_Data.stageNominalThrust != 0d)
	{
	leftHUD.AppendFormat(
	string.Intern("Thrust Offset: {0}\n"),
	VOID_Data.vesselThrustOffset.Value.ToString("F1")
	);
	}
	}
	else
	{
	this.core.LabelStyles["hud"].normal.textColor = Color.red;
	leftHUD.Append(string.Intern("-- POWER LOST --"));
	}

	GUILayout.Label(leftHUD.ToString(), this.core.LabelStyles["hud"], GUILayout.ExpandWidth(true));

	if (!this.positionsLocked)
	{
	GUI.DragWindow();
	}

	GUI.BringWindowToBack(id);
	}

	protected void rightHUDWindow(int id)
	{
	StringBuilder rightHUD;

	rightHUD = new StringBuilder();

	this.core.LabelStyles["hud"].alignment = TextAnchor.UpperLeft;

	if (this.core.powerAvailable)
	{
	rightHUD.AppendFormat(
	"Burn Δv (Rem/Tot): {0} / {1}\n",
	VOID_Data.currManeuverDVRemaining.ValueUnitString("f2"),
	VOID_Data.currManeuverDeltaV.ValueUnitString("f2")
	);

	if (VOID_Data.upcomingManeuverNodes > 1)
	{
	rightHUD.AppendFormat("Next Burn Δv: {0}\n",
	VOID_Data.nextManeuverDeltaV.ValueUnitString("f2")
	);
	}

	rightHUD.AppendFormat("Burn Time (Rem/Total): {0} / {1}\n",
	VOID_Tools.ConvertInterval(VOID_Data.currentNodeBurnRemaining.Value),
	VOID_Tools.ConvertInterval(VOID_Data.currentNodeBurnDuration.Value)
	);

	if (VOID_Data.burnTimeDoneAtNode.Value != string.Empty)
	{
	rightHUD.AppendFormat("{0} (done @ node)\n",
	VOID_Data.burnTimeDoneAtNode.Value
	);

	rightHUD.AppendFormat("{0} (½ done @ node)",
	VOID_Data.burnTimeHalfDoneAtNode.Value
	);
	}
	else
	{
	rightHUD.Append("Node is past");
	}
	}
	else
	{
	this.core.LabelStyles["hud"].normal.textColor = Color.red;
	rightHUD.Append(string.Intern("-- POWER LOST --"));
	}

	GUILayout.Label(rightHUD.ToString(), this.core.LabelStyles["hud"], GUILayout.ExpandWidth(true));

	if (!this.positionsLocked)
	{
	GUI.DragWindow();
	}

	GUI.BringWindowToBack(id);
	}

	public override void DrawGUI()
	{
	if (this.primaryHUD == null)
	{
	foreach (IVOID_Module module in this.core.Modules)
	{
	if (module is VOID_HUD)
	{
	this.primaryHUD = module as VOID_HUD;
	}
	}
	}
	else
	{
	if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) \|\| (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))
	{
	SimManager.RequestSimulation();
	}

	this.leftHUDPos.value = GUI.Window(
	this.core.windowID,
	this.leftHUDPos,
	VOID_Tools.GetWindowHandler(this.leftHUDWindow),
	GUIContent.none,
	GUIStyle.none
	);

	if (VOID_Data.upcomingManeuverNodes > 0)
	{
	this.rightHUDPos.value = GUI.Window(
	this.core.windowID,
	this.rightHUDPos,
	VOID_Tools.GetWindowHandler(this.rightHUDWindow),
	GUIContent.none,
	GUIStyle.none
	);
	}
	}
	}

	public override void DrawConfigurables()
	{
	this.positionsLocked = GUILayout.Toggle(this.positionsLocked,
	string.Intern("Lock Advanced HUD Positions"),
	GUILayout.ExpandWidth(false));
	}
	}

	public static partial class VOID_Data
	{
	public static int upcomingManeuverNodes
	{
	get
	{
	if (core.vessel == null \|\|
	core.vessel.patchedConicSolver == null \|\|
	core.vessel.patchedConicSolver.maneuverNodes == null
	)
	{
	return 0;
	}

	return core.vessel.patchedConicSolver.maneuverNodes.Count;
	}
	}

	public static readonly VOID_Vector3dValue vesselThrustOffset = new VOID_Vector3dValue(
	"Thrust Offset",
	delegate()
	{
	if (core.vessel == null)
	{
	return Vector3d.zero;
	}

	List<PartModule> engineModules = core.vessel.getModulesOfType<PartModule>();

	Vector3d thrustPos = Vector3d.zero;
	Vector3d thrustDir = Vector3d.zero;
	float thrust = 0;

	foreach (PartModule engine in engineModules)
	{
	float moduleThrust = 0;

	switch (engine.moduleName)
	{
	case "ModuleEngines":
	case "ModuleEnginesFX":
	break;
	default:
	continue;
	}

	if (!engine.isEnabled)
	{
	continue;
	}

	CenterOfThrustQuery cotQuery = new CenterOfThrustQuery();

	if (engine is ModuleEngines)
	{
	ModuleEngines engineModule = engine as ModuleEngines;

	moduleThrust = engineModule.finalThrust;

	engineModule.OnCenterOfThrustQuery(cotQuery);
	}
	else // engine is ModuleEnginesFX
	{
	ModuleEnginesFX engineFXModule = engine as ModuleEnginesFX;

	moduleThrust = engineFXModule.finalThrust;

	engineFXModule.OnCenterOfThrustQuery(cotQuery);
	}

	if (moduleThrust != 0d)
	{
	cotQuery.thrust = moduleThrust;
	}

	thrustPos += cotQuery.pos * cotQuery.thrust;
	thrustDir += cotQuery.dir * cotQuery.thrust;
	thrust += cotQuery.thrust;
	}

	if (thrust != 0)
	{
	thrustPos /= thrust;
	thrustDir /= thrust;
	}

	Transform vesselTransform = core.vessel.transform;

	thrustPos = vesselTransform.InverseTransformPoint(thrustPos);
	thrustDir = vesselTransform.InverseTransformDirection(thrustDir);

	Vector3d thrustOffset = VectorTools.PointDistanceToLine(
	thrustPos, thrustDir.normalized, core.vessel.findLocalCenterOfMass());

	Tools.PostDebugMessage(typeof(VOID_Data), "vesselThrustOffset:\n" +
	"\tthrustPos: {0}\n" +
	"\tthrustDir: {1}\n" +
	"\tthrustOffset: {2}\n" +
	"\tvessel.CoM: {3}",
	thrustPos,
	thrustDir.normalized,
	thrustOffset,
	core.vessel.findWorldCenterOfMass()
	);

	return thrustOffset;
	},
	"m"
	);

	public static readonly VOID_DoubleValue vesselAccel = new VOID_DoubleValue(
	"Acceleration",
	() => geeForce * KerbinGee,
	"m/s²"
	);

	public static readonly VOID_IntValue vesselCrewCount = new VOID_IntValue(
	"Crew Onboard",
	delegate()
	{
	if (core.vessel != null)
	{
	return core.vessel.GetCrewCount();
	}
	else
	{
	return 0;
	}
	},
	""
	);

	public static readonly VOID_IntValue vesselCrewCapacity = new VOID_IntValue(
	"Crew Capacity",
	delegate()
	{
	if (core.vessel != null)
	{
	return core.vessel.GetCrewCapacity();
	}
	else
	{
	return 0;
	}
	},
	""
	);

	public static readonly VOID_DoubleValue vesselAngularVelocity = new VOID_DoubleValue(
	"Angular Velocity",
	delegate()
	{
	if (core.vessel != null)
	{
	return core.vessel.angularVelocity.magnitude;
	}
	else
	{
	return double.NaN;
	}
	},
	"rad/s"
	);

	public static readonly VOID_DoubleValue stageNominalThrust = new VOID_DoubleValue(
	"Nominal Stage Thrust",
	delegate()
	{
	if (core.LastStage == null)
	{
	return double.NaN;
	}

	if (core.LastStage.actualThrust == 0d)
	{
	return core.LastStage.thrust;
	}
	else
	{
	return core.LastStage.actualThrust;
	}
	},
	"kN"
	);

	public static readonly VOID_DoubleValue stageMassFlow = new VOID_DoubleValue(
	"Stage Mass Flow",
	delegate()
	{
	if (core.LastStage == null)
	{
	return double.NaN;
	}

	double stageIsp = core.LastStage.isp;
	double stageThrust = stageNominalThrust;

	Tools.PostDebugMessage(typeof(VOID_Data), "calculating stageMassFlow from:\n" +
	"\tstageIsp: {0}\n" +
	"\tstageThrust: {1}\n" +
	"\tKerbinGee: {2}\n",
	stageIsp,
	stageThrust,
	KerbinGee
	);

	return stageThrust / (stageIsp * KerbinGee);
	},
	"Mg/s"
	);

	public static readonly VOID_DoubleValue currManeuverDeltaV = new VOID_DoubleValue(
	"Current Maneuver Delta-V",
	delegate()
	{
	if (upcomingManeuverNodes > 0)
	{
	return core.vessel.patchedConicSolver.maneuverNodes[0].DeltaV.magnitude;
	}
	else
	{
	return double.NaN;
	}
	},
	"m/s"
	);

	public static readonly VOID_DoubleValue currManeuverDVRemaining = new VOID_DoubleValue(
	"Remaining Maneuver Delta-V",
	delegate()
	{
	if (upcomingManeuverNodes > 0)
	{
	return core.vessel.patchedConicSolver.maneuverNodes[0].GetBurnVector(core.vessel.orbit).magnitude;
	}
	else
	{
	return double.NaN;
	}
	},
	"m/s"
	);

	public static readonly VOID_DoubleValue nextManeuverDeltaV = new VOID_DoubleValue(
	"Current Maneuver Delta-V",
	delegate()
	{
	if (upcomingManeuverNodes > 1)
	{
	return core.vessel.patchedConicSolver.maneuverNodes[1].DeltaV.magnitude;
	}
	else
	{
	return double.NaN;
	}
	},
	"m/s"
	);

	public static readonly VOID_DoubleValue currentNodeBurnDuration = new VOID_DoubleValue(
	"Total Burn Time",
	delegate()
	{
	if (core.LastStage == null \|\| currManeuverDeltaV.Value == double.NaN)
	{
	return double.NaN;
	}

	double stageThrust = stageNominalThrust;

	return burnTime(currManeuverDeltaV.Value, totalMass, stageMassFlow, stageThrust);
	},
	"s"
	);

	public static readonly VOID_DoubleValue currentNodeBurnRemaining = new VOID_DoubleValue(
	"Burn Time Remaining",
	delegate()
	{
	if (core.LastStage == null \|\| currManeuverDVRemaining == double.NaN)
	{
	return double.NaN;
	}

	double stageThrust = stageNominalThrust;

	return burnTime(currManeuverDVRemaining, totalMass, stageMassFlow, stageThrust);
	},
	"s"
	);

	public static readonly VOID_DoubleValue currentNodeHalfBurnDuration = new VOID_DoubleValue(
	"Half Burn Time",
	delegate()
	{
	if (core.LastStage == null \|\| currManeuverDeltaV.Value == double.NaN)
	{
	return double.NaN;
	}

	double stageThrust = stageNominalThrust;

	return burnTime(currManeuverDeltaV.Value / 2d, totalMass, stageMassFlow, stageThrust);
	},
	"s"
	);

	public static readonly VOID_StrValue burnTimeDoneAtNode = new VOID_StrValue(
	"Full burn time to be half done at node",
	delegate()
	{
	if (core.LastStage == null && upcomingManeuverNodes < 1)
	{
	return "N/A";
	}

	ManeuverNode node = core.vessel.patchedConicSolver.maneuverNodes[0];

	if ((node.UT - Planetarium.GetUniversalTime()) < 0)
	{
	return string.Empty;
	}

	double interval = (node.UT - currentNodeBurnDuration) - Planetarium.GetUniversalTime();

	if (double.IsNaN(interval))
	{
	return string.Intern("NaN");
	}

	int sign = Math.Sign(interval);
	interval = Math.Abs(interval);

	string format;

	if (sign >= 0)
	{
	format = string.Intern("T - {0}");
	}
	else
	{
	format = string.Intern("T + {0}");
	}

	return string.Format(format, VOID_Tools.ConvertInterval(interval));
	}
	);

	public static readonly VOID_StrValue burnTimeHalfDoneAtNode = new VOID_StrValue(
	"Full burn time to be half done at node",
	delegate()
	{
	if (core.LastStage == null && upcomingManeuverNodes < 1)
	{
	return "N/A";
	}

	ManeuverNode node = core.vessel.patchedConicSolver.maneuverNodes[0];

	if ((node.UT - Planetarium.GetUniversalTime()) < 0)
	{
	return string.Empty;
	}

	double interval = (node.UT - currentNodeHalfBurnDuration) - Planetarium.GetUniversalTime();

	if (double.IsNaN(interval))
	{
	return string.Intern("NaN");
	}

	int sign = Math.Sign(interval);
	interval = Math.Abs(interval);

	string format;

	if (sign >= 0)
	{
	format = string.Intern("T - {0}");
	}
	else
	{
	format = string.Intern("T + {0}");
	}

	return string.Format(format, VOID_Tools.ConvertInterval(interval));
	}
	);

	private static double burnTime(double deltaV, double initialMass, double massFlow, double thrust)
	{
	Tools.PostDebugMessage(typeof(VOID_Data), "calculating burnTime from:\n" +
	"\tdeltaV: {0}\n" +
	"\tinitialMass: {1}\n" +
	"\tmassFlow: {2}\n" +
	"\tthrust: {3}\n",
	deltaV,
	initialMass,
	massFlow,
	thrust
	);
	return initialMass / massFlow * (Math.Exp(deltaV * massFlow / thrust) - 1d);
	}
	}
	}

file:b/VOID_Localization.cs (new)

	// VOID
	//
	// VOID_Localization.cs
	//
	// Copyright © 2014, toadicus
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice,
	// this list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation and/or other
	// materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	public static class VOID_Localization
	{
	public static string void_primary = "Primary";
	public static string void_altitude_asl = "Altitude (ASL)";
	public static string void_velocity = "Velocity";
	public static string void_apoapsis = "Apoapsis";
	public static string void_periapsis = "Periapsis";
	}

file:a/VOID_Module.cs -> file:b/VOID_Module.cs

//	// VOID
// VOID_Module.cs	//
//	// VOID_Module.cs
// Author:	//
// toadicus <>	// Copyright © 2014, toadicus
//	// All rights reserved.
// Copyright (c) 2013 toadicus	//
//	// Redistribution and use in source and binary forms, with or without modification,
// This program is free software: you can redistribute it and/or modify	// are permitted provided that the following conditions are met:
// it under the terms of the GNU General Public License as published by	//
// the Free Software Foundation, either version 3 of the License, or	// 1. Redistributions of source code must retain the above copyright notice,
// (at your option) any later version.	// this list of conditions and the following disclaimer.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.	//
//	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// You should have received a copy of the GNU General Public License	// to endorse or promote products derived from this software without specific prior written permission.
// along with this program. If not, see <http://www.gnu.org/licenses/>.	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using System.Linq;	using System.Linq;
using System.Reflection;	using System.Reflection;
	using ToadicusTools;
using UnityEngine;	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 = false;	protected VOID_SaveValue<bool> _Active = false;
protected bool _Running = false;	protected bool _Running = false;

protected string _Name;	protected string _Name;

protected float lastUpdate = 0;	protected float lastUpdate = 0;

/*	/*
* Properties	* Properties
* */	* */
	protected virtual VOID_Core core
	{
	get
	{
	if (HighLogic.LoadedSceneIsEditor)
	{
	return VOID_EditorCore.Instance as VOID_Core;
	}

	return VOID_Core.Instance;
	}
	}

public virtual bool toggleActive	public virtual bool toggleActive
{	{
get	get
{	{
return this._Active;	return this._Active;
}	}
set	set
{	{
this._Active.value = value;	this._Active.value = 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	public virtual Vessel vessel
{	{
get	get
{	{
return FlightGlobals.ActiveVessel;	return FlightGlobals.ActiveVessel;
}	}
}	}

/*	/*
* Methods	* Methods
* */	* */
public void StartGUI()	public void StartGUI()
{	{
if (!this.toggleActive \|\| this.guiRunning)	if (!this.toggleActive \|\| this.guiRunning)
{	{
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()
{	{
if (!this.guiRunning)	if (!this.guiRunning)
{	{
return;	return;
}	}
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	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) {
continue;	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);

Tools.PostDebugMessage(string.Format("{0}: Loading field {1}.", this.GetType().Name, fieldName));	Tools.PostDebugMessage(string.Format("{0}: Loading field {1}.", this.GetType().Name, fieldName));

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 _SaveToConfig(KSP.IO.PluginConfiguration config)	public virtual void _SaveToConfig(KSP.IO.PluginConfiguration config)
{	{
foreach (var field in this.GetType().GetFields(	foreach (var field in this.GetType().GetFields(
BindingFlags.Instance \|	BindingFlags.Instance \|
BindingFlags.NonPublic \|	BindingFlags.NonPublic \|
BindingFlags.Public \|	BindingFlags.Public \|
BindingFlags.FlattenHierarchy	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) {
continue;	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));
}	}
}	}
}	}

public abstract class VOID_WindowModule : VOID_Module	public abstract class VOID_WindowModule : VOID_Module
{	{
[AVOID_SaveValue("WindowPos")]	[AVOID_SaveValue("WindowPos")]
protected Rect WindowPos = new Rect(Screen.width / 2, Screen.height / 2, 250f, 50f);	protected Rect WindowPos;
protected float defWidth = 250f;	protected float defWidth;
protected float defHeight = 50f;	protected float defHeight;

public virtual void ModuleWindow(int _)	public VOID_WindowModule() : base()
{	{
// if (VOID_Core.Instance.updateTimer - this.lastUpdate > VOID_Core.Instance.updatePeriod) {	this.defWidth = 250f;
// foreach (var fieldinfo in this.GetType().GetFields(	this.defHeight = 50f;
// BindingFlags.Instance \|
// BindingFlags.NonPublic \|	this.WindowPos = new Rect(Screen.width / 2, Screen.height / 2, this.defWidth, this.defHeight);
// BindingFlags.Public \|	}
// BindingFlags.FlattenHierarchy
// ))	public abstract void ModuleWindow(int _);
// {
// object field = null;
//
// try
// {
// field = fieldinfo.GetValue (this);
// }
// catch (NullReferenceException) {
// Tools.PostDebugMessage(string.Format(
// "{0}: caught NullReferenceException, could not get value for field {1}.",
// this.GetType().Name,
// fieldinfo.Name
// ));
// }
//
// if (field == null) {
// continue;
// }
//
// if (typeof(IVOID_DataValue).IsAssignableFrom (field.GetType ())) {
// (field as IVOID_DataValue).Refresh ();
// }
// }
//
// this.lastUpdate = VOID_Core.Instance.updateTimer;
// }
}

public override void DrawGUI()	public override void DrawGUI()
{	{
GUI.skin = VOID_Core.Instance.Skin;	GUI.skin = this.core.Skin;

Rect _Pos = this.WindowPos;	Rect _Pos = this.WindowPos;

_Pos = GUILayout.Window(	_Pos = GUILayout.Window(
VOID_Core.Instance.windowID,	this.core.windowID,
_Pos,	_Pos,
this.ModuleWindow,	VOID_Tools.GetWindowHandler(this.ModuleWindow),
this.Name,	this.Name,
GUILayout.Width(this.defWidth),	GUILayout.Width(this.defWidth),
GUILayout.Height(this.defHeight)	GUILayout.Height(this.defHeight)
);	);

_Pos = Tools.ClampRectToScreen (_Pos);	_Pos = Tools.ClampRectToScreen (_Pos);

if (_Pos != this.WindowPos)	if (_Pos != this.WindowPos)
{	{
this.WindowPos = _Pos;	this.WindowPos = _Pos;
VOID_Core.Instance.configDirty = true;	this.core.configDirty = true;
}	}
}	}
}	}
}	}

file:a/VOID_Orbital.cs -> file:b/VOID_Orbital.cs

//	// VOID
// VOID_Orbital.cs	//
//	// VOID_Orbital.cs
// Author:	//
// toadicus <>	// Copyright © 2014, toadicus
//	// All rights reserved.
// Copyright (c) 2013 toadicus	//
//	// Redistribution and use in source and binary forms, with or without modification,
// This program is free software: you can redistribute it and/or modify	// are permitted provided that the following conditions are met:
// it under the terms of the GNU General Public License as published by	//
// the Free Software Foundation, either version 3 of the License, or	// 1. Redistributions of source code must retain the above copyright notice,
// (at your option) any later version.	// this list of conditions and the following disclaimer.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.	//
//	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// You should have received a copy of the GNU General Public License	// to endorse or promote products derived from this software without specific prior written permission.
// along with this program. If not, see <http://www.gnu.org/licenses/>.	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using KSP;	using KSP;
using System;	using System;
	using ToadicusTools;
using UnityEngine;	using UnityEngine;

namespace VOID	namespace VOID
{	{
public class VOID_Orbital : VOID_WindowModule	public class VOID_Orbital : VOID_WindowModule
{	{
[AVOID_SaveValue("toggleExtended")]	[AVOID_SaveValue("toggleExtended")]
protected VOID_SaveValue<bool> toggleExtended = false;	protected VOID_SaveValue<bool> toggleExtended = false;

[AVOID_SaveValue("precisionValues")]	[AVOID_SaveValue("precisionValues")]
protected long _precisionValues = 230584300921369395;	protected long _precisionValues = 230584300921369395;
protected IntCollection precisionValues;	protected IntCollection precisionValues;

public VOID_Orbital()	public VOID_Orbital()
{	{
this._Name = "Orbital Information";	this._Name = "Orbital Information";

this.WindowPos.x = Screen.width - 520f;	this.WindowPos.x = Screen.width - 520f;
this.WindowPos.y = 250f;	this.WindowPos.y = 250f;
}	}

public override void ModuleWindow(int _)	public override void ModuleWindow(int _)
{	{
base.ModuleWindow (_);

int idx = 0;	int idx = 0;

GUILayout.BeginVertical();	GUILayout.BeginVertical();

VOID_Data.primaryName.DoGUIHorizontal ();	VOID_Data.primaryName.DoGUIHorizontal ();

this.precisionValues [idx]= (ushort)VOID_Data.orbitAltitude.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.orbitAltitude.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

this.precisionValues [idx]= (ushort)VOID_Data.orbitVelocity.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.orbitVelocity.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

this.precisionValues [idx]= (ushort)VOID_Data.orbitApoAlt.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.orbitApoAlt.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

VOID_Data.timeToApo.DoGUIHorizontal();	VOID_Data.timeToApo.DoGUIHorizontal();

this.precisionValues [idx]= (ushort)VOID_Data.oribtPeriAlt.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.oribtPeriAlt.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

VOID_Data.timeToPeri.DoGUIHorizontal();	VOID_Data.timeToPeri.DoGUIHorizontal();

VOID_Data.orbitInclination.DoGUIHorizontal("F3");	VOID_Data.orbitInclination.DoGUIHorizontal("F3");

this.precisionValues [idx]= (ushort)VOID_Data.gravityAccel.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.gravityAccel.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

this.toggleExtended.value = GUILayout.Toggle(this.toggleExtended, "Extended info");	this.toggleExtended.value = GUILayout.Toggle(this.toggleExtended, "Extended info");

if (this.toggleExtended)	if (this.toggleExtended)
{	{
VOID_Data.orbitPeriod.DoGUIHorizontal();	VOID_Data.orbitPeriod.DoGUIHorizontal();

this.precisionValues [idx]= (ushort)VOID_Data.semiMajorAxis.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.semiMajorAxis.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

VOID_Data.eccentricity.DoGUIHorizontal("F4");	VOID_Data.eccentricity.DoGUIHorizontal("F4");

VOID_Data.meanAnomaly.DoGUIHorizontal("F3");	VOID_Data.meanAnomaly.DoGUIHorizontal("F3");

VOID_Data.trueAnomaly.DoGUIHorizontal("F3");	VOID_Data.trueAnomaly.DoGUIHorizontal("F3");

VOID_Data.eccAnomaly.DoGUIHorizontal("F3");	VOID_Data.eccAnomaly.DoGUIHorizontal("F3");

VOID_Data.longitudeAscNode.DoGUIHorizontal("F3");	VOID_Data.longitudeAscNode.DoGUIHorizontal("F3");

VOID_Data.argumentPeriapsis.DoGUIHorizontal("F3");	VOID_Data.argumentPeriapsis.DoGUIHorizontal("F3");

VOID_Data.localSiderealLongitude.DoGUIHorizontal("F3");	VOID_Data.localSiderealLongitude.DoGUIHorizontal("F3");
}	}

GUILayout.EndVertical();	GUILayout.EndVertical();
GUI.DragWindow();	GUI.DragWindow();
}	}

public override void LoadConfig ()	public override void LoadConfig ()
{	{
base.LoadConfig ();	base.LoadConfig ();

this.precisionValues = new IntCollection (4, this._precisionValues);	this.precisionValues = new IntCollection (4, this._precisionValues);
}	}

public override void _SaveToConfig (KSP.IO.PluginConfiguration config)	public override void _SaveToConfig (KSP.IO.PluginConfiguration config)
{	{
this._precisionValues = this.precisionValues.collection;	this._precisionValues = this.precisionValues.collection;

base._SaveToConfig (config);	base._SaveToConfig (config);
}	}
}	}


public static partial class VOID_Data	public static partial class VOID_Data
{	{
public static readonly VOID_StrValue primaryName = new VOID_StrValue (	public static readonly VOID_StrValue primaryName = new VOID_StrValue (
VOIDLabels.void_primary,	VOID_Localization.void_primary,
new Func<string> (() => VOID_Core.Instance.vessel.mainBody.name)	delegate()
	{
	if (core.vessel == null)
	{
	return string.Empty;
	}
	return core.vessel.mainBody.name;
	}
);	);

public static readonly VOID_DoubleValue orbitAltitude = new VOID_DoubleValue (	public static readonly VOID_DoubleValue orbitAltitude = new VOID_DoubleValue (
"Altitude (ASL)",	"Altitude (ASL)",
new Func<double> (() => VOID_Core.Instance.vessel.orbit.altitude),	new Func<double> (() => core.vessel.orbit.altitude),
"m"	"m"
);	);

public static readonly VOID_DoubleValue orbitVelocity = new VOID_DoubleValue (	public static readonly VOID_DoubleValue orbitVelocity = new VOID_DoubleValue (
VOIDLabels.void_velocity,	VOID_Localization.void_velocity,
new Func<double> (() => VOID_Core.Instance.vessel.orbit.vel.magnitude),	new Func<double> (() => core.vessel.orbit.vel.magnitude),
"m/s"	"m/s"
);	);

public static readonly VOID_DoubleValue orbitApoAlt = new VOID_DoubleValue(	public static readonly VOID_DoubleValue orbitApoAlt = new VOID_DoubleValue(
VOIDLabels.void_apoapsis,	VOID_Localization.void_apoapsis,
new Func<double>(() => VOID_Core.Instance.vessel.orbit.ApA),	new Func<double>(() => core.vessel.orbit.ApA),
"m"	"m"
);	);

public static readonly VOID_DoubleValue oribtPeriAlt = new VOID_DoubleValue(	public static readonly VOID_DoubleValue oribtPeriAlt = new VOID_DoubleValue(
VOIDLabels.void_periapsis,	VOID_Localization.void_periapsis,
new Func<double>(() => VOID_Core.Instance.vessel.orbit.PeA),	new Func<double>(() => core.vessel.orbit.PeA),
"m"	"m"
);	);

public static readonly VOID_StrValue timeToApo = new VOID_StrValue(	public static readonly VOID_StrValue timeToApo = new VOID_StrValue(
"Time to Apoapsis",	"Time to Apoapsis",
new Func<string>(() => Tools.ConvertInterval(VOID_Core.Instance.vessel.orbit.timeToAp))	new Func<string>(() => VOID_Tools.ConvertInterval(core.vessel.orbit.timeToAp))
);	);

public static readonly VOID_StrValue timeToPeri = new VOID_StrValue(	public static readonly VOID_StrValue timeToPeri = new VOID_StrValue(
"Time to Periapsis",	"Time to Periapsis",
new Func<string>(() => Tools.ConvertInterval(VOID_Core.Instance.vessel.orbit.timeToPe))	new Func<string>(() => VOID_Tools.ConvertInterval(core.vessel.orbit.timeToPe))
);	);

public static readonly VOID_DoubleValue orbitInclination = new VOID_DoubleValue(	public static readonly VOID_DoubleValue orbitInclination = new VOID_DoubleValue(
"Inclination",	"Inclination",
new Func<double>(() => VOID_Core.Instance.vessel.orbit.inclination),	new Func<double>(() => core.vessel.orbit.inclination),
"°"	"°"
);	);

public static readonly VOID_DoubleValue gravityAccel = new VOID_DoubleValue(	public static readonly VOID_DoubleValue gravityAccel = new VOID_DoubleValue(
"Gravity",	"Gravity",
delegate()	delegate()
{	{
double orbitRadius = VOID_Core.Instance.vessel.mainBody.Radius +	double orbitRadius = core.vessel.mainBody.Radius +
VOID_Core.Instance.vessel.mainBody.GetAltitude(VOID_Core.Instance.vessel.findWorldCenterOfMass());	core.vessel.mainBody.GetAltitude(core.vessel.findWorldCenterOfMass());
return (VOID_Core.Constant_G * VOID_Core.Instance.vessel.mainBody.Mass) /	return (VOID_Core.Constant_G * core.vessel.mainBody.Mass) /
Math.Pow(orbitRadius, 2);	(orbitRadius * orbitRadius);
},	},
"m/s²"	"m/s²"
);	);

public static readonly VOID_StrValue orbitPeriod = new VOID_StrValue(	public static readonly VOID_StrValue orbitPeriod = new VOID_StrValue(
"Period",	"Period",
new Func<string>(() => Tools.ConvertInterval(VOID_Core.Instance.vessel.orbit.period))	new Func<string>(() => VOID_Tools.ConvertInterval(core.vessel.orbit.period))
);	);

public static readonly VOID_DoubleValue semiMajorAxis = new VOID_DoubleValue(	public static readonly VOID_DoubleValue semiMajorAxis = new VOID_DoubleValue(
"Semi-Major Axis",	"Semi-Major Axis",
new Func<double>(() => VOID_Core.Instance.vessel.orbit.semiMajorAxis),	new Func<double>(() => core.vessel.orbit.semiMajorAxis),
"m"	"m"
);	);

public static readonly VOID_DoubleValue eccentricity = new VOID_DoubleValue(	public static readonly VOID_DoubleValue eccentricity = new VOID_DoubleValue(
"Eccentricity",	"Eccentricity",
new Func<double>(() => VOID_Core.Instance.vessel.orbit.eccentricity),	new Func<double>(() => core.vessel.orbit.eccentricity),
""	""
);	);

public static readonly VOID_DoubleValue meanAnomaly = new VOID_DoubleValue(	public static readonly VOID_DoubleValue meanAnomaly = new VOID_DoubleValue(
"Mean Anomaly",	"Mean Anomaly",
new Func<double>(() => VOID_Core.Instance.vessel.orbit.meanAnomaly * 180d / Math.PI),	new Func<double>(() => core.vessel.orbit.meanAnomaly * 180d / Math.PI),
"°"	"°"
);	);

public static readonly VOID_DoubleValue trueAnomaly = new VOID_DoubleValue(	public static readonly VOID_DoubleValue trueAnomaly = new VOID_DoubleValue(
"True Anomaly",	"True Anomaly",
new Func<double>(() => VOID_Core.Instance.vessel.orbit.trueAnomaly),	new Func<double>(() => core.vessel.orbit.trueAnomaly),
"°"	"°"
);	);

public static readonly VOID_DoubleValue eccAnomaly = new VOID_DoubleValue(	public static readonly VOID_DoubleValue eccAnomaly = new VOID_DoubleValue(
"Eccentric Anomaly",	"Eccentric Anomaly",
new Func<double>(() => VOID_Core.Instance.vessel.orbit.eccentricAnomaly * 180d / Math.PI),	new Func<double>(() => core.vessel.orbit.eccentricAnomaly * 180d / Math.PI),
"°"	"°"
);	);

public static readonly VOID_DoubleValue longitudeAscNode = new VOID_DoubleValue(	public static readonly VOID_DoubleValue longitudeAscNode = new VOID_DoubleValue(
"Long. Ascending Node",	"Long. Ascending Node",
new Func<double>(() => VOID_Core.Instance.vessel.orbit.LAN),	new Func<double>(() => core.vessel.orbit.LAN),
"°"	"°"
);	);

public static readonly VOID_DoubleValue argumentPeriapsis = new VOID_DoubleValue(	public static readonly VOID_DoubleValue argumentPeriapsis = new VOID_DoubleValue(
"Argument of Periapsis",	"Argument of Periapsis",
new Func<double>(() => VOID_Core.Instance.vessel.orbit.argumentOfPeriapsis),	new Func<double>(() => core.vessel.orbit.argumentOfPeriapsis),
"°"	"°"
);	);

public static readonly VOID_DoubleValue localSiderealLongitude = new VOID_DoubleValue(	public static readonly VOID_DoubleValue localSiderealLongitude = new VOID_DoubleValue(
"Local Sidereal Longitude",	"Local Sidereal Longitude",
new Func<double>(() => Tools.FixDegreeDomain(	new Func<double>(() => VOID_Tools.FixDegreeDomain(
VOID_Core.Instance.vessel.longitude + VOID_Core.Instance.vessel.orbit.referenceBody.rotationAngle)),	core.vessel.longitude + core.vessel.orbit.referenceBody.rotationAngle)),
"°"	"°"
);	);
}	}
}	}

file:a/VOID_Rendezvous.cs -> file:b/VOID_Rendezvous.cs

//	// VOID
// VOID_Orbital.cs	//
//	// VOID_Rendezvous.cs
// Author:	//
// toadicus <>	// Copyright © 2014, toadicus
//	// All rights reserved.
// Copyright (c) 2013 toadicus	//
//	// Redistribution and use in source and binary forms, with or without modification,
// This program is free software: you can redistribute it and/or modify	// are permitted provided that the following conditions are met:
// it under the terms of the GNU General Public License as published by	//
// the Free Software Foundation, either version 3 of the License, or	// 1. Redistributions of source code must retain the above copyright notice,
// (at your option) any later version.	// this list of conditions and the following disclaimer.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.	//
//	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// You should have received a copy of the GNU General Public License	// to endorse or promote products derived from this software without specific prior written permission.
// along with this program. If not, see <http://www.gnu.org/licenses/>.	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using KSP;	using KSP;
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using System.Linq;	using System.Linq;
	using ToadicusTools;
using UnityEngine;	using UnityEngine;

namespace VOID	namespace VOID
{	{
public class VOID_Rendezvous : VOID_WindowModule	public class VOID_Rendezvous : VOID_WindowModule
{	{
[AVOID_SaveValue("untoggleRegisterInfo")]	[AVOID_SaveValue("untoggleRegisterInfo")]
protected VOID_SaveValue<bool> untoggleRegisterInfo = false;	protected VOID_SaveValue<bool> untoggleRegisterInfo = false;

[AVOID_SaveValue("toggleExtendedOrbital")]	[AVOID_SaveValue("toggleExtendedOrbital")]
protected VOID_SaveValue<bool> toggleExtendedOrbital = false;	protected VOID_SaveValue<bool> toggleExtendedOrbital = false;

protected VOID_VesselRegister RegisterModule;	protected VOID_VesselRegister RegisterModule;

public VOID_Rendezvous()	public VOID_Rendezvous()
{	{
this._Name = "Rendezvous Information";	this._Name = "Rendezvous Information";

this.WindowPos.x = 845;	this.WindowPos.x = 845;
this.WindowPos.y = 85;	this.WindowPos.y = 85;
}	}

public override void ModuleWindow(int _)	public override void ModuleWindow(int _)
{	{
Vessel rendezvessel = new Vessel();	Vessel rendezvessel = new Vessel();
CelestialBody rendezbody = new CelestialBody();	CelestialBody rendezbody = new CelestialBody();

this.RegisterModule = VOID_Core.Instance.Modules.Where(m => typeof(VOID_VesselRegister).IsAssignableFrom(m.GetType())).FirstOrDefault() as VOID_VesselRegister;	if (this.RegisterModule == null)
	{
	this.RegisterModule = this.core.Modules.Where(m => typeof(VOID_VesselRegister).IsAssignableFrom(m.GetType())).FirstOrDefault() as VOID_VesselRegister;
	}

GUILayout.BeginVertical();	GUILayout.BeginVertical();

//display both	//display both
//Show Target Info	//Show Target Info
GUILayout.Label("Target:", VOID_Core.Instance.LabelStyles["center_bold"]);	GUILayout.Label("Target:", this.core.LabelStyles["center_bold"]);
if (FlightGlobals.fetch.VesselTarget != null)	if (FlightGlobals.fetch.VesselTarget != null)
{	{
//a KSP Target (body or vessel) is selected	//a KSP Target (body or vessel) is selected
if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.Direction)	if (FlightGlobals.fetch.vesselTargetMode == VesselTargetModes.Direction)
{	{
//a Body is selected	//a Body is selected
rendezbody = vessel.patchedConicSolver.targetBody;	rendezbody = vessel.patchedConicSolver.targetBody;
display_rendezvous_info(null, rendezbody);	display_rendezvous_info(null, rendezbody);
}	}
else if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.DirectionAndVelocity)	else if (FlightGlobals.fetch.vesselTargetMode == VesselTargetModes.DirectionAndVelocity)
{	{
//a Vessel is selected	//a Vessel is selected
rendezvessel = FlightGlobals.fetch.VesselTarget.GetVessel();	rendezvessel = FlightGlobals.fetch.VesselTarget.GetVessel();
display_rendezvous_info(rendezvessel, null);	display_rendezvous_info(rendezvessel, null);
}	}
//Show Unset button for both options above	//Show Unset button for both options above
if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false)))	if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false)))
{	{
FlightGlobals.fetch.SetVesselTarget(null);	FlightGlobals.fetch.SetVesselTarget(null);
Tools.PostDebugMessage("VOID_Rendezvous: KSP Target set to null");	Tools.PostDebugMessage("VOID_Rendezvous: KSP Target set to null");
}	}

}	}
else	else
{	{
//no KSP Target selected	//no KSP Target selected
GUILayout.Label("No Target Selected", VOID_Core.Instance.LabelStyles["center_bold"]);	GUILayout.Label("No Target Selected", this.core.LabelStyles["center_bold"]);
}	}

//Show Vessel Register vessel info	//Show Vessel Register vessel info
if (untoggleRegisterInfo == false && this.RegisterModule != default(IVOID_Module))	if (untoggleRegisterInfo == false && this.RegisterModule != default(IVOID_Module))
{	{
GUILayout.Label("Vessel Register:", VOID_Core.Instance.LabelStyles["center_bold"]);	GUILayout.Label("Vessel Register:", this.core.LabelStyles["center_bold"]);
if (this.RegisterModule.selectedVessel != null)	if (this.RegisterModule.selectedVessel != null)
{	{
rendezvessel = this.RegisterModule.selectedVessel;	rendezvessel = this.RegisterModule.selectedVessel;
display_rendezvous_info(rendezvessel, null);	display_rendezvous_info(rendezvessel, null);

//show set/unset buttons	//show set/unset buttons
if (FlightGlobals.fetch.VesselTarget == null \|\| (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != this.RegisterModule.selectedVessel))	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	//no Tgt set or Tgt is not this vessel
//show a Set button	//show a Set button
if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))	if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false)))
{	{
FlightGlobals.fetch.SetVesselTarget(rendezvessel);	FlightGlobals.fetch.SetVesselTarget(rendezvessel);
Tools.PostDebugMessage("[VOID] KSP Target set to " + rendezvessel.vesselName);	Tools.PostDebugMessage("[VOID] KSP Target set to " + rendezvessel.vesselName);
}	}
}	}
}	}
else	else
{	{
//vesreg Vessel is null	//vesreg Vessel is null
//targ = null;	//targ = null;
GUILayout.Label("No Vessel Selected", VOID_Core.Instance.LabelStyles["center_bold"]);	GUILayout.Label("No Vessel Selected", this.core.LabelStyles["center_bold"]);
}	}
}	}

untoggleRegisterInfo.value = GUILayout.Toggle(untoggleRegisterInfo, "Hide Vessel Register Info");	untoggleRegisterInfo.value = GUILayout.Toggle(untoggleRegisterInfo, "Hide Vessel Register Info");

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label(" ", GUILayout.ExpandWidth(true));	GUILayout.Label(" ", GUILayout.ExpandWidth(true));
if (GUILayout.Button("Close", GUILayout.ExpandWidth(false))) this._Active = false;	if (GUILayout.Button("Close", GUILayout.ExpandWidth(false))) this.toggleActive = false;
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.EndVertical();	GUILayout.EndVertical();
GUI.DragWindow();	GUI.DragWindow();
}	}

private void display_rendezvous_info(Vessel v, CelestialBody cb)	private void display_rendezvous_info(Vessel v, CelestialBody cb)
{	{
if (cb == null && v != null)	if (cb == null && v != null)
{	{
//Display vessel rendezvous info	//Display vessel rendezvous info
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label(v.vesselName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true));	GUILayout.Label(v.vesselName, this.core.LabelStyles["center_bold"], GUILayout.ExpandWidth(true));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

if (v.situation == Vessel.Situations.ESCAPING \|\| v.situation == Vessel.Situations.FLYING \|\| v.situation == Vessel.Situations.ORBITING \|\| v.situation == Vessel.Situations.SUB_ORBITAL)	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.
// Toadicus edit: added local sidereal longitude.	// Toadicus edit: added local sidereal longitude.
double LSL = v.longitude + v.orbit.referenceBody.rotationAngle;	double LSL = v.longitude + v.orbit.referenceBody.rotationAngle;
LSL = Tools.FixDegreeDomain (LSL);	LSL = VOID_Tools.FixDegreeDomain (LSL);

//display orbital info for orbiting/flying/suborbital/escaping vessels only	//display orbital info for orbiting/flying/suborbital/escaping vessels only
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Ap/Pe:");	GUILayout.Label("Ap/Pe:");
GUILayout.Label(Tools.MuMech_ToSI(v.orbit.ApA) + "m / " + Tools.MuMech_ToSI(v.orbit.PeA) + "m", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.MuMech_ToSI(v.orbit.ApA) + "m / " + Tools.MuMech_ToSI(v.orbit.PeA) + "m", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Altitude:");	GUILayout.Label("Altitude:");
GUILayout.Label(Tools.MuMech_ToSI(v.orbit.altitude) + "m", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.MuMech_ToSI(v.orbit.altitude) + "m", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Inclination:");	GUILayout.Label("Inclination:");
GUILayout.Label(v.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(v.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

if (vessel.mainBody == v.mainBody)	if (vessel.mainBody == v.mainBody)
{	{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Relative inclination:");	GUILayout.Label("Relative inclination:");
GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), v.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), v.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();
}	}
//if (debugging) Debug.Log("[CHATR] v -> v relative incl OK");	//if (debugging) Debug.Log("[CHATR] v -> v relative incl OK");

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Velocity:");	GUILayout.Label("Velocity:");
GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Relative velocity:");	GUILayout.Label("Relative velocity:");
GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude - vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude - vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Distance:");	GUILayout.Label("Distance:");
GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

//target_vessel_extended_orbital_info = GUILayout.Toggle(target_vessel_extended_orbital_info, "Extended info");	// Toadicus edit: added local sidereal longitude.
	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
	GUILayout.Label("Local Sidereal Longitude:");
	GUILayout.Label(LSL.ToString("F3") + "°", this.core.LabelStyles["right"]);
	GUILayout.EndHorizontal();

	toggleExtendedOrbital.value = GUILayout.Toggle(toggleExtendedOrbital, "Extended info");

if (toggleExtendedOrbital)	if (toggleExtendedOrbital)
{	{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Period:");	GUILayout.Label("Period:");
GUILayout.Label(Tools.ConvertInterval(v.orbit.period), GUILayout.ExpandWidth(false));	GUILayout.Label(VOID_Tools.ConvertInterval(v.orbit.period), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Semi-major axis:");	GUILayout.Label("Semi-major axis:");
GUILayout.Label((v.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false));	GUILayout.Label((v.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Eccentricity:");	GUILayout.Label("Eccentricity:");
GUILayout.Label(v.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false));	GUILayout.Label(v.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

// Toadicus edit: convert mean anomaly into degrees.	// Toadicus edit: convert mean anomaly into degrees.
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Mean anomaly:");	GUILayout.Label("Mean anomaly:");
GUILayout.Label((v.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label((v.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("True anomaly:");	GUILayout.Label("True anomaly:");
GUILayout.Label(v.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(v.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

// Toadicus edit: convert eccentric anomaly into degrees.	// Toadicus edit: convert eccentric anomaly into degrees.
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Eccentric anomaly:");	GUILayout.Label("Eccentric anomaly:");
GUILayout.Label((v.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label((v.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Long. ascending node:");	GUILayout.Label("Long. ascending node:");
GUILayout.Label(v.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(v.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Arg. of periapsis:");	GUILayout.Label("Arg. of periapsis:");
GUILayout.Label(v.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(v.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	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["right"]);
GUILayout.EndHorizontal();
}	}
}	}
else	else
{	{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Latitude:");	GUILayout.Label("Latitude:");
GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false));	GUILayout.Label(VOID_Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Longitude:");	GUILayout.Label("Longitude:");
GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false));	GUILayout.Label(VOID_Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Distance:");	GUILayout.Label("Distance:");
GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();
}	}
}	}
else if (cb != null && v == null)	else if (cb != null && v == null)
{	{
//Display CelstialBody rendezvous info	//Display CelstialBody rendezvous info
GUILayout.Label(cb.bodyName, VOID_Core.Instance.LabelStyles["center_bold"]);	GUILayout.Label(cb.bodyName, this.core.LabelStyles["center_bold"]);

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Ap/Pe:");	GUILayout.Label("Ap/Pe:");
GUILayout.Label(Tools.MuMech_ToSI(cb.orbit.ApA) + "m / " + Tools.MuMech_ToSI(cb.orbit.PeA) + "m", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.MuMech_ToSI(cb.orbit.ApA) + "m / " + Tools.MuMech_ToSI(cb.orbit.PeA) + "m", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();
//if (debugging) Debug.Log("[VOID] Ap/Pe OK");	//if (debugging) Debug.Log("[VOID] Ap/Pe OK");

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Inclination:");	GUILayout.Label("Inclination:");
GUILayout.Label(cb.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(cb.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();
//if (debugging) Debug.Log("[VOID] Inclination OK");	//if (debugging) Debug.Log("[VOID] Inclination OK");

if (cb.referenceBody == vessel.mainBody)	if (cb.referenceBody == vessel.mainBody)
{	{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Relative inclination:");	GUILayout.Label("Relative inclination:");
GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), cb.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), cb.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();
//if (debugging) Debug.Log("[VOID] cb Relative inclination OK");	//if (debugging) Debug.Log("[VOID] cb Relative inclination OK");
}	}

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Distance:");	GUILayout.Label("Distance:");
GUILayout.Label(Tools.MuMech_ToSI((vessel.mainBody.position - cb.position).magnitude) + "m", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.MuMech_ToSI((vessel.mainBody.position - cb.position).magnitude) + "m", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

//if (debugging) Debug.Log("[VOID] Distance OK");	//if (debugging) Debug.Log("[VOID] Distance OK");

//SUN2PLANET:	//SUN2PLANET:
if (vessel.mainBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)	if (vessel.mainBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)
{	{
Tools.display_transfer_angles_SUN2PLANET(cb, vessel);	VOID_Tools.display_transfer_angles_SUN2PLANET(cb, vessel);
//if (debugging) Debug.Log("[VOID] SUN2PLANET OK");	//if (debugging) Debug.Log("[VOID] SUN2PLANET OK");
}	}

//PLANET2PLANET	//PLANET2PLANET
else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)	else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)
{	{
Tools.display_transfer_angles_PLANET2PLANET(cb, vessel);	VOID_Tools.display_transfer_angles_PLANET2PLANET(cb, vessel);
//if (debugging) Debug.Log("[VOID] PLANET2PLANET OK");	//if (debugging) Debug.Log("[VOID] PLANET2PLANET OK");
}	}

//PLANET2MOON	//PLANET2MOON
else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)	else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody)
{	{
Tools.display_transfer_angles_PLANET2MOON(cb, vessel);	VOID_Tools.display_transfer_angles_PLANET2MOON(cb, vessel);
//if (debugging) Debug.Log("[VOID] PLANET2MOON OK");	//if (debugging) Debug.Log("[VOID] PLANET2MOON OK");
}	}

//MOON2MOON	//MOON2MOON
else if (vessel.mainBody.referenceBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)	else if (vessel.mainBody.referenceBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody)
{	{
Tools.display_transfer_angles_MOON2MOON(cb, vessel);	VOID_Tools.display_transfer_angles_MOON2MOON(cb, vessel);
//if (debugging) Debug.Log("[VOID] MOON2MOON OK");	//if (debugging) Debug.Log("[VOID] MOON2MOON OK");
}	}

//else GUILayout.Label("Transfer angle information\nunavailable for this target");	//else GUILayout.Label("Transfer angle information\nunavailable for this target");

}	}
}	}
}	}
}	}

file:a/VOID_SaveValue.cs -> file:b/VOID_SaveValue.cs

	// VOID
//	//
// VOID_Config.cs	// VOID_SaveValue.cs
//	//
// Author:	// Copyright © 2014, toadicus
// toadicus <>	// All rights reserved.
//	//
// Copyright (c) 2013 toadicus	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
//	//
// This program is free software: you can redistribute it and/or modify	// 1. Redistributions of source code must retain the above copyright notice,
// it under the terms of the GNU General Public License as published by	// this list of conditions and the following disclaimer.
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	using KSP;
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using KSP;	using ToadicusTools;
using UnityEngine;	using UnityEngine;

namespace VOID	namespace VOID
{	{
public struct VOID_SaveValue<T> : IVOID_SaveValue	public struct VOID_SaveValue<T> : IVOID_SaveValue
{	{
private T _value;	private T _value;
private Type _type;	private Type _type;

private VOID_Core Core	private VOID_Core Core
{	{
get	get
{	{
if (HighLogic.LoadedSceneIsEditor)	if (HighLogic.LoadedSceneIsEditor)
{	{
if (VOID_EditorCore.Initialized)	if (VOID_EditorCore.Initialized)
{	{
return VOID_EditorCore.Instance;	return VOID_EditorCore.Instance;
}	}
}	}
else if (HighLogic.LoadedSceneIsFlight)	else if (HighLogic.LoadedSceneIsFlight)
{	{
if (VOID_Core.Initialized)	if (VOID_Core.Initialized)
{	{
return VOID_Core.Instance;	return VOID_Core.Instance;
}	}
}	}
return null;	return null;
}	}
}	}

public T value	public T value
{	{
get	get
{	{
return this._value;	return this._value;
}	}
set	set
{	{
if (this.Core != null && !System.Object.Equals(this._value, value))	if (this.Core != null && !System.Object.Equals(this._value, value))
{	{
Tools.PostDebugMessage (string.Format (	Tools.PostDebugMessage (string.Format (
"VOID: Dirtying config for type {0} in method {1}." +	"VOID: Dirtying config for type {0} in method {1}." +
"\n\t Old Value: {2}, New Value: {3}" +	"\n\t Old Value: {2}, New Value: {3}" +
"\n\t Object.Equals(New, Old): {4}",	"\n\t Object.Equals(New, Old): {4}",
this._type,	this._type,
new System.Diagnostics.StackTrace().GetFrame(1).GetMethod(),	new System.Diagnostics.StackTrace().GetFrame(1).GetMethod(),
this._value,	this._value,
value,	value,
System.Object.Equals(this._value, value)	System.Object.Equals(this._value, value)
));	));
this.Core.configDirty = true;	this.Core.configDirty = true;
}	}
this._value = value;	this._value = value;
}	}
}	}

public Type type	public Type type
{	{
get	get
{	{
if (this._type == null && this._value != null)	if (this._type == null && this._value != null)
{	{
this._type = this._value.GetType ();	this._type = this._value.GetType ();
}	}
return this._type;	return this._type;
}	}
set	set
{	{
this._type = value;	this._type = value;
}	}
}	}

public object AsType	public object AsType
{	{
get	get
{	{
return (T)this._value;	return (T)this._value;
}	}
}	}

public void SetValue(object v)	public void SetValue(object v)
{	{
this.value = (T)v;	this.value = (T)v;
}	}

public static implicit operator T(VOID_SaveValue<T> v)	public static implicit operator T(VOID_SaveValue<T> v)
{	{
return (T)v.value;	return (T)v.value;
}	}

public static implicit operator VOID_SaveValue<T>(T v)	public static implicit operator VOID_SaveValue<T>(T v)
{	{
VOID_SaveValue<T> r = new VOID_SaveValue<T>();	VOID_SaveValue<T> r = new VOID_SaveValue<T>();
r.type = v.GetType();	r.type = v.GetType();
r.value = v;	r.value = v;

return r;	return r;
}	}

public override string ToString()	public override string ToString()
{	{
return this.value.ToString();	return this.value.ToString();
}	}
}	}

public interface IVOID_SaveValue	public interface IVOID_SaveValue
{	{
Type type { get; }	Type type { get; }
object AsType { get; }	object AsType { get; }
void SetValue(object v);	void SetValue(object v);
}	}

[AttributeUsage(AttributeTargets.Field)]	[AttributeUsage(AttributeTargets.Field)]
public class AVOID_SaveValue : Attribute	public class AVOID_SaveValue : Attribute
{	{
protected string _name;	protected string _name;

public string Name	public string Name
{	{
get	get
{	{
return this._name;	return this._name;
}	}
}	}

public AVOID_SaveValue(string fieldName)	public AVOID_SaveValue(string fieldName)
{	{
this._name = fieldName;	this._name = fieldName;
}	}
}	}
}	}

file:a/VOID_SurfAtmo.cs -> file:b/VOID_SurfAtmo.cs

//	// VOID
// VOID_Orbital.cs	//
//	// VOID_SurfAtmo.cs
// Author:	//
// toadicus <>	// Copyright © 2014, toadicus
//	// All rights reserved.
// Copyright (c) 2013 toadicus	//
//	// Redistribution and use in source and binary forms, with or without modification,
// This program is free software: you can redistribute it and/or modify	// are permitted provided that the following conditions are met:
// it under the terms of the GNU General Public License as published by	//
// the Free Software Foundation, either version 3 of the License, or	// 1. Redistributions of source code must retain the above copyright notice,
// (at your option) any later version.	// this list of conditions and the following disclaimer.
//	//
// This program is distributed in the hope that it will be useful,	// 2. Redistributions in binary form must reproduce the above copyright notice,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// this list of conditions and the following disclaimer in the documentation and/or other
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// materials provided with the distribution.
// GNU General Public License for more details.	//
//	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// You should have received a copy of the GNU General Public License	// to endorse or promote products derived from this software without specific prior written permission.
// along with this program. If not, see <http://www.gnu.org/licenses/>.	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using KSP;	using KSP;
using System;	using System;
	using ToadicusTools;
using UnityEngine;	using UnityEngine;

namespace VOID	namespace VOID
{	{
public class VOID_SurfAtmo : VOID_WindowModule	public class VOID_SurfAtmo : VOID_WindowModule
{	{
[AVOID_SaveValue("precisionValues")]	[AVOID_SaveValue("precisionValues")]
protected long _precisionValues = 230584300921369395;	protected long _precisionValues = 230584300921369395;
protected IntCollection precisionValues;	protected IntCollection precisionValues;

public VOID_SurfAtmo()	public VOID_SurfAtmo()
{	{
this._Name = "Surface & Atmospheric Information";	this._Name = "Surface & Atmospheric Information";

this.WindowPos.x = Screen.width - 260f;	this.WindowPos.x = Screen.width - 260f;
this.WindowPos.y = 85;	this.WindowPos.y = 85;
}	}

public override void ModuleWindow(int _)	public override void ModuleWindow(int _)
{	{
base.ModuleWindow (_);

int idx = 0;	int idx = 0;

GUILayout.BeginVertical();	GUILayout.BeginVertical();

this.precisionValues [idx]= (ushort)VOID_Data.trueAltitude.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.trueAltitude.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

VOID_Data.surfLatitude.DoGUIHorizontal ();	VOID_Data.surfLatitude.DoGUIHorizontal ();

VOID_Data.surfLongitude.DoGUIHorizontal ();	VOID_Data.surfLongitude.DoGUIHorizontal ();

VOID_Data.vesselHeading.DoGUIHorizontal ();	VOID_Data.vesselHeading.DoGUIHorizontal ();

this.precisionValues [idx]= (ushort)VOID_Data.terrainElevation.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.terrainElevation.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

this.precisionValues [idx]= (ushort)VOID_Data.surfVelocity.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.surfVelocity.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

this.precisionValues [idx]= (ushort)VOID_Data.vertVelocity.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.vertVelocity.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

this.precisionValues [idx]= (ushort)VOID_Data.horzVelocity.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.horzVelocity.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

VOID_Data.temperature.DoGUIHorizontal ("F2");	VOID_Data.temperature.DoGUIHorizontal ("F2");

VOID_Data.atmDensity.DoGUIHorizontal (3);	VOID_Data.atmDensity.DoGUIHorizontal (3);

VOID_Data.atmPressure.DoGUIHorizontal ("F2");	VOID_Data.atmPressure.DoGUIHorizontal ("F2");

this.precisionValues [idx]= (ushort)VOID_Data.atmLimit.DoGUIHorizontal (this.precisionValues [idx]);	this.precisionValues [idx]= (ushort)VOID_Data.atmLimit.DoGUIHorizontal (this.precisionValues [idx]);
idx++;	idx++;

// Toadicus edit: added Biome	// Toadicus edit: added Biome
VOID_Data.currBiome.DoGUIHorizontal ();	VOID_Data.currBiome.DoGUIHorizontal ();

GUILayout.EndVertical();	GUILayout.EndVertical();
GUI.DragWindow();	GUI.DragWindow();
}	}

public override void LoadConfig ()	public override void LoadConfig ()
{	{
base.LoadConfig ();	base.LoadConfig ();

this.precisionValues = new IntCollection (4, this._precisionValues);	this.precisionValues = new IntCollection (4, this._precisionValues);
}	}

public override void _SaveToConfig (KSP.IO.PluginConfiguration config)	public override void _SaveToConfig (KSP.IO.PluginConfiguration config)
{	{
this._precisionValues = this.precisionValues.collection;	this._precisionValues = this.precisionValues.collection;

base._SaveToConfig (config);	base._SaveToConfig (config);
}	}
}	}

public static partial class VOID_Data	public static partial class VOID_Data
{	{
public static readonly VOID_DoubleValue trueAltitude = new VOID_DoubleValue(	public static readonly VOID_DoubleValue trueAltitude = new VOID_DoubleValue(
"Altitude (true)",	"Altitude (true)",
delegate()	delegate()
{	{
double alt_true = VOID_Core.Instance.vessel.orbit.altitude - VOID_Core.Instance.vessel.terrainAltitude;	double alt_true = core.vessel.orbit.altitude - core.vessel.terrainAltitude;
// HACK: This assumes that on worlds with oceans, all water is fixed 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.	// and water covers the whole surface at 0 m.
if (VOID_Core.Instance.vessel.terrainAltitude < 0 && VOID_Core.Instance.vessel.mainBody.ocean )	if (core.vessel.terrainAltitude < 0 && core.vessel.mainBody.ocean )
alt_true = VOID_Core.Instance.vessel.orbit.altitude;	alt_true = core.vessel.orbit.altitude;
return alt_true;	return alt_true;
},	},
"m"	"m"
);	);

public static readonly VOID_StrValue surfLatitude = new VOID_StrValue(	public static readonly VOID_StrValue surfLatitude = new VOID_StrValue(
"Latitude",	"Latitude",
new Func<string> (() => Tools.GetLatitudeString(VOID_Core.Instance.vessel))	new Func<string> (() => VOID_Tools.GetLatitudeString(core.vessel))
);	);

public static readonly VOID_StrValue surfLongitude = new VOID_StrValue(	public static readonly VOID_StrValue surfLongitude = new VOID_StrValue(
"Longitude",	"Longitude",
new Func<string> (() => Tools.GetLongitudeString(VOID_Core.Instance.vessel))	new Func<string> (() => VOID_Tools.GetLongitudeString(core.vessel))
);	);

public static readonly VOID_StrValue vesselHeading = new VOID_StrValue(	public static readonly VOID_StrValue vesselHeading = new VOID_StrValue(
"Heading",	"Heading",
delegate()	delegate()
{	{
double heading = core.vessel.getSurfaceHeading();	double heading = core.vessel.getSurfaceHeading();
string cardinal = Tools.get_heading_text(heading);	string cardinal = VOID_Tools.get_heading_text(heading);

return string.Format(	return string.Format(
"{0}° {1}",	"{0}° {1}",
heading.ToString("F2"),	heading.ToString("F2"),
cardinal	cardinal
);	);
}	}
);	);

public static readonly VOID_DoubleValue terrainElevation = new VOID_DoubleValue(	public static readonly VOID_DoubleValue terrainElevation = new VOID_DoubleValue(
"Terrain elevation",	"Terrain elevation",
new Func<double> (() => VOID_Core.Instance.vessel.terrainAltitude),	new Func<double> (() => core.vessel.terrainAltitude),
"m"	"m"
);	);

public static readonly VOID_DoubleValue surfVelocity = new VOID_DoubleValue(	public static readonly VOID_DoubleValue surfVelocity = new VOID_DoubleValue(
"Surface velocity",	"Surface velocity",
new Func<double> (() => VOID_Core.Instance.vessel.srf_velocity.magnitude),	new Func<double> (() => core.vessel.srf_velocity.magnitude),
"m/s"	"m/s"
);	);

public static readonly VOID_DoubleValue vertVelocity = new VOID_DoubleValue(	public static readonly VOID_DoubleValue vertVelocity = new VOID_DoubleValue(
"Vertical speed",	"Vertical speed",
new Func<double> (() => VOID_Core.Instance.vessel.verticalSpeed),	new Func<double> (() => core.vessel.verticalSpeed),
"m/s"	"m/s"
);	);

public static readonly VOID_DoubleValue horzVelocity = new VOID_DoubleValue(	public static readonly VOID_DoubleValue horzVelocity = new VOID_DoubleValue(
"Horizontal speed",	"Horizontal speed",
new Func<double> (() => VOID_Core.Instance.vessel.horizontalSrfSpeed),	new Func<double> (() => core.vessel.horizontalSrfSpeed),
"m/s"	"m/s"
);	);

public static readonly VOID_FloatValue temperature = new VOID_FloatValue(	public static readonly VOID_FloatValue temperature = new VOID_FloatValue(
"Temperature",	"Temperature",
new Func<float> (() => VOID_Core.Instance.vessel.flightIntegrator.getExternalTemperature()),	new Func<float> (() => core.vessel.flightIntegrator.getExternalTemperature()),
"°C"	"°C"
);	);

public static readonly VOID_DoubleValue atmDensity = new VOID_DoubleValue (	public static readonly VOID_DoubleValue atmDensity = new VOID_DoubleValue (
"Atmosphere Density",	"Atmosphere Density",
new Func<double> (() => VOID_Core.Instance.vessel.atmDensity * 1000f),	new Func<double> (() => core.vessel.atmDensity * 1000f),
"g/m³"	"g/m³"
);	);

public static readonly VOID_DoubleValue atmPressure = new VOID_DoubleValue (	public static readonly VOID_DoubleValue atmPressure = new VOID_DoubleValue (
"Pressure",	"Pressure",
new Func<double> (() => VOID_Core.Instance.vessel.staticPressure),	new Func<double> (() => core.vessel.staticPressure),
"atm"	"atm"
);	);

public static readonly VOID_FloatValue atmLimit = new VOID_FloatValue(	public static readonly VOID_FloatValue atmLimit = new VOID_FloatValue(
"Atmosphere Limit",	"Atmosphere Limit",
new Func<float> (() => VOID_Core.Instance.vessel.mainBody.maxAtmosphereAltitude),	new Func<float> (() => core.vessel.mainBody.maxAtmosphereAltitude),
"m"	"m"
);	);

public static readonly VOID_StrValue currBiome = new VOID_StrValue(	public static readonly VOID_StrValue currBiome = new VOID_StrValue(
"Biome",	"Biome",
new Func<string> (() => Tools.Toadicus_GetAtt(VOID_Core.Instance.vessel).name)	new Func<string> (() => VOID_Tools.GetBiome(core.vessel).name)
);	);

}	}
}	}

file:b/VOID_TWR.cs (new)

	// VOID © 2014 toadicus
	//
	// This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a
	// copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/

	using KSP;
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using ToadicusTools;
	using UnityEngine;

	namespace VOID
	{
	public class VOID_TWR : VOID_WindowModule
	{
	private List<CelestialBody> sortedBodyList;

	public VOID_TWR() : base()
	{
	this._Name = "IP Thrust-to-Weight Ratios";
	}

	public override void ModuleWindow(int _)
	{
	if (
	HighLogic.LoadedSceneIsEditor \|\|
	(TimeWarp.WarpMode == TimeWarp.Modes.LOW) \|\|
	(TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate)
	)
	{
	Engineer.VesselSimulator.SimManager.RequestSimulation();
	}

	GUILayout.BeginVertical();

	if (this.sortedBodyList == null)
	{
	if (FlightGlobals.Bodies != null && FlightGlobals.Bodies.Count > 0)
	{
	this.sortedBodyList = new List<CelestialBody>(FlightGlobals.Bodies);
	this.sortedBodyList.Sort(new CBListComparer());
	this.sortedBodyList.Reverse();

	Debug.Log(string.Format("sortedBodyList: {0}", string.Join("\n\t", this.sortedBodyList.Select(b => b.bodyName).ToArray())));
	}
	else
	{
	GUILayout.BeginHorizontal();
	GUILayout.Label("Unavailable.");
	GUILayout.EndHorizontal();
	}
	}
	else
	{
	foreach (CelestialBody body in this.sortedBodyList)
	{
	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));

	GUILayout.Label(body.bodyName);
	GUILayout.FlexibleSpace();
	GUILayout.Label(
	(VOID_Data.nominalThrustWeight.Value / body.GeeASL).ToString("0.0##"),
	GUILayout.ExpandWidth(true)
	);

	GUILayout.EndHorizontal();
	}
	}

	GUILayout.EndVertical();

	GUI.DragWindow();
	}
	}

	public class VOID_EditorTWR : VOID_TWR, IVOID_EditorModule {}

	public static partial class VOID_Data
	{
	public static readonly VOID_DoubleValue nominalThrustWeight = new VOID_DoubleValue(
	"Thrust-to-Weight Ratio",
	delegate()
	{
	if (HighLogic.LoadedSceneIsEditor \|\| currThrustWeight.Value == 0d)
	{
	return maxThrustWeight.Value;
	}

	return currThrustWeight.Value;
	},
	""
	);
	}
	}

file:b/VOID_Tools.cs (new)

	// VOID
	//
	// VOID_Tools.cs
	//
	// Copyright © 2014, toadicus
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice,
	// this list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation and/or other
	// materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	using KSP;
	using System;
	using System.Collections.Generic;
	using ToadicusTools;
	using UnityEngine;

	namespace VOID
	{
	public static partial class VOID_Tools
	{
	#region CelestialBody Utilities
	public static bool hasAncestor(this CelestialBody bodyA, CelestialBody bodyB)
	{
	if (bodyA == null \|\| bodyB == null)
	{
	return false;
	}

	while (bodyA.orbitDriver != null)
	{
	if (bodyA.orbit.referenceBody == bodyB)
	{
	return true;
	}

	bodyA = bodyA.orbit.referenceBody;
	}

	return false;
	}

	public static bool NearestRelatedParents(ref CelestialBody bodyA, ref CelestialBody bodyB)
	{
	if (bodyA == null \|\| bodyB == null \|\| bodyA.orbitDriver == null \|\| bodyB.orbitDriver == null)
	{
	throw new ArgumentException(string.Concat(
	"CelestialBody::FindRelatedParents: ",
	"Neither body may be null, and both bodies must have orbits."
	));
	}

	CelestialBody a, b;

	a = bodyA;

	while (bodyA.orbitDriver != null)
	{
	b = bodyB;

	while (b.orbitDriver != null)
	{
	if (a.orbit.referenceBody == b.orbit.referenceBody)
	{
	bodyA = a;
	bodyB = b;
	return true;
	}

	b = b.orbit.referenceBody;
	}

	a = a.orbit.referenceBody;
	}

	return false;
	}
	#endregion

	#region VESSEL_EXTENSIONS_SCIENCE
	public static CBAttributeMap.MapAttribute GetBiome(this Vessel vessel)
	{
	CBAttributeMap.MapAttribute mapAttribute;

	try
	{
	CBAttributeMap BiomeMap = vessel.mainBody.BiomeMap;

	double lat = vessel.latitude * Math.PI / 180d;
	double lon = vessel.longitude * Math.PI / 180d;

	mapAttribute = BiomeMap.GetAtt(lat, lon);

	/*
	lon -= Math.PI / 2d;

	if (lon < 0d)
	{
	lon += 2d * Math.PI;
	}

	float v = (float)(lat / Math.PI) + 0.5f;
	float u = (float)(lon / (2d * Math.PI));

	Color pixelBilinear = BiomeMap.Map.GetPixelBilinear(u, v);
	mapAttribute = BiomeMap.defaultAttribute;

	if (BiomeMap.Map != null)
	{
	if (BiomeMap.exactSearch)
	{
	for (int i = 0; i < BiomeMap.Attributes.Length; ++i)
	{
	if (pixelBilinear == BiomeMap.Attributes[i].mapColor)
	{
	mapAttribute = BiomeMap.Attributes[i];
	}
	}
	}
	else
	{
	float zero = 0;
	float num = 1 / zero;
	for (int j = 0; j < BiomeMap.Attributes.Length; ++j)
	{
	Color mapColor = BiomeMap.Attributes[j].mapColor;
	float sqrMagnitude = ((Vector4)(mapColor - pixelBilinear)).sqrMagnitude;
	if (sqrMagnitude < num)
	{
	bool testCase = true;
	if (BiomeMap.nonExactThreshold != -1)
	{
	testCase = (sqrMagnitude < BiomeMap.nonExactThreshold);
	}
	if (testCase)
	{
	mapAttribute = BiomeMap.Attributes[j];
	num = sqrMagnitude;
	}
	}
	}
	}
	}
	*/
	}
	catch (NullReferenceException)
	{
	mapAttribute = new CBAttributeMap.MapAttribute();
	mapAttribute.name = "N/A";
	}

	return mapAttribute;
	}

	public static ExperimentSituations GetExperimentSituation(this Vessel vessel)
	{
	if (vessel == null)
	{
	return ExperimentSituations.SrfSplashed;
	}

	Vessel.Situations situation = vessel.situation;

	switch (situation)
	{
	case Vessel.Situations.PRELAUNCH:
	case Vessel.Situations.LANDED:
	return ExperimentSituations.SrfLanded;
	case Vessel.Situations.SPLASHED:
	return ExperimentSituations.SrfSplashed;
	case Vessel.Situations.FLYING:
	if (vessel.altitude < (double)vessel.mainBody.scienceValues.flyingAltitudeThreshold)
	{
	return ExperimentSituations.FlyingLow;
	}
	else
	{
	return ExperimentSituations.FlyingHigh;
	}
	}

	if (vessel.altitude < (double)vessel.mainBody.scienceValues.spaceAltitudeThreshold)
	{
	return ExperimentSituations.InSpaceLow;
	}
	else
	{
	return ExperimentSituations.InSpaceHigh;
	}
	}

	public static string HumanString(this ExperimentSituations situation)
	{
	switch (situation)
	{
	case ExperimentSituations.FlyingHigh:
	return "Upper Atmosphere";
	case ExperimentSituations.FlyingLow:
	return "Flying";
	case ExperimentSituations.SrfLanded:
	return "Surface";
	case ExperimentSituations.InSpaceLow:
	return "Near in Space";
	case ExperimentSituations.InSpaceHigh:
	return "High in Space";
	case ExperimentSituations.SrfSplashed:
	return "Splashed Down";
	default:
	return "Unknown";
	}
	}
	#endregion

	#region VESSEL_EXTENSIONS_LAT_LONG
	public static string GetLongitudeString(this Vessel vessel, string format = "F4")
	{
	string dir_long = "W";
	double v_long = vessel.longitude;

	v_long = FixDegreeDomain(v_long);

	if (v_long < -180d)
	{
	v_long += 360d;
	}
	if (v_long >= 180)
	{
	v_long -= 360d;
	}

	if (v_long > 0)
	dir_long = "E";

	return string.Format("{0}° {1}", Math.Abs(v_long).ToString(format), dir_long);
	}

	public static string GetLatitudeString(this Vessel vessel, string format = "F4")
	{
	string dir_lat = "S";
	double v_lat = vessel.latitude;
	if (v_lat > 0)
	dir_lat = "N";

	return string.Format("{0}° {1}", Math.Abs(v_lat).ToString(format), dir_lat);
	}
	#endregion

	#region VESSEL_EXTENSIONS_GENERAL
	public static double TrueAltitude(Vessel vessel)
	{
	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.
	if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean)
	{
	trueAltitude = vessel.orbit.altitude;
	}

	return trueAltitude;
	}

	public static double Radius(this Vessel vessel)
	{
	double radius;

	radius = vessel.altitude;

	if (vessel.mainBody != null)
	{
	radius += vessel.mainBody.Radius;
	}

	return radius;
	}
	#endregion

	#region GEOMETRY_UTILS
	public static double FixAngleDomain(double Angle, bool Degrees = false)
	{
	double Extent = 2d * Math.PI;
	if (Degrees)
	{
	Extent = 360d;
	}

	Angle = Angle % (Extent);
	if (Angle < 0d)
	{
	Angle += Extent;
	}

	return Angle;
	}

	public static double FixDegreeDomain(double Angle)
	{
	return FixAngleDomain(Angle, true);
	}
	#endregion

	private static Dictionary<int, GUI.WindowFunction> functionCache;
	public static UnityEngine.GUI.WindowFunction GetWindowHandler(Action<int> func)
	{
	if (functionCache == null)
	{
	functionCache = new Dictionary<int, GUI.WindowFunction>();
	}

	int hashCode = func.GetHashCode();

	if (!functionCache.ContainsKey(hashCode))
	{
	functionCache[hashCode] = delegate (int id)
	{
	try
	{