Create README.md
Create README.md

Just the part dev portion so far, taken from http://goo.gl/3scCXl

// AntennaRange © 2014 toadicus // AntennaRange © 2014 toadicus
// //
// This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a // 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/ // copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/
   
using KSP; using KSP;
using System; using System;
using ToadicusTools; using ToadicusTools;
using UnityEngine; using UnityEngine;
   
namespace AntennaRange namespace AntennaRange
{ {
/// <summary> /// <summary>
/// A <see cref="UnityEngine.MonoBehaviour"/> responsible for managing configuration items for AntennaRange. /// A <see cref="UnityEngine.MonoBehaviour"/> responsible for managing configuration items for AntennaRange.
/// </summary> /// </summary>
[KSPAddon(KSPAddon.Startup.SpaceCentre, false)] [KSPAddon(KSPAddon.Startup.SpaceCentre, false)]
public class ARConfiguration : MonoBehaviour public class ARConfiguration : MonoBehaviour
{ {
private const string WINDOW_POS_KEY = "configWindowPos"; private const string WINDOW_POS_KEY = "configWindowPos";
private const string REQUIRE_LOS_KEY = "requireLineOfSight"; private const string REQUIRE_LOS_KEY = "requireLineOfSight";
private const string GRACE_RATIO_KEY = "graceRatio"; private const string GRACE_RATIO_KEY = "graceRatio";
private const string REQUIRE_PROBE_CONNECTION_KEY = "requireConnectionForControl"; private const string REQUIRE_PROBE_CONNECTION_KEY = "requireConnectionForControl";
private const string FIXED_POWER_KEY = "fixedPowerCost"; private const string FIXED_POWER_KEY = "fixedPowerCost";
private const string PRETTY_LINES_KEY = "drawPrettyLines"; private const string PRETTY_LINES_KEY = "drawPrettyLines";
private const string UPDATE_DELAY_KEY = "updateDelay"; private const string UPDATE_DELAY_KEY = "updateDelay";
private const string USE_ADDITIVE_KEY = "useAdditiveRanges";  
   
private const string TRACKING_STATION_RANGES_KEY = "TRACKING_STATION_RANGES";  
private const string RANGE_KEY = "range";  
   
/// <summary> /// <summary>
/// Indicates whether connections require line of sight. /// Indicates whether connections require line of sight.
/// </summary> /// </summary>
public static bool RequireLineOfSight public static bool RequireLineOfSight
{ {
get; get;
private set; private set;
} }
   
/// <summary> /// <summary>
/// A "fudge factor" ratio that pretends planets and moons are slightly smaller than reality to make /// A "fudge factor" ratio that pretends planets and moons are slightly smaller than reality to make
/// building communication constellations easier. /// building communication constellations easier.
/// </summary> /// </summary>
public static double RadiusRatio public static double RadiusRatio
{ {
get; get;
private set; private set;
} }
   
/// <summary> /// <summary>
/// Indicates whether unmanned vessels require a connection for control. /// Indicates whether unmanned vessels require a connection for control.
/// </summary> /// </summary>
public static bool RequireConnectionForControl public static bool RequireConnectionForControl
{ {
get; get;
private set; private set;
} }
   
/// <summary> /// <summary>
/// If true, relays will fix their power cost when above nominal range, decreasing data rate instead. /// If true, relays will fix their power cost when above nominal range, decreasing data rate instead.
/// </summary> /// </summary>
public static bool FixedPowerCost public static bool FixedPowerCost
{ {
get; get;
private set; private set;
} }
   
/// <summary> /// <summary>
/// Indicates whether this AntennaRange will draw pretty lines in map view. /// Indicates whether this AntennaRange will draw pretty lines in map view.
/// </summary> /// </summary>
public static bool PrettyLines public static bool PrettyLines
{ {
get; get;
set; set;
} }
   
/// <summary>  
/// Gets the update delay.  
/// </summary>  
public static long UpdateDelay public static long UpdateDelay
{ {
get; get;
private set; private set;
}  
   
/// <summary>  
/// Gets a value indicating whether AntennaRange will use additive ranges.  
/// </summary>  
public static bool UseAdditiveRanges  
{  
get;  
private set;  
}  
   
/// <summary>  
/// Gets Kerbin's relay range based on the current tracking station level.  
/// </summary>  
public static double KerbinRelayRange  
{  
get;  
private set;  
}  
   
/// <summary>  
/// Gets Kerbin's nominal relay range based on the current tracking station level.  
/// </summary>  
public static double KerbinNominalRange  
{  
get  
{  
return KerbinRelayRange / 2.8284271247461901d;  
}  
} }
   
#pragma warning disable 1591 #pragma warning disable 1591
   
private bool showConfigWindow; private bool showConfigWindow;
private Rect configWindowPos; private Rect configWindowPos;
   
private string updateDelayStr; private string updateDelayStr;
private long updateDelay; private long updateDelay;
   
private IButton toolbarButton; private IButton toolbarButton;
private ApplicationLauncherButton appLauncherButton; private ApplicationLauncherButton appLauncherButton;
   
private double[] trackingStationRanges;  
   
private System.Version runningVersion; private System.Version runningVersion;
   
private bool runOnce;  
   
private KSP.IO.PluginConfiguration _config; private KSP.IO.PluginConfiguration _config;
private KSP.IO.PluginConfiguration config private KSP.IO.PluginConfiguration config
{ {
get get
{ {
if (this._config == null) if (this._config == null)
{ {
this._config = KSP.IO.PluginConfiguration.CreateForType<AntennaRelay>(); this._config = KSP.IO.PluginConfiguration.CreateForType<AntennaRelay>();
} }
   
return this._config; return this._config;
} }
} }
   
public void Awake() public void Awake()
{ {
Tools.PostDebugMessage(this, "Waking up."); Tools.PostDebugMessage(this, "Waking up.");
   
this.runningVersion = this.GetType().Assembly.GetName().Version; this.runningVersion = this.GetType().Assembly.GetName().Version;
   
this.showConfigWindow = false; this.showConfigWindow = false;
this.configWindowPos = new Rect(Screen.width / 4, Screen.height / 2, 180, 15); this.configWindowPos = new Rect(Screen.width / 4, Screen.height / 2, 180, 15);
   
   
this.configWindowPos = this.LoadConfigValue(WINDOW_POS_KEY, this.configWindowPos); this.configWindowPos = this.LoadConfigValue(WINDOW_POS_KEY, this.configWindowPos);
   
ARConfiguration.RequireLineOfSight = this.LoadConfigValue(REQUIRE_LOS_KEY, false); ARConfiguration.RequireLineOfSight = this.LoadConfigValue(REQUIRE_LOS_KEY, false);
   
ARConfiguration.RadiusRatio = (1 - this.LoadConfigValue(GRACE_RATIO_KEY, .05d)); ARConfiguration.RadiusRatio = (1 - this.LoadConfigValue(GRACE_RATIO_KEY, .05d));
ARConfiguration.RadiusRatio *= ARConfiguration.RadiusRatio; ARConfiguration.RadiusRatio *= ARConfiguration.RadiusRatio;
   
ARConfiguration.RequireConnectionForControl = ARConfiguration.RequireConnectionForControl =
this.LoadConfigValue(REQUIRE_PROBE_CONNECTION_KEY, false); this.LoadConfigValue(REQUIRE_PROBE_CONNECTION_KEY, false);
   
ARConfiguration.FixedPowerCost = this.LoadConfigValue(FIXED_POWER_KEY, false); ARConfiguration.FixedPowerCost = this.LoadConfigValue(FIXED_POWER_KEY, false);
   
ARConfiguration.PrettyLines = this.LoadConfigValue(PRETTY_LINES_KEY, true); ARConfiguration.PrettyLines = this.LoadConfigValue(PRETTY_LINES_KEY, true);
   
ARConfiguration.UpdateDelay = this.LoadConfigValue(UPDATE_DELAY_KEY, 16L); ARConfiguration.UpdateDelay = this.LoadConfigValue(UPDATE_DELAY_KEY, 16L);
   
ARConfiguration.UseAdditiveRanges = this.LoadConfigValue(USE_ADDITIVE_KEY, true);  
   
this.updateDelayStr = ARConfiguration.UpdateDelay.ToString(); this.updateDelayStr = ARConfiguration.UpdateDelay.ToString();
   
GameEvents.onGameSceneLoadRequested.Add(this.onSceneChangeRequested); GameEvents.onGameSceneLoadRequested.Add(this.onSceneChangeRequested);
GameEvents.OnKSCFacilityUpgraded.Add(this.onFacilityUpgraded);  
   
Debug.Log(string.Format("{0} v{1} - ARConfiguration loaded!", this.GetType().Name, this.runningVersion)); Debug.Log(string.Format("{0} v{1} - ARConfiguration loaded!", this.GetType().Name, this.runningVersion));
   
ConfigNode[] tsRangeNodes = GameDatabase.Instance.GetConfigNodes(TRACKING_STATION_RANGES_KEY);  
   
if (tsRangeNodes.Length > 0)  
{  
string[] rangeValues = tsRangeNodes[0].GetValues(RANGE_KEY);  
   
this.trackingStationRanges = new double[rangeValues.Length];  
   
for (int idx = 0; idx < rangeValues.Length; idx++)  
{  
if (!double.TryParse(rangeValues[idx], out this.trackingStationRanges[idx]))  
{  
this.LogError("Could not parse value '{0}' to double; Tracking Station ranges may not work!");  
this.trackingStationRanges[idx] = 0d;  
}  
}  
   
this.Log("Loaded Tracking Station ranges from config: [{0}]", this.trackingStationRanges.SPrint());  
}  
else  
{  
this.trackingStationRanges = new double[]  
{  
51696576d,  
37152180000d,  
224770770000d  
};  
   
this.LogWarning("Failed to load Tracking Station ranges from config, using hard-coded values: [{0}]",  
this.trackingStationRanges.SPrint());  
}  
   
this.runOnce = true;  
   
Tools.PostDebugMessage(this, "Awake."); Tools.PostDebugMessage(this, "Awake.");
}  
   
public void Update()  
{  
if (  
this.runOnce &&  
(ScenarioUpgradeableFacilities.Instance != null || HighLogic.CurrentGame.Mode != Game.Modes.CAREER)  
)  
{  
this.runOnce = false;  
   
this.SetKerbinRelayRange();  
}  
} }
   
public void OnGUI() public void OnGUI()
{ {
// Only runs once, if the Toolbar is available. // Only runs once, if the Toolbar is available.
if (ToolbarManager.ToolbarAvailable) if (ToolbarManager.ToolbarAvailable)
{ {
if (this.toolbarButton == null) if (this.toolbarButton == null)
{ {
Tools.PostDebugMessage(this, "Toolbar available; initializing toolbar button."); Tools.PostDebugMessage(this, "Toolbar available; initializing toolbar button.");
   
this.toolbarButton = ToolbarManager.Instance.add("AntennaRange", "ARConfiguration"); this.toolbarButton = ToolbarManager.Instance.add("AntennaRange", "ARConfiguration");
this.toolbarButton.Visibility = new GameScenesVisibility(GameScenes.SPACECENTER); this.toolbarButton.Visibility = new GameScenesVisibility(GameScenes.SPACECENTER);
this.toolbarButton.Text = "AR"; this.toolbarButton.Text = "AR";
this.toolbarButton.TexturePath = "AntennaRange/Textures/toolbarIcon"; this.toolbarButton.TexturePath = "AntennaRange/Textures/toolbarIcon";
this.toolbarButton.TextColor = (Color)XKCDColors.Amethyst; this.toolbarButton.TextColor = (Color)XKCDColors.Amethyst;
this.toolbarButton.OnClick += delegate(ClickEvent e) this.toolbarButton.OnClick += delegate(ClickEvent e)
{ {
this.toggleConfigWindow(); this.toggleConfigWindow();
}; };
} }
} }
else if (this.appLauncherButton == null && ApplicationLauncher.Ready) else if (this.appLauncherButton == null && ApplicationLauncher.Ready)
{ {
Tools.PostDebugMessage(this, "Toolbar available; initializing AppLauncher button."); Tools.PostDebugMessage(this, "Toolbar available; initializing AppLauncher button.");
   
this.appLauncherButton = ApplicationLauncher.Instance.AddModApplication( this.appLauncherButton = ApplicationLauncher.Instance.AddModApplication(
this.toggleConfigWindow, this.toggleConfigWindow,
this.toggleConfigWindow, this.toggleConfigWindow,
ApplicationLauncher.AppScenes.SPACECENTER, ApplicationLauncher.AppScenes.SPACECENTER,
GameDatabase.Instance.GetTexture( GameDatabase.Instance.GetTexture(
"AntennaRange/Textures/appLauncherIcon", "AntennaRange/Textures/appLauncherIcon",
false false
) )
); );
} }
   
if (this.showConfigWindow) if (this.showConfigWindow)
{ {
Rect configPos = GUILayout.Window(354163056, Rect configPos = GUILayout.Window(354163056,
this.configWindowPos, this.configWindowPos,
this.ConfigWindow, this.ConfigWindow,
string.Format("AntennaRange {0}.{1}", this.runningVersion.Major, this.runningVersion.Minor), string.Format("AntennaRange {0}.{1}", this.runningVersion.Major, this.runningVersion.Minor),
GUILayout.ExpandHeight(true), GUILayout.ExpandHeight(true),
GUILayout.ExpandWidth(true) GUILayout.ExpandWidth(true)
); );
   
configPos = Tools.ClampRectToScreen(configPos, 20); configPos = Tools.ClampRectToScreen(configPos, 20);
   
if (configPos != this.configWindowPos) if (configPos != this.configWindowPos)
{ {
this.configWindowPos = configPos; this.configWindowPos = configPos;
this.SaveConfigValue(WINDOW_POS_KEY, this.configWindowPos); this.SaveConfigValue(WINDOW_POS_KEY, this.configWindowPos);
} }
} }
} }
   
public void ConfigWindow(int _) public void ConfigWindow(int _)
{ {
GUILayout.BeginVertical(GUILayout.ExpandHeight(true)); GUILayout.BeginVertical(GUILayout.ExpandHeight(true));
   
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
   
bool requireLineOfSight = GUITools.Toggle(ARConfiguration.RequireLineOfSight, "Require Line of Sight"); bool requireLineOfSight = GUITools.Toggle(ARConfiguration.RequireLineOfSight, "Require Line of Sight");
if (requireLineOfSight != ARConfiguration.RequireLineOfSight) if (requireLineOfSight != ARConfiguration.RequireLineOfSight)
{ {
ARConfiguration.RequireLineOfSight = requireLineOfSight; ARConfiguration.RequireLineOfSight = requireLineOfSight;
this.SaveConfigValue(REQUIRE_LOS_KEY, requireLineOfSight); this.SaveConfigValue(REQUIRE_LOS_KEY, requireLineOfSight);
} }
   
GUILayout.EndHorizontal(); GUILayout.EndHorizontal();
   
GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true));
   
bool requireConnectionForControl = bool requireConnectionForControl =
GUITools.Toggle( GUITools.Toggle(
ARConfiguration.RequireConnectionForControl, ARConfiguration.RequireConnectionForControl,
"Require Connection for Probe Control" "Require Connection for Probe Control"
); );
if (requireConnectionForControl != ARConfiguration.RequireConnectionForControl) if (requireConnectionForControl != ARConfiguration.RequireConnectionForControl)
{ {
ARConfiguration.RequireConnectionForControl = requireConnectionForControl; ARConfiguration.RequireConnectionForControl = requireConnectionForControl;
this.SaveConfigValue(REQUIRE_PROBE_CONNECTION_KEY, requireConnectionForControl); this.SaveConfigValue(REQUIRE_PROBE_CONNECTION_KEY, requireConnectionForControl);
} }
   
GUILayout.EndHorizontal(); GUILayout.EndHorizontal();
   
GUILayout.BeginHorizontal(); GUILayout.BeginHorizontal();
   
bool fixedPowerCost = GUITools.Toggle(ARConfiguration.FixedPowerCost, "Use Fixed Power Cost"); bool fixedPowerCost = GUITools.Toggle(ARConfiguration.FixedPowerCost, "Use Fixed Power Cost");
if (fixedPowerCost != ARConfiguration.FixedPowerCost) if (fixedPowerCost != ARConfiguration.FixedPowerCost)
{ {
ARConfiguration.FixedPowerCost = fixedPowerCost; ARConfiguration.FixedPowerCost = fixedPowerCost;
this.SaveConfigValue(FIXED_POWER_KEY, fixedPowerCost); this.SaveConfigValue(FIXED_POWER_KEY, fixedPowerCost);
} }
   
GUILayout.EndHorizontal(); GUILayout.EndHorizontal();
   
GUILayout.BeginHorizontal(); GUILayout.BeginHorizontal();
   
bool useAdditive = GUITools.Toggle(ARConfiguration.UseAdditiveRanges, "Use Additive Ranges");  
if (useAdditive != ARConfiguration.UseAdditiveRanges)  
{  
ARConfiguration.UseAdditiveRanges = useAdditive;  
this.SaveConfigValue(USE_ADDITIVE_KEY, useAdditive);  
}  
   
GUILayout.EndHorizontal();  
   
GUILayout.BeginHorizontal();  
   
bool prettyLines = GUITools.Toggle(ARConfiguration.PrettyLines, "Draw Pretty Lines"); bool prettyLines = GUITools.Toggle(ARConfiguration.PrettyLines, "Draw Pretty Lines");
if (prettyLines != ARConfiguration.PrettyLines) if (prettyLines != ARConfiguration.PrettyLines)
{ {
ARConfiguration.PrettyLines = prettyLines; ARConfiguration.PrettyLines = prettyLines;
this.SaveConfigValue(PRETTY_LINES_KEY, prettyLines); this.SaveConfigValue(PRETTY_LINES_KEY, prettyLines);
} }
   
GUILayout.EndHorizontal(); GUILayout.EndHorizontal();
   
GUILayout.BeginHorizontal(); GUILayout.BeginHorizontal();
   
GUILayout.Label("Update Delay", GUILayout.ExpandWidth(false)); GUILayout.Label("Update Delay", GUILayout.ExpandWidth(false));
   
this.updateDelayStr = GUILayout.TextField(this.updateDelayStr, 4, GUILayout.Width(40f)); this.updateDelayStr = GUILayout.TextField(this.updateDelayStr, 4, GUILayout.Width(40f));
   
GUILayout.Label("ms", GUILayout.ExpandWidth(false)); GUILayout.Label("ms", GUILayout.ExpandWidth(false));
   
GUILayout.EndHorizontal(); GUILayout.EndHorizontal();
   
if (this.updateDelayStr.Length > 1 && long.TryParse(this.updateDelayStr, out this.updateDelay)) if (this.updateDelayStr.Length > 1 && long.TryParse(this.updateDelayStr, out this.updateDelay))
{ {
ARConfiguration.UpdateDelay = Math.Min(Math.Max(this.updateDelay, 16), 2500); ARConfiguration.UpdateDelay = Math.Min(Math.Max(this.updateDelay, 16), 2500);
this.updateDelayStr = ARConfiguration.UpdateDelay.ToString(); this.updateDelayStr = ARConfiguration.UpdateDelay.ToString();
} }
   
if (requireLineOfSight) if (requireLineOfSight)
{ {
GUILayout.BeginHorizontal(); GUILayout.BeginHorizontal();
   
double graceRatio = 1d - Math.Sqrt(ARConfiguration.RadiusRatio); double graceRatio = 1d - Math.Sqrt(ARConfiguration.RadiusRatio);
double newRatio; double newRatio;
   
GUILayout.Label(string.Format("Line of Sight 'Fudge Factor': {0:P0}", graceRatio)); GUILayout.Label(string.Format("Line of Sight 'Fudge Factor': {0:P0}", graceRatio));
   
GUILayout.EndHorizontal(); GUILayout.EndHorizontal();
   
GUILayout.BeginHorizontal(); GUILayout.BeginHorizontal();
   
newRatio = GUILayout.HorizontalSlider((float)graceRatio, 0f, 1f, GUILayout.ExpandWidth(true)); newRatio = GUILayout.HorizontalSlider((float)graceRatio, 0f, 1f, GUILayout.ExpandWidth(true));
newRatio = Math.Round(newRatio, 2); newRatio = Math.Round(newRatio, 2);
   
if (newRatio != graceRatio) if (newRatio != graceRatio)
{ {
ARConfiguration.RadiusRatio = (1d - newRatio) * (1d - newRatio); ARConfiguration.RadiusRatio = (1d - newRatio) * (1d - newRatio);
this.SaveConfigValue(GRACE_RATIO_KEY, newRatio); this.SaveConfigValue(GRACE_RATIO_KEY, newRatio);
} }
   
GUILayout.EndHorizontal(); GUILayout.EndHorizontal();
} }
   
GUILayout.EndVertical(); GUILayout.EndVertical();
   
GUI.DragWindow(); GUI.DragWindow();
} }
   
public void OnDestroy() public void OnDestroy()
{ {
GameEvents.onGameSceneLoadRequested.Remove(this.onSceneChangeRequested); GameEvents.onGameSceneLoadRequested.Remove(this.onSceneChangeRequested);
GameEvents.OnKSCFacilityUpgraded.Remove(this.onFacilityUpgraded);  
   
if (this.toolbarButton != null) if (this.toolbarButton != null)
{ {
this.toolbarButton.Destroy(); this.toolbarButton.Destroy();
this.toolbarButton = null;  
} }
   
if (this.appLauncherButton != null) if (this.appLauncherButton != null)
{ {
ApplicationLauncher.Instance.RemoveModApplication(this.appLauncherButton); ApplicationLauncher.Instance.RemoveModApplication(this.appLauncherButton);
this.appLauncherButton = null; }
} }
}  
  protected void onSceneChangeRequested(GameScenes scene)
private void onSceneChangeRequested(GameScenes scene)  
{ {
if (scene != GameScenes.SPACECENTER) if (scene != GameScenes.SPACECENTER)
{ {
print("ARConfiguration: Requesting Destruction."); print("ARConfiguration: Requesting Destruction.");
MonoBehaviour.Destroy(this); MonoBehaviour.Destroy(this);
} }
} }
   
private void onFacilityUpgraded(Upgradeables.UpgradeableFacility fac, int lvl)  
{  
if (fac.id == "SpaceCenter/TrackingStation")  
{  
this.Log("Caught onFacilityUpgraded for {0} at level {1}", fac.id, lvl);  
this.SetKerbinRelayRange();  
}  
}  
   
private void SetKerbinRelayRange()  
{  
int tsLevel;  
   
if (HighLogic.CurrentGame.Mode == Game.Modes.CAREER)  
{  
tsLevel = ScenarioUpgradeableFacilities.protoUpgradeables["SpaceCenter/TrackingStation"]  
.facilityRefs[0].FacilityLevel;  
   
   
}  
else  
{  
tsLevel = this.trackingStationRanges.Length - 1;  
}  
   
if (tsLevel < this.trackingStationRanges.Length && tsLevel >= 0)  
{  
KerbinRelayRange = this.trackingStationRanges[tsLevel];  
this.Log("Setting Kerbin's range to {0}", KerbinRelayRange);  
}  
else  
{  
this.LogError("Could not set Kerbin's range with invalid Tracking Station level {0}", tsLevel);  
}  
}  
   
private void toggleConfigWindow() private void toggleConfigWindow()
{ {
this.showConfigWindow = !this.showConfigWindow; this.showConfigWindow = !this.showConfigWindow;
this.updateDelayStr = ARConfiguration.UpdateDelay.ToString(); this.updateDelayStr = ARConfiguration.UpdateDelay.ToString();
} }
   
private T LoadConfigValue<T>(string key, T defaultValue) private T LoadConfigValue<T>(string key, T defaultValue)
{ {
this.config.load(); this.config.load();
   
return config.GetValue(key, defaultValue); return config.GetValue(key, defaultValue);
} }
   
private void SaveConfigValue<T>(string key, T value) private void SaveConfigValue<T>(string key, T value)
{ {
this.config.load(); this.config.load();
   
this.config.SetValue(key, value); this.config.SetValue(key, value);
   
this.config.save(); this.config.save();
} }
} }
} }
   
