ToadGIT :: VOID.git/commitdiff

VOID_DataValue: Removed Invoke() call from ctor to avoid "object not set" exceptions. Added a toggle to DoGUIHorizontal(ushort) to disable the precision button.

16 files changed: (show all)
IntCollection.cs (new)
Tools.cs
VOID.csproj (deleted)
VOIDFlightMaster.cs
VOID_CBInfoBrowser.cs
VOID_Core.cs
VOID_DataValue.cs (new)
VOID_EditorCore.cs
VOID_EditorHUD.cs
VOID_HUD.cs
VOID_Module.cs
VOID_Orbital.cs
VOID_Rendezvous.cs
VOID_SaveValue.cs
VOID_SurfAtmo.cs
VOID_VesselInfo.cs

file:b/IntCollection.cs (new)

	//
	// 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 {
	Console.WriteLine (value);
	if (idx < 0) {
	idx += this.maxCount;
	}

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

	idx *= wordLength;

	long packvalue = value & this.mask;
	Console.WriteLine (packvalue);

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

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

//	//
// Tools.cs	// Tools.cs
//	//
// Author:	// Author:
// toadicus	// toadicus
//	//
// Copyright (c) 2013 toadicus	// Copyright (c) 2013 toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
//	//
// This software uses VesselSimulator and Engineer.Extensions from Engineer Redux.	// This software uses VesselSimulator and Engineer.Extensions from Engineer Redux.
// Engineer Redux (c) 2013 cybutek	// Engineer Redux (c) 2013 cybutek
// Used by permission.	// Used by permission.
//	//
///////////////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////////////


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

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

