ToadGIT :: VOID.git/commitdiff

VOID_HUD: Rework to use new common data from VOID_Data, and using StringBuilder instead of string + operators.

19 files changed: (show all)
ToolbarButtonWrapper.cs (deleted)
Tools.cs
VOIDEditorMaster.cs (new)
VOIDFlightMaster.cs
VOID_CBInfoBrowser.cs
VOID_Core.cs
VOID_DataValue.cs
VOID_EditorCore.cs
VOID_EditorHUD.cs
VOID_HUD.cs
VOID_Module.cs
VOID_Orbital.cs
VOID_Rendezvous.cs
VOID_SurfAtmo.cs
VOID_Transfer.cs
VOID_VesselInfo.cs
Wrapper/Properties/AssemblyInfo.cs (new)
Wrapper/ToolbarWrapper.cs (new)
Wrapper/Wrapper.csproj (new)

file:a/ToolbarButtonWrapper.cs (deleted)

//
// ToolbarWrapper.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 System.Linq;
using System.Reflection;
using UnityEngine;

namespace VOID
{
/// <summary>
/// Wraps a Toolbar clickable button, after fetching it from a foreign assembly.
/// </summary>
internal class ToolbarButtonWrapper
{
protected static System.Type ToolbarManager;
protected static object TBManagerInstance;
protected static MethodInfo TBManagerAdd;

/// <summary>
/// Wraps the ToolbarManager class, if present.
/// </summary>
/// <returns><c>true</c>, if ToolbarManager is wrapped, <c>false</c> otherwise.</returns>
protected static bool TryWrapToolbarManager()
{
if (ToolbarManager == null)
{
Tools.PostDebugMessage(string.Format(
"{0}: Loading ToolbarManager.",
"ToolbarButtonWrapper"
));

ToolbarManager = AssemblyLoader.loadedAssemblies
.Select(a => a.assembly.GetExportedTypes())
.SelectMany(t => t)
.FirstOrDefault(t => t.FullName == "Toolbar.ToolbarManager");

Tools.PostDebugMessage(string.Format(
"{0}: Loaded ToolbarManager. Getting Instance.",
"ToolbarButtonWrapper"
));

if (ToolbarManager == null)
{
return false;
}

TBManagerInstance = ToolbarManager.GetProperty(
"Instance",
System.Reflection.BindingFlags.Public \| System.Reflection.BindingFlags.Static
)
.GetValue(null, null);

Tools.PostDebugMessage(string.Format(
"{0}: Got ToolbarManager Instance '{1}'. Getting 'add' method.",
"ToolbarButtonWrapper",
TBManagerInstance
));

TBManagerAdd = ToolbarManager.GetMethod("add");

Tools.PostDebugMessage(string.Format(
"{0}: Got ToolbarManager Instance 'add' method. Loading IButton.",
"ToolbarButtonWrapper"
));
}

return true;
}

/// <summary>
/// Gets a value indicating whether <see cref="Toolbar.ToolbarManager"/> is present.
/// </summary>
/// <value><c>true</c>, if ToolbarManager is wrapped, <c>false</c> otherwise.</value>
public static bool ToolbarManagerPresent
{
get
{
return TryWrapToolbarManager();
}
}

/// <summary>
/// If ToolbarManager is present, initializes a new instance of the <see cref="VOID.ToolbarButtonWrapper"/> class.
/// </summary>
/// <param name="ns">Namespace, usually the plugin name.</param>
/// <param name="id">Identifier, unique per namespace.</param>
/// <returns>If ToolbarManager is present, a new <see cref="Toolbar.IButton"/> object, <c>null</c> otherwise.</returns>
public static ToolbarButtonWrapper TryWrapToolbarButton(string ns, string id)
{
if (ToolbarManagerPresent)
{
object button = TBManagerAdd.Invoke(TBManagerInstance, new object[] { ns, id });

Tools.PostDebugMessage(string.Format(
"{0}: Added Button '{1}' with ToolbarManager. Getting 'Text' property",
"ToolbarButtonWrapper",
button.ToString()
));

return new ToolbarButtonWrapper(button);
}
else
{
return null;
}
}

protected System.Type IButton;
protected object Button;
protected PropertyInfo ButtonText;
protected PropertyInfo ButtonTextColor;
protected PropertyInfo ButtonTexturePath;
protected PropertyInfo ButtonToolTip;
protected PropertyInfo ButtonVisible;
protected PropertyInfo ButtonVisibility;
protected PropertyInfo ButtonEnalbed;
protected PropertyInfo ButtonImportant;
protected EventInfo ButtonOnClick;
protected EventInfo ButtonOnMouseEnter;
protected EventInfo ButtonOnMouseLeave;
protected MethodInfo ButtonDestroy;
protected System.Type GameScenesVisibilityType;

/// <summary>
/// The text displayed on the button. Set to null to hide text.
/// </summary>
/// <remarks>
/// The text can be changed at any time to modify the button's appearance. Note that since this will also
/// modify the button's size, this feature should be used sparingly, if at all.
/// </remarks>
/// <seealso cref="TexturePath"/>
public string Text
{
get
{
return this.ButtonText.GetValue(this.Button, null) as String;
}
set
{
this.ButtonText.SetValue(this.Button, value, null);
}
}

/// <summary>
/// The color the button text is displayed with. Defaults to Color.white.
/// </summary>
/// <remarks>
/// The text color can be changed at any time to modify the button's appearance.
/// </remarks>
public Color TextColor
{
get
{
return (Color)this.ButtonTextColor.GetValue(this.Button, null);
}
set
{
this.ButtonTextColor.SetValue(this.Button, value, null);
}
}

/// <summary>
/// The path of a texture file to display an icon on the button. Set to null to hide icon.
/// </summary>
/// <remarks>
/// <para>
/// A texture path on a button will have precedence over text. That is, if both text and texture path
/// have been set on a button, the button will show the texture, not the text.
/// </para>
/// <para>
/// The texture size must not exceed 24x24 pixels.
/// </para>
/// <para>
/// The texture path must be relative to the "GameData" directory, and must not specify a file name suffix.
/// Valid example: MyAddon/Textures/icon_mybutton
/// </para>
/// <para>
/// The texture path can be changed at any time to modify the button's appearance.
/// </para>
/// </remarks>
/// <seealso cref="Text"/>
public string TexturePath
{
get
{
return this.ButtonTexturePath.GetValue(this.Button, null) as string;
}
set
{
this.ButtonTexturePath.SetValue(this.Button, value, null);
}
}

/// <summary>
/// The button's tool tip text. Set to null if no tool tip is desired.
/// </summary>
/// <remarks>
/// Tool Tip Text Should Always Use Headline Style Like This.
/// </remarks>
public string ToolTip
{
get
{
return this.ButtonToolTip.GetValue(this.Button, null) as string;
}
set
{
this.ButtonToolTip.SetValue(this.Button, value, null);
}
}

/// <summary>
/// Whether this button is currently visible or not. Can be used in addition to or as a replacement for <see cref="Visibility"/>.
/// </summary>
public bool Visible
{
get
{
return (bool)this.ButtonVisible.GetValue(this.Button, null);
}
set
{
this.ButtonVisible.SetValue(this.Button, value, null);
}
}

/// <summary>
/// Whether this button is currently enabled (clickable) or not. This will not affect the player's ability to
/// position the button on their screen.
/// </summary>
public bool Enabled
{
get
{
return (bool)this.ButtonEnalbed.GetValue(this.Button, null);
}
set
{
this.ButtonEnalbed.SetValue(this.Button, value, null);
}
}

/// <summary>
/// Whether this button is currently "important." Set to false to return to normal button behaviour.
/// </summary>
/// <remarks>
/// <para>
/// This can be used to temporarily force the button to be shown on the screen regardless of the toolbar being
/// currently in auto-hidden mode. For example, a button that signals the arrival of a private message in a
/// chat room could mark itself as "important" as long as the message has not been read.
/// </para>
/// <para>
/// Setting this property does not change the appearance of the button. use <see cref="TexturePath"/> to
/// change the button's icon.
/// </para>
/// <para>
/// This feature should be used only sparingly, if at all, since it forces the button to be displayed on screen
/// even when it normally wouldn't.
/// </para>
/// </remarks>
/// <value><c>true</c> if important; otherwise, <c>false</c>.</value>
public bool Important
{
get
{
return (bool)this.ButtonImportant.GetValue(this.Button, null);
}
set
{
this.ButtonImportant.SetValue(this.Button, value, null);
}
}

private ToolbarButtonWrapper()
{
}

/// <summary>
/// Initializes a new instance of the <see cref="VOID.ToolbarButtonWrapper"/> class.
/// </summary>
/// <param name="ns">Namespace, usually the plugin name.</param>
/// <param name="id">Identifier, unique per namespace.</param>
protected ToolbarButtonWrapper(object button)
{
this.Button = button;

this.IButton = AssemblyLoader.loadedAssemblies
.Select(a => a.assembly.GetExportedTypes())
.SelectMany(t => t)
.FirstOrDefault(t => t.FullName == "Toolbar.IButton");

Tools.PostDebugMessage(string.Format(
"{0}: Loaded IButton. Adding Button with ToolbarManager.",
this.GetType().Name
));

this.ButtonText = this.IButton.GetProperty("Text");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'Text' property. Getting 'TextColor' property.",
this.GetType().Name
));

this.ButtonTextColor = this.IButton.GetProperty("TextColor");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'TextColor' property. Getting 'TexturePath' property.",
this.GetType().Name
));

this.ButtonTexturePath = this.IButton.GetProperty("TexturePath");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'TexturePath' property. Getting 'ToolTip' property.",
this.GetType().Name
));

this.ButtonToolTip = this.IButton.GetProperty("ToolTip");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'ToolTip' property. Getting 'Visible' property.",
this.GetType().Name
));

this.ButtonVisible = this.IButton.GetProperty("Visible");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'Visible' property. Getting 'Visibility' property.",
this.GetType().Name
));

this.ButtonVisibility = this.IButton.GetProperty("Visibility");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'Visibility' property. Getting 'Enabled' property.",
this.GetType().Name
));

this.ButtonEnalbed = this.IButton.GetProperty("Enabled");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'Enabled' property. Getting 'OnClick' event.",
this.GetType().Name
));

this.ButtonImportant = this.IButton.GetProperty("Important");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'Enabled' property. Getting 'OnClick' event.",
this.GetType().Name
));

this.ButtonOnClick = this.IButton.GetEvent("OnClick");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'OnClick' event '{1}'. Getting 'OnMouseEnter' event.",
this.GetType().Name,
this.ButtonOnClick.ToString()
));

this.ButtonOnMouseEnter = this.IButton.GetEvent("OnMouseEnter");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'OnMouseEnter' event '{1}'. Getting 'OnMouseLeave' event.",
this.GetType().Name,
this.ButtonOnClick.ToString()
));

this.ButtonOnMouseLeave = this.IButton.GetEvent("OnMouseLeave");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'OnMouseLeave' event '{1}'. Getting 'Destroy' method.",
this.GetType().Name,
this.ButtonOnClick.ToString()
));

this.ButtonDestroy = this.IButton.GetMethod("Destroy");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'Destroy' property '{1}'. Loading GameScenesVisibility class.",
this.GetType().Name,
this.ButtonDestroy.ToString()
));

this.GameScenesVisibilityType = AssemblyLoader.loadedAssemblies
.Select(a => a.assembly.GetExportedTypes())
.SelectMany(t => t)
.FirstOrDefault(t => t.FullName == "Toolbar.GameScenesVisibility");

Tools.PostDebugMessage(string.Format(
"{0}: Got 'GameScenesVisibility' class '{1}'.",
this.GetType().Name,
this.GameScenesVisibilityType.ToString()
));

Tools.PostDebugMessage("ToolbarButtonWrapper built!");
}

/// <summary>
/// Adds event handler to receive "on click" events.
/// </summary>
/// <example>
/// <code>
/// ToolbarButtonWrapper button = ...
/// button.AddButtonClickHandler(
/// (e) =>
/// {
/// Debug.Log("button clicked, mouseButton: " + e.Mousebutton");
/// }
/// );
/// </code>
/// </example>
/// <param name="Handler">Delegate to handle "on click" events</param>
public void AddButtonClickHandler(Action<object> Handler)
{
this.AddButtonEventHandler(this.ButtonOnClick, Handler);
}

/// <summary>
/// Adds event handler that can be registered with to receive "on mouse enter" events.
/// </summary>
/// <example>
/// <code>
/// ToolbarWrapperButton button = ...
/// button.AddButtonOnMouseEnterHandler(
/// (e) =>
/// {
/// Debug.Log("mouse entered button");
/// }
/// );
/// </code>
/// </example>
/// <param name="Handler">Delegate to handle "OnMouseEnter" events.</param>
public void AddButtonOnMouseEnterHandler(Action<object> Handler)
{
this.AddButtonEventHandler(this.ButtonOnMouseEnter, Handler);
}

/// <summary>
/// Adds event handler that can be registered with to receive "on mouse leave" events.
/// </summary>
/// <example>
/// <code>
/// ToolbarWrapperButton button = ...
/// button.AddButtonOnMouseLeaveHandler(
/// (e) =>
/// {
/// Debug.Log("mouse left button");
/// }
/// );
/// </code>
/// </example>
/// <param name="Handler">Delegate to handle "OnMouseLeave" events.</param>
public void AddButtonOnMouseLeaveHandler(Action<object> Handler)
{
this.AddButtonEventHandler(this.ButtonOnMouseLeave, Handler);
}