// AntennaRange // AntennaRange
// //
// ARMapRenderer.cs // ARMapRenderer.cs
// //
// Copyright © 2014-2015, toadicus // Copyright © 2014-2015, 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.
   
#pragma warning disable 1591 #pragma warning disable 1591
   
using KSP; using KSP;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using ToadicusTools; using ToadicusTools;
using UnityEngine; using UnityEngine;
   
namespace AntennaRange namespace AntennaRange
{ {
public class ARMapRenderer : MonoBehaviour public class ARMapRenderer : MonoBehaviour
{ {
#region Fields #region Fields
private Dictionary<Guid, LineRenderer> vesselLineRenderers; private Dictionary<Guid, LineRenderer> vesselLineRenderers;
   
// Debug Stuff // Debug Stuff
#pragma warning disable 649 #pragma warning disable 649
private System.Diagnostics.Stopwatch timer; private System.Diagnostics.Stopwatch timer;
private Tools.DebugLogger log; private Tools.DebugLogger log;
private long relayStart; private long relayStart;
private long start; private long start;
#pragma warning restore 649 #pragma warning restore 649
   
#pragma warning disable 414 #pragma warning disable 414
private Color thisColor; private Color thisColor;
#pragma warning restore 414 #pragma warning restore 414
#endregion #endregion
   
#region Properties #region Properties
public LineRenderer this[Guid idx] public LineRenderer this[Guid idx]
{ {
get get
{ {
if (this.vesselLineRenderers == null) if (this.vesselLineRenderers == null)
{ {
this.vesselLineRenderers = new Dictionary<Guid, LineRenderer>(); this.vesselLineRenderers = new Dictionary<Guid, LineRenderer>();
} }
   
LineRenderer lr; LineRenderer lr;
   
if (this.vesselLineRenderers.TryGetValue(idx, out lr)) if (this.vesselLineRenderers.TryGetValue(idx, out lr))
{ {
return lr; return lr;
} }
else else
{ {
GameObject obj = new GameObject(); GameObject obj = new GameObject();
obj.layer = 31; obj.layer = 31;
   
lr = obj.AddComponent<LineRenderer>(); lr = obj.AddComponent<LineRenderer>();
   
// lr.SetColors(Color.green, Color.green); // lr.SetColors(Color.green, Color.green);
lr.material = MapView.OrbitLinesMaterial; lr.material = MapView.OrbitLinesMaterial;
// lr.SetVertexCount(2); // lr.SetVertexCount(2);
   
this.vesselLineRenderers[idx] = lr; this.vesselLineRenderers[idx] = lr;
   
return lr; return lr;
} }
} }
} }
#endregion #endregion
   
#region MonoBehaviour Lifecycle #region MonoBehaviour Lifecycle
private void Awake() private void Awake()
{ {
if (ARConfiguration.PrettyLines) if (ARConfiguration.PrettyLines)
{ {
this.vesselLineRenderers = new Dictionary<Guid, LineRenderer>(); this.vesselLineRenderers = new Dictionary<Guid, LineRenderer>();
} }
   
#if DEBUG #if DEBUG
this.timer = new System.Diagnostics.Stopwatch(); this.timer = new System.Diagnostics.Stopwatch();
this.log = Tools.DebugLogger.New(this); this.log = Tools.DebugLogger.New(this);
#endif #endif
} }
   
private void OnPreCull() private void OnPreCull()
{ {
if (!HighLogic.LoadedSceneIsFlight || !MapView.MapIsEnabled || !ARConfiguration.PrettyLines) if (!HighLogic.LoadedSceneIsFlight || !MapView.MapIsEnabled || !ARConfiguration.PrettyLines)
{ {
this.Cleanup(); this.Cleanup();
   
return; return;
} }
   
#if DEBUG #if DEBUG
timer.Restart(); timer.Restart();
#endif #endif
   
try try
{ {
log.Clear(); log.Clear();
   
log.AppendFormat("OnPreCull.\n"); log.AppendFormat("OnPreCull.\n");
   
log.AppendFormat("\tMapView: Draw3DLines: {0}\n" + log.AppendFormat("\tMapView: Draw3DLines: {0}\n" +
"\tMapView.MapCamera.camera.fieldOfView: {1}\n" + "\tMapView.MapCamera.camera.fieldOfView: {1}\n" +
"\tMapView.MapCamera.Distance: {2}\n", "\tMapView.MapCamera.Distance: {2}\n",
MapView.Draw3DLines, MapView.Draw3DLines,
MapView.MapCamera.camera.fieldOfView, MapView.MapCamera.camera.fieldOfView,
MapView.MapCamera.Distance MapView.MapCamera.Distance
); );
   
if (FlightGlobals.ready && FlightGlobals.Vessels != null) if (FlightGlobals.ready && FlightGlobals.Vessels != null)
{ {
log.AppendLine("FlightGlobals ready and Vessels list not null."); log.AppendLine("FlightGlobals ready and Vessels list not null.");
   
for (int i = 0; i < FlightGlobals.Vessels.Count; i++) for (int i = 0; i < FlightGlobals.Vessels.Count; i++)
{ {
Vessel vessel = FlightGlobals.Vessels[i]; Vessel vessel = FlightGlobals.Vessels[i];
   
log.AppendFormat("\nStarting check for vessel {0} at {1}ms", vessel, timer.ElapsedMilliseconds); log.AppendFormat("\nStarting check for vessel {0} at {1}ms", vessel, timer.ElapsedMilliseconds);
   
if (vessel == null) if (vessel == null)
{ {
log.AppendFormat("\n\tSkipping vessel {0} altogether because it is null.", vessel); log.AppendFormat("\n\tSkipping vessel {0} altogether because it is null.", vessel);
continue; continue;
} }
   
switch (vessel.vesselType) switch (vessel.vesselType)
{ {
case VesselType.Debris: case VesselType.Debris:
case VesselType.EVA: case VesselType.EVA:
case VesselType.Unknown: case VesselType.Unknown:
case VesselType.SpaceObject: case VesselType.SpaceObject:
log.AppendFormat("\n\tDiscarded because vessel is of invalid type {0}", log.AppendFormat("\n\tDiscarded because vessel is of invalid type {0}",
vessel.vesselType); vessel.vesselType);
continue; continue;
} }
   
log.AppendFormat("\n\tChecking vessel {0}.", vessel.vesselName); log.AppendFormat("\n\tChecking vessel {0}.", vessel.vesselName);
   
#if DEBUG #if DEBUG
start = timer.ElapsedMilliseconds; start = timer.ElapsedMilliseconds;
#endif #endif
   
IAntennaRelay vesselRelay = vessel.GetBestRelay(); IAntennaRelay vesselRelay = vessel.GetBestRelay();
   
if (vesselRelay == null) if (vesselRelay == null)
{ {
log.AppendFormat("\n\tGot null relay for vessel {0}", vessel.vesselName); log.AppendFormat("\n\tGot null relay for vessel {0}", vessel.vesselName);
continue; continue;
} }
   
log.AppendFormat("\n\tGot best relay {0} ({3}) for vessel {1} in {2} ms", log.AppendFormat("\n\tGot best relay {0} ({3}) for vessel {1} in {2} ms",
vesselRelay, vessel, timer.ElapsedMilliseconds - start, vesselRelay.GetType().Name); vesselRelay, vessel, timer.ElapsedMilliseconds - start, vesselRelay.GetType().Name);
   
if (vesselRelay != null) if (vesselRelay != null)
{ {
#if DEBUG #if DEBUG
start = timer.ElapsedMilliseconds; start = timer.ElapsedMilliseconds;
#endif #endif
   
this.SetRelayVertices(vesselRelay); this.SetRelayVertices(vesselRelay);
   
log.AppendFormat("\n\tSet relay vertices for {0} in {1}ms", log.AppendFormat("\n\tSet relay vertices for {0} in {1}ms",
vessel, timer.ElapsedMilliseconds - start); vessel, timer.ElapsedMilliseconds - start);
} }
} }
} }
} }
catch (Exception ex) catch (Exception ex)
{ {
this.LogError("Caught {0}: {1}\n{2}\n", ex.GetType().Name, ex.ToString(), ex.StackTrace.ToString()); this.LogError("Caught {0}: {1}\n{2}\n", ex.GetType().Name, ex.ToString(), ex.StackTrace.ToString());
this.Cleanup(); this.Cleanup();
} }
#if DEBUG #if DEBUG
finally finally
{ {
log.AppendFormat("\n\tOnPreCull finished in {0}ms\n", timer.ElapsedMilliseconds); log.AppendFormat("\n\tOnPreCull finished in {0}ms\n", timer.ElapsedMilliseconds);
   
log.Print(); log.Print();
} }
#endif #endif
} }
   
private void OnDestroy() private void OnDestroy()
{ {
this.Cleanup(); this.Cleanup();
   
this.Log("Destroyed"); this.Log("Destroyed");
} }
#endregion #endregion
   
#region Utility #region Utility
private void SetRelayVertices(IAntennaRelay relay) private void SetRelayVertices(IAntennaRelay relay)
{ {
log.AppendFormat("\n\t\tDrawing line for relay chain starting at {0}.", relay); log.AppendFormat("\n\t\tDrawing line for relay chain starting at {0}.", relay);
   
if (relay.vessel == null) if (relay.vessel == null)
{ {
log.Append("\n\t\tvessel is null, bailing out"); log.Append("\n\t\tvessel is null, bailing out");
return; return;
} }
   
LineRenderer renderer = this[relay.vessel.id]; LineRenderer renderer = this[relay.vessel.id];
Vector3d start = ScaledSpace.LocalToScaledSpace(relay.vessel.GetWorldPos3D()); Vector3d start = ScaledSpace.LocalToScaledSpace(relay.vessel.GetWorldPos3D());
   
float lineWidth; float lineWidth;
float d = Screen.height / 2f + 0.01f; float d = Screen.height / 2f + 0.01f;
   
if (MapView.Draw3DLines) if (MapView.Draw3DLines)
{ {
lineWidth = 0.005859375f * MapView.MapCamera.Distance; lineWidth = 0.005859375f * MapView.MapCamera.Distance;
} }
else else
{ {
lineWidth = 2f; lineWidth = 2f;
   
start = MapView.MapCamera.camera.WorldToScreenPoint(start); start = MapView.MapCamera.camera.WorldToScreenPoint(start);
   
start.z = start.z >= 0f ? d : -d; start.z = start.z >= 0f ? d : -d;
} }
   
renderer.SetWidth(lineWidth, lineWidth); renderer.SetWidth(lineWidth, lineWidth);
   
renderer.SetPosition(0, start); renderer.SetPosition(0, start);
   
int idx = 0; int idx = 0;
   
#if DEBUG #if DEBUG
relayStart = timer.ElapsedMilliseconds; relayStart = timer.ElapsedMilliseconds;
#endif #endif
   
Vector3d nextPoint; Vector3d nextPoint;
   
renderer.enabled = true; renderer.enabled = true;
   
if (!relay.CanTransmit()) if (!relay.CanTransmit())
{ {
thisColor = Color.red; thisColor = Color.red;
} }
else else
{ {
if (relay.LinkStatus == ConnectionStatus.Optimal) if (relay.transmitDistance < relay.nominalTransmitDistance)
{ {
thisColor = Color.green; thisColor = Color.green;
} }
else else
{ {
thisColor = Color.yellow; thisColor = Color.yellow;
} }
} }
   
if (relay.KerbinDirect) if (relay.KerbinDirect)
{ {
nextPoint = ScaledSpace.LocalToScaledSpace(AntennaRelay.Kerbin.position); nextPoint = ScaledSpace.LocalToScaledSpace(AntennaRelay.Kerbin.position);
} }
else else
{ {
if (relay.targetRelay == null || relay.targetRelay.vessel == null) if (relay.targetRelay == null || relay.targetRelay.vessel == null)
{ {
this.LogError( this.LogError(
"SetRelayVertices: relay {0} has null target relay or vessel when not KerbinDirect, bailing out!", "SetRelayVertices: relay {0} has null target relay or vessel when not KerbinDirect, bailing out!",
relay relay
); );
   
renderer.enabled = false; renderer.enabled = false;
return; return;
} }
   
nextPoint = ScaledSpace.LocalToScaledSpace(relay.targetRelay.vessel.GetWorldPos3D()); nextPoint = ScaledSpace.LocalToScaledSpace(relay.targetRelay.vessel.GetWorldPos3D());
} }
   
renderer.SetColors(thisColor, thisColor); renderer.SetColors(thisColor, thisColor);
   
if (!MapView.Draw3DLines) if (!MapView.Draw3DLines)
{ {
nextPoint = MapView.MapCamera.camera.WorldToScreenPoint(nextPoint); nextPoint = MapView.MapCamera.camera.WorldToScreenPoint(nextPoint);
nextPoint.z = nextPoint.z >= 0f ? d : -d; nextPoint.z = nextPoint.z >= 0f ? d : -d;
} }
   
idx++; idx++;
   
renderer.SetVertexCount(idx + 1); renderer.SetVertexCount(idx + 1);
renderer.SetPosition(idx, nextPoint); renderer.SetPosition(idx, nextPoint);
   
log.AppendFormat("\n\t\t\t...finished segment in {0} ms", timer.ElapsedMilliseconds - relayStart); log.AppendFormat("\n\t\t\t...finished segment in {0} ms", timer.ElapsedMilliseconds - relayStart);
} }
   
private void Cleanup() private void Cleanup()
{ {
if (this.vesselLineRenderers != null && this.vesselLineRenderers.Count > 0) if (this.vesselLineRenderers != null && this.vesselLineRenderers.Count > 0)
{ {
IEnumerator<LineRenderer> enumerator = this.vesselLineRenderers.Values.GetEnumerator(); IEnumerator<LineRenderer> enumerator = this.vesselLineRenderers.Values.GetEnumerator();
LineRenderer lineRenderer; LineRenderer lineRenderer;
   
while (enumerator.MoveNext()) while (enumerator.MoveNext())
{ {
lineRenderer = enumerator.Current; lineRenderer = enumerator.Current;
lineRenderer.enabled = false; lineRenderer.enabled = false;
GameObject.Destroy(lineRenderer.gameObject); GameObject.Destroy(lineRenderer.gameObject);
} }
this.vesselLineRenderers.Clear(); this.vesselLineRenderers.Clear();
} }
} }
#endregion #endregion
} }
} }
   