public static class Tools	public static class Tools
{	{
// Toadicus edit: Added re-implementation of the CBAttributeMap.GetAtt function that does not fire a debug message to the game screen.	// Toadicus edit: Added re-implementation of the CBAttributeMap.GetAtt function that does not fire a debug message to the game screen.
public static CBAttributeMap.MapAttribute Toadicus_GetAtt(Vessel vessel)	public static CBAttributeMap.MapAttribute Toadicus_GetAtt(Vessel vessel)
{	{
CBAttributeMap.MapAttribute mapAttribute;	CBAttributeMap.MapAttribute mapAttribute;

try	try
{	{
CBAttributeMap BiomeMap = vessel.mainBody.BiomeMap;	CBAttributeMap BiomeMap = vessel.mainBody.BiomeMap;
double lat = vessel.latitude * Math.PI / 180d;	double lat = vessel.latitude * Math.PI / 180d;
double lon = vessel.longitude * Math.PI / 180d;	double lon = vessel.longitude * Math.PI / 180d;

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

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

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

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

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

return mapAttribute;	return mapAttribute;
}	}

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

v_long = FixDegreeDomain(v_long);	v_long = FixDegreeDomain(v_long);

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

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

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

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

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

///////////////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////////////

//For MuMech_get_heading()	//For MuMech_get_heading()
public class MuMech_MovingAverage	public class MuMech_MovingAverage
{	{
private double[] store;	private double[] store;
private int storeSize;	private int storeSize;
private int nextIndex = 0;	private int nextIndex = 0;

public double value	public double value
{	{
get	get
{	{
double tmp = 0;	double tmp = 0;
foreach (double i in store)	foreach (double i in store)
{	{
tmp += i;	tmp += i;
}	}
return tmp / storeSize;	return tmp / storeSize;
}	}
set	set
{	{
store[nextIndex] = value;	store[nextIndex] = value;
nextIndex = (nextIndex + 1) % storeSize;	nextIndex = (nextIndex + 1) % storeSize;
}	}
}	}

public MuMech_MovingAverage(int size = 10, double startingValue = 0)	public MuMech_MovingAverage(int size = 10, double startingValue = 0)
{	{
storeSize = size;	storeSize = size;
store = new double[size];	store = new double[size];
force(startingValue);	force(startingValue);
}	}

public void force(double newValue)	public void force(double newValue)
{	{
for (int i = 0; i < storeSize; i++)	for (int i = 0; i < storeSize; i++)
{	{
store[i] = newValue;	store[i] = newValue;
}	}
}	}

public static implicit operator double(MuMech_MovingAverage v)	public static implicit operator double(MuMech_MovingAverage v)
{	{
return v.value;	return v.value;
}	}

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

public string ToString(string format)	public string ToString(string format)
{	{
return value.ToString(format);	return value.ToString(format);
}	}
}	}

//From http://svn.mumech.com/KSP/trunk/MuMechLib/VOID.vesselState.cs	//From http://svn.mumech.com/KSP/trunk/MuMechLib/VOID.vesselState.cs
public static double MuMech_get_heading(Vessel vessel)	public static double MuMech_get_heading(Vessel vessel)
{	{
Vector3d CoM = vessel.findWorldCenterOfMass();	Vector3d CoM = vessel.findWorldCenterOfMass();
Vector3d up = (CoM - vessel.mainBody.position).normalized;	Vector3d up = (CoM - vessel.mainBody.position).normalized;
Vector3d north = Vector3d.Exclude(up, (vessel.mainBody.position + vessel.mainBody.transform.up * (float)vessel.mainBody.Radius) - CoM).normalized;	Vector3d north = Vector3d.Exclude(
	up,
Quaternion rotationSurface = Quaternion.LookRotation(north, up);	(vessel.mainBody.position +
Quaternion rotationvesselSurface = Quaternion.Inverse(Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(vessel.transform.rotation) * rotationSurface);	vessel.mainBody.transform.up * (float)vessel.mainBody.Radius
MuMech_MovingAverage vesselHeading = new MuMech_MovingAverage();	) - CoM).normalized;
vesselHeading.value = rotationvesselSurface.eulerAngles.y;
return vesselHeading.value * 10; // *10 by me	Quaternion rotationSurface = Quaternion.LookRotation(north, up);
}	Quaternion rotationvesselSurface = Quaternion.Inverse(
	Quaternion.Euler(90, 0, 0) *
//From http://svn.mumech.com/KSP/trunk/MuMechLib/MuUtils.cs	Quaternion.Inverse(vessel.transform.rotation) *
public static string MuMech_ToSI(double d)	rotationSurface);
{
int digits = 2;	return rotationvesselSurface.eulerAngles.y;
double exponent = Math.Log10(Math.Abs(d));	}
if (Math.Abs(d) >= 1)
{	//From http://svn.mumech.com/KSP/trunk/MuMechLib/MuUtils.cs
switch ((int)Math.Floor(exponent))	public static string MuMech_ToSI(
{	double d, int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue
case 0:	)
case 1:	{
case 2:	float exponent = (float)Math.Log10(Math.Abs(d));
return d.ToString("F" + digits);	exponent = Mathf.Clamp(exponent, (float)MinMagnitude, (float)MaxMagnitude);
case 3:
case 4:	if (exponent >= 0)
case 5:	{
return (d / 1e3).ToString("F" + digits) + "k";	switch ((int)Math.Floor(exponent))
case 6:	{
case 7:	case 0:
case 8:	case 1:
return (d / 1e6).ToString("F" + digits) + "M";	case 2:
case 9:	return d.ToString("F" + digits);
case 10:	case 3:
case 11:	case 4:
return (d / 1e9).ToString("F" + digits) + "G";	case 5:
case 12:	return (d / 1e3).ToString("F" + digits) + "k";
case 13:	case 6:
case 14:	case 7:
return (d / 1e12).ToString("F" + digits) + "T";	case 8:
case 15:	return (d / 1e6).ToString("F" + digits) + "M";
case 16:	case 9:
case 17:	case 10:
return (d / 1e15).ToString("F" + digits) + "P";	case 11:
case 18:	return (d / 1e9).ToString("F" + digits) + "G";
case 19:	case 12:
case 20:	case 13:
return (d / 1e18).ToString("F" + digits) + "E";	case 14:
case 21:	return (d / 1e12).ToString("F" + digits) + "T";
case 22:	case 15:
case 23:	case 16:
return (d / 1e21).ToString("F" + digits) + "Z";	case 17:
default:	return (d / 1e15).ToString("F" + digits) + "P";
return (d / 1e24).ToString("F" + digits) + "Y";	case 18:
}	case 19:
}	case 20:
else if (Math.Abs(d) > 0)	return (d / 1e18).ToString("F" + digits) + "E";
{	case 21:
switch ((int)Math.Floor(exponent))	case 22:
{	case 23:
case -1:	return (d / 1e21).ToString("F" + digits) + "Z";
case -2:	default:
case -3:	return (d / 1e24).ToString("F" + digits) + "Y";
return (d * 1e3).ToString("F" + digits) + "m";	}
case -4:	}
case -5:	else if (exponent < 0)
case -6:	{
return (d * 1e6).ToString("F" + digits) + "μ";	switch ((int)Math.Floor(exponent))
case -7:	{
case -8:	case -1:
case -9:	case -2:
return (d * 1e9).ToString("F" + digits) + "n";	case -3:
case -10:	return (d * 1e3).ToString("F" + digits) + "m";
case -11:	case -4:
case -12:	case -5:
return (d * 1e12).ToString("F" + digits) + "p";	case -6:
case -13:	return (d * 1e6).ToString("F" + digits) + "μ";
case -14:	case -7:
case -15:	case -8:
return (d * 1e15).ToString("F" + digits) + "f";	case -9:
case -16:	return (d * 1e9).ToString("F" + digits) + "n";
case -17:	case -10:
case -18:	case -11:
return (d * 1e18).ToString("F" + digits) + "a";	case -12:
case -19:	return (d * 1e12).ToString("F" + digits) + "p";
case -20:	case -13:
case -21:	case -14:
return (d * 1e21).ToString("F" + digits) + "z";	case -15:
default:	return (d * 1e15).ToString("F" + digits) + "f";
return (d * 1e24).ToString("F" + digits) + "y";	case -16:
}	case -17:
}	case -18:
else	return (d * 1e18).ToString("F" + digits) + "a";
{	case -19:
return "0";	case -20:
}	case -21:
}	return (d * 1e21).ToString("F" + digits) + "z";
	default:
public static string ConvertInterval(double seconds)	return (d * 1e24).ToString("F" + digits) + "y";
{	}
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";	else
string format_3 = "{0:D2}h {1:D2}m {2:D2}.{3:D1}s";	{
	return "0";
	}
	}

	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;	TimeSpan interval;

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

int years = interval.Days / 365;	int years = interval.Days / 365;

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

public static string UppercaseFirst(string s)	public static string UppercaseFirst(string s)
{	{
if (string.IsNullOrEmpty(s))	if (string.IsNullOrEmpty(s))
{	{
return string.Empty;	return string.Empty;
}	}
char[] a = s.ToCharArray();	char[] a = s.ToCharArray();
a[0] = char.ToUpper(a[0]);	a[0] = char.ToUpper(a[0]);
return new string(a);	return new string(a);
}	}

//transfer angles	//transfer angles

public static double Nivvy_CalcTransferPhaseAngle(double r_current, double r_target, double grav_param)	public static double Nivvy_CalcTransferPhaseAngle(double r_current, double r_target, double grav_param)
{	{
double T_target = (2 * Math.PI) * Math.Sqrt(Math.Pow((r_target / 1000), 3) / (grav_param / 1000000000));	double T_target = (2 * Math.PI) * Math.Sqrt(Math.Pow((r_target / 1000), 3) / (grav_param / 1000000000));
double T_transfer = (2 * Math.PI) * Math.Sqrt(Math.Pow((((r_target / 1000) + (r_current / 1000)) / 2), 3) / (grav_param / 1000000000));	double T_transfer = (2 * Math.PI) * Math.Sqrt(Math.Pow((((r_target / 1000) + (r_current / 1000)) / 2), 3) / (grav_param / 1000000000));
return 360 * (0.5 - (T_transfer / (2 * T_target)));	return 360 * (0.5 - (T_transfer / (2 * T_target)));
}	}

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

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

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

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

public static double Adammada_CurrrentPhaseAngle(double body_LAN, double body_orbitPct, double origin_LAN, double origin_orbitPct)	public static double Adammada_CurrrentPhaseAngle(double body_LAN, double body_orbitPct, double origin_LAN, double origin_orbitPct)
{	{
double angle = (body_LAN / 360 + body_orbitPct) - (origin_LAN / 360 + origin_orbitPct);	double angle = (body_LAN / 360 + body_orbitPct) - (origin_LAN / 360 + origin_orbitPct);
if (angle > 1) angle = angle - 1;	if (angle > 1) angle = angle - 1;
if (angle < 0) angle = angle + 1;	if (angle < 0) angle = angle + 1;
if (angle > 0.5) angle = angle - 1;	if (angle > 0.5) angle = angle - 1;
angle = angle * 360;	angle = angle * 360;
return angle;	return angle;
}	}

public static double Adammada_CurrentEjectionAngle(double vessel_long, double origin_rotAngle, double origin_LAN, double origin_orbitPct)	public static double Adammada_CurrentEjectionAngle(double vessel_long, double origin_rotAngle, double origin_LAN, double origin_orbitPct)
{	{
//double eangle = ((FlightGlobals.ActiveVOID.vessel.longitude + orbiting.rotationAngle) - (orbiting.orbit.LAN / 360 + orbiting.orbit.orbitPercent) * 360);	//double eangle = ((FlightGlobals.ActiveVOID.vessel.longitude + orbiting.rotationAngle) - (orbiting.orbit.LAN / 360 + orbiting.orbit.orbitPercent) * 360);
double eangle = ((vessel_long + origin_rotAngle) - (origin_LAN / 360 + origin_orbitPct) * 360);	double eangle = ((vessel_long + origin_rotAngle) - (origin_LAN / 360 + origin_orbitPct) * 360);

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

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

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

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

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

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

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

return (phase + 360) % 360;	return (phase + 360) % 360;
}	}

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

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

return Angle;	return Angle;
}	}

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

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

public static double adjust_current_ejection_angle(double curr_ejection)	public static double adjust_current_ejection_angle(double curr_ejection)
{	{
//curr_ejection WILL need to be adjusted once for all transfers as it returns values ranging -180 to 180	//curr_ejection WILL need to be adjusted once for all transfers as it returns values ranging -180 to 180
// need 0-360 instead	// need 0-360 instead
//	//
// ie i have -17 in the screenshot	// ie i have -17 in the screenshot
// need it to show 343	// need it to show 343
//	//
// do this	// do this
//	//
// if < 0, add curr to 360 // 360 + (-17) = 343	// if < 0, add curr to 360 // 360 + (-17) = 343
// else its good as it is	// else its good as it is

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

}	}

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

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

}	}

public static double TrueAltitude(Vessel vessel)	public static double TrueAltitude(Vessel vessel)
{	{
double trueAltitude = vessel.orbit.altitude - vessel.terrainAltitude;	double trueAltitude = vessel.orbit.altitude - vessel.terrainAltitude;

// HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m.	// HACK: This assumes that on worlds with oceans, all water is fixed at 0 m,
	// and water covers the whole surface at 0 m.
if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean )	if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean )
{	{
trueAltitude = vessel.orbit.altitude;	trueAltitude = vessel.orbit.altitude;
}	}

return trueAltitude;	return trueAltitude;
}	}

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