/// <summary>
/// Sets this button's visibility. Can be used in addition to or as a replacement for <see cref="Visible"/>.
/// </summary>
/// <param name="gameScenes">Array of GameScene objects in which the button should be visible.</param>
public void SetButtonVisibility(params GameScenes[] gameScenes)
{
object GameScenesVisibilityObj = Activator.CreateInstance(this.GameScenesVisibilityType, gameScenes);
this.ButtonVisibility.SetValue(this.Button, GameScenesVisibilityObj, null);
}

/// <summary>
/// Permanently destroys this button so that it is no longer displayed.
/// Should be used when a plugin is stopped to remove leftover buttons.
/// </summary>
public void Destroy()
{
this.ButtonDestroy.Invoke(this.Button, null);
}

// Utility method for use with the AddButton<event>Handler API methods.
protected void AddButtonEventHandler(EventInfo Event, Action<object> Handler)
{
Delegate d = Delegate.CreateDelegate(Event.EventHandlerType, Handler.Target, Handler.Method);
MethodInfo addHandler = Event.GetAddMethod();
addHandler.Invoke(this.Button, new object[] { d });
}
}
}

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;

mapAttribute = BiomeMap.GetAtt(lat, lon);	mapAttribute = BiomeMap.GetAtt(lat, lon);

/*	/*
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)	if (v_long > 0)
dir_long = "E";	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)	if (v_lat > 0)
dir_lat = "N";	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;

	try
	{
	CoM = vessel.findWorldCenterOfMass();
	}
	catch
	{
	return double.NaN;
	}

Vector3d up = (CoM - vessel.mainBody.position).normalized;	Vector3d up = (CoM - vessel.mainBody.position).normalized;
Vector3d north = Vector3d.Exclude(	Vector3d north = Vector3d.Exclude(
up,	up,
(vessel.mainBody.position +	(vessel.mainBody.position +
vessel.mainBody.transform.up * (float)vessel.mainBody.Radius	vessel.mainBody.transform.up * (float)vessel.mainBody.Radius
) - CoM).normalized;	) - CoM).normalized;

Quaternion rotationSurface = Quaternion.LookRotation(north, up);	Quaternion rotationSurface = Quaternion.LookRotation(north, up);
Quaternion rotationvesselSurface = Quaternion.Inverse(	Quaternion rotationvesselSurface = Quaternion.Inverse(
Quaternion.Euler(90, 0, 0) *	Quaternion.Euler(90, 0, 0) *
Quaternion.Inverse(vessel.transform.rotation) *	Quaternion.Inverse(vessel.transform.rotation) *
rotationSurface);	rotationSurface);

return rotationvesselSurface.eulerAngles.y;	return rotationvesselSurface.eulerAngles.y;
}	}
//From http://svn.mumech.com/KSP/trunk/MuMechLib/MuUtils.cs	//From http://svn.mumech.com/KSP/trunk/MuMechLib/MuUtils.cs
public static string MuMech_ToSI(	public static string MuMech_ToSI(
double d, int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue	double d, int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue
)	)
{	{
float exponent = (float)Math.Log10(Math.Abs(d));	float exponent = (float)Math.Log10(Math.Abs(d));
exponent = Mathf.Clamp(exponent, (float)MinMagnitude, (float)MaxMagnitude);	exponent = Mathf.Clamp(exponent, (float)MinMagnitude, (float)MaxMagnitude);

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

public static string ConvertInterval(double seconds)	public static string ConvertInterval(double seconds)
{	{
string format_1 = "{0:D1}y {1:D1}d {2:D2}h {3:D2}m {4:D2}.{5:D1}s";	string format_1 = "{0:D1}y {1:D1}d {2:D2}h {3:D2}m {4:D2}.{5:D1}s";
string format_2 = "{0:D1}d {1:D2}h {2:D2}m {3:D2}.{4:D1}s";	string format_2 = "{0:D1}d {1:D2}h {2:D2}m {3:D2}.{4:D1}s";
string format_3 = "{0:D2}h {1:D2}m {2:D2}.{3:D1}s";	string format_3 = "{0:D2}h {1:D2}m {2:D2}.{3:D1}s";

TimeSpan interval;	TimeSpan interval;

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

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

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

public static string UppercaseFirst(string s)	public static string UppercaseFirst(string s)
{	{
if (string.IsNullOrEmpty(s))	if (string.IsNullOrEmpty(s))
{	{
return string.Empty;	return string.Empty;
}	}
char[] a = s.ToCharArray();	char[] a = s.ToCharArray();
a[0] = char.ToUpper(a[0]);	a[0] = char.ToUpper(a[0]);
return new string(a);	return new string(a);
}	}
//transfer angles	//transfer angles
public static double Nivvy_CalcTransferPhaseAngle(double r_current, double r_target, double grav_param)	public static double Nivvy_CalcTransferPhaseAngle(double r_current, double r_target, double grav_param)
{	{
double T_target = (2 * Math.PI) * Math.Sqrt(Math.Pow((r_target / 1000), 3) / (grav_param / 1000000000));	double T_target = (2 * Math.PI) * Math.Sqrt(Math.Pow((r_target / 1000), 3) / (grav_param / 1000000000));
double T_transfer = (2 * Math.PI) * Math.Sqrt(Math.Pow((((r_target / 1000) + (r_current / 1000)) / 2), 3) / (grav_param / 1000000000));	double T_transfer = (2 * Math.PI) * Math.Sqrt(Math.Pow((((r_target / 1000) + (r_current / 1000)) / 2), 3) / (grav_param / 1000000000));
return 360 * (0.5 - (T_transfer / (2 * T_target)));	return 360 * (0.5 - (T_transfer / (2 * T_target)));
}	}

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

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

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

public static double Younata_TransferBurnPoint(double r, double v, double angle, double mu)	public static double Younata_TransferBurnPoint(double r, double v, double angle, double mu)
{	{
/*	/*
def transferBurnPoint(r, v, angle, mu):	def transferBurnPoint(r, v, angle, mu):
# r = parking orbit radius	# r = parking orbit radius
# v = ejection velocity	# v = ejection velocity
# angle = phase angle (from function phaseAngle())	# angle = phase angle (from function phaseAngle())
# mu = gravity param of current body.	# mu = gravity param of current body.
epsilon = ((v**2)/2) - (mu / r)	epsilon = ((v**2)/2) - (mu / r)
h = r * v * math.sin(angle)	h = r * v * math.sin(angle)
e = math.sqrt(1 + ((2 * epsilon * 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(	public static double Adammada_CurrrentPhaseAngle(
double body_LAN,	double body_LAN,
double body_orbitPct,	double body_orbitPct,
double origin_LAN,	double origin_LAN,
double origin_orbitPct	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)	if (angle > 1)
angle = angle - 1;	angle = angle - 1;
if (angle < 0)	if (angle < 0)
angle = angle + 1;	angle = angle + 1;
if (angle > 0.5)	if (angle > 0.5)
angle = angle - 1;	angle = angle - 1;
angle = angle * 360;	angle = angle * 360;
return angle;	return angle;
}	}

public static double Adammada_CurrentEjectionAngle(	public static double Adammada_CurrentEjectionAngle(
double vessel_long,	double vessel_long,
double origin_rotAngle,	double origin_rotAngle,
double origin_LAN,	double origin_LAN,
double origin_orbitPct	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)	while (eangle < 0)
eangle = eangle + 360;	eangle = eangle + 360;
while (eangle > 360)	while (eangle > 360)
eangle = eangle - 360;	eangle = eangle - 360;
if (eangle < 270)	if (eangle < 270)
eangle = 90 - eangle;	eangle = 90 - eangle;
else	else
eangle = 450 - eangle;	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)	if (Vector3d.Angle(prograde, vectarget) > 90)
phase = 360 - phase;	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)	if (curr_phase > 0)
return (-1 * (360 - curr_phase));	return (-1 * (360 - curr_phase));
else if (curr_phase < 0)	else if (curr_phase < 0)
return curr_phase;	return curr_phase;
}	}
else if (transfer_angle > 0)	else if (transfer_angle > 0)
{	{
if (curr_phase > 0)	if (curr_phase > 0)
return curr_phase;	return curr_phase;
else if (curr_phase < 0)	else if (curr_phase < 0)
return (360 + curr_phase);	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)	if (curr_ejection < 0)
return 360 + curr_ejection;	return 360 + curr_ejection;
else	else
return curr_ejection;	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)	if (trans_phase < 0)
return 180 + trans_ejection;	return 180 + trans_ejection;
else	else
return trans_ejection;	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,	// HACK: This assumes that on worlds with oceans, all water is fixed at 0 m,
// and water covers the whole surface at 0 m.	// and water covers the whole surface at 0 m.
if (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)	if (heading > 348.75 \|\| heading <= 11.25)
return "N";	return "N";
else if (heading > 11.25 && heading <= 33.75)	else if (heading > 11.25 && heading <= 33.75)
return "NNE";	return "NNE";
else if (heading > 33.75 && heading <= 56.25)	else if (heading > 33.75 && heading <= 56.25)
return "NE";	return "NE";
else if (heading > 56.25 && heading <= 78.75)	else if (heading > 56.25 && heading <= 78.75)
return "ENE";	return "ENE";
else if (heading > 78.75 && heading <= 101.25)	else if (heading > 78.75 && heading <= 101.25)
return "E";	return "E";
else if (heading > 101.25 && heading <= 123.75)	else if (heading > 101.25 && heading <= 123.75)
return "ESE";	return "ESE";
else if (heading > 123.75 && heading <= 146.25)	else if (heading > 123.75 && heading <= 146.25)
return "SE";	return "SE";
else if (heading > 146.25 && heading <= 168.75)	else if (heading > 146.25 && heading <= 168.75)
return "SSE";	return "SSE";
else if (heading > 168.75 && heading <= 191.25)	else if (heading > 168.75 && heading <= 191.25)
return "S";	return "S";
else if (heading > 191.25 && heading <= 213.75)	else if (heading > 191.25 && heading <= 213.75)
return "SSW";	return "SSW";
else if (heading > 213.75 && heading <= 236.25)	else if (heading > 213.75 && heading <= 236.25)
return "SW";	return "SW";
else if (heading > 236.25 && heading <= 258.75)	else if (heading > 236.25 && heading <= 258.75)
return "WSW";	return "WSW";
else if (heading > 258.75 && heading <= 281.25)	else if (heading > 258.75 && heading <= 281.25)
return "W";	return "W";
else if (heading > 281.25 && heading <= 303.75)	else if (heading > 281.25 && heading <= 303.75)
return "WNW";	return "WNW";
else if (heading > 303.75 && heading <= 326.25)	else if (heading > 303.75 && heading <= 326.25)
return "NW";	return "NW";
else if (heading > 326.25 && heading <= 348.75)	else if (heading > 326.25 && heading <= 348.75)
return "NNW";	return "NNW";
else	else
return "";	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(	GUILayout.Label(
Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + Tools.Nivvy_CalcTransferPhaseAngle(	Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + Tools.Nivvy_CalcTransferPhaseAngle(
vessel.orbit.semiMajorAxis,	vessel.orbit.semiMajorAxis,
body.orbit.semiMajorAxis,	body.orbit.semiMajorAxis,
vessel.mainBody.gravParameter	vessel.mainBody.gravParameter
).ToString("F3") + "°",	).ToString("F3") + "°",
GUILayout.ExpandWidth(false)	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(	GUILayout.Label(
(Tools.Younata_DeltaVToGetToOtherBody(	(Tools.Younata_DeltaVToGetToOtherBody(
(vessel.mainBody.gravParameter / 1000000000),	(vessel.mainBody.gravParameter / 1000000000),
(vessel.orbit.semiMajorAxis / 1000),	(vessel.orbit.semiMajorAxis / 1000),
(body.orbit.semiMajorAxis / 1000)	(body.orbit.semiMajorAxis / 1000)
) * 1000).ToString("F2") + "m/s",	) * 1000).ToString("F2") + "m/s",
GUILayout.ExpandWidth(false)	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(	double dv1 = Tools.Younata_DeltaVToGetToOtherBody(
(vessel.mainBody.referenceBody.gravParameter / 1000000000),	(vessel.mainBody.referenceBody.gravParameter / 1000000000),
(vessel.mainBody.orbit.semiMajorAxis / 1000),	(vessel.mainBody.orbit.semiMajorAxis / 1000),
(body.orbit.semiMajorAxis / 1000)	(body.orbit.semiMajorAxis / 1000)
);	);
double dv2 = Tools.Younata_DeltaVToExitSOI(	double dv2 = Tools.Younata_DeltaVToExitSOI(
(vessel.mainBody.gravParameter / 1000000000),	(vessel.mainBody.gravParameter / 1000000000),
(vessel.orbit.semiMajorAxis / 1000),	(vessel.orbit.semiMajorAxis / 1000),
(vessel.mainBody.sphereOfInfluence / 1000),	(vessel.mainBody.sphereOfInfluence / 1000),
Math.Abs(dv1)	Math.Abs(dv1)
);	);

double trans_ejection_angle = Tools.Younata_TransferBurnPoint(	double trans_ejection_angle = Tools.Younata_TransferBurnPoint(
(vessel.orbit.semiMajorAxis / 1000),	(vessel.orbit.semiMajorAxis / 1000),
dv2,	dv2,
(Math.PI / 2.0),	(Math.PI / 2.0),
(vessel.mainBody.gravParameter / 1000000000)	(vessel.mainBody.gravParameter / 1000000000)
);	);
double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(	double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(
FlightGlobals.ActiveVessel.longitude,	FlightGlobals.ActiveVessel.longitude,
FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle,	FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle,
FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN,	FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN,
FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent	FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent
);	);

double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(	double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(
vessel.mainBody.orbit.semiMajorAxis,	vessel.mainBody.orbit.semiMajorAxis,
body.orbit.semiMajorAxis,	body.orbit.semiMajorAxis,
vessel.mainBody.referenceBody.gravParameter	vessel.mainBody.referenceBody.gravParameter
) % 360;	) % 360;
double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(	double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(
body.orbit.LAN,	body.orbit.LAN,
body.orbit.orbitPercent,	body.orbit.orbitPercent,
FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN,	FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN,
FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent	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(	GUILayout.Label(
adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°",	adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°",
GUILayout.ExpandWidth(false)	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(	GUILayout.Label(
adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°",	adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°",
GUILayout.ExpandWidth(false)	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(	double dv1 = Tools.Younata_DeltaVToGetToOtherBody(
(vessel.mainBody.gravParameter / 1000000000),	(vessel.mainBody.gravParameter / 1000000000),
(vessel.orbit.semiMajorAxis / 1000),	(vessel.orbit.semiMajorAxis / 1000),
(body.orbit.semiMajorAxis / 1000)	(body.orbit.semiMajorAxis / 1000)
);	);

double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(	double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(
vessel.orbit.semiMajorAxis,	vessel.orbit.semiMajorAxis,
body.orbit.semiMajorAxis,	body.orbit.semiMajorAxis,
vessel.mainBody.gravParameter	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(	GUILayout.Label(
Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°",	Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°",
GUILayout.ExpandWidth(false)	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(	double dv1 = Tools.Younata_DeltaVToGetToOtherBody(
(vessel.mainBody.referenceBody.gravParameter / 1000000000),	(vessel.mainBody.referenceBody.gravParameter / 1000000000),
(vessel.mainBody.orbit.semiMajorAxis / 1000),	(vessel.mainBody.orbit.semiMajorAxis / 1000),
(body.orbit.semiMajorAxis / 1000)	(body.orbit.semiMajorAxis / 1000)
);	);
double dv2 = Tools.Younata_DeltaVToExitSOI(	double dv2 = Tools.Younata_DeltaVToExitSOI(
(vessel.mainBody.gravParameter / 1000000000),	(vessel.mainBody.gravParameter / 1000000000),
(vessel.orbit.semiMajorAxis / 1000),	(vessel.orbit.semiMajorAxis / 1000),
(vessel.mainBody.sphereOfInfluence / 1000),	(vessel.mainBody.sphereOfInfluence / 1000),
Math.Abs(dv1)	Math.Abs(dv1)
);	);
double trans_ejection_angle = Tools.Younata_TransferBurnPoint(	double trans_ejection_angle = Tools.Younata_TransferBurnPoint(
(vessel.orbit.semiMajorAxis / 1000),	(vessel.orbit.semiMajorAxis / 1000),
dv2,	dv2,
(Math.PI / 2.0),	(Math.PI / 2.0),
(vessel.mainBody.gravParameter / 1000000000)	(vessel.mainBody.gravParameter / 1000000000)
);	);

double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(	double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(
body.orbit.LAN,	body.orbit.LAN,
body.orbit.orbitPercent,	body.orbit.orbitPercent,
FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN,	FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN,
FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent	FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent
);	);
double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(	double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(
FlightGlobals.ActiveVessel.longitude,	FlightGlobals.ActiveVessel.longitude,
FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle,	FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle,
FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN,	FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN,
FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent	FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent
);	);

double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(	double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(
vessel.mainBody.orbit.semiMajorAxis,	vessel.mainBody.orbit.semiMajorAxis,
body.orbit.semiMajorAxis,	body.orbit.semiMajorAxis,
vessel.mainBody.referenceBody.gravParameter	vessel.mainBody.referenceBody.gravParameter
) % 360;	) % 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(	GUILayout.Label(
adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°",	adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°",
GUILayout.ExpandWidth(false)	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(	GUILayout.Label(
adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°",	adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°",
GUILayout.ExpandWidth(false)	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	// This implementation is adapted from FARGUIUtils.ClampToScreen
public static Rect ClampRectToScreen(Rect window, int xMargin, int yMargin)	public static Rect ClampRectToScreen(Rect window, int xMargin, int yMargin)
{	{
window.x = Mathf.Clamp(window.x, xMargin - window.width, Screen.width - xMargin);	window.x = Mathf.Clamp(window.x, xMargin - window.width, Screen.width - xMargin);
window.y = Mathf.Clamp(window.y, yMargin - window.height, Screen.height - yMargin);	window.y = Mathf.Clamp(window.y, yMargin - window.height, Screen.height - yMargin);

return window;	return window;
}	}

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

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

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

return vec;	return vec;
}	}

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

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

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

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

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

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

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

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

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

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

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

	radius = vessel.altitude;

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

	return radius;
	}

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

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

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

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

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

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

file:b/VOIDEditorMaster.cs (new)

	///////////////////////////////////////////////////////////////////////////////
	//
	// VOID - Vessel Orbital Information Display for Kerbal Space Program
	// Copyright (C) 2012 Iannic-ann-od
	// 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/>.
	//
	///////////////////////////////////////////////////////////////////////////////
	//
	// Much, much credit to Younata, Adammada, Nivvydaskrl and to all the authors
	// behind MechJeb, RemoteTech Relay Network, ISA MapSat, and Protractor for some
	// invaluable functions and making your nicely written code available to learn from.
	//
	///////////////////////////////////////////////////////////////////////////////
	//
	// This software uses VesselSimulator and Engineer.Extensions from Engineer Redux.
	// Engineer Redux (c) 2013 cybutek
	// Used by permission.
	//
	///////////////////////////////////////////////////////////////////////////////

	using System;
	using UnityEngine;
	using Engineer.VesselSimulator;

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

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

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

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

	this.Core.Update ();

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

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

	this.Core.FixedUpdate ();
	}

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

	this.Core.OnGUI();
	}
	}
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

this.Core.Update ();

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

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

this.Core.FixedUpdate ();
}

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

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 KSP;	using KSP;
using UnityEngine;	using UnityEngine;
using Engineer.VesselSimulator;	using Engineer.VesselSimulator;

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.19";	protected string VoidVersion = "0.9.20";

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

[AVOID_SaveValue("configValue")]	[AVOID_SaveValue("configValue")]
protected VOID_SaveValue<int> configVersion = 1;	protected VOID_SaveValue<int> configVersion = 1;

protected List<IVOID_Module> _modules = new List<IVOID_Module>();	protected List<IVOID_Module> _modules = new List<IVOID_Module>();
protected bool _modulesLoaded = false;	protected bool _modulesLoaded = false;

[AVOID_SaveValue("mainWindowPos")]	[AVOID_SaveValue("mainWindowPos")]
protected VOID_SaveValue<Rect> mainWindowPos = new Rect(475, 575, 10f, 10f);	protected VOID_SaveValue<Rect> mainWindowPos = new Rect(475, 575, 10f, 10f);
[AVOID_SaveValue("mainGuiMinimized")]	[AVOID_SaveValue("mainGuiMinimized")]
protected VOID_SaveValue<bool> mainGuiMinimized = false;	protected VOID_SaveValue<bool> mainGuiMinimized = false;

[AVOID_SaveValue("configWindowPos")]	[AVOID_SaveValue("configWindowPos")]
protected VOID_SaveValue<Rect> configWindowPos = new Rect(825, 625, 10f, 10f);	protected VOID_SaveValue<Rect> configWindowPos = new Rect(825, 625, 10f, 10f);
[AVOID_SaveValue("configWindowMinimized")]	[AVOID_SaveValue("configWindowMinimized")]

protected VOID_SaveValue<bool> configWindowMinimized = true;	protected VOID_SaveValue<bool> configWindowMinimized = true;
[AVOID_SaveValue("VOIDIconPos")]	[AVOID_SaveValue("VOIDIconPos")]
protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 32, 32f, 32f);	protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 32, 32f, 32f);
protected Texture2D VOIDIconOff;
protected Texture2D VOIDIconOn;
protected Texture2D VOIDIconTexture;	protected Texture2D VOIDIconTexture;
protected string VOIDIconOnPath = "VOID/Textures/void_icon_on";	protected string VOIDIconOnActivePath;
protected string VOIDIconOffPath = "VOID/Textures/void_icon_off";	protected string VOIDIconOnInactivePath;
	protected string VOIDIconOffActivePath;
	protected string VOIDIconOffInactivePath;

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

protected GUIStyle iconStyle;	protected GUIStyle iconStyle;

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

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

	protected CelestialBody _Kerbin;

[AVOID_SaveValue("togglePower")]	[AVOID_SaveValue("togglePower")]
public VOID_SaveValue<bool> togglePower = true;	public VOID_SaveValue<bool> togglePower = true;
public bool powerAvailable = true;	public bool powerAvailable = true;

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

[AVOID_SaveValue("resourceName")]	[AVOID_SaveValue("resourceName")]
protected VOID_SaveValue<string> resourceName = "ElectricCharge";	protected VOID_SaveValue<string> resourceName = "ElectricCharge";

[AVOID_SaveValue("resourceRate")]	[AVOID_SaveValue("resourceRate")]
protected VOID_SaveValue<float> resourceRate = 0.2f;	protected VOID_SaveValue<float> resourceRate = 0.2f;

[AVOID_SaveValue("updatePeriod")]	[AVOID_SaveValue("updatePeriod")]
protected VOID_SaveValue<double> _updatePeriod = 1001f / 15000f;	protected VOID_SaveValue<double> _updatePeriod = 1001f / 15000f;
protected float _updateTimer = 0f;	protected float _updateTimer = 0f;
protected string stringFrequency;	protected string stringFrequency;
// Celestial Body Housekeeping
protected List<CelestialBody> _allBodies = new List<CelestialBody>();
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";	protected string defaultSkin = "KSP window 2";
[AVOID_SaveValue("defaultSkin")]	[AVOID_SaveValue("defaultSkin")]
protected VOID_SaveValue<string> _skinName;	protected VOID_SaveValue<string> _skinName;
protected Dictionary<string, GUISkin> skin_list;	protected Dictionary<string, GUISkin> skin_list;
protected List<string> skinNames;	protected List<string> skinNames;
protected string[] forbiddenSkins =	protected string[] forbiddenSkins =
{	{
"PlaqueDialogSkin",	"PlaqueDialogSkin",
"FlagBrowserSkin",	"FlagBrowserSkin",
"SSUITextAreaDefault",	"SSUITextAreaDefault",
"ExperimentsDialogSkin",	"ExperimentsDialogSkin",
"ExpRecoveryDialogSkin",	"ExpRecoveryDialogSkin",
"KSP window 5",	"KSP window 5",
"KSP window 6",	"KSP window 6",
"PartTooltipSkin"	"PartTooltipSkin"
};	};
protected bool skinsLoaded = false;	protected bool skinsLoaded = false;

public bool configDirty;	public bool configDirty;

[AVOID_SaveValue("UseBlizzyToolbar")]	[AVOID_SaveValue("UseBlizzyToolbar")]
protected VOID_SaveValue<bool> _UseToolbarManager;	protected VOID_SaveValue<bool> _UseToolbarManager;
protected bool ToolbarManagerLoaded;	internal IButton ToolbarButton;
internal ToolbarButtonWrapper ToolbarButton;
/*	/*
* Properties	* Properties
* */	* */
public bool factoryReset	public bool factoryReset
{	{
get	get
{	{
return this._factoryReset;	return this._factoryReset;
}	}
}	}