// AntennaRange // AntennaRange
// //
// AntennaRelay.cs // AntennaRelay.cs
// //
// Copyright © 2014-2015, toadicus // Copyright © 2014-2015, 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 ToadicusTools; using ToadicusTools;
   
namespace AntennaRange namespace AntennaRange
{ {
/// <summary> /// <summary>
/// Relay code at the heart of AntennaRange /// Relay code at the heart of AntennaRange
/// </summary> /// </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.
private static CelestialBody _Kerbin; private static CelestialBody _Kerbin;
   
/// <summary> /// <summary>
/// Fetches, caches, and returns a <see cref="CelestialBody"/> reference to Kerbin /// Fetches, caches, and returns a <see cref="CelestialBody"/> reference to Kerbin
/// </summary> /// </summary>
public static CelestialBody Kerbin public static CelestialBody Kerbin
{ {
get get
{ {
if (_Kerbin == null && FlightGlobals.ready) if (_Kerbin == null && FlightGlobals.ready)
{ {
_Kerbin = FlightGlobals.GetHomeBody(); _Kerbin = FlightGlobals.GetHomeBody();
} }
   
return _Kerbin; return _Kerbin;
} }
} }
   
private bool canTransmit; private bool canTransmit;
private bool isChecked; private bool isChecked;
   
private IAntennaRelay nearestRelay; private IAntennaRelay nearestRelay;
private IAntennaRelay bestOccludedRelay; private IAntennaRelay bestOccludedRelay;
   
/// <summary> /// <summary>
/// The <see cref="AntennaRange.ModuleLimitedDataTransmitter"/> reference underlying this AntennaRelay, as an /// The <see cref="AntennaRange.ModuleLimitedDataTransmitter"/> reference underlying this AntennaRelay, as an
/// <see cref="AntennaRange.IAntennaRelay"/> /// <see cref="AntennaRange.IAntennaRelay"/>
/// </summary> /// </summary>
protected IAntennaRelay moduleRef; protected IAntennaRelay moduleRef;
   
/// <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 the target <see cref="AntennaRange.IAntennaRelay"/>relay. /// Gets the target <see cref="AntennaRange.IAntennaRelay"/>relay.
/// </summary> /// </summary>
public IAntennaRelay targetRelay public IAntennaRelay targetRelay
{ {
get; get;
protected set; protected set;
} }
   
/// <summary> /// <summary>
  /// Gets the first <see cref="CelestialBody"/> found to be blocking line of sight.
  /// </summary>
  public virtual CelestialBody firstOccludingBody
  {
  get;
  protected set;
  }
   
  /// <summary>
  /// Gets the transmit distance.
  /// </summary>
  /// <value>The transmit distance.</value>
  public double transmitDistance
  {
  get
  {
  if (this.KerbinDirect || this.targetRelay == null)
  {
  return this.DistanceTo(Kerbin);
  }
  else
  {
  return this.DistanceTo(this.targetRelay);
  }
  }
  }
   
  /// <summary>
  /// Gets the nominal transmit distance at which the Antenna behaves just as prescribed by Squad's config.
  /// </summary>
  public virtual double nominalTransmitDistance
  {
  get;
  set;
  }
   
  /// <summary>
  /// The maximum distance at which this relay can operate.
  /// </summary>
  /// <value>The max transmit distance.</value>
  public virtual double maxTransmitDistance
  {
  get;
  set;
  }
   
  /// <summary>
/// Gets a value indicating whether this <see cref="AntennaRange.IAntennaRelay"/> Relay is communicating /// Gets a value indicating whether this <see cref="AntennaRange.IAntennaRelay"/> Relay is communicating
/// directly with Kerbin. /// directly with Kerbin.
/// </summary> /// </summary>
public virtual bool KerbinDirect public virtual bool KerbinDirect
{ {
get; get;
protected set; protected set;
}  
   
/// <summary>  
/// Gets or sets the nominal link distance, in meters.  
/// </summary>  
public virtual double NominalLinkDistance  
{  
get;  
protected set;  
}  
   
/// <summary>  
/// Gets or sets the maximum link distance, in meters.  
/// </summary>  
public virtual double MaximumLinkDistance  
{  
get;  
protected set;  
}  
   
/// <summary>  
/// Gets the first <see cref="CelestialBody"/> found to be blocking line of sight.  
/// </summary>  
public virtual CelestialBody firstOccludingBody  
{  
get;  
protected set;  
}  
   
/// <summary>  
/// Gets the transmit distance.  
/// </summary>  
/// <value>The transmit distance.</value>  
public double transmitDistance  
{  
get  
{  
if (this.KerbinDirect || this.targetRelay == null)  
{  
return this.DistanceTo(Kerbin);  
}  
else  
{  
return this.DistanceTo(this.targetRelay);  
}  
}  
}  
   
public virtual ConnectionStatus LinkStatus  
{  
get;  
protected set;  
}  
   
/// <summary>  
/// Gets the nominal transmit distance at which the Antenna behaves just as prescribed by Squad's config.  
/// </summary>  
public virtual double nominalTransmitDistance  
{  
get;  
set;  
}  
   
/// <summary>  
/// The maximum distance at which this relay can operate.  
/// </summary>  
/// <value>The max transmit distance.</value>  
public virtual double maxTransmitDistance  
{  
get;  
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()
{ {
return this.canTransmit; return this.canTransmit;
} }
   
/// <summary> /// <summary>
/// Finds the nearest relay. /// Finds the nearest relay.
/// </summary> /// </summary>
/// <returns>The nearest relay or null, if no relays in range.</returns> /// <returns>The nearest relay or null, if no relays in range.</returns>
public void FindNearestRelay() public void FindNearestRelay()
{ {
if (!FlightGlobals.ready) if (!FlightGlobals.ready)
{ {
return; return;
} }
   
Tools.DebugLogger log; Tools.DebugLogger log;
#if DEBUG #if DEBUG
log = Tools.DebugLogger.New(this); log = Tools.DebugLogger.New(this);
#endif #endif
   
// Skip vessels that have already been checked for a nearest relay this pass. // Skip vessels that have already been checked for a nearest relay this pass.
if (this.isChecked) if (this.isChecked)
{ {
log.AppendFormat("{0}: Target search skipped because our vessel has been checked already this search.", log.AppendFormat("{0}: Target search skipped because our vessel has been checked already this search.",
this); this);
log.Print(); log.Print();
return; return;
} }
   
log.AppendFormat("{0}: Target search started).", this.ToString()); log.AppendFormat("{0}: Target search started).", this.ToString());
   
#if DEBUG #if DEBUG
try { try {
#endif #endif
// 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.
this.isChecked = true; this.isChecked = true;
   
// Blank everything we're trying to find before the search. // Blank everything we're trying to find before the search.
this.firstOccludingBody = null; this.firstOccludingBody = null;
this.bestOccludedRelay = null; this.bestOccludedRelay = null;
this.targetRelay = null; this.targetRelay = null;
this.nearestRelay = null; this.nearestRelay = null;
   
// Default to KerbinDirect = true in case something in here doesn't work right. // Default to KerbinDirect = true in case something in here doesn't work right.
this.KerbinDirect = true; this.KerbinDirect = true;
   
CelestialBody bodyOccludingBestOccludedRelay = null; CelestialBody bodyOccludingBestOccludedRelay = null;
IAntennaRelay needle; IAntennaRelay needle;
   
// double nearestRelaySqrDistance = double.PositiveInfinity; double nearestRelaySqrDistance = double.PositiveInfinity;
// double bestOccludedSqrDistance = double.PositiveInfinity; double bestOccludedSqrDistance = double.PositiveInfinity;
  double maxTransmitSqrDistance = this.maxTransmitDistance * this.maxTransmitDistance;
// double maxTransmitSqrDistance = double.NegativeInfinity;  
   
double nearestRelaySqrQuotient = double.PositiveInfinity;  
double bestOccludedSqrQuotient = double.PositiveInfinity;  
   
/* /*
* 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.
* */ * */
Vessel potentialVessel; Vessel potentialVessel;
IAntennaRelay potentialBestRelay; IAntennaRelay potentialBestRelay;
CelestialBody fob; CelestialBody fob;
   
// IList<IAntennaRelay> vesselRelays; // IList<IAntennaRelay> vesselRelays;
for (int vIdx = 0; vIdx < FlightGlobals.Vessels.Count; vIdx++) for (int vIdx = 0; vIdx < FlightGlobals.Vessels.Count; vIdx++)
{ {
log.AppendFormat("\nFetching vessel at index {0}", vIdx); log.AppendFormat("\nFetching vessel at index {0}", vIdx);
potentialVessel = FlightGlobals.Vessels[vIdx]; potentialVessel = FlightGlobals.Vessels[vIdx];
if (potentialVessel == null) if (potentialVessel == null)
{ {
Tools.PostErrorMessage("{0}: Skipping vessel at index {1} because it is null.", this, vIdx); Tools.PostErrorMessage("{0}: Skipping vessel at index {1} because it is null.", this, vIdx);
log.AppendFormat("\n\tSkipping vessel at index {0} because it is null.", vIdx); log.AppendFormat("\n\tSkipping vessel at index {0} because it is null.", vIdx);
log.Print(); log.Print();
return; return;
} }
#if DEBUG #if DEBUG
else else
{ {
log.AppendFormat("\n\tGot vessel {0}", potentialVessel); log.AppendFormat("\n\tGot vessel {0}", potentialVessel);
} }
#endif #endif
   
// Skip vessels of the wrong type. // Skip vessels of the wrong type.
log.Append("\n\tchecking vessel type"); log.Append("\n\tchecking vessel 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:
log.Append("\n\tSkipping because vessel is the wrong type."); log.Append("\n\tSkipping because vessel is the wrong type.");
continue; continue;
default: default:
break; break;
} }
log.Append("\n\tchecking if vessel is this vessel"); log.Append("\n\tchecking if vessel is this vessel");
// Skip vessels with the wrong ID // Skip vessels with the wrong ID
if (potentialVessel.id == vessel.id) if (potentialVessel.id == vessel.id)
{ {
log.Append("\n\tSkipping because vessel is this vessel."); log.Append("\n\tSkipping because vessel is this vessel.");
continue; continue;
} }
   
potentialBestRelay = potentialVessel.GetBestRelay();  
log.AppendFormat("\n\t\tgot best vessel relay {0}",  
potentialBestRelay == null ? "null" : potentialBestRelay.ToString());  
   
if (potentialBestRelay == null)  
{  
log.Append("\n\t\t...skipping null relay");  
continue;  
}  
   
// Find the distance from here to the vessel... // Find the distance from here to the vessel...
log.Append("\n\tgetting distance to potential vessel"); log.Append("\n\tgetting distance to potential vessel");
double potentialSqrDistance = this.sqrDistanceTo(potentialVessel); double potentialSqrDistance = this.sqrDistanceTo(potentialVessel);
log.Append("\n\tgetting best vessel relay"); log.Append("\n\tgetting best vessel relay");
   
log.Append("\n\tgetting max link distance to potential relay"); potentialBestRelay = potentialVessel.GetBestRelay();
double maxLinkSqrDistance; log.AppendFormat("\n\t\tgot best vessel relay {0}",
  potentialBestRelay == null ? "null" : potentialBestRelay.ToString());
if (ARConfiguration.UseAdditiveRanges)  
{ if (potentialBestRelay == null)
maxLinkSqrDistance = this.maxTransmitDistance * potentialBestRelay.maxTransmitDistance; {
} log.Append("\n\t\t...skipping null relay");
else continue;
{ }
maxLinkSqrDistance = this.maxTransmitDistance * this.maxTransmitDistance;  
}  
   
log.AppendFormat("\n\tmax link distance: {0}", maxLinkSqrDistance);  
   
double potentialSqrQuotient = potentialSqrDistance / maxLinkSqrDistance;  
   
log.Append("\n\t\tdoing LOS check"); log.Append("\n\t\tdoing LOS check");
// Skip vessels to which we do not have line of sight. // Skip vessels to which we do not have line of sight.
if ( if (
ARConfiguration.RequireLineOfSight && ARConfiguration.RequireLineOfSight &&
!this.vessel.hasLineOfSightTo(potentialVessel, out fob, ARConfiguration.RadiusRatio) !this.vessel.hasLineOfSightTo(potentialVessel, out fob, ARConfiguration.RadiusRatio)
) )
{ {
log.Append("\n\t\t...failed LOS check"); log.Append("\n\t\t...failed LOS check");
   
log.AppendFormat("\n\t\t\t{0}: Vessel {1} not in line of sight.", log.AppendFormat("\n\t\t\t{0}: Vessel {1} not in line of sight.",
this.ToString(), potentialVessel.vesselName); this.ToString(), potentialVessel.vesselName);
log.AppendFormat("\n\t\t\tpotentialSqrDistance: {0}", potentialSqrDistance); log.AppendFormat("\n\t\t\tpotentialSqrDistance: {0}", potentialSqrDistance);
log.AppendFormat("\n\t\t\tbestOccludedSqrQuotient: {0}", bestOccludedSqrQuotient); log.AppendFormat("\n\t\t\tbestOccludedSqrDistance: {0}", bestOccludedSqrDistance);
log.AppendFormat("\n\t\t\tmaxTransmitSqrDistance: {0}", maxLinkSqrDistance); log.AppendFormat("\n\t\t\tmaxTransmitSqrDistance: {0}", maxTransmitSqrDistance);
   
if ( if (
(potentialSqrQuotient < bestOccludedSqrQuotient) && (potentialSqrDistance < bestOccludedSqrDistance) &&
(potentialSqrQuotient <= 1d) && (potentialSqrDistance < maxTransmitSqrDistance) &&
potentialBestRelay.CanTransmit() potentialBestRelay.CanTransmit()
) )
{ {
log.Append("\n\t\t...vessel is close enough to and potentialBestRelay can transmit"); log.Append("\n\t\t...vessel is close enough to and potentialBestRelay can transmit");
log.AppendFormat("\n\t\t...{0} found new best occluded relay {1}", this, potentialBestRelay); log.AppendFormat("\n\t\t...{0} found new best occluded relay {1}", this, potentialBestRelay);
   
this.bestOccludedRelay = potentialBestRelay; this.bestOccludedRelay = potentialBestRelay;
bodyOccludingBestOccludedRelay = fob; bodyOccludingBestOccludedRelay = fob;
bestOccludedSqrQuotient = potentialSqrQuotient; bestOccludedSqrDistance = potentialSqrDistance;
} }
else else
{ {
log.Append("\n\t\t...vessel is not close enough to check for occluded relays, carrying on"); log.Append("\n\t\t...vessel is not close enough to check for occluded relays, carrying on");
} }
continue; continue;
} }
   
log.Append("\n\t\t...passed LOS check"); log.Append("\n\t\t...passed LOS check");
   
/* /*
* ...so that we can skip the vessel if it is further away than a vessel we've already checked. * ...so that we can skip the vessel if it is further away than a vessel we've already checked.
* */ * */
if (potentialSqrQuotient > nearestRelaySqrQuotient) if (potentialSqrDistance > nearestRelaySqrDistance)
{ {
log.AppendFormat("\n\t{0}: Vessel {1} discarded because it is farther than another the nearest relay.", log.AppendFormat("\n\t{0}: Vessel {1} discarded because it is farther than another the nearest relay.",
this.ToString(), this.ToString(),
potentialVessel.vesselName potentialVessel.vesselName
); );
continue; continue;
} }
   
log.Append("\n\t\t...passed distance check"); log.Append("\n\t\t...passed distance check");
   
if (potentialBestRelay.CanTransmit()) if (potentialBestRelay.CanTransmit())
{ {
needle = potentialBestRelay; needle = potentialBestRelay;
bool isCircular = false; bool isCircular = false;
   
int iterCount = 0; int iterCount = 0;
while (needle != null) while (needle != null)
{ {
iterCount++; iterCount++;
   
if (needle.KerbinDirect) if (needle.KerbinDirect)
{ {
break; break;
} }
   
if (needle.targetRelay == null) if (needle.targetRelay == null)
{ {
break; break;
} }
   
if (needle.targetRelay.vessel == this.vessel || needle == this.moduleRef) if (needle.targetRelay.vessel == this.vessel || needle == this.moduleRef)
{ {
isCircular = true; isCircular = true;
break; break;
} }
   
// Avoid infinite loops when we're not catching things right. // Avoid infinite loops when we're not catching things right.
if (iterCount > FlightGlobals.Vessels.Count) if (iterCount > FlightGlobals.Vessels.Count)
{ {
Tools.PostErrorMessage( Tools.PostErrorMessage(
"[{0}] iterCount exceeded while checking for circular network; assuming it is circular" + "[{0}] iterCount exceeded while checking for circular network; assuming it is circular" +
"\n\tneedle={1}" + "\n\tneedle={1}" +
"\n\tthis.moduleRef={2}", "\n\tthis.moduleRef={2}",
this, this,
needle == null ? "null" : string.Format( needle == null ? "null" : string.Format(
"{0}, needle.KerbinDirect={1}, needle.targetRelay={2}", "{0}, needle.KerbinDirect={1}, needle.targetRelay={2}",
needle, needle.KerbinDirect, needle.targetRelay == null ? "null" : string.Format( needle, needle.KerbinDirect, needle.targetRelay == null ? "null" : string.Format(
"{0}\n\tneedle.targetRelay.vessel={1}", "{0}\n\tneedle.targetRelay.vessel={1}",
needle.targetRelay, needle.targetRelay,
needle.targetRelay.vessel == null ? needle.targetRelay.vessel == null ?
"null" : needle.targetRelay.vessel.vesselName "null" : needle.targetRelay.vessel.vesselName
) )
), ),
this.moduleRef == null ? "null" : this.moduleRef.ToString() this.moduleRef == null ? "null" : this.moduleRef.ToString()
); );
isCircular = true; isCircular = true;
break; break;
} }
   
needle = needle.targetRelay; needle = needle.targetRelay;
} }
   
if (!isCircular) if (!isCircular)
{ {
nearestRelaySqrQuotient = potentialSqrQuotient; nearestRelaySqrDistance = potentialSqrDistance;
this.nearestRelay = potentialBestRelay; this.nearestRelay = potentialBestRelay;
   
log.AppendFormat("\n\t{0}: found new nearest relay {1} ({2}m²)", log.AppendFormat("\n\t{0}: found new nearest relay {1} ({2}m)",
this.ToString(), this.ToString(),
this.nearestRelay.ToString(), this.nearestRelay.ToString(),
Math.Sqrt(nearestRelaySqrQuotient) Math.Sqrt(nearestRelaySqrDistance)
); );
} }
else else
{ {
log.AppendFormat("\n\t\t...connection to {0} would result in a circular network, skipping", log.AppendFormat("\n\t\t...connection to {0} would result in a circular network, skipping",
potentialBestRelay potentialBestRelay
); );
} }
} }
} }
   
CelestialBody bodyOccludingKerbin = null; CelestialBody bodyOccludingKerbin = null;
   
double kerbinSqrDistance = this.vessel.DistanceTo(Kerbin) - Kerbin.Radius; double kerbinSqrDistance = this.vessel.DistanceTo(Kerbin) - Kerbin.Radius;
kerbinSqrDistance *= kerbinSqrDistance; kerbinSqrDistance *= kerbinSqrDistance;
   
double kerbinSqrQuotient;  
   
if (ARConfiguration.UseAdditiveRanges)  
{  
kerbinSqrQuotient = kerbinSqrDistance /  
(this.maxTransmitDistance * ARConfiguration.KerbinRelayRange);  
}  
else  
{  
kerbinSqrQuotient = kerbinSqrDistance /  
(this.maxTransmitDistance * this.maxTransmitDistance);  
}  
   
log.AppendFormat("\n{0} ({1}): Search done, figuring status.", this.ToString(), this.GetType().Name); log.AppendFormat("\n{0} ({1}): Search done, figuring status.", this.ToString(), this.GetType().Name);
log.AppendFormat( log.AppendFormat(
"\n{0}: nearestRelay={1} ({2}m²)), bestOccludedRelay={3} ({4}m²), kerbinSqrDistance={5}m²)", "\n{0}: nearestRelay={1} ({2}m²)), bestOccludedRelay={3} ({4}m²), kerbinSqrDistance={5}m²)",
this, this,
this.nearestRelay == null ? "null" : this.nearestRelay.ToString(), this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
nearestRelaySqrQuotient, nearestRelaySqrDistance,
this.bestOccludedRelay == null ? "null" : this.bestOccludedRelay.ToString(), this.bestOccludedRelay == null ? "null" : this.bestOccludedRelay.ToString(),
bestOccludedSqrQuotient, bestOccludedSqrDistance,
kerbinSqrDistance kerbinSqrDistance
); );
   
// If we don't have LOS to Kerbin, focus on relays // If we don't have LOS to Kerbin, focus on relays
if ( if (
ARConfiguration.RequireLineOfSight && ARConfiguration.RequireLineOfSight &&
!this.vessel.hasLineOfSightTo(Kerbin, out bodyOccludingKerbin, ARConfiguration.RadiusRatio) !this.vessel.hasLineOfSightTo(Kerbin, out bodyOccludingKerbin, ARConfiguration.RadiusRatio)
) )
{ {
log.AppendFormat("\n\tKerbin LOS is blocked by {0}.", bodyOccludingKerbin.bodyName); log.AppendFormat("\n\tKerbin LOS is blocked by {0}.", bodyOccludingKerbin.bodyName);
   
// nearestRelaySqrDistance will be infinity if all relays are occluded or none exist. // 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. // Therefore, this will only be true if a valid relay is in range.
if (nearestRelaySqrQuotient <= 1d) if (nearestRelaySqrDistance <= maxTransmitSqrDistance)
{ {
log.AppendFormat("\n\t\tCan transmit to nearby relay {0} ({1} <= {2}).", log.AppendFormat("\n\t\tCan transmit to nearby relay {0} ({1} <= {2}).",
this.nearestRelay == null ? "null" : this.nearestRelay.ToString(), this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
nearestRelaySqrQuotient, 1d); nearestRelaySqrDistance, maxTransmitSqrDistance);
   
this.KerbinDirect = false; this.KerbinDirect = false;
this.canTransmit = true; this.canTransmit = true;
this.targetRelay = this.nearestRelay; this.targetRelay = this.nearestRelay;
} }
// If this isn't true, we can't transmit, but pick a second best of bestOccludedRelay and Kerbin anyway // If this isn't true, we can't transmit, but pick a second best of bestOccludedRelay and Kerbin anyway
else else
{ {
log.AppendFormat("\n\t\tCan't transmit to nearby relay {0} ({1} > {2}).", log.AppendFormat("\n\t\tCan't transmit to nearby relay {0} ({1} > {2}).",
this.nearestRelay == null ? "null" : this.nearestRelay.ToString(), this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
nearestRelaySqrQuotient, 1d); nearestRelaySqrDistance, maxTransmitSqrDistance);
   
this.canTransmit = false; this.canTransmit = false;
   
// If the best occluded relay is closer than Kerbin, check it against the nearest relay. // If the best occluded relay is closer than Kerbin, check it against the nearest relay.
// Since bestOccludedSqrDistance is infinity if there are no occluded relays, this is safe // Since bestOccludedSqrDistance is infinity if there are no occluded relays, this is safe
if (bestOccludedSqrQuotient < kerbinSqrQuotient) if (bestOccludedSqrDistance < kerbinSqrDistance)
{ {
log.AppendFormat("\n\t\t\tBest occluded relay is closer than Kerbin ({0} < {1})", log.AppendFormat("\n\t\t\tBest occluded relay is closer than Kerbin ({0} < {1})",
bestOccludedRelay, kerbinSqrDistance); bestOccludedRelay, kerbinSqrDistance);
this.KerbinDirect = false; this.KerbinDirect = false;
   
// If the nearest relay is closer than the best occluded relay, pick it. // If the nearest relay is closer than the best occluded relay, pick it.
// Since nearestRelaySqrDistane is infinity if there are no nearby relays, this is safe. // Since nearestRelaySqrDistane is infinity if there are no nearby relays, this is safe.
if (nearestRelaySqrQuotient < bestOccludedSqrQuotient) if (nearestRelaySqrDistance < bestOccludedSqrDistance)
{ {
log.AppendFormat("\n\t\t\t\t...but the nearest relay is closer ({0} < {1}), so picking it.", log.AppendFormat("\n\t\t\t\t...but the nearest relay is closer ({0} < {1}), so picking it.",
nearestRelaySqrQuotient, bestOccludedSqrQuotient); nearestRelaySqrDistance, bestOccludedSqrDistance);
this.targetRelay = this.nearestRelay; this.targetRelay = this.nearestRelay;
this.firstOccludingBody = null; this.firstOccludingBody = null;
} }
// Otherwise, target the best occluded relay. // Otherwise, target the best occluded relay.
else else
{ {
log.AppendFormat("\n\t\t\t\t...and closer than the nearest relay ({0} >= {1}), so picking it.", log.AppendFormat("\n\t\t\t\t...and closer than the nearest relay ({0} >= {1}), so picking it.",
nearestRelaySqrQuotient, bestOccludedSqrQuotient); nearestRelaySqrDistance, bestOccludedSqrDistance);
this.targetRelay = bestOccludedRelay; this.targetRelay = bestOccludedRelay;
this.firstOccludingBody = bodyOccludingBestOccludedRelay; this.firstOccludingBody = bodyOccludingBestOccludedRelay;
} }
} }
// Otherwise, check Kerbin against the nearest relay. // Otherwise, check Kerbin against the nearest relay.
// Since we have LOS, blank the first occluding body. // Since we have LOS, blank the first occluding body.
else else
{ {
log.AppendFormat("\n\t\t\tKerbin is closer than the best occluded relay ({0} >= {1})", log.AppendFormat("\n\t\t\tKerbin is closer than the best occluded relay ({0} >= {1})",
bestOccludedRelay, kerbinSqrDistance); bestOccludedRelay, kerbinSqrDistance);
  this.firstOccludingBody = null;
   
// If the nearest relay is closer than Kerbin, pick it. // If the nearest relay is closer than Kerbin, pick it.
// Since nearestRelaySqrDistane is infinity if there are no nearby relays, this is safe. // Since nearestRelaySqrDistane is infinity if there are no nearby relays, this is safe.
if (nearestRelaySqrQuotient < kerbinSqrQuotient) if (nearestRelaySqrDistance < kerbinSqrDistance)
{ {
log.AppendFormat("\n\t\t\t\t...but the nearest relay is closer ({0} < {1}), so picking it.", log.AppendFormat("\n\t\t\t\t...but the nearest relay is closer ({0} < {1}), so picking it.",
nearestRelaySqrQuotient, kerbinSqrQuotient); nearestRelaySqrDistance, kerbinSqrDistance);
this.KerbinDirect = false; this.KerbinDirect = false;
this.firstOccludingBody = null;  
this.targetRelay = this.nearestRelay; this.targetRelay = this.nearestRelay;
} }
// Otherwise, pick Kerbin. // Otherwise, pick Kerbin.
else else
{ {
log.AppendFormat("\n\t\t\t\t...and closer than the nearest relay ({0} >= {1}), so picking it.", log.AppendFormat("\n\t\t\t\t...and closer than the nearest relay ({0} >= {1}), so picking it.",
nearestRelaySqrQuotient, kerbinSqrQuotient); nearestRelaySqrDistance, kerbinSqrDistance);
this.KerbinDirect = true; this.KerbinDirect = true;
this.firstOccludingBody = bodyOccludingKerbin;  
this.targetRelay = null; this.targetRelay = null;
} }
} }
} }
} }
// If we do have LOS to Kerbin, try to prefer the closest of nearestRelay and Kerbin // If we do have LOS to Kerbin, try to prefer the closest of nearestRelay and Kerbin
else else
{ {
log.AppendFormat("\n\tKerbin is in LOS."); log.AppendFormat("\n\tKerbin is in LOS.");
   
// If the nearest relay is closer than Kerbin and in range, transmit to it. // If the nearest relay is closer than Kerbin and in range, transmit to it.
if (nearestRelaySqrQuotient <= 1d) if (nearestRelaySqrDistance <= maxTransmitSqrDistance)
{ {
log.AppendFormat("\n\t\tCan transmit to nearby relay {0} ({1} <= {2}).", log.AppendFormat("\n\t\tCan transmit to nearby relay {0} ({1} <= {2}).",
this.nearestRelay == null ? "null" : this.nearestRelay.ToString(), this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
nearestRelaySqrQuotient, 1d); nearestRelaySqrDistance, maxTransmitSqrDistance);
   
this.canTransmit = true; this.canTransmit = true;
   
// If the nearestRelay is closer than Kerbin, use it. // If the nearestRelay is closer than Kerbin, use it.
if (nearestRelaySqrQuotient < kerbinSqrQuotient) if (nearestRelaySqrDistance < kerbinSqrDistance)
{ {
log.AppendFormat("\n\t\t\tPicking relay {0} over Kerbin ({1} < {2}).", log.AppendFormat("\n\t\t\tPicking relay {0} over Kerbin ({1} < {2}).",
this.nearestRelay == null ? "null" : this.nearestRelay.ToString(), this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
nearestRelaySqrQuotient, kerbinSqrQuotient); nearestRelaySqrDistance, kerbinSqrDistance);
   
this.KerbinDirect = false; this.KerbinDirect = false;
this.targetRelay = this.nearestRelay; this.targetRelay = this.nearestRelay;
} }
// Otherwise, Kerbin is closer, so use it. // Otherwise, Kerbin is closer, so use it.
else else
{ {
log.AppendFormat("\n\t\t\tBut picking Kerbin over nearby relay {0} ({1} >= {2}).", log.AppendFormat("\n\t\t\tBut picking Kerbin over nearby relay {0} ({1} >= {2}).",
this.nearestRelay == null ? "null" : this.nearestRelay.ToString(), this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
nearestRelaySqrQuotient, kerbinSqrQuotient); nearestRelaySqrDistance, kerbinSqrDistance);
   
this.KerbinDirect = true; this.KerbinDirect = true;
this.targetRelay = null; this.targetRelay = null;
} }
} }
// If the nearest relay is out of range, we still need to check on Kerbin. // If the nearest relay is out of range, we still need to check on Kerbin.
else else
{ {
log.AppendFormat("\n\t\tCan't transmit to nearby relay {0} ({1} > {2}).", log.AppendFormat("\n\t\tCan't transmit to nearby relay {0} ({1} > {2}).",
this.nearestRelay == null ? "null" : this.nearestRelay.ToString(), this.nearestRelay == null ? "null" : this.nearestRelay.ToString(),
nearestRelaySqrQuotient, 1d); nearestRelaySqrDistance, maxTransmitSqrDistance);
   
// If Kerbin is in range, use it. // If Kerbin is in range, use it.
if (kerbinSqrQuotient <= 1d) if (kerbinSqrDistance <= maxTransmitSqrDistance)
{ {
log.AppendFormat("\n\t\t\tCan transmit to Kerbin ({0} <= {1}).", log.AppendFormat("\n\t\t\tCan transmit to Kerbin ({0} <= {1}).",
kerbinSqrQuotient, 1d); kerbinSqrDistance, maxTransmitSqrDistance);
   
this.canTransmit = true; this.canTransmit = true;
this.KerbinDirect = true; this.KerbinDirect = true;
this.targetRelay = null; this.targetRelay = null;
} }
// If Kerbin is out of range and the nearest relay is out of range, pick a second best between // If Kerbin is out of range and the nearest relay is out of range, pick a second best between
// Kerbin and bestOccludedRelay // Kerbin and bestOccludedRelay
else else
{ {
log.AppendFormat("\n\t\t\tCan't transmit to Kerbin ({0} > {1}).", log.AppendFormat("\n\t\t\tCan't transmit to Kerbin ({0} > {1}).",
kerbinSqrQuotient, 1d); kerbinSqrDistance, maxTransmitSqrDistance);
   
this.canTransmit = false; this.canTransmit = false;
   
// If the best occluded relay is closer than Kerbin, check it against the nearest relay. // If the best occluded relay is closer than Kerbin, check it against the nearest relay.
// Since bestOccludedSqrDistance is infinity if there are no occluded relays, this is safe // Since bestOccludedSqrDistance is infinity if there are no occluded relays, this is safe
if (bestOccludedSqrQuotient < kerbinSqrQuotient) if (bestOccludedSqrDistance < kerbinSqrDistance)
{ {
log.AppendFormat("\n\t\t\tBest occluded relay is closer than Kerbin ({0} < {1})", log.AppendFormat("\n\t\t\tBest occluded relay is closer than Kerbin ({0} < {1})",
bestOccludedRelay, kerbinSqrDistance); bestOccludedRelay, kerbinSqrDistance);
this.KerbinDirect = false; this.KerbinDirect = false;
   
// If the nearest relay is closer than the best occluded relay, pick it. // If the nearest relay is closer than the best occluded relay, pick it.
// Since nearestRelaySqrDistane is infinity if there are no nearby relays, this is safe. // Since nearestRelaySqrDistane is infinity if there are no nearby relays, this is safe.
if (nearestRelaySqrQuotient < bestOccludedSqrQuotient) if (nearestRelaySqrDistance < bestOccludedSqrDistance)
{ {
log.AppendFormat("\n\t\t\t\t...but the nearest relay is closer ({0} < {1}), so picking it.", log.AppendFormat("\n\t\t\t\t...but the nearest relay is closer ({0} < {1}), so picking it.",
nearestRelaySqrQuotient, bestOccludedSqrQuotient); nearestRelaySqrDistance, bestOccludedSqrDistance);
this.targetRelay = this.nearestRelay; this.targetRelay = this.nearestRelay;
this.firstOccludingBody = null; this.firstOccludingBody = null;
} }
// Otherwise, target the best occluded relay. // Otherwise, target the best occluded relay.
else else
{ {
log.AppendFormat("\n\t\t\t\t...and closer than the nearest relay ({0} >= {1}), so picking it.", log.AppendFormat("\n\t\t\t\t...and closer than the nearest relay ({0} >= {1}), so picking it.",
nearestRelaySqrQuotient, bestOccludedSqrQuotient); nearestRelaySqrDistance, bestOccludedSqrDistance);
this.targetRelay = bestOccludedRelay; this.targetRelay = bestOccludedRelay;
this.firstOccludingBody = bodyOccludingBestOccludedRelay; this.firstOccludingBody = bodyOccludingBestOccludedRelay;
} }
} }
// Otherwise, check Kerbin against the nearest relay. // Otherwise, check Kerbin against the nearest relay.
// Since we have LOS, blank the first occluding body. // Since we have LOS, blank the first occluding body.
else else
{ {
log.AppendFormat("\n\t\t\tKerbin is closer than the best occluded relay ({0} >= {1})", log.AppendFormat("\n\t\t\tKerbin is closer than the best occluded relay ({0} >= {1})",
bestOccludedRelay, kerbinSqrDistance); bestOccludedRelay, kerbinSqrDistance);
this.firstOccludingBody = null; this.firstOccludingBody = null;
   
// If the nearest relay is closer than Kerbin, pick it. // If the nearest relay is closer than Kerbin, pick it.
// Since nearestRelaySqrDistane is infinity if there are no nearby relays, this is safe. // Since nearestRelaySqrDistane is infinity if there are no nearby relays, this is safe.
if (nearestRelaySqrQuotient < kerbinSqrQuotient) if (nearestRelaySqrDistance < kerbinSqrDistance)
{ {
log.AppendFormat("\n\t\t\t\t...but the nearest relay is closer ({0} < {1}), so picking it.", log.AppendFormat("\n\t\t\t\t...but the nearest relay is closer ({0} < {1}), so picking it.",
nearestRelaySqrQuotient, kerbinSqrQuotient); nearestRelaySqrDistance, kerbinSqrDistance);
this.KerbinDirect = false; this.KerbinDirect = false;
this.targetRelay = this.nearestRelay; this.targetRelay = this.nearestRelay;
} }
// Otherwise, pick Kerbin. // Otherwise, pick Kerbin.
else else
{ {
log.AppendFormat("\n\t\t\t\t...and closer than the nearest relay ({0} >= {1}), so picking it.", log.AppendFormat("\n\t\t\t\t...and closer than the nearest relay ({0} >= {1}), so picking it.",
nearestRelaySqrQuotient, kerbinSqrQuotient); nearestRelaySqrDistance, kerbinSqrDistance);
this.KerbinDirect = true; this.KerbinDirect = true;
this.targetRelay = null; this.targetRelay = null;
} }
} }
} }
} }
}  
   
if (ARConfiguration.UseAdditiveRanges)  
{  
if (this.KerbinDirect)  
{  
this.NominalLinkDistance = Math.Sqrt(this.nominalTransmitDistance * ARConfiguration.KerbinNominalRange);  
this.MaximumLinkDistance = Math.Sqrt(this.maxTransmitDistance * ARConfiguration.KerbinRelayRange);  
}  
else  
{  
this.NominalLinkDistance = Math.Sqrt(this.nominalTransmitDistance * this.targetRelay.nominalTransmitDistance);  
this.MaximumLinkDistance = Math.Sqrt(this.maxTransmitDistance * this.targetRelay.maxTransmitDistance);  
}  
}  
else  
{  
this.NominalLinkDistance = this.nominalTransmitDistance;  
this.MaximumLinkDistance = this.maxTransmitDistance;  
}  
   
if (this.canTransmit)  
{  
if (this.transmitDistance < this.NominalLinkDistance)  
{  
this.LinkStatus = ConnectionStatus.Optimal;  
}  
else  
{  
this.LinkStatus = ConnectionStatus.Suboptimal;  
}  
}  
else  
{  
this.LinkStatus = ConnectionStatus.None;  
} }
   
log.AppendFormat("\n{0}: Target search and status determination complete.", this.ToString()); log.AppendFormat("\n{0}: Target search and status determination complete.", this.ToString());
#if DEBUG #if DEBUG
} catch (Exception ex) { } catch (Exception ex) {
log.AppendFormat("\nCaught {0}: {1}\n{2}", ex.GetType().FullName, ex.ToString(), ex.StackTrace); log.AppendFormat("\nCaught {0}: {1}\n{2}", ex.GetType().FullName, ex.ToString(), ex.StackTrace);
#if QUIT_ON_EXCEPTION #if QUIT_ON_EXCEPTION
UnityEngine.Application.Quit(); UnityEngine.Application.Quit();
#endif #endif
} finally { } finally {
#endif #endif
log.Print(false); log.Print(false);
#if DEBUG #if DEBUG
} }
#endif #endif
// 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.
this.isChecked = false; this.isChecked = false;
} }
   
/// <summary> /// <summary>
/// Returns a <see cref="System.String"/> that represents the current <see cref="AntennaRange.AntennaRelay"/>. /// 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> /// <returns>A <see cref="System.String"/> that represents the current <see cref="AntennaRange.AntennaRelay"/>.</returns>
public override string ToString() public override string ToString()
{ {
if (this is ProtoAntennaRelay) if (this is ProtoAntennaRelay)
{ {
return (this as ProtoAntennaRelay).ToString(); return (this as ProtoAntennaRelay).ToString();
} }
return this.moduleRef.ToString(); return this.moduleRef.ToString();
} }
   
/// <summary> /// <summary>
/// Initializes a new instance of the <see cref="AntennaRange.AntennaRelay"/> class. /// Initializes a new instance of the <see cref="AntennaRange.AntennaRelay"/> class.
/// </summary> /// </summary>
/// <param name="module">The module reference underlying this AntennaRelay, /// <param name="module">The module reference underlying this AntennaRelay,
/// as an <see cref="AntennaRange.IAntennaRelay"/></param> /// as an <see cref="AntennaRange.IAntennaRelay"/></param>
public AntennaRelay(IAntennaRelay module) public AntennaRelay(IAntennaRelay module)
{ {
this.moduleRef = module; this.moduleRef = module;
this.isChecked = false; this.isChecked = false;
   
Tools.PostLogMessage("{0}: constructed {1}", this.GetType().Name, this.ToString()); Tools.PostLogMessage("{0}: constructed {1}", this.GetType().Name, this.ToString());
} }
} }
} }
   
   
// AntennaRange // AntennaRange
// //
// AntennaRange.cfg // AntennaRange.cfg
// //
// Copyright © 2014-2015, toadicus // Copyright © 2014-2015, 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.
// //
// This software uses the ModuleManager library © 2013 ialdabaoth, used under a Creative Commons Attribution-ShareAlike // This software uses the ModuleManager library © 2013 ialdabaoth, used under a Creative Commons Attribution-ShareAlike
// 3.0 Uported License. // 3.0 Uported License.
// //
// Specifications: // Specifications:
// nominalRange: The distance from Kerbin at which the antenna will perform exactly as prescribed by // nominalRange: The distance from Kerbin at which the antenna will perform exactly as prescribed by
// packetResourceCost and packetSize. // packetResourceCost and packetSize.
// maxPowerFactor: The multiplier on packetResourceCost that defines the maximum power output of the antenna. When the // maxPowerFactor: The multiplier on packetResourceCost that defines the maximum power output of the antenna. When the
// power cost exceeds packetResourceCost * maxPowerFactor, transmission will fail. // power cost exceeds packetResourceCost * maxPowerFactor, transmission will fail.
// maxDataFactor: The multipler on packetSize that defines the maximum data bandwidth of the antenna. // maxDataFactor: The multipler on packetSize that defines the maximum data bandwidth of the antenna.
// //
   