public static void display_transfer_angles_SUN2PLANET(CelestialBody body, Vessel vessel)	public static void display_transfer_angles_SUN2PLANET(CelestialBody body, Vessel vessel)
{	{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Phase angle (curr/trans):");	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.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.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Transfer velocity:");	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.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();	GUILayout.EndHorizontal();
}	}

public static void display_transfer_angles_PLANET2PLANET(CelestialBody body, Vessel vessel)	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 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 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 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 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 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 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_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_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);	double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle);

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Phase angle (curr/trans):");	GUILayout.Label("Phase angle (curr/trans):");
GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Ejection angle (curr/trans):");	GUILayout.Label("Ejection angle (curr/trans):");
GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Transfer velocity:");	GUILayout.Label("Transfer velocity:");
GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));	GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();
}	}

public static void display_transfer_angles_PLANET2MOON(CelestialBody body, Vessel vessel)	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 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);	double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter);

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Phase angle (curr/trans):");	GUILayout.Label("Phase angle (curr/trans):");
GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Transfer velocity:");	GUILayout.Label("Transfer velocity:");
GUILayout.Label((dv1 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));	GUILayout.Label((dv1 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();
}	}

public static void display_transfer_angles_MOON2MOON(CelestialBody body, Vessel vessel)	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 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 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 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_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 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 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_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle);
//double adj_ejection_angle = adjustCurrEjectionAngle(trans_phase_angle, curr_ejection_angle);	//double adj_ejection_angle = adjustCurrEjectionAngle(trans_phase_angle, curr_ejection_angle);

//new stuff	//new stuff
//	//
double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_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);	double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle);
//	//
//	//

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Phase angle (curr/trans):");	GUILayout.Label("Phase angle (curr/trans):");
GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Ejection angle (curr/trans):");	GUILayout.Label("Ejection angle (curr/trans):");
GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));	GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Transfer velocity:");	GUILayout.Label("Transfer velocity:");
GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));	GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	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;
	}

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

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

KSPLog.print(Msg);	KSPLog.print(Msg);
}	}
}	}
}	}

file:a/VOID.csproj (deleted)

<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<PropertyGroup>
<Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
<Platform Condition=" '$(Platform)' == '' ">x86</Platform>
<ProductVersion>10.0.0</ProductVersion>
<SchemaVersion>2.0</SchemaVersion>
<ProjectGuid>{45ACC1CC-942C-4A66-BFC7-8BE375938B18}</ProjectGuid>
<OutputType>Library</OutputType>
<RootNamespace>VOID</RootNamespace>
<AssemblyName>VOID</AssemblyName>
<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Debug\|x86' ">
<DebugSymbols>true</DebugSymbols>
<DebugType>full</DebugType>
<Optimize>false</Optimize>
<OutputPath>bin\Debug</OutputPath>
<DefineConstants>DEBUG; TRACE</DefineConstants>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<ConsolePause>false</ConsolePause>
<CustomCommands>
<CustomCommands>
<Command type="AfterBuild" command="xcopy /Y ${ProjectDir}\bin\Debug\*.dll ..\..\..\Games\KSP_win\GameData\VOID\Plugins\" workingdir="${ProjectDir}" externalConsole="True" />
</CustomCommands>
</CustomCommands>
</PropertyGroup>
<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Release\|x86' ">
<Optimize>true</Optimize>
<OutputPath>bin\Release</OutputPath>
<ErrorReport>prompt</ErrorReport>
<WarningLevel>4</WarningLevel>
<ConsolePause>false</ConsolePause>
<DefineConstants>TRACE</DefineConstants>
<CustomCommands>
<CustomCommands>
<Command type="AfterBuild" command="xcopy /Y ${ProjectDir}\bin\Release\*.dll ..\..\..\Games\KSP_win\GameData\VOID\Plugins\" workingdir="${ProjectDir}" externalConsole="True" />
</CustomCommands>
</CustomCommands>
</PropertyGroup>
<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
<ItemGroup>
<Compile Include="Tools.cs" />
<Compile Include="IVOID_Module.cs" />
<Compile Include="VOIDFlightMaster.cs" />
<Compile Include="VOID_Core.cs" />
<Compile Include="VOID_Module.cs" />
<Compile Include="VOID_HUD.cs" />
<Compile Include="VOID_SaveValue.cs" />
<Compile Include="VOID_Orbital.cs" />
<Compile Include="VOID_SurfAtmo.cs" />
<Compile Include="VOID_VesselInfo.cs" />
<Compile Include="VOID_Transfer.cs" />
<Compile Include="VOID_CBInfoBrowser.cs" />
<Compile Include="VOID_Rendezvous.cs" />
<Compile Include="VOID_VesselRegister.cs" />
<Compile Include="VOID_DataLogger.cs" />
<Compile Include="VOID_EditorCore.cs" />
<Compile Include="VOID_EditorHUD.cs" />
</ItemGroup>
<ItemGroup>
<Reference Include="Assembly-CSharp">
<HintPath>..\..\..\Games\KSP_win\KSP_Data\Managed\Assembly-CSharp.dll</HintPath>
</Reference>
<Reference Include="UnityEngine">
<HintPath>..\..\..\Games\KSP_win\KSP_Data\Managed\UnityEngine.dll</HintPath>
</Reference>
<Reference Include="System">
<HintPath>..\..\..\Games\KSP_win\KSP_Data\Managed\System.dll</HintPath>
</Reference>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Engineer.Extensions\Engineer.Extensions.csproj">
<Project>{2FCF882B-0771-4649-8D04-81D7AA76A486}</Project>
<Name>Engineer.Extensions</Name>
</ProjectReference>
<ProjectReference Include="..\VesselSimulator\VesselSimulator.csproj">
<Project>{30FD6C0B-D36E-462F-B0FF-F0FAC9C666CF}</Project>
<Name>VesselSimulator</Name>
</ProjectReference>
</ItemGroup>
<ProjectExtensions>
<MonoDevelop>
<Properties>
<Policies>
<StandardHeader Text=" ${FileName} Author: ${AuthorName} <${AuthorEmail}> Copyright (c) ${Year} ${CopyrightHolder} 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/>." IncludeInNewFiles="True" />
</Policies>
</Properties>
</MonoDevelop>
</ProjectExtensions>
</Project>

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

///////////////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////////////
//	//
// VOID - Vessel Orbital Information Display for Kerbal Space Program	// VOID - Vessel Orbital Information Display for Kerbal Space Program
// Copyright (C) 2012 Iannic-ann-od	// Copyright (C) 2012 Iannic-ann-od
// Copyright (C) 2013 Toadicus	// Copyright (C) 2013 Toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
//	//
///////////////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////////////
//	//
// Much, much credit to Younata, Adammada, Nivvydaskrl and to all the authors	// Much, much credit to Younata, Adammada, Nivvydaskrl and to all the authors
// behind MechJeb, RemoteTech Relay Network, ISA MapSat, and Protractor for some	// behind MechJeb, RemoteTech Relay Network, ISA MapSat, and Protractor for some
// invaluable functions and making your nicely written code available to learn from.	// invaluable functions and making your nicely written code available to learn from.
//	//
///////////////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////////////
//	//
// This software uses VesselSimulator and Engineer.Extensions from Engineer Redux.	// This software uses VesselSimulator and Engineer.Extensions from Engineer Redux.
// Engineer Redux (c) 2013 cybutek	// Engineer Redux (c) 2013 cybutek
// Used by permission.	// Used by permission.
//	//
///////////////////////////////////////////////////////////////////////////////	///////////////////////////////////////////////////////////////////////////////

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