public List<IVOID_Module> Modules	public List<IVOID_Module> Modules
{	{
get	get
{	{
return this._modules;	return this._modules;
}	}
}	}

public GUISkin Skin	public GUISkin Skin
{	{
get	get
{	{
if (!this.skinsLoaded \|\| this._skinName == null)	if (!this.skinsLoaded \|\| this._skinName == null)
{	{
return AssetBase.GetGUISkin(this.defaultSkin);	return AssetBase.GetGUISkin(this.defaultSkin);
}	}
return this.skin_list[this._skinName];	return this.skin_list[this._skinName];
}	}
}	}

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 FlightGlobals.Bodies;
	}
	}

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

	return this._Kerbin;
}	}
}	}

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

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

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

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

	}
	}

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

	}
	}

protected bool UseToolbarManager	protected bool UseToolbarManager
{	{
get	get
{	{
return _UseToolbarManager;	return _UseToolbarManager;
}	}
set	set
{	{
if (value == false && this.ToolbarManagerLoaded && this.ToolbarButton != null)	if (this._UseToolbarManager == value)
	{
	return;
	}

	if (value == false && this.ToolbarButton != null)
{	{
this.ToolbarButton.Destroy();	this.ToolbarButton.Destroy();
this.ToolbarButton = null;	this.ToolbarButton = null;
}	}
if (value == true && this.ToolbarManagerLoaded && this.ToolbarButton == null)	if (value == true && this.ToolbarButton == null)
{	{
this.InitializeToolbarButton();	this.InitializeToolbarButton();
}	}

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

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

/*	/*
* Methods	* Methods
* */	* */
protected VOID_Core()	public override void DrawGUI()
{	{
this._Name = "VOID Core";	this._windowID = this.windowBaseID;

this._Active.value = true;	if (!this._modulesLoaded)
	{
this.VOIDIconOn = GameDatabase.Instance.GetTexture(this.VOIDIconOnPath, false);	this.LoadModulesOfType<IVOID_Module>();
this.VOIDIconOff = GameDatabase.Instance.GetTexture(this.VOIDIconOffPath, false);	}

this._skinName = this.defaultSkin;	if (!this.skinsLoaded)
	{
this.UseToolbarManager = false;	this.LoadSkins();
this.ToolbarManagerLoaded = false;	}

this.LoadConfig();	GUI.skin = this.Skin;
}
	if (!this.GUIStylesLoaded)
protected void LoadModulesOfType<T>()	{
{	this.LoadGUIStyles();
var types = AssemblyLoader.loadedAssemblies	}
.Select(a => a.assembly.GetExportedTypes())
.SelectMany(t => t)	if (!this.UseToolbarManager)
.Where(v => typeof(T).IsAssignableFrom(v)	{
&& !(v.IsInterface \|\| v.IsAbstract) &&	if (GUI.Button(VOIDIconPos, VOIDIconTexture, this.iconStyle) && this.VOIDIconLocked)
!typeof(VOID_Core).IsAssignableFrom(v)	{
);	this.ToggleMainWindow();
	}
Tools.PostDebugMessage(string.Format(	}
"{0}: Found {1} modules to check.",	else if (this.ToolbarButton == null)
this.GetType().Name,
types.Count()
));
foreach (var voidType in types)
{
if (!HighLogic.LoadedSceneIsEditor &&
typeof(IVOID_EditorModule).IsAssignableFrom(voidType))
{
continue;
}

Tools.PostDebugMessage(string.Format(
"{0}: found Type {1}",
this.GetType().Name,
voidType.Name
));

this.LoadModule(voidType);
}

this._modulesLoaded = true;

Tools.PostDebugMessage(string.Format(
"{0}: Loaded {1} modules.",
this.GetType().Name,
this.Modules.Count
));
}

protected void LoadModule(Type T)
{
var existingModules = this._modules.Where(mod => mod.GetType().Name == T.Name);
if (existingModules.Any())
{
Tools.PostDebugMessage(string.Format(
"{0}: refusing to load {1}: already loaded",
this.GetType().Name,
T.Name
));
return;
}
IVOID_Module module = Activator.CreateInstance(T) as IVOID_Module;
module.LoadConfig();
this._modules.Add(module);

Tools.PostDebugMessage(string.Format(
"{0}: loaded module {1}.",
this.GetType().Name,
T.Name
));
}

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

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

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

this.skinNames = this.skin_list.Keys.ToList();
this.skinNames.Sort();

if (this._skinName == null \|\| !this.skinNames.Contains(this._skinName))
{
this._skinName = this.defaultSkin;
Tools.PostDebugMessage(string.Format(
"{0}: resetting _skinIdx to default.",
this.GetType().Name
));
}

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

this.skinsLoaded = true;
}

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

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

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

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

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

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

this.GUIStylesLoaded = true;
}

protected void LoadAllBodies()
{
this._allBodies = FlightGlobals.Bodies;
this.bodiesLoaded = true;
}

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

protected void LoadBeforeUpdate()
{
if (!this.bodiesLoaded)
{
this.LoadAllBodies();
}

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

protected void LoadToolbarManager()
{
this.ToolbarManagerLoaded = ToolbarButtonWrapper.ToolbarManagerPresent;

if (this.ToolbarManagerLoaded)
{	{
this.InitializeToolbarButton();	this.InitializeToolbarButton();
}	}
}

protected void InitializeToolbarButton()
{
this.ToolbarButton = ToolbarButtonWrapper.TryWrapToolbarButton(this.GetType().Name, "coreToggle");
this.ToolbarButton.Text = this.VoidName;
this.ToolbarButton.TexturePath = this.VOIDIconOffPath;
if (this is VOID_EditorCore)
{
this.ToolbarButton.SetButtonVisibility(new GameScenes[] { GameScenes.EDITOR });
}
else
{
this.ToolbarButton.SetButtonVisibility(new GameScenes[] { GameScenes.FLIGHT });
}
this.ToolbarButton.AddButtonClickHandler(
(e) => this.mainGuiMinimized = !this.mainGuiMinimized
);
}

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

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

if (togglePower \|\| HighLogic.LoadedSceneIsEditor)
{
foreach (IVOID_Module module in this.Modules)
{
module.toggleActive = GUILayout.Toggle(module.toggleActive, module.Name);
}
}
}
else
{
GUILayout.Label("-- POWER LOST --", this.LabelStyles["red"]);
}

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

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

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

this.DrawConfigurables();

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

public override void DrawConfigurables()
{
int skinIdx;

GUIContent _content;

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

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

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

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

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

_content = new GUIContent();

if (skinNames.Contains(this._skinName))
{
skinIdx = skinNames.IndexOf(this._skinName);
}
else if (skinNames.Contains(this.defaultSkin))
{
skinIdx = skinNames.IndexOf(this.defaultSkin);
}
else
{
skinIdx = 0;
}

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

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

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

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

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)
{
mod.DrawConfigurables();
}

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

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

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

if (this.UseToolbarManager && !this.ToolbarManagerLoaded)
{
this.LoadToolbarManager();
}

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

GUI.skin = this.Skin;

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

if (this.UseToolbarManager && this.ToolbarManagerLoaded)
{
this.ToolbarButton.TexturePath = VOIDIconOffPath;
if (this.togglePower)
{
this.ToolbarButton.TexturePath = VOIDIconOnPath;
}
}
else
{
this.VOIDIconTexture = this.VOIDIconOff; //icon off default
if (this.togglePower)
this.VOIDIconTexture = this.VOIDIconOn; //or on if power_toggle==true

if (GUI.Button(VOIDIconPos, VOIDIconTexture, this.iconStyle) && this.VOIDIconLocked)
{
this.mainGuiMinimized.value = !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);	_mainWindowPos = Tools.ClampRectToScreen(_mainWindowPos);

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

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

_configWindowPos = GUILayout.Window(	_configWindowPos = GUILayout.Window(
this.windowID,	this.windowID,
_configWindowPos,	_configWindowPos,
this.VOIDConfigWindow,	this.VOIDConfigWindow,
string.Join(" ", new string[] { this.VoidName, "Configuration" }),	string.Join(" ", new string[] { this.VoidName, "Configuration" }),
GUILayout.Width(250),	GUILayout.Width(250),
GUILayout.Height(50)	GUILayout.Height(50)
);	);

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

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

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

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

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

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

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

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

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

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

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

if (this.vessel != null)	if (this.vessel != null)
{	{
SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /	SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /
Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);	Math.Pow(VOID_Core.Instance.vessel.Radius(), 2);
SimManager.Instance.TryStartSimulation();	SimManager.Instance.TryStartSimulation();
}	}

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

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

foreach (IVOID_Module module in this.Modules)	foreach (IVOID_Module module in this.Modules)
{	{
if (!module.guiRunning && module.toggleActive)	if (!module.guiRunning && module.toggleActive)
{	{
module.StartGUI();	module.StartGUI();
}	}
if (module.guiRunning && !module.toggleActive \|\|	if (module.guiRunning && !module.toggleActive \|\|
!this.togglePower \|\|	!this.togglePower \|\|
!HighLogic.LoadedSceneIsFlight \|\|	!HighLogic.LoadedSceneIsFlight \|\|
this.factoryReset)	this.factoryReset)
{	{
module.StopGUI();	module.StopGUI();
}	}

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

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

public void FixedUpdate()	public void FixedUpdate()
{	{
if (this.consumeResource &&	bool newPowerState = this.powerAvailable;

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

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

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

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

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

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

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

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

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

	if (togglePower \|\| HighLogic.LoadedSceneIsEditor)
	{
	foreach (IVOID_Module module in this.Modules)
	{
	module.toggleActive = GUILayout.Toggle(module.toggleActive, module.Name);
	}
	}
	}
	else
	{
	GUILayout.Label("-- POWER LOST --", this.LabelStyles["red"]);
	}

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

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

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

	this.DrawConfigurables();

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

	public override void DrawConfigurables()
	{
	int skinIdx;

	GUIContent _content;

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

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

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

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

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

	_content = new GUIContent();

	if (skinNames.Contains(this._skinName))
	{
	skinIdx = skinNames.IndexOf(this._skinName);
	}
	else if (skinNames.Contains(this.defaultSkin))
	{
	skinIdx = skinNames.IndexOf(this.defaultSkin);
	}
	else
	{
	skinIdx = 0;
	}

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

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

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

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

	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)
	{
	mod.DrawConfigurables();
	}

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

	protected void LoadModulesOfType<T>()
	{
	var types = AssemblyLoader.loadedAssemblies
	.Select(a => a.assembly.GetExportedTypes())
	.SelectMany(t => t)
	.Where(v => typeof(T).IsAssignableFrom(v)
	&& !(v.IsInterface \|\| v.IsAbstract) &&
	!typeof(VOID_Core).IsAssignableFrom(v)
	);

	Tools.PostDebugMessage(string.Format(
	"{0}: Found {1} modules to check.",
	this.GetType().Name,
	types.Count()
	));
	foreach (var voidType in types)
	{
	if (!HighLogic.LoadedSceneIsEditor &&
	typeof(IVOID_EditorModule).IsAssignableFrom(voidType))
	{
	continue;
	}

	Tools.PostDebugMessage(string.Format(
	"{0}: found Type {1}",
	this.GetType().Name,
	voidType.Name
	));

	this.LoadModule(voidType);
	}

	this._modulesLoaded = true;

	Tools.PostDebugMessage(string.Format(
	"{0}: Loaded {1} modules.",
	this.GetType().Name,
	this.Modules.Count
	));
	}

	protected void LoadModule(Type T)
	{
	var existingModules = this._modules.Where(mod => mod.GetType().Name == T.Name);
	if (existingModules.Any())
	{
	Tools.PostDebugMessage(string.Format(
	"{0}: refusing to load {1}: already loaded",
	this.GetType().Name,
	T.Name
	));
	return;
	}
	IVOID_Module module = Activator.CreateInstance(T) as IVOID_Module;
	module.LoadConfig();
	this._modules.Add(module);

	Tools.PostDebugMessage(string.Format(
	"{0}: loaded module {1}.",
	this.GetType().Name,
	T.Name
	));
	}

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

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

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

	this.skinNames = this.skin_list.Keys.ToList();
	this.skinNames.Sort();

	if (this._skinName == null \|\| !this.skinNames.Contains(this._skinName))
	{
	this._skinName = this.defaultSkin;
	Tools.PostDebugMessage(string.Format(
	"{0}: resetting _skinIdx to default.",
	this.GetType().Name
	));
	}

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

	this.skinsLoaded = true;
	}

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

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

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

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

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

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

	this.GUIStylesLoaded = true;
	}

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

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

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

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

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

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

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

	protected void SetIconTexture(string texturePath)
	{
	if (this.UseToolbarManager && this.ToolbarButton != null)
	{
	this.ToolbarButton.TexturePath = texturePath;
	}
	else
	{
	this.VOIDIconTexture = GameDatabase.Instance.GetTexture(texturePath, false);
	}
}	}

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

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

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

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

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

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

public void SaveConfig()	public void SaveConfig()
{	{
var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core>();	var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core>();
config.load();	config.load();

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

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

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

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

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

	this._Active.value = true;

	this._skinName = this.defaultSkin;

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

	this.UseToolbarManager = false;

	this.LoadConfig();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

internal interface IVOID_NumericValue	public abstract class VOID_NumValue<T> : VOID_DataValue<T>
{	where T : IFormattable, IConvertible, IComparable
double ToDouble();	{
string ToString(string format);	public static implicit operator Double(VOID_NumValue<T> v)
string ToSIString(int digits, int MinMagnitude, int MaxMagnitude);	{
}	return v.ToDouble();
	}
public abstract class VOID_NumValue<T> : VOID_DataValue<T>, IVOID_NumericValue
{	public static implicit operator Int32(VOID_NumValue<T> v)
public VOID_NumValue(string Label, Func<T> ValueFunc, string Units = "") : base(Label, ValueFunc, Units) {}	{
	return v.ToInt32();
public abstract double ToDouble();	}
public abstract string ToString(string Format);
public abstract string ToSIString(int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue);
	public static implicit operator Single(VOID_NumValue<T> v)
public abstract string ValueUnitString(string format);	{
	return v.ToSingle();
	}


	protected IFormatProvider formatProvider;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

return digits;	return digits;
}	}

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

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

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

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

GUILayout.Label(this.ValueUnitString(3, int.MinValue, (int)magnitude - digits), GUILayout.ExpandWidth(false));	GUILayout.Label(this.ValueUnitString(3, int.MinValue, (int)magnitude - digits), GUILayout.ExpandWidth(false));
GUILayout.EndHorizontal();	GUILayout.EndHorizontal();

if (Event.current.type == EventType.mouseUp)	if (Event.current.type == EventType.mouseUp)
{	{
Rect lastRect = GUILayoutUtility.GetLastRect();	Rect lastRect = GUILayoutUtility.GetLastRect();
if (lastRect.Contains(Event.current.mousePosition))	if (lastRect.Contains(Event.current.mousePosition))
{	{
if (Event.current.button == 0)	if (Event.current.button == 0)
{	{
digits = (digits + 3) % (int)magLimit;	digits = (digits + 3) % (int)magLimit;
}	}
else if (Event.current.button == 1)	else if (Event.current.button == 1)
{	{
digits = (digits - 3) % (int)magLimit;	digits = (digits - 3) % (int)magLimit;
if (digits < 0)	if (digits < 0)
{	{
digits = (int)magLimit - 3;	digits = (int)magLimit - 3;
}	}
}	}
}	}
}	}

return digits;	return digits;
}	}
}	}

public class VOID_DoubleValue : VOID_NumValue<double>, IVOID_NumericValue	public class VOID_DoubleValue : VOID_NumValue<double>
{	{
public VOID_DoubleValue(string Label, Func<double> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}	public VOID_DoubleValue(string Label, Func<double> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}
	}
public override double ToDouble ()	public class VOID_FloatValue : VOID_NumValue<float>
{
return this.Value;
}

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 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 VOID_FloatValue(string Label, Func<float> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}
	}
public override double ToDouble ()
{	public class VOID_IntValue : VOID_NumValue<int>
return (double)this.Value;
}

public override string ValueUnitString(string format) {
return this.Value.ToString(format) + 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 VOID_IntValue(string Label, Func<int> ValueFunc, string Units) : base(Label, ValueFunc, Units) {}
	}
public override double ToDouble ()
{
return (double)this.Value;
}

public override string ValueUnitString(string format) {
return this.Value.ToString(format) + 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 class VOID_StrValue : VOID_DataValue<string>
{	{
public VOID_StrValue(string Label, Func<string> ValueFunc) : base(Label, ValueFunc, "") {}	public VOID_StrValue(string Label, Func<string> ValueFunc) : base(Label, ValueFunc, "") {}
}	}
}	}

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 = Tools.DockToWindow (this.VOIDIconPos, this.mainWindowPos);	Rect _iconPos = Tools.DockToWindow (this.VOIDIconPos, this.mainWindowPos);

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

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

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

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

if (EditorLogic.SortedShipList.Count > 0)	if (EditorLogic.SortedShipList.Count > 0)
{	{
SimManager.Instance.Gravity = 9.08665;	SimManager.Instance.Gravity = this.Kerbin.gravParameter /
	Math.Pow(this.Kerbin.Radius, 2);
SimManager.Instance.TryStartSimulation();	SimManager.Instance.TryStartSimulation();
}	}

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

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

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

//	//
// 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 System.Linq;
	using System.Text;
using UnityEngine;	using UnityEngine;

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

protected List<Color> textColors = new List<Color>();	protected List<Color> textColors = new List<Color>();

protected GUIStyle labelStyle;	protected GUIStyle labelStyle;

	protected EditorVesselOverlays _vesselOverlays;

/*	/*
* Properties	* Properties
* */	* */
public int ColorIndex	public int ColorIndex
{	{
get	get
{	{
return this._colorIndex;	return this._colorIndex;
}	}
set	set
{	{
if (this._colorIndex >= this.textColors.Count - 1)	if (this._colorIndex >= this.textColors.Count - 1)
{	{
this._colorIndex = 0;	this._colorIndex = 0;
return;	return;
}	}

this._colorIndex = value;	this._colorIndex = value;
	}
	}

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

	return this._vesselOverlays;
	}
	}

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

	return this.vesselOverlays.CoMmarker;
	}
	}

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

	return this.vesselOverlays.CoTmarker;
}	}
}	}

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