@PART[longAntenna]:FOR[AntennaRange]:NEEDS[!RemoteTech2] @PART[longAntenna]:FOR[AntennaRange]:NEEDS[!RemoteTech2]
{ {
@MODULE[ModuleDataTransmitter] @MODULE[ModuleDataTransmitter]
{ {
@name = ModuleLimitedDataTransmitter @name = ModuleLimitedDataTransmitter
nominalRange = 6364 nominalRange = 1500000
simpleRange = 20500000  
maxPowerFactor = 8 maxPowerFactor = 8
maxDataFactor = 4 maxDataFactor = 4
} }
   
MODULE MODULE
{ {
name = ModuleScienceContainer name = ModuleScienceContainer
   
dataIsCollectable = true dataIsCollectable = true
dataIsStorable = false dataIsStorable = false
   
storageRange = 2 storageRange = 2
} }
} }
   
@PART[mediumDishAntenna]:FOR[AntennaRange]:NEEDS[!RemoteTech2] @PART[mediumDishAntenna]:FOR[AntennaRange]:NEEDS[!RemoteTech2]
{ {
@MODULE[ModuleDataTransmitter] @MODULE[ModuleDataTransmitter]
{ {
@name = ModuleLimitedDataTransmitter @name = ModuleLimitedDataTransmitter
nominalRange = 3500000000 nominalRange = 30000000
simpleRange = 18000000000 maxPowerFactor = 8
maxPowerFactor = 4 maxDataFactor = 4
maxDataFactor = 8  
} }
   
MODULE MODULE
{ {
name = ModuleScienceContainer name = ModuleScienceContainer
   
dataIsCollectable = true dataIsCollectable = true
dataIsStorable = false dataIsStorable = false
   
storageRange = 2 storageRange = 2
} }
} }
   