namespace VOID	namespace VOID
{	{
[KSPAddon(KSPAddon.Startup.Flight, false)]	[KSPAddon(KSPAddon.Startup.Flight, false)]
public class VOIDFlightMaster : MonoBehaviour	public class VOIDFlightMaster : MonoBehaviour
{	{
protected VOID_Core Core;	protected VOID_Core Core;

public void Awake()	public void Awake()
{	{
Tools.PostDebugMessage ("VOIDLightMaster: Waking up.");	Tools.PostDebugMessage ("VOIDFlightMaster: Waking up.");
this.Core = (VOID_Core)VOID_Core.Instance;	this.Core = (VOID_Core)VOID_Core.Instance;
this.Core.StartGUI ();	this.Core.ResetGUI ();
Tools.PostDebugMessage ("VOIDFlightMaster: Awake.");	Tools.PostDebugMessage ("VOIDFlightMaster: Awake.");
}	}

public void Update()	public void Update()
{	{
if (!HighLogic.LoadedSceneIsEditor)	if (!HighLogic.LoadedSceneIsFlight && this.Core != null)
{	{
	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.vessel != null)	if (this.Core.vessel != null)
{	{
SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter / Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);	SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /
	Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);
SimManager.Instance.TryStartSimulation();	SimManager.Instance.TryStartSimulation();
}	}

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();
}	}
}	}

[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.StartGUI ();	this.Core.ResetGUI ();
Tools.PostDebugMessage ("VOIDEditorMaster: Awake.");	Tools.PostDebugMessage ("VOIDEditorMaster: Awake.");
}	}