this._Active.value = true;	this._Active.value = 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;	float hudLeft;
	StringBuilder hudString;

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

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

	hudString = new StringBuilder();

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

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

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

	hudString.Append(' ');

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

	hudString.Append('\n');

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

	hudString.Append('\n');

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

	hudString.Append('\n');

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

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

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

GUI.Label (	GUI.Label (
hudPos,	hudPos,
"Total Mass: " + SimManager.Instance.LastStage.totalMass.ToString("F3") + "t" +	hudString.ToString(),
" Part Count: " + EditorLogic.SortedShipList.Count +
"\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 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;
}	}
}	}
}	}
}	}

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

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

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

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

protected List<Color> textColors = new List<Color>();	protected List<Color> textColors = new List<Color>();

/*	/*
* Properties	* Properties
* */	* */
public int ColorIndex	public int ColorIndex
{	{
get	get
{	{
return this._colorIndex;	return this._colorIndex;
}	}
set	set
{	{
if (this._colorIndex >= this.textColors.Count - 1)	if (this._colorIndex >= this.textColors.Count - 1)
{	{
this._colorIndex = 0;	this._colorIndex = 0;
return;	return;
}	}

this._colorIndex = value;	this._colorIndex = value;
}	}
}	}

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

this._Active.value = true;	this._Active.value = 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);