@PART[commDish]:FOR[AntennaRange]:NEEDS[!RemoteTech2] @PART[commDish]:FOR[AntennaRange]:NEEDS[!RemoteTech2]
{ {
@MODULE[ModuleDataTransmitter] @MODULE[ModuleDataTransmitter]
{ {
@name = ModuleLimitedDataTransmitter @name = ModuleLimitedDataTransmitter
@packetResourceCost /= 1.414213 nominalRange = 80000000000
nominalRange = 10000000000 maxPowerFactor = 8
simpleRange = 56250000000 maxDataFactor = 4
maxPowerFactor = 16  
maxDataFactor = 2  
} }
   
MODULE MODULE
{ {
name = ModuleScienceContainer name = ModuleScienceContainer
   
dataIsCollectable = true dataIsCollectable = true
dataIsStorable = false dataIsStorable = false
   
storageRange = 2 storageRange = 2
} }
} }
   
TRACKING_STATION_RANGES  
{  
range = 800000  
range = 200000000000  
range = 2250000000000  
}  
   
EVA_MODULE EVA_MODULE
{ {
name = ModuleLimitedDataTransmitter name = ModuleLimitedDataTransmitter
   
nominalRange = 1389 nominalRange = 5000
maxPowerFactor = 1 maxPowerFactor = 1
maxDataFactor = 1 maxDataFactor = 1
   
packetInterval = 0.2 packetInterval = 0.2
packetSize = 1 packetSize = 1
packetResourceCost = 6.25 packetResourceCost = 6.25
   
requiredResource = ElectricCharge requiredResource = ElectricCharge
} }
   
EVA_RESOURCE EVA_RESOURCE
{ {
name = ElectricCharge name = ElectricCharge
amount = 100 amount = 100
maxAmount = 100 maxAmount = 100
} }
   
@EVA_RESOURCE[ElectricCharge]:AFTER[AntennaRange]:NEEDS[TacLifeSupport] @EVA_RESOURCE[ElectricCharge]:AFTER[AntennaRange]:NEEDS[TacLifeSupport]
{ {
!name = DELETE !name = DELETE
} }
   
// AntennaRange // AntennaRange
// //
// IAntennaRelay.cs // IAntennaRelay.cs
// //
// Copyright © 2014-2015, toadicus // Copyright © 2014-2015, 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> /// <summary>
/// Interface defining the basic functionality of AntennaRelay modules for AntennaRange. /// Interface defining the basic functionality of AntennaRelay modules for AntennaRange.
/// </summary> /// </summary>
public interface IAntennaRelay public interface IAntennaRelay
{ {
/// <summary> /// <summary>
/// Gets the parent Vessel. /// Gets the parent Vessel.
/// </summary> /// </summary>
Vessel vessel { get; } Vessel vessel { get; }
   
/// <summary> /// <summary>
/// Gets the target <see cref="AntennaRange.IAntennaRelay"/>relay. /// Gets the target <see cref="AntennaRange.IAntennaRelay"/>relay.
/// </summary> /// </summary>
IAntennaRelay targetRelay { get; } IAntennaRelay targetRelay { get; }
   
/// <summary> /// <summary>
/// Gets a value indicating whether this <see cref="AntennaRange.IAntennaRelay"/> Relay is communicating  
/// directly with Kerbin.  
/// </summary>  
bool KerbinDirect { get; }  
   
/// <summary>  
/// The link distance, in meters, at which this relay behaves nominally.  
/// </summary>  
double NominalLinkDistance { get; }  
   
   
/// <summary>  
/// The link distance, in meters, beyond which this relay cannot operate.  
/// </summary>  
double MaximumLinkDistance { get; }  
   
/// <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>
double transmitDistance { get; } double transmitDistance { get; }
   
/// <summary>  
/// Gets the link status.  
/// </summary>  
ConnectionStatus LinkStatus { get; }  
   
/// <summary> /// <summary>
/// Gets the nominal transmit distance at which the Antenna behaves just as prescribed by Squad's config. /// Gets the nominal transmit distance at which the Antenna behaves just as prescribed by Squad's config.
/// </summary> /// </summary>
double nominalTransmitDistance { get; } 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>
double maxTransmitDistance { get; } double maxTransmitDistance { get; }
   
/// <summary> /// <summary>
/// The first CelestialBody blocking line of sight to a /// The first CelestialBody blocking line of sight to a
/// </summary> /// </summary>
CelestialBody firstOccludingBody { get; } CelestialBody firstOccludingBody { get; }
   
  /// <summary>
  /// Gets a value indicating whether this <see cref="AntennaRange.IAntennaRelay"/> Relay is communicating
  /// directly with Kerbin.
  /// </summary>
  bool KerbinDirect { get; }
   
/// <summary> /// <summary>
/// Gets the Part title. /// Gets the Part title.
/// </summary> /// </summary>
string Title { get; } 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>. /// <c>true</c> if this instance can transmit; otherwise, <c>false</c>.
/// </summary> /// </summary>
bool CanTransmit(); bool CanTransmit();
   
/// <summary> /// <summary>
/// Finds the nearest relay. /// Finds the nearest relay.
/// </summary> /// </summary>
void FindNearestRelay(); void FindNearestRelay();
   
/// <summary> /// <summary>
/// Returns a <see cref="System.String"/> that represents the current <see cref="AntennaRange.IAntennaRelay"/>. /// Returns a <see cref="System.String"/> that represents the current <see cref="AntennaRange.IAntennaRelay"/>.
/// </summary> /// </summary>
string ToString(); string ToString();
} }
} }
   
   
// AntennaRange // AntennaRange
// //
// ModuleLimitedDataTransmitter.cs // ModuleLimitedDataTransmitter.cs
// //
// Copyright © 2014-2015, toadicus // Copyright © 2014-2015, 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;
using System.Collections.Generic; using System.Collections.Generic;
using System.Text; using System.Text;
using ToadicusTools; using ToadicusTools;
using UnityEngine; using UnityEngine;
   