public void Update()	public void Update()
{	{
if (!HighLogic.LoadedSceneIsEditor)	if (!HighLogic.LoadedSceneIsEditor && this.Core != null)
{	{
	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/VOID_CBInfoBrowser.cs -> file:b/VOID_CBInfoBrowser.cs

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

//	//
// VOID_Core.cs	// VOID_Core.cs
//	//
// Author:	// Author:
// toadicus <>	// toadicus <>
//	//
// Copyright (c) 2013 toadicus	// Copyright (c) 2013 toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using System.Linq;	using System.Linq;
using System.Reflection;	using System.Reflection;
using KSP;	using KSP;
using UnityEngine;	using UnityEngine;

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

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

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

public static double Constant_G = 6.674e-11;	public static double Constant_G = 6.674e-11;

/*	/*
* Fields	* Fields
* */	* */
protected string VoidName = "VOID";	protected string VoidName = "VOID";
protected string VoidVersion = "0.9.9";	protected string VoidVersion = "0.9.13";

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 - 30, 30f, 30f);	protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 30, 30f, 30f);
protected Texture2D VOIDIconOff = new Texture2D(30, 30, TextureFormat.ARGB32, false);	protected Texture2D VOIDIconOff = new Texture2D(30, 30, TextureFormat.ARGB32, false);
protected Texture2D VOIDIconOn = new Texture2D(30, 30, TextureFormat.ARGB32, false);	protected Texture2D VOIDIconOn = new Texture2D(30, 30, TextureFormat.ARGB32, false);
protected Texture2D VOIDIconTexture;	protected Texture2D VOIDIconTexture;
protected string VOIDIconOnPath = "VOID/Textures/void_icon_on";	protected string VOIDIconOnPath = "VOID/Textures/void_icon_on";
protected string VOIDIconOffPath = "VOID/Textures/void_icon_off";	protected string VOIDIconOffPath = "VOID/Textures/void_icon_off";
protected bool VOIDIconLocked = true;	protected bool VOIDIconLocked = true;

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>();

[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")]
	protected VOID_SaveValue<double> _updatePeriod = 1001f/15000f;
	protected float _updateTimer = 0f;
	protected string stringFrequency;

// Celestial Body Housekeeping	// Celestial Body Housekeeping
protected List<CelestialBody> _allBodies = new List<CelestialBody>();	protected List<CelestialBody> _allBodies = new List<CelestialBody>();
protected bool bodiesLoaded = false;	protected bool bodiesLoaded = false;

// 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";	[AVOID_SaveValue("defaultSkin")]
protected VOID_SaveValue<int> _skinIdx = int.MinValue;	protected VOID_SaveValue<string> defaultSkin = "KSP window 2";
	protected int _skinIdx = int.MinValue;
protected List<GUISkin> skin_list;	protected List<GUISkin> skin_list;
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"
};	};
protected bool skinsLoaded = false;	protected bool skinsLoaded = false;

public bool configDirty;	public bool configDirty;

/*	/*
* 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.skin_list == null \|\| this._skinIdx < 0 \|\| this._skinIdx > this.skin_list.Count)	if (this.skin_list == null \|\| this._skinIdx < 0 \|\| this._skinIdx > this.skin_list.Count)
{	{
return AssetBase.GetGUISkin(this.defaultSkin);	return AssetBase.GetGUISkin(this.defaultSkin);
}	}
return this.skin_list[this._skinIdx];	return this.skin_list[this._skinIdx];
}	}
}	}

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 this._allBodies;	return this._allBodies;
}	}
}	}

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

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

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

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

this._Active = true;	this._Active = true;

this.VOIDIconOn = GameDatabase.Instance.GetTexture (this.VOIDIconOnPath, false);	this.VOIDIconOn = GameDatabase.Instance.GetTexture (this.VOIDIconOnPath, false);
this.VOIDIconOff = GameDatabase.Instance.GetTexture (this.VOIDIconOffPath, false);	this.VOIDIconOff = GameDatabase.Instance.GetTexture (this.VOIDIconOffPath, false);

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

protected void 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 &&
	typeof(IVOID_EditorModule).IsAssignableFrom(voidType)
	)
	{
	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 Preload_BeforeUpdate()
	{
	if (!this.bodiesLoaded)
	{
	this.LoadAllBodies();
	}

	if (!this.vesselTypesLoaded)
	{
	this.LoadVesselTypes();
	}
	}

public void Update()	public void Update()
{	{
this.saveTimer += Time.deltaTime;	this.Preload_BeforeUpdate ();

if (!this.bodiesLoaded)
{
this.LoadAllBodies();
}

if (!this.vesselTypesLoaded)
{
this.LoadVesselTypes();
}

if (!this.guiRunning)	if (!this.guiRunning)
{	{
this.StartGUI ();	this.StartGUI ();
}	}

if (!HighLogic.LoadedSceneIsFlight && this.guiRunning)	if (!HighLogic.LoadedSceneIsFlight && this.guiRunning)
{	{
this.StopGUI ();	this.StopGUI ();
}	}

foreach (IVOID_Module module in this.Modules)	foreach (IVOID_Module module in this.Modules)
{	{
if (!module.guiRunning && module.toggleActive)	if (!module.guiRunning && module.toggleActive)
{	{
module.StartGUI ();	module.StartGUI ();
}	}
if (module.guiRunning && !module.toggleActive \|\|	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();
}	}
}	}

if (this.saveTimer > 2f)	this.CheckAndSave ();
{	this._updateTimer += Time.deltaTime;
this.SaveConfig ();
this.saveTimer = 0;
}
}	}

public void FixedUpdate()	public void FixedUpdate()
{	{
if (this.consumeResource &&	if (this.consumeResource &&
this.vessel.vesselType != VesselType.EVA &&	this.vessel.vesselType != VesselType.EVA &&
TimeWarp.deltaTime != 0	TimeWarp.deltaTime != 0
)	)
{	{
float powerReceived = this.vessel.rootPart.RequestResource(this.resourceName,	float powerReceived = this.vessel.rootPart.RequestResource(this.resourceName,
this.resourceRate * TimeWarp.fixedDeltaTime);	this.resourceRate * TimeWarp.fixedDeltaTime);
if (powerReceived > 0)	if (powerReceived > 0)
{	{
this.powerAvailable = true;	this.powerAvailable = true;
}	}
else	else
{	{
this.powerAvailable = false;	this.powerAvailable = false;
}	}
}	}

foreach (IVOID_BehaviorModule module in	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();
}	}
}	}

protected void LoadSkins()	protected void LoadSkins()
{	{
this.skin_list = AssetBase.FindObjectsOfTypeIncludingAssets(typeof(GUISkin))	this.skin_list = AssetBase.FindObjectsOfTypeIncludingAssets(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)
.ToList();	.ToList();

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

if (this._skinIdx == int.MinValue)	if (this._skinIdx == int.MinValue)
{	{
this._skinIdx = this.skin_list.IndexOf(this.Skin);	this._skinIdx = this.skin_list.IndexOf(this.Skin);
Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"{0}: resetting _skinIdx to default.",	"{0}: resetting _skinIdx to default.",
this.GetType().Name	this.GetType().Name
));	));
}	}

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

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

protected void LoadGUIStyles()	protected void LoadGUIStyles()
{	{
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["txt_right"] = new GUIStyle(GUI.skin.label);	this.LabelStyles["right"] = new GUIStyle(GUI.skin.label);
this.LabelStyles["txt_right"].normal.textColor = Color.white;	this.LabelStyles["right"].normal.textColor = Color.white;
this.LabelStyles["txt_right"].alignment = TextAnchor.UpperRight;	this.LabelStyles["right"].alignment = TextAnchor.UpperRight;

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


protected void LoadAllBodies()	protected void LoadAllBodies()
{	{
this._allBodies = FlightGlobals.Bodies;	this._allBodies = FlightGlobals.Bodies;
this.bodiesLoaded = true;	this.bodiesLoaded = 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 CheckAndSave()
	{
	this.saveTimer += Time.deltaTime;

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

	if (!this.configDirty)
	{
	return;
	}

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

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 = "ON";	string str = "ON";
if (togglePower) str = "OFF";	if (togglePower) str = "OFF";
if (GUILayout.Button("Power " + str)) togglePower = !togglePower;	if (GUILayout.Button("Power " + str)) togglePower = !togglePower;
}	}

if (togglePower \|\| 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
{	{
GUIStyle label_txt_red = new GUIStyle(GUI.skin.label);	GUIStyle label_txt_red = new GUIStyle(GUI.skin.label);
label_txt_red.normal.textColor = Color.red;	label_txt_red.normal.textColor = Color.red;
label_txt_red.alignment = TextAnchor.MiddleCenter;	label_txt_red.alignment = TextAnchor.MiddleCenter;
GUILayout.Label("-- POWER LOST --", label_txt_red);	GUILayout.Label("-- POWER LOST --", label_txt_red);
}	}

this.configWindowMinimized = !GUILayout.Toggle (!this.configWindowMinimized, "Configuration");	this.configWindowMinimized = !GUILayout.Toggle (!this.configWindowMinimized, "Configuration");

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

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

this.DrawConfigurables ();	this.DrawConfigurables ();

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

public override void DrawConfigurables()	public override void DrawConfigurables()
{	{
if (HighLogic.LoadedSceneIsFlight)	if (HighLogic.LoadedSceneIsFlight)
{	{
this.consumeResource = GUILayout.Toggle (this.consumeResource, "Consume Resources");	this.consumeResource = GUILayout.Toggle (this.consumeResource, "Consume Resources");

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

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

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

GUIContent _content = new GUIContent();	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._skinIdx--;	this._skinIdx--;
if (this._skinIdx < 0) this._skinIdx = skin_list.Count - 1;	if (this._skinIdx < 0) this._skinIdx = skin_list.Count - 1;
Tools.PostDebugMessage("[VOID] new this._skin = " + this._skinIdx + " :: skin_list.Count = " + skin_list.Count);	Tools.PostDebugMessage (string.Format (
	"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",
	this.GetType().Name,
	this._skinIdx,
	this.skin_list.Count
	));
}	}

string skin_name = skin_list[this._skinIdx].name;	string skin_name = skin_list[this._skinIdx].name;
_content.text = skin_name;	_content.text = 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._skinIdx++;	this._skinIdx++;
if (this._skinIdx >= skin_list.Count) this._skinIdx = 0;	if (this._skinIdx >= skin_list.Count) this._skinIdx = 0;
Tools.PostDebugMessage("[VOID] new this._skin = " + this._skinIdx + " :: skin_list.Count = " + skin_list.Count);	Tools.PostDebugMessage (string.Format (
	"{0}: new this._skinIdx = {1} :: skin_list.Count = {2}",
	this.GetType().Name,
	this._skinIdx,
	this.skin_list.Count
	));
	}

	if (this.Skin.name != this.defaultSkin)
	{
	this.defaultSkin = this.Skin.name;
}	}

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

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

public void OnGUI()	public 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 override void DrawGUI()	public override void DrawGUI()
{	{
if (!this._modulesLoaded)	if (!this._modulesLoaded)
{	{
this.LoadModulesOfType<IVOID_Module> ();	this.LoadModulesOfType<IVOID_Module> ();
}	}

this._windowID = this.windowBaseID;	this._windowID = this.windowBaseID;

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 ();
}	}

this.VOIDIconTexture = this.VOIDIconOff; //icon off default	this.VOIDIconTexture = this.VOIDIconOff; //icon off default
if (this.togglePower) this.VOIDIconTexture = this.VOIDIconOn; //or on if power_toggle==true	if (this.togglePower) this.VOIDIconTexture = this.VOIDIconOn; //or on if power_toggle==true
if (GUI.Button(VOIDIconPos, VOIDIconTexture, new GUIStyle()) && this.VOIDIconLocked)	if (GUI.Button(VOIDIconPos, VOIDIconTexture, new GUIStyle()) && this.VOIDIconLocked)
{	{
this.mainGuiMinimized = !this.mainGuiMinimized;	this.mainGuiMinimized = !this.mainGuiMinimized;
}	}

if (!this.mainGuiMinimized)	if (!this.mainGuiMinimized)
{	{
Rect _mainWindowPos = this.mainWindowPos;	Rect _mainWindowPos = this.mainWindowPos;

_mainWindowPos = GUILayout.Window (	_mainWindowPos = GUILayout.Window (
this.windowID,	this.windowID,
_mainWindowPos,	_mainWindowPos,
this.VOIDMainWindow,	this.VOIDMainWindow,
string.Join (" ", new string[] {this.VoidName, this.VoidVersion}),	string.Join (" ", new string[] {this.VoidName, this.VoidVersion}),
GUILayout.Width (250),	GUILayout.Width (250),
GUILayout.Height (50)	GUILayout.Height (50)
);	);

	_mainWindowPos = Tools.ClampRectToScreen (_mainWindowPos);

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

if (!this.configWindowMinimized)	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,	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);

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

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

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

	this.StartGUI ();
	}

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()
{	{
if (!this.configDirty)
{
return;
}

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

file:b/VOID_DataValue.cs (new)

	//
	// VOID_DataValue.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;
	using UnityEngine;

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

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

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

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

	public T Value {
	get {
	return (T)this.cache;
	}
	}

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

	public void Refresh()
	{
	this.cache = this.ValueFunc.Invoke ();
	}

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

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

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

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

	internal interface IVOID_NumericValue
	{
	string ToString(string format);
	string ToSIString(int digits, int MinMagnitude, int MaxMagnitude);
	}

	public abstract class VOID_NumValue<T> : VOID_DataValue<T>, IVOID_NumericValue
	{
	public VOID_NumValue(string Label, Func<T> ValueFunc, string Units = "") : base(Label, ValueFunc, Units) {}

	public abstract string ToString(string Format);
	public abstract string ToSIString(int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue);

	public abstract string ValueUnitString(string format);
	public abstract string ValueUnitString(ushort digits);

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

	public virtual ushort DoGUIHorizontal(ushort digits, bool precisionButton = true)
	{
	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
	GUILayout.Label(this.Label + ":", GUILayout.ExpandWidth(true));
	GUILayout.FlexibleSpace();
	GUILayout.Label(this.ValueUnitString(digits), GUILayout.ExpandWidth(false));
	if (precisionButton)
	{
	if (GUILayout.Button ("P"))
	{
	digits = (ushort)((digits + 3) % 15);
	}
	}
	GUILayout.EndHorizontal();

	return digits;
	}
	}

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

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

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

	public override string ValueUnitString(ushort digits) {
	return Tools.MuMech_ToSI(this.Value, digits) + this.Units;
	}

	public override string ToSIString(int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue)
	{
	return string.Format (
	"{0}{1}",
	Tools.MuMech_ToSI (this.Value, digits, MinMagnitude, MaxMagnitude),
	this.Units
	);
	}
	}
	public class VOID_FloatValue : VOID_NumValue<float>, IVOID_NumericValue
	{
	public VOID_FloatValue(string Label, Func<float> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}

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

	public override string ValueUnitString(ushort digits) {
	return Tools.MuMech_ToSI((double)this.Value, digits) + this.Units;
	}

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

	public override string ToSIString(int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue)
	{
	return string.Format (
	"{0}{1}",
	Tools.MuMech_ToSI ((double)this.Value, digits, MinMagnitude, MaxMagnitude),
	this.Units
	);
	}
	}
	public class VOID_IntValue : VOID_NumValue<int>, IVOID_NumericValue
	{
	public VOID_IntValue(string Label, Func<int> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}

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

	public override string ValueUnitString(ushort digits) {
	return Tools.MuMech_ToSI((double)this.Value, digits) + this.Units;
	}

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

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


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

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

//	//
// VOID_EditorCore.cs	// VOID_EditorCore.cs
//	//
// Author:	// Author:
// toadicus <>	// toadicus <>
//	//
// Copyright (c) 2013 toadicus	// Copyright (c) 2013 toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
using 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 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;
}	}
}	}

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

public new void OnGUI() {}	public new 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 = new Rect(this.VOIDIconPos);	Rect _iconPos = Tools.DockToWindow (this.VOIDIconPos, this.mainWindowPos);
Vector2 _iconCtr = new Vector2 ();
_iconCtr.x = ((Rect)this.mainWindowPos).center.x;

if (this.mainWindowPos.value.center.y < Screen.height / 2)	_iconPos = Tools.ClampRectToScreen (_iconPos, (int)_iconPos.width, (int)_iconPos.height);
{
_iconCtr.y = ((Rect)this.mainWindowPos).yMin - 15;
}
else
{
_iconCtr.y = ((Rect)this.mainWindowPos).yMax + 15;
}

_iconPos.center = _iconCtr;	if (_iconPos != this.VOIDIconPos)

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

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

public new void Update()	public new 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)	if (EditorLogic.startPod == null \|\| !HighLogic.LoadedSceneIsEditor)
{	{
this.StopGUI();	this.StopGUI();
return;	return;
}	}
else if (!this.guiRunning)	else if (!this.guiRunning && HighLogic.LoadedSceneIsEditor)
{	{
this.StartGUI();	this.StartGUI();
}	}

if (EditorLogic.SortedShipList.Count > 0)	if (EditorLogic.SortedShipList.Count > 0)
{	{
SimManager.Instance.Gravity = 9.08665;	SimManager.Instance.Gravity = 9.08665;
SimManager.Instance.TryStartSimulation();	SimManager.Instance.TryStartSimulation();
}	}

	this.CheckAndSave ();
}	}

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

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

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

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

//	//
// VOID_Module.cs	// VOID_Module.cs
//	//
// Author:	// Author:
// toadicus <>	// toadicus <>
//	//
// Copyright (c) 2013 toadicus	// Copyright (c) 2013 toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using System.Linq;	using System.Linq;
using System.Reflection;	using System.Reflection;
using UnityEngine;	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;

/*	/*
* Properties	* Properties
* */	* */
public virtual bool toggleActive	public virtual bool toggleActive
{	{
get	get
{	{
return this._Active;	return this._Active;
}	}
set	set
{	{
this._Active = value;	this._Active = value;
}	}
}	}

public virtual bool guiRunning	public virtual bool guiRunning
{	{
get	get
{	{
return this._Running;	return this._Running;
}	}
}	}

public virtual string Name	public virtual string Name
{	{
get	get
{	{
return this._Name;	return this._Name;
}	}
}	}

public virtual Vessel vessel	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);

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 = new Rect(Screen.width / 2, Screen.height / 2, 250f, 50f);
protected float defWidth = 250f;	protected float defWidth = 250f;
protected float defHeight = 50f;	protected float defHeight = 50f;