VOID_Core.Instance.LabelStyles["hud"] = new GUIStyle();	VOID_Core.Instance.LabelStyles["hud"] = new GUIStyle();
VOID_Core.Instance.LabelStyles["hud"].normal.textColor = this.textColors [this.ColorIndex];	VOID_Core.Instance.LabelStyles["hud"].normal.textColor = this.textColors [this.ColorIndex];

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

public override void DrawGUI()	public override void DrawGUI()
{	{
	StringBuilder leftHUD;
	StringBuilder rightHUD;

GUI.skin = VOID_Core.Instance.Skin;	GUI.skin = VOID_Core.Instance.Skin;

if (VOID_Core.Instance.powerAvailable)	if (VOID_Core.Instance.powerAvailable)
{	{
	leftHUD = new StringBuilder();
	rightHUD = new StringBuilder();

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

	leftHUD.AppendFormat("Obt Alt: {0} Obt Vel: {1}",
	VOID_Data.orbitAltitude.ToSIString(),
	VOID_Data.orbitVelocity.ToSIString()
	);
	leftHUD.AppendFormat("\nAp: {0} ETA {1}",
	VOID_Data.orbitApoAlt.ToSIString(),
	VOID_Data.timeToApo.ValueUnitString()
	);
	leftHUD.AppendFormat("\nPe: {0} ETA {1}",
	VOID_Data.oribtPeriAlt.ToSIString(),
	VOID_Data.timeToPeri.ValueUnitString()
	);
	leftHUD.AppendFormat("\nInc: {0}", VOID_Data.orbitInclination.ValueUnitString("F3"));
	leftHUD.AppendFormat("\nPrimary: {0}", VOID_Data.primaryName.ValueUnitString());

	rightHUD.AppendFormat("Srf Alt: {0} Srf Vel: {1}",
	VOID_Data.trueAltitude.ToSIString(),
	VOID_Data.surfVelocity.ToSIString()
	);
	rightHUD.AppendFormat("\nVer: {0} Hor: {1}",
	VOID_Data.vertVelocity.ToSIString(),
	VOID_Data.horzVelocity.ToSIString()
	);
	rightHUD.AppendFormat("\nLat: {0} Lon: {1}",
	VOID_Data.surfLatitude.ValueUnitString(),
	VOID_Data.surfLongitude.ValueUnitString()
	);
	rightHUD.AppendFormat("\nHdg: {0}", VOID_Data.vesselHeading.ValueUnitString());
	rightHUD.AppendFormat("\nBiome: {0} Sit: {1}",
	VOID_Data.currBiome.ValueUnitString(),
	VOID_Data.expSituation.ValueUnitString()
	);

GUI.Label (	GUI.Label (
new Rect ((Screen.width * .2083f), 0, 300f, 70f),	new Rect ((Screen.width * .2083f), 0, 300f, 70f),
"Obt Alt: " + Tools.MuMech_ToSI (vessel.orbit.altitude) + "m" +	leftHUD.ToString(),
" Obt Vel: " + Tools.MuMech_ToSI (vessel.orbit.vel.magnitude) + "m/s" +
"\nAp: " + Tools.MuMech_ToSI (vessel.orbit.ApA) + "m" +
" ETA " + Tools.ConvertInterval (vessel.orbit.timeToAp) +
"\nPe: " + Tools.MuMech_ToSI (vessel.orbit.PeA) + "m" +
" ETA " + Tools.ConvertInterval (vessel.orbit.timeToPe) +
"\nInc: " + vessel.orbit.inclination.ToString ("F3") + "°" +
"\nPrimary: " + vessel.mainBody.bodyName,
VOID_Core.Instance.LabelStyles["hud"]);	VOID_Core.Instance.LabelStyles["hud"]);
// Toadicus edit: Added "Biome: " line to surf/atmo HUD
GUI.Label (	GUI.Label (
new Rect ((Screen.width * .625f), 0, 300f, 90f),	new Rect ((Screen.width * .625f), 0, 300f, 90f),
"Srf Alt: " + Tools.MuMech_ToSI (Tools.TrueAltitude (vessel)) + "m" +	rightHUD.ToString(),
" Srf Vel: " + Tools.MuMech_ToSI (vessel.srf_velocity.magnitude) + "m/s" +
"\nVer: " + Tools.MuMech_ToSI (vessel.verticalSpeed) + "m/s" +
" Hor: " + Tools.MuMech_ToSI (vessel.horizontalSrfSpeed) + "m/s" +
"\nLat: " + Tools.GetLatitudeString (vessel, "F3") +
" Lon: " + Tools.GetLongitudeString (vessel, "F3") +
"\nHdg: " + Tools.MuMech_get_heading (vessel).ToString ("F2") + "° " +
Tools.get_heading_text (Tools.MuMech_get_heading (vessel)) +
"\nBiome: " + Tools.Toadicus_GetAtt (vessel).name,
VOID_Core.Instance.LabelStyles["hud"]);	VOID_Core.Instance.LabelStyles["hud"]);
}	}
else	else
{	{
VOID_Core.Instance.LabelStyles["hud"].normal.textColor = Color.red;	VOID_Core.Instance.LabelStyles["hud"].normal.textColor = Color.red;
GUI.Label (new Rect ((Screen.width * .2083f), 0, 300f, 70f), "-- POWER LOST --", VOID_Core.Instance.LabelStyles["hud"]);	GUI.Label (new Rect ((Screen.width * .2083f), 0, 300f, 70f), "-- POWER LOST --", VOID_Core.Instance.LabelStyles["hud"]);
GUI.Label (new Rect ((Screen.width * .625f), 0, 300f, 70f), "-- POWER LOST --", VOID_Core.Instance.LabelStyles["hud"]);	GUI.Label (new Rect ((Screen.width * .625f), 0, 300f, 70f), "-- POWER LOST --", VOID_Core.Instance.LabelStyles["hud"]);
}	}
}	}

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

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

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;	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 = value;	this._Active.value = value;
}	}
}	}

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

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

public virtual Vessel vessel	public virtual Vessel vessel
{	{
get	get
{	{
return FlightGlobals.ActiveVessel;	return FlightGlobals.ActiveVessel;
}	}
}	}

/*	/*
* Methods	* Methods
* */	* */
public void StartGUI()	public void StartGUI()
{	{
if (!this.toggleActive \|\| this.guiRunning)	if (!this.toggleActive \|\| this.guiRunning)
{	{
return;	return;
}	}

Tools.PostDebugMessage (string.Format("Adding {0} to the draw queue.", this.GetType().Name));	Tools.PostDebugMessage (string.Format("Adding {0} to the draw queue.", this.GetType().Name));
RenderingManager.AddToPostDrawQueue (3, this.DrawGUI);	RenderingManager.AddToPostDrawQueue (3, this.DrawGUI);
this._Running = true;	this._Running = true;
}	}

public void StopGUI()	public void StopGUI()
{	{
if (!this.guiRunning)	if (!this.guiRunning)
{	{
return;	return;
}	}
Tools.PostDebugMessage (string.Format("Removing {0} from the draw queue.", this.GetType().Name));	Tools.PostDebugMessage (string.Format("Removing {0} from the draw queue.", this.GetType().Name));
RenderingManager.RemoveFromPostDrawQueue (3, this.DrawGUI);	RenderingManager.RemoveFromPostDrawQueue (3, this.DrawGUI);
this._Running = false;	this._Running = false;
}	}

public abstract void DrawGUI();	public abstract void DrawGUI();

public virtual void DrawConfigurables() {}	public virtual void DrawConfigurables() {}

public virtual void LoadConfig()	public virtual void LoadConfig()
{	{
var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> ();	var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> ();
config.load ();	config.load ();

foreach (var field in this.GetType().GetFields(	foreach (var field in this.GetType().GetFields(
BindingFlags.NonPublic \|	BindingFlags.NonPublic \|
BindingFlags.Public \|	BindingFlags.Public \|
BindingFlags.Instance \|	BindingFlags.Instance \|
BindingFlags.FlattenHierarchy	BindingFlags.FlattenHierarchy
))	))
{	{
object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false);	object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false);

if (attrs.Length == 0) {	if (attrs.Length == 0) {
continue;	continue;
}	}

AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue;	AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue;

string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name);	string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name);

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

object fieldValue = field.GetValue(this);	object fieldValue = field.GetValue(this);

bool convertBack = false;	bool convertBack = false;
if (fieldValue is IVOID_SaveValue)	if (fieldValue is IVOID_SaveValue)
{	{
fieldValue = (fieldValue as IVOID_SaveValue).AsType;	fieldValue = (fieldValue as IVOID_SaveValue).AsType;
convertBack = true;	convertBack = true;
}	}

fieldValue = config.GetValue(fieldName, fieldValue);	fieldValue = config.GetValue(fieldName, fieldValue);

if (convertBack)	if (convertBack)
{	{
Type type = typeof(VOID_SaveValue<>).MakeGenericType (fieldValue.GetType ());	Type type = typeof(VOID_SaveValue<>).MakeGenericType (fieldValue.GetType ());
IVOID_SaveValue convertValue = Activator.CreateInstance (type) as IVOID_SaveValue;	IVOID_SaveValue convertValue = Activator.CreateInstance (type) as IVOID_SaveValue;
convertValue.SetValue (fieldValue);	convertValue.SetValue (fieldValue);
fieldValue = convertValue;	fieldValue = convertValue;
}	}

field.SetValue (this, fieldValue);	field.SetValue (this, fieldValue);

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

public virtual void _SaveToConfig(KSP.IO.PluginConfiguration config)	public virtual void _SaveToConfig(KSP.IO.PluginConfiguration config)
{	{
foreach (var field in this.GetType().GetFields(	foreach (var field in this.GetType().GetFields(
BindingFlags.Instance \|	BindingFlags.Instance \|
BindingFlags.NonPublic \|	BindingFlags.NonPublic \|
BindingFlags.Public \|	BindingFlags.Public \|
BindingFlags.FlattenHierarchy	BindingFlags.FlattenHierarchy
))	))
{	{
object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false);	object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false);

if (attrs.Length == 0) {	if (attrs.Length == 0) {
continue;	continue;
}	}

AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue;	AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue;

string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name);	string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name);

object fieldValue = field.GetValue(this);	object fieldValue = field.GetValue(this);

if (fieldValue is IVOID_SaveValue)	if (fieldValue is IVOID_SaveValue)
{	{
fieldValue = (fieldValue as IVOID_SaveValue).AsType;	fieldValue = (fieldValue as IVOID_SaveValue).AsType;
}	}

config.SetValue(fieldName, fieldValue);	config.SetValue(fieldName, fieldValue);

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

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

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

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);	_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")]	[AVOID_SaveValue("precisionValues")]
protected long _precisionValues = 230584300921369395;	protected long _precisionValues = 230584300921369395;
protected IntCollection precisionValues;	protected IntCollection precisionValues;

protected VOID_StrValue primaryName = new VOID_StrValue (	public VOID_Orbital()
	{
	this._Name = "Orbital Information";

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

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

	int idx = 0;

	GUILayout.BeginVertical();

	VOID_Data.primaryName.DoGUIHorizontal ();

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

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

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

	VOID_Data.timeToApo.DoGUIHorizontal();

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

	VOID_Data.timeToPeri.DoGUIHorizontal();

	VOID_Data.orbitInclination.DoGUIHorizontal("F3");

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

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

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

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

	VOID_Data.eccentricity.DoGUIHorizontal("F4");

	VOID_Data.meanAnomaly.DoGUIHorizontal("F3");

	VOID_Data.trueAnomaly.DoGUIHorizontal("F3");

	VOID_Data.eccAnomaly.DoGUIHorizontal("F3");

	VOID_Data.longitudeAscNode.DoGUIHorizontal("F3");

	VOID_Data.argumentPeriapsis.DoGUIHorizontal("F3");

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

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


	public static partial class VOID_Data
	{
	public static VOID_StrValue primaryName = new VOID_StrValue (
VOIDLabels.void_primary,	VOIDLabels.void_primary,
new Func<string> (() => VOID_Core.Instance.vessel.mainBody.name)	new Func<string> (() => VOID_Core.Instance.vessel.mainBody.name)
);	);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

int idx = 0;

GUILayout.BeginVertical();

this.primaryName.DoGUIHorizontal ();

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

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

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

this.timeToApo.DoGUIHorizontal();

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

this.timeToPeri.DoGUIHorizontal();

this.orbitInclination.DoGUIHorizontal("F3");

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

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

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

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

this.eccentricity.DoGUIHorizontal("F4");

this.meanAnomaly.DoGUIHorizontal("F3");

this.trueAnomaly.DoGUIHorizontal("F3");

this.eccAnomaly.DoGUIHorizontal("F3");

this.longitudeAscNode.DoGUIHorizontal("F3");

this.argumentPeriapsis.DoGUIHorizontal("F3");

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

GUILayout.EndVertical();
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_SurfAtmo.cs -> file:b/VOID_SurfAtmo.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_SurfAtmo : VOID_WindowModule	public class VOID_SurfAtmo : VOID_WindowModule
{	{
[AVOID_SaveValue("precisionValues")]	[AVOID_SaveValue("precisionValues")]
protected long _precisionValues = 230584300921369395;	protected long _precisionValues = 230584300921369395;
protected IntCollection precisionValues;	protected IntCollection precisionValues;

protected VOID_DoubleValue trueAltitude = new VOID_DoubleValue(
"Altitude (true)",
delegate()
{
double alt_true = VOID_Core.Instance.vessel.orbit.altitude - VOID_Core.Instance.vessel.terrainAltitude;
// HACK: This assumes that on worlds with oceans, all water is fixed at 0 m,
// and water covers the whole surface at 0 m.
if (VOID_Core.Instance.vessel.terrainAltitude < 0 && VOID_Core.Instance.vessel.mainBody.ocean )
alt_true = VOID_Core.Instance.vessel.orbit.altitude;
return alt_true;
},
"m"
);

protected VOID_StrValue surfLatitude = new VOID_StrValue(
"Latitude",
new Func<string> (() => Tools.GetLatitudeString(VOID_Core.Instance.vessel))
);

protected VOID_StrValue surfLongitude = new VOID_StrValue(
"Longitude",
new Func<string> (() => Tools.GetLongitudeString(VOID_Core.Instance.vessel))
);

protected VOID_StrValue vesselHeading = new VOID_StrValue(
"Heading",
delegate()
{
double heading = Tools.MuMech_get_heading(VOID_Core.Instance.vessel);
string cardinal = Tools.get_heading_text(heading);

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

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

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

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

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

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

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

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

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

protected VOID_StrValue currBiome = new VOID_StrValue(
"Biome",
new Func<string> (() => Tools.Toadicus_GetAtt(VOID_Core.Instance.vessel).name)
);

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

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

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

int idx = 0;	int idx = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	public static VOID_StrValue vesselHeading = new VOID_StrValue(
	"Heading",
	delegate()
	{
	double heading = Tools.MuMech_get_heading(VOID_Core.Instance.vessel);
	string cardinal = Tools.get_heading_text(heading);

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

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

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

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

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

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

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

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

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

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

	}
}	}

file:a/VOID_Transfer.cs -> file:b/VOID_Transfer.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 System.Collections.Generic;	using System.Collections.Generic;
using UnityEngine;	using UnityEngine;
using Engineer.VesselSimulator;	using Engineer.VesselSimulator;
	using Engineer.Extensions;

namespace VOID	namespace VOID
{	{
public class VOID_VesselInfo : VOID_WindowModule	public class VOID_VesselInfo : VOID_WindowModule
{	{
protected VOID_DoubleValue geeForce = new VOID_DoubleValue(	public VOID_VesselInfo() : base()
	{
	this._Name = "Vessel Information";

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

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

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

	GUILayout.BeginVertical();

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

	Tools.PostDebugMessage("Starting VesselInfo window.");

	VOID_Data.geeForce.DoGUIHorizontal ("F2");

	Tools.PostDebugMessage("GeeForce done.");

	VOID_Data.partCount.DoGUIHorizontal ();

	Tools.PostDebugMessage("PartCount done.");

	VOID_Data.totalMass.DoGUIHorizontal ("F1");

	Tools.PostDebugMessage("TotalMass done.");

	VOID_Data.resourceMass.DoGUIHorizontal ("F1");

	Tools.PostDebugMessage("ResourceMass done.");

	VOID_Data.stageDeltaV.DoGUIHorizontal (3, false);

	Tools.PostDebugMessage("Stage deltaV done.");

	VOID_Data.totalDeltaV.DoGUIHorizontal (3, false);

	Tools.PostDebugMessage("Total deltaV done.");

	VOID_Data.mainThrottle.DoGUIHorizontal ("F0");

	Tools.PostDebugMessage("MainThrottle done.");

	VOID_Data.currmaxThrust.DoGUIHorizontal ();

	Tools.PostDebugMessage("CurrMaxThrust done.");

	VOID_Data.currmaxThrustWeight.DoGUIHorizontal ();

	Tools.PostDebugMessage("CurrMaxTWR done.");

	VOID_Data.surfaceThrustWeight.DoGUIHorizontal ("F2");

	Tools.PostDebugMessage("surfaceTWR done.");

	VOID_Data.intakeAirStatus.DoGUIHorizontal();

	Tools.PostDebugMessage("intakeAirStatus done.");

	GUILayout.EndVertical();

	Tools.PostDebugMessage("VesselInfo window done.");

	GUI.DragWindow();
	}
	}

	public static partial class VOID_Data
	{
	public static VOID_DoubleValue geeForce = new VOID_DoubleValue(
"G-force",	"G-force",
new Func<double>(() => VOID_Core.Instance.vessel.geeForce),	new Func<double>(() => VOID_Core.Instance.vessel.geeForce),
"gees"	"gees"
);	);

protected VOID_IntValue partCount = new VOID_IntValue(	public static VOID_IntValue partCount = new VOID_IntValue(
"Parts",	"Parts",
new Func<int>(() => VOID_Core.Instance.vessel.Parts.Count),	new Func<int>(() => VOID_Core.Instance.vessel.Parts.Count),
""	""
);	);

protected VOID_DoubleValue totalMass = new VOID_DoubleValue(	public static VOID_DoubleValue totalMass = new VOID_DoubleValue(
"Total Mass",	"Total Mass",
new Func<double>(() => VOID_Core.Instance.vessel.GetTotalMass()),	new Func<double> (() => SimManager.Instance.TryGetLastMass()),
"tons"	"tons"
);	);

protected VOID_DoubleValue resourceMass = new VOID_DoubleValue(	public static VOID_DoubleValue resourceMass = new VOID_DoubleValue(
"Resource Mass",	"Resource Mass",
delegate()	delegate()
{	{
double rscMass = 0;	double rscMass = 0;
foreach (Part part in VOID_Core.Instance.vessel.Parts)	foreach (Part part in VOID_Core.Instance.vessel.Parts)
{	{
rscMass += part.GetResourceMass();	rscMass += part.GetResourceMass();
}	}
return rscMass;	return rscMass;
},	},
"tons"	"tons"
);	);

protected VOID_DoubleValue stageDeltaV = new VOID_DoubleValue(	public static VOID_DoubleValue stageDeltaV = new VOID_DoubleValue(
"DeltaV (Current Stage)",	"DeltaV (Current Stage)",
delegate()	delegate()
{	{
if (SimManager.Instance.Stages == null \|\|	if (SimManager.Instance.Stages == null \|\|
SimManager.Instance.Stages.Length <= Staging.lastStage	SimManager.Instance.Stages.Length <= Staging.lastStage
)	)
return double.NaN;	return double.NaN;
return SimManager.Instance.Stages[Staging.lastStage].deltaV;	return SimManager.Instance.Stages[Staging.lastStage].deltaV;
},	},
"m/s"	"m/s"
);	);

protected VOID_DoubleValue totalDeltaV = new VOID_DoubleValue(	public static VOID_DoubleValue totalDeltaV = new VOID_DoubleValue(
"DeltaV (Total)",	"DeltaV (Total)",
delegate()	delegate()
{	{
if (SimManager.Instance.Stages == null)	if (SimManager.Instance.Stages == null)
return double.NaN;	return double.NaN;
return SimManager.Instance.LastStage.totalDeltaV;	return SimManager.Instance.LastStage.totalDeltaV;
},	},
"m/s"	"m/s"
);	);

protected VOID_FloatValue mainThrottle = new VOID_FloatValue(	public static VOID_FloatValue mainThrottle = new VOID_FloatValue(
"Throttle",	"Throttle",
new Func<float>(() => VOID_Core.Instance.vessel.ctrlState.mainThrottle * 100f),	new Func<float>(() => VOID_Core.Instance.vessel.ctrlState.mainThrottle * 100f),
"%"	"%"
);	);

protected VOID_StrValue currmaxThrust = new VOID_StrValue(	public static VOID_StrValue currmaxThrust = new VOID_StrValue(
"Thrust (curr/max)",	"Thrust (curr/max)",
delegate()	delegate()
{	{
if (SimManager.Instance.Stages == null)	if (SimManager.Instance.Stages == null)
return "N/A";	return "N/A";

double currThrust = SimManager.Instance.LastStage.actualThrust;	double currThrust = SimManager.Instance.LastStage.actualThrust;
double maxThrust = SimManager.Instance.LastStage.thrust;	double maxThrust = SimManager.Instance.LastStage.thrust;

return string.Format(	return string.Format(
"{0} / {1}",	"{0} / {1}",
currThrust.ToString("F1"),	currThrust.ToString("F1"),
maxThrust.ToString("F1")	maxThrust.ToString("F1")
);	);
}	}
);	);

protected VOID_StrValue currmaxThrustWeight = new VOID_StrValue(	public static VOID_StrValue currmaxThrustWeight = new VOID_StrValue(
"T:W (curr/max)",	"T:W (curr/max)",
delegate()	delegate()
{	{
if (SimManager.Instance.Stages == null)	if (SimManager.Instance.Stages == null)
return "N/A";	return "N/A";

double currThrust = SimManager.Instance.LastStage.actualThrust;	double currThrust = SimManager.Instance.LastStage.actualThrust;
double maxThrust = SimManager.Instance.LastStage.thrust;	double maxThrust = SimManager.Instance.LastStage.thrust;
double mass = VOID_Core.Instance.vessel.GetTotalMass();	double mass = SimManager.Instance.TryGetLastMass();
double gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /	double gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /
Math.Pow(	Math.Pow(
VOID_Core.Instance.vessel.mainBody.Radius + VOID_Core.Instance.vessel.altitude,	VOID_Core.Instance.vessel.mainBody.Radius + VOID_Core.Instance.vessel.altitude,
2	2
);	);
double weight = mass * gravity;	double weight = mass * gravity;

return string.Format(	return string.Format(
"{0} / {1}",	"{0} / {1}",
(currThrust / weight).ToString("F2"),	(currThrust / weight).ToString("F2"),
(maxThrust / weight).ToString("F2")	(maxThrust / weight).ToString("F2")
);	);
}	}
);	);

protected VOID_DoubleValue surfaceThrustWeight = new VOID_DoubleValue(	public static VOID_DoubleValue surfaceThrustWeight = new VOID_DoubleValue(
"Max T:W @ surface",	"Max T:W @ surface",
delegate()	delegate()
{	{
if (SimManager.Instance.Stages == null)	if (SimManager.Instance.Stages == null)
return double.NaN;	return double.NaN;

double maxThrust = SimManager.Instance.LastStage.thrust;	double maxThrust = SimManager.Instance.LastStage.thrust;
double mass = VOID_Core.Instance.vessel.GetTotalMass();	double mass = SimManager.Instance.TryGetLastMass();
double gravity = (VOID_Core.Constant_G * VOID_Core.Instance.vessel.mainBody.Mass) /	double gravity = (VOID_Core.Constant_G * VOID_Core.Instance.vessel.mainBody.Mass) /
Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);	Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);
double weight = mass * gravity;	double weight = mass * gravity;

return maxThrust / weight;	return maxThrust / weight;
},	},
""	""
);	);

public VOID_VesselInfo() : base()	public static VOID_StrValue intakeAirStatus = new VOID_StrValue(
{	"Intake Air (Curr / Req)",
this._Name = "Vessel Information";	delegate()
	{
this.WindowPos.x = Screen.width - 260;	double currentAmount;
this.WindowPos.y = 450;	double currentRequirement;
}
	currentAmount = 0d;
public override void ModuleWindow(int _)	currentRequirement = 0d;
{
base.ModuleWindow (_);	foreach (Part part in VOID_Core.Instance.vessel.Parts)
	{
if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) \|\| (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate))	if (part.HasModule<ModuleEngines>() && part.enabled)
{	{
SimManager.Instance.RequestSimulation();	foreach (Propellant propellant in part.GetModule<ModuleEngines>().propellants)
}	{
	if (propellant.name == "IntakeAir")
Stage[] stages = SimManager.Instance.Stages;	{
	// currentAmount += propellant.currentAmount;
GUILayout.BeginVertical();	currentRequirement += propellant.currentRequirement / TimeWarp.fixedDeltaTime;
	break;
GUILayout.Label(	}
vessel.vesselName,	}
VOID_Core.Instance.LabelStyles["center_bold"],	}
GUILayout.ExpandWidth(true));
	if (part.HasModule<ModuleResourceIntake>() && part.enabled)
this.geeForce.DoGUIHorizontal ("F2");	{
	ModuleResourceIntake intakeModule = part.GetModule<ModuleResourceIntake>();
this.partCount.DoGUIHorizontal ();
	if (intakeModule.resourceName == "IntakeAir")
this.totalMass.DoGUIHorizontal ("F1");	{
	currentAmount += intakeModule.airFlow;
this.resourceMass.DoGUIHorizontal ("F1");	}
	}
this.stageDeltaV.DoGUIHorizontal (3, false);	}

this.totalDeltaV.DoGUIHorizontal (3, false);	if (currentAmount == 0 && currentRequirement == 0)
	{
this.mainThrottle.DoGUIHorizontal ("F0");	return "N/A";
	}
this.currmaxThrust.DoGUIHorizontal ();
	return string.Format("{0:F3} / {1:F3}", currentAmount, currentRequirement);
this.currmaxThrustWeight.DoGUIHorizontal ();	}
	);
this.surfaceThrustWeight.DoGUIHorizontal ("F2");

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

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

	using System.Reflection;
	using System.Runtime.CompilerServices;
	using System.Runtime.InteropServices;

	// Allgemeine Informationen über eine Assembly werden über die folgenden
	// Attribute gesteuert. Ändern Sie diese Attributwerte, um die Informationen zu ändern,
	// die mit einer Assembly verknüpft sind.
	[assembly: AssemblyTitle("Toolbar Wrapper for Kerbal Space Program")]
	[assembly: AssemblyDescription("")]
	[assembly: AssemblyConfiguration("")]
	[assembly: AssemblyCompany("")]
	[assembly: AssemblyProduct("ToolbarWrapper")]
	[assembly: AssemblyCopyright("Copyright © 2013-2014 Maik Schreiber")]
	[assembly: AssemblyTrademark("")]
	[assembly: AssemblyCulture("")]

	// Durch Festlegen von ComVisible auf "false" werden die Typen in dieser Assembly unsichtbar
	// für COM-Komponenten. Wenn Sie auf einen Typ in dieser Assembly von
	// COM zugreifen müssen, legen Sie das ComVisible-Attribut für diesen Typ auf "true" fest.
	[assembly: ComVisible(false)]

	// Die folgende GUID bestimmt die ID der Typbibliothek, wenn dieses Projekt für COM verfügbar gemacht wird
	[assembly: Guid("bfd95a60-6335-4a59-a29e-438d806d8f2d")]

	// Versionsinformationen für eine Assembly bestehen aus den folgenden vier Werten:
	//
	// Hauptversion
	// Nebenversion
	// Buildnummer
	// Revision
	//
	// Sie können alle Werte angeben oder die standardmäßigen Build- und Revisionsnummern
	// übernehmen, indem Sie "*" eingeben:
	// [assembly: AssemblyVersion("1.0.*")]
	[assembly: AssemblyVersion("1.0.0.0")]
	[assembly: AssemblyFileVersion("1.0.0.0")]

file:b/Wrapper/ToolbarWrapper.cs (new)

	/*
	Copyright (c) 2013-2014, Maik Schreiber
	All rights reserved.

	Redistribution and use in source and binary forms, with or without modification,
	are permitted provided that the following conditions are met:

	1. Redistributions of source code must retain the above copyright notice, this
	list of conditions and the following disclaimer.

	2. Redistributions in binary form must reproduce the above copyright notice,
	this list of conditions and the following disclaimer in the documentation
	and/or other materials provided with the distribution.

	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
	FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
	CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
	OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	*/
	using System;
	using System.Collections.Generic;
	using System.Linq;
	using System.Reflection;
	using System.Text;
	using UnityEngine;


	namespace VOID {



	/**********************************************************\
	* --- DO NOT EDIT BELOW THIS COMMENT --- *
	* *
	* This file contains classes and interfaces to use the *
	* Toolbar Plugin without creating a hard dependency on it. *
	* *
	* There is nothing in this file that needs to be edited *
	* by hand. *
	* *
	* --- DO NOT EDIT BELOW THIS COMMENT --- *
	\**********************************************************/



	/// <summary>
	/// The global tool bar manager.
	/// </summary>
	public partial class ToolbarManager : IToolbarManager {
	/// <summary>
	/// Whether the Toolbar Plugin is available.
	/// </summary>
	public static bool ToolbarAvailable {
	get {
	if (toolbarAvailable == null) {
	toolbarAvailable = Instance != null;
	}
	return (bool) toolbarAvailable;
	}
	}

	/// <summary>
	/// The global tool bar manager instance.
	/// </summary>
	public static IToolbarManager Instance {
	get {
	if ((toolbarAvailable != false) && (instance_ == null)) {
	Type type = ToolbarTypes.getType("Toolbar.ToolbarManager");
	if (type != null) {
	object realToolbarManager = ToolbarTypes.getStaticProperty(type, "Instance").GetValue(null, null);
	instance_ = new ToolbarManager(realToolbarManager);
	}
	}
	return instance_;
	}
	}
	}

	#region interfaces

	/// <summary>
	/// A toolbar manager.
	/// </summary>
	public interface IToolbarManager {
	/// <summary>
	/// Adds a new button.
	/// </summary>
	/// <remarks>
	/// To replace an existing button, just add a new button using the old button's namespace and ID.
	/// Note that the new button will inherit the screen position of the old button.
	/// </remarks>
	/// <param name="ns">The new button's namespace. This is usually the plugin's name. Must not include special characters like '.'</param>
	/// <param name="id">The new button's ID. This ID must be unique across all buttons in the namespace. Must not include special characters like '.'</param>
	/// <returns>The button created.</returns>
	IButton add(string ns, string id);
	}

	/// <summary>
	/// Represents a clickable button.
	/// </summary>
	public interface IButton {
	/// <summary>
	/// The text displayed on the button. Set to null to hide text.
	/// </summary>
	/// <remarks>
	/// The text can be changed at any time to modify the button's appearance. Note that since this will also
	/// modify the button's size, this feature should be used sparingly, if at all.
	/// </remarks>
	/// <seealso cref="TexturePath"/>
	string Text {
	set;
	get;
	}

	/// <summary>
	/// The color the button text is displayed with. Defaults to Color.white.
	/// </summary>
	/// <remarks>
	/// The text color can be changed at any time to modify the button's appearance.
	/// </remarks>
	Color TextColor {
	set;
	get;
	}

	/// <summary>
	/// The path of a texture file to display an icon on the button. Set to null to hide icon.
	/// </summary>
	/// <remarks>
	/// <para>
	/// A texture path on a button will have precedence over text. That is, if both text and texture path
	/// have been set on a button, the button will show the texture, not the text.
	/// </para>
	/// <para>
	/// The texture size must not exceed 24x24 pixels.
	/// </para>
	/// <para>
	/// The texture path must be relative to the "GameData" directory, and must not specify a file name suffix.
	/// Valid example: MyAddon/Textures/icon_mybutton
	/// </para>
	/// <para>
	/// The texture path can be changed at any time to modify the button's appearance.
	/// </para>
	/// </remarks>
	/// <seealso cref="Text"/>
	string TexturePath {
	set;
	get;
	}

	/// <summary>
	/// The button's tool tip text. Set to null if no tool tip is desired.
	/// </summary>
	/// <remarks>
	/// Tool Tip Text Should Always Use Headline Style Like This.
	/// </remarks>
	string ToolTip {
	set;
	get;
	}

	/// <summary>
	/// Whether this button is currently visible or not. Can be used in addition to or as a replacement for <see cref="Visibility"/>.
	/// </summary>
	/// <remarks>
	/// Setting this property to true does not affect the player's ability to hide the button using the configuration.
	/// Conversely, setting this property to false does not enable the player to show the button using the configuration.
	/// </remarks>
	bool Visible {
	set;
	get;
	}

	/// <summary>
	/// Determines this button's visibility. Can be used in addition to or as a replacement for <see cref="Visible"/>.
	/// </summary>
	/// <remarks>
	/// The return value from IVisibility.Visible is subject to the same rules as outlined for
	/// <see cref="Visible"/>.
	/// </remarks>
	IVisibility Visibility {
	set;
	get;
	}

	/// <summary>
	/// Whether this button is currently effectively visible or not. This is a combination of
	/// <see cref="Visible"/> and <see cref="Visibility"/>.
	/// </summary>
	/// <remarks>
	/// Note that the toolbar is not visible in certain game scenes, for example the loading screens. This property
	/// does not reflect button invisibility in those scenes. In addition, this property does not reflect the
	/// player's configuration of the button's visibility.
	/// </remarks>
	bool EffectivelyVisible {
	get;
	}

	/// <summary>
	/// Whether this button is currently enabled (clickable) or not. This does not affect the player's ability to
	/// position the button on their toolbar.
	/// </summary>
	bool Enabled {
	set;
	get;
	}

	/// <summary>
	/// Whether this button is currently "important." Set to false to return to normal button behaviour.
	/// </summary>
	/// <remarks>
	/// <para>
	/// This can be used to temporarily force the button to be shown on screen regardless of the toolbar being
	/// currently in auto-hidden mode. For example, a button that signals the arrival of a private message in
	/// a chat room could mark itself as "important" as long as the message has not been read.
	/// </para>
	/// <para>
	/// Setting this property does not change the appearance of the button. Use <see cref="TexturePath"/> to
	/// change the button's icon.
	/// </para>
	/// <para>
	/// Setting this property to true does not affect the player's ability to hide the button using the
	/// configuration.
	/// </para>
	/// <para>
	/// This feature should be used only sparingly, if at all, since it forces the button to be displayed on
	/// screen even when it normally wouldn't.
	/// </para>
	/// </remarks>
	bool Important {
	set;
	get;
	}

	/// <summary>
	/// A drawable that is tied to the current button. This can be anything from a popup menu to
	/// an informational window. Set to null to hide the drawable.
	/// </summary>
	IDrawable Drawable {
	set;
	get;
	}

	/// <summary>
	/// Event handler that can be registered with to receive "on click" events.
	/// </summary>
	/// <example>
	/// <code>
	/// IButton button = ...
	/// button.OnClick += (e) => {
	/// Debug.Log("button clicked, mouseButton: " + e.MouseButton);
	/// };
	/// </code>
	/// </example>
	event ClickHandler OnClick;

	/// <summary>
	/// Event handler that can be registered with to receive "on mouse enter" events.
	/// </summary>
	/// <example>
	/// <code>
	/// IButton button = ...
	/// button.OnMouseEnter += (e) => {
	/// Debug.Log("mouse entered button");
	/// };
	/// </code>
	/// </example>
	event MouseEnterHandler OnMouseEnter;

	/// <summary>
	/// Event handler that can be registered with to receive "on mouse leave" events.
	/// </summary>
	/// <example>
	/// <code>
	/// IButton button = ...
	/// button.OnMouseLeave += (e) => {
	/// Debug.Log("mouse left button");
	/// };
	/// </code>
	/// </example>
	event MouseLeaveHandler OnMouseLeave;

	/// <summary>
	/// Permanently destroys this button so that it is no longer displayed.
	/// Should be used when a plugin is stopped to remove leftover buttons.
	/// </summary>
	void Destroy();
	}

	/// <summary>
	/// A drawable that is tied to a particular button. This can be anything from a popup menu
	/// to an informational window.
	/// </summary>
	public interface IDrawable {
	/// <summary>
	/// Update any information. This is called once per frame.
	/// </summary>
	void Update();

	/// <summary>
	/// Draws GUI widgets for this drawable. This is the equivalent to the OnGUI() message in
	/// <see cref="MonoBehaviour"/>.
	/// </summary>
	/// <remarks>
	/// The drawable will be positioned near its parent toolbar according to the drawable's current
	/// width/height.
	/// </remarks>
	/// <param name="position">The left/top position of where to draw this drawable.</param>
	/// <returns>The current width/height of this drawable.</returns>
	Vector2 Draw(Vector2 position);
	}

	#endregion

	#region events

	/// <summary>
	/// Event describing a click on a button.
	/// </summary>
	public partial class ClickEvent : EventArgs {
	/// <summary>
	/// The button that has been clicked.
	/// </summary>
	public readonly IButton Button;

	/// <summary>
	/// The mouse button which the button was clicked with.
	/// </summary>
	/// <remarks>
	/// Is 0 for left mouse button, 1 for right mouse button, and 2 for middle mouse button.
	/// </remarks>
	public readonly int MouseButton;
	}

	/// <summary>
	/// An event handler that is invoked whenever a button has been clicked.
	/// </summary>
	/// <param name="e">An event describing the button click.</param>
	public delegate void ClickHandler(ClickEvent e);

	/// <summary>
	/// Event describing the mouse pointer moving about a button.
	/// </summary>
	public abstract partial class MouseMoveEvent {
	/// <summary>
	/// The button in question.
	/// </summary>
	public readonly IButton button;
	}

	/// <summary>
	/// Event describing the mouse pointer entering a button's area.
	/// </summary>
	public partial class MouseEnterEvent : MouseMoveEvent {
	}

	/// <summary>
	/// Event describing the mouse pointer leaving a button's area.
	/// </summary>
	public partial class MouseLeaveEvent : MouseMoveEvent {
	}

	/// <summary>
	/// An event handler that is invoked whenever the mouse pointer enters a button's area.
	/// </summary>
	/// <param name="e">An event describing the mouse pointer entering.</param>
	public delegate void MouseEnterHandler(MouseEnterEvent e);

	/// <summary>
	/// An event handler that is invoked whenever the mouse pointer leaves a button's area.
	/// </summary>
	/// <param name="e">An event describing the mouse pointer leaving.</param>
	public delegate void MouseLeaveHandler(MouseLeaveEvent e);

	#endregion

	#region visibility

	/// <summary>
	/// Determines visibility of a button.
	/// </summary>
	/// <seealso cref="IButton.Visibility"/>
	public interface IVisibility {
	/// <summary>
	/// Whether a button is currently visible or not.
	/// </summary>
	/// <seealso cref="IButton.Visible"/>
	bool Visible {
	get;
	}
	}

	/// <summary>
	/// Determines visibility of a button in relation to the currently running game scene.
	/// </summary>
	/// <example>
	/// <code>
	/// IButton button = ...
	/// button.Visibility = new GameScenesVisibility(GameScenes.EDITOR, GameScenes.SPH);
	/// </code>
	/// </example>
	/// <seealso cref="IButton.Visibility"/>
	public class GameScenesVisibility : IVisibility {
	private GameScenes[] gameScenes;

	public bool Visible {
	get {
	return (bool) visibleProperty.GetValue(realGameScenesVisibility, null);
	}
	}

	private object realGameScenesVisibility;
	private PropertyInfo visibleProperty;

	public GameScenesVisibility(params GameScenes[] gameScenes) {
	Type gameScenesVisibilityType = ToolbarTypes.getType("Toolbar.GameScenesVisibility");
	realGameScenesVisibility = Activator.CreateInstance(gameScenesVisibilityType, new object[] { gameScenes });
	visibleProperty = ToolbarTypes.getProperty(gameScenesVisibilityType, "Visible");
	this.gameScenes = gameScenes;
	}
	}

	#endregion

	#region drawable

	/// <summary>
	/// A drawable that draws a popup menu.
	/// </summary>
	public partial class PopupMenuDrawable : IDrawable {
	/// <summary>
	/// Event handler that can be registered with to receive "any menu option clicked" events.
	/// </summary>
	public event Action OnAnyOptionClicked {
	add {
	onAnyOptionClickedEvent.AddEventHandler(realPopupMenuDrawable, value);
	}
	remove {
	onAnyOptionClickedEvent.RemoveEventHandler(realPopupMenuDrawable, value);
	}
	}

	private object realPopupMenuDrawable;
	private MethodInfo updateMethod;
	private MethodInfo drawMethod;
	private MethodInfo addOptionMethod;
	private MethodInfo addSeparatorMethod;
	private MethodInfo destroyMethod;
	private EventInfo onAnyOptionClickedEvent;

	public PopupMenuDrawable() {
	Type popupMenuDrawableType = ToolbarTypes.getType("Toolbar.PopupMenuDrawable");
	realPopupMenuDrawable = Activator.CreateInstance(popupMenuDrawableType, null);
	updateMethod = ToolbarTypes.getMethod(popupMenuDrawableType, "Update");
	drawMethod = ToolbarTypes.getMethod(popupMenuDrawableType, "Draw");
	addOptionMethod = ToolbarTypes.getMethod(popupMenuDrawableType, "AddOption");
	addSeparatorMethod = ToolbarTypes.getMethod(popupMenuDrawableType, "AddSeparator");
	destroyMethod = ToolbarTypes.getMethod(popupMenuDrawableType, "Destroy");
	onAnyOptionClickedEvent = ToolbarTypes.getEvent(popupMenuDrawableType, "OnAnyOptionClicked");
	}

	public void Update() {
	updateMethod.Invoke(realPopupMenuDrawable, null);
	}

	public Vector2 Draw(Vector2 position) {
	return (Vector2) drawMethod.Invoke(realPopupMenuDrawable, new object[] { position });
	}

	/// <summary>
	/// Adds a new option to the popup menu.
	/// </summary>
	/// <param name="text">The text of the option.</param>
	/// <returns>A button that can be used to register clicks on the menu option.</returns>
	public IButton AddOption(string text) {
	object realButton = addOptionMethod.Invoke(realPopupMenuDrawable, new object[] { text });
	return new Button(realButton, new ToolbarTypes());
	}

	/// <summary>
	/// Adds a separator to the popup menu.
	/// </summary>
	public void AddSeparator() {
	addSeparatorMethod.Invoke(realPopupMenuDrawable, null);
	}

	/// <summary>
	/// Destroys this drawable. This must always be called before disposing of this drawable.
	/// </summary>
	public void Destroy() {
	destroyMethod.Invoke(realPopupMenuDrawable, null);
	}
	}

	#endregion

	#region private implementations

	public partial class ToolbarManager : IToolbarManager {
	private static bool? toolbarAvailable = null;
	private static IToolbarManager instance_;

	private object realToolbarManager;
	private MethodInfo addMethod;
	private Dictionary<object, IButton> buttons = new Dictionary<object, IButton>();
	private ToolbarTypes types = new ToolbarTypes();

	private ToolbarManager(object realToolbarManager) {
	this.realToolbarManager = realToolbarManager;

	addMethod = ToolbarTypes.getMethod(types.iToolbarManagerType, "add");
	}

	public IButton add(string ns, string id) {
	object realButton = addMethod.Invoke(realToolbarManager, new object[] { ns, id });
	IButton button = new Button(realButton, types);
	buttons.Add(realButton, button);
	return button;
	}
	}

	internal class Button : IButton {
	private object realButton;
	private ToolbarTypes types;
	private Delegate realClickHandler;
	private Delegate realMouseEnterHandler;
	private Delegate realMouseLeaveHandler;

	internal Button(object realButton, ToolbarTypes types) {
	this.realButton = realButton;
	this.types = types;

	realClickHandler = attachEventHandler(types.button.onClickEvent, "clicked", realButton);
	realMouseEnterHandler = attachEventHandler(types.button.onMouseEnterEvent, "mouseEntered", realButton);
	realMouseLeaveHandler = attachEventHandler(types.button.onMouseLeaveEvent, "mouseLeft", realButton);
	}

	private Delegate attachEventHandler(EventInfo @event, string methodName, object realButton) {
	MethodInfo method = GetType().GetMethod(methodName, BindingFlags.NonPublic \| BindingFlags.Instance);
	Delegate d = Delegate.CreateDelegate(@event.EventHandlerType, this, method);
	@event.AddEventHandler(realButton, d);
	return d;
	}

	public string Text {
	set {
	types.button.textProperty.SetValue(realButton, value, null);
	}
	get {
	return (string) types.button.textProperty.GetValue(realButton, null);
	}
	}

	public Color TextColor {
	set {
	types.button.textColorProperty.SetValue(realButton, value, null);
	}
	get {
	return (Color) types.button.textColorProperty.GetValue(realButton, null);
	}
	}

	public string TexturePath {
	set {
	types.button.texturePathProperty.SetValue(realButton, value, null);
	}
	get {
	return (string) types.button.texturePathProperty.GetValue(realButton, null);
	}
	}

	public string ToolTip {
	set {
	types.button.toolTipProperty.SetValue(realButton, value, null);
	}
	get {
	return (string) types.button.toolTipProperty.GetValue(realButton, null);
	}
	}

	public bool Visible {
	set {
	types.button.visibleProperty.SetValue(realButton, value, null);
	}
	get {
	return (bool) types.button.visibleProperty.GetValue(realButton, null);
	}
	}

	public IVisibility Visibility {
	set {
	object functionVisibility = null;
	if (value != null) {
	functionVisibility = Activator.CreateInstance(types.functionVisibilityType, new object[] { new Func<bool>(() => value.Visible) });
	}
	types.button.visibilityProperty.SetValue(realButton, functionVisibility, null);
	visibility_ = value;
	}
	get {
	return visibility_;
	}
	}
	private IVisibility visibility_;

	public bool EffectivelyVisible {
	get {
	return (bool) types.button.effectivelyVisibleProperty.GetValue(realButton, null);
	}
	}

	public bool Enabled {
	set {
	types.button.enabledProperty.SetValue(realButton, value, null);
	}
	get {
	return (bool) types.button.enabledProperty.GetValue(realButton, null);
	}
	}

	public bool Important {
	set {
	types.button.importantProperty.SetValue(realButton, value, null);
	}
	get {
	return (bool) types.button.importantProperty.GetValue(realButton, null);
	}
	}

	public IDrawable Drawable {
	set {
	object functionDrawable = null;
	if (value != null) {
	functionDrawable = Activator.CreateInstance(types.functionDrawableType, new object[] {
	new Action(() => value.Update()),
	new Func<Vector2, Vector2>((pos) => value.Draw(pos))
	});
	}
	types.button.drawableProperty.SetValue(realButton, functionDrawable, null);
	drawable_ = value;
	}
	get {
	return drawable_;
	}
	}
	private IDrawable drawable_;

	public event ClickHandler OnClick;

	private void clicked(object realEvent) {
	if (OnClick != null) {
	OnClick(new ClickEvent(realEvent, this));
	}
	}

	public event MouseEnterHandler OnMouseEnter;

	private void mouseEntered(object realEvent) {
	if (OnMouseEnter != null) {
	OnMouseEnter(new MouseEnterEvent(this));
	}
	}

	public event MouseLeaveHandler OnMouseLeave;

	private void mouseLeft(object realEvent) {
	if (OnMouseLeave != null) {
	OnMouseLeave(new MouseLeaveEvent(this));
	}
	}

	public void Destroy() {
	detachEventHandler(types.button.onClickEvent, realClickHandler, realButton);
	detachEventHandler(types.button.onMouseEnterEvent, realMouseEnterHandler, realButton);
	detachEventHandler(types.button.onMouseLeaveEvent, realMouseLeaveHandler, realButton);

	types.button.destroyMethod.Invoke(realButton, null);
	}

	private void detachEventHandler(EventInfo @event, Delegate d, object realButton) {
	@event.RemoveEventHandler(realButton, d);
	}
	}

	public partial class ClickEvent : EventArgs {
	internal ClickEvent(object realEvent, IButton button) {
	Type type = realEvent.GetType();
	Button = button;
	MouseButton = (int) type.GetField("MouseButton", BindingFlags.Public \| BindingFlags.Instance).GetValue(realEvent);
	}
	}

	public abstract partial class MouseMoveEvent : EventArgs {
	internal MouseMoveEvent(IButton button) {
	this.button = button;
	}
	}

	public partial class MouseEnterEvent : MouseMoveEvent {
	internal MouseEnterEvent(IButton button)
	: base(button) {
	}
	}

	public partial class MouseLeaveEvent : MouseMoveEvent {
	internal MouseLeaveEvent(IButton button)
	: base(button) {
	}
	}

	internal class ToolbarTypes {
	internal readonly Type iToolbarManagerType;
	internal readonly Type functionVisibilityType;
	internal readonly Type functionDrawableType;

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

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

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

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

protected VOID_VesselRegister RegisterModule;	protected VOID_VesselRegister RegisterModule;

public VOID_Rendezvous()	public VOID_Rendezvous()
{	{