namespace AntennaRange namespace AntennaRange
{ {
/// <summary> /// <summary>
/// <para>ModuleLimitedDataTransmitter is designed as a drop-in replacement for ModuleDataTransmitter, and handles /// <para>ModuleLimitedDataTransmitter is designed as a drop-in replacement for ModuleDataTransmitter, and handles
/// rangefinding, power scaling, and data scaling for antennas during science transmission. Its functionality /// rangefinding, power scaling, and data scaling for antennas during science transmission. Its functionality
/// varies with three tunables: nominalRange, maxPowerFactor, and maxDataFactor, set in .cfg files.</para> /// varies with three tunables: nominalRange, maxPowerFactor, and maxDataFactor, set in .cfg files.</para>
/// ///
/// <para>In general, the scaling functions assume the following relation:</para> /// <para>In general, the scaling functions assume the following relation:</para>
/// ///
/// <para> D² α P/R,</para> /// <para> D² α P/R,</para>
/// ///
/// <para>where D is the total transmission distance, P is the transmission power, and R is the data rate.</para> /// <para>where D is the total transmission distance, P is the transmission power, and R is the data rate.</para>
/// </summary> /// </summary>
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.
private float _basepacketResourceCost; private float _basepacketResourceCost;
   
// Stores the packetSize as defined in the .cfg file. // Stores the packetSize as defined in the .cfg file.
private float _basepacketSize; private float _basepacketSize;
   
// Every antenna is a relay. // Every antenna is a relay.
private AntennaRelay relay; private AntennaRelay relay;
   
// 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.
private ScreenMessage ErrorMsg; private ScreenMessage ErrorMsg;
   
/// <summary> /// <summary>
/// When additive ranges are enabled, the distance from Kerbin at which the antenna will perform exactly as /// The distance from Kerbin at which the antenna will perform exactly as prescribed by packetResourceCost
/// prescribed by packetResourceCost and packetSize. /// and packetSize.
/// </summary> /// </summary>
[KSPField(isPersistant = false)] [KSPField(isPersistant = false)]
public double nominalRange; public double nominalRange;
   
/// <summary> /// <summary>
/// When additive ranges are disabled, the distance from Kerbin at which the antenna will perform exactly as  
/// prescribed by packetResourceCost and packetSize.  
/// </summary>  
[KSPField(isPersistant = false)]  
public double simpleRange;  
   
/// <summary>  
/// Relay status string for use in action menus. /// Relay status string for use in action menus.
/// </summary> /// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Status")] [KSPField(isPersistant = false, guiActive = true, guiName = "Status")]
public string UIrelayStatus; public string UIrelayStatus;
   
/// <summary> /// <summary>
/// Relay target string for use in action menus. /// Relay target string for use in action menus.
/// </summary> /// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Relay")] [KSPField(isPersistant = false, guiActive = true, guiName = "Relay")]
public string UIrelayTarget; public string UIrelayTarget;
   
/// <summary> /// <summary>
/// Transmit distance string for use in action menus. /// Transmit distance string for use in action menus.
/// </summary> /// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Transmission Distance")] [KSPField(isPersistant = false, guiActive = true, guiName = "Transmission Distance")]
public string UItransmitDistance; public string UItransmitDistance;
   
/// <summary> /// <summary>
/// The nominal range string for use in action menus.  
/// </summary>  
[KSPField(isPersistant = false, guiActive = true, guiName = "Nominal Range")]  
public string UInominalLinkDistance;  
   
/// <summary>  
/// Maximum distance string for use in action menus. /// Maximum distance string for use in action menus.
/// </summary> /// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Maximum Range")] [KSPField(isPersistant = false, guiActive = true, guiName = "Maximum Distance")]
public string UImaxTransmitDistance; public string UImaxTransmitDistance;
   
/// <summary> /// <summary>
/// Packet size string for use in action menus. /// Packet size string for use in action menus.
/// </summary> /// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Packet Size")] [KSPField(isPersistant = false, guiActive = true, guiName = "Packet Size")]
public string UIpacketSize; public string UIpacketSize;
   
/// <summary> /// <summary>
/// Packet cost string for use in action menus. /// Packet cost string for use in action menus.
/// </summary> /// </summary>
[KSPField(isPersistant = false, guiActive = true, guiName = "Packet Cost")] [KSPField(isPersistant = false, guiActive = true, guiName = "Packet Cost")]
public string UIpacketCost; public string UIpacketCost;
   
/// <summary> /// <summary>
/// The multiplier on packetResourceCost that defines the maximum power output of the antenna. When the power /// The multiplier on packetResourceCost that defines the maximum power output of the antenna. When the power
/// cost exceeds packetResourceCost * maxPowerFactor, transmission will fail. /// cost exceeds packetResourceCost * maxPowerFactor, transmission will fail.
/// </summary> /// </summary>
[KSPField(isPersistant = false)] [KSPField(isPersistant = false)]
public float maxPowerFactor; public float maxPowerFactor;
   
/// <summary> /// <summary>
/// The multipler on packetSize that defines the maximum data bandwidth of the antenna. /// The multipler on packetSize that defines the maximum data bandwidth of the antenna.
/// </summary> /// </summary>
[KSPField(isPersistant = false)] [KSPField(isPersistant = false)]
public float maxDataFactor; public float maxDataFactor;
   
/// <summary> /// <summary>
/// The packet throttle. /// The packet throttle.
/// </summary> /// </summary>
[KSPField( [KSPField(
isPersistant = true, isPersistant = true,
guiName = "Packet Throttle", guiName = "Packet Throttle",
guiUnits = "%", guiUnits = "%",
guiActive = true, guiActive = true,
guiActiveEditor = false guiActiveEditor = false
)] )]
[UI_FloatRange(maxValue = 100f, minValue = 2.5f, stepIncrement = 2.5f)] [UI_FloatRange(maxValue = 100f, minValue = 2.5f, stepIncrement = 2.5f)]
public float packetThrottle; public float packetThrottle;
   
private bool actionUIUpdate; private bool actionUIUpdate;
   
/* /*
* Properties * Properties
* */ * */
/// <summary> /// <summary>
/// Gets the parent Vessel. /// Gets the parent Vessel.
/// </summary> /// </summary>
public new Vessel vessel public new Vessel vessel
{ {
get get
{ {
if (base.vessel != null) if (base.vessel != null)
{ {
return base.vessel; return base.vessel;
} }
else if (this.part != null && this.part.vessel != null) else if (this.part != null && this.part.vessel != null)
{ {
return this.part.vessel; return this.part.vessel;
} }
else if ( else if (
this.part.protoPartSnapshot != null && this.part.protoPartSnapshot != null &&
this.part.protoPartSnapshot.pVesselRef != null && this.part.protoPartSnapshot.pVesselRef != null &&
this.part.protoPartSnapshot.pVesselRef.vesselRef != null this.part.protoPartSnapshot.pVesselRef.vesselRef != null
) )
{ {
return this.part.protoPartSnapshot.pVesselRef.vesselRef; return this.part.protoPartSnapshot.pVesselRef.vesselRef;
} }
else else
{ {
this.LogError("Vessel and/or part reference are null, returning null vessel."); this.LogError("Vessel and/or part reference are null, returning null vessel.");
return null; return null;
} }
} }
} }
   
/// <summary> /// <summary>
/// Gets the target <see cref="AntennaRange.IAntennaRelay"/>relay. /// Gets the target <see cref="AntennaRange.IAntennaRelay"/>relay.
/// </summary> /// </summary>
public IAntennaRelay targetRelay public IAntennaRelay targetRelay
{ {
get get
{ {
if (this.relay == null) if (this.relay == null)
{ {
return null; return null;
} }
   
return this.relay.targetRelay; return this.relay.targetRelay;
} }
} }
   
/// <summary> /// <summary>
/// Gets a value indicating whether this <see cref="AntennaRange.IAntennaRelay"/> Relay is communicating /// Gets the distance to the nearest relay or Kerbin, whichever is closer.
/// directly with Kerbin. /// </summary>
/// </summary> public double transmitDistance
public bool KerbinDirect  
{ {
get get
{ {
if (this.relay != null) if (this.relay == null)
{ {
return this.relay.KerbinDirect; return double.PositiveInfinity;
} }
   
return false; return this.relay.transmitDistance;
} }
} }
   
/// <summary> /// <summary>
/// Gets or sets the nominal link distance, in meters. /// Gets the nominal transmit distance at which the Antenna behaves just as prescribed by Squad's config.
/// </summary> /// </summary>
public double NominalLinkDistance public double nominalTransmitDistance
{ {
get get
{ {
if (this.relay != null) return this.nominalRange;
{  
return this.relay.NominalLinkDistance;  
}  
   
return 0d;  
}  
}  
   
/// <summary>  
/// Gets or sets the maximum link distance, in meters.  
/// </summary>  
public double MaximumLinkDistance  
{  
get  
{  
if (this.relay != null)  
{  
return this.relay.MaximumLinkDistance;  
}  
   
return 0d;  
}  
}  
   
/// <summary>  
/// Gets the distance to the nearest relay or Kerbin, whichever is closer.  
/// </summary>  
public double transmitDistance  
{  
get  
{  
if (this.relay == null)  
{  
return double.PositiveInfinity;  
}  
   
return this.relay.transmitDistance;  
}  
}  
   
/// <summary>  
/// Gets the link status.  
/// </summary>  
public ConnectionStatus LinkStatus  
{  
get  
{  
if (this.relay == null)  
{  
return ConnectionStatus.None;  
}  
   
return this.relay.LinkStatus;  
}  
}  
   
/// <summary>  
/// Gets the nominal transmit distance at which the Antenna behaves just as prescribed by Squad's config.  
/// </summary>  
public double nominalTransmitDistance  
{  
get  
{  
if (ARConfiguration.UseAdditiveRanges)  
{  
return this.nominalRange;  
}  
else  
{  
return this.simpleRange;  
}  
} }
} }
   
/// <summary> /// <summary>
/// The maximum distance at which this relay can operate. /// The maximum distance at which this relay can operate.
/// </summary> /// </summary>
public double maxTransmitDistance public double maxTransmitDistance
{ {
get; get;
protected set; protected set;
} }
   
/// <summary> /// <summary>
/// The first CelestialBody blocking line of sight to a /// The first CelestialBody blocking line of sight to a
/// </summary> /// </summary>
public CelestialBody firstOccludingBody public CelestialBody firstOccludingBody
{ {
get get
{ {
return this.relay.firstOccludingBody; 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.
* */ * */
/// <summary> /// <summary>
/// Override ModuleDataTransmitter.DataRate to just return packetSize, because we want antennas to be scored in /// Override ModuleDataTransmitter.DataRate to just return packetSize, because we want antennas to be scored in
/// terms of joules/byte /// terms of joules/byte
/// </summary> /// </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;
} }
} }
} }
   
/// <summary> /// <summary>
/// Override ModuleDataTransmitter.DataResourceCost to just return packetResourceCost, because we want antennas /// Override ModuleDataTransmitter.DataResourceCost to just return packetResourceCost, because we want antennas
/// to be scored in terms of joules/byte /// to be scored in terms of joules/byte
/// </summary> /// </summary>
public new double DataResourceCost 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;
} }
} }
} }
   
/// <summary> /// <summary>
  /// Gets a value indicating whether this <see cref="AntennaRange.IAntennaRelay"/> Relay is communicating
  /// directly with Kerbin.
  /// </summary>
  public bool KerbinDirect
  {
  get
  {
  if (this.relay != null)
  {
  return this.relay.KerbinDirect;
  }
   
  return false;
  }
  }
   
  /// <summary>
/// Gets the Part title. /// Gets the Part title.
/// </summary> /// </summary>
public string Title public string Title
{ {
get get
{ {
if (this.part != null && this.part.partInfo != null) if (this.part != null && this.part.partInfo != null)
{ {
return this.part.partInfo.title; return this.part.partInfo.title;
} }
   
return string.Empty; 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; this.packetThrottle = 100f;
} }
   
/// <summary> /// <summary>
/// PartModule OnAwake override; runs at Unity Awake. /// PartModule OnAwake override; runs at Unity Awake.
/// </summary> /// </summary>
public override void OnAwake() public override void OnAwake()
{ {
base.OnAwake(); base.OnAwake();
   
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" +
"nominalTransmitDistance: {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.nominalTransmitDistance, this.nominalRange,
this.maxPowerFactor, this.maxPowerFactor,
this.maxDataFactor this.maxDataFactor
)); ));
} }
   
/// <summary> /// <summary>
/// PartModule OnStart override; runs at Unity Start. /// PartModule OnStart override; runs at Unity Start.
/// </summary> /// </summary>
/// <param name="state">State.</param> /// <param name="state">State.</param>
public override void OnStart (StartState state) public override void OnStart (StartState state)
{ {
base.OnStart (state); base.OnStart (state);
   
if (state >= StartState.PreLaunch) if (state >= StartState.PreLaunch)
{ {
this.maxTransmitDistance = Math.Sqrt(this.maxPowerFactor) * this.nominalTransmitDistance; this.maxTransmitDistance = Math.Sqrt(this.maxPowerFactor) * this.nominalRange;
   
this.relay = new AntennaRelay(this); this.relay = new AntennaRelay(this);
this.relay.nominalTransmitDistance = this.nominalTransmitDistance;  
this.relay.maxTransmitDistance = this.maxTransmitDistance; this.relay.maxTransmitDistance = this.maxTransmitDistance;
  this.relay.nominalTransmitDistance = this.nominalRange;
this.UImaxTransmitDistance = string.Format(Tools.SIFormatter, "{0:S3}m", this.maxTransmitDistance);  
  this.UImaxTransmitDistance = Tools.MuMech_ToSI(this.maxTransmitDistance) + "m";
   
GameEvents.onPartActionUICreate.Add(this.onPartActionUICreate); GameEvents.onPartActionUICreate.Add(this.onPartActionUICreate);
GameEvents.onPartActionUIDismiss.Add(this.onPartActionUIDismiss); GameEvents.onPartActionUIDismiss.Add(this.onPartActionUIDismiss);
} }
} }
   
/// <summary> /// <summary>
/// When the module loads, fetch the Squad KSPFields from the base. This is necessary in part because /// 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 /// overloading packetSize and packetResourceCostinto a property in ModuleLimitedDataTransmitter didn't
/// work. /// work.
/// </summary> /// </summary>
/// <param name="node"><see cref="ConfigNode"/> with data for this module.</param> /// <param name="node"><see cref="ConfigNode"/> with data for this module.</param>
public override void OnLoad(ConfigNode node) public override void OnLoad(ConfigNode node)
{ {
this.Fields.Load(node); this.Fields.Load(node);
base.Fields.Load(node); base.Fields.Load(node);
   
base.OnLoad (node); base.OnLoad (node);
   
this.maxTransmitDistance = Math.Sqrt(this.maxPowerFactor) * this.nominalTransmitDistance; this.maxTransmitDistance = Math.Sqrt(this.maxPowerFactor) * this.nominalRange;
} }
   
/// <summary> /// <summary>
/// Override ModuleDataTransmitter.GetInfo to add nominal and maximum range to the VAB description. /// Override ModuleDataTransmitter.GetInfo to add nominal and maximum range to the VAB description.
/// </summary> /// </summary>
public override string GetInfo() public override string GetInfo()
{ {
StringBuilder sb = Tools.GetStringBuilder(); string text = base.GetInfo();
string text; text += "Nominal Range: " + Tools.MuMech_ToSI((double)this.nominalRange, 2) + "m\n";
  text += "Maximum Range: " + Tools.MuMech_ToSI((double)this.maxTransmitDistance, 2) + "m\n";
sb.Append(base.GetInfo());  
sb.AppendFormat(Tools.SIFormatter, "Nominal Range: {0:S3}m\n", this.nominalTransmitDistance);  
sb.AppendFormat(Tools.SIFormatter, "Maximum Range: {0:S3}m\n", this.maxTransmitDistance);  
   
text = sb.ToString();  
   
Tools.PutStringBuilder(sb);  
   
return text; return text;
} }
   
/// <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>. /// <c>true</c> if this instance can transmit; otherwise, <c>false</c>.
/// </summary> /// </summary>
public new bool CanTransmit() public new bool CanTransmit()
{ {
if (this.part == null || this.relay == null) if (this.part == null || this.relay == null)
{ {
return false; return false;
} }
   
switch (this.part.State) switch (this.part.State)
{ {
case PartStates.DEAD: case PartStates.DEAD:
case PartStates.DEACTIVATED: case 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.part.partInfo.title, this.part.partInfo.title,
this.vessel.vesselName, this.vessel.vesselName,
Enum.GetName(typeof(PartStates), this.part.State) Enum.GetName(typeof(PartStates), this.part.State)
)); ));
return false; return false;
default: default:
break; break;
} }
   
return this.relay.CanTransmit(); return this.relay.CanTransmit();
} }
   
/// <summary> /// <summary>
/// Finds the nearest relay. /// Finds the nearest relay.
/// </summary> /// </summary>
public void FindNearestRelay() public void FindNearestRelay()
{ {
if (this.relay != null) if (this.relay != null)
{ {
this.relay.FindNearestRelay(); this.relay.FindNearestRelay();
} }
} }
   
/// <summary> /// <summary>
/// Override ModuleDataTransmitter.TransmitData to check against CanTransmit and fail out when CanTransmit /// Override ModuleDataTransmitter.TransmitData to check against CanTransmit and fail out when CanTransmit
/// returns false. /// returns false.
/// </summary> /// </summary>
/// <param name="dataQueue">List of <see cref="ScienceData"/> to transmit.</param> /// <param name="dataQueue">List of <see cref="ScienceData"/> to transmit.</param>
/// <param name="callback">Callback function</param> /// <param name="callback">Callback function</param>
public new void TransmitData(List<ScienceData> dataQueue, Callback callback) public new void TransmitData(List<ScienceData> dataQueue, Callback callback)
{ {
this.LogDebug( this.LogDebug(
"TransmitData(List<ScienceData> dataQueue, Callback callback) called. dataQueue.Count={0}", "TransmitData(List<ScienceData> dataQueue, Callback callback) called. dataQueue.Count={0}",
dataQueue.Count dataQueue.Count
); );
   
this.FindNearestRelay(); this.FindNearestRelay();
   
this.PreTransmit_SetPacketSize(); this.PreTransmit_SetPacketSize();
this.PreTransmit_SetPacketResourceCost(); this.PreTransmit_SetPacketResourceCost();
   
if (this.CanTransmit()) if (this.CanTransmit())
{ {
ScreenMessages.PostScreenMessage(this.buildTransmitMessage(), 4f, ScreenMessageStyle.UPPER_LEFT); ScreenMessages.PostScreenMessage(this.buildTransmitMessage(), 4f, ScreenMessageStyle.UPPER_LEFT);
   
this.LogDebug( this.LogDebug(
"CanTransmit in TransmitData, calling base.TransmitData with dataQueue=[{0}] and callback={1}", "CanTransmit in TransmitData, calling base.TransmitData with dataQueue=[{0}] and callback={1}",
dataQueue.SPrint(), dataQueue.SPrint(),
callback == null ? "null" : callback.ToString() callback == null ? "null" : callback.ToString()
); );
   
if (callback == null) if (callback == null)
{ {
base.TransmitData(dataQueue); base.TransmitData(dataQueue);
} }
else else
{ {
base.TransmitData(dataQueue, callback); base.TransmitData(dataQueue, callback);
} }
} }
else else
{ {
Tools.PostDebugMessage(this, "{0} unable to transmit during TransmitData.", this.part.partInfo.title); Tools.PostDebugMessage(this, "{0} unable to transmit during TransmitData.", this.part.partInfo.title);
   
var logger = Tools.DebugLogger.New(this); var logger = Tools.DebugLogger.New(this);
   
IList<ModuleScienceContainer> vesselContainers = this.vessel.getModulesOfType<ModuleScienceContainer>(); IList<ModuleScienceContainer> vesselContainers = this.vessel.getModulesOfType<ModuleScienceContainer>();
ModuleScienceContainer scienceContainer; ModuleScienceContainer scienceContainer;
for (int cIdx = 0; cIdx < vesselContainers.Count; cIdx++) for (int cIdx = 0; cIdx < vesselContainers.Count; cIdx++)
{ {
scienceContainer = vesselContainers[cIdx]; scienceContainer = vesselContainers[cIdx];
   
logger.AppendFormat("Checking ModuleScienceContainer in {0}\n", logger.AppendFormat("Checking ModuleScienceContainer in {0}\n",
scienceContainer.part.partInfo.title); scienceContainer.part.partInfo.title);
   
if ( if (
scienceContainer.capacity != 0 && scienceContainer.capacity != 0 &&
scienceContainer.GetScienceCount() >= scienceContainer.capacity scienceContainer.GetScienceCount() >= scienceContainer.capacity
) )
{ {
logger.Append("\tInsufficient capacity, skipping.\n"); logger.Append("\tInsufficient capacity, skipping.\n");
continue; continue;
} }
   
List<ScienceData> dataStored = new List<ScienceData>(); List<ScienceData> dataStored = new List<ScienceData>();
   
ScienceData data; ScienceData data;
for (int dIdx = 0; dIdx < dataQueue.Count; dIdx++) for (int dIdx = 0; dIdx < dataQueue.Count; dIdx++)
{ {
data = dataQueue[dIdx]; data = dataQueue[dIdx];
if (!scienceContainer.allowRepeatedSubjects && scienceContainer.HasData(data)) if (!scienceContainer.allowRepeatedSubjects && scienceContainer.HasData(data))
{ {
logger.Append("\tAlready contains subject and repeated subjects not allowed, skipping.\n"); logger.Append("\tAlready contains subject and repeated subjects not allowed, skipping.\n");
continue; continue;
} }
   
logger.AppendFormat("\tAcceptable, adding data on subject {0}... ", data.subjectID); logger.AppendFormat("\tAcceptable, adding data on subject {0}... ", data.subjectID);
if (scienceContainer.AddData(data)) if (scienceContainer.AddData(data))
{ {
logger.Append("done, removing from queue.\n"); logger.Append("done, removing from queue.\n");
   
dataStored.Add(data); dataStored.Add(data);
} }
#if DEBUG #if DEBUG
else else
{ {
logger.Append("failed.\n"); logger.Append("failed.\n");
} }
#endif #endif
} }
   
dataQueue.RemoveAll(i => dataStored.Contains(i)); dataQueue.RemoveAll(i => dataStored.Contains(i));
   
logger.AppendFormat("\t{0} data left in queue.", dataQueue.Count); logger.AppendFormat("\t{0} data left in queue.", dataQueue.Count);
} }
   
logger.Print(); logger.Print();
   
if (dataQueue.Count > 0) if (dataQueue.Count > 0)
{ {
StringBuilder sb = Tools.GetStringBuilder(); StringBuilder sb = Tools.GetStringBuilder();
   
sb.Append('['); sb.Append('[');
sb.Append(this.part.partInfo.title); sb.Append(this.part.partInfo.title);
sb.AppendFormat("]: {0} data items could not be saved: no space available in data containers.\n"); sb.AppendFormat("]: {0} data items could not be saved: no space available in data containers.\n");
sb.Append("Data to be discarded:\n"); sb.Append("Data to be discarded:\n");
   
ScienceData data; ScienceData data;
for (int dIdx = 0; dIdx < dataQueue.Count; dIdx++) for (int dIdx = 0; dIdx < dataQueue.Count; dIdx++)
{ {
data = dataQueue[dIdx]; data = dataQueue[dIdx];
sb.AppendFormat("\t{0}\n", data.title); sb.AppendFormat("\t{0}\n", data.title);
} }
   
ScreenMessages.PostScreenMessage(sb.ToString(), 4f, ScreenMessageStyle.UPPER_LEFT); ScreenMessages.PostScreenMessage(sb.ToString(), 4f, ScreenMessageStyle.UPPER_LEFT);
   
Tools.PostDebugMessage(sb.ToString()); Tools.PostDebugMessage(sb.ToString());
   
Tools.PutStringBuilder(sb); Tools.PutStringBuilder(sb);
} }
   
this.PostCannotTransmitError(); this.PostCannotTransmitError();
} }
   
Tools.PostDebugMessage ( Tools.PostDebugMessage (
"distance: " + this.transmitDistance "distance: " + this.transmitDistance
+ " packetSize: " + this.packetSize + " packetSize: " + this.packetSize
+ " packetResourceCost: " + this.packetResourceCost + " packetResourceCost: " + this.packetResourceCost
); );
} }
   
/// <summary> /// <summary>
/// Override ModuleDataTransmitter.TransmitData to check against CanTransmit and fail out when CanTransmit /// Override ModuleDataTransmitter.TransmitData to check against CanTransmit and fail out when CanTransmit
/// returns false. /// returns false.
/// </summary> /// </summary>
/// <param name="dataQueue">List of <see cref="ScienceData"/> to transmit.</param> /// <param name="dataQueue">List of <see cref="ScienceData"/> to transmit.</param>
public new void TransmitData(List<ScienceData> dataQueue) public new void TransmitData(List<ScienceData> dataQueue)
{ {
this.LogDebug( this.LogDebug(
"TransmitData(List<ScienceData> dataQueue) called, dataQueue.Count={0}", "TransmitData(List<ScienceData> dataQueue) called, dataQueue.Count={0}",
dataQueue.Count dataQueue.Count
); );
   
this.TransmitData(dataQueue, null); this.TransmitData(dataQueue, null);
} }
   
/// <summary> /// <summary>
/// Override ModuleDataTransmitter.StartTransmission to check against CanTransmit and fail out when CanTransmit /// Override ModuleDataTransmitter.StartTransmission to check against CanTransmit and fail out when CanTransmit
/// returns false. /// returns false.
/// </summary> /// </summary>
public new void StartTransmission() public new void StartTransmission()
{ {
this.FindNearestRelay(); this.FindNearestRelay();
   
PreTransmit_SetPacketSize (); PreTransmit_SetPacketSize ();
PreTransmit_SetPacketResourceCost (); PreTransmit_SetPacketResourceCost ();
   
Tools.PostDebugMessage ( Tools.PostDebugMessage (
"distance: " + this.transmitDistance "distance: " + this.transmitDistance
+ " packetSize: " + this.packetSize + " packetSize: " + this.packetSize
+ " packetResourceCost: " + this.packetResourceCost + " packetResourceCost: " + this.packetResourceCost
); );
   
if (this.CanTransmit()) if (this.CanTransmit())
{ {
ScreenMessages.PostScreenMessage(this.buildTransmitMessage(), 4f, ScreenMessageStyle.UPPER_LEFT); ScreenMessages.PostScreenMessage(this.buildTransmitMessage(), 4f, ScreenMessageStyle.UPPER_LEFT);
   
base.StartTransmission(); base.StartTransmission();
} }
else else
{ {
this.PostCannotTransmitError (); this.PostCannotTransmitError ();
} }
} }
   
/// <summary> /// <summary>
/// MonoBehaviour Update /// MonoBehaviour Update
/// </summary> /// </summary>
public void Update() public void Update()
{ {
if (this.actionUIUpdate) if (this.actionUIUpdate)
{ {
this.UImaxTransmitDistance = string.Format(Tools.SIFormatter, "{0:S3}m", this.MaximumLinkDistance);  
this.UInominalLinkDistance = string.Format(Tools.SIFormatter, "{0:S3}m", this.NominalLinkDistance);  
   
if (this.CanTransmit()) if (this.CanTransmit())
{ {
this.UIrelayStatus = this.LinkStatus.ToString(); this.UIrelayStatus = "Connected";
this.UItransmitDistance = string.Format(Tools.SIFormatter, "{0:S3}m", this.transmitDistance); this.UItransmitDistance = Tools.MuMech_ToSI(this.transmitDistance) + "m";
this.UIpacketSize = string.Format(Tools.SIFormatter, "{0:S3}MiT", this.DataRate); this.UIpacketSize = Tools.MuMech_ToSI(this.DataRate) + "MiT";
this.UIpacketCost = string.Format(Tools.SIFormatter, "{0:S3}EC", this.DataResourceCost); this.UIpacketCost = Tools.MuMech_ToSI(this.DataResourceCost) + "E";
} }
else else
{ {
if (this.relay.firstOccludingBody == null) if (this.relay.firstOccludingBody == null)
{ {
this.UItransmitDistance = string.Format(Tools.SIFormatter, "{0:S3}m", this.transmitDistance);  
this.UIrelayStatus = "Out of range"; this.UIrelayStatus = "Out of range";
} }
else else
{ {
this.UItransmitDistance = "N/A";  
this.UIrelayStatus = string.Format("Blocked by {0}", this.relay.firstOccludingBody.bodyName); this.UIrelayStatus = string.Format("Blocked by {0}", this.relay.firstOccludingBody.bodyName);
} }
this.UIpacketSize = "N/A"; this.UIpacketSize = "N/A";
this.UIpacketCost = "N/A"; this.UIpacketCost = "N/A";
} }
   
if (this.KerbinDirect) if (this.KerbinDirect)
{ {
this.UIrelayTarget = AntennaRelay.Kerbin.bodyName; this.UIrelayTarget = AntennaRelay.Kerbin.bodyName;
} }
else else
{ {
this.UIrelayTarget = this.targetRelay.ToString(); this.UIrelayTarget = this.targetRelay.ToString();
} }
} }
} }
   
/// <summary> /// <summary>
/// Returns a <see cref="System.String"/> that represents the current <see cref="AntennaRange.ModuleLimitedDataTransmitter"/>. /// Returns a <see cref="System.String"/> that represents the current <see cref="AntennaRange.ModuleLimitedDataTransmitter"/>.
/// </summary> /// </summary>
/// <returns>A <see cref="System.String"/> that represents the current <see cref="AntennaRange.ModuleLimitedDataTransmitter"/>.</returns> /// <returns>A <see cref="System.String"/> that represents the current <see cref="AntennaRange.ModuleLimitedDataTransmitter"/>.</returns>
public override string ToString() public override string ToString()
{ {
StringBuilder sb = Tools.GetStringBuilder(); StringBuilder sb = Tools.GetStringBuilder();
string msg; string msg;
   
sb.Append(this.part.partInfo.title); sb.Append(this.part.partInfo.title);
   
if (vessel != null) if (vessel != null)
{ {
sb.Append(" on "); sb.Append(" on ");
sb.Append(vessel.vesselName); sb.Append(vessel.vesselName);
} }
else if ( else if (
this.part != null && this.part != null &&
this.part.protoPartSnapshot != null && this.part.protoPartSnapshot != null &&
this.part.protoPartSnapshot != null && this.part.protoPartSnapshot != null &&
this.part.protoPartSnapshot.pVesselRef != null this.part.protoPartSnapshot.pVesselRef != null
) )
{ {
sb.Append(" on "); sb.Append(" on ");
sb.Append(this.part.protoPartSnapshot.pVesselRef.vesselName); sb.Append(this.part.protoPartSnapshot.pVesselRef.vesselName);
} }
   
msg = sb.ToString(); msg = sb.ToString();
   
Tools.PutStringBuilder(sb); Tools.PutStringBuilder(sb);
   
return msg; return msg;
} }
   
// When we catch an onPartActionUICreate event for our part, go ahead and update every frame to look pretty. // When we catch an onPartActionUICreate event for our part, go ahead and update every frame to look pretty.
private void onPartActionUICreate(Part eventPart) private void onPartActionUICreate(Part eventPart)
{ {
if (eventPart == base.part) if (eventPart == base.part)
{ {
this.actionUIUpdate = true; this.actionUIUpdate = true;
} }
} }
   
// When we catch an onPartActionUIDismiss event for our part, stop updating every frame to look pretty. // When we catch an onPartActionUIDismiss event for our part, stop updating every frame to look pretty.
private void onPartActionUIDismiss(Part eventPart) private void onPartActionUIDismiss(Part eventPart)
{ {
if (eventPart == base.part) if (eventPart == base.part)
{ {
this.actionUIUpdate = false; 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.
private void PostCannotTransmitError() private void PostCannotTransmitError()
{ {
string ErrorText = string.Intern("Unable to transmit: no visible receivers in range!"); string ErrorText = string.Intern("Unable to transmit: no visible receivers in range!");
   
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).
private void PreTransmit_SetPacketResourceCost() private void PreTransmit_SetPacketResourceCost()
{ {
if (ARConfiguration.FixedPowerCost || this.transmitDistance <= this.NominalLinkDistance) if (ARConfiguration.FixedPowerCost || this.transmitDistance <= this.nominalRange)
{ {
base.packetResourceCost = this._basepacketResourceCost; base.packetResourceCost = this._basepacketResourceCost;
} }
else else
{ {
float rangeFactor = (float)(this.transmitDistance / this.NominalLinkDistance); float rangeFactor = (float)(this.transmitDistance / this.nominalRange);
rangeFactor *= rangeFactor; rangeFactor *= rangeFactor;
   
base.packetResourceCost = this._basepacketResourceCost base.packetResourceCost = this._basepacketResourceCost
* rangeFactor; * rangeFactor;
} }
   
base.packetResourceCost *= this.packetThrottle / 100f; 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.
private void PreTransmit_SetPacketSize() private void PreTransmit_SetPacketSize()
{ {
if (!ARConfiguration.FixedPowerCost && this.transmitDistance >= this.NominalLinkDistance) if (!ARConfiguration.FixedPowerCost && this.transmitDistance >= this.nominalRange)
{ {
base.packetSize = this._basepacketSize; base.packetSize = this._basepacketSize;
} }
else else
{ {
float rangeFactor = (float)(this.NominalLinkDistance / this.transmitDistance); float rangeFactor = (float)(this.nominalRange / this.transmitDistance);
rangeFactor *= rangeFactor; rangeFactor *= rangeFactor;
   
base.packetSize = Mathf.Min( base.packetSize = Mathf.Min(
this._basepacketSize * rangeFactor, this._basepacketSize * rangeFactor,
this._basepacketSize * this.maxDataFactor); this._basepacketSize * this.maxDataFactor);
} }
   
base.packetSize *= this.packetThrottle / 100f; base.packetSize *= this.packetThrottle / 100f;
} }
   
private string buildTransmitMessage() private string buildTransmitMessage()
{ {
StringBuilder sb = Tools.GetStringBuilder(); StringBuilder sb = Tools.GetStringBuilder();
string msg; string msg;
   
sb.Append("["); sb.Append("[");
sb.Append(base.part.partInfo.title); sb.Append(base.part.partInfo.title);
sb.Append("]: "); sb.Append("]: ");
   
sb.Append("Beginning transmission "); sb.Append("Beginning transmission ");
   
if (this.KerbinDirect) if (this.KerbinDirect)
{ {
sb.Append("directly to Kerbin."); sb.Append("directly to Kerbin.");
} }
else else
{ {
sb.Append("via "); sb.Append("via ");
sb.Append(this.relay.targetRelay); sb.Append(this.relay.targetRelay);
} }
   
msg = sb.ToString(); msg = sb.ToString();
   
Tools.PutStringBuilder(sb); Tools.PutStringBuilder(sb);
   
return msg; return msg;
} }
   
#if DEBUG #if DEBUG
// 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.
[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 ();
   
DebugPartModule.DumpClassObject(this); DebugPartModule.DumpClassObject(this);
} }
   
[KSPEvent (guiName = "Dump Vessels", active = true, guiActive = true)] [KSPEvent (guiName = "Dump Vessels", active = true, guiActive = true)]
public void PrintAllVessels() public void PrintAllVessels()
{ {
StringBuilder sb = Tools.GetStringBuilder(); StringBuilder sb = Tools.GetStringBuilder();
sb.Append("Dumping FlightGlobals.Vessels:"); sb.Append("Dumping FlightGlobals.Vessels:");
   
Vessel vessel; Vessel vessel;
for (int i = 0; i < FlightGlobals.Vessels.Count; i++) for (int i = 0; i < FlightGlobals.Vessels.Count; i++)
{ {
vessel = FlightGlobals.Vessels[i]; vessel = FlightGlobals.Vessels[i];
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());
   
Tools.PutStringBuilder(sb); Tools.PutStringBuilder(sb);
} }
[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
} }
} }
// AntennaRange // AntennaRange
// //
// AssemblyInfo.cs // AssemblyInfo.cs
// //
// Copyright © 2014-2015, toadicus // Copyright © 2014-2015, 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)] [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.9.*")] [assembly: AssemblyVersion("1.9.1.*")]
// 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("")]
   
file:b/README.md (new)
  # AntennaRange
  A KSP mod that enforces and encourages the use of the bigger antennas.
 
  # For Part Developers
  ## The Fields
  AntennaRange extends and augments the functionality of the stock ModuleDataTransmitter through the new ModuleLimitedDataTransmitter class. This class uses five additional configurable fields to define the part's behavior.
 
  nominalRange is the range, in meters, at which the part should function identically to the stock module, i.e. without any modification to the power cost or packet size. This is used along with maxPowerFactor to calculate the maximum range of the part.
  simpleRange is the same as nominalRange, but is used when the mod is in "simple" mode. In general it will probably need to be a much larger number than nominalRange.
  maxPowerFactor effectively sets the maximum range of the antenna by essentially capping how much the power may be "turned up" to get better range. I originally used 8 for this number, because it felt right. I've since used 4 (for my DTS) and 16 (for my Comm. 88-88). You don't want this number to be too high, or small probes will go uncontrollable a lot when transmitting.
  maxDataFactor defines the maximum "speed up" bonus that comes from using antennas at less their nominal range. I originally used 4 for this number for all parts; the DTS has a higher bonus now.
 
  Note that all of the fields needed for Squad's ModuleDataTransmitter still need to be filled out. Depending on how you're defining your parts, they might need to go in your AntennaRange patch, or they might already be defined on the base part.
 
  ## The Mechanic
  In general, the scaling functions assume the relation `D² α P/R,` where D is the total transmission distance, P is the transmission power, and R is the data rate. Data rate increases as range decreases below nominalRange: `R α nominalRange² / D²`. By default, power use increases as range increases above nominalRange: `P α D² / nominalRange²`. Optionally, power use may remain fixed, and data rate instead decreases as range increases above nominalRange: `R α nominalRange² / D²`.
 
  ## Patch Conventions
  To maximize cross-compatibility, please consider the following conventions for ModuleManager patches regarding AntennaRange:
 
  When providing new definitions for your own parts, always specify a :FOR[YourModHere] pass name.
  Whenever changing default AntennaRange definitions (e.g. if you were going to rebalance my antennas to suit your mod), please do so in the :AFTER[AntennaRange] pass.
  I recommend providing all optional functionality (e.g. enabling RemoteTech vs. AntennaRange modules) in separate patches using :NEEDS[] blocks.
 
  A sample AntennaRange configuration for an all-new mod part might look like this:
  ```
  @PART[modPartName]:FOR[YourModName]:NEEDS[AntennaRange,!RemoteTech]
  {
  MODULE
  {
  // ### Module Definition ###
  name = ModuleLimitedDataTransmitter
 
  // ### Squad Definitions ###
  // Delay between transmission packets, in seconds
  packetInterval = 0.10
 
  // Data capacity of nominal transmission packets, in MiT
  packetSize = 2
 
  // Resource cost of nominal transmission packets, in units
  packetResourceCost = 20.0
 
  // Resource name to be consumed by transmission
  requiredResource = ElectricCharge
 
  // Animation module index, 0-based, of the antenna extend/retract animation
  DeployFxModules = 0
 
  // ### AntennaRange Defintions ###
  // Range, in meters, at which the antenna behaves per the "nominal" characteristics above
  // Used with "additive" ranges.
  nominalRange = 10000000000
 
  // Range, in meters, at which the antenna behaves per the "nominal" characteristics above
  // Used with "simple" ranges.
  simpleRange = 56250000000
 
  // The maxmimum multiplier on packetResourceCost, essentially defining the maximum power output of the
  // transmitter. Maximum range is defined as: maxTransmitDistance = nominalRange * sqrt(maxPowerFactor)
  maxPowerFactor = 16
 
  // The maximum multiplier on packetSize, essentially defining the maximum data throughput of the
  // transmitter.
  maxDataFactor = 2
  }
 
  // We add this ModuleScienceContainer so that when transmission fails the antennas can try to stash the data instead of dumping it to the void.
  MODULE
  {
  name = ModuleScienceContainer
 
  dataIsCollectable = true
  dataIsStorable = false
 
  storageRange = 2
  }
  }
  ```
 
  This example assumes that the base part definition does not include a ModuleDataTransmitter module, or any RT modules. If the base part definition includes a ModuleDataTransmitter module, a sample AntennaRange patch could look like this:
  ```
  @PART[modPartName]:FOR[YourModName]:NEEDS[AntennaRange,!RemoteTech]
  {
  @MODULE[ModuleDataTransmitter]
  {
  @name = ModuleLimitedDataTransmitter
  nominalRange = 10000000000
  simpleRange = 56250000000
  maxPowerFactor = 16
  maxDataFactor = 2
  }
 
  // We add this ModuleScienceContainer so that when transmission fails the antennas can try to stash the data instead of dumping it to the void.
  MODULE
  {
  name = ModuleScienceContainer
 
  dataIsCollectable = true
  dataIsStorable = false
 
  storageRange = 2
  }
  }
  ```
 
  IIRC, RemoteTech parts should not have ModuleDataTransmitter definitions. In that case, to facilitate RT, AR, and Stock compatibility, a suite of patches like this might be appropriate:
 
  ```
  // If we don't have RemoteTech, add a stock ModuleDataTransmitter first.
  @PART[modPartName]:NEEDS[!RemoteTech]:BEFORE[YourModName]
  {
  MODULE
  {
  // ### Module Definition ###
  name = ModuleDataTransmitter
 
  // ### Squad Definitions ###
  // Delay between transmission packets, in seconds
  packetInterval = 0.10
 
  // Data capacity of nominal transmission packets, in MiT
  packetSize = 2
 
  // Resource cost of nominal transmission packets, in units
  packetResourceCost = 20.0
 
  // Resource name to be consumed by transmission
  requiredResource = ElectricCharge
 
  // Animation module index, 0-based, of the antenna extend/retract animation
  DeployFxModules = 0
  }
  }
 
  // If AntennaRange is installed, convert that to a ModuleLimitedDataTransmitter
  @PART[modPartName]:NEEDS[AntennaRange,!RemoteTech]:FOR[YourModName]
  {
  @MODULE[ModuleDataTransmitter]
  {
  // ### Module Redefinition ###
  @name = ModuleLimitedDataTransmitter
 
  // ### AntennaRange Defintions ###
  // Range, in meters, at which the antenna behaves per the "nominal" characteristics above
  // Used with "additive" ranges.
  nominalRange = 10000000000
 
  // Range, in meters, at which the antenna behaves per the "nominal" characteristics above
  // Used with "simple" ranges.
  simpleRange = 56250000000
 
  // The maxmimum multiplier on packetResourceCost, essentially defining the maximum power output of the
  // transmitter. Maximum range is defined as: maxTransmitDistance = nominalRange * sqrt(maxPowerFactor)
  maxPowerFactor = 16
 
  // The maximum multiplier on packetSize, essentially defining the maximum data throughput of the
  // transmitter.
  maxDataFactor = 2
  }
 
  // We add this ModuleScienceContainer so that when transmission fails the antennas can try to stash the data instead of dumping it to the void.
  MODULE
  {
  name = ModuleScienceContainer
 
  dataIsCollectable = true
  dataIsStorable = false
 
  storageRange = 2
  }
  }
 
  // If RemoteTech is installed, do their module(s) instead
  @PART[modPartName]:NEEDS[RemoteTech]:FOR[YourModName]
  {
  // RemoteTech module(s) here
  }
  ```
 
  ## Useful Formulas
 
  ### Per Antenna
  `nominalRange` is a given, and is never calculated
  `maxPowerFactor` is a given, and is never calculated
  `maxTransmitDistance = nominalRange * sqrt(maxPowerFactor)`
 
  ### Per Link
  A "link" is any connected pair of antennas.
  `NominalLinkDistance = sqrt(nominalRange1 * nominalRange2)`
  `MaxLinkDistance = sqrt(maxTransmitDistance1 * maxTransmitDistance2)`
 
  Therefore, to find the `MaxLinkDistance` from two sets of `nominalRange` and `maxPowerFactor`:
  `MaxLinkDistance = sqrt(nominalRange1 * sqrt(maxPowerFactor1) * nominalRange2 * sqrt(maxPowerFactor2))`
 
  To find a single antenna's `nominalRange` from a desired `maxTransmitDistance` given its `maxPowerFactor`:
  `nominalRange = maxTransmitDistance / sqrt(maxPowerFactor)`
 
  To find a single antenna's desired maximum range given the desired maximum link distance and another set `maxTransmitDistance`:
  `maxTransmitDistance1 = MaxLinkDistance * MaxLinkDistance / maxTransmitDistance2`
 
  Remember that `maxPowerFactor` may differ between antennas (and does, in my lastest configs: longAntenna is 8, mediumDish is 4, commDish is 16).
 
  Currently Kerbin's `maxPowerFactor` is hard-coded as 8.
 
  Feel free to use this spreadsheet for balancing antennas if it's useful to you: https://goo.gl/ChsbfL
 
  ## On Balance
  In my configs I've balanced the three stock antennas to cover all of the stock solar system. Since you're introducing five more antennas and working with OPM, you will probably want to change the behavior of the stock parts and diversify the range to gradually cover the whole OPM system. Since you have some parts specifically designed for use in planetary subsystems, their balance when transmitting to other parts is probably more important than their balance when transmitting to Kerbin. For longer range parts designed to make the whole interplanetary leap, the inverse is probably true.
 
  Feel free to ask questions! If anything's unclear or you just want to bounce balance ideas off of me, don't be shy. I'm always happy to help.
 
// AntennaRange // AntennaRange
// //
// Extensions.cs // Extensions.cs
// //
// Copyright © 2014-2015, toadicus // Copyright © 2014-2015, 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 ToadicusTools; using ToadicusTools;
   
namespace AntennaRange namespace AntennaRange
{ {
/// <summary> /// <summary>
/// A class of utility extensions for Vessels and Relays to help find a relay path back to Kerbin. /// A class of utility extensions for Vessels and Relays to help find a relay path back to Kerbin.
/// </summary> /// </summary>
public static class RelayExtensions public static class RelayExtensions
{ {
/// <summary>  
/// Returns the distance between two IAntennaRelays.  
/// </summary>  
/// <param name="relayOne">Relay one.</param>  
/// <param name="relayTwo">Relay two.</param>  
public static double DistanceTo(this IAntennaRelay relayOne, IAntennaRelay relayTwo)  
{  
return relayOne.vessel.DistanceTo(relayTwo.vessel);  
}  
   
/// <summary>  
/// Returns the distance from this IAntennaRelay to the given CelestialBody  
/// </summary>  
/// <param name="relay">Relay.</param>  
/// <param name="body">Body.</param>  
public static double SqrDistanceTo(this IAntennaRelay relay, CelestialBody body)  
{  
double range = relay.vessel.DistanceTo(body) - body.Radius;  
   
return range * range;  
}  
   
/// <summary>  
/// Returns the distance between two IAntennaRelays.  
/// </summary>  
/// <param name="relayOne">Relay one.</param>  
/// <param name="relayTwo">Relay two.</param>  
public static double SqrDistanceTo(this IAntennaRelay relayOne, IAntennaRelay relayTwo)  
{  
return relayOne.vessel.sqrDistanceTo(relayTwo.vessel);  
}  
   
/// <summary>  
/// Returns the distance from this IAntennaRelay to the given CelestialBody  
/// </summary>  
/// <param name="relay">Relay.</param>  
/// <param name="body">Body.</param>  
public static double DistanceTo(this IAntennaRelay relay, CelestialBody body)  
{  
double range = relay.vessel.DistanceTo(body) - body.Radius;  
   
return range;  
}  
   
/// <summary> /// <summary>
/// Returns the distance between this IAntennaRelay and a Vessel /// Returns the distance between this IAntennaRelay and a Vessel
/// </summary> /// </summary>
/// <param name="relay">This <see cref="IAntennaRelay"/></param> /// <param name="relay">This <see cref="IAntennaRelay"/></param>
/// <param name="Vessel">A <see cref="Vessel"/></param> /// <param name="Vessel">A <see cref="Vessel"/></param>
public static double DistanceTo(this AntennaRelay relay, Vessel Vessel) public static double DistanceTo(this AntennaRelay relay, Vessel Vessel)
{ {
return relay.vessel.DistanceTo(Vessel); return relay.vessel.DistanceTo(Vessel);
} }
   
/// <summary> /// <summary>
/// Returns the distance between this IAntennaRelay and a CelestialBody /// Returns the distance between this IAntennaRelay and a CelestialBody
/// </summary> /// </summary>
/// <param name="relay">This <see cref="IAntennaRelay"/></param> /// <param name="relay">This <see cref="IAntennaRelay"/></param>
/// <param name="body">A <see cref="CelestialBody"/></param> /// <param name="body">A <see cref="CelestialBody"/></param>
public static double DistanceTo(this AntennaRelay relay, CelestialBody body) public static double DistanceTo(this AntennaRelay relay, CelestialBody body)
{ {
return relay.vessel.DistanceTo(body) - body.Radius; return relay.vessel.DistanceTo(body) - body.Radius;
} }
   
/// <summary> /// <summary>
/// Returns the distance between this IAntennaRelay and another IAntennaRelay /// Returns the distance between this IAntennaRelay and another IAntennaRelay
/// </summary> /// </summary>
/// <param name="relayOne">This <see cref="IAntennaRelay"/></param> /// <param name="relayOne">This <see cref="IAntennaRelay"/></param>
/// <param name="relayTwo">Another <see cref="IAntennaRelay"/></param> /// <param name="relayTwo">Another <see cref="IAntennaRelay"/></param>
public static double DistanceTo(this AntennaRelay relayOne, IAntennaRelay relayTwo) public static double DistanceTo(this AntennaRelay relayOne, IAntennaRelay relayTwo)
{ {
return relayOne.DistanceTo(relayTwo.vessel); return relayOne.DistanceTo(relayTwo.vessel);
} }
   
/// <summary> /// <summary>
/// Returns the square of the distance between this IAntennaRelay and a Vessel /// Returns the square of the distance between this IAntennaRelay and a Vessel
/// </summary> /// </summary>
/// <param name="relay">This <see cref="IAntennaRelay"/></param> /// <param name="relay">This <see cref="IAntennaRelay"/></param>
/// <param name="vessel">A <see cref="Vessel"/></param> /// <param name="vessel">A <see cref="Vessel"/></param>
public static double sqrDistanceTo(this AntennaRelay relay, Vessel vessel) public static double sqrDistanceTo(this AntennaRelay relay, Vessel vessel)
{ {
return relay.vessel.sqrDistanceTo(vessel); return relay.vessel.sqrDistanceTo(vessel);
} }
   
/// <summary> /// <summary>
/// Returns the square of the distance between this IAntennaRelay and a CelestialBody /// Returns the square of the distance between this IAntennaRelay and a CelestialBody
/// </summary> /// </summary>
/// <param name="relay">This <see cref="IAntennaRelay"/></param> /// <param name="relay">This <see cref="IAntennaRelay"/></param>
/// <param name="body">A <see cref="CelestialBody"/></param> /// <param name="body">A <see cref="CelestialBody"/></param>
public static double sqrDistanceTo(this AntennaRelay relay, CelestialBody body) public static double sqrDistanceTo(this AntennaRelay relay, CelestialBody body)
{ {
return relay.vessel.sqrDistanceTo(body); return relay.vessel.sqrDistanceTo(body);
} }
   
/// <summary> /// <summary>
/// Returns the square of the distance between this IAntennaRelay and another IAntennaRelay /// Returns the square of the distance between this IAntennaRelay and another IAntennaRelay
/// </summary> /// </summary>
/// <param name="relayOne">This <see cref="IAntennaRelay"/></param> /// <param name="relayOne">This <see cref="IAntennaRelay"/></param>
/// <param name="relayTwo">Another <see cref="IAntennaRelay"/></param> /// <param name="relayTwo">Another <see cref="IAntennaRelay"/></param>
public static double sqrDistanceTo(this AntennaRelay relayOne, IAntennaRelay relayTwo) public static double sqrDistanceTo(this AntennaRelay relayOne, IAntennaRelay relayTwo)
{ {
return relayOne.vessel.sqrDistanceTo(relayTwo.vessel); return relayOne.vessel.sqrDistanceTo(relayTwo.vessel);
} }
   
/// <summary> /// <summary>
/// Returns all of the PartModules or ProtoPartModuleSnapshots implementing IAntennaRelay in this Vessel. /// Returns all of the PartModules or ProtoPartModuleSnapshots implementing IAntennaRelay in this Vessel.
/// </summary> /// </summary>
/// <param name="vessel">This <see cref="Vessel"/></param> /// <param name="vessel">This <see cref="Vessel"/></param>
public static IList<IAntennaRelay> GetAntennaRelays (this Vessel vessel) public static IList<IAntennaRelay> GetAntennaRelays (this Vessel vessel)
{ {
return RelayDatabase.Instance[vessel]; return RelayDatabase.Instance[vessel];
} }
   
/// <summary> /// <summary>
/// Determines if the specified vessel has a connected relay. /// Determines if the specified vessel has a connected relay.
/// </summary> /// </summary>
/// <returns><c>true</c> if the specified vessel has a connected relay; otherwise, <c>false</c>.</returns> /// <returns><c>true</c> if the specified vessel has a connected relay; otherwise, <c>false</c>.</returns>
/// <param name="vessel"></param> /// <param name="vessel"></param>
public static bool HasConnectedRelay(this Vessel vessel) public static bool HasConnectedRelay(this Vessel vessel)
{ {
IList<IAntennaRelay> vesselRelays = RelayDatabase.Instance[vessel]; IList<IAntennaRelay> vesselRelays = RelayDatabase.Instance[vessel];
IAntennaRelay relay; IAntennaRelay relay;
for (int rIdx = 0; rIdx < vesselRelays.Count; rIdx++) for (int rIdx = 0; rIdx < vesselRelays.Count; rIdx++)
{ {
relay = vesselRelays[rIdx]; relay = vesselRelays[rIdx];
if (relay.CanTransmit()) if (relay.CanTransmit())
{ {
return true; return true;
} }
} }
   
return false; return false;
} }
   
/// <summary> /// <summary>
/// Gets the <see cref="AntennaRange.ConnectionStatus"/> for this <see cref="Vessel"/> /// Gets the <see cref="AntennaRange.ConnectionStatus"/> for this <see cref="Vessel"/>
/// </summary> /// </summary>
/// <param name="vessel">This <see cref="Vessel"/></param> /// <param name="vessel">This <see cref="Vessel"/></param>
public static ConnectionStatus GetConnectionStatus(this Vessel vessel) public static ConnectionStatus GetConnectionStatus(this Vessel vessel)
{ {
bool canTransmit = false; bool canTransmit = false;
   
IList<IAntennaRelay> vesselRelays = RelayDatabase.Instance[vessel]; IList<IAntennaRelay> vesselRelays = RelayDatabase.Instance[vessel];
IAntennaRelay relay; IAntennaRelay relay;
for (int rIdx = 0; rIdx < vesselRelays.Count; rIdx++) for (int rIdx = 0; rIdx < vesselRelays.Count; rIdx++)
{ {
relay = vesselRelays[rIdx]; relay = vesselRelays[rIdx];
if (relay.LinkStatus > ConnectionStatus.None) if (relay.CanTransmit())
{ {
canTransmit = true; canTransmit = true;
  if (relay.transmitDistance <= relay.nominalTransmitDistance)
if (relay.LinkStatus == ConnectionStatus.Optimal)  
{ {
return ConnectionStatus.Optimal; return ConnectionStatus.Optimal;
} }
} }
} }
   
if (canTransmit) if (canTransmit)
{ {
return ConnectionStatus.Suboptimal; return ConnectionStatus.Suboptimal;
} }
else else
{ {
return ConnectionStatus.None; return ConnectionStatus.None;
} }
} }
   
/// <summary> /// <summary>
/// Gets the best relay on this Vessel. The best relay may not be able to transmit. /// Gets the best relay on this Vessel. The best relay may not be able to transmit.
/// </summary> /// </summary>
/// <param name="vessel">This <see cref="Vessel"/></param> /// <param name="vessel">This <see cref="Vessel"/></param>
public static IAntennaRelay GetBestRelay(this Vessel vessel) public static IAntennaRelay GetBestRelay(this Vessel vessel)
{ {
return RelayDatabase.Instance.GetBestVesselRelay(vessel); return RelayDatabase.Instance.GetBestVesselRelay(vessel);
} }
} }
   
#pragma warning disable 1591 #pragma warning disable 1591
/// <summary> /// <summary>
/// An Enum describing the connection status of a vessel or relay. /// An Enum describing the connection status of a vessel or relay.
/// </summary> /// </summary>
public enum ConnectionStatus public enum ConnectionStatus
{ {
None, None,
Suboptimal, Suboptimal,
Optimal Optimal
} }
} }