public abstract void ModuleWindow(int _);	public virtual void ModuleWindow(int _)
	{
	if (VOID_Core.Instance.updateTimer - this.lastUpdate > VOID_Core.Instance.updatePeriod) {
	Tools.PostDebugMessage(string.Format(
	"{0}: refreshing VOID_DataValues.",
	this.GetType().Name
	));

	foreach (var fieldinfo in this.GetType().GetFields(
	BindingFlags.Instance \|
	BindingFlags.NonPublic \|
	BindingFlags.Public \|
	BindingFlags.FlattenHierarchy
	)) {
	Tools.PostDebugMessage(string.Format(
	"{0}: checking field {1}.",
	this.GetType().Name,
	fieldinfo.Name
	));

	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 ())) {
	Tools.PostDebugMessage(string.Format(
	"{0}: found field {1}.",
	this.GetType().Name,
	fieldinfo.Name
	));

	(field as IVOID_DataValue).Refresh ();

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

	this.lastUpdate = VOID_Core.Instance.updateTimer;
	}
	}

public override void DrawGUI()	public override void DrawGUI()
{	{
Rect _Pos = this.WindowPos;	Rect _Pos = this.WindowPos;

_Pos = GUILayout.Window(	_Pos = GUILayout.Window(
VOID_Core.Instance.windowID,	VOID_Core.Instance.windowID,
_Pos,	_Pos,
this.ModuleWindow,	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);

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

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

//	//
// VOID_Orbital.cs	// VOID_Orbital.cs
//	//
// Author:	// Author:
// toadicus <>	// toadicus <>
//	//
// Copyright (c) 2013 toadicus	// Copyright (c) 2013 toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
using KSP;	using KSP;
using System;	using System;
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")]
	protected long _precisionValues = 230584300921369395;
	protected IntCollection precisionValues;

	protected VOID_StrValue primaryName = new VOID_StrValue (
	VOIDLabels.void_primary,
	new Func<string> (() => VOID_Core.Instance.vessel.mainBody.name)
	);

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

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

	protected VOID_DoubleValue orbitApoAlt = new VOID_DoubleValue(
	VOIDLabels.void_apoapsis,
	new Func<double>(() => VOID_Core.Instance.vessel.orbit.ApA),
	"m"
	);

	protected VOID_DoubleValue oribtPeriAlt = new VOID_DoubleValue(
	VOIDLabels.void_periapsis,
	new Func<double>(() => VOID_Core.Instance.vessel.orbit.PeA),
	"m"
	);

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

	protected VOID_StrValue timeToPeri = new VOID_StrValue(
	"Time to Apoapsis",
	new Func<string>(() => Tools.ConvertInterval(VOID_Core.Instance.vessel.orbit.timeToPe))
	);

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

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

	protected VOID_StrValue orbitPeriod = new VOID_StrValue(
	"Period",
	new Func<string>(() => Tools.ConvertInterval(VOID_Core.Instance.vessel.orbit.period))
	);

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

	protected VOID_DoubleValue eccentricity = new VOID_DoubleValue(
	"Eccentricity",
	new Func<double>(() => VOID_Core.Instance.vessel.orbit.eccentricity),
	""
	);

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

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

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

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

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

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

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 _)
{	{
// Toadicus edit: added local sidereal longitude.	base.ModuleWindow (_);
double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle;
LSL = Tools.FixDegreeDomain (LSL);	int idx = 0;

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

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	this.primaryName.DoGUIHorizontal ();
GUILayout.Label(VOIDLabels.void_primary + ":");
GUILayout.Label(vessel.mainBody.bodyName, GUILayout.ExpandWidth(false));	this.precisionValues [idx] = this.orbitAltitude.DoGUIHorizontal (this.precisionValues [idx]);
GUILayout.EndHorizontal();	idx++;

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	this.precisionValues [idx] = this.orbitVelocity.DoGUIHorizontal (this.precisionValues [idx]);
GUILayout.Label(VOIDLabels.void_altitude_asl + ":");	idx++;
GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.altitude) + "m", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	this.precisionValues [idx] = this.orbitApoAlt.DoGUIHorizontal (this.precisionValues [idx]);
	idx++;
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label(VOIDLabels.void_velocity + ":");	this.timeToApo.DoGUIHorizontal();
GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	this.precisionValues [idx] = this.oribtPeriAlt.DoGUIHorizontal (this.precisionValues [idx]);
	idx++;
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label(VOIDLabels.void_apoapsis + ":");	this.timeToPeri.DoGUIHorizontal();
GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.ApA) + "m", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	this.orbitInclination.DoGUIHorizontal("F3");

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	this.precisionValues [idx] = this.gravityAccel.DoGUIHorizontal (this.precisionValues [idx]);
GUILayout.Label("Time to Ap:");	idx++;
GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToAp), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label(VOIDLabels.void_periapsis + ":");
GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.PeA) + "m", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Time to Pe:");
GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToPe), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();

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

double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass());
double g_vessel = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2);
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Gravity:");
GUILayout.Label(Tools.MuMech_ToSI(g_vessel) + "m/s²", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();

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

if (this.toggleExtended)	if (this.toggleExtended)
{	{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	this.orbitPeriod.DoGUIHorizontal();
GUILayout.Label("Period:");
GUILayout.Label(Tools.ConvertInterval(vessel.orbit.period), GUILayout.ExpandWidth(false));	this.precisionValues [idx] = this.semiMajorAxis.DoGUIHorizontal (this.precisionValues [idx]);
GUILayout.EndHorizontal();	idx++;

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	this.eccentricity.DoGUIHorizontal("F4");
GUILayout.Label("Semi-major axis:");
GUILayout.Label((vessel.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false));	this.meanAnomaly.DoGUIHorizontal("F3");
GUILayout.EndHorizontal();
	this.trueAnomaly.DoGUIHorizontal("F3");
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Eccentricity:");	this.eccAnomaly.DoGUIHorizontal("F3");
GUILayout.Label(vessel.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	this.longitudeAscNode.DoGUIHorizontal("F3");

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

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

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

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

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Arg. of periapsis:");
GUILayout.Label(vessel.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();

// Toadicus edit: added local sidereal longitude.
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Local Sidereal Longitude:");
GUILayout.Label(LSL.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"]);
GUILayout.EndHorizontal();
}	}

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

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

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

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

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

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

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

//	//
// VOID_Config.cs	// VOID_Config.cs
//	//
// Author:	// Author:
// toadicus <>	// toadicus <>
//	//
// Copyright (c) 2013 toadicus	// Copyright (c) 2013 toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using KSP;	using KSP;
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;

public T value	public T value
{	{
get	get
{	{
return this._value;	return this._value;
}	}
set	set
{	{
this._value = value;	this._value = value;
}	}
}	}

public Type type	public Type type
{	{
get	get
{	{
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 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.value = v;	r.value = v;
r.type = v.GetType();	r.type = v.GetType();

if (VOID_Core.Initialized)	if (VOID_Core.Initialized)
{	{
VOID_Core.Instance.configDirty = true;	VOID_Core.Instance.configDirty = true;
}	}

	if (VOID_EditorCore.Initialized)
	{
	VOID_EditorCore.Instance.configDirty = true;
	}

return r;	return r;
}	}

public new 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

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

//	//
// VOID_Orbital.cs	// VOID_Orbital.cs
//	//
// Author:	// Author:
// toadicus <>	// toadicus <>
//	//
// Copyright (c) 2013 toadicus	// Copyright (c) 2013 toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
using KSP;	using KSP;
using System;	using System;
using UnityEngine;	using UnityEngine;

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

public VOID_VesselInfo()	public VOID_VesselInfo()
{	{
this._Name = "Vessel Information";	this._Name = "Vessel Information";

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

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

Engineer.VesselSimulator.Stage[] stages = Engineer.VesselSimulator.SimManager.Instance.Stages;	Engineer.VesselSimulator.Stage[] stages = Engineer.VesselSimulator.SimManager.Instance.Stages;

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

GUILayout.Label(vessel.vesselName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true));	GUILayout.Label(
	vessel.vesselName,
	VOID_Core.Instance.LabelStyles["center_bold"],
	GUILayout.ExpandWidth(true));

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("G-force:");	GUILayout.Label("G-force:");
GUILayout.Label(vessel.geeForce.ToString("F2") + " gees", GUILayout.ExpandWidth(false));	GUILayout.Label(vessel.geeForce.ToString("F2") + " gees", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

int num_parts = 0;	int num_parts = 0;
double total_mass = vessel.GetTotalMass();	double total_mass = vessel.GetTotalMass();
double resource_mass = 0;	double resource_mass = 0;
double max_thrust = 0;	double max_thrust = 0;
double final_thrust = 0;	double final_thrust = 0;

foreach (Part p in vessel.parts)	foreach (Part p in vessel.parts)
{	{
num_parts++;	num_parts++;
resource_mass += p.GetResourceMass();	resource_mass += p.GetResourceMass();

foreach (PartModule pm in p.Modules)	foreach (PartModule pm in p.Modules)
{	{
if ((pm.moduleName == "ModuleEngines") && ((p.State == PartStates.ACTIVE) \|\| ((Staging.CurrentStage > Staging.lastStage) && (p.inverseStage == Staging.lastStage))))	if ((pm.moduleName == "ModuleEngines") &&
	((p.State == PartStates.ACTIVE) \|\|
	((Staging.CurrentStage > Staging.lastStage) && (p.inverseStage == Staging.lastStage)))
	)
{	{
max_thrust += ((ModuleEngines)pm).maxThrust;	max_thrust += ((ModuleEngines)pm).maxThrust;
final_thrust += ((ModuleEngines)pm).finalThrust;	final_thrust += ((ModuleEngines)pm).finalThrust;
}	}
}	}
}	}

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Parts:");	GUILayout.Label("Parts:");
GUILayout.Label(num_parts.ToString("F0"), GUILayout.ExpandWidth(false));	GUILayout.Label(num_parts.ToString("F0"), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Total mass:");	GUILayout.Label("Total mass:");
GUILayout.Label(total_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false));	GUILayout.Label(total_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Resource mass:");	GUILayout.Label("Resource mass:");
GUILayout.Label(resource_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false));	GUILayout.Label(resource_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

if (stages.Length > Staging.lastStage)	if (stages.Length > Staging.lastStage)
{	{
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("DeltaV (Current Stage):");	GUILayout.Label("DeltaV (Current Stage):");
GUILayout.Label(Tools.MuMech_ToSI(stages[Staging.lastStage].deltaV).ToString() + "m/s", GUILayout.ExpandWidth(false));	GUILayout.Label(
	Tools.MuMech_ToSI(stages[Staging.lastStage].deltaV).ToString() + "m/s",
	GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();
}	}

if (stages.Length > 0)	if (stages.Length > 0)
{	{
double totalDeltaV = 0d;	double totalDeltaV = 0d;

for (int i = 0; i < stages.Length; ++i)	for (int i = 0; i < stages.Length; ++i)
{	{
totalDeltaV += stages [i].deltaV;	totalDeltaV += stages [i].deltaV;
}	}

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("DeltaV (Total):");	GUILayout.Label("DeltaV (Total):");
GUILayout.Label(Tools.MuMech_ToSI(totalDeltaV).ToString() + "m/s", GUILayout.ExpandWidth(false));	GUILayout.Label(Tools.MuMech_ToSI(totalDeltaV).ToString() + "m/s", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();
}	}

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Throttle:");	GUILayout.Label("Throttle:");
GUILayout.Label((vessel.ctrlState.mainThrottle * 100f).ToString("F0") + "%", GUILayout.ExpandWidth(false));	GUILayout.Label((vessel.ctrlState.mainThrottle * 100f).ToString("F0") + "%", GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Thrust (curr/max):");	GUILayout.Label("Thrust (curr/max):");
GUILayout.Label(final_thrust.ToString("F1") + " / " + max_thrust.ToString("F1") + " kN", GUILayout.ExpandWidth(false));	GUILayout.Label(
	final_thrust.ToString("F1") +
	" / " + max_thrust.ToString("F1") + " kN",
	GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

double gravity = vessel.mainBody.gravParameter / Math.Pow(vessel.mainBody.Radius + vessel.altitude, 2);	double gravity = vessel.mainBody.gravParameter / Math.Pow(vessel.mainBody.Radius + vessel.altitude, 2);
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("T:W (curr/max):");	GUILayout.Label("T:W (curr/max):");
GUILayout.Label((final_thrust / (total_mass * gravity)).ToString("F2") + " / " + (max_thrust / (total_mass * gravity)).ToString("F2"), GUILayout.ExpandWidth(false));	GUILayout.Label(
	(final_thrust / (total_mass * gravity)).ToString("F2") +
	" / " + (max_thrust / (total_mass * gravity)).ToString("F2"),
	GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

double g_ASL = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(vessel.mainBody.Radius, 2);	double g_ASL = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(vessel.mainBody.Radius, 2);
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));	GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
GUILayout.Label("Max T:W @ surface:");	GUILayout.Label("Max T:W @ surface:");
GUILayout.Label((max_thrust / (total_mass * g_ASL)).ToString("F2"), GUILayout.ExpandWidth(false));	GUILayout.Label((max_thrust / (total_mass * g_ASL)).ToString("F2"), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

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

//	//
// VOID_Hud.cs	// VOID_Hud.cs
//	//
// Author:	// Author:
// toadicus <>	// toadicus <>
//	//
// Copyright (c) 2013 toadicus	// Copyright (c) 2013 toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
//	//

using Engineer.VesselSimulator;	using Engineer.VesselSimulator;
using KSP;	using KSP;
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
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;

/*	/*
* 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_EditorHUD() : base()	public VOID_EditorHUD() : base()
{	{
this._Name = "Heads-Up Display";	this._Name = "Heads-Up Display";

this._Active = true;	this._Active = 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.Instance.RequestSimulation();

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

	float hudLeft;

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

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

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

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

GUI.Label (	GUI.Label (
new Rect (Screen.width - 310, 80, 300f, 32f),	hudPos,
"Total Mass: " + SimManager.Instance.LastStage.totalMass.ToString("F3") + "t" +	"Total Mass: " + SimManager.Instance.LastStage.totalMass.ToString("F3") + "t" +
" Part Count: " + EditorLogic.SortedShipList.Count +	" Part Count: " + EditorLogic.SortedShipList.Count +
"\nTotal Delta-V: " + Tools.MuMech_ToSI(SimManager.Instance.LastStage.totalDeltaV) + "m/s" +	"\nTotal Delta-V: " + Tools.MuMech_ToSI(SimManager.Instance.LastStage.totalDeltaV) + "m/s" +
"\nBottom Stage Delta-V: " + Tools.MuMech_ToSI(SimManager.Instance.LastStage.deltaV) + "m/s" +	"\nBottom Stage Delta-V: " + Tools.MuMech_ToSI(SimManager.Instance.LastStage.deltaV) + "m/s" +
"\nBottom Stage T/W Ratio: " + SimManager.Instance.LastStage.thrustToWeight.ToString("F3"),	"\nBottom Stage T/W Ratio: " + SimManager.Instance.LastStage.thrustToWeight.ToString("F3"),
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;
}	}
}	}
}	}
}	}

//	//
// VOID_Orbital.cs	// VOID_Orbital.cs
//	//
// Author:	// Author:
// toadicus <>	// toadicus <>
//	//
// Copyright (c) 2013 toadicus	// Copyright (c) 2013 toadicus
//	//
// This program is free software: you can redistribute it and/or modify	// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by	// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or	// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.	// (at your option) any later version.
//	//
// This program is distributed in the hope that it will be useful,	// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of	// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.	// GNU General Public License for more details.
//	//
// You should have received a copy of the GNU General Public License	// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.	// along with this program. If not, see <http://www.gnu.org/licenses/>.
using KSP;	using KSP;
using System;	using System;
using System.Collections.Generic;	using System.Collections.Generic;
using UnityEngine;	using UnityEngine;

namespace VOID	namespace VOID
{	{
public class VOID_CBInfoBrowser : VOID_WindowModule	public class VOID_CBInfoBrowser : VOID_WindowModule
{	{
[AVOID_SaveValue("selectedBodyIdx1")]	[AVOID_SaveValue("selectedBodyIdx1")]
protected VOID_SaveValue<int> selectedBodyIdx1 = 1;	protected VOID_SaveValue<int> selectedBodyIdx1 = 1;

[AVOID_SaveValue("selectedBodyIdx2")]	[AVOID_SaveValue("selectedBodyIdx2")]
protected VOID_SaveValue<int> selectedBodyIdx2 = 2;	protected VOID_SaveValue<int> selectedBodyIdx2 = 2;

protected CelestialBody selectedBody1;	protected CelestialBody selectedBody1;
protected CelestialBody selectedBody2;	protected CelestialBody selectedBody2;

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