ToadGIT :: AntennaRange.git/commitdiff

Mostly comments and scope tweaks, some reorganization.

26 files changed: (show all)
.gitattributes (new)
ARConfiguration.cs (new)
ARFlightController.cs (new)
ARMapRenderer.cs (new)
ARTools.cs (deleted)
AntennaRange.cfg (deleted)
AntennaRange.csproj (new)
AntennaRelay.cs
Extensions.cs (deleted)
GameData/AntennaRange/ATM_AntennaRange.cfg (new)
GameData/AntennaRange/AntennaRange.cfg (new)
GameData/AntennaRange/Textures/appLauncherIcon.png (new)
GameData/AntennaRange/Textures/appLauncherIconNoConnection.png (new)
GameData/AntennaRange/Textures/appLauncherIconSubOptimal.png (new)
GameData/AntennaRange/Textures/toolbarIcon.png (new)
GameData/AntennaRange/Textures/toolbarIconNoConnection.png (new)
GameData/AntennaRange/Textures/toolbarIconSubOptimal.png (new)
IAntennaRelay.cs
ModuleLimitedDataTransmitter.cs
Properties/AssemblyInfo.cs
ProtoAntennaRelay.cs
RelayDatabase.cs
RelayExtensions.cs (new)
toolbarIcon.xcf (new)
toolbarIcon_24x24.xcf (new)
toolbarIcon_38x38.xcf (new)

file:b/.gitattributes (new)

	* text=auto
	* eol=lf

	# These files are text and should be normalized (convert crlf => lf)
	*.cs text diff=csharp
	*.cfg text
	*.csproj text
	*.sln text

	# Images should be treated as binary
	# (binary is a macro for -text -diff)
	*.png binary

file:b/ARConfiguration.cs (new)

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

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

	namespace AntennaRange
	{
	[KSPAddon(KSPAddon.Startup.SpaceCentre, false)]
	public class ARConfiguration : MonoBehaviour
	{
	public static bool RequireLineOfSight
	{
	get;
	private set;
	}

	public static double RadiusRatio
	{
	get;
	private set;
	}

	public static bool RequireConnectionForControl
	{
	get;
	private set;
	}

	public static bool FixedPowerCost
	{
	get;
	private set;
	}

	public static bool PrettyLines
	{
	get;
	private set;
	}

	private bool showConfigWindow;
	private Rect configWindowPos;

	private IButton toolbarButton;
	private ApplicationLauncherButton appLauncherButton;

	private System.Version runningVersion;

	private KSP.IO.PluginConfiguration _config;
	private KSP.IO.PluginConfiguration config
	{
	get
	{
	if (this._config == null)
	{
	this._config = KSP.IO.PluginConfiguration.CreateForType<AntennaRelay>();
	}

	return this._config;
	}
	}

	public void Awake()
	{
	Tools.PostDebugMessage(this, "Waking up.");

	this.runningVersion = this.GetType().Assembly.GetName().Version;

	this.showConfigWindow = false;
	this.configWindowPos = new Rect(Screen.width / 4, Screen.height / 2, 180, 15);


	this.configWindowPos = this.LoadConfigValue("configWindowPos", this.configWindowPos);

	ARConfiguration.RequireLineOfSight = this.LoadConfigValue("requireLineOfSight", false);

	ARConfiguration.RadiusRatio = (1 - this.LoadConfigValue("graceRatio", .05d));
	ARConfiguration.RadiusRatio *= ARConfiguration.RadiusRatio;

	ARConfiguration.RequireConnectionForControl =
	this.LoadConfigValue("requireConnectionForControl", false);

	ARConfiguration.FixedPowerCost = this.LoadConfigValue("fixedPowerCost", false);

	ARConfiguration.PrettyLines = this.LoadConfigValue("drawPrettyLines", true);

	GameEvents.onGameSceneLoadRequested.Add(this.onSceneChangeRequested);

	Debug.Log(string.Format("{0} v{1} - ARConfiguration loaded!", this.GetType().Name, this.runningVersion));

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

	public void OnGUI()
	{
	// Only runs once, if the Toolbar is available.
	if (ToolbarManager.ToolbarAvailable)
	{
	if (this.toolbarButton == null)
	{
	Tools.PostDebugMessage(this, "Toolbar available; initializing toolbar button.");

	this.toolbarButton = ToolbarManager.Instance.add("AntennaRange", "ARConfiguration");
	this.toolbarButton.Visibility = new GameScenesVisibility(GameScenes.SPACECENTER);
	this.toolbarButton.Text = "AR";
	this.toolbarButton.TexturePath = "AntennaRange/Textures/toolbarIcon";
	this.toolbarButton.TextColor = (Color)XKCDColors.Amethyst;
	this.toolbarButton.OnClick += delegate(ClickEvent e)
	{
	this.toggleConfigWindow();
	};
	}
	}
	else if (this.appLauncherButton == null && ApplicationLauncher.Ready)
	{
	Tools.PostDebugMessage(this, "Toolbar available; initializing AppLauncher button.");

	this.appLauncherButton = ApplicationLauncher.Instance.AddModApplication(
	this.toggleConfigWindow,
	this.toggleConfigWindow,
	ApplicationLauncher.AppScenes.SPACECENTER,
	GameDatabase.Instance.GetTexture(
	"AntennaRange/Textures/appLauncherIcon",
	false
	)
	);
	}

	if (this.showConfigWindow)
	{
	Rect configPos = GUILayout.Window(354163056,
	this.configWindowPos,
	this.ConfigWindow,
	string.Format("AntennaRange {0}.{1}", this.runningVersion.Major, this.runningVersion.Minor),
	GUILayout.ExpandHeight(true),
	GUILayout.ExpandWidth(true)
	);

	configPos = Tools.ClampRectToScreen(configPos, 20);

	if (configPos != this.configWindowPos)
	{
	this.configWindowPos = configPos;
	this.SaveConfigValue("configWindowPos", this.configWindowPos);
	}
	}
	}

	public void ConfigWindow(int _)
	{
	GUILayout.BeginVertical(GUILayout.ExpandHeight(true));

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

	bool requireLineOfSight = GUITools.Toggle(ARConfiguration.RequireLineOfSight, "Require Line of Sight");
	if (requireLineOfSight != ARConfiguration.RequireLineOfSight)
	{
	ARConfiguration.RequireLineOfSight = requireLineOfSight;
	this.SaveConfigValue("requireLineOfSight", requireLineOfSight);
	}

	GUILayout.EndHorizontal();

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

	bool requireConnectionForControl =
	GUITools.Toggle(
	ARConfiguration.RequireConnectionForControl,
	"Require Connection for Probe Control"
	);
	if (requireConnectionForControl != ARConfiguration.RequireConnectionForControl)
	{
	ARConfiguration.RequireConnectionForControl = requireConnectionForControl;
	this.SaveConfigValue("requireConnectionForControl", requireConnectionForControl);
	}

	GUILayout.EndHorizontal();

	GUILayout.BeginHorizontal();

	bool fixedPowerCost = GUITools.Toggle(ARConfiguration.FixedPowerCost, "Use Fixed Power Cost");
	if (fixedPowerCost != ARConfiguration.FixedPowerCost)
	{
	ARConfiguration.FixedPowerCost = fixedPowerCost;
	this.SaveConfigValue("fixedPowerCost", fixedPowerCost);
	}

	GUILayout.EndHorizontal();

	GUILayout.BeginHorizontal();

	bool prettyLines = GUITools.Toggle(ARConfiguration.PrettyLines, "Draw Pretty Lines");
	if (prettyLines != ARConfiguration.PrettyLines)
	{
	ARConfiguration.PrettyLines = prettyLines;
	this.SaveConfigValue("drawPrettyLines", prettyLines);
	}

	GUILayout.EndHorizontal();

	if (requireLineOfSight)
	{
	GUILayout.BeginHorizontal();

	double graceRatio = 1d - Math.Sqrt(ARConfiguration.RadiusRatio);
	double newRatio;

	GUILayout.Label(string.Format("Line of Sight 'Fudge Factor': {0:P0}", graceRatio));

	GUILayout.EndHorizontal();

	GUILayout.BeginHorizontal();

	newRatio = GUILayout.HorizontalSlider((float)graceRatio, 0f, 1f, GUILayout.ExpandWidth(true));
	newRatio = Math.Round(newRatio, 2);

	if (newRatio != graceRatio)
	{
	ARConfiguration.RadiusRatio = (1d - newRatio) * (1d - newRatio);
	this.SaveConfigValue("graceRatio", newRatio);
	}

	GUILayout.EndHorizontal();
	}

	GUILayout.EndVertical();

	GUI.DragWindow();
	}

	public void OnDestroy()
	{
	GameEvents.onGameSceneLoadRequested.Remove(this.onSceneChangeRequested);

	if (this.toolbarButton != null)
	{
	this.toolbarButton.Destroy();
	}

	if (this.appLauncherButton != null)
	{
	ApplicationLauncher.Instance.RemoveModApplication(this.appLauncherButton);
	}
	}

	protected void onSceneChangeRequested(GameScenes scene)
	{
	if (scene != GameScenes.SPACECENTER)
	{
	print("ARConfiguration: Requesting Destruction.");
	MonoBehaviour.Destroy(this);
	}
	}

	private void toggleConfigWindow()
	{
	this.showConfigWindow = !this.showConfigWindow;
	}

	private T LoadConfigValue<T>(string key, T defaultValue)
	{
	this.config.load();

	return config.GetValue(key, defaultValue);
	}

	private void SaveConfigValue<T>(string key, T value)
	{
	this.config.load();

	this.config.SetValue(key, value);

	this.config.save();
	}
	}
	}

file:b/ARFlightController.cs (new)

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

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

	namespace AntennaRange
	{
	[KSPAddon(KSPAddon.Startup.Flight, false)]
	public class ARFlightController : MonoBehaviour
	{
	#region Fields
	protected Dictionary<ConnectionStatus, string> connectionTextures;
	protected Dictionary<ConnectionStatus, Texture> appLauncherTextures;

	protected ARMapRenderer mapRenderer;

	protected IButton toolbarButton;

	protected ApplicationLauncherButton appLauncherButton;
	protected Tools.DebugLogger log;

	protected System.Diagnostics.Stopwatch updateTimer;
	#endregion

	#region Properties
	public ConnectionStatus currentConnectionStatus
	{
	get;
	protected set;
	}

	protected string currentConnectionTexture
	{
	get
	{
	return this.connectionTextures[this.currentConnectionStatus];
	}
	}

	protected Texture currentAppLauncherTexture
	{
	get
	{
	return this.appLauncherTextures[this.currentConnectionStatus];
	}
	}

	public ControlTypes currentControlLock
	{
	get
	{
	if (this.lockID == string.Empty)
	{
	return ControlTypes.None;
	}

	return InputLockManager.GetControlLock(this.lockID);
	}
	}

	public string lockID
	{
	get;
	protected set;
	}

	public ControlTypes lockSet
	{
	get
	{
	return ControlTypes.ALL_SHIP_CONTROLS;
	}
	}

	public Vessel vessel
	{
	get
	{
	if (FlightGlobals.ready && FlightGlobals.ActiveVessel != null)
	{
	return FlightGlobals.ActiveVessel;
	}

	return null;
	}
	}
	#endregion

	#region MonoBehaviour LifeCycle
	protected void Awake()
	{
	this.lockID = "ARConnectionRequired";

	this.log = Tools.DebugLogger.New(this);

	this.updateTimer = new System.Diagnostics.Stopwatch();

	this.connectionTextures = new Dictionary<ConnectionStatus, string>();

	this.connectionTextures[ConnectionStatus.None] = "AntennaRange/Textures/toolbarIconNoConnection";
	this.connectionTextures[ConnectionStatus.Suboptimal] = "AntennaRange/Textures/toolbarIconSubOptimal";
	this.connectionTextures[ConnectionStatus.Optimal] = "AntennaRange/Textures/toolbarIcon";

	this.appLauncherTextures = new Dictionary<ConnectionStatus, Texture>();

	this.appLauncherTextures[ConnectionStatus.None] =
	GameDatabase.Instance.GetTexture("AntennaRange/Textures/appLauncherIconNoConnection", false);
	this.appLauncherTextures[ConnectionStatus.Suboptimal] =
	GameDatabase.Instance.GetTexture("AntennaRange/Textures/appLauncherIconSubOptimal", false);
	this.appLauncherTextures[ConnectionStatus.Optimal] =
	GameDatabase.Instance.GetTexture("AntennaRange/Textures/appLauncherIcon", false);

	if (ToolbarManager.ToolbarAvailable)
	{
	this.toolbarButton = ToolbarManager.Instance.add("AntennaRange", "ARConnectionStatus");

	this.toolbarButton.TexturePath = this.connectionTextures[ConnectionStatus.None];
	this.toolbarButton.Text = "AntennaRange";
	this.toolbarButton.Visibility = new GameScenesVisibility(GameScenes.FLIGHT);
	this.toolbarButton.Enabled = false;
	}

	GameEvents.onGameSceneLoadRequested.Add(this.onSceneChangeRequested);
	GameEvents.onVesselChange.Add(this.onVesselChange);
	}

	protected void Start()
	{
	this.mapRenderer = MapView.MapCamera.gameObject.AddComponent<ARMapRenderer>();
	}

	protected void FixedUpdate()
	{
	if (this.appLauncherButton == null && !ToolbarManager.ToolbarAvailable && ApplicationLauncher.Ready)
	{
	this.appLauncherButton = ApplicationLauncher.Instance.AddModApplication(
	ApplicationLauncher.AppScenes.FLIGHT,
	this.appLauncherTextures[ConnectionStatus.None]
	);
	}

	this.log.Clear();

	VesselCommand availableCommand;

	if (ARConfiguration.RequireConnectionForControl)
	{
	availableCommand = this.vessel.CurrentCommand();
	}
	else
	{
	availableCommand = VesselCommand.Crew;
	}

	log.AppendFormat("availableCommand: {0}\n\t" +
	"(availableCommand & VesselCommand.Crew) == VesselCommand.Crew: {1}\n\t" +
	"(availableCommand & VesselCommand.Probe) == VesselCommand.Probe: {2}\n\t" +
	"vessel.HasConnectedRelay(): {3}",
	(int)availableCommand,
	(availableCommand & VesselCommand.Crew) == VesselCommand.Crew,
	(availableCommand & VesselCommand.Probe) == VesselCommand.Probe,
	vessel.HasConnectedRelay()
	);

	// If we are requiring a connection for control, the vessel does not have any adequately staffed pods,
	// and the vessel does not have any connected relays...
	if (
	HighLogic.LoadedSceneIsFlight &&
	ARConfiguration.RequireConnectionForControl &&
	this.vessel != null &&
	this.vessel.vesselType != VesselType.EVA &&
	!(
	(availableCommand & VesselCommand.Crew) == VesselCommand.Crew \|\|
	(availableCommand & VesselCommand.Probe) == VesselCommand.Probe && vessel.HasConnectedRelay()
	))
	{
	// ...and if the controls are not currently locked...
	if (currentControlLock == ControlTypes.None)
	{
	// ...lock the controls.
	InputLockManager.SetControlLock(this.lockSet, this.lockID);
	}
	}
	// ...otherwise, if the controls are locked...
	else if (currentControlLock != ControlTypes.None)
	{
	// ...unlock the controls.
	InputLockManager.RemoveControlLock(this.lockID);
	}

	log.Print();
	}

	protected void Update()
	{
	if (!this.updateTimer.IsRunning \|\| this.updateTimer.ElapsedMilliseconds > 125L)
	{
	this.updateTimer.Reset();
	}
	else
	{
	return;
	}

	this.log.Clear();

	if (
	(this.toolbarButton != null \|\| this.appLauncherButton != null) &&
	HighLogic.LoadedSceneIsFlight &&
	FlightGlobals.ActiveVessel != null
	)
	{
	log.Append("Checking vessel relay status.\n");

	this.currentConnectionStatus = FlightGlobals.ActiveVessel.GetConnectionStatus();

	log.AppendFormat("currentConnectionStatus: {0}, setting texture to {1}",
	this.currentConnectionStatus, this.currentConnectionTexture);

	if (this.toolbarButton != null)
	{
	this.toolbarButton.TexturePath = this.currentConnectionTexture;

	if (this.currentConnectionStatus == ConnectionStatus.None)
	{
	this.toolbarButton.Important = true;
	}
	else
	{
	this.toolbarButton.Important = false;
	}
	}
	if (this.appLauncherButton != null)
	{
	this.appLauncherButton.SetTexture(this.currentAppLauncherTexture);
	}
	}

	log.Print();
	}

	protected void OnDestroy()
	{
	InputLockManager.RemoveControlLock(this.lockID);

	if (this.mapRenderer != null)
	{
	GameObject.Destroy(this.mapRenderer);
	}

	if (this.toolbarButton != null)
	{
	this.toolbarButton.Destroy();
	}

	if (this.appLauncherButton != null)
	{
	ApplicationLauncher.Instance.RemoveModApplication(this.appLauncherButton);
	this.appLauncherButton = null;
	}

	GameEvents.onGameSceneLoadRequested.Remove(this.onSceneChangeRequested);
	GameEvents.onVesselChange.Remove(this.onVesselChange);

	print("ARFlightController: Destroyed.");
	}
	#endregion

	#region Event Handlers
	protected void onSceneChangeRequested(GameScenes scene)
	{
	print("ARFlightController: Requesting Destruction.");
	MonoBehaviour.Destroy(this);
	}

	protected void onVesselChange(Vessel vessel)
	{
	InputLockManager.RemoveControlLock(this.lockID);
	}
	#endregion
	}
	}

file:b/ARMapRenderer.cs (new)

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

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

	namespace AntennaRange
	{
	public class ARMapRenderer : MonoBehaviour
	{
	#region Fields
	private Dictionary<Guid, LineRenderer> vesselLineRenderers;
	#endregion

	#region Properties
	public LineRenderer this[Guid idx]
	{
	get
	{
	if (this.vesselLineRenderers == null)
	{
	this.vesselLineRenderers = new Dictionary<Guid, LineRenderer>();
	}

	if (!this.vesselLineRenderers.ContainsKey(idx))
	{
	GameObject obj = new GameObject();
	obj.layer = 31;

	LineRenderer lr = obj.AddComponent<LineRenderer>();

	lr.SetColors(Color.green, Color.green);
	lr.material = MapView.OrbitLinesMaterial;
	lr.SetVertexCount(2);

	this.vesselLineRenderers[idx] = lr;
	}

	return this.vesselLineRenderers[idx];
	}
	}
	#endregion

	#region MonoBehaviour Lifecycle
	private void Awake()
	{
	if (ARConfiguration.PrettyLines)
	{
	this.vesselLineRenderers = new Dictionary<Guid, LineRenderer>();
	}
	}

	private void OnPreCull()
	{
	if (!HighLogic.LoadedSceneIsFlight \|\| !MapView.MapIsEnabled \|\| !ARConfiguration.PrettyLines)
	{
	this.Cleanup();

	return;
	}

	Tools.DebugLogger log = Tools.DebugLogger.New(this);

	try
	{
	log.AppendFormat("OnPreCull.\n");

	log.AppendFormat("\tMapView: Draw3DLines: {0}\n" +
	"\tMapView.MapCamera.camera.fieldOfView: {1}\n" +
	"\tMapView.MapCamera.Distance: {2}\n",
	MapView.Draw3DLines,
	MapView.MapCamera.camera.fieldOfView,
	MapView.MapCamera.Distance
	);

	log.AppendLine("vesselFrameCache cleared.");

	if (FlightGlobals.ready && FlightGlobals.Vessels != null)
	{
	log.AppendLine("FlightGlobals ready and Vessels list not null.");

	foreach (Vessel vessel in FlightGlobals.Vessels)
	{
	if (vessel == null)
	{
	log.AppendFormat("Skipping vessel {0} altogether because it is null.\n");
	continue;
	}

	log.AppendFormat("Checking vessel {0}.\n", vessel.vesselName);

	switch (vessel.vesselType)
	{
	case VesselType.Debris:
	case VesselType.EVA:
	case VesselType.Unknown:
	case VesselType.SpaceObject:
	log.AppendFormat("\tDiscarded because vessel is of invalid type {0}\n",
	vessel.vesselType);
	continue;
	}

	IAntennaRelay vesselRelay = vessel.GetBestRelay();

	if (vesselRelay != null)
	{
	this.SetRelayVertices(vesselRelay);
	}
	}
	}
	}
	catch (Exception)
	{
	this.Cleanup();
	}
	#if DEBUG
	finally
	{
	log.Print();
	}
	#endif
	}

	private void OnDestroy()
	{
	this.Cleanup();

	print("ARMapRenderer: Destroyed.");
	}
	#endregion

	private void SetRelayVertices(IAntennaRelay relay)
	{
	if (relay == null)
	{
	return;
	}

	LineRenderer renderer = this[relay.vessel.id];

	Vector3d start;
	Vector3d end;

	renderer.enabled = true;

	if (!relay.CanTransmit())
	{
	renderer.SetColors(Color.red, Color.red);
	}
	else
	{
	if (relay.transmitDistance < relay.nominalTransmitDistance)
	{
	renderer.SetColors(Color.green, Color.green);
	}
	else
	{
	renderer.SetColors(Color.yellow, Color.yellow);
	}
	}

	start = ScaledSpace.LocalToScaledSpace(relay.vessel.GetWorldPos3D());

	if (relay.KerbinDirect)
	{
	end = ScaledSpace.LocalToScaledSpace(AntennaRelay.Kerbin.position);
	}
	else
	{
	if (relay.targetRelay == null)
	{
	return;
	}
	end = ScaledSpace.LocalToScaledSpace(relay.targetRelay.vessel.GetWorldPos3D());
	}

	float lineWidth;

	if (MapView.Draw3DLines)
	{
	lineWidth = 0.005859375f * MapView.MapCamera.Distance;
	}
	else
	{
	lineWidth = 2f;

	start = MapView.MapCamera.camera.WorldToScreenPoint(start);
	end = MapView.MapCamera.camera.WorldToScreenPoint(end);

	float d = Screen.height / 2f + 0.01f;
	start.z = start.z >= 0f ? d : -d;
	end.z = end.z >= 0f ? d : -d;
	}

	renderer.SetWidth(lineWidth, lineWidth);

	renderer.SetPosition(0, start);
	renderer.SetPosition(1, end);
	}

	public void Cleanup()
	{
	if (this.vesselLineRenderers != null && this.vesselLineRenderers.Count > 0)
	{
	foreach (LineRenderer lineRenderer in this.vesselLineRenderers.Values)
	{
	lineRenderer.enabled = false;
	GameObject.Destroy(lineRenderer.gameObject);
	}
	this.vesselLineRenderers.Clear();
	}
	}
	}
	}

file:a/ARTools.cs (deleted)

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

using System;

namespace AntennaRange
{
public static class Tools
{
private static ScreenMessage debugmsg = new ScreenMessage("", 2f, ScreenMessageStyle.UPPER_RIGHT);
// Function that posts messages to the screen and the log when DEBUG is defined.
[System.Diagnostics.Conditional("DEBUG")]
public static void PostDebugMessage(string Msg)
{
if (HighLogic.LoadedScene > GameScenes.SPACECENTER)
{
debugmsg.message = Msg;
ScreenMessages.PostScreenMessage(debugmsg, true);
}

KSPLog.print(Msg);
}

/*
* MuMech_ToSI is a part of the MuMechLib library, © 2013 r4m0n, used under the GNU GPL version 3.
* */
public static string MuMech_ToSI(double d, int digits = 3, int MinMagnitude = 0, int MaxMagnitude = int.MaxValue)
{
float exponent = (float)Math.Log10(Math.Abs(d));
exponent = UnityEngine.Mathf.Clamp(exponent, (float)MinMagnitude, (float)MaxMagnitude);

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

public static T Min<T>(params T[] values) where T : IComparable<T>
{
if (values.Length < 2)
{
throw new ArgumentException("Min must be called with at least two arguments.");
}

IComparable<T> minValue = values[0];

for (long i = 1; i < values.LongLength; i++)
{
IComparable<T> value = values[i];

if (value.CompareTo((T)minValue) < 0)
{
minValue = value;
}
}

return (T)minValue;
}

public static void Restart(this System.Diagnostics.Stopwatch stopwatch)
{
stopwatch.Reset();
stopwatch.Start();
}
}
}

file:a/AntennaRange.cfg (deleted)

// AntennaRange
//
// AntennaRange.cfg
//
// Copyright © 2014, toadicus
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// to endorse or promote products derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// This software uses the ModuleManager library © 2013 ialdabaoth, used under a Creative Commons Attribution-ShareAlike
// 3.0 Uported License.
//
// Specifications:
// nominalRange: The distance from Kerbin at which the antenna will perform exactly as prescribed by
// packetResourceCost and packetSize.
// maxPowerFactor: The multiplier on packetResourceCost that defines the maximum power output of the antenna. When the
// power cost exceeds packetResourceCost * maxPowerFactor, transmission will fail.
// maxDataFactor: The multipler on packetSize that defines the maximum data bandwidth of the antenna.
//

@PART[longAntenna]
{
@MODULE[ModuleDataTransmitter]
{
@name = ModuleLimitedDataTransmitter
nominalRange = 1500000
maxPowerFactor = 8
maxDataFactor = 4
}
}

@PART[mediumDishAntenna]
{
@MODULE[ModuleDataTransmitter]
{
@name = ModuleLimitedDataTransmitter
nominalRange = 30000000
maxPowerFactor = 8
maxDataFactor = 4
}
}

@PART[commDish]
{
@MODULE[ModuleDataTransmitter]
{
@name = ModuleLimitedDataTransmitter
nominalRange = 80000000000
maxPowerFactor = 8
maxDataFactor = 4
}
}

file:b/AntennaRange.csproj (new)

	<?xml version="1.0" encoding="utf-8"?>
	<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
	<PropertyGroup>
	<Configuration Condition=" '$(Configuration)' == '' ">Debug_win</Configuration>
	<Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
	<ProductVersion>8.0.30703</ProductVersion>
	<SchemaVersion>2.0</SchemaVersion>
	<ProjectGuid>{B36F2C11-962E-4A75-9F41-61AD56D11493}</ProjectGuid>
	<OutputType>Library</OutputType>
	<RootNamespace>AntennaRange</RootNamespace>
	<AssemblyName>AntennaRange</AssemblyName>
	<ReleaseVersion>1.3</ReleaseVersion>
	<SynchReleaseVersion>false</SynchReleaseVersion>
	<TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
	<UseMSBuildEngine>False</UseMSBuildEngine>
	</PropertyGroup>
	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Debug_win\|AnyCPU' ">
	<DebugSymbols>true</DebugSymbols>
	<DebugType>full</DebugType>
	<Optimize>false</Optimize>
	<OutputPath>bin\Debug</OutputPath>
	<DefineConstants>DEBUG;TRACE;</DefineConstants>
	<ErrorReport>prompt</ErrorReport>
	<WarningLevel>4</WarningLevel>
	<ConsolePause>false</ConsolePause>
	<CustomCommands>
	<CustomCommands>
	<Command type="AfterBuild" command="xcopy /y ${TargetFile} ${ProjectDir}\GameData\AntennaRange\" />
	</CustomCommands>
	</CustomCommands>
	</PropertyGroup>
	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Release_win\|AnyCPU' ">
	<Optimize>true</Optimize>
	<OutputPath>bin\Release</OutputPath>
	<ErrorReport>prompt</ErrorReport>
	<WarningLevel>4</WarningLevel>
	<ConsolePause>false</ConsolePause>
	<CustomCommands>
	<CustomCommands>
	<Command type="AfterBuild" command="xcopy /y ${TargetFile} ${ProjectDir}\GameData\AntennaRange\" />
	</CustomCommands>
	</CustomCommands>
	</PropertyGroup>
	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Debug_linux\|AnyCPU' ">
	<DebugSymbols>true</DebugSymbols>
	<DebugType>full</DebugType>
	<Optimize>false</Optimize>
	<OutputPath>bin\Debug</OutputPath>
	<DefineConstants>DEBUG;TRACE;</DefineConstants>
	<ErrorReport>prompt</ErrorReport>
	<WarningLevel>4</WarningLevel>
	<ConsolePause>false</ConsolePause>
	<CustomCommands>
	<CustomCommands>
	<Command type="AfterBuild" command="cp -afv ${TargetFile} ${ProjectDir}/GameData/${ProjectName}/" />
	</CustomCommands>
	</CustomCommands>
	</PropertyGroup>
	<PropertyGroup Condition=" '$(Configuration)\|$(Platform)' == 'Release_linux\|AnyCPU' ">
	<Optimize>true</Optimize>
	<OutputPath>bin\Release</OutputPath>
	<ErrorReport>prompt</ErrorReport>
	<WarningLevel>4</WarningLevel>
	<CustomCommands>
	<CustomCommands>
	<Command type="AfterBuild" command="cp -afv ${TargetFile} ${ProjectDir}/GameData/${ProjectName}/" />
	</CustomCommands>
	</CustomCommands>
	<ConsolePause>false</ConsolePause>
	</PropertyGroup>
	<ItemGroup>
	<Compile Include="Properties\AssemblyInfo.cs" />
	<Compile Include="IAntennaRelay.cs" />
	<Compile Include="ModuleLimitedDataTransmitter.cs" />
	<Compile Include="AntennaRelay.cs" />
	<Compile Include="ProtoAntennaRelay.cs" />
	<Compile Include="RelayDatabase.cs" />
	<Compile Include="RelayExtensions.cs" />
	<Compile Include="ARConfiguration.cs" />
	<Compile Include="ARFlightController.cs" />
	<Compile Include="ARMapRenderer.cs" />
	</ItemGroup>
	<Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" />
	<ItemGroup>
	<Reference Include="Assembly-CSharp">
	<HintPath>..\_KSPAssemblies\Assembly-CSharp.dll</HintPath>
	<Private>False</Private>
	</Reference>
	<Reference Include="System">
	<HintPath>..\_KSPAssemblies\System.dll</HintPath>
	<Private>False</Private>
	</Reference>
	<Reference Include="UnityEngine">
	<HintPath>..\_KSPAssemblies\UnityEngine.dll</HintPath>
	<Private>False</Private>
	</Reference>
	</ItemGroup>
	<ItemGroup>
	<ProjectReference Include="..\ToadicusTools\ToadicusTools.csproj">
	<Project>{D48A5542-6655-4149-BC27-B27DF0466F1C}</Project>
	<Name>ToadicusTools</Name>
	</ProjectReference>
	</ItemGroup>
	<ItemGroup>
	<None Include="GameData\AntennaRange\AntennaRange.cfg" />
	<None Include="GameData\AntennaRange\ATM_AntennaRange.cfg" />
	</ItemGroup>
	</Project>

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

// AntennaRange	// AntennaRange
//	//
// AntennaRelay.cs	// AntennaRelay.cs
//	//
// Copyright © 2014, toadicus	// Copyright © 2014, toadicus
// All rights reserved.	// All rights reserved.
//	//
// Redistribution and use in source and binary forms, with or without modification,	// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:	// are permitted provided that the following conditions are met:
//	//
// 1. Redistributions of source code must retain the above copyright notice,	// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.	// this list of conditions and the following disclaimer.
//	//
// 2. Redistributions in binary form must reproduce the above copyright notice,	// 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	// this list of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.	// materials provided with the distribution.
//	//
// 3. Neither the name of the copyright holder nor the names of its contributors may be used	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// to endorse or promote products derived from this software without specific prior written permission.	// to endorse or promote products derived from this software without specific prior written permission.
//	//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,	// 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	// 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,	// 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	// 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,	// 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	// 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.	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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

namespace AntennaRange	namespace AntennaRange
{	{
	/// <summary>
	/// Relay code at the heart of AntennaRange
	/// </summary>
public class AntennaRelay	public class AntennaRelay
{	{
// We don't have a Bard, so we'll hide Kerbin here.	// We don't have a Bard, so we'll hide Kerbin here.
protected CelestialBody Kerbin;	private static CelestialBody _Kerbin;

protected IAntennaRelay _nearestRelayCache;	/// <summary>
	/// Fetches, caches, and returns a <see cref="CelestialBody"/> reference to Kerbin
	/// </summary>
	public static CelestialBody Kerbin
	{
	get
	{
	if (_Kerbin == null && FlightGlobals.ready)
	{
	_Kerbin = FlightGlobals.GetHomeBody();
	}

	return _Kerbin;
	}
	}

	private bool canTransmit;

	private IAntennaRelay nearestRelay;
	private IAntennaRelay bestOccludedRelay;

	private System.Diagnostics.Stopwatch searchTimer;
	private long millisecondsBetweenSearches;

	/// <summary>
	/// The <see cref="AntennaRange.ModuleLimitedDataTransmitter"/> reference underlying this AntennaRelay, as an
	/// <see cref="AntennaRange.IAntennaRelay"/>
	/// </summary>
protected IAntennaRelay moduleRef;	protected IAntennaRelay moduleRef;

protected System.Diagnostics.Stopwatch searchTimer;
protected long millisecondsBetweenSearches;

/// <summary>	/// <summary>
/// Gets the parent Vessel.	/// Gets the parent Vessel.
/// </summary>	/// </summary>
/// <value>The parent Vessel.</value>	/// <value>The parent Vessel.</value>
public virtual Vessel vessel	public virtual Vessel vessel
{	{
get	get
{	{
return this.moduleRef.vessel;	return this.moduleRef.vessel;
}	}
}	}

/// <summary>	/// <summary>
/// Gets or sets the nearest relay.	/// Gets the target <see cref="AntennaRange.IAntennaRelay"/>relay.
/// </summary>	/// </summary>
/// <value>The nearest relay</value>	public IAntennaRelay targetRelay
public IAntennaRelay nearestRelay	{
{	get;
get	protected set;
{	}
if (this.searchTimer.IsRunning &&
this.searchTimer.ElapsedMilliseconds > this.millisecondsBetweenSearches)	/// <summary>
{	/// Gets the first <see cref="CelestialBody"/> found to be blocking line of sight.
this._nearestRelayCache = this.FindNearestRelay();	/// </summary>
this.searchTimer.Restart();	public virtual CelestialBody firstOccludingBody
}	{
	get;
return this._nearestRelayCache;	protected set;
}
protected set
{
this._nearestRelayCache = value;
}
}	}

/// <summary>	/// <summary>
/// Gets the transmit distance.	/// Gets the transmit distance.
/// </summary>	/// </summary>
/// <value>The transmit distance.</value>	/// <value>The transmit distance.</value>
public double transmitDistance	public double transmitDistance
{	{
get	get
{	{
this.nearestRelay = this.FindNearestRelay();	this.FindNearestRelay();

// If there is no available relay nearby...	if (this.KerbinDirect \|\| this.targetRelay == null)
if (this.nearestRelay == null)	{
{	return this.DistanceTo(Kerbin);
// .. return the distance to Kerbin
return this.DistanceTo(this.Kerbin);
}	}
else	else
{	{
/// ...otherwise, return the distance to the nearest available relay.	return this.DistanceTo(this.targetRelay);
return this.DistanceTo(nearestRelay);	}
}	}
}	}
}
	/// <summary>
/// <summary>	/// Gets the nominal transmit distance at which the Antenna behaves just as prescribed by Squad's config.
/// The maximum distance at which this relay can operate.	/// </summary>
/// </summary>	public virtual double nominalTransmitDistance
/// <value>The max transmit distance.</value>
public virtual float maxTransmitDistance
{	{
get;	get;
set;	set;
}	}

/// <summary>	/// <summary>
/// Gets a value indicating whether this <see cref="AntennaRange.ProtoDataTransmitter"/> has been checked during	/// The maximum distance at which this relay can operate.
/// the current relay attempt.	/// </summary>
/// </summary>	/// <value>The max transmit distance.</value>
/// <value><c>true</c> if relay checked; otherwise, <c>false</c>.</value>	public virtual double maxTransmitDistance
public virtual bool relayChecked	{
	get;
	set;
	}

	/// <summary>
	/// Gets a value indicating whether this <see cref="AntennaRange.IAntennaRelay"/> Relay is communicating
	/// directly with Kerbin.
	/// </summary>
	public virtual bool KerbinDirect
{	{
get;	get;
protected set;	protected set;
}	}

/// <summary>	/// <summary>
/// Determines whether this instance can transmit.	/// Determines whether this instance can transmit.
/// </summary>	/// </summary>
/// <returns><c>true</c> if this instance can transmit; otherwise, <c>false</c>.</returns>	/// <returns><c>true</c> if this instance can transmit; otherwise, <c>false</c>.</returns>
public virtual bool CanTransmit()	public virtual bool CanTransmit()
{	{
if (this.transmitDistance > this.maxTransmitDistance)	this.FindNearestRelay();
{	return this.canTransmit;
return false;	}

	/// <summary>
	/// Finds the nearest relay.
	/// </summary>
	/// <returns>The nearest relay or null, if no relays in range.</returns>
	private void FindNearestRelay()
	{
	if (!this.searchTimer.IsRunning \|\| this.searchTimer.ElapsedMilliseconds > this.millisecondsBetweenSearches)
	{
	this.searchTimer.Reset();
}	}
else	else
{	{
return true;	return;
}	}
}
	// Skip vessels that have already been checked for a nearest relay this pass.
/// <summary>	if (RelayDatabase.Instance.CheckedVesselsTable.ContainsKey(this.vessel.id))
/// Finds the nearest relay.	{
/// </summary>	return;
/// <returns>The nearest relay or null, if no relays in range.</returns>	}
public IAntennaRelay FindNearestRelay()
{	if (FlightGlobals.ActiveVessel != null && FlightGlobals.ActiveVessel.id == this.vessel.id)
if (this.searchTimer.IsRunning && this.searchTimer.ElapsedMilliseconds < this.millisecondsBetweenSearches)	{
{	Tools.PostDebugMessage(string.Format(
return this.nearestRelay;	"{0}: finding nearest relay for {1}",
}	this.GetType().Name,
	this.ToString()
if (this.searchTimer.IsRunning)	));
{	}
this.searchTimer.Stop();
this.searchTimer.Reset();
}

this.searchTimer.Start();

Tools.PostDebugMessage(string.Format(
"{0}: finding nearest relay for {1} ({2})",
this.GetType().Name,
this,
this.vessel.id
));

// Set this vessel as checked, so that we don't check it again.	// Set this vessel as checked, so that we don't check it again.
RelayDatabase.Instance.CheckedVesselsTable[vessel.id] = true;	RelayDatabase.Instance.CheckedVesselsTable[vessel.id] = true;

double nearestDistance = double.PositiveInfinity;	// Blank everything we're trying to find before the search.
IAntennaRelay _nearestRelay = null;	this.firstOccludingBody = null;
	this.bestOccludedRelay = null;
	this.targetRelay = null;
	this.nearestRelay = null;

	CelestialBody bodyOccludingBestOccludedRelay = null;

	double nearestRelaySqrDistance = double.PositiveInfinity;
	double bestOccludedSqrDistance = double.PositiveInfinity;
	double maxTransmitSqrDistance = this.maxTransmitDistance * this.maxTransmitDistance;

/*	/*
* Loop through all the vessels and exclude this vessel, vessels of the wrong type, and vessels that are too	* Loop through all the vessels and exclude this vessel, vessels of the wrong type, and vessels that are too
* far away. When we find a candidate, get through its antennae for relays which have not been checked yet	* far away. When we find a candidate, get through its antennae for relays which have not been checked yet
* and that can transmit. Once we find a suitable candidate, assign it to _nearestRelay for comparison	* and that can transmit. Once we find a suitable candidate, assign it to nearestRelay for comparison
* against future finds.	* against future finds.
* */	* */
foreach (Vessel potentialVessel in FlightGlobals.Vessels)	foreach (Vessel potentialVessel in FlightGlobals.Vessels)
{	{
// Skip vessels that have already been checked for a nearest relay this pass.
try
{
if (RelayDatabase.Instance.CheckedVesselsTable[potentialVessel.id])
{
continue;
}
}
catch (KeyNotFoundException) { /* If the key doesn't exist, don't skip it. */}

// Skip vessels of the wrong type.	// Skip vessels of the wrong type.
switch (potentialVessel.vesselType)	switch (potentialVessel.vesselType)
{	{
case VesselType.Debris:	case VesselType.Debris:
case VesselType.Flag:	case VesselType.Flag:
case VesselType.EVA:	case VesselType.EVA:
case VesselType.SpaceObject:	case VesselType.SpaceObject:
case VesselType.Unknown:	case VesselType.Unknown:
continue;	continue;
default:	default:
break;	break;
}	}

// Skip vessels with the wrong ID	// Skip vessels with the wrong ID
if (potentialVessel.id == vessel.id)	if (potentialVessel.id == vessel.id)
{	{
continue;	continue;
}	}

// Find the distance from here to the vessel...	// Find the distance from here to the vessel...
double potentialDistance = (potentialVessel.GetWorldPos3D() - vessel.GetWorldPos3D()).magnitude;	double potentialSqrDistance = this.sqrDistanceTo(potentialVessel);

	CelestialBody fob = null;

	// Skip vessels to which we do not have line of sight.
	if (
	ARConfiguration.RequireLineOfSight &&
	!this.vessel.hasLineOfSightTo(potentialVessel, out fob, ARConfiguration.RadiusRatio)
	)
	{
	this.firstOccludingBody = fob;

	if (FlightGlobals.ActiveVessel != null && FlightGlobals.ActiveVessel.id == this.vessel.id)
	{
	Tools.PostDebugMessage("{6}: Vessel {0} discarded because we do not have line of sight." +
	"\npotentialSqrDistance: {1}, bestOccludedSqrDistance: {2}, maxTransmitSqrDistance: {3}" +
	"\npotentialSqrDistance < bestOccludedSqrDistance: {4}" +
	"\npotentialSqrDistance < (this.maxTransmitDistance * this.maxTransmitDistance): {5}",
	potentialVessel.vesselName,
	potentialSqrDistance, bestOccludedSqrDistance, this.maxTransmitDistance * this.maxTransmitDistance,
	potentialSqrDistance < bestOccludedSqrDistance,
	potentialSqrDistance < (this.maxTransmitDistance * this.maxTransmitDistance),
	this.ToString()
	);
	}

	if (
	(potentialSqrDistance < bestOccludedSqrDistance) &&
	(potentialSqrDistance < maxTransmitSqrDistance)
	)
	{
	if (FlightGlobals.ActiveVessel != null && FlightGlobals.ActiveVessel.id == this.vessel.id)
	{
	Tools.PostDebugMessage("{0}: Checking {1} relays on {2}.",
	this.ToString(),
	potentialVessel.GetAntennaRelays().Count(),
	potentialVessel
	);
	}

	foreach (IAntennaRelay occludedRelay in potentialVessel.GetAntennaRelays())
	{
	if (FlightGlobals.ActiveVessel != null && FlightGlobals.ActiveVessel.id == this.vessel.id)
	{
	Tools.PostDebugMessage(this.ToString() + " Checking candidate for bestOccludedRelay: {0}" +
	"\n\tCanTransmit: {1}", occludedRelay, occludedRelay.CanTransmit());
	}

	if (occludedRelay.CanTransmit())
	{
	this.bestOccludedRelay = occludedRelay;
	bodyOccludingBestOccludedRelay = fob;
	bestOccludedSqrDistance = potentialSqrDistance;

	if (FlightGlobals.ActiveVessel != null && FlightGlobals.ActiveVessel.id == this.vessel.id)
	{
	Tools.PostDebugMessage(this.ToString() + " Found new bestOccludedRelay: {0}" +
	"\nfirstOccludingBody: {1}" +
	"\nbestOccludedSqrDistance: {2}",
	occludedRelay,
	fob,
	potentialSqrDistance
	);
	}
	break;
	}
	}
	}

	continue;
	}

/*	/*
* ...so that we can skip the vessel if it is further away than Kerbin, our transmit distance, or a	* ...so that we can skip the vessel if it is further away than a vessel we've already checked.
* vessel we've already checked.
* */	* */
if (potentialDistance > Tools.Min(this.maxTransmitDistance, nearestDistance, vessel.DistanceTo(Kerbin)))	if (potentialSqrDistance > nearestRelaySqrDistance)
{	{
	if (FlightGlobals.ActiveVessel != null && FlightGlobals.ActiveVessel.id == this.vessel.id)
	{
	Tools.PostDebugMessage("{0}: Vessel {1} discarded because it is out of range, or farther than another relay.",
	this.ToString(),
	potentialVessel.vesselName
	);
	}
continue;	continue;
}	}

nearestDistance = potentialDistance;	nearestRelaySqrDistance = potentialSqrDistance;

foreach (IAntennaRelay potentialRelay in potentialVessel.GetAntennaRelays())	foreach (IAntennaRelay potentialRelay in potentialVessel.GetAntennaRelays())
{	{
if (potentialRelay.CanTransmit())	if (potentialRelay.CanTransmit() && potentialRelay.targetRelay != this)
{	{
_nearestRelay = potentialRelay;	this.nearestRelay = potentialRelay;
Tools.PostDebugMessage(string.Format("{0}: found new best relay {1} ({2})",
this.GetType().Name,	if (FlightGlobals.ActiveVessel != null && FlightGlobals.ActiveVessel.id == this.vessel.id)
_nearestRelay.ToString(),	{
_nearestRelay.vessel.id	Tools.PostDebugMessage(string.Format("{0}: found new best relay {1} ({2})",
));	this.ToString(),
	this.nearestRelay.ToString(),
	this.nearestRelay.vessel.id
	));
	}
break;	break;
}	}
}	}
}	}

	CelestialBody bodyOccludingKerbin = null;

	double kerbinSqrDistance = this.vessel.DistanceTo(Kerbin) - Kerbin.Radius;
	kerbinSqrDistance *= kerbinSqrDistance;

	Tools.DebugLogger log = Tools.DebugLogger.New(this);

	log.AppendFormat("{0} ({1}): Search done, figuring status.", this.ToString(), this.GetType().Name);

	// If we don't have LOS to Kerbin, focus on relays
	if (!this.vessel.hasLineOfSightTo(Kerbin, out bodyOccludingKerbin, ARConfiguration.RadiusRatio))
	{
	log.AppendFormat("\n\tKerbin LOS is blocked by {0}.", bodyOccludingKerbin.bodyName);

	// nearestRelaySqrDistance will be infinity if all relays are occluded or none exist.
	// Therefore, this will only be true if a valid relay is in range.
	if (nearestRelaySqrDistance <= maxTransmitSqrDistance)
	{
	log.AppendFormat("\n\tCan transmit to nearby relay {0} ({1} <= {2}).",
	this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
	nearestRelaySqrDistance, maxTransmitSqrDistance);

	this.KerbinDirect = false;
	this.canTransmit = true;
	this.targetRelay = this.nearestRelay;
	}
	// If this isn't true, we can't transmit, but pick a second best of bestOccludedRelay and Kerbin anyway
	else
	{
	log.AppendFormat("\n\tCan't transmit to nearby relay {0} ({1} > {2}).",
	this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
	nearestRelaySqrDistance, maxTransmitSqrDistance);

	this.canTransmit = false;

	// If the best occluded relay is closer than Kerbin, target it.
	if (bestOccludedSqrDistance < kerbinSqrDistance)
	{
	log.AppendFormat("\n\t\tPicking occluded relay {0} as target ({1} < {2}).",
	this.bestOccludedRelay == null ? "null" : this.bestOccludedRelay.ToString(),
	bestOccludedSqrDistance, kerbinSqrDistance);

	this.KerbinDirect = false;
	this.targetRelay = this.bestOccludedRelay;
	this.firstOccludingBody = bodyOccludingBestOccludedRelay;
	}
	// Otherwise, target Kerbin and report the first body blocking it.
	else
	{
	log.AppendFormat("\n\t\tPicking Kerbin as target ({0} >= {1}).",
	bestOccludedSqrDistance, kerbinSqrDistance);

	this.KerbinDirect = true;
	this.targetRelay = null;
	this.firstOccludingBody = bodyOccludingKerbin;
	}
	}
	}
	// If we do have LOS to Kerbin, try to prefer the closest of nearestRelay and Kerbin
	else
	{
	log.AppendFormat("\n\tKerbin is in LOS.");

	// If the nearest relay is closer than Kerbin and in range, transmit to it.
	if (nearestRelaySqrDistance <= maxTransmitSqrDistance)
	{
	log.AppendFormat("\n\tCan transmit to nearby relay {0} ({1} <= {2}).",
	this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
	nearestRelaySqrDistance, maxTransmitSqrDistance);

	this.canTransmit = true;

	// If the nearestRelay is closer than Kerbin, use it.
	if (nearestRelaySqrDistance < kerbinSqrDistance)
	{
	log.AppendFormat("\n\tPicking relay {0} over Kerbin ({1} < {2}).",
	this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
	nearestRelaySqrDistance, kerbinSqrDistance);

	this.KerbinDirect = false;
	this.targetRelay = this.nearestRelay;
	}
	// Otherwise, Kerbin is closer, so use it.
	else
	{
	log.AppendFormat("\n\tBut picking Kerbin over nearby relay {0} ({1} >= {2}).",
	this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
	nearestRelaySqrDistance, kerbinSqrDistance);

	this.KerbinDirect = true;
	this.targetRelay = null;
	}
	}
	// If the nearest relay is out of range, we still need to check on Kerbin.
	else
	{
	log.AppendFormat("\n\tCan't transmit to nearby relay {0} ({1} > {2}).",
	this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
	nearestRelaySqrDistance, maxTransmitSqrDistance);

	// If Kerbin is in range, use it.
	if (kerbinSqrDistance <= maxTransmitSqrDistance)
	{
	log.AppendFormat("\n\tCan transmit to Kerbin ({0} <= {1}).",
	kerbinSqrDistance, maxTransmitSqrDistance);

	this.canTransmit = true;
	this.KerbinDirect = true;
	this.targetRelay = null;
	}
	// If Kerbin is out of range and the nearest relay is out of range, pick a second best between
	// Kerbin and bestOccludedRelay
	else
	{
	log.AppendFormat("\n\tCan't transmit to Kerbin ({0} > {1}).",
	kerbinSqrDistance, maxTransmitSqrDistance);

	this.canTransmit = false;

	// If the best occluded relay is closer than Kerbin, use it.
	// Since bestOccludedSqrDistance is infinity if there are no occluded relays,
	// this is safe
	if (bestOccludedSqrDistance < kerbinSqrDistance)
	{
	log.AppendFormat("\n\t\tPicking occluded relay {0} as target ({1} < {2}).",
	this.bestOccludedRelay == null ? "null" : this.bestOccludedRelay.ToString(),
	bestOccludedSqrDistance, kerbinSqrDistance);

	this.KerbinDirect = false;
	this.targetRelay = bestOccludedRelay;
	this.firstOccludingBody = bodyOccludingBestOccludedRelay;
	}
	// Otherwise, target Kerbin. Since we have LOS, blank the first occluding body.
	else
	{
	log.AppendFormat("\n\t\tPicking Kerbin as target ({0} >= {1}).",
	bestOccludedSqrDistance, kerbinSqrDistance);

	this.KerbinDirect = true;
	this.targetRelay = null;
	this.firstOccludingBody = null;
	}
	}
	}
	}

	log.AppendFormat("\n{0}: Status determination complete.", this.ToString());

	log.Print();

// Now that we're done with our recursive CanTransmit checks, flag this relay as not checked so it can be	// Now that we're done with our recursive CanTransmit checks, flag this relay as not checked so it can be
// used next time.	// used next time.
RelayDatabase.Instance.CheckedVesselsTable.Remove(vessel.id);	RelayDatabase.Instance.CheckedVesselsTable.Remove(vessel.id);
	}
// Return the nearest available relay, or null if there are no available relays nearby.
return _nearestRelay;	/// <summary>
}	/// Returns a <see cref="System.String"/> that represents the current <see cref="AntennaRange.AntennaRelay"/>.
	/// </summary>
/// <summary>	/// <returns>A <see cref="System.String"/> that represents the current <see cref="AntennaRange.AntennaRelay"/>.</returns>
/// Initializes a new instance of the <see cref="AntennaRange.ProtoDataTransmitter"/> class.	public override string ToString()
/// </summary>	{
/// <param name="ms"><see cref="ProtoPartModuleSnapshot"/></param>	if (this is ProtoAntennaRelay)
	{
	return (this as ProtoAntennaRelay).ToString();
	}
	return this.moduleRef.ToString();
	}

	/// <summary>
	/// Initializes a new instance of the <see cref="AntennaRange.AntennaRelay"/> class.
	/// </summary>
	/// <param name="module">The module reference underlying this AntennaRelay,
	/// as an <see cref="AntennaRange.IAntennaRelay"/></param>
public AntennaRelay(IAntennaRelay module)	public AntennaRelay(IAntennaRelay module)
{	{
this.moduleRef = module;	this.moduleRef = module;

this.searchTimer = new System.Diagnostics.Stopwatch();	this.searchTimer = new System.Diagnostics.Stopwatch();
this.millisecondsBetweenSearches = 5000;	this.millisecondsBetweenSearches = 125L;

// HACK: This might not be safe in all circumstances, but since AntennaRelays are not built until Start,
// we hope it is safe enough.
this.Kerbin = FlightGlobals.Bodies.FirstOrDefault(b => b.name == "Kerbin");
}	}
}	}
}	}

file:a/Extensions.cs (deleted)

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

using System;
using System.Collections.Generic;
using System.Linq;

namespace AntennaRange
{
/*
* A class of utility extensions for Vessels and Relays to help find a relay path back to Kerbin.
* */
public static class Extensions
{
/// <summary>
/// Returns the distance between this Vessel and another Vessel.
/// </summary>
/// <param name="vesselOne">This <see cref="Vessel"/><see ></param>
/// <param name="vesselTwo">Another <see cref="Vessel"/></param>
public static double DistanceTo(this Vessel vesselOne, Vessel vesselTwo)
{
return (vesselOne.GetWorldPos3D() - vesselTwo.GetWorldPos3D()).magnitude;
}

/// <summary>
/// Returns the distance between this Vessel and a CelestialBody
/// </summary>
/// <param name="vessel">This Vessel</param>
/// <param name="body">A <see cref="CelestialBody"/></param>
public static double DistanceTo(this Vessel vessel, CelestialBody body)
{
return (vessel.GetWorldPos3D() - body.position).magnitude;
}

/// <summary>
/// Returns the distance between this IAntennaRelay and a Vessel
/// </summary>
/// <param name="relay">This <see cref="IAntennaRelay"/></param>
/// <param name="Vessel">A <see cref="Vessel"/></param>
public static double DistanceTo(this AntennaRelay relay, Vessel Vessel)
{
return relay.vessel.DistanceTo(Vessel);
}

/// <summary>
/// Returns the distance between this IAntennaRelay and a CelestialBody
/// </summary>
/// <param name="relay">This <see cref="IAntennaRelay"/></param>
/// <param name="body">A <see cref="CelestialBody"/></param>
public static double DistanceTo(this AntennaRelay relay, CelestialBody body)
{
return relay.vessel.DistanceTo(body);
}

/// <summary>
/// Returns the distance between this IAntennaRelay and another IAntennaRelay
/// </summary>
/// <param name="relayOne">This <see cref="IAntennaRelay"/></param>
/// <param name="relayTwo">Another <see cref="IAntennaRelay"/></param>
public static double DistanceTo(this AntennaRelay relayOne, IAntennaRelay relayTwo)
{
return relayOne.DistanceTo(relayTwo.vessel);
}

/// <summary>
/// Returns all of the PartModules or ProtoPartModuleSnapshots implementing IAntennaRelay in this Vessel.
/// </summary>
/// <param name="vessel">This <see cref="Vessel"/></param>
public static IEnumerable<IAntennaRelay> GetAntennaRelays (this Vessel vessel)
{
return RelayDatabase.Instance[vessel].Values.ToList();
}


}
}

file:b/GameData/AntennaRange/ATM_AntennaRange.cfg (new)

	ACTIVE_TEXTURE_MANAGER_CONFIG
	{
	folder = AntennaRange
	enabled = true
	OVERRIDES
	{
	AntennaRange/.*
	{
	compress = true
	mipmaps = false
	scale = 1
	max_size = 0
	}
	}
	}

file:b/GameData/AntennaRange/AntennaRange.cfg (new)

	// AntennaRange
	//
	// AntennaRange.cfg
	//
	// Copyright © 2014, toadicus
	// All rights reserved.
	//
	// Redistribution and use in source and binary forms, with or without modification,
	// are permitted provided that the following conditions are met:
	//
	// 1. Redistributions of source code must retain the above copyright notice,
	// this list of conditions and the following disclaimer.
	//
	// 2. Redistributions in binary form must reproduce the above copyright notice,
	// this list of conditions and the following disclaimer in the documentation and/or other
	// materials provided with the distribution.
	//
	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
	// to endorse or promote products derived from this software without specific prior written permission.
	//
	// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
	// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
	// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
	// WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	//
	// This software uses the ModuleManager library © 2013 ialdabaoth, used under a Creative Commons Attribution-ShareAlike
	// 3.0 Uported License.
	//
	// Specifications:
	// nominalRange: The distance from Kerbin at which the antenna will perform exactly as prescribed by
	// packetResourceCost and packetSize.
	// maxPowerFactor: The multiplier on packetResourceCost that defines the maximum power output of the antenna. When the
	// power cost exceeds packetResourceCost * maxPowerFactor, transmission will fail.
	// maxDataFactor: The multipler on packetSize that defines the maximum data bandwidth of the antenna.
	//

	@PART[longAntenna]:FOR[AntennaRange]:NEEDS[!RemoteTech2]
	{
	@MODULE[ModuleDataTransmitter]
	{
	@name = ModuleLimitedDataTransmitter
	nominalRange = 1500000
	maxPowerFactor = 8
	maxDataFactor = 4
	}

	MODULE
	{
	name = ModuleScienceContainer

	dataIsCollectable = true
	dataIsStorable = false

	storageRange = 2
	}
	}

	@PART[mediumDishAntenna]:FOR[AntennaRange]:NEEDS[!RemoteTech2]
	{
	@MODULE[ModuleDataTransmitter]
	{
	@name = ModuleLimitedDataTransmitter
	nominalRange = 30000000
	maxPowerFactor = 8
	maxDataFactor = 4
	}

	MODULE
	{
	name = ModuleScienceContainer

	dataIsCollectable = true
	dataIsStorable = false

	storageRange = 2
	}
	}

	@PART[commDish]:FOR[AntennaRange]:NEEDS[!RemoteTech2]
	{
	@MODULE[ModuleDataTransmitter]
	{
	@name = ModuleLimitedDataTransmitter
	nominalRange = 80000000000
	maxPowerFactor = 8
	maxDataFactor = 4
	}

	MODULE
	{
	name = ModuleScienceContainer

	dataIsCollectable = true
	dataIsStorable = false

	storageRange = 2
	}
	}

	EVA_MODULE
	{
	name = ModuleLimitedDataTransmitter

	nominalRange = 5000
	maxPowerFactor = 1
	maxDataFactor = 1

	packetInterval = 0.2
	packetSize = 1
	packetResourceCost = 6.25

	requiredResource = ElectricCharge
	}

	EVA_RESOURCE
	{
	name = ElectricCharge
	amount = 100
	maxAmount = 100
	}

	@EVA_RESOURCE[ElectricCharge]:AFTER[AntennaRange]:NEEDS[TacLifeSupport]
	{
	!name = DELETE
	}

file:b/GameData/AntennaRange/Textures/appLauncherIcon.png (new)

 Binary files /dev/null and b/GameData/AntennaRange/Textures/appLauncherIcon.png differ

file:b/GameData/AntennaRange/Textures/appLauncherIconNoConnection.png (new)

 Binary files /dev/null and b/GameData/AntennaRange/Textures/appLauncherIconNoConnection.png differ

file:b/GameData/AntennaRange/Textures/appLauncherIconSubOptimal.png (new)

 Binary files /dev/null and b/GameData/AntennaRange/Textures/appLauncherIconSubOptimal.png differ

file:b/GameData/AntennaRange/Textures/toolbarIcon.png (new)

 Binary files /dev/null and b/GameData/AntennaRange/Textures/toolbarIcon.png differ

file:b/GameData/AntennaRange/Textures/toolbarIconNoConnection.png (new)

 Binary files /dev/null and b/GameData/AntennaRange/Textures/toolbarIconNoConnection.png differ

file:b/GameData/AntennaRange/Textures/toolbarIconSubOptimal.png (new)

 Binary files /dev/null and b/GameData/AntennaRange/Textures/toolbarIconSubOptimal.png differ

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

// AntennaRange	// AntennaRange
//	//
// IAntennaRelay.cs	// IAntennaRelay.cs
//	//
// Copyright © 2014, toadicus	// Copyright © 2014, toadicus
// All rights reserved.	// All rights reserved.
//	//
// Redistribution and use in source and binary forms, with or without modification,	// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:	// are permitted provided that the following conditions are met:
//	//
// 1. Redistributions of source code must retain the above copyright notice,	// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.	// this list of conditions and the following disclaimer.
//	//
// 2. Redistributions in binary form must reproduce the above copyright notice,	// 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	// this list of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.	// materials provided with the distribution.
//	//
// 3. Neither the name of the copyright holder nor the names of its contributors may be used	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// to endorse or promote products derived from this software without specific prior written permission.	// to endorse or promote products derived from this software without specific prior written permission.
//	//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,	// 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	// 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,	// 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	// 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,	// 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	// 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.	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

using KSP;	using KSP;
using System;	using System;

namespace AntennaRange	namespace AntennaRange
{	{
/*	/// <summary>
* Interface defining the basic functionality of AntennaRelay modules for AntennaRange.	/// Interface defining the basic functionality of AntennaRelay modules for AntennaRange.
* */	/// </summary>
public interface IAntennaRelay	public interface IAntennaRelay
{	{
/// <summary>	/// <summary>
/// Gets the parent Vessel.	/// Gets the parent Vessel.
/// </summary>	/// </summary>
/// <value>The parent Vessel.</value>
Vessel vessel { get; }	Vessel vessel { get; }

	/// <summary>
	/// Gets the target <see cref="AntennaRange.IAntennaRelay"/>relay.
	/// </summary>
	IAntennaRelay targetRelay { get; }

/// <summary>	/// <summary>
/// Gets the distance to the nearest relay or Kerbin, whichever is closer.	/// Gets the distance to the nearest relay or Kerbin, whichever is closer.
/// </summary>	/// </summary>
/// <value>The distance to the nearest relay or Kerbin, whichever is closer.</value>
double transmitDistance { get; }	double transmitDistance { get; }

	/// <summary>
	/// Gets the nominal transmit distance at which the Antenna behaves just as prescribed by Squad's config.
	/// </summary>
	double nominalTransmitDistance { get; }

/// <summary>	/// <summary>
/// The maximum distance at which this relay can operate.	/// The maximum distance at which this relay can operate.
/// </summary>	/// </summary>
/// <value>The max transmit distance.</value>	double maxTransmitDistance { get; }
float maxTransmitDistance { get; }

/// <summary>	/// <summary>
/// Gets a value indicating whether this <see cref="AntennaRange.ProtoDataTransmitter"/> has been checked during	/// The first CelestialBody blocking line of sight to a
/// the current relay attempt.
/// </summary>	/// </summary>
/// <value><c>true</c> if relay checked; otherwise, <c>false</c>.</value>	CelestialBody firstOccludingBody { get; }
bool relayChecked { get; }
	/// <summary>
	/// Gets a value indicating whether this <see cref="AntennaRange.IAntennaRelay"/> Relay is communicating
	/// directly with Kerbin.
	/// </summary>
	bool KerbinDirect { get; }

	/// <summary>
	/// Gets the Part title.
	/// </summary>
	string Title { get; }

/// <summary>	/// <summary>
/// Determines whether this instance can transmit.	/// Determines whether this instance can transmit.
	/// <c>true</c> if this instance can transmit; otherwise, <c>false</c>.
/// </summary>	/// </summary>
/// <returns><c>true</c> if this instance can transmit; otherwise, <c>false</c>.</returns>
bool CanTransmit();	bool CanTransmit();

	/// <summary>
	/// Returns a <see cref="System.String"/> that represents the current <see cref="AntennaRange.IAntennaRelay"/>.
	/// </summary>
	string ToString();
}	}
}	}

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

// AntennaRange	// AntennaRange
//	//
// ModuleLimitedDataTransmitter.cs	// ModuleLimitedDataTransmitter.cs
//	//
// Copyright © 2014, toadicus	// Copyright © 2014, toadicus
// All rights reserved.	// All rights reserved.
//	//
// Redistribution and use in source and binary forms, with or without modification,	// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:	// are permitted provided that the following conditions are met:
//	//
// 1. Redistributions of source code must retain the above copyright notice,	// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.	// this list of conditions and the following disclaimer.
//	//
// 2. Redistributions in binary form must reproduce the above copyright notice,	// 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	// this list of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.	// materials provided with the distribution.
//	//
// 3. Neither the name of the copyright holder nor the names of its contributors may be used	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// to endorse or promote products derived from this software without specific prior written permission.	// to endorse or promote products derived from this software without specific prior written permission.
//	//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,	// 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	// 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,	// 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	// 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,	// 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	// 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.	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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

namespace AntennaRange	namespace AntennaRange
{	{
/*	/// <summary>
* ModuleLimitedDataTransmitter is designed as a drop-in replacement for ModuleDataTransmitter, and handles range-	/// <para>ModuleLimitedDataTransmitter is designed as a drop-in replacement for ModuleDataTransmitter, and handles
* finding, power scaling, and data scaling for antennas during science transmission. Its functionality varies with	/// rangefinding, power scaling, and data scaling for antennas during science transmission. Its functionality
* three tunables: nominalRange, maxPowerFactor, and maxDataFactor, set in .cfg files.	/// varies with three tunables: nominalRange, maxPowerFactor, and maxDataFactor, set in .cfg files.</para>
*	///
* In general, the scaling functions assume the following relation:	/// <para>In general, the scaling functions assume the following relation:</para>
*	///
* D² α P/R,	/// <para> D² α P/R,</para>
*	///
* where D is the total transmission distance, P is the transmission power, and R is the data rate.	/// <para>where D is the total transmission distance, P is the transmission power, and R is the data rate.</para>
*	/// </summary>
* */

/*
* Fields
* */
public class ModuleLimitedDataTransmitter : ModuleDataTransmitter, IScienceDataTransmitter, IAntennaRelay	public class ModuleLimitedDataTransmitter : ModuleDataTransmitter, IScienceDataTransmitter, IAntennaRelay
{	{
// Stores the packetResourceCost as defined in the .cfg file.	// Stores the packetResourceCost as defined in the .cfg file.
protected float _basepacketResourceCost;	private float _basepacketResourceCost;

// Stores the packetSize as defined in the .cfg file.	// Stores the packetSize as defined in the .cfg file.
protected float _basepacketSize;	private float _basepacketSize;

// Every antenna is a relay.	// Every antenna is a relay.
protected AntennaRelay relay;	private AntennaRelay relay;

// Keep track of vessels with transmitters for relay purposes.
protected List<Vessel> _relayVessels;

// Sometimes we will need to communicate errors; this is how we do it.	// Sometimes we will need to communicate errors; this is how we do it.
protected ScreenMessage ErrorMsg;	private ScreenMessage ErrorMsg;

// The distance from Kerbin at which the antenna will perform exactly as prescribed by packetResourceCost	/// <summary>
// and packetSize.	/// The distance from Kerbin at which the antenna will perform exactly as prescribed by packetResourceCost
	/// and packetSize.
	/// </summary>
[KSPField(isPersistant = false)]	[KSPField(isPersistant = false)]
public float nominalRange;	public double nominalRange;

	/// <summary>
	/// Relay status string for use in action menus.
	/// </summary>
	[KSPField(isPersistant = false, guiActive = true, guiName = "Status")]
	public string UIrelayStatus;

	/// <summary>
	/// Relay target string for use in action menus.
	/// </summary>
	[KSPField(isPersistant = false, guiActive = true, guiName = "Relay")]
	public string UIrelayTarget;

	/// <summary>
	/// Transmit distance string for use in action menus.
	/// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Transmission Distance")]	[KSPField(isPersistant = false, guiActive = true, guiName = "Transmission Distance")]
public string UItransmitDistance;	public string UItransmitDistance;

	/// <summary>
	/// Maximum distance string for use in action menus.
	/// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Maximum Distance")]	[KSPField(isPersistant = false, guiActive = true, guiName = "Maximum Distance")]
public string UImaxTransmitDistance;	public string UImaxTransmitDistance;

	/// <summary>
	/// Packet size string for use in action menus.
	/// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Packet Size")]	[KSPField(isPersistant = false, guiActive = true, guiName = "Packet Size")]
public string UIpacketSize;	public string UIpacketSize;

	/// <summary>
	/// Packet cost string for use in action menus.
	/// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Packet Cost")]	[KSPField(isPersistant = false, guiActive = true, guiName = "Packet Cost")]
public string UIpacketCost;	public string UIpacketCost;

// The multiplier on packetResourceCost that defines the maximum power output of the antenna. When the power	/// <summary>
// cost exceeds packetResourceCost * maxPowerFactor, transmission will fail.	/// The multiplier on packetResourceCost that defines the maximum power output of the antenna. When the power
	/// cost exceeds packetResourceCost * maxPowerFactor, transmission will fail.
	/// </summary>
[KSPField(isPersistant = false)]	[KSPField(isPersistant = false)]
public float maxPowerFactor;	public float maxPowerFactor;

// The multipler on packetSize that defines the maximum data bandwidth of the antenna.	/// <summary>
	/// The multipler on packetSize that defines the maximum data bandwidth of the antenna.
	/// </summary>
[KSPField(isPersistant = false)]	[KSPField(isPersistant = false)]
public float maxDataFactor;	public float maxDataFactor;

protected bool actionUIUpdate;	/// <summary>
	/// The packet throttle.
	/// </summary>
	[KSPField(
	isPersistant = true,
	guiName = "Packet Throttle",
	guiUnits = "%",
	guiActive = true,
	guiActiveEditor = false
	)]
	[UI_FloatRange(maxValue = 100f, minValue = 2.5f, stepIncrement = 2.5f)]
	public float packetThrottle;

	private bool actionUIUpdate;

/*	/*
* Properties	* Properties
* */	* */
// Returns the parent vessel housing this antenna.	/// <summary>
	/// Gets the parent Vessel.
	/// </summary>
public new Vessel vessel	public new Vessel vessel
{	{
get	get
{	{
return base.vessel;	if (base.vessel != null)
}	{
}	return base.vessel;
	}
// Returns the distance to the nearest relay or Kerbin, whichever is closer.	else if (this.part != null)
	{
	return this.part.vessel;
	}

	else
	{
	return null;
	}
	}
	}

	/// <summary>
	/// Gets the target <see cref="AntennaRange.IAntennaRelay"/>relay.
	/// </summary>
	public IAntennaRelay targetRelay
	{
	get
	{
	if (this.relay == null)
	{
	return null;
	}

	return this.relay.targetRelay;
	}
	}

	/// <summary>
	/// Gets the distance to the nearest relay or Kerbin, whichever is closer.
	/// </summary>
public double transmitDistance	public double transmitDistance
{	{
get	get
{	{
	if (this.relay == null)
	{
	return double.PositiveInfinity;
	}

return this.relay.transmitDistance;	return this.relay.transmitDistance;
}	}
}	}

// Returns the maximum distance this module can transmit	/// <summary>
public float maxTransmitDistance	/// Gets the nominal transmit distance at which the Antenna behaves just as prescribed by Squad's config.
{	/// </summary>
get	public double nominalTransmitDistance
{	{
return Mathf.Sqrt (this.maxPowerFactor) * this.nominalRange;	get
	{
	return this.nominalRange;
	}
	}

	/// <summary>
	/// The maximum distance at which this relay can operate.
	/// </summary>
	public double maxTransmitDistance
	{
	get
	{
	// TODO: Cache this in a way that doesn't break everything.
	return Math.Sqrt(this.maxPowerFactor) * this.nominalRange;
	}
	}

	/// <summary>
	/// The first CelestialBody blocking line of sight to a
	/// </summary>
	public CelestialBody firstOccludingBody
	{
	get
	{
	return this.relay.firstOccludingBody;
}	}
}	}

/*	/*
* The next two functions overwrite the behavior of the stock functions and do not perform equivalently, except	* The next two functions overwrite the behavior of the stock functions and do not perform equivalently, except
* in that they both return floats. Here's some quick justification:	* in that they both return floats. Here's some quick justification:
*	*
* The stock implementation of GetTransmitterScore (which I cannot override) is:	* The stock implementation of GetTransmitterScore (which I cannot override) is:
* Score = (1 + DataResourceCost) / DataRate	* Score = (1 + DataResourceCost) / DataRate
*	*
* The stock DataRate and DataResourceCost are:	* The stock DataRate and DataResourceCost are:
* DataRate = packetSize / packetInterval	* DataRate = packetSize / packetInterval
* DataResourceCost = packetResourceCost / packetSize	* DataResourceCost = packetResourceCost / packetSize
*	*
* So, the resulting score is essentially in terms of joules per byte per baud. Rearranging that a bit, it	* So, the resulting score is essentially in terms of joules per byte per baud. Rearranging that a bit, it
* could also look like joule-seconds per byte per byte, or newton-meter-seconds per byte per byte. Either way,	* could also look like joule-seconds per byte per byte, or newton-meter-seconds per byte per byte. Either way,
* that metric is not a very reasonable one.	* that metric is not a very reasonable one.
*	*
* Two metrics that might make more sense are joules per byte or joules per byte per second. The latter case	* Two metrics that might make more sense are joules per byte or joules per byte per second. The latter case
* would look like:	* would look like:
* DataRate = packetSize / packetInterval	* DataRate = packetSize / packetInterval
* DataResourceCost = packetResourceCost	* DataResourceCost = packetResourceCost
*	*
* The former case, which I've chosen to implement below, is:	* The former case, which I've chosen to implement below, is:
* DataRate = packetSize	* DataRate = packetSize
* DataResourceCost = packetResourceCost	* DataResourceCost = packetResourceCost
*	*
* So... hopefully that doesn't screw with anything else.	* So... hopefully that doesn't screw with anything else.
* */	* */
// Override ModuleDataTransmitter.DataRate to just return packetSize, because we want antennas to be scored in	/// <summary>
// terms of joules/byte	/// Override ModuleDataTransmitter.DataRate to just return packetSize, because we want antennas to be scored in
	/// terms of joules/byte
	/// </summary>
public new float DataRate	public new float DataRate
{	{
get	get
{	{
this.PreTransmit_SetPacketSize();	this.PreTransmit_SetPacketSize();

if (this.CanTransmit())	if (this.CanTransmit())
{	{
return this.packetSize;	return this.packetSize;
}	}
else	else
{	{
return float.Epsilon;	return float.Epsilon;
}	}
}	}
}	}

// Override ModuleDataTransmitter.DataResourceCost to just return packetResourceCost, because we want antennas	/// <summary>
// to be scored in terms of joules/byte	/// Override ModuleDataTransmitter.DataResourceCost to just return packetResourceCost, because we want antennas
public new float DataResourceCost	/// to be scored in terms of joules/byte
	/// </summary>
	public new double DataResourceCost
{	{
get	get
{	{
this.PreTransmit_SetPacketResourceCost();	this.PreTransmit_SetPacketResourceCost();

if (this.CanTransmit())	if (this.CanTransmit())
{	{
return this.packetResourceCost;	return this.packetResourceCost;
}	}
else	else
{	{
return float.PositiveInfinity;	return float.PositiveInfinity;
}	}
}	}
}	}

// Reports whether this antenna has been checked as a viable relay already in the current FindNearestRelay.	/// <summary>
public bool relayChecked	/// Gets a value indicating whether this <see cref="AntennaRange.IAntennaRelay"/> Relay is communicating
{	/// directly with Kerbin.
get	/// </summary>
{	public bool KerbinDirect
return this.relay.relayChecked;	{
	get
	{
	if (this.relay != null)
	{
	return this.relay.KerbinDirect;
	}

	return false;
	}
	}

	/// <summary>
	/// Gets the Part title.
	/// </summary>
	public string Title
	{
	get
	{
	if (this.part != null && this.part.partInfo != null)
	{
	return this.part.partInfo.title;
	}

	return string.Empty;
}	}
}	}

/*	/*
* Methods	* Methods
* */	* */
// Build ALL the objects.	// Build ALL the objects.
public ModuleLimitedDataTransmitter () : base()	public ModuleLimitedDataTransmitter () : base()
{	{
this.ErrorMsg = new ScreenMessage("", 4f, false, ScreenMessageStyle.UPPER_LEFT);	this.ErrorMsg = new ScreenMessage("", 4f, false, ScreenMessageStyle.UPPER_LEFT);
}	this.packetThrottle = 100f;
	}
// At least once, when the module starts with a state on the launch pad or later, go find Kerbin.
public override void OnStart (StartState state)	/// <summary>
{	/// PartModule OnAwake override; runs at Unity Awake.
base.OnStart (state);	/// </summary>
	public override void OnAwake()
if (state >= StartState.PreLaunch)	{
{	base.OnAwake();
this.relay = new AntennaRelay(this);
this.relay.maxTransmitDistance = this.maxTransmitDistance;

this.UImaxTransmitDistance = Tools.MuMech_ToSI(this.maxTransmitDistance) + "m";

GameEvents.onPartActionUICreate.Add(this.onPartActionUICreate);
GameEvents.onPartActionUIDismiss.Add(this.onPartActionUIDismiss);
}
}

// When the module loads, fetch the Squad KSPFields from the base. This is necessary in part because
// overloading packetSize and packetResourceCostinto a property in ModuleLimitedDataTransmitter didn't
// work.
public override void OnLoad(ConfigNode node)
{
this.Fields.Load(node);
base.Fields.Load(node);

base.OnLoad (node);

this._basepacketSize = base.packetSize;	this._basepacketSize = base.packetSize;
this._basepacketResourceCost = base.packetResourceCost;	this._basepacketResourceCost = base.packetResourceCost;

Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"{0} loaded:\n" +	"{0} loaded:\n" +
"packetSize: {1}\n" +	"packetSize: {1}\n" +
"packetResourceCost: {2}\n" +	"packetResourceCost: {2}\n" +
"nominalRange: {3}\n" +	"nominalRange: {3}\n" +
"maxPowerFactor: {4}\n" +	"maxPowerFactor: {4}\n" +
"maxDataFactor: {5}\n",	"maxDataFactor: {5}\n",
this.name,	this.name,
base.packetSize,	base.packetSize,
this._basepacketResourceCost,	this._basepacketResourceCost,
this.nominalRange,	this.nominalRange,
this.maxPowerFactor,	this.maxPowerFactor,
this.maxDataFactor	this.maxDataFactor
));	));
}	}

	/// <summary>
	/// PartModule OnStart override; runs at Unity Start.
	/// </summary>
	/// <param name="state">State.</param>
	public override void OnStart (StartState state)
	{
	base.OnStart (state);

	if (state >= StartState.PreLaunch)
	{
	this.relay = new AntennaRelay(this);
	this.relay.maxTransmitDistance = this.maxTransmitDistance;
	this.relay.nominalTransmitDistance = this.nominalRange;

	this.UImaxTransmitDistance = Tools.MuMech_ToSI(this.maxTransmitDistance) + "m";

	GameEvents.onPartActionUICreate.Add(this.onPartActionUICreate);
	GameEvents.onPartActionUIDismiss.Add(this.onPartActionUIDismiss);
	}
	}

	/// <summary>
	/// When the module loads, fetch the Squad KSPFields from the base. This is necessary in part because
	/// overloading packetSize and packetResourceCostinto a property in ModuleLimitedDataTransmitter didn't
	/// work.
	/// </summary>
	/// <param name="node"><see cref="ConfigNode"/> with data for this module.</param>
	public override void OnLoad(ConfigNode node)
	{
	this.Fields.Load(node);
	base.Fields.Load(node);

	base.OnLoad (node);
	}

	/// <summary>
	/// Override ModuleDataTransmitter.GetInfo to add nominal and maximum range to the VAB description.
	/// </summary>
	public override string GetInfo()
	{
	string text = base.GetInfo();
	text += "Nominal Range: " + Tools.MuMech_ToSI((double)this.nominalRange, 2) + "m\n";
	text += "Maximum Range: " + Tools.MuMech_ToSI((double)this.maxTransmitDistance, 2) + "m\n";
	return text;
	}

	/// <summary>
	/// Determines whether this instance can transmit.
	/// <c>true</c> if this instance can transmit; otherwise, <c>false</c>.
	/// </summary>
	public new bool CanTransmit()
	{
	if (this.part == null \|\| this.relay == null)
	{
	return false;
	}

	switch (this.part.State)
	{
	case PartStates.DEAD:
	case PartStates.DEACTIVATED:
	Tools.PostDebugMessage(string.Format(
	"{0}: {1} on {2} cannot transmit: {3}",
	this.GetType().Name,
	this.part.partInfo.title,
	this.vessel.vesselName,
	Enum.GetName(typeof(PartStates), this.part.State)
	));
	return false;
	default:
	break;
	}

	return this.relay.CanTransmit();
	}

	/// <summary>
	/// Override ModuleDataTransmitter.TransmitData to check against CanTransmit and fail out when CanTransmit
	/// returns false.
	/// </summary>
	/// <param name="dataQueue">List of <see cref="ScienceData"/> to transmit.</param>
	/// <param name="callback">Callback function</param>
	public new void TransmitData(List<ScienceData> dataQueue, Callback callback)
	{
	this.PreTransmit_SetPacketSize();
	this.PreTransmit_SetPacketResourceCost();

	if (this.CanTransmit())
	{
	ScreenMessages.PostScreenMessage(this.buildTransmitMessage(), 4f, ScreenMessageStyle.UPPER_LEFT);

	base.TransmitData(dataQueue, callback);
	}
	else
	{
	Tools.PostDebugMessage(this, "{0} unable to transmit during TransmitData.", this.part.partInfo.title);

	var logger = Tools.DebugLogger.New(this);

	foreach (ModuleScienceContainer scienceContainer in this.vessel.getModulesOfType<ModuleScienceContainer>())
	{
	logger.AppendFormat("Checking ModuleScienceContainer in {0}\n",
	scienceContainer.part.partInfo.title);

	if (
	scienceContainer.capacity != 0 &&
	scienceContainer.GetScienceCount() >= scienceContainer.capacity
	)
	{
	logger.Append("\tInsufficient capacity, skipping.\n");
	continue;
	}

	List<ScienceData> dataStored = new List<ScienceData>();

	foreach (ScienceData data in dataQueue)
	{
	if (!scienceContainer.allowRepeatedSubjects && scienceContainer.HasData(data))
	{
	logger.Append("\tAlready contains subject and repeated subjects not allowed, skipping.\n");
	continue;
	}

	logger.AppendFormat("\tAcceptable, adding data on subject {0}... ", data.subjectID);
	if (scienceContainer.AddData(data))
	{
	logger.Append("done, removing from queue.\n");

	dataStored.Add(data);
	}
	#if DEBUG
	else
	{
	logger.Append("failed.\n");
	}
	#endif
	}

	dataQueue.RemoveAll(i => dataStored.Contains(i));

	logger.AppendFormat("\t{0} data left in queue.", dataQueue.Count);
	}

	logger.Print();

	if (dataQueue.Count > 0)
	{
	StringBuilder msg = new StringBuilder();

	msg.Append('[');
	msg.Append(this.part.partInfo.title);
	msg.AppendFormat("]: {0} data items could not be saved: no space available in data containers.\n");
	msg.Append("Data to be discarded:\n");

	foreach (ScienceData data in dataQueue)
	{
	msg.AppendFormat("\t{0}\n", data.title);
	}

	ScreenMessages.PostScreenMessage(msg.ToString(), 4f, ScreenMessageStyle.UPPER_LEFT);

	Tools.PostDebugMessage(msg.ToString());
	}

	this.PostCannotTransmitError();
	}

	Tools.PostDebugMessage (
	"distance: " + this.transmitDistance
	+ " packetSize: " + this.packetSize
	+ " packetResourceCost: " + this.packetResourceCost
	);
	}

	/// <summary>
	/// Override ModuleDataTransmitter.TransmitData to check against CanTransmit and fail out when CanTransmit
	/// returns false.
	/// </summary>
	/// <param name="dataQueue">List of <see cref="ScienceData"/> to transmit.</param>
	public new void TransmitData(List<ScienceData> dataQueue)
	{
	this.TransmitData(dataQueue, null);
	}

	/// <summary>
	/// Override ModuleDataTransmitter.StartTransmission to check against CanTransmit and fail out when CanTransmit
	/// returns false.
	/// </summary>
	public new void StartTransmission()
	{
	PreTransmit_SetPacketSize ();
	PreTransmit_SetPacketResourceCost ();

	Tools.PostDebugMessage (
	"distance: " + this.transmitDistance
	+ " packetSize: " + this.packetSize
	+ " packetResourceCost: " + this.packetResourceCost
	);

	if (this.CanTransmit())
	{
	ScreenMessages.PostScreenMessage(this.buildTransmitMessage(), 4f, ScreenMessageStyle.UPPER_LEFT);

	base.StartTransmission();
	}
	else
	{
	this.PostCannotTransmitError ();
	}
	}

	/// <summary>
	/// MonoBehaviour Update
	/// </summary>
	public void Update()
	{
	if (this.actionUIUpdate)
	{
	if (this.CanTransmit())
	{
	this.UIrelayStatus = "Connected";
	this.UItransmitDistance = Tools.MuMech_ToSI(this.transmitDistance) + "m";
	this.UIpacketSize = Tools.MuMech_ToSI(this.DataRate) + "MiT";
	this.UIpacketCost = Tools.MuMech_ToSI(this.DataResourceCost) + "E";
	}
	else
	{
	if (this.relay.firstOccludingBody == null)
	{
	this.UIrelayStatus = "Out of range";
	}
	else
	{
	this.UIrelayStatus = string.Format("Blocked by {0}", this.relay.firstOccludingBody.bodyName);
	}
	this.UImaxTransmitDistance = "N/A";
	this.UIpacketSize = "N/A";
	this.UIpacketCost = "N/A";
	}

	if (this.KerbinDirect)
	{
	this.UIrelayTarget = AntennaRelay.Kerbin.bodyName;
	}
	else
	{
	this.UIrelayTarget = this.targetRelay.ToString();
	}
	}
	}

	/// <summary>
	/// Returns a <see cref="System.String"/> that represents the current <see cref="AntennaRange.ModuleLimitedDataTransmitter"/>.
	/// </summary>
	/// <returns>A <see cref="System.String"/> that represents the current <see cref="AntennaRange.ModuleLimitedDataTransmitter"/>.</returns>
	public override string ToString()
	{
	StringBuilder msg = new StringBuilder();

	msg.Append(this.part.partInfo.title);

	if (vessel != null)
	{
	msg.Append(" on ");
	msg.Append(vessel.vesselName);
	}
	else if (
	this.part != null &&
	this.part.protoPartSnapshot != null &&
	this.part.protoPartSnapshot != null &&
	this.part.protoPartSnapshot.pVesselRef != null
	)
	{
	msg.Append(" on ");
	msg.Append(this.part.protoPartSnapshot.pVesselRef.vesselName);
	}

	return msg.ToString();
	}

	// When we catch an onPartActionUICreate event for our part, go ahead and update every frame to look pretty.
	private void onPartActionUICreate(Part eventPart)
	{
	if (eventPart == base.part)
	{
	this.actionUIUpdate = true;
	}
	}

	// When we catch an onPartActionUIDismiss event for our part, stop updating every frame to look pretty.
	private void onPartActionUIDismiss(Part eventPart)
	{
	if (eventPart == base.part)
	{
	this.actionUIUpdate = false;
	}
	}

// Post an error in the communication messages describing the reason transmission has failed. Currently there	// Post an error in the communication messages describing the reason transmission has failed. Currently there
// is only one reason for this.	// is only one reason for this.
protected void PostCannotTransmitError()	private void PostCannotTransmitError()
{	{
string ErrorText = string.Format (	string ErrorText = string.Intern("Unable to transmit: no visible receivers in range!");
"Unable to transmit: out of range! Maximum range = {0}m; Current range = {1}m.",
Tools.MuMech_ToSI((double)this.maxTransmitDistance, 2),
Tools.MuMech_ToSI((double)this.transmitDistance, 2)
);

this.ErrorMsg.message = string.Format(	this.ErrorMsg.message = string.Format(
"<color='#{0}{1}{2}{3}'><b>{4}</b></color>",	"<color='#{0}{1}{2}{3}'><b>{4}</b></color>",
((int)(XKCDColors.OrangeRed.r * 255f)).ToString("x2"),	((int)(XKCDColors.OrangeRed.r * 255f)).ToString("x2"),
((int)(XKCDColors.OrangeRed.g * 255f)).ToString("x2"),	((int)(XKCDColors.OrangeRed.g * 255f)).ToString("x2"),
((int)(XKCDColors.OrangeRed.b * 255f)).ToString("x2"),	((int)(XKCDColors.OrangeRed.b * 255f)).ToString("x2"),
((int)(XKCDColors.OrangeRed.a * 255f)).ToString("x2"),	((int)(XKCDColors.OrangeRed.a * 255f)).ToString("x2"),
ErrorText	ErrorText
);	);

Tools.PostDebugMessage(this.GetType().Name + ": " + this.ErrorMsg.message);	Tools.PostDebugMessage(this.GetType().Name + ": " + this.ErrorMsg.message);

ScreenMessages.PostScreenMessage(this.ErrorMsg, false);	ScreenMessages.PostScreenMessage(this.ErrorMsg, false);
}	}

// Before transmission, set packetResourceCost. Per above, packet cost increases with the square of	// Before transmission, set packetResourceCost. Per above, packet cost increases with the square of
// distance. packetResourceCost maxes out at _basepacketResourceCost * maxPowerFactor, at which point	// distance. packetResourceCost maxes out at _basepacketResourceCost * maxPowerFactor, at which point
// transmission fails (see CanTransmit).	// transmission fails (see CanTransmit).
protected void PreTransmit_SetPacketResourceCost()	private void PreTransmit_SetPacketResourceCost()
{	{
if (this.transmitDistance <= this.nominalRange)	if (ARConfiguration.FixedPowerCost \|\| this.transmitDistance <= this.nominalRange)
{	{
base.packetResourceCost = this._basepacketResourceCost;	base.packetResourceCost = this._basepacketResourceCost;
}	}
else	else
{	{
	float rangeFactor = (float)(this.transmitDistance / this.nominalRange);
	rangeFactor *= rangeFactor;

base.packetResourceCost = this._basepacketResourceCost	base.packetResourceCost = this._basepacketResourceCost
* (float)Math.Pow (this.transmitDistance / this.nominalRange, 2);	* rangeFactor;
}
	Tools.PostDebugMessage(
	this,
	"Pretransmit: packet cost set to {0} before throttle (rangeFactor = {1}).",
	base.packetResourceCost,
	rangeFactor);
	}

	base.packetResourceCost *= this.packetThrottle / 100f;
}	}

// Before transmission, set packetSize. Per above, packet size increases with the inverse square of	// Before transmission, set packetSize. Per above, packet size increases with the inverse square of
// distance. packetSize maxes out at _basepacketSize * maxDataFactor.	// distance. packetSize maxes out at _basepacketSize * maxDataFactor.
protected void PreTransmit_SetPacketSize()	private void PreTransmit_SetPacketSize()
{	{
if (this.transmitDistance >= this.nominalRange)	if (!ARConfiguration.FixedPowerCost && this.transmitDistance >= this.nominalRange)
{	{
base.packetSize = this._basepacketSize;	base.packetSize = this._basepacketSize;
}	}
else	else
{	{
base.packetSize = Math.Min(	float rangeFactor = (float)(this.nominalRange / this.transmitDistance);
this._basepacketSize * (float)Math.Pow (this.nominalRange / this.transmitDistance, 2),	rangeFactor *= rangeFactor;

	base.packetSize = Mathf.Min(
	this._basepacketSize * rangeFactor,
this._basepacketSize * this.maxDataFactor);	this._basepacketSize * this.maxDataFactor);
}
}	Tools.PostDebugMessage(
	this,
// Override ModuleDataTransmitter.GetInfo to add nominal and maximum range to the VAB description.	"Pretransmit: packet size set to {0} before throttle (rangeFactor = {1}).",
public override string GetInfo()	base.packetSize,
{	rangeFactor);
string text = base.GetInfo();	}
text += "Nominal Range: " + Tools.MuMech_ToSI((double)this.nominalRange, 2) + "m\n";
text += "Maximum Range: " + Tools.MuMech_ToSI((double)this.maxTransmitDistance, 2) + "m\n";	base.packetSize *= this.packetThrottle / 100f;
return text;	}
}
	private string buildTransmitMessage()
// Override ModuleDataTransmitter.CanTransmit to return false when transmission is not possible.	{
public new bool CanTransmit()	StringBuilder message = new StringBuilder();
{
PartStates partState = this.part.State;	message.Append("[");
if (partState == PartStates.DEAD \|\| partState == PartStates.DEACTIVATED)	message.Append(base.part.partInfo.title);
{	message.Append("]: ");
Tools.PostDebugMessage(string.Format(
"{0}: {1} on {2} cannot transmit: {3}",	message.Append("Beginning transmission ");
this.GetType().Name,
this.part.partInfo.title,	if (this.KerbinDirect)
this.vessel.vesselName,	{
Enum.GetName(typeof(PartStates), partState)	message.Append("directly to Kerbin.");
));
return false;
}
return this.relay.CanTransmit();
}

// Override ModuleDataTransmitter.TransmitData to check against CanTransmit and fail out when CanTransmit
// returns false.
public new void TransmitData(List<ScienceData> dataQueue)
{
this.PreTransmit_SetPacketSize();
this.PreTransmit_SetPacketResourceCost();

if (this.CanTransmit())
{
StringBuilder message = new StringBuilder();

message.Append("[");
message.Append(base.part.partInfo.title);
message.Append("]: ");

message.Append("Beginning transmission ");

if (this.relay.nearestRelay == null)
{
message.Append("directly to Kerbin.");
}
else
{
message.Append("via ");
message.Append(this.relay.nearestRelay);
}

ScreenMessages.PostScreenMessage(message.ToString(), 4f, ScreenMessageStyle.UPPER_LEFT);

base.TransmitData(dataQueue);
}	}
else	else
{	{
this.PostCannotTransmitError ();	message.Append("via ");
}	message.Append(this.relay.targetRelay);
	}
Tools.PostDebugMessage (
"distance: " + this.transmitDistance	return message.ToString();
+ " packetSize: " + this.packetSize	}
+ " packetResourceCost: " + this.packetResourceCost
);	#if DEBUG
}

// Override ModuleDataTransmitter.StartTransmission to check against CanTransmit and fail out when CanTransmit
// returns false.
public new void StartTransmission()
{
PreTransmit_SetPacketSize ();
PreTransmit_SetPacketResourceCost ();

Tools.PostDebugMessage (
"distance: " + this.transmitDistance
+ " packetSize: " + this.packetSize
+ " packetResourceCost: " + this.packetResourceCost
);

if (this.CanTransmit())
{
StringBuilder message = new StringBuilder();

message.Append("[");
message.Append(base.part.partInfo.title);
message.Append("]: ");

message.Append("Beginning transmission ");

if (this.relay.nearestRelay == null)
{
message.Append("directly to Kerbin.");
}
else
{
message.Append("via ");
message.Append(this.relay.nearestRelay);
}

ScreenMessages.PostScreenMessage(message.ToString(), 4f, ScreenMessageStyle.UPPER_LEFT);

base.StartTransmission();
}
else
{
this.PostCannotTransmitError ();
}
}

public void Update()
{
if (this.actionUIUpdate)
{
this.UItransmitDistance = Tools.MuMech_ToSI(this.transmitDistance) + "m";
this.UIpacketSize = this.CanTransmit() ? Tools.MuMech_ToSI(this.DataRate) + "MiT" : "N/A";
this.UIpacketCost = this.CanTransmit() ? Tools.MuMech_ToSI(this.DataResourceCost) + "E" : "N/A";
}
}

public void onPartActionUICreate(Part eventPart)
{
if (eventPart == base.part)
{
this.actionUIUpdate = true;
}
}

public void onPartActionUIDismiss(Part eventPart)
{
if (eventPart == base.part)
{
this.actionUIUpdate = false;
}
}

public override string ToString()
{
StringBuilder msg = new StringBuilder();

msg.Append(this.part.partInfo.title);

if (vessel != null)
{
msg.Append(" on ");
msg.Append(vessel.vesselName);
}

return msg.ToString();
}

// When debugging, it's nice to have a button that just tells you everything.	// When debugging, it's nice to have a button that just tells you everything.
#if DEBUG
[KSPEvent (guiName = "Show Debug Info", active = true, guiActive = true)]	[KSPEvent (guiName = "Show Debug Info", active = true, guiActive = true)]
public void DebugInfo()	public void DebugInfo()
{	{
PreTransmit_SetPacketSize ();	PreTransmit_SetPacketSize ();
PreTransmit_SetPacketResourceCost ();	PreTransmit_SetPacketResourceCost ();

string msg = string.Format(	string msg = string.Format(
"'{0}'\n" +	"'{0}'\n" +
"_basepacketSize: {1}\n" +	"_basepacketSize: {1}\n" +
"packetSize: {2}\n" +	"packetSize: {2}\n" +
"_basepacketResourceCost: {3}\n" +	"_basepacketResourceCost: {3}\n" +
"packetResourceCost: {4}\n" +	"packetResourceCost: {4}\n" +
"maxTransmitDistance: {5}\n" +	"maxTransmitDistance: {5}\n" +
"transmitDistance: {6}\n" +	"transmitDistance: {6}\n" +
"nominalRange: {7}\n" +	"nominalRange: {7}\n" +
"CanTransmit: {8}\n" +	"CanTransmit: {8}\n" +
"DataRate: {9}\n" +	"DataRate: {9}\n" +
"DataResourceCost: {10}\n" +	"DataResourceCost: {10}\n" +
"TransmitterScore: {11}\n" +	"TransmitterScore: {11}\n" +
"NearestRelay: {12}\n" +	"targetRelay: {12}\n" +
"Vessel ID: {13}",	"KerbinDirect: {13}\n" +
	"Vessel ID: {14}",
this.name,	this.name,
this._basepacketSize,	this._basepacketSize,
base.packetSize,	base.packetSize,
this._basepacketResourceCost,	this._basepacketResourceCost,
base.packetResourceCost,	base.packetResourceCost,
this.maxTransmitDistance,	this.maxTransmitDistance,
this.transmitDistance,	this.transmitDistance,
this.nominalRange,	this.nominalRange,
this.CanTransmit(),	this.CanTransmit(),
this.DataRate,	this.DataRate,
this.DataResourceCost,	this.DataResourceCost,
ScienceUtil.GetTransmitterScore(this),	ScienceUtil.GetTransmitterScore(this),
this.relay.FindNearestRelay(),	this.relay.targetRelay == null ? "null" : this.relay.targetRelay.ToString(),
	this.KerbinDirect,
this.vessel.id	this.vessel.id
);	);
Tools.PostDebugMessage(msg);
	Tools.PostLogMessage(msg);
}	}

[KSPEvent (guiName = "Dump Vessels", active = true, guiActive = true)]	[KSPEvent (guiName = "Dump Vessels", active = true, guiActive = true)]
public void PrintAllVessels()	public void PrintAllVessels()
{	{
StringBuilder sb = new StringBuilder();	StringBuilder sb = new StringBuilder();

sb.Append("Dumping FlightGlobals.Vessels:");	sb.Append("Dumping FlightGlobals.Vessels:");

foreach (Vessel vessel in FlightGlobals.Vessels)	foreach (Vessel vessel in FlightGlobals.Vessels)
{	{
sb.AppendFormat("\n'{0} ({1})'", vessel.vesselName, vessel.id);	sb.AppendFormat("\n'{0} ({1})'", vessel.vesselName, vessel.id);
}	}

Tools.PostDebugMessage(sb.ToString());	Tools.PostDebugMessage(sb.ToString());
}	}

[KSPEvent (guiName = "Dump RelayDB", active = true, guiActive = true)]	[KSPEvent (guiName = "Dump RelayDB", active = true, guiActive = true)]
public void DumpRelayDB()	public void DumpRelayDB()
{	{
RelayDatabase.Instance.Dump();	RelayDatabase.Instance.Dump();
}	}
#endif	#endif
}	}
}	}

file:a/Properties/AssemblyInfo.cs -> file:b/Properties/AssemblyInfo.cs

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

// AntennaRange	// AntennaRange
//	//
// ProtoAntennaRelay.cs	// ProtoAntennaRelay.cs
//	//
// Copyright © 2014, toadicus	// Copyright © 2014, toadicus
// All rights reserved.	// All rights reserved.
//	//
// Redistribution and use in source and binary forms, with or without modification,	// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:	// are permitted provided that the following conditions are met:
//	//
// 1. Redistributions of source code must retain the above copyright notice,	// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.	// this list of conditions and the following disclaimer.
//	//
// 2. Redistributions in binary form must reproduce the above copyright notice,	// 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	// this list of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.	// materials provided with the distribution.
//	//
// 3. Neither the name of the copyright holder nor the names of its contributors may be used	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// to endorse or promote products derived from this software without specific prior written permission.	// to endorse or promote products derived from this software without specific prior written permission.
//	//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,	// 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	// 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,	// 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	// 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,	// 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	// 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.	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

	using KSP;
using System;	using System;
using System.Linq;	using System.Linq;
	using ToadicusTools;

namespace AntennaRange	namespace AntennaRange
{	{
/*	/*
* Wrapper class for ProtoPartModuleSnapshot extending AntennaRelay and implementing IAntennaRelay.	* Wrapper class for ProtoPartModuleSnapshot extending AntennaRelay and implementing IAntennaRelay.
* This is used for finding relays in unloaded Vessels.	* This is used for finding relays in unloaded Vessels.
* */	* */
public class ProtoAntennaRelay : AntennaRelay, IAntennaRelay	public class ProtoAntennaRelay : AntennaRelay, IAntennaRelay
{	{
// Stores the prototype part so we can make sure we haven't exploded or so.	// Stores the prototype part so we can make sure we haven't exploded or so.
protected ProtoPartSnapshot protoPart;	protected ProtoPartSnapshot protoPart;

public override Vessel vessel	public override Vessel vessel
{	{
get	get
{	{
return this.protoPart.pVesselRef.vesselRef;	return this.protoPart.pVesselRef.vesselRef;
}	}
}	}

	public override double nominalTransmitDistance
	{
	get
	{
	return this.moduleRef.nominalTransmitDistance;
	}
	}

/// <summary>	/// <summary>
/// The maximum distance at which this transmitter can operate.	/// The maximum distance at which this transmitter can operate.
/// </summary>	/// </summary>
/// <value>The max transmit distance.</value>	/// <value>The max transmit distance.</value>
public override float maxTransmitDistance	public override double maxTransmitDistance
{	{
get	get
{	{
return moduleRef.maxTransmitDistance;	return moduleRef.maxTransmitDistance;
}	}
}	}

/// <summary>	/// <summary>
/// Gets a value indicating whether this <see cref="AntennaRange.ProtoDataTransmitter"/> has been checked during
/// the current relay attempt.
/// </summary>
/// <value><c>true</c> if relay checked; otherwise, <c>false</c>.</value>
public override bool relayChecked
{
get;
protected set;
}

/// <summary>
/// Gets the underlying part's title.	/// Gets the underlying part's title.
/// </summary>	/// </summary>
/// <value>The title.</value>	/// <value>The title.</value>
public string title	public string Title
{	{
get	get
{	{
return this.protoPart.partInfo.title;	if (this.protoPart != null && this.protoPart.partInfo != null)
	{
	return this.protoPart.partInfo.title;
	}

	return string.Empty;
}	}
}	}

public override bool CanTransmit()	public override bool CanTransmit()
{	{
PartStates partState = (PartStates)this.protoPart.state;	PartStates partState = (PartStates)this.protoPart.state;
if (partState == PartStates.DEAD \|\| partState == PartStates.DEACTIVATED)	if (partState == PartStates.DEAD \|\| partState == PartStates.DEACTIVATED)
{	{
Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"{0}: {1} on {2} cannot transmit: {3}",	"{0}: {1} on {2} cannot transmit: {3}",
this.GetType().Name,	this.GetType().Name,
this.title,	this.Title,
this.vessel.vesselName,	this.vessel.vesselName,
Enum.GetName(typeof(PartStates), partState)	Enum.GetName(typeof(PartStates), partState)
));	));
return false;	return false;
}	}
return base.CanTransmit();	return base.CanTransmit();
}	}

public override string ToString()	public override string ToString()
{	{
return string.Format(	return string.Format(
"{0} on {1} (proto)",	"{0} on {1}",
this.title,	this.Title,
this.protoPart.pVesselRef.vesselName	this.protoPart.pVesselRef.vesselName
);	);
}	}

/// <summary>	/// <summary>
/// Initializes a new instance of the <see cref="AntennaRange.ProtoAntennaRelay"/> class.	/// Initializes a new instance of the <see cref="AntennaRange.ProtoAntennaRelay"/> class.
/// </summary>	/// </summary>
/// <param name="ms">The ProtoPartModuleSnapshot to wrap</param>	/// <param name="ms">The ProtoPartModuleSnapshot to wrap</param>
/// <param name="vessel">The parent Vessel</param>	/// <param name="vessel">The parent Vessel</param>
public ProtoAntennaRelay(IAntennaRelay prefabRelay, ProtoPartSnapshot pps) : base(prefabRelay)	public ProtoAntennaRelay(IAntennaRelay prefabRelay, ProtoPartSnapshot pps) : base(prefabRelay)
{	{
this.protoPart = pps;	this.protoPart = pps;
}	}

~ProtoAntennaRelay()	~ProtoAntennaRelay()
{	{
Tools.PostDebugMessage(string.Format(	Tools.PostDebugMessage(string.Format(
"{0}: destroyed",	"{0}: destroyed",
this.ToString()	this.ToString()
));	));
}	}
}	}
}	}

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

file:b/RelayExtensions.cs (new)

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

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

	namespace AntennaRange
	{
	/*
	* A class of utility extensions for Vessels and Relays to help find a relay path back to Kerbin.
	* */
	public static class RelayExtensions
	{
	/// <summary>
	/// Returns the distance between this IAntennaRelay and a Vessel
	/// </summary>
	/// <param name="relay">This <see cref="IAntennaRelay"/></param>
	/// <param name="Vessel">A <see cref="Vessel"/></param>
	public static double DistanceTo(this AntennaRelay relay, Vessel Vessel)
	{
	return relay.vessel.DistanceTo(Vessel);
	}

	/// <summary>
	/// Returns the distance between this IAntennaRelay and a CelestialBody
	/// </summary>
	/// <param name="relay">This <see cref="IAntennaRelay"/></param>
	/// <param name="body">A <see cref="CelestialBody"/></param>
	public static double DistanceTo(this AntennaRelay relay, CelestialBody body)
	{
	return relay.vessel.DistanceTo(body) - body.Radius;
	}

	/// <summary>
	/// Returns the distance between this IAntennaRelay and another IAntennaRelay
	/// </summary>
	/// <param name="relayOne">This <see cref="IAntennaRelay"/></param>
	/// <param name="relayTwo">Another <see cref="IAntennaRelay"/></param>
	public static double DistanceTo(this AntennaRelay relayOne, IAntennaRelay relayTwo)
	{
	return relayOne.DistanceTo(relayTwo.vessel);
	}

	public static double sqrDistanceTo(this AntennaRelay relay, Vessel vessel)
	{
	return relay.vessel.sqrDistanceTo(vessel);
	}

	public static double sqrDistanceTo(this AntennaRelay relay, CelestialBody body)
	{
	return relay.vessel.sqrDistanceTo(body);
	}

	public static double sqrDistanceTo(this AntennaRelay relayOne, IAntennaRelay relayTwo)
	{
	return relayOne.vessel.sqrDistanceTo(relayTwo.vessel);
	}

	/// <summary>
	/// Returns all of the PartModules or ProtoPartModuleSnapshots implementing IAntennaRelay in this Vessel.
	/// </summary>
	/// <param name="vessel">This <see cref="Vessel"/></param>
	public static IEnumerable<IAntennaRelay> GetAntennaRelays (this Vessel vessel)
	{
	return RelayDatabase.Instance[vessel].Values.ToList().AsReadOnly();
	}

	/// <summary>
	/// Determines if the specified vessel has a connected relay.
	/// </summary>
	/// <returns><c>true</c> if the specified vessel has a connected relay; otherwise, <c>false</c>.</returns>
	/// <param name="vessel"></param>
	public static bool HasConnectedRelay(this Vessel vessel)
	{
	foreach (IAntennaRelay relay in RelayDatabase.Instance[vessel].Values)
	{
	if (relay.CanTransmit())
	{
	return true;
	}
	}

	return false;
	}

	public static ConnectionStatus GetConnectionStatus(this Vessel vessel)
	{
	bool canTransmit = false;

	foreach (IAntennaRelay relay in RelayDatabase.Instance[vessel].Values)
	{
	if (relay.CanTransmit())
	{
	canTransmit = true;
	if (relay.transmitDistance <= relay.nominalTransmitDistance)
	{
	return ConnectionStatus.Optimal;
	}
	}
	}

	if (canTransmit)
	{
	return ConnectionStatus.Suboptimal;
	}
	else
	{
	return ConnectionStatus.None;
	}
	}

	public static IAntennaRelay GetBestRelay(this Vessel vessel)
	{
	IAntennaRelay bestRelay = null;
	double bestScore = double.PositiveInfinity;
	double relayScore = double.NaN;

	foreach (IAntennaRelay relay in vessel.GetAntennaRelays())
	{
	relayScore = relay.transmitDistance / relay.maxTransmitDistance;

	if (relayScore < bestScore)
	{
	bestScore = relayScore;
	bestRelay = relay;
	}
	}

	return bestRelay;
	}
	}

	public enum ConnectionStatus
	{
	None,
	Suboptimal,
	Optimal
	}
	}

file:b/toolbarIcon.xcf (new)

 Binary files /dev/null and b/toolbarIcon.xcf differ

file:b/toolbarIcon_24x24.xcf (new)

 Binary files /dev/null and b/toolbarIcon_24x24.xcf differ

file:b/toolbarIcon_38x38.xcf (new)

 Binary files /dev/null and b/toolbarIcon_38x38.xcf differ

// AntennaRange	// AntennaRange
//	//
// AssemblyInfo.cs	// AssemblyInfo.cs
//	//
// Copyright © 2014, toadicus	// Copyright © 2014, toadicus
// All rights reserved.	// All rights reserved.
//	//
// Redistribution and use in source and binary forms, with or without modification,	// Redistribution and use in source and binary forms, with or without modification,
// are permitted provided that the following conditions are met:	// are permitted provided that the following conditions are met:
//	//
// 1. Redistributions of source code must retain the above copyright notice,	// 1. Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.	// this list of conditions and the following disclaimer.
//	//
// 2. Redistributions in binary form must reproduce the above copyright notice,	// 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	// this list of conditions and the following disclaimer in the documentation and/or other
// materials provided with the distribution.	// materials provided with the distribution.
//	//
// 3. Neither the name of the copyright holder nor the names of its contributors may be used	// 3. Neither the name of the copyright holder nor the names of its contributors may be used
// to endorse or promote products derived from this software without specific prior written permission.	// to endorse or promote products derived from this software without specific prior written permission.
//	//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,	// 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	// 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,	// 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	// 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,	// 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	// 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.	// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

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

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

// Information about this assembly is defined by the following attributes.	// Information about this assembly is defined by the following attributes.
// Change them to the values specific to your project.	// Change them to the values specific to your project.
[assembly: AssemblyTitle("AntennaRange")]	[assembly: AssemblyTitle("AntennaRange")]
[assembly: AssemblyDescription("Enforce and Encourage Antenna Diversity")]	[assembly: AssemblyDescription("Enforce and Encourage Antenna Diversity")]
[assembly: AssemblyCopyright("toadicus")]	[assembly: AssemblyCopyright("toadicus")]
// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".	// The assembly version has the format "{Major}.{Minor}.{Build}.{Revision}".
// The form "{Major}.{Minor}.*" will automatically update the build and revision,	// The form "{Major}.{Minor}.*" will automatically update the build and revision,
// and "{Major}.{Minor}.{Build}.*" will update just the revision.	// and "{Major}.{Minor}.{Build}.*" will update just the revision.
[assembly: AssemblyVersion("1.0.0.*")]	[assembly: AssemblyVersion("1.8.*")]
// The following attributes are used to specify the signing key for the assembly,	// The following attributes are used to specify the signing key for the assembly,
// if desired. See the Mono documentation for more information about signing.	// if desired. See the Mono documentation for more information about signing.
//[assembly: AssemblyDelaySign(false)]	//[assembly: AssemblyDelaySign(false)]
//[assembly: AssemblyKeyFile("")]	//[assembly: AssemblyKeyFile("")]