| // | // |
| // IVOID_Module.cs | // IVOID_Module.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| using System; | using System; |
| namespace VOID | namespace VOID |
| { | { |
| public interface IVOID_Module | public interface IVOID_Module |
| { | { |
| string Name { get; } | string Name { get; } |
| bool toggleActive { get; set; } | bool toggleActive { get; set; } |
| bool guiRunning { get; } | bool guiRunning { get; } |
| void DrawGUI(); | void DrawGUI(); |
| void StartGUI(); | void StartGUI(); |
| void StopGUI(); | void StopGUI(); |
| void DrawConfigurables(); | void DrawConfigurables(); |
| void LoadConfig(); | void LoadConfig(); |
| void _SaveToConfig(KSP.IO.PluginConfiguration config); | void _SaveToConfig(KSP.IO.PluginConfiguration config); |
| } | } |
| public interface IVOID_BehaviorModule : IVOID_Module | |
| { | |
| void Update(); | |
| void FixedUpdate(); | |
| } | |
| public interface IVOID_EditorModule : IVOID_Module {} | |
| } | } |
| // | // |
| // Tools.cs | // Tools.cs |
| // | // |
| // Author: | // Author: |
| // toadicus | // toadicus |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| // | // |
| // This software uses VesselSimulator and Engineer.Extensions from Engineer Redux. | // This software uses VesselSimulator and Engineer.Extensions from Engineer Redux. |
| // Engineer Redux (c) 2013 cybutek | // Engineer Redux (c) 2013 cybutek |
| // Used by permission. | // Used by permission. |
| // | // |
| /////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////// |
| using System; | using System; |
| using System.Collections.Generic; | using System.Collections.Generic; |
| using UnityEngine; | using UnityEngine; |
| namespace VOID | namespace VOID |
| { | { |
| public static class VOIDLabels | public static class VOIDLabels |
| { | { |
| public static string void_primary = "Primary"; | public static string void_primary = "Primary"; |
| public static string void_altitude_asl = "Altitude (ASL)"; | public static string void_altitude_asl = "Altitude (ASL)"; |
| public static string void_velocity = "Velocity"; | public static string void_velocity = "Velocity"; |
| public static string void_apoapsis = "Apoapsis"; | public static string void_apoapsis = "Apoapsis"; |
| public static string void_periapsis = "Periapsis"; | public static string void_periapsis = "Periapsis"; |
| } | } |
| public static class Tools | public static class Tools |
| { | { |
| // Toadicus edit: Added re-implementation of the CBAttributeMap.GetAtt function that does not fire a debug message to the game screen. | // Toadicus edit: Added re-implementation of the CBAttributeMap.GetAtt function that does not fire a debug message to the game screen. |
| public static CBAttributeMap.MapAttribute Toadicus_GetAtt(Vessel vessel) | public static CBAttributeMap.MapAttribute Toadicus_GetAtt(Vessel vessel) |
| { | { |
| CBAttributeMap.MapAttribute mapAttribute; | CBAttributeMap.MapAttribute mapAttribute; |
| try | try |
| { | { |
| CBAttributeMap BiomeMap = vessel.mainBody.BiomeMap; | CBAttributeMap BiomeMap = vessel.mainBody.BiomeMap; |
| double lat = vessel.latitude * Math.PI / 180d; | double lat = vessel.latitude * Math.PI / 180d; |
| double lon = vessel.longitude * Math.PI / 180d; | double lon = vessel.longitude * Math.PI / 180d; |
| lon -= Math.PI / 2d; | lon -= Math.PI / 2d; |
| if (lon < 0d) | if (lon < 0d) |
| { | { |
| lon += 2d * Math.PI; | lon += 2d * Math.PI; |
| } | } |
| float v = (float)(lat / Math.PI) + 0.5f; | float v = (float)(lat / Math.PI) + 0.5f; |
| float u = (float)(lon / (2d * Math.PI)); | float u = (float)(lon / (2d * Math.PI)); |
| Color pixelBilinear = BiomeMap.Map.GetPixelBilinear (u, v); | Color pixelBilinear = BiomeMap.Map.GetPixelBilinear (u, v); |
| mapAttribute = BiomeMap.defaultAttribute; | mapAttribute = BiomeMap.defaultAttribute; |
| if (BiomeMap.Map != null) | if (BiomeMap.Map != null) |
| { | { |
| if (BiomeMap.exactSearch) | if (BiomeMap.exactSearch) |
| { | { |
| for (int i = 0; i < BiomeMap.Attributes.Length; ++i) | for (int i = 0; i < BiomeMap.Attributes.Length; ++i) |
| { | { |
| if (pixelBilinear == BiomeMap.Attributes[i].mapColor) | if (pixelBilinear == BiomeMap.Attributes[i].mapColor) |
| { | { |
| mapAttribute = BiomeMap.Attributes[i]; | mapAttribute = BiomeMap.Attributes[i]; |
| } | } |
| } | } |
| } | } |
| else | else |
| { | { |
| float zero = 0; | float zero = 0; |
| float num = 1 / zero; | float num = 1 / zero; |
| for (int j = 0; j < BiomeMap.Attributes.Length; ++j) | for (int j = 0; j < BiomeMap.Attributes.Length; ++j) |
| { | { |
| Color mapColor = BiomeMap.Attributes [j].mapColor; | Color mapColor = BiomeMap.Attributes [j].mapColor; |
| float sqrMagnitude = ((Vector4)(mapColor - pixelBilinear)).sqrMagnitude; | float sqrMagnitude = ((Vector4)(mapColor - pixelBilinear)).sqrMagnitude; |
| if (sqrMagnitude < num) | if (sqrMagnitude < num) |
| { | { |
| bool testCase = true; | bool testCase = true; |
| if (BiomeMap.nonExactThreshold != -1) | if (BiomeMap.nonExactThreshold != -1) |
| { | { |
| testCase = (sqrMagnitude < BiomeMap.nonExactThreshold); | testCase = (sqrMagnitude < BiomeMap.nonExactThreshold); |
| } | } |
| if (testCase) | if (testCase) |
| { | { |
| mapAttribute = BiomeMap.Attributes[j]; | mapAttribute = BiomeMap.Attributes[j]; |
| num = sqrMagnitude; | num = sqrMagnitude; |
| } | } |
| } | } |
| } | } |
| } | } |
| } | } |
| } | } |
| catch (NullReferenceException) | catch (NullReferenceException) |
| { | { |
| mapAttribute = new CBAttributeMap.MapAttribute(); | mapAttribute = new CBAttributeMap.MapAttribute(); |
| mapAttribute.name = "N/A"; | mapAttribute.name = "N/A"; |
| } | } |
| return mapAttribute; | return mapAttribute; |
| } | } |
| public static string GetLongitudeString(Vessel vessel, string format="F4") | public static string GetLongitudeString(Vessel vessel, string format="F4") |
| { | { |
| string dir_long = "W"; | string dir_long = "W"; |
| double v_long = vessel.longitude; | double v_long = vessel.longitude; |
| v_long = FixDegreeDomain(v_long); | v_long = FixDegreeDomain(v_long); |
| if (v_long < -180d) | if (v_long < -180d) |
| { | { |
| v_long += 360d; | v_long += 360d; |
| } | } |
| if (v_long >= 180) | if (v_long >= 180) |
| { | { |
| v_long -= 360d; | v_long -= 360d; |
| } | } |
| if (v_long > 0) dir_long = "E"; | if (v_long > 0) dir_long = "E"; |
| return string.Format("{0}° {1}", Math.Abs(v_long).ToString(format), dir_long); | return string.Format("{0}° {1}", Math.Abs(v_long).ToString(format), dir_long); |
| } | } |
| public static string GetLatitudeString(Vessel vessel, string format="F4") | public static string GetLatitudeString(Vessel vessel, string format="F4") |
| { | { |
| string dir_lat = "S"; | string dir_lat = "S"; |
| double v_lat = vessel.latitude; | double v_lat = vessel.latitude; |
| if (v_lat > 0) dir_lat = "N"; | if (v_lat > 0) dir_lat = "N"; |
| return string.Format("{0}° {1}", Math.Abs(v_lat).ToString(format), dir_lat); | return string.Format("{0}° {1}", Math.Abs(v_lat).ToString(format), dir_lat); |
| } | } |
| /////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////// |
| //For MuMech_get_heading() | //For MuMech_get_heading() |
| public class MuMech_MovingAverage | public class MuMech_MovingAverage |
| { | { |
| private double[] store; | private double[] store; |
| private int storeSize; | private int storeSize; |
| private int nextIndex = 0; | private int nextIndex = 0; |
| public double value | public double value |
| { | { |
| get | get |
| { | { |
| double tmp = 0; | double tmp = 0; |
| foreach (double i in store) | foreach (double i in store) |
| { | { |
| tmp += i; | tmp += i; |
| } | } |
| return tmp / storeSize; | return tmp / storeSize; |
| } | } |
| set | set |
| { | { |
| store[nextIndex] = value; | store[nextIndex] = value; |
| nextIndex = (nextIndex + 1) % storeSize; | nextIndex = (nextIndex + 1) % storeSize; |
| } | } |
| } | } |
| public MuMech_MovingAverage(int size = 10, double startingValue = 0) | public MuMech_MovingAverage(int size = 10, double startingValue = 0) |
| { | { |
| storeSize = size; | storeSize = size; |
| store = new double[size]; | store = new double[size]; |
| force(startingValue); | force(startingValue); |
| } | } |
| public void force(double newValue) | public void force(double newValue) |
| { | { |
| for (int i = 0; i < storeSize; i++) | for (int i = 0; i < storeSize; i++) |
| { | { |
| store[i] = newValue; | store[i] = newValue; |
| } | } |
| } | } |
| public static implicit operator double(MuMech_MovingAverage v) | public static implicit operator double(MuMech_MovingAverage v) |
| { | { |
| return v.value; | return v.value; |
| } | } |
| public override string ToString() | public override string ToString() |
| { | { |
| return value.ToString(); | return value.ToString(); |
| } | } |
| public string ToString(string format) | public string ToString(string format) |
| { | { |
| return value.ToString(format); | return value.ToString(format); |
| } | } |
| } | } |
| //From http://svn.mumech.com/KSP/trunk/MuMechLib/VOID.vesselState.cs | //From http://svn.mumech.com/KSP/trunk/MuMechLib/VOID.vesselState.cs |
| public static double MuMech_get_heading(Vessel vessel) | public static double MuMech_get_heading(Vessel vessel) |
| { | { |
| Vector3d CoM = vessel.findWorldCenterOfMass(); | Vector3d CoM = vessel.findWorldCenterOfMass(); |
| Vector3d up = (CoM - vessel.mainBody.position).normalized; | Vector3d up = (CoM - vessel.mainBody.position).normalized; |
| Vector3d north = Vector3d.Exclude(up, (vessel.mainBody.position + vessel.mainBody.transform.up * (float)vessel.mainBody.Radius) - CoM).normalized; | Vector3d north = Vector3d.Exclude(up, (vessel.mainBody.position + vessel.mainBody.transform.up * (float)vessel.mainBody.Radius) - CoM).normalized; |
| Quaternion rotationSurface = Quaternion.LookRotation(north, up); | Quaternion rotationSurface = Quaternion.LookRotation(north, up); |
| Quaternion rotationvesselSurface = Quaternion.Inverse(Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(vessel.transform.rotation) * rotationSurface); | Quaternion rotationvesselSurface = Quaternion.Inverse(Quaternion.Euler(90, 0, 0) * Quaternion.Inverse(vessel.transform.rotation) * rotationSurface); |
| MuMech_MovingAverage vesselHeading = new MuMech_MovingAverage(); | MuMech_MovingAverage vesselHeading = new MuMech_MovingAverage(); |
| vesselHeading.value = rotationvesselSurface.eulerAngles.y; | vesselHeading.value = rotationvesselSurface.eulerAngles.y; |
| return vesselHeading.value * 10; // *10 by me | return vesselHeading.value * 10; // *10 by me |
| } | } |
| //From http://svn.mumech.com/KSP/trunk/MuMechLib/MuUtils.cs | //From http://svn.mumech.com/KSP/trunk/MuMechLib/MuUtils.cs |
| public static string MuMech_ToSI(double d) | public static string MuMech_ToSI(double d) |
| { | { |
| int digits = 2; | int digits = 2; |
| double exponent = Math.Log10(Math.Abs(d)); | double exponent = Math.Log10(Math.Abs(d)); |
| if (Math.Abs(d) >= 1) | if (Math.Abs(d) >= 1) |
| { | { |
| switch ((int)Math.Floor(exponent)) | switch ((int)Math.Floor(exponent)) |
| { | { |
| case 0: | case 0: |
| case 1: | case 1: |
| case 2: | case 2: |
| return d.ToString("F" + digits); | return d.ToString("F" + digits); |
| case 3: | case 3: |
| case 4: | case 4: |
| case 5: | case 5: |
| return (d / 1e3).ToString("F" + digits) + "k"; | return (d / 1e3).ToString("F" + digits) + "k"; |
| case 6: | case 6: |
| case 7: | case 7: |
| case 8: | case 8: |
| return (d / 1e6).ToString("F" + digits) + "M"; | return (d / 1e6).ToString("F" + digits) + "M"; |
| case 9: | case 9: |
| case 10: | case 10: |
| case 11: | case 11: |
| return (d / 1e9).ToString("F" + digits) + "G"; | return (d / 1e9).ToString("F" + digits) + "G"; |
| case 12: | case 12: |
| case 13: | case 13: |
| case 14: | case 14: |
| return (d / 1e12).ToString("F" + digits) + "T"; | return (d / 1e12).ToString("F" + digits) + "T"; |
| case 15: | case 15: |
| case 16: | case 16: |
| case 17: | case 17: |
| return (d / 1e15).ToString("F" + digits) + "P"; | return (d / 1e15).ToString("F" + digits) + "P"; |
| case 18: | case 18: |
| case 19: | case 19: |
| case 20: | case 20: |
| return (d / 1e18).ToString("F" + digits) + "E"; | return (d / 1e18).ToString("F" + digits) + "E"; |
| case 21: | case 21: |
| case 22: | case 22: |
| case 23: | case 23: |
| return (d / 1e21).ToString("F" + digits) + "Z"; | return (d / 1e21).ToString("F" + digits) + "Z"; |
| default: | default: |
| return (d / 1e24).ToString("F" + digits) + "Y"; | return (d / 1e24).ToString("F" + digits) + "Y"; |
| } | } |
| } | } |
| else if (Math.Abs(d) > 0) | else if (Math.Abs(d) > 0) |
| { | { |
| switch ((int)Math.Floor(exponent)) | switch ((int)Math.Floor(exponent)) |
| { | { |
| case -1: | case -1: |
| case -2: | case -2: |
| case -3: | case -3: |
| return (d * 1e3).ToString("F" + digits) + "m"; | return (d * 1e3).ToString("F" + digits) + "m"; |
| case -4: | case -4: |
| case -5: | case -5: |
| case -6: | case -6: |
| return (d * 1e6).ToString("F" + digits) + "μ"; | return (d * 1e6).ToString("F" + digits) + "μ"; |
| case -7: | case -7: |
| case -8: | case -8: |
| case -9: | case -9: |
| return (d * 1e9).ToString("F" + digits) + "n"; | return (d * 1e9).ToString("F" + digits) + "n"; |
| case -10: | case -10: |
| case -11: | case -11: |
| case -12: | case -12: |
| return (d * 1e12).ToString("F" + digits) + "p"; | return (d * 1e12).ToString("F" + digits) + "p"; |
| case -13: | case -13: |
| case -14: | case -14: |
| case -15: | case -15: |
| return (d * 1e15).ToString("F" + digits) + "f"; | return (d * 1e15).ToString("F" + digits) + "f"; |
| case -16: | case -16: |
| case -17: | case -17: |
| case -18: | case -18: |
| return (d * 1e18).ToString("F" + digits) + "a"; | return (d * 1e18).ToString("F" + digits) + "a"; |
| case -19: | case -19: |
| case -20: | case -20: |
| case -21: | case -21: |
| return (d * 1e21).ToString("F" + digits) + "z"; | return (d * 1e21).ToString("F" + digits) + "z"; |
| default: | default: |
| return (d * 1e24).ToString("F" + digits) + "y"; | return (d * 1e24).ToString("F" + digits) + "y"; |
| } | } |
| } | } |
| else | else |
| { | { |
| return "0"; | return "0"; |
| } | } |
| } | } |
| public static string ConvertInterval(double seconds) | public static string ConvertInterval(double seconds) |
| { | { |
| string format_1 = "{0:D1}y {1:D1}d {2:D2}h {3:D2}m {4:D2}.{5:D1}s"; | string format_1 = "{0:D1}y {1:D1}d {2:D2}h {3:D2}m {4:D2}.{5:D1}s"; |
| string format_2 = "{0:D1}d {1:D2}h {2:D2}m {3:D2}.{4:D1}s"; | string format_2 = "{0:D1}d {1:D2}h {2:D2}m {3:D2}.{4:D1}s"; |
| string format_3 = "{0:D2}h {1:D2}m {2:D2}.{3:D1}s"; | string format_3 = "{0:D2}h {1:D2}m {2:D2}.{3:D1}s"; |
| TimeSpan interval; | TimeSpan interval; |
| try | try |
| { | { |
| interval = TimeSpan.FromSeconds(seconds); | interval = TimeSpan.FromSeconds(seconds); |
| } | } |
| catch (OverflowException) | catch (OverflowException) |
| { | { |
| return "NaN"; | return "NaN"; |
| } | } |
| int years = interval.Days / 365; | int years = interval.Days / 365; |
| string output; | string output; |
| if (years > 0) | if (years > 0) |
| { | { |
| output = string.Format(format_1, | output = string.Format(format_1, |
| years, | years, |
| interval.Days - (years * 365), // subtract years * 365 for accurate day count | interval.Days - (years * 365), // subtract years * 365 for accurate day count |
| interval.Hours, | interval.Hours, |
| interval.Minutes, | interval.Minutes, |
| interval.Seconds, | interval.Seconds, |
| interval.Milliseconds.ToString().Substring(0, 1)); | interval.Milliseconds.ToString().Substring(0, 1)); |
| } | } |
| else if (interval.Days > 0) | else if (interval.Days > 0) |
| { | { |
| output = string.Format(format_2, | output = string.Format(format_2, |
| interval.Days, | interval.Days, |
| interval.Hours, | interval.Hours, |
| interval.Minutes, | interval.Minutes, |
| interval.Seconds, | interval.Seconds, |
| interval.Milliseconds.ToString().Substring(0, 1)); | interval.Milliseconds.ToString().Substring(0, 1)); |
| } | } |
| else | else |
| { | { |
| output = string.Format(format_3, | output = string.Format(format_3, |
| interval.Hours, | interval.Hours, |
| interval.Minutes, | interval.Minutes, |
| interval.Seconds, | interval.Seconds, |
| interval.Milliseconds.ToString().Substring(0, 1)); | interval.Milliseconds.ToString().Substring(0, 1)); |
| } | } |
| return output; | return output; |
| } | } |
| public static string UppercaseFirst(string s) | public static string UppercaseFirst(string s) |
| { | { |
| if (string.IsNullOrEmpty(s)) | if (string.IsNullOrEmpty(s)) |
| { | { |
| return string.Empty; | return string.Empty; |
| } | } |
| char[] a = s.ToCharArray(); | char[] a = s.ToCharArray(); |
| a[0] = char.ToUpper(a[0]); | a[0] = char.ToUpper(a[0]); |
| return new string(a); | return new string(a); |
| } | } |
| //transfer angles | //transfer angles |
| public static double Nivvy_CalcTransferPhaseAngle(double r_current, double r_target, double grav_param) | public static double Nivvy_CalcTransferPhaseAngle(double r_current, double r_target, double grav_param) |
| { | { |
| double T_target = (2 * Math.PI) * Math.Sqrt(Math.Pow((r_target / 1000), 3) / (grav_param / 1000000000)); | double T_target = (2 * Math.PI) * Math.Sqrt(Math.Pow((r_target / 1000), 3) / (grav_param / 1000000000)); |
| double T_transfer = (2 * Math.PI) * Math.Sqrt(Math.Pow((((r_target / 1000) + (r_current / 1000)) / 2), 3) / (grav_param / 1000000000)); | double T_transfer = (2 * Math.PI) * Math.Sqrt(Math.Pow((((r_target / 1000) + (r_current / 1000)) / 2), 3) / (grav_param / 1000000000)); |
| return 360 * (0.5 - (T_transfer / (2 * T_target))); | return 360 * (0.5 - (T_transfer / (2 * T_target))); |
| } | } |
| public static double Younata_DeltaVToGetToOtherBody(double mu, double r1, double r2) | public static double Younata_DeltaVToGetToOtherBody(double mu, double r1, double r2) |
| { | { |
| /* | /* |
| def deltaVToGetToOtherBody(mu, r1, r2): | def deltaVToGetToOtherBody(mu, r1, r2): |
| # mu = gravity param of common orbiting body of r1 and r2 | # mu = gravity param of common orbiting body of r1 and r2 |
| # (e.g. for mun to minmus, mu is kerbin's gravity param | # (e.g. for mun to minmus, mu is kerbin's gravity param |
| # r1 = initial body's orbit radius | # r1 = initial body's orbit radius |
| # r2 = target body's orbit radius | # r2 = target body's orbit radius |
| # return value is km/s | # return value is km/s |
| sur1 = math.sqrt(mu / r1) | sur1 = math.sqrt(mu / r1) |
| sr1r2 = math.sqrt(float(2*r2)/float(r1+r2)) | sr1r2 = math.sqrt(float(2*r2)/float(r1+r2)) |
| mult = sr1r2 - 1 | mult = sr1r2 - 1 |
| return sur1 * mult | return sur1 * mult |
| */ | */ |
| double sur1, sr1r2, mult; | double sur1, sr1r2, mult; |
| sur1 = Math.Sqrt(mu / r1); | sur1 = Math.Sqrt(mu / r1); |
| sr1r2 = Math.Sqrt((2 * r2) / (r1 + r2)); | sr1r2 = Math.Sqrt((2 * r2) / (r1 + r2)); |
| mult = sr1r2 - 1; | mult = sr1r2 - 1; |
| return sur1 * mult; | return sur1 * mult; |
| } | } |
| public static double Younata_DeltaVToExitSOI(double mu, double r1, double r2, double v) | public static double Younata_DeltaVToExitSOI(double mu, double r1, double r2, double v) |
| { | { |
| /* | /* |
| def deltaVToExitSOI(mu, r1, r2, v): | def deltaVToExitSOI(mu, r1, r2, v): |
| # mu = gravity param of current body | # mu = gravity param of current body |
| # r1 = current orbit radius | # r1 = current orbit radius |
| # r2 = SOI radius | # r2 = SOI radius |
| # v = SOI exit velocity | # v = SOI exit velocity |
| foo = r2 * (v**2) - 2 * mu | foo = r2 * (v**2) - 2 * mu |
| bar = r1 * foo + (2 * r2 * mu) | bar = r1 * foo + (2 * r2 * mu) |
| r = r1*r2 | r = r1*r2 |
| return math.sqrt(bar / r) | return math.sqrt(bar / r) |
| */ | */ |
| double foo = r2 * Math.Pow(v, 2) - 2 * mu; | double foo = r2 * Math.Pow(v, 2) - 2 * mu; |
| double bar = r1 * foo + (2 * r2 * mu); | double bar = r1 * foo + (2 * r2 * mu); |
| double r = r1 * r2; | double r = r1 * r2; |
| return Math.Sqrt(bar / r); | return Math.Sqrt(bar / r); |
| } | } |
| public static double Younata_TransferBurnPoint(double r, double v, double angle, double mu) | public static double Younata_TransferBurnPoint(double r, double v, double angle, double mu) |
| { | { |
| /* | /* |
| def transferBurnPoint(r, v, angle, mu): | def transferBurnPoint(r, v, angle, mu): |
| # r = parking orbit radius | # r = parking orbit radius |
| # v = ejection velocity | # v = ejection velocity |
| # angle = phase angle (from function phaseAngle()) | # angle = phase angle (from function phaseAngle()) |
| # mu = gravity param of current body. | # mu = gravity param of current body. |
| epsilon = ((v**2)/2) - (mu / r) | epsilon = ((v**2)/2) - (mu / r) |
| h = r * v * math.sin(angle) | h = r * v * math.sin(angle) |
| e = math.sqrt(1 + ((2 * epsilon * h**2)/(mu**2))) | e = math.sqrt(1 + ((2 * epsilon * h**2)/(mu**2))) |
| theta = math.acos(1.0 / e) | theta = math.acos(1.0 / e) |
| degrees = theta * (180.0 / math.pi) | degrees = theta * (180.0 / math.pi) |
| return 180 - degrees | return 180 - degrees |
| */ | */ |
| double epsilon, h, ee, theta, degrees; | double epsilon, h, ee, theta, degrees; |
| epsilon = (Math.Pow(v, 2) / 2) - (mu / r); | epsilon = (Math.Pow(v, 2) / 2) - (mu / r); |
| h = r * v * Math.Sin(angle); | h = r * v * Math.Sin(angle); |
| ee = Math.Sqrt(1 + ((2 * epsilon * Math.Pow(h, 2)) / Math.Pow(mu, 2))); | ee = Math.Sqrt(1 + ((2 * epsilon * Math.Pow(h, 2)) / Math.Pow(mu, 2))); |
| theta = Math.Acos(1.0 / ee); | theta = Math.Acos(1.0 / ee); |
| degrees = theta * (180.0 / Math.PI); | degrees = theta * (180.0 / Math.PI); |
| return 180 - degrees; | return 180 - degrees; |
| // returns the ejection angle | // returns the ejection angle |
| } | } |
| public static double Adammada_CurrrentPhaseAngle(double body_LAN, double body_orbitPct, double origin_LAN, double origin_orbitPct) | public static double Adammada_CurrrentPhaseAngle(double body_LAN, double body_orbitPct, double origin_LAN, double origin_orbitPct) |
| { | { |
| double angle = (body_LAN / 360 + body_orbitPct) - (origin_LAN / 360 + origin_orbitPct); | double angle = (body_LAN / 360 + body_orbitPct) - (origin_LAN / 360 + origin_orbitPct); |
| if (angle > 1) angle = angle - 1; | if (angle > 1) angle = angle - 1; |
| if (angle < 0) angle = angle + 1; | if (angle < 0) angle = angle + 1; |
| if (angle > 0.5) angle = angle - 1; | if (angle > 0.5) angle = angle - 1; |
| angle = angle * 360; | angle = angle * 360; |
| return angle; | return angle; |
| } | } |
| public static double Adammada_CurrentEjectionAngle(double vessel_long, double origin_rotAngle, double origin_LAN, double origin_orbitPct) | public static double Adammada_CurrentEjectionAngle(double vessel_long, double origin_rotAngle, double origin_LAN, double origin_orbitPct) |
| { | { |
| //double eangle = ((FlightGlobals.ActiveVOID.vessel.longitude + orbiting.rotationAngle) - (orbiting.orbit.LAN / 360 + orbiting.orbit.orbitPercent) * 360); | //double eangle = ((FlightGlobals.ActiveVOID.vessel.longitude + orbiting.rotationAngle) - (orbiting.orbit.LAN / 360 + orbiting.orbit.orbitPercent) * 360); |
| double eangle = ((vessel_long + origin_rotAngle) - (origin_LAN / 360 + origin_orbitPct) * 360); | double eangle = ((vessel_long + origin_rotAngle) - (origin_LAN / 360 + origin_orbitPct) * 360); |
| while (eangle < 0) eangle = eangle + 360; | while (eangle < 0) eangle = eangle + 360; |
| while (eangle > 360) eangle = eangle - 360; | while (eangle > 360) eangle = eangle - 360; |
| if (eangle < 270) eangle = 90 - eangle; | if (eangle < 270) eangle = 90 - eangle; |
| else eangle = 450 - eangle; | else eangle = 450 - eangle; |
| return eangle; | return eangle; |
| } | } |
| public static double mrenigma03_calcphase(Vessel vessel, CelestialBody target) //calculates phase angle between the current body and target body | public static double mrenigma03_calcphase(Vessel vessel, CelestialBody target) //calculates phase angle between the current body and target body |
| { | { |
| Vector3d vecthis = new Vector3d(); | Vector3d vecthis = new Vector3d(); |
| Vector3d vectarget = new Vector3d(); | Vector3d vectarget = new Vector3d(); |
| vectarget = target.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime()); | vectarget = target.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime()); |
| if ((vessel.mainBody.name == "Sun") || (vessel.mainBody.referenceBody.referenceBody.name == "Sun")) | if ((vessel.mainBody.name == "Sun") || (vessel.mainBody.referenceBody.referenceBody.name == "Sun")) |
| { | { |
| vecthis = vessel.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime()); | vecthis = vessel.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime()); |
| } | } |
| else | else |
| { | { |
| vecthis = vessel.mainBody.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime()); | vecthis = vessel.mainBody.orbit.getRelativePositionAtUT(Planetarium.GetUniversalTime()); |
| } | } |
| vecthis = Vector3d.Project(new Vector3d(vecthis.x, 0, vecthis.z), vecthis); | vecthis = Vector3d.Project(new Vector3d(vecthis.x, 0, vecthis.z), vecthis); |
| vectarget = Vector3d.Project(new Vector3d(vectarget.x, 0, vectarget.z), vectarget); | vectarget = Vector3d.Project(new Vector3d(vectarget.x, 0, vectarget.z), vectarget); |
| Vector3d prograde = new Vector3d(); | Vector3d prograde = new Vector3d(); |
| prograde = Quaternion.AngleAxis(90, Vector3d.forward) * vecthis; | prograde = Quaternion.AngleAxis(90, Vector3d.forward) * vecthis; |
| double phase = Vector3d.Angle(vecthis, vectarget); | double phase = Vector3d.Angle(vecthis, vectarget); |
| if (Vector3d.Angle(prograde, vectarget) > 90) phase = 360 - phase; | if (Vector3d.Angle(prograde, vectarget) > 90) phase = 360 - phase; |
| return (phase + 360) % 360; | return (phase + 360) % 360; |
| } | } |
| public static double FixAngleDomain(double Angle, bool Degrees = false) | public static double FixAngleDomain(double Angle, bool Degrees = false) |
| { | { |
| double Extent = 2d * Math.PI; | double Extent = 2d * Math.PI; |
| if (Degrees) { | if (Degrees) { |
| Extent = 360d; | Extent = 360d; |
| } | } |
| Angle = Angle % (Extent); | Angle = Angle % (Extent); |
| if (Angle < 0d) | if (Angle < 0d) |
| { | { |
| Angle += Extent; | Angle += Extent; |
| } | } |
| return Angle; | return Angle; |
| } | } |
| public static double FixDegreeDomain(double Angle) | public static double FixDegreeDomain(double Angle) |
| { | { |
| return FixAngleDomain (Angle, true); | return FixAngleDomain (Angle, true); |
| } | } |
| public static double adjustCurrPhaseAngle(double transfer_angle, double curr_phase) | public static double adjustCurrPhaseAngle(double transfer_angle, double curr_phase) |
| { | { |
| if (transfer_angle < 0) | if (transfer_angle < 0) |
| { | { |
| if (curr_phase > 0) return (-1 * (360 - curr_phase)); | if (curr_phase > 0) return (-1 * (360 - curr_phase)); |
| else if (curr_phase < 0) return curr_phase; | else if (curr_phase < 0) return curr_phase; |
| } | } |
| else if (transfer_angle > 0) | else if (transfer_angle > 0) |
| { | { |
| if (curr_phase > 0) return curr_phase; | if (curr_phase > 0) return curr_phase; |
| else if (curr_phase < 0) return (360 + curr_phase); | else if (curr_phase < 0) return (360 + curr_phase); |
| } | } |
| return curr_phase; | return curr_phase; |
| } | } |
| public static double adjust_current_ejection_angle(double curr_ejection) | public static double adjust_current_ejection_angle(double curr_ejection) |
| { | { |
| //curr_ejection WILL need to be adjusted once for all transfers as it returns values ranging -180 to 180 | //curr_ejection WILL need to be adjusted once for all transfers as it returns values ranging -180 to 180 |
| // need 0-360 instead | // need 0-360 instead |
| // | // |
| // ie i have -17 in the screenshot | // ie i have -17 in the screenshot |
| // need it to show 343 | // need it to show 343 |
| // | // |
| // do this | // do this |
| // | // |
| // if < 0, add curr to 360 // 360 + (-17) = 343 | // if < 0, add curr to 360 // 360 + (-17) = 343 |
| // else its good as it is | // else its good as it is |
| if (curr_ejection < 0) return 360 + curr_ejection; | if (curr_ejection < 0) return 360 + curr_ejection; |
| else return curr_ejection; | else return curr_ejection; |
| } | } |
| public static double adjust_transfer_ejection_angle(double trans_ejection, double trans_phase) | public static double adjust_transfer_ejection_angle(double trans_ejection, double trans_phase) |
| { | { |
| // if transfer_phase_angle < 0 its a lower transfer | // if transfer_phase_angle < 0 its a lower transfer |
| //180 + curr_ejection | //180 + curr_ejection |
| // else if transfer_phase_angle > 0 its good as it is | // else if transfer_phase_angle > 0 its good as it is |
| if (trans_phase < 0) return 180 + trans_ejection; | if (trans_phase < 0) return 180 + trans_ejection; |
| else return trans_ejection; | else return trans_ejection; |
| } | } |
| public static double TrueAltitude(Vessel vessel) | public static double TrueAltitude(Vessel vessel) |
| { | { |
| double trueAltitude = vessel.orbit.altitude - vessel.terrainAltitude; | double trueAltitude = vessel.orbit.altitude - vessel.terrainAltitude; |
| // HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m. | // HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m. |
| if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean ) | if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean ) |
| { | { |
| trueAltitude = vessel.orbit.altitude; | trueAltitude = vessel.orbit.altitude; |
| } | } |
| return trueAltitude; | return trueAltitude; |
| } | } |
| public static string get_heading_text(double heading) | public static string get_heading_text(double heading) |
| { | { |
| if (heading > 348.75 || heading <= 11.25) return "N"; | if (heading > 348.75 || heading <= 11.25) return "N"; |
| else if (heading > 11.25 && heading <= 33.75) return "NNE"; | else if (heading > 11.25 && heading <= 33.75) return "NNE"; |
| else if (heading > 33.75 && heading <= 56.25) return "NE"; | else if (heading > 33.75 && heading <= 56.25) return "NE"; |
| else if (heading > 56.25 && heading <= 78.75) return "ENE"; | else if (heading > 56.25 && heading <= 78.75) return "ENE"; |
| else if (heading > 78.75 && heading <= 101.25) return "E"; | else if (heading > 78.75 && heading <= 101.25) return "E"; |
| else if (heading > 101.25 && heading <= 123.75) return "ESE"; | else if (heading > 101.25 && heading <= 123.75) return "ESE"; |
| else if (heading > 123.75 && heading <= 146.25) return "SE"; | else if (heading > 123.75 && heading <= 146.25) return "SE"; |
| else if (heading > 146.25 && heading <= 168.75) return "SSE"; | else if (heading > 146.25 && heading <= 168.75) return "SSE"; |
| else if (heading > 168.75 && heading <= 191.25) return "S"; | else if (heading > 168.75 && heading <= 191.25) return "S"; |
| else if (heading > 191.25 && heading <= 213.75) return "SSW"; | else if (heading > 191.25 && heading <= 213.75) return "SSW"; |
| else if (heading > 213.75 && heading <= 236.25) return "SW"; | else if (heading > 213.75 && heading <= 236.25) return "SW"; |
| else if (heading > 236.25 && heading <= 258.75) return "WSW"; | else if (heading > 236.25 && heading <= 258.75) return "WSW"; |
| else if (heading > 258.75 && heading <= 281.25) return "W"; | else if (heading > 258.75 && heading <= 281.25) return "W"; |
| else if (heading > 281.25 && heading <= 303.75) return "WNW"; | else if (heading > 281.25 && heading <= 303.75) return "WNW"; |
| else if (heading > 303.75 && heading <= 326.25) return "NW"; | else if (heading > 303.75 && heading <= 326.25) return "NW"; |
| else if (heading > 326.25 && heading <= 348.75) return "NNW"; | else if (heading > 326.25 && heading <= 348.75) return "NNW"; |
| else return ""; | else return ""; |
| } | } |
| public static void display_transfer_angles_SUN2PLANET(CelestialBody body, Vessel vessel) | |
| { | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Phase angle (curr/trans):"); | |
| GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Transfer velocity:"); | |
| GUILayout.Label((Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)) * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| public static void display_transfer_angles_PLANET2PLANET(CelestialBody body, Vessel vessel) | |
| { | |
| double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)); | |
| double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1)); | |
| double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000)); | |
| double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360; | |
| double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle); | |
| double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle); | |
| double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Phase angle (curr/trans):"); | |
| GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Ejection angle (curr/trans):"); | |
| GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Transfer velocity:"); | |
| GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| public static void display_transfer_angles_PLANET2MOON(CelestialBody body, Vessel vessel) | |
| { | |
| double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)); | |
| double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Phase angle (curr/trans):"); | |
| GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Transfer velocity:"); | |
| GUILayout.Label((dv1 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| public static void display_transfer_angles_MOON2MOON(CelestialBody body, Vessel vessel) | |
| { | |
| double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)); | |
| double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1)); | |
| double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000)); | |
| double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360; | |
| double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle); | |
| //double adj_ejection_angle = adjustCurrEjectionAngle(trans_phase_angle, curr_ejection_angle); | |
| //new stuff | |
| // | |
| double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle); | |
| double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle); | |
| // | |
| // | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Phase angle (curr/trans):"); | |
| GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Ejection angle (curr/trans):"); | |
| GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Transfer velocity:"); | |
| GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| // This implementation is adapted from FARGUIUtils.ClampToScreen | |
| public static Rect ClampRectToScreen(Rect window, int xMargin, int yMargin) | |
| { | |
| window.x = Mathf.Clamp (window.x, xMargin - window.width, Screen.width - xMargin); | |
| window.y = Mathf.Clamp (window.y, yMargin - window.height, Screen.height - yMargin); | |
| return window; | |
| } | |
| public static Rect ClampRectToScreen(Rect window, int Margin) | |
| { | |
| return ClampRectToScreen(window, Margin, Margin); | |
| } | |
| public static Rect ClampRectToScreen(Rect window) | |
| { | |
| return ClampRectToScreen (window, 30); | |
| } | |
| public static Vector2 ClampV2ToScreen(Vector2 vec, uint xMargin, uint yMargin) | |
| { | |
| vec.x = Mathf.Clamp (vec.x, xMargin, Screen.width - xMargin); | |
| vec.y = Mathf.Clamp (vec.y, yMargin, Screen.height - yMargin); | |
| return vec; | |
| } | |
| public static Vector2 ClampV2ToScreen(Vector2 vec, uint Margin) | |
| { | |
| return ClampV2ToScreen(vec, Margin, Margin); | |
| } | |
| public static Vector2 ClampV2ToScreen(Vector2 vec) | |
| { | |
| return ClampV2ToScreen (vec, 15); | |
| } | |
| // UNDONE: This seems messy. Can we clean it up? | |
| public static Rect DockToWindow(Rect icon, Rect window) | |
| { | |
| // We can't set the x and y of the center point directly, so build a new vector. | |
| Vector2 center = new Vector2 (); | |
| // If we are near the top or bottom of the screen... | |
| if (window.yMax > Screen.height - icon.height || | |
| window.yMin < icon.height | |
| ) | |
| { | |
| // If we are in a corner... | |
| if (window.xMax > Screen.width - icon.width || | |
| window.xMin < icon.width | |
| ) | |
| { | |
| // If it is a top corner, put the icon below the window. | |
| if (window.yMax < Screen.height / 2) | |
| { | |
| center.y = window.yMax + icon.height / 2; | |
| } | |
| // If it is a bottom corner, put the icon above the window. | |
| else | |
| { | |
| center.y = window.yMin - icon.height / 2; | |
| } | |
| } | |
| // If we are not in a corner... | |
| else | |
| { | |
| // If we are along the top edge, align the icon's top edge with the top edge of the window | |
| if (window.yMax > Screen.height / 2) | |
| { | |
| center.y = window.yMax - icon.height / 2; | |
| } | |
| // If we are along the bottom edge, align the icon's bottom edge with the bottom edge of the window | |
| else | |
| { | |
| center.y = window.yMin + icon.height / 2; | |
| } | |
| } | |
| // At the top or bottom, if we are towards the right, put the icon to the right of the window | |
| if (window.center.x < Screen.width / 2) | |
| { | |
| center.x = window.xMin - icon.width / 2; | |
| } | |
| // At the top or bottom, if we are towards the left, put the icon to the left of the window | |
| else | |
| { | |
| center.x = window.xMax + icon.width / 2; | |
| } | |
| } | |
| // If we are not along the top or bottom of the screen... | |
| else | |
| { | |
| // By default, center the icon above the window | |
| center.y = window.yMin - icon.height / 2; | |
| center.x = window.center.x; | |
| // If we are along a side... | |
| if (window.xMax > Screen.width - icon.width || | |
| window.xMin < icon.width | |
| ) | |
| { | |
| // UNDONE: I'm not sure I like the feel of this part. | |
| // If we are along a side towards the bottom, put the icon below the window | |
| if (window.center.y > Screen.height / 2) | |
| { | |
| center.y = window.yMax + icon.height / 2; | |
| } | |
| // Along the left side, align the left edge of the icon with the left edge of the window. | |
| if (window.xMax > Screen.width - icon.width) | |
| { | |
| center.x = window.xMax - icon.width / 2; | |
| } | |
| // Along the right side, align the right edge of the icon with the right edge of the window. | |
| else if (window.xMin < icon.width) | |
| { | |
| center.x = window.xMin + icon.width / 2; | |
| } | |
| } | |
| } | |
| // Assign the vector to the center of the rect. | |
| icon.center = center; | |
| // Return the icon's position. | |
| return icon; | |
| } | |
| private static ScreenMessage debugmsg = new ScreenMessage("", 2f, ScreenMessageStyle.UPPER_RIGHT); | private static ScreenMessage debugmsg = new ScreenMessage("", 2f, ScreenMessageStyle.UPPER_RIGHT); |
| [System.Diagnostics.Conditional("DEBUG")] | [System.Diagnostics.Conditional("DEBUG")] |
| public static void PostDebugMessage(string Msg) | public static void PostDebugMessage(string Msg) |
| { | { |
| if (HighLogic.LoadedScene > GameScenes.SPACECENTER) | if (HighLogic.LoadedScene > GameScenes.SPACECENTER) |
| { | { |
| debugmsg.message = Msg; | debugmsg.message = Msg; |
| ScreenMessages.PostScreenMessage(debugmsg, true); | ScreenMessages.PostScreenMessage(debugmsg, true); |
| } | } |
| KSPLog.print(Msg); | KSPLog.print(Msg); |
| } | } |
| } | } |
| } | } |
| <?xml version="1.0" encoding="utf-8"?> | <?xml version="1.0" encoding="utf-8"?> |
| <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> | <Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003"> |
| <PropertyGroup> | <PropertyGroup> |
| <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> | <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration> |
| <Platform Condition=" '$(Platform)' == '' ">x86</Platform> | <Platform Condition=" '$(Platform)' == '' ">x86</Platform> |
| <ProductVersion>10.0.0</ProductVersion> | <ProductVersion>10.0.0</ProductVersion> |
| <SchemaVersion>2.0</SchemaVersion> | <SchemaVersion>2.0</SchemaVersion> |
| <ProjectGuid>{45ACC1CC-942C-4A66-BFC7-8BE375938B18}</ProjectGuid> | <ProjectGuid>{45ACC1CC-942C-4A66-BFC7-8BE375938B18}</ProjectGuid> |
| <OutputType>Library</OutputType> | <OutputType>Library</OutputType> |
| <RootNamespace>VOID</RootNamespace> | <RootNamespace>VOID</RootNamespace> |
| <AssemblyName>VOID</AssemblyName> | <AssemblyName>VOID</AssemblyName> |
| <TargetFrameworkVersion>v3.5</TargetFrameworkVersion> | <TargetFrameworkVersion>v3.5</TargetFrameworkVersion> |
| </PropertyGroup> | </PropertyGroup> |
| <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' "> | <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|x86' "> |
| <DebugSymbols>true</DebugSymbols> | <DebugSymbols>true</DebugSymbols> |
| <DebugType>full</DebugType> | <DebugType>full</DebugType> |
| <Optimize>false</Optimize> | <Optimize>false</Optimize> |
| <OutputPath>bin\Debug</OutputPath> | <OutputPath>bin\Debug</OutputPath> |
| <DefineConstants>DEBUG; TRACE</DefineConstants> | <DefineConstants>DEBUG; TRACE</DefineConstants> |
| <ErrorReport>prompt</ErrorReport> | <ErrorReport>prompt</ErrorReport> |
| <WarningLevel>4</WarningLevel> | <WarningLevel>4</WarningLevel> |
| <ConsolePause>false</ConsolePause> | <ConsolePause>false</ConsolePause> |
| <CustomCommands> | <CustomCommands> |
| <CustomCommands> | <CustomCommands> |
| <Command type="AfterBuild" command="/usr/bin/cp -fv ${ProjectDir}/bin/Debug/VOID.dll /mnt/games/ssd/KSP_linux/GameData/VOID/Plugins/" /> | <Command type="AfterBuild" command="xcopy /Y ${ProjectDir}\bin\Debug\*.dll ..\..\..\Games\KSP_win\GameData\VOID\Plugins\" workingdir="${ProjectDir}" externalConsole="True" /> |
| </CustomCommands> | </CustomCommands> |
| </CustomCommands> | </CustomCommands> |
| </PropertyGroup> | </PropertyGroup> |
| <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' "> | <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|x86' "> |
| <Optimize>true</Optimize> | <Optimize>true</Optimize> |
| <OutputPath>bin\Release</OutputPath> | <OutputPath>bin\Release</OutputPath> |
| <ErrorReport>prompt</ErrorReport> | <ErrorReport>prompt</ErrorReport> |
| <WarningLevel>4</WarningLevel> | <WarningLevel>4</WarningLevel> |
| <ConsolePause>false</ConsolePause> | <ConsolePause>false</ConsolePause> |
| <DefineConstants>TRACE</DefineConstants> | <DefineConstants>TRACE</DefineConstants> |
| <CustomCommands> | |
| <CustomCommands> | |
| <Command type="AfterBuild" command="xcopy /Y ${ProjectDir}\bin\Release\*.dll ..\..\..\Games\KSP_win\GameData\VOID\Plugins\" workingdir="${ProjectDir}" externalConsole="True" /> | |
| </CustomCommands> | |
| </CustomCommands> | |
| </PropertyGroup> | </PropertyGroup> |
| <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> | <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.targets" /> |
| <ItemGroup> | <ItemGroup> |
| <Compile Include="Tools.cs" /> | <Compile Include="Tools.cs" /> |
| <Compile Include="IVOID_Module.cs" /> | <Compile Include="IVOID_Module.cs" /> |
| <Compile Include="VOIDFlightMaster.cs" /> | <Compile Include="VOIDFlightMaster.cs" /> |
| <Compile Include="VOID_Core.cs" /> | <Compile Include="VOID_Core.cs" /> |
| <Compile Include="VOID_Module.cs" /> | <Compile Include="VOID_Module.cs" /> |
| <Compile Include="VOID_HUD.cs" /> | <Compile Include="VOID_HUD.cs" /> |
| <Compile Include="VOID_SaveValue.cs" /> | <Compile Include="VOID_SaveValue.cs" /> |
| <Compile Include="VOID_Orbital.cs" /> | <Compile Include="VOID_Orbital.cs" /> |
| <Compile Include="VOID_SurfAtmo.cs" /> | <Compile Include="VOID_SurfAtmo.cs" /> |
| <Compile Include="VOID_VesselInfo.cs" /> | <Compile Include="VOID_VesselInfo.cs" /> |
| <Compile Include="VOID_Transfer.cs" /> | <Compile Include="VOID_Transfer.cs" /> |
| <Compile Include="VOID_CBInfoBrowser.cs" /> | <Compile Include="VOID_CBInfoBrowser.cs" /> |
| <Compile Include="VOID_Rendezvous.cs" /> | |
| <Compile Include="VOID_VesselRegister.cs" /> | |
| <Compile Include="VOID_DataLogger.cs" /> | |
| <Compile Include="VOID_EditorCore.cs" /> | |
| <Compile Include="VOID_EditorHUD.cs" /> | |
| </ItemGroup> | </ItemGroup> |
| <ItemGroup> | <ItemGroup> |
| <Reference Include="Assembly-CSharp"> | <Reference Include="Assembly-CSharp"> |
| <HintPath>..\..\..\..\..\mnt\games-ssd\KSP_linux\KSP_Data\Managed\Assembly-CSharp.dll</HintPath> | <HintPath>..\..\..\Games\KSP_win\KSP_Data\Managed\Assembly-CSharp.dll</HintPath> |
| <Private>False</Private> | |
| </Reference> | </Reference> |
| <Reference Include="UnityEngine"> | <Reference Include="UnityEngine"> |
| <HintPath>..\..\..\..\..\mnt\games-ssd\KSP_linux\KSP_Data\Managed\UnityEngine.dll</HintPath> | <HintPath>..\..\..\Games\KSP_win\KSP_Data\Managed\UnityEngine.dll</HintPath> |
| <Private>False</Private> | |
| </Reference> | </Reference> |
| <Reference Include="System"> | <Reference Include="System"> |
| <HintPath>..\..\..\..\..\mnt\games-ssd\KSP_linux\KSP_Data\Managed\System.dll</HintPath> | <HintPath>..\..\..\Games\KSP_win\KSP_Data\Managed\System.dll</HintPath> |
| <Private>False</Private> | |
| </Reference> | </Reference> |
| </ItemGroup> | </ItemGroup> |
| <ItemGroup> | <ItemGroup> |
| <ProjectReference Include="..\Engineer.Extensions\Engineer.Extensions.csproj"> | <ProjectReference Include="..\Engineer.Extensions\Engineer.Extensions.csproj"> |
| <Project>{2FCF882B-0771-4649-8D04-81D7AA76A486}</Project> | <Project>{2FCF882B-0771-4649-8D04-81D7AA76A486}</Project> |
| <Name>Engineer.Extensions</Name> | <Name>Engineer.Extensions</Name> |
| </ProjectReference> | </ProjectReference> |
| <ProjectReference Include="..\VesselSimulator\VesselSimulator.csproj"> | <ProjectReference Include="..\VesselSimulator\VesselSimulator.csproj"> |
| <Project>{30FD6C0B-D36E-462F-B0FF-F0FAC9C666CF}</Project> | <Project>{30FD6C0B-D36E-462F-B0FF-F0FAC9C666CF}</Project> |
| <Name>VesselSimulator</Name> | <Name>VesselSimulator</Name> |
| </ProjectReference> | </ProjectReference> |
| </ItemGroup> | </ItemGroup> |
| <ProjectExtensions> | <ProjectExtensions> |
| <MonoDevelop> | <MonoDevelop> |
| <Properties> | <Properties> |
| <Policies> | <Policies> |
| <StandardHeader Text=" 
 ${FileName}
 
 Author:
 ${AuthorName} <${AuthorEmail}>

 Copyright (c) ${Year} ${CopyrightHolder}

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program. If not, see <http://www.gnu.org/licenses/>." IncludeInNewFiles="True" /> | <StandardHeader Text=" 
 ${FileName}
 
 Author:
 ${AuthorName} <${AuthorEmail}>

 Copyright (c) ${Year} ${CopyrightHolder}

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program. If not, see <http://www.gnu.org/licenses/>." IncludeInNewFiles="True" /> |
| </Policies> | </Policies> |
| </Properties> | </Properties> |
| </MonoDevelop> | </MonoDevelop> |
| </ProjectExtensions> | </ProjectExtensions> |
| </Project> | </Project> |
| /////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////// |
| // | // |
| // VOID - Vessel Orbital Information Display for Kerbal Space Program | // VOID - Vessel Orbital Information Display for Kerbal Space Program |
| // Copyright (C) 2012 Iannic-ann-od | // Copyright (C) 2012 Iannic-ann-od |
| // Copyright (C) 2013 Toadicus | // Copyright (C) 2013 Toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| // | // |
| /////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////// |
| // | // |
| // Much, much credit to Younata, Adammada, Nivvydaskrl and to all the authors | // Much, much credit to Younata, Adammada, Nivvydaskrl and to all the authors |
| // behind MechJeb, RemoteTech Relay Network, ISA MapSat, and Protractor for some | // behind MechJeb, RemoteTech Relay Network, ISA MapSat, and Protractor for some |
| // invaluable functions and making your nicely written code available to learn from. | // invaluable functions and making your nicely written code available to learn from. |
| // | // |
| /////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////// |
| // | // |
| // This software uses VesselSimulator and Engineer.Extensions from Engineer Redux. | // This software uses VesselSimulator and Engineer.Extensions from Engineer Redux. |
| // Engineer Redux (c) 2013 cybutek | // Engineer Redux (c) 2013 cybutek |
| // Used by permission. | // Used by permission. |
| // | // |
| /////////////////////////////////////////////////////////////////////////////// | /////////////////////////////////////////////////////////////////////////////// |
| using System; | using System; |
| using System.Collections.Generic; | using System.Collections.Generic; |
| using System.Linq; | using System.Linq; |
| using UnityEngine; | using UnityEngine; |
| using Engineer.VesselSimulator; | using Engineer.VesselSimulator; |
| namespace VOID | namespace VOID |
| { | { |
| [KSPAddon(KSPAddon.Startup.Flight, false)] | [KSPAddon(KSPAddon.Startup.Flight, false)] |
| public class VOIDFlightMaster : MonoBehaviour | public class VOIDFlightMaster : MonoBehaviour |
| { | { |
| protected VOID_Core Core; | protected VOID_Core Core; |
| public void Awake() | public void Awake() |
| { | { |
| Tools.PostDebugMessage ("VOIDLightMaster: Waking up."); | Tools.PostDebugMessage ("VOIDFlightMaster: Waking up."); |
| this.Core = (VOID_Core)VOID_Core.Instance; | this.Core = (VOID_Core)VOID_Core.Instance; |
| this.Core.StopGUI (); | |
| this.Core.StartGUI (); | this.Core.StartGUI (); |
| Tools.PostDebugMessage ("VOIDFlightMaster: Awake."); | Tools.PostDebugMessage ("VOIDFlightMaster: Awake."); |
| } | } |
| public void Update() | public void Update() |
| { | { |
| if (!HighLogic.LoadedSceneIsFlight && this.Core != null) | |
| { | |
| this.Core.SaveConfig (); | |
| this.Core = null; | |
| VOID_Core.Reset(); | |
| return; | |
| } | |
| if (this.Core == null) | if (this.Core == null) |
| { | { |
| return; | this.Awake(); |
| } | } |
| this.Core.Update (); | this.Core.Update (); |
| if (this.Core.vessel != null) | if (this.Core.vessel != null) |
| { | { |
| SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter / Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2); | SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter / Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2); |
| SimManager.Instance.TryStartSimulation(); | SimManager.Instance.TryStartSimulation(); |
| } | } |
| if (this.Core.factoryReset) | |
| { | |
| KSP.IO.File.Delete<VOID_Core>("config.xml"); | |
| this.Core = null; | |
| VOID_Core.Reset(); | |
| } | |
| } | } |
| public void FixedUpdate() | public void FixedUpdate() |
| { | { |
| if (this.Core == null) | if (this.Core == null || !HighLogic.LoadedSceneIsFlight) |
| { | { |
| return; | return; |
| } | } |
| this.Core.FixedUpdate (); | this.Core.FixedUpdate (); |
| } | } |
| // private bool debugging = false; | public void OnGUI() |
| // | { |
| // private int window_base_id = -96518722; | if (this.Core == null) |
| // | { |
| // private double G_constant = .0000000000667; | return; |
| // | } |
| // public Vessel vessel; | |
| // private VOIDLabels label_strings = new VOIDLabels(); | |
| // | |
| // private List<CelestialBody> all_bodies = new List<CelestialBody>(); | |
| // private List<VesselType> all_vessel_types = new List<VesselType>(); | |
| // | |
| // //Windows | |
| // protected Rect main_window_pos = new Rect(Screen.width / 2, Screen.height / 2, 10f, 10f); //VOID main | |
| // protected Rect void_window_pos = new Rect((Screen.width / 2) - 20, (Screen.height / 2) - 10, 10, 10); //vessel orbital info | |
| // protected Rect atmo_window_pos = new Rect((Screen.width / 2) - 40, (Screen.height / 2) - 20, 10, 10); //atmospheric info | |
| // protected Rect transfer_window_pos = new Rect((Screen.width / 2) - 60, (Screen.height / 2) - 30, 10, 10); //transfer angle info | |
| // protected Rect vessel_register_window_pos = new Rect((Screen.width / 2) - 80, (Screen.height / 2) - 40, 10, 10); //neighboring vessels | |
| // protected Rect data_logging_window_pos = new Rect((Screen.width / 2) - 100, (Screen.height / 2) - 50, 10, 10); //data logging & time | |
| // protected Rect vessel_info_window_pos = new Rect((Screen.width / 2) - 120, (Screen.height / 2) - 60, 10, 10); //vessel info | |
| // protected Rect misc_window_pos = new Rect((Screen.width / 2) - 160, (Screen.height / 2) - 80, 10, 10); //miscellaneous | |
| // protected Rect body_op_window_pos = new Rect((Screen.width / 2) - 140, (Screen.height / 2) - 70, 10, 10); //body orbital/physical info | |
| // protected Rect rendezvous_info_window_pos = new Rect((Screen.width / 2) - 180, (Screen.height / 2) - 90, 10, 10); //target vessel info | |
| // protected Rect lab_window_pos = new Rect(0, 0, 10, 10); //The Lab | |
| // | |
| // //Icons | |
| // | |
| // | |
| // //GUI | |
| // private bool gui_running = false; | |
| // private int skin_index = 2; | |
| // private bool main_gui_minimized = false; | |
| // private bool gui_styles_set = false; | |
| // | |
| // //GUIStyles | |
| // //private GUIStyle label_txt_left; | |
| // private GUIStyle label_txt_center; | |
| // private GUIStyle label_txt_center_bold; | |
| // private GUIStyle label_txt_right; //needed for body OP alignment | |
| // //private GUIStyle button_txt_left; | |
| // //private GUIStyle button_txt_center; | |
| // //private GUIStyle button_txt_right; | |
| // | |
| // //private GUIStyle gs_tooltip; | |
| // | |
| // //Window toggles | |
| // private bool void_module = false; | |
| // private bool extended_orbital_info = false; | |
| // private bool tad_module = false; | |
| // private bool atmo_module = false; | |
| // private bool data_time_module = false; | |
| // private bool vessel_info_module = false; | |
| // private bool test_module = false; | |
| // private bool misc_module = false; | |
| // private bool vessel_register_module = false; | |
| // public bool toggleHUDModule = false; | |
| // private bool celestial_body_info_module = false; | |
| // private bool rendezvous_module = false; | |
| // | |
| // //Celestial body info window | |
| // private bool body_op_show_orbital = true; | |
| // private bool body_op_show_physical = true; | |
| // private int body_OP_body_1_index = 1; | |
| // private int body_OP_body_2_index = 2; | |
| // private CelestialBody body_OP_selected_body_1 = new CelestialBody(); | |
| // private CelestialBody body_OP_selected_body_2 = new CelestialBody(); | |
| // | |
| // //Data logging/time & cfg update | |
| // private bool csv_logging = false; | |
| // private List<string> csvList = new List<string>(); | |
| // private float csvWriteTimer = 0; | |
| // private float csvCollectTimer = 0; | |
| // private bool first_write = true; | |
| // private float csv_log_interval; | |
| // private string csv_log_interval_str = "0.5"; | |
| // private float cfg_update_timer = 0; | |
| // private double stopwatch1; | |
| // private bool stopwatch1_running = false; | |
| // | |
| // //Vessel Register | |
| // private Vector2 vessel_register_scroll_pos = new Vector2(); | |
| // private Vessel vesreg_selected_vessel; | |
| // private bool target_vessel_extended_orbital_info = false; | |
| // private VesselType vessel_register_vessel_type = VesselType.Ship; | |
| // private string vessel_register_vessel_situation = "Orbiting"; | |
| // private CelestialBody vessel_register_selected_body = null; | |
| // private int vessel_register_body_index = 0; | |
| // private int vessel_register_vessel_type_index = 0; | |
| // private bool hide_vesreg_info = false; //in rendezvous window | |
| // | |
| // //Miscellaneous window & http | |
| // private string version_name = "VOID "; | |
| // private string this_version = "0.9.9"; | |
| // private int configVersion = 1; | |
| // private bool hide_on_pause = false; | |
| // private bool changing_icon_pos = false; | |
| // private bool show_tooltips = true; | |
| // public bool disable_power_usage = true; | |
| // | |
| // // Power consumption | |
| // private float power_request_amount = 0.01f; | |
| // public bool power_toggle = true; | |
| // public bool power_available = false; | |
| // | |
| // // VesselSimulator | |
| // Stage[] stages = new Stage[0]; | |
| // | |
| // // Modules | |
| // VOID_HUD moduleHUD; | |
| // | |
| // //Debugging / limbo | |
| // private List<CelestialBody> tad_selected_bodies = new List<CelestialBody>(); //Bodies selected in Transfer Angle Info | |
| // private bool run_once = true; //for Update() | |
| // private string settings_path; | |
| // | |
| // private enum languages { EN }; | |
| // private languages user_lang = languages.EN; | |
| // private int user_lang_index; | |
| // | |
| // public VOIDFlightMaster() : base() | |
| // { | |
| // Tools.PostDebugMessage ("Constructing VOID."); | |
| // } | |
| // | |
| // ~VOIDFlightMaster() | |
| // { | |
| // Tools.PostDebugMessage ("Destructing VOID."); | |
| // } | |
| // | |
| // private void Innsewerants_writeData(string[] csvArray) | |
| // { | |
| // var efile = KSP.IO.File.AppendText<VOIDFlightMaster>(vessel.vesselName + "_data.csv", null); | |
| // foreach (string line in csvArray) | |
| // { | |
| // efile.Write(line); | |
| // } | |
| // efile.Close(); | |
| // } | |
| // | |
| // private void line_to_csvList() | |
| // { | |
| // //called if logging is on and interval has passed | |
| // //writes one line to the csvList | |
| // | |
| // string line = ""; | |
| // if (first_write && !KSP.IO.File.Exists<VOIDFlightMaster>(vessel.vesselName + "_data.csv", null)) | |
| // { | |
| // first_write = false; | |
| // line += "Mission Elapsed Time (s);Altitude ASL (m);Altitude above terrain (m);Orbital Velocity (m/s);Surface Velocity (m/s);Vertical Speed (m/s);Horizontal Speed (m/s);Gee Force (gees);Temperature (°C);Gravity (m/s²);Atmosphere Density (g/m³);\n"; | |
| // } | |
| // //Mission time | |
| // line += vessel.missionTime.ToString("F3") + ";"; | |
| // //Altitude ASL | |
| // line += vessel.orbit.altitude.ToString("F3") + ";"; | |
| // //Altitude (true) | |
| // double alt_true = vessel.orbit.altitude - vessel.terrainAltitude; | |
| // if (vessel.terrainAltitude < 0) alt_true = vessel.orbit.altitude; | |
| // line += alt_true.ToString("F3") + ";"; | |
| // //Orbital velocity | |
| // line += vessel.orbit.vel.magnitude.ToString("F3") + ";"; | |
| // //surface velocity | |
| // line += vessel.srf_velocity.magnitude.ToString("F3") + ";"; | |
| // //vertical speed | |
| // line += vessel.verticalSpeed.ToString("F3") + ";"; | |
| // //horizontal speed | |
| // line += vessel.horizontalSrfSpeed.ToString("F3") + ";"; | |
| // //gee force | |
| // line += vessel.geeForce.ToString("F3") + ";"; | |
| // //temperature | |
| // line += vessel.flightIntegrator.getExternalTemperature().ToString("F2") + ";"; | |
| // //gravity | |
| // double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass()); | |
| // double g_vessel = (G_constant * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2); | |
| // line += g_vessel.ToString("F3") + ";"; | |
| // //atm density | |
| // line += (vessel.atmDensity * 1000).ToString("F3") + ";"; | |
| // line += "\n"; | |
| // if (csvList.Contains(line) == false) csvList.Add(line); | |
| // csvCollectTimer = 0f; | |
| // } | |
| // | |
| // private void main_csv() | |
| // { | |
| // // CSV Logging | |
| // // from ISA MapSat | |
| // if (csv_logging) | |
| // { | |
| // //data logging is on | |
| // //increment timers | |
| // csvWriteTimer += Time.deltaTime; | |
| // csvCollectTimer += Time.deltaTime; | |
| // } | |
| // else | |
| // { | |
| // //data logging is off | |
| // //reset any timers and clear anything from csvList | |
| // csvWriteTimer = 0f; | |
| // csvCollectTimer = 0f; | |
| // if (csvList.Count > 0) csvList.Clear(); | |
| // } | |
| // | |
| // if (csv_logging && csvCollectTimer >= csv_log_interval && vessel.situation != Vessel.Situations.PRELAUNCH) | |
| // { | |
| // //data logging is on, vessel is not prelaunch, and interval has passed | |
| // //write a line to the list | |
| // line_to_csvList(); //write to the csv | |
| // } | |
| // | |
| // if (csvList.Count != 0 && csvWriteTimer >= 15f && csv_logging) | |
| // { | |
| // // csvList is not empty and interval between writings to file has elapsed | |
| // //write it | |
| // string[] csvData; | |
| // csvData = (string[])csvList.ToArray(); | |
| // Innsewerants_writeData(csvData); | |
| // csvList.Clear(); | |
| // csvWriteTimer = 0f; | |
| // } | |
| // } | |
| // | |
| // private void load_language() | |
| // { | |
| // ConfigNode lang_node = ConfigNode.Load(settings_path + "lang.dat"); | |
| // | |
| // if (lang_node != null) | |
| // { | |
| // if (lang_node.HasNode(user_lang.ToString())) | |
| // { | |
| // ConfigNode _lang = lang_node.GetNode(user_lang.ToString()); | |
| // | |
| // if (_lang.HasValue("void_primary")) label_strings.void_primary = _lang.GetValue("void_primary"); | |
| // if (_lang.HasValue("void_altitude_asl")) label_strings.void_altitude_asl = _lang.GetValue("void_altitude_asl"); | |
| // if (_lang.HasValue("void_velocity")) label_strings.void_velocity = _lang.GetValue("void_velocity"); | |
| // if (_lang.HasValue("void_apoapsis")) label_strings.void_apoapsis = _lang.GetValue("void_apoapsis"); | |
| // if (_lang.HasValue("void_periapsis")) label_strings.void_periapsis = _lang.GetValue("void_periapsis"); | |
| // } | |
| // } | |
| // else | |
| // { | |
| // //lang_node == null | |
| // // Toadicus edit: added settings_path to the debug message for extra verbosity | |
| // Debug.LogError("[VOID] Unable to load file " + settings_path + "lang.dat!"); | |
| // } | |
| // } | |
| // | |
| // private void load_icons() | |
| // { | |
| // // Toadicus edit: changed the directory to VOID instead of RBR, because RBR seemed confusing. | |
| // string path_icon_on = "VOID/Textures/void_icon_on"; | |
| // string path_icon_off = "VOID/Textures/void_icon_off"; | |
| // | |
| // if (GameDatabase.Instance.ExistsTexture(path_icon_on) && GameDatabase.Instance.ExistsTexture(path_icon_off)) | |
| // { | |
| // if (debugging) Debug.Log("icon textures exist, loading..."); | |
| // void_icon_on = GameDatabase.Instance.GetTexture(path_icon_on, false); | |
| // void_icon_off = GameDatabase.Instance.GetTexture(path_icon_off, false); | |
| // if (main_gui_minimized) void_icon = void_icon_off; | |
| // else void_icon = void_icon_on; | |
| // } | |
| // else | |
| // { | |
| // if (debugging) Debug.LogError("[VOID] icon texture file(s) missing"); | |
| // //void_icons_loaded = false; | |
| // } | |
| // } | |
| // | |
| // private void start_GUI() | |
| // { | |
| // RenderingManager.AddToPostDrawQueue(3, new Callback(draw_GUI)); //start the GUI | |
| // if (this.moduleHUD != null && !this.moduleHUD.guiRunning) | |
| // { | |
| // this.moduleHUD.StopGUI(); | |
| // } | |
| // gui_running = true; | |
| // } | |
| // | |
| // private void stop_GUI() | |
| // { | |
| // RenderingManager.RemoveFromPostDrawQueue(3, new Callback(draw_GUI)); //stop the GUI | |
| // if (this.moduleHUD != null && this.moduleHUD.guiRunning) | |
| // { | |
| // this.moduleHUD.StopGUI(); | |
| // } | |
| // gui_running = false; | |
| // } | |
| // | |
| // private void consume_resources() | |
| // { | |
| // if (TimeWarp.deltaTime == 0) return; //do nothing if paused | |
| // if (vessel.vesselType == VesselType.EVA || disable_power_usage) power_available = true; //power always available when EVA | |
| // else | |
| // { | |
| // float recvd_amount = vessel.rootPart.RequestResource("ElectricCharge", power_request_amount * TimeWarp.fixedDeltaTime); | |
| // if (recvd_amount > 0) power_available = true; // doesn't always send 100% of demand so as long as it sends something | |
| // else power_available = false; | |
| // } | |
| // } | |
| // | |
| // private void set_gui_styles() | |
| // { | |
| // //label_txt_left = new GUIStyle(GUI.skin.label); | |
| // //label_txt_left.normal.textColor = Color.white; | |
| // //label_txt_left.alignment = TextAnchor.UpperLeft; | |
| // | |
| // label_txt_center = new GUIStyle(GUI.skin.label); | |
| // label_txt_center.normal.textColor = Color.white; | |
| // label_txt_center.alignment = TextAnchor.UpperCenter; | |
| // | |
| // label_txt_center_bold = new GUIStyle(GUI.skin.label); | |
| // label_txt_center_bold.normal.textColor = Color.white; | |
| // label_txt_center_bold.alignment = TextAnchor.UpperCenter; | |
| // label_txt_center_bold.fontStyle = FontStyle.Bold; | |
| // | |
| // label_txt_right = new GUIStyle(GUI.skin.label); | |
| // label_txt_right.normal.textColor = Color.white; | |
| // label_txt_right.alignment = TextAnchor.UpperRight; | |
| // | |
| // gui_styles_set = true; | |
| // } | |
| // | |
| // | this.Core.OnGUI(); |
| // private void tad_targeting(CelestialBody body) | } |
| // { | |
| // //Target Set/Unset buttons | |
| // if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() == null)) | |
| // { | |
| // //No TGT set or TGT is a Body | |
| // if ((CelestialBody)FlightGlobals.fetch.VesselTarget != body) | |
| // { | |
| // if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false))) | |
| // { | |
| // FlightGlobals.fetch.SetVesselTarget(body); | |
| // if (debugging) Debug.Log("[VOID] KSP Target set to CelestialBody " + body.bodyName); | |
| // } | |
| // } | |
| // else if ((CelestialBody)FlightGlobals.fetch.VesselTarget == body) | |
| // { | |
| // if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false))) | |
| // { | |
| // FlightGlobals.fetch.SetVesselTarget(null); | |
| // if (debugging) Debug.Log("[VOID] KSP Target set to null"); | |
| // } | |
| // } | |
| // } | |
| // else if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != null)) | |
| // { | |
| // //No TGT or TGT is a vessel | |
| // if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false))) | |
| // { | |
| // FlightGlobals.fetch.SetVesselTarget(body); | |
| // if (debugging) Debug.Log("[VOID] KSP Target set to CelestialBody " + body.bodyName); | |
| // } | |
| // } | |
| // } | |
| // | |
| // private void display_transfer_angles_SUN2PLANET(CelestialBody body) | |
| // { | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Phase angle (curr/trans):"); | |
| // GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Transfer velocity:"); | |
| // GUILayout.Label((Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)) * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // | |
| // private void display_transfer_angles_PLANET2PLANET(CelestialBody body) | |
| // { | |
| // double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)); | |
| // double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1)); | |
| // | |
| // double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000)); | |
| // double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| // | |
| // double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360; | |
| // double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| // | |
| // double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle); | |
| // double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle); | |
| // double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Phase angle (curr/trans):"); | |
| // GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Ejection angle (curr/trans):"); | |
| // GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Transfer velocity:"); | |
| // GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // | |
| // private void display_transfer_angles_PLANET2MOON(CelestialBody body) | |
| // { | |
| // double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)); | |
| //// double curr_phase_angle = Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, vessel.orbit.LAN, vessel.orbit.orbitPercent); | |
| // double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Phase angle (curr/trans):"); | |
| // GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Transfer velocity:"); | |
| // GUILayout.Label((dv1 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // | |
| // private void display_transfer_angles_MOON2MOON(CelestialBody body) | |
| // { | |
| // double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)); | |
| // double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1)); | |
| // double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000)); | |
| // | |
| // double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| // double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| // | |
| // double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360; | |
| // | |
| // double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle); | |
| // //double adj_ejection_angle = adjustCurrEjectionAngle(trans_phase_angle, curr_ejection_angle); | |
| // | |
| // //new stuff | |
| // // | |
| // double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle); | |
| // double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle); | |
| // // | |
| // // | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Phase angle (curr/trans):"); | |
| // GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Ejection angle (curr/trans):"); | |
| // GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Transfer velocity:"); | |
| // GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // | |
| // // GUI | |
| // // Toadicus edit: added colons for each label_string. | |
| // private void void_gui(int window_id) | |
| // { | |
| // // Toadicus edit: added local sidereal longitude. | |
| // double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle; | |
| // LSL = Tools.FixDegreeDomain (LSL); | |
| // | |
| // GUILayout.BeginVertical(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label(label_strings.void_primary + ":"); | |
| // GUILayout.Label(vessel.mainBody.bodyName, GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label(label_strings.void_altitude_asl + ":"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.altitude) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label(label_strings.void_velocity + ":"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label(label_strings.void_apoapsis + ":"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.ApA) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Time to Ap:"); | |
| // GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToAp), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label(label_strings.void_periapsis + ":"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.PeA) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Time to Pe:"); | |
| // GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToPe), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Inclination:"); | |
| // GUILayout.Label(vessel.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass()); | |
| // double g_vessel = (G_constant * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2); | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Gravity:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(g_vessel) + "m/s²", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // extended_orbital_info = GUILayout.Toggle(extended_orbital_info, "Extended info"); | |
| // | |
| // if (extended_orbital_info) | |
| // { | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Period:"); | |
| // GUILayout.Label(Tools.ConvertInterval(vessel.orbit.period), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Semi-major axis:"); | |
| // GUILayout.Label((vessel.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Eccentricity:"); | |
| // GUILayout.Label(vessel.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // // Toadicus edit: convert mean anomaly into degrees. | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Mean anomaly:"); | |
| // GUILayout.Label((vessel.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("True anomaly:"); | |
| // GUILayout.Label(vessel.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // // Toadicus edit: convert eccentric anomaly into degrees. | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Eccentric anomaly:"); | |
| // GUILayout.Label((vessel.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Long. ascending node:"); | |
| // GUILayout.Label(vessel.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Arg. of periapsis:"); | |
| // GUILayout.Label(vessel.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // // Toadicus edit: added local sidereal longitude. | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Local Sidereal Longitude:"); | |
| // GUILayout.Label(LSL.ToString("F3") + "°", label_txt_right); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // | |
| // GUILayout.EndVertical(); | |
| // GUI.DragWindow(); | |
| // } | |
| // | |
| // private void atmo_gui(int window_id) | |
| // { | |
| // GUILayout.BeginVertical(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Altitude (true):"); | |
| // double alt_true = vessel.orbit.altitude - vessel.terrainAltitude; | |
| // // HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m. | |
| // if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean ) alt_true = vessel.orbit.altitude; | |
| // GUILayout.Label(Tools.MuMech_ToSI(alt_true) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal (); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Latitude:"); | |
| // GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Longitude:"); | |
| // GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Heading:"); | |
| // GUILayout.Label(Tools.MuMech_get_heading(vessel).ToString("F2") + "° " + Tools.get_heading_text(Tools.MuMech_get_heading(vessel)), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Terrain elevation:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(vessel.terrainAltitude) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Surface velocity:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(vessel.srf_velocity.magnitude) + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Vertical speed:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(vessel.verticalSpeed) + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Horizontal speed:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(vessel.horizontalSrfSpeed) + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Temperature:"); | |
| // GUILayout.Label(vessel.flightIntegrator.getExternalTemperature().ToString("F2") + "° C", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Atmosphere density:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(vessel.atmDensity * 1000) + "g/m³", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Pressure:"); | |
| // GUILayout.Label(vessel.staticPressure.ToString("F2") + " atms", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Atmosphere limit:"); | |
| // GUILayout.Label("≈ " + Tools.MuMech_ToSI(vessel.mainBody.maxAtmosphereAltitude) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // // Toadicus edit: added Biome | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Biome:"); | |
| // GUILayout.Label(Tools.Toadicus_GetAtt(vessel).name, label_txt_right); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.EndVertical(); | |
| // GUI.DragWindow(); | |
| // } | |
| // | |
| // private void celestial_body_info_gui(int window_id) | |
| // { | |
| // //print("starting celestial_body_info_gui()..."); | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // | |
| // GUILayout.BeginVertical(GUILayout.Width(150)); | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("", GUILayout.ExpandWidth(true)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.EndVertical(); | |
| // | |
| // GUILayout.BeginVertical(GUILayout.Width(150)); | |
| // | |
| // body_OP_selected_body_1 = all_bodies[body_OP_body_1_index]; | |
| // body_OP_selected_body_2 = all_bodies[body_OP_body_2_index]; | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button("<", GUILayout.ExpandWidth(false))) | |
| // { | |
| // body_OP_body_1_index--; | |
| // if (body_OP_body_1_index < 0) body_OP_body_1_index = all_bodies.Count - 1; | |
| // } | |
| // GUILayout.Label(all_bodies[body_OP_body_1_index].bodyName, label_txt_center_bold, GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button(">", GUILayout.ExpandWidth(false))) | |
| // { | |
| // body_OP_body_1_index++; | |
| // if (body_OP_body_1_index > all_bodies.Count - 1) body_OP_body_1_index = 0; | |
| // } | |
| // GUILayout.EndHorizontal(); | |
| // GUILayout.EndVertical(); | |
| // | |
| // GUILayout.BeginVertical(GUILayout.Width(150)); | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button("<", GUILayout.ExpandWidth(false))) | |
| // { | |
| // body_OP_body_2_index--; | |
| // if (body_OP_body_2_index < 0) body_OP_body_2_index = all_bodies.Count - 1; | |
| // } | |
| // GUILayout.Label(all_bodies[body_OP_body_2_index].bodyName, label_txt_center_bold, GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button(">", GUILayout.ExpandWidth(false))) | |
| // { | |
| // body_OP_body_2_index++; | |
| // if (body_OP_body_2_index > all_bodies.Count - 1) body_OP_body_2_index = 0; | |
| // } | |
| // GUILayout.EndHorizontal(); | |
| // GUILayout.EndVertical(); | |
| // | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // //} | |
| // | |
| // //toggle for orbital info chunk | |
| // if (GUILayout.Button("Orbital Characteristics", GUILayout.ExpandWidth(true))) body_op_show_orbital = !body_op_show_orbital; | |
| // | |
| // if (body_op_show_orbital) | |
| // { | |
| // //begin orbital into horizontal chunk | |
| // //print("begin orbital info section..."); | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // | |
| // //begin orbital value labels column | |
| // GUILayout.BeginVertical(GUILayout.Width(150)); | |
| // | |
| // //print("printing row labels..."); | |
| // | |
| // GUILayout.Label("Apoapsis:"); | |
| // GUILayout.Label("Time to Ap:"); | |
| // GUILayout.Label("Periapsis:"); | |
| // GUILayout.Label("Time to Pe:"); | |
| // GUILayout.Label("Semi-major axis:"); | |
| // GUILayout.Label("Eccentricity:"); | |
| // GUILayout.Label("Orbital period:"); | |
| // GUILayout.Label("Rotational period:"); | |
| // GUILayout.Label("Velocity:"); | |
| // GUILayout.Label("Mean anomaly:"); | |
| // GUILayout.Label("True anomaly:"); | |
| // GUILayout.Label("Eccentric anomaly:"); | |
| // GUILayout.Label("Inclination:"); | |
| // GUILayout.Label("Long. ascending node:"); | |
| // GUILayout.Label("Arg. of periapsis:"); | |
| // GUILayout.Label("Tidally locked:"); | |
| // | |
| // //end orbital value labels column | |
| // GUILayout.EndVertical(); | |
| // | |
| // //begin primary orbital values column | |
| // GUILayout.BeginVertical(GUILayout.Width(150)); | |
| // | |
| // body_OP_show_orbital_info(body_OP_selected_body_1); | |
| // | |
| // //end primary orbital values column | |
| // GUILayout.EndVertical(); | |
| // | |
| // //begin secondary orbital values column | |
| // GUILayout.BeginVertical(GUILayout.Width(150)); | |
| // | |
| // body_OP_show_orbital_info(body_OP_selected_body_2); | |
| // | |
| // //end secondary orbital values column | |
| // GUILayout.EndVertical(); | |
| // | |
| // //end orbital info horizontal chunk | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // | |
| // //toggle for physical info chunk | |
| // if (GUILayout.Button("Physical Characteristics", GUILayout.ExpandWidth(true))) body_op_show_physical = !body_op_show_physical; | |
| // | |
| // if (body_op_show_physical) | |
| // { | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // | |
| // //begin physical info value label column | |
| // GUILayout.BeginVertical(GUILayout.Width(150)); | |
| // | |
| // GUILayout.Label("Radius:"); | |
| // GUILayout.Label("Surface area:"); | |
| // GUILayout.Label("Volume:"); | |
| // GUILayout.Label("Mass:"); | |
| // GUILayout.Label("Density:"); | |
| // GUILayout.Label("Sphere of influence:"); | |
| // GUILayout.Label("Natural satellites:"); | |
| // GUILayout.Label("Artificial satellites:"); | |
| // GUILayout.Label("Surface gravity:"); | |
| // GUILayout.Label("Atmosphere altitude:"); | |
| // GUILayout.Label("Atmospheric O\u2082:"); | |
| // GUILayout.Label("Has ocean:"); | |
| // | |
| // //end physical info value label column | |
| // GUILayout.EndVertical(); | |
| // | |
| // //begin primary physical values column | |
| // GUILayout.BeginVertical(GUILayout.Width(150)); | |
| // | |
| // body_OP_show_physical_info(body_OP_selected_body_1); | |
| // | |
| // //end primary physical column | |
| // GUILayout.EndVertical(); | |
| // | |
| // //begin secondary physical values column | |
| // GUILayout.BeginVertical(GUILayout.Width(150)); | |
| // | |
| // body_OP_show_physical_info(body_OP_selected_body_2); | |
| // | |
| // //end target physical values column | |
| // GUILayout.EndVertical(); | |
| // | |
| // //end physical value horizontal chunk | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // | |
| // GUI.DragWindow(); | |
| // } | |
| // | |
| // private void rendezvous_info_gui(int window_id) | |
| // { | |
| // Vessel rendezvessel = new Vessel(); | |
| // CelestialBody rendezbody = new CelestialBody(); | |
| // | |
| // GUILayout.BeginVertical(); | |
| // | |
| // //display both | |
| // //Show Target Info | |
| // GUILayout.Label("Target:", label_txt_center_bold); | |
| // if (FlightGlobals.fetch.VesselTarget != null) | |
| // { | |
| // //a KSP Target (body or vessel) is selected | |
| // if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.Direction) | |
| // { | |
| // //a Body is selected | |
| // rendezbody = vessel.patchedConicSolver.targetBody; | |
| // display_rendezvous_info(null, rendezbody); | |
| // } | |
| // else if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.DirectionAndVelocity) | |
| // { | |
| // //a Vessel is selected | |
| // rendezvessel = FlightGlobals.fetch.VesselTarget.GetVessel(); | |
| // display_rendezvous_info(rendezvessel, null); | |
| // } | |
| // //Show Unset button for both options above | |
| // if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false))) | |
| // { | |
| // FlightGlobals.fetch.SetVesselTarget(null); | |
| // if (debugging) Debug.Log("[VOID] KSP Target set to null"); | |
| // } | |
| // | |
| // } | |
| // else | |
| // { | |
| // //no KSP Target selected | |
| // GUILayout.Label("No Target Selected", label_txt_center_bold); | |
| // } | |
| // | |
| // //Show Vessel Register vessel info | |
| // if (hide_vesreg_info == false) | |
| // { | |
| // GUILayout.Label("Vessel Register:", label_txt_center_bold); | |
| // if (vesreg_selected_vessel != null) | |
| // { | |
| // rendezvessel = vesreg_selected_vessel; | |
| // display_rendezvous_info(rendezvessel, null); | |
| // | |
| // //show set/unset buttons | |
| // if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != vesreg_selected_vessel)) | |
| // { | |
| // //no Tgt set or Tgt is not this vessel | |
| // //show a Set button | |
| // if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false))) | |
| // { | |
| // FlightGlobals.fetch.SetVesselTarget(rendezvessel); | |
| // if (debugging) Debug.Log("[VOID] KSP Target set to " + rendezvessel.vesselName); | |
| // } | |
| // } | |
| // else if (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() == vesreg_selected_vessel) | |
| // { | |
| // //this VRegister Tgt is also set as KSP tgt | |
| // //show Unset button | |
| // //if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false))) | |
| // //{ | |
| // // FlightGlobals.fetch.SetVesselTarget(null); | |
| // // if (debugging) Debug.Log("[VOID] KSP Target set to null"); | |
| // // } | |
| // } | |
| // } | |
| // else | |
| // { | |
| // //vesreg Vessel is null | |
| // //targ = null; | |
| // GUILayout.Label("No Vessel Selected", label_txt_center_bold); | |
| // } | |
| // } | |
| // | |
| // hide_vesreg_info = GUILayout.Toggle(hide_vesreg_info, "Hide Vessel Register Info"); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label(" ", GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button("Close", GUILayout.ExpandWidth(false))) rendezvous_module = false; | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.EndVertical(); | |
| // GUI.DragWindow(); | |
| // } | |
| // | |
| // private void display_rendezvous_info(Vessel v, CelestialBody cb) | |
| // { | |
| // if (cb == null && v != null) | |
| // { | |
| // //Display vessel rendezvous info | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label(v.vesselName, label_txt_center_bold, GUILayout.ExpandWidth(true)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // if (v.situation == Vessel.Situations.ESCAPING || v.situation == Vessel.Situations.FLYING || v.situation == Vessel.Situations.ORBITING || v.situation == Vessel.Situations.SUB_ORBITAL) | |
| // { | |
| // // Toadicus edit: added local sidereal longitude. | |
| // // Toadicus edit: added local sidereal longitude. | |
| // double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle; | |
| // LSL = Tools.FixDegreeDomain (LSL); | |
| // | |
| // //display orbital info for orbiting/flying/suborbital/escaping vessels only | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Ap/Pe:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(v.orbit.ApA) + "m / " + Tools.MuMech_ToSI(v.orbit.PeA) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Altitude:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(v.orbit.altitude) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Inclination:"); | |
| // GUILayout.Label(v.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // if (vessel.mainBody == v.mainBody) | |
| // { | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Relative inclination:"); | |
| // GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), v.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // //if (debugging) Debug.Log("[CHATR] v -> v relative incl OK"); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Velocity:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Relative velocity:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude - vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Distance:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // //target_vessel_extended_orbital_info = GUILayout.Toggle(target_vessel_extended_orbital_info, "Extended info"); | |
| // | |
| // if (target_vessel_extended_orbital_info) | |
| // { | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Period:"); | |
| // GUILayout.Label(Tools.ConvertInterval(v.orbit.period), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Semi-major axis:"); | |
| // GUILayout.Label((v.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Eccentricity:"); | |
| // GUILayout.Label(v.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // // Toadicus edit: convert mean anomaly into degrees. | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Mean anomaly:"); | |
| // GUILayout.Label((v.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("True anomaly:"); | |
| // GUILayout.Label(v.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // // Toadicus edit: convert eccentric anomaly into degrees. | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Eccentric anomaly:"); | |
| // GUILayout.Label((v.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Long. ascending node:"); | |
| // GUILayout.Label(v.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Arg. of periapsis:"); | |
| // GUILayout.Label(v.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // // Toadicus edit: added local sidereal longitude. | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Local Sidereal Longitude:"); | |
| // GUILayout.Label(LSL.ToString("F3") + "°", label_txt_right); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // } | |
| // else | |
| // { | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Latitude:"); | |
| // GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Longitude:"); | |
| // GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Distance:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // } | |
| // else if (cb != null && v == null) | |
| // { | |
| // //Display CelstialBody rendezvous info | |
| // GUILayout.Label(cb.bodyName, label_txt_center_bold); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Ap/Pe:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(cb.orbit.ApA) + "m / " + Tools.MuMech_ToSI(cb.orbit.PeA) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // //if (debugging) Debug.Log("[VOID] Ap/Pe OK"); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Inclination:"); | |
| // GUILayout.Label(cb.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // //if (debugging) Debug.Log("[VOID] Inclination OK"); | |
| // | |
| // if (cb.referenceBody == vessel.mainBody) | |
| // { | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Relative inclination:"); | |
| // GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), cb.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // //if (debugging) Debug.Log("[VOID] cb Relative inclination OK"); | |
| // } | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Distance:"); | |
| // GUILayout.Label(Tools.MuMech_ToSI((vessel.mainBody.position - cb.position).magnitude) + "m", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // //if (debugging) Debug.Log("[VOID] Distance OK"); | |
| // | |
| // //SUN2PLANET: | |
| // if (vessel.mainBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody) | |
| // { | |
| // display_transfer_angles_SUN2PLANET(cb); | |
| // //if (debugging) Debug.Log("[VOID] SUN2PLANET OK"); | |
| // } | |
| // | |
| // //PLANET2PLANET | |
| // else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody) | |
| // { | |
| // display_transfer_angles_PLANET2PLANET(cb); | |
| // //if (debugging) Debug.Log("[VOID] PLANET2PLANET OK"); | |
| // } | |
| // | |
| // //PLANET2MOON | |
| // else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody) | |
| // { | |
| // display_transfer_angles_PLANET2MOON(cb); | |
| // //if (debugging) Debug.Log("[VOID] PLANET2MOON OK"); | |
| // } | |
| // | |
| // //MOON2MOON | |
| // else if (vessel.mainBody.referenceBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody) | |
| // { | |
| // display_transfer_angles_MOON2MOON(cb); | |
| // //if (debugging) Debug.Log("[VOID] MOON2MOON OK"); | |
| // } | |
| // | |
| // //else GUILayout.Label("Transfer angle information\nunavailable for this target"); | |
| // | |
| // } | |
| // } | |
| // | |
| // private void data_time_gui(int window_id) | |
| // { | |
| // GUIStyle txt_white = new GUIStyle(GUI.skin.label); | |
| // txt_white.normal.textColor = txt_white.focused.textColor = Color.white; | |
| // GUIStyle txt_green = new GUIStyle(GUI.skin.label); | |
| // txt_green.normal.textColor = txt_green.focused.textColor = Color.green; | |
| // GUIStyle txt_yellow = new GUIStyle(GUI.skin.label); | |
| // txt_yellow.normal.textColor = txt_yellow.focused.textColor = Color.yellow; | |
| // | |
| // GUILayout.BeginVertical(); | |
| // | |
| // GUILayout.Label("System time: " + DateTime.Now.ToString("HH:mm:ss")); | |
| // GUILayout.Label(Tools.ConvertInterval(stopwatch1)); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button("Start")) | |
| // { | |
| // if (stopwatch1_running == false) stopwatch1_running = true; | |
| // } | |
| // if (GUILayout.Button("Stop")) | |
| // { | |
| // if (stopwatch1_running == true) stopwatch1_running = false; | |
| // } | |
| // if (GUILayout.Button("Reset")) | |
| // { | |
| // if (stopwatch1_running == true) stopwatch1_running = false; | |
| // stopwatch1 = 0; | |
| // } | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUIStyle label_style = txt_white; | |
| // string log_label = "Inactive"; | |
| // if (csv_logging && vessel.situation.ToString() == "PRELAUNCH") | |
| // { | |
| // log_label = "Awaiting launch"; | |
| // label_style = txt_yellow; | |
| // } | |
| // if (csv_logging && vessel.situation.ToString() != "PRELAUNCH") | |
| // { | |
| // log_label = "Active"; | |
| // label_style = txt_green; | |
| // } | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // csv_logging = GUILayout.Toggle(csv_logging, "Data logging: ", GUILayout.ExpandWidth(false)); | |
| // GUILayout.Label(log_label, label_style, GUILayout.ExpandWidth(true)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Interval: ", GUILayout.ExpandWidth(false)); | |
| // csv_log_interval_str = GUILayout.TextField(csv_log_interval_str, GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // float new_log_interval; | |
| // if (Single.TryParse(csv_log_interval_str, out new_log_interval)) csv_log_interval = new_log_interval; | |
| // | |
| // GUILayout.EndVertical(); | |
| // GUI.DragWindow(); | |
| // } | |
| // | |
| // private void vessel_info_gui(int window_id) | |
| // { | |
| // GUILayout.BeginVertical(); | |
| // | |
| // GUILayout.Label(vessel.vesselName, label_txt_center_bold, GUILayout.ExpandWidth(true)); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("G-force:"); | |
| // GUILayout.Label(vessel.geeForce.ToString("F2") + " gees", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // int num_parts = 0; | |
| // double total_mass = vessel.GetTotalMass(); | |
| // double resource_mass = 0; | |
| // double max_thrust = 0; | |
| // double final_thrust = 0; | |
| // | |
| // foreach (Part p in vessel.parts) | |
| // { | |
| // num_parts++; | |
| // resource_mass += p.GetResourceMass(); | |
| // | |
| // foreach (PartModule pm in p.Modules) | |
| // { | |
| // if ((pm.moduleName == "ModuleEngines") && ((p.State == PartStates.ACTIVE) || ((Staging.CurrentStage > Staging.lastStage) && (p.inverseStage == Staging.lastStage)))) | |
| // { | |
| // max_thrust += ((ModuleEngines)pm).maxThrust; | |
| // final_thrust += ((ModuleEngines)pm).finalThrust; | |
| // } | |
| // } | |
| // } | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Parts:"); | |
| // GUILayout.Label(num_parts.ToString("F0"), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Total mass:"); | |
| // GUILayout.Label(total_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Resource mass:"); | |
| // GUILayout.Label(resource_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // if (stages.Length > Staging.lastStage) | |
| // { | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("DeltaV (Current Stage):"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(stages[Staging.lastStage].deltaV).ToString() + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // | |
| // if (stages.Length > 0) | |
| // { | |
| // double totalDeltaV = 0d; | |
| // | |
| // for (int i = 0; i < stages.Length; ++i) | |
| // { | |
| // totalDeltaV += stages [i].deltaV; | |
| // } | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("DeltaV (Total):"); | |
| // GUILayout.Label(Tools.MuMech_ToSI(totalDeltaV).ToString() + "m/s", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // } | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Throttle:"); | |
| // GUILayout.Label((vessel.ctrlState.mainThrottle * 100f).ToString("F0") + "%", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Thrust (curr/max):"); | |
| // GUILayout.Label(final_thrust.ToString("F1") + " / " + max_thrust.ToString("F1") + " kN", GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // double gravity = vessel.mainBody.gravParameter / Math.Pow(vessel.mainBody.Radius + vessel.altitude, 2); | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("T:W (curr/max):"); | |
| // GUILayout.Label((final_thrust / (total_mass * gravity)).ToString("F2") + " / " + (max_thrust / (total_mass * gravity)).ToString("F2"), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // double g_ASL = (G_constant * vessel.mainBody.Mass) / Math.Pow(vessel.mainBody.Radius, 2); | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label("Max T:W @ surface:"); | |
| // GUILayout.Label((max_thrust / (total_mass * g_ASL)).ToString("F2"), GUILayout.ExpandWidth(false)); | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.EndVertical(); | |
| // GUI.DragWindow(); | |
| // } | |
| // | |
| // private void misc_info_gui(int window_id) | |
| // { | |
| // GUIContent _content = new GUIContent(); | |
| // GUILayout.BeginVertical(); | |
| // | |
| // //show_tooltips = GUILayout.Toggle(show_tooltips, "Show tooltips", GUILayout.ExpandWidth(true)); | |
| // disable_power_usage = GUILayout.Toggle(disable_power_usage, "Disable power usage"); | |
| // hide_on_pause = GUILayout.Toggle(hide_on_pause, "Hide windows on pause"); | |
| // data_time_module = GUILayout.Toggle(data_time_module, "Data Logging & Time"); | |
| // | |
| // //Language | |
| // languages[] languages_array = Enum.GetValues(typeof(languages)) as languages[]; | |
| // List<languages> languages_list = new List<languages>(); | |
| // | |
| // foreach (var val in languages_array) | |
| // { | |
| // languages_list.Add(val); | |
| // } | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // | |
| // if (GUILayout.Button("◄")) | |
| // { | |
| // //need separate preset indices for chatter and each beep | |
| // user_lang_index--; | |
| // if (user_lang_index < 0) user_lang_index = languages_list.Count - 1; | |
| // if (debugging) Debug.Log("[VOID] user_lang_index = " + user_lang_index); | |
| // //user_lang = languages_list[user_lang_index]; | |
| // //load_language(); | |
| // } | |
| // | |
| // if (GUILayout.Button("[WIP]" + languages_list[user_lang_index].ToString())) | |
| // { | |
| // user_lang = languages_list[user_lang_index]; | |
| // load_language(); | |
| // } | |
| // | |
| // if (GUILayout.Button("►")) | |
| // { | |
| // user_lang_index++; | |
| // if (user_lang_index >= languages_list.Count) user_lang_index = 0; | |
| // if (debugging) Debug.Log("[VOID] user_lang_index = " + user_lang_index); | |
| // //user_lang = languages_list[user_lang_index]; | |
| // //load_language(); | |
| // } | |
| // | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // //Skin picker | |
| // GUISkin[] skin_array = AssetBase.FindObjectsOfTypeIncludingAssets(typeof(GUISkin)) as GUISkin[]; | |
| // List<GUISkin> skin_list = new List<GUISkin>(); | |
| // | |
| // foreach (GUISkin _skin in skin_array) | |
| // { | |
| // if (_skin.name != "PlaqueDialogSkin" && _skin.name != "FlagBrowserSkin" && _skin.name != "SSUITextAreaDefault") skin_list.Add(_skin); | |
| // } | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // | |
| // GUILayout.Label("Skin:", GUILayout.ExpandWidth(false)); | |
| // | |
| // _content.text = "◄"; | |
| // _content.tooltip = "Select previous skin"; | |
| // if (GUILayout.Button(_content, GUILayout.ExpandWidth(true))) | |
| // { | |
| // skin_index--; | |
| // if (skin_index < 0) skin_index = skin_list.Count; | |
| // if (debugging) Debug.Log("[VOID] new skin_index = " + skin_index + " :: skin_list.Count = " + skin_list.Count); | |
| // } | |
| // | |
| // string skin_name = ""; | |
| // if (skin_index == 0) skin_name = "None"; | |
| // else skin_name = skin_list[skin_index - 1].name; | |
| // _content.text = skin_name; | |
| // _content.tooltip = "Current skin"; | |
| // GUILayout.Label(_content, label_txt_center, GUILayout.ExpandWidth(true)); | |
| // | |
| // _content.text = "►"; | |
| // _content.tooltip = "Select next skin"; | |
| // if (GUILayout.Button(_content, GUILayout.ExpandWidth(true))) | |
| // { | |
| // skin_index++; | |
| // if (skin_index > skin_list.Count) skin_index = 0; | |
| // if (debugging) Debug.Log("[VOID] new skin_index = " + skin_index + " :: skin_list.Count = " + skin_list.Count); | |
| // } | |
| // | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // //Change icon position | |
| // if (changing_icon_pos == false) | |
| // { | |
| // _content.text = "Change icon position"; | |
| // _content.tooltip = "Move icon anywhere on the screen"; | |
| // if (GUILayout.Button(_content, GUILayout.ExpandWidth(false))) changing_icon_pos = true; | |
| // } | |
| // else GUILayout.Label("Click anywhere to set new icon position"); | |
| // | |
| // //HUD color | |
| // if (GUILayout.Button("Change HUD color", GUILayout.ExpandWidth(false)) && this.moduleHUD != null) | |
| // { | |
| // Tools.PostDebugMessage ("VOID: Incrementing VOID_HUD ColorIndex."); | |
| // this.moduleHUD.ColorIndex++; | |
| // | |
| // } | |
| // | |
| // //if (show_tooltips && GUI.tooltip != "") tooltips(misc_window_pos); | |
| // | |
| // GUILayout.EndVertical(); | |
| // GUI.DragWindow(); | |
| // } | |
| // | |
| // private void vessel_register_gui(int window_id) | |
| // { | |
| // GUILayout.BeginVertical(); | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button("<")) | |
| // { | |
| // vessel_register_body_index--; | |
| // if (vessel_register_body_index < 0) vessel_register_body_index = all_bodies.Count - 1; | |
| // } | |
| // GUILayout.Label(all_bodies[vessel_register_body_index].bodyName, label_txt_center_bold, GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button(">")) | |
| // { | |
| // vessel_register_body_index++; | |
| // if (vessel_register_body_index > all_bodies.Count - 1) vessel_register_body_index = 0; | |
| // } | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // vessel_register_selected_body = all_bodies[vessel_register_body_index]; | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button("<")) | |
| // { | |
| // vessel_register_vessel_type_index--; | |
| // if (vessel_register_vessel_type_index < 0) vessel_register_vessel_type_index = all_vessel_types.Count - 1; | |
| // } | |
| // GUILayout.Label(all_vessel_types[vessel_register_vessel_type_index].ToString(), label_txt_center_bold, GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button(">")) | |
| // { | |
| // vessel_register_vessel_type_index++; | |
| // if (vessel_register_vessel_type_index > all_vessel_types.Count - 1) vessel_register_vessel_type_index = 0; | |
| // } | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // vessel_register_vessel_type = all_vessel_types[vessel_register_vessel_type_index]; | |
| // | |
| // GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // if (GUILayout.Button("Landed", GUILayout.ExpandWidth(true))) vessel_register_vessel_situation = "Landed"; | |
| // if (GUILayout.Button("Orbiting", GUILayout.ExpandWidth(true))) vessel_register_vessel_situation = "Orbiting"; | |
| // GUILayout.EndHorizontal(); | |
| // | |
| // //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| // GUILayout.Label(Tools.UppercaseFirst(vessel_register_vessel_situation) + " " + vessel_register_vessel_type.ToString() + "s @ " + vessel_register_selected_body.bodyName, label_txt_center, GUILayout.ExpandWidth(true)); | |
| // //GUILayout.EndHorizontal(); | |
| // | |
| // GUILayout.EndVertical(); | |
| // | |
| // vessel_register_scroll_pos = GUILayout.BeginScrollView(vessel_register_scroll_pos, false, false); | |
| // | |
| // foreach (Vessel v in FlightGlobals.Vessels) | |
| // { | |
| // if (v != vessel && v.vesselType == vessel_register_vessel_type && v.mainBody == vessel_register_selected_body) | |
| // { | |
| // if ((vessel_register_vessel_situation == "Landed" && (v.situation == Vessel.Situations.LANDED || v.situation == Vessel.Situations.PRELAUNCH || v.situation == Vessel.Situations.SPLASHED)) || (vessel_register_vessel_situation == "Orbiting" && (v.situation == Vessel.Situations.ESCAPING || v.situation == Vessel.Situations.FLYING || v.situation == Vessel.Situations.ORBITING || v.situation == Vessel.Situations.SUB_ORBITAL))) | |
| // { | |
| // if (GUILayout.Button(v.vesselName, GUILayout.ExpandWidth(true))) | |
| // { | |
| // if (vesreg_selected_vessel != v) | |
| // { | |
| // vesreg_selected_vessel = v; //set clicked vessel as selected_vessel | |
| // rendezvous_module = true; //turn bool on to open the window if closed | |
| // } | |
| // else | |
| // { | |
| // vesreg_selected_vessel = null; | |
| // } | |
| // } | |
| // } | |
| // } | |
| // } | |
| // | |
| // GUILayout.EndScrollView(); | |
| // GUI.DragWindow(); | |
| // } | |
| // | |
| // //private void tooltips(Rect pos) | |
| // //{ | |
| // // if (show_tooltips && GUI.tooltip != "") | |
| // // { | |
| // // float w = 5.5f * GUI.tooltip.Length; | |
| // // float x = (Event.current.mousePosition.x < pos.width / 2) ? Event.current.mousePosition.x + 10 : Event.current.mousePosition.x - 10 - w; | |
| // // GUI.Box(new Rect(x, Event.current.mousePosition.y, w, 25f), GUI.tooltip, gs_tooltip); | |
| // // } | |
| // //} | |
| // | |
| // private void main_gui(int window_id) | |
| // { | |
| // GUILayout.BeginVertical(); | |
| // | |
| // if (power_available) | |
| // { | |
| // if (power_toggle) | |
| // { | |
| // //Show menu toggles only when power is turned on and available | |
| // vessel_info_module = GUILayout.Toggle(vessel_info_module, "Vessel Infomation"); | |
| // void_module = GUILayout.Toggle(void_module, "Orbital Information"); | |
| // atmo_module = GUILayout.Toggle(atmo_module, "Surface & Atmospheric Information"); | |
| // tad_module = GUILayout.Toggle(tad_module, "Transfer Angle Information"); | |
| // rendezvous_module = GUILayout.Toggle(rendezvous_module, "Rendezvous Information"); | |
| // celestial_body_info_module = GUILayout.Toggle(celestial_body_info_module, "Celestial Body Information"); | |
| // vessel_register_module = GUILayout.Toggle(vessel_register_module, "Vessel Register"); | |
| // misc_module = GUILayout.Toggle(misc_module, "Miscellaneous"); | |
| // toggleHUDModule = GUILayout.Toggle(toggleHUDModule, "Show HUD"); | |
| // //test_module = GUILayout.Toggle(test_module, "The Lab"); | |
| // } | |
| // | |
| // string str = "ON"; | |
| // if (power_toggle) str = "OFF"; | |
| // if (GUILayout.Button("Power " + str)) power_toggle = !power_toggle; | |
| // } | |
| // else | |
| // { | |
| // GUIStyle label_txt_red = new GUIStyle(GUI.skin.label); | |
| // label_txt_red.normal.textColor = Color.red; | |
| // label_txt_red.alignment = TextAnchor.MiddleCenter; | |
| // GUILayout.Label("-- POWER LOST --", label_txt_red); | |
| // } | |
| // | |
| // GUILayout.EndVertical(); | |
| // GUI.DragWindow(); | |
| // } | |
| // | |
| // protected void draw_GUI() | |
| // { | |
| // if (hide_on_pause == false || (hide_on_pause && PauseMenu.isOpen == false)) | |
| // { | |
| // //Apply a skin if selected | |
| // if (skin_index == 0) GUI.skin = null; | |
| // else if (skin_index == 1) GUI.skin = AssetBase.GetGUISkin("KSP window 1"); | |
| // else if (skin_index == 2) GUI.skin = AssetBase.GetGUISkin("KSP window 2"); | |
| // else if (skin_index == 3) GUI.skin = AssetBase.GetGUISkin("KSP window 3"); | |
| // else if (skin_index == 4) GUI.skin = AssetBase.GetGUISkin("KSP window 4"); | |
| // else if (skin_index == 5) GUI.skin = AssetBase.GetGUISkin("KSP window 5"); | |
| // else if (skin_index == 6) GUI.skin = AssetBase.GetGUISkin("KSP window 6"); | |
| // else if (skin_index == 7) GUI.skin = AssetBase.GetGUISkin("KSP window 7"); | |
| // else if (skin_index == 8) GUI.skin = AssetBase.GetGUISkin("OrbitMapSkin"); | |
| // | |
| // if (gui_styles_set == false) set_gui_styles(); //set GUI styles once AFTER setting skin | |
| // | |
| // void_icon = void_icon_off; //icon off default | |
| // if (power_toggle) void_icon = void_icon_on; //or on if power_toggle==true | |
| // if (GUI.Button(new Rect(main_icon_pos), void_icon, new GUIStyle())) main_gui_minimized = !main_gui_minimized; | |
| // | |
| // int window_id = window_base_id; | |
| // | |
| // if (main_gui_minimized == false) main_window_pos = GUILayout.Window(window_id, main_window_pos, main_gui, version_name + this_version, GUILayout.Width(250), GUILayout.Height(50)); | |
| // if (power_toggle && power_available) | |
| // { | |
| // //hide these windows if power is turned off or unavailable | |
| // if (void_module) void_window_pos = GUILayout.Window(++window_id, void_window_pos, void_gui, "Orbital Information", GUILayout.Width(250), GUILayout.Height(50)); | |
| // if (atmo_module) atmo_window_pos = GUILayout.Window(++window_id, atmo_window_pos, atmo_gui, "Surface & Atmospheric Information", GUILayout.Width(250), GUILayout.Height(50)); | |
| // if (tad_module) transfer_window_pos = GUILayout.Window(++window_id, transfer_window_pos, tad_gui, "Transfer Angle Information", GUILayout.Width(315), GUILayout.Height(50)); | |
| // if (vessel_register_module) vessel_register_window_pos = GUILayout.Window(++window_id, vessel_register_window_pos, vessel_register_gui, "Vessel Register", GUILayout.Width(250), GUILayout.Height(375)); | |
| // if (data_time_module) data_logging_window_pos = GUILayout.Window(++window_id, data_logging_window_pos, data_time_gui, "Data Logging & Time", GUILayout.Width(250), GUILayout.Height(50)); | |
| // if (vessel_info_module) | |
| // { | |
| // if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate)) | |
| // { | |
| // SimManager.Instance.RequestSimulation(); | |
| // } | |
| // | |
| // vessel_info_window_pos = GUILayout.Window(++window_id, vessel_info_window_pos, vessel_info_gui, "Vessel Information", GUILayout.Width(250), GUILayout.Height(50)); | |
| // } | |
| // if (misc_module) misc_window_pos = GUILayout.Window(++window_id, misc_window_pos, misc_info_gui, "Miscellaneous", GUILayout.Width(275), GUILayout.Height(50)); | |
| // if (test_module) lab_window_pos = GUILayout.Window(++window_id, lab_window_pos, test_gui, "The Lab", GUILayout.Width(350), GUILayout.Height(50)); | |
| // if (rendezvous_module) rendezvous_info_window_pos = GUILayout.Window(++window_id, rendezvous_info_window_pos, rendezvous_info_gui, "Rendezvous Information", GUILayout.Width(315), GUILayout.Height(50)); | |
| // if (celestial_body_info_module) body_op_window_pos = GUILayout.Window(++window_id, body_op_window_pos, celestial_body_info_gui, "Celestial Body Information", GUILayout.Width(420), GUILayout.Height(50)); | |
| // } | |
| // } | |
| // } | |
| // | |
| // public void Awake() | |
| // { | |
| // settings_path = AssemblyLoader.loadedAssemblies.GetPathByType(typeof(VOIDFlightMaster)) + "/"; //returns "X:/full/path/to/GameData/RBR/Plugins/PluginData/VOID" | |
| // load_icons(); | |
| // load_language(); | |
| // load_settings(); | |
| // } | |
| // | |
| // private UInt64 updateCounter = 0; | |
| // public void Update() | |
| // { | |
| // ++updateCounter; | |
| // Tools.PostDebugMessage (string.Format ("VOID: Update #{0}", updateCounter)); | |
| // // Module Startups | |
| // if (this.toggleHUDModule && this.moduleHUD == null) | |
| // { | |
| // Tools.PostDebugMessage ("VOID: Getting VOID_HUD instance."); | |
| // this.moduleHUD = (VOID_HUD)VOID_HUD.Instance; | |
| // Tools.PostDebugMessage ("VOID: Loading VOID_HUD config."); | |
| // this.moduleHUD.LoadConfig (); | |
| // Tools.PostDebugMessage ("VOID: VOID_HUD All loaded."); | |
| // this.moduleHUD.StartGUI (); | |
| // } | |
| // | |
| // Tools.PostDebugMessage (string.Format("VOID: this.moduleHUD.ColorIndex = '{0}'.", this.moduleHUD.ColorIndex)); | |
| // | |
| // //Icon relocation | |
| // if (changing_icon_pos && Input.GetMouseButtonDown(0)) | |
| // { | |
| // main_icon_pos = new Rect(Input.mousePosition.x - 15f, Screen.height - Input.mousePosition.y - 15f, 30f, 30f); | |
| // changing_icon_pos = false; | |
| // } | |
| // | |
| // if (FlightGlobals.ActiveVessel != null) | |
| // { | |
| // vessel = FlightGlobals.ActiveVessel; | |
| // | |
| // if (run_once) | |
| // { | |
| // if (debugging) Debug.Log("[VOID] running run_once..."); | |
| // all_bodies.AddRange(FlightGlobals.Bodies); | |
| // vessel_register_body_index = all_bodies.IndexOf(vessel.mainBody); | |
| // | |
| // Array va = System.Enum.GetValues(typeof(VesselType)); | |
| // all_vessel_types = va.OfType<VesselType>().ToList(); | |
| // vessel_register_vessel_type_index = all_vessel_types.IndexOf(vessel.vesselType); | |
| // | |
| // run_once = false; | |
| // } | |
| // | |
| // if (vessel == FlightGlobals.ActiveVessel) | |
| // { | |
| // | |
| // if (SimManager.Instance.Stages != null) | |
| // { | |
| // stages = SimManager.Instance.Stages; | |
| // } | |
| // | |
| // SimManager.Instance.Gravity = vessel.mainBody.gravParameter / Math.Pow(vessel.mainBody.Radius, 2); | |
| // SimManager.Instance.TryStartSimulation(); | |
| // } | |
| // | |
| // if (gui_running == false) start_GUI(); | |
| // | |
| // cfg_update_timer += 1; | |
| // if (cfg_update_timer >= 15f) | |
| // { | |
| // write_settings(); | |
| // cfg_update_timer = 0f; | |
| // } | |
| // | |
| // if (power_available) | |
| // { | |
| // main_csv(); // a function to group together all the Data Logging/csv functions | |
| // if (stopwatch1_running) stopwatch1 += Time.deltaTime; | |
| // } | |
| // } | |
| // else | |
| // { | |
| // //activevessel == null | |
| // if (gui_running) | |
| // { | |
| // Tools.PostDebugMessage ("VOID: Stopping GUI because our vessel isn't the active vessel."); | |
| // stop_GUI(); | |
| // } | |
| // } | |
| // } | |
| // | |
| // public void FixedUpdate() | |
| // { | |
| // if (power_toggle) consume_resources(); | |
| // } | |
| } | } |
| [KSPAddon(KSPAddon.Startup.EditorAny, false)] | |
| public class VOIDEditorMaster : MonoBehaviour | |
| { | |
| protected VOID_EditorCore Core; | |
| public void Awake() | |
| { | |
| Tools.PostDebugMessage ("VOIDEditorMaster: Waking up."); | |
| this.Core = VOID_EditorCore.Instance; | |
| this.Core.StopGUI (); | |
| this.Core.StartGUI (); | |
| Tools.PostDebugMessage ("VOIDEditorMaster: Awake."); | |
| } | |
| public void Update() | |
| { | |
| if (!HighLogic.LoadedSceneIsEditor && this.Core != null) | |
| { | |
| this.Core.SaveConfig (); | |
| this.Core = null; | |
| VOID_EditorCore.Reset(); | |
| return; | |
| } | |
| if (this.Core == null) | |
| { | |
| this.Awake(); | |
| } | |
| this.Core.Update (); | |
| if (this.Core.factoryReset) | |
| { | |
| KSP.IO.File.Delete<VOID_EditorCore>("config.xml"); | |
| this.Core = null; | |
| VOID_EditorCore.Reset(); | |
| } | |
| } | |
| public void FixedUpdate() | |
| { | |
| if (this.Core == null || !HighLogic.LoadedSceneIsEditor) | |
| { | |
| return; | |
| } | |
| this.Core.FixedUpdate (); | |
| } | |
| public void OnGUI() | |
| { | |
| if (this.Core == null) | |
| { | |
| return; | |
| } | |
| this.Core.OnGUI(); | |
| } | |
| } | |
| } | } |
| // | // |
| // VOID_Orbital.cs | // VOID_Orbital.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| using KSP; | using KSP; |
| using System; | using System; |
| using System.Collections.Generic; | using System.Collections.Generic; |
| using UnityEngine; | using UnityEngine; |
| namespace VOID | namespace VOID |
| { | { |
| public class VOID_CBInfoBrowser : VOID_WindowModule | public class VOID_CBInfoBrowser : VOID_WindowModule |
| { | { |
| protected List<CelestialBody> allBodies; | |
| protected bool bodiesLoaded = false; | |
| [AVOID_SaveValue("selectedBodyIdx1")] | [AVOID_SaveValue("selectedBodyIdx1")] |
| protected VOID_SaveValue<int> selectedBodyIdx1 = 1; | protected VOID_SaveValue<int> selectedBodyIdx1 = 1; |
| [AVOID_SaveValue("selectedBodyIdx2")] | [AVOID_SaveValue("selectedBodyIdx2")] |
| protected VOID_SaveValue<int> selectedBodyIdx2 = 2; | protected VOID_SaveValue<int> selectedBodyIdx2 = 2; |
| protected CelestialBody selectedBody1; | protected CelestialBody selectedBody1; |
| protected CelestialBody selectedBody2; | protected CelestialBody selectedBody2; |
| [AVOID_SaveValue("toggleOrbital")] | [AVOID_SaveValue("toggleOrbital")] |
| protected VOID_SaveValue<bool> toggleOrbital = false; | protected VOID_SaveValue<bool> toggleOrbital = false; |
| [AVOID_SaveValue("togglePhysical")] | [AVOID_SaveValue("togglePhysical")] |
| protected VOID_SaveValue<bool> togglePhysical = false; | protected VOID_SaveValue<bool> togglePhysical = false; |
| public VOID_CBInfoBrowser() | public VOID_CBInfoBrowser() |
| { | { |
| this._Name = "Celestial Body Information Browser"; | this._Name = "Celestial Body Information Browser"; |
| } | |
| this.WindowPos.x = 10; | |
| protected void LoadAllBodies() | this.WindowPos.y = 85; |
| { | |
| allBodies = FlightGlobals.Bodies; | |
| this.bodiesLoaded = true; | |
| } | } |
| public override void ModuleWindow(int _) | public override void ModuleWindow(int _) |
| { | { |
| if (!this.bodiesLoaded) | |
| { | |
| this.LoadAllBodies(); | |
| } | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.BeginVertical(GUILayout.Width(150)); | GUILayout.BeginVertical(GUILayout.Width(150)); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("", GUILayout.ExpandWidth(true)); | GUILayout.Label("", GUILayout.ExpandWidth(true)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| GUILayout.BeginVertical(GUILayout.Width(150)); | GUILayout.BeginVertical(GUILayout.Width(150)); |
| selectedBody1 = allBodies[selectedBodyIdx1]; | selectedBody1 = VOID_Core.Instance.allBodies[selectedBodyIdx1]; |
| selectedBody2 = allBodies[selectedBodyIdx2]; | selectedBody2 = VOID_Core.Instance.allBodies[selectedBodyIdx2]; |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (GUILayout.Button("<", GUILayout.ExpandWidth(false))) | if (GUILayout.Button("<", GUILayout.ExpandWidth(false))) |
| { | { |
| selectedBodyIdx1--; | selectedBodyIdx1--; |
| if (selectedBodyIdx1 < 0) selectedBodyIdx1 = allBodies.Count - 1; | if (selectedBodyIdx1 < 0) selectedBodyIdx1 = VOID_Core.Instance.allBodies.Count - 1; |
| } | } |
| GUILayout.Label(allBodies[selectedBodyIdx1].bodyName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true)); | GUILayout.Label(VOID_Core.Instance.allBodies[selectedBodyIdx1].bodyName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true)); |
| if (GUILayout.Button(">", GUILayout.ExpandWidth(false))) | if (GUILayout.Button(">", GUILayout.ExpandWidth(false))) |
| { | { |
| selectedBodyIdx1++; | selectedBodyIdx1++; |
| if (selectedBodyIdx1 > allBodies.Count - 1) selectedBodyIdx1 = 0; | if (selectedBodyIdx1 > VOID_Core.Instance.allBodies.Count - 1) selectedBodyIdx1 = 0; |
| } | } |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| GUILayout.BeginVertical(GUILayout.Width(150)); | GUILayout.BeginVertical(GUILayout.Width(150)); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (GUILayout.Button("<", GUILayout.ExpandWidth(false))) | if (GUILayout.Button("<", GUILayout.ExpandWidth(false))) |
| { | { |
| selectedBodyIdx2--; | selectedBodyIdx2--; |
| if (selectedBodyIdx2 < 0) selectedBodyIdx2 = allBodies.Count - 1; | if (selectedBodyIdx2 < 0) selectedBodyIdx2 = VOID_Core.Instance.allBodies.Count - 1; |
| } | } |
| GUILayout.Label(allBodies[selectedBodyIdx2].bodyName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true)); | GUILayout.Label(VOID_Core.Instance.allBodies[selectedBodyIdx2].bodyName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true)); |
| if (GUILayout.Button(">", GUILayout.ExpandWidth(false))) | if (GUILayout.Button(">", GUILayout.ExpandWidth(false))) |
| { | { |
| selectedBodyIdx2++; | selectedBodyIdx2++; |
| if (selectedBodyIdx2 > allBodies.Count - 1) selectedBodyIdx2 = 0; | if (selectedBodyIdx2 > VOID_Core.Instance.allBodies.Count - 1) selectedBodyIdx2 = 0; |
| } | } |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| //} | //} |
| //toggle for orbital info chunk | //toggle for orbital info chunk |
| if (GUILayout.Button("Orbital Characteristics", GUILayout.ExpandWidth(true))) toggleOrbital = !toggleOrbital; | if (GUILayout.Button("Orbital Characteristics", GUILayout.ExpandWidth(true))) toggleOrbital = !toggleOrbital; |
| if (toggleOrbital) | if (toggleOrbital) |
| { | { |
| //begin orbital into horizontal chunk | //begin orbital into horizontal chunk |
| //print("begin orbital info section..."); | //print("begin orbital info section..."); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| //begin orbital value labels column | //begin orbital value labels column |
| GUILayout.BeginVertical(GUILayout.Width(150)); | GUILayout.BeginVertical(GUILayout.Width(150)); |
| //print("printing row labels..."); | //print("printing row labels..."); |
| GUILayout.Label("Apoapsis:"); | GUILayout.Label("Apoapsis:"); |
| GUILayout.Label("Time to Ap:"); | GUILayout.Label("Time to Ap:"); |
| GUILayout.Label("Periapsis:"); | GUILayout.Label("Periapsis:"); |
| GUILayout.Label("Time to Pe:"); | GUILayout.Label("Time to Pe:"); |
| GUILayout.Label("Semi-major axis:"); | GUILayout.Label("Semi-major axis:"); |
| GUILayout.Label("Eccentricity:"); | GUILayout.Label("Eccentricity:"); |
| GUILayout.Label("Orbital period:"); | GUILayout.Label("Orbital period:"); |
| GUILayout.Label("Rotational period:"); | GUILayout.Label("Rotational period:"); |
| GUILayout.Label("Velocity:"); | GUILayout.Label("Velocity:"); |
| GUILayout.Label("Mean anomaly:"); | GUILayout.Label("Mean anomaly:"); |
| GUILayout.Label("True anomaly:"); | GUILayout.Label("True anomaly:"); |
| GUILayout.Label("Eccentric anomaly:"); | GUILayout.Label("Eccentric anomaly:"); |
| GUILayout.Label("Inclination:"); | GUILayout.Label("Inclination:"); |
| GUILayout.Label("Long. ascending node:"); | GUILayout.Label("Long. ascending node:"); |
| GUILayout.Label("Arg. of periapsis:"); | GUILayout.Label("Arg. of periapsis:"); |
| GUILayout.Label("Tidally locked:"); | GUILayout.Label("Tidally locked:"); |
| //end orbital value labels column | //end orbital value labels column |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| //begin primary orbital values column | //begin primary orbital values column |
| GUILayout.BeginVertical(GUILayout.Width(150)); | GUILayout.BeginVertical(GUILayout.Width(150)); |
| body_OP_show_orbital_info(selectedBody1); | body_OP_show_orbital_info(selectedBody1); |
| //end primary orbital values column | //end primary orbital values column |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| //begin secondary orbital values column | //begin secondary orbital values column |
| GUILayout.BeginVertical(GUILayout.Width(150)); | GUILayout.BeginVertical(GUILayout.Width(150)); |
| body_OP_show_orbital_info(selectedBody2); | body_OP_show_orbital_info(selectedBody2); |
| //end secondary orbital values column | //end secondary orbital values column |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| //end orbital info horizontal chunk | //end orbital info horizontal chunk |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| } | } |
| //toggle for physical info chunk | //toggle for physical info chunk |
| if (GUILayout.Button("Physical Characteristics", GUILayout.ExpandWidth(true))) togglePhysical = !togglePhysical; | if (GUILayout.Button("Physical Characteristics", GUILayout.ExpandWidth(true))) togglePhysical = !togglePhysical; |
| if (togglePhysical) | if (togglePhysical) |
| { | { |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| //begin physical info value label column | //begin physical info value label column |
| GUILayout.BeginVertical(GUILayout.Width(150)); | GUILayout.BeginVertical(GUILayout.Width(150)); |
| GUILayout.Label("Radius:"); | GUILayout.Label("Radius:"); |
| GUILayout.Label("Surface area:"); | GUILayout.Label("Surface area:"); |
| GUILayout.Label("Volume:"); | GUILayout.Label("Volume:"); |
| GUILayout.Label("Mass:"); | GUILayout.Label("Mass:"); |
| GUILayout.Label("Density:"); | GUILayout.Label("Density:"); |
| GUILayout.Label("Sphere of influence:"); | GUILayout.Label("Sphere of influence:"); |
| GUILayout.Label("Natural satellites:"); | GUILayout.Label("Natural satellites:"); |
| GUILayout.Label("Artificial satellites:"); | GUILayout.Label("Artificial satellites:"); |
| GUILayout.Label("Surface gravity:"); | GUILayout.Label("Surface gravity:"); |
| GUILayout.Label("Atmosphere altitude:"); | GUILayout.Label("Atmosphere altitude:"); |
| GUILayout.Label("Atmospheric O\u2082:"); | GUILayout.Label("Atmospheric O\u2082:"); |
| GUILayout.Label("Has ocean:"); | GUILayout.Label("Has ocean:"); |
| //end physical info value label column | //end physical info value label column |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| //begin primary physical values column | //begin primary physical values column |
| GUILayout.BeginVertical(GUILayout.Width(150)); | GUILayout.BeginVertical(GUILayout.Width(150)); |
| body_OP_show_physical_info(selectedBody1); | body_OP_show_physical_info(selectedBody1); |
| //end primary physical column | //end primary physical column |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| //begin secondary physical values column | //begin secondary physical values column |
| GUILayout.BeginVertical(GUILayout.Width(150)); | GUILayout.BeginVertical(GUILayout.Width(150)); |
| body_OP_show_physical_info(selectedBody2); | body_OP_show_physical_info(selectedBody2); |
| //end target physical values column | //end target physical values column |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| //end physical value horizontal chunk | //end physical value horizontal chunk |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| } | } |
| GUI.DragWindow(); | GUI.DragWindow(); |
| } | } |
| private void body_OP_show_orbital_info(CelestialBody body) | private void body_OP_show_orbital_info(CelestialBody body) |
| { | { |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label((body.orbit.ApA / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label((body.orbit.ApA / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(Tools.ConvertInterval(body.orbit.timeToAp), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(Tools.ConvertInterval(body.orbit.timeToAp), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label((body.orbit.PeA / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label((body.orbit.PeA / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(Tools.ConvertInterval(body.orbit.timeToPe), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(Tools.ConvertInterval(body.orbit.timeToPe), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label((body.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label((body.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(body.orbit.eccentricity.ToString("F4") + "", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(body.orbit.eccentricity.ToString("F4") + "", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(Tools.ConvertInterval(body.orbit.period), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(Tools.ConvertInterval(body.orbit.period), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(Tools.ConvertInterval(body.rotationPeriod), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(Tools.ConvertInterval(body.rotationPeriod), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label((body.orbit.orbitalSpeed / 1000).ToString("F2") + "km/s", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label((body.orbit.orbitalSpeed / 1000).ToString("F2") + "km/s", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| // Toadicus edit: convert mean anomaly into degrees. | // Toadicus edit: convert mean anomaly into degrees. |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label((body.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label((body.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(body.orbit.trueAnomaly.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(body.orbit.trueAnomaly.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| // Toadicus edit: convert eccentric anomaly into degrees. | // Toadicus edit: convert eccentric anomaly into degrees. |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label((body.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label((body.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(body.orbit.inclination.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(body.orbit.inclination.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(body.orbit.LAN.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(body.orbit.LAN.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(body.orbit.argumentOfPeriapsis.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(body.orbit.argumentOfPeriapsis.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label("N/A", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else | else |
| { | { |
| string body_tidally_locked = "No"; | string body_tidally_locked = "No"; |
| if (body.tidallyLocked) body_tidally_locked = "Yes"; | if (body.tidallyLocked) body_tidally_locked = "Yes"; |
| GUILayout.Label(body_tidally_locked, VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label(body_tidally_locked, VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| } | } |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| } | } |
| private void body_OP_show_physical_info(CelestialBody body) | private void body_OP_show_physical_info(CelestialBody body) |
| { | { |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label((body.Radius / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label((body.Radius / 1000).ToString("##,#") + "km", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(((Math.Pow((body.Radius), 2) * 4 * Math.PI) / 1000).ToString("0.00e+00") + "km²", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label(((Math.Pow((body.Radius), 2) * 4 * Math.PI) / 1000).ToString("0.00e+00") + "km²", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| // divide by 1000 to convert m to km | // divide by 1000 to convert m to km |
| GUILayout.Label((((4d / 3) * Math.PI * Math.Pow(body.Radius, 3)) / 1000).ToString("0.00e+00") + "km³", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label((((4d / 3) * Math.PI * Math.Pow(body.Radius, 3)) / 1000).ToString("0.00e+00") + "km³", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.Label(((4 / 3) * Math.PI * Math.Pow((vessel.mainBody.Radius / 1000), 3)).ToString(), txt_right, GUILayout.ExpandWidth(true)); | //GUILayout.Label(((4 / 3) * Math.PI * Math.Pow((vessel.mainBody.Radius / 1000), 3)).ToString(), txt_right, GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(body.Mass.ToString("0.00e+00") + "kg", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label(body.Mass.ToString("0.00e+00") + "kg", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| double p = body.Mass / (Math.Pow(body.Radius, 3) * (4d / 3) * Math.PI); | double p = body.Mass / (Math.Pow(body.Radius, 3) * (4d / 3) * Math.PI); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(p.ToString("##,#") + "kg/m³", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label(p.ToString("##,#") + "kg/m³", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (body.bodyName == "Sun") GUILayout.Label(Tools.MuMech_ToSI(body.sphereOfInfluence), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | if (body.bodyName == "Sun") GUILayout.Label(Tools.MuMech_ToSI(body.sphereOfInfluence), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| else GUILayout.Label(Tools.MuMech_ToSI(body.sphereOfInfluence), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | else GUILayout.Label(Tools.MuMech_ToSI(body.sphereOfInfluence), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(body.orbitingBodies.Count.ToString(), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label(body.orbitingBodies.Count.ToString(), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //show # artificial satellites | //show # artificial satellites |
| int num_art_sats = 0; | int num_art_sats = 0; |
| foreach (Vessel v in FlightGlobals.Vessels) | foreach (Vessel v in FlightGlobals.Vessels) |
| { | { |
| if (v.mainBody == body && v.situation.ToString() == "ORBITING") num_art_sats++; | if (v.mainBody == body && v.situation.ToString() == "ORBITING") num_art_sats++; |
| } | } |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(num_art_sats.ToString(), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label(num_art_sats.ToString(), VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| double g_ASL = (VOID_Core.Constant_G * body.Mass) / Math.Pow(body.Radius, 2); | double g_ASL = (VOID_Core.Constant_G * body.Mass) / Math.Pow(body.Radius, 2); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(Tools.MuMech_ToSI(g_ASL) + "m/s²", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label(Tools.MuMech_ToSI(g_ASL) + "m/s²", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("≈ " + Tools.MuMech_ToSI(body.maxAtmosphereAltitude) + "m", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label("≈ " + Tools.MuMech_ToSI(body.maxAtmosphereAltitude) + "m", VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| string O2 = "No"; | string O2 = "No"; |
| if (body.atmosphereContainsOxygen == true) O2 = "Yes"; | if (body.atmosphereContainsOxygen == true) O2 = "Yes"; |
| GUILayout.Label(O2, VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label(O2, VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | //GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| string ocean = "No"; | string ocean = "No"; |
| if (body.ocean == true) ocean = "Yes"; | if (body.ocean == true) ocean = "Yes"; |
| GUILayout.Label(ocean, VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); | GUILayout.Label(ocean, VOID_Core.Instance.LabelStyles["txt_right"], GUILayout.ExpandWidth(true)); |
| //GUILayout.EndHorizontal(); | //GUILayout.EndHorizontal(); |
| } | } |
| } | } |
| } | } |
| // | // |
| // VOID_Core.cs | // VOID_Core.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| using System; | using System; |
| using System.Collections.Generic; | using System.Collections.Generic; |
| using System.Linq; | using System.Linq; |
| using System.Reflection; | using System.Reflection; |
| using KSP; | using KSP; |
| using UnityEngine; | using UnityEngine; |
| namespace VOID | namespace VOID |
| { | { |
| public class VOID_Core : VOID_Module, IVOID_Module | public class VOID_Core : VOID_Module, IVOID_Module |
| { | { |
| /* | /* |
| * Static Members | * Static Members |
| * */ | * */ |
| protected static bool _initialized = false; | protected static bool _initialized = false; |
| public static bool Initialized | public static bool Initialized |
| { | { |
| get | get |
| { | { |
| return _initialized; | return _initialized; |
| } | } |
| } | } |
| protected static VOID_Core _instance; | protected static VOID_Core _instance; |
| public static VOID_Core Instance | public static VOID_Core Instance |
| { | { |
| get | get |
| { | { |
| if (_instance == null) | if (_instance == null) |
| { | { |
| _instance = new VOID_Core(); | _instance = new VOID_Core(); |
| _initialized = true; | _initialized = true; |
| } | } |
| return _instance; | return _instance; |
| } | } |
| } | } |
| public static void Reset() | |
| { | |
| _instance.StopGUI(); | |
| _instance = null; | |
| _initialized = false; | |
| } | |
| public static double Constant_G = 6.674e-11; | public static double Constant_G = 6.674e-11; |
| /* | /* |
| * Fields | * Fields |
| * */ | * */ |
| protected string VoidName = "VOID"; | protected string VoidName = "VOID"; |
| protected string VoidVersion = "0.9.9"; | protected string VoidVersion = "0.9.10"; |
| protected bool _factoryReset = false; | |
| [AVOID_SaveValue("configValue")] | [AVOID_SaveValue("configValue")] |
| protected VOID_SaveValue<int> configVersion = 1; | protected VOID_SaveValue<int> configVersion = 1; |
| protected List<IVOID_Module> _modules = new List<IVOID_Module>(); | protected List<IVOID_Module> _modules = new List<IVOID_Module>(); |
| protected bool _modulesLoaded = false; | protected bool _modulesLoaded = false; |
| [AVOID_SaveValue("mainWindowPos")] | [AVOID_SaveValue("mainWindowPos")] |
| protected VOID_SaveValue<Rect> mainWindowPos = new Rect(Screen.width / 2, Screen.height / 2, 10f, 10f); | protected VOID_SaveValue<Rect> mainWindowPos = new Rect(475, 575, 10f, 10f); |
| [AVOID_SaveValue("mainGuiMinimized")] | [AVOID_SaveValue("mainGuiMinimized")] |
| protected VOID_SaveValue<bool> mainGuiMinimized = false; | protected VOID_SaveValue<bool> mainGuiMinimized = false; |
| [AVOID_SaveValue("configWindowPos")] | [AVOID_SaveValue("configWindowPos")] |
| protected VOID_SaveValue<Rect> configWindowPos = new Rect(Screen.width / 2, Screen.height /2, 10f, 10f); | protected VOID_SaveValue<Rect> configWindowPos = new Rect(825, 625, 10f, 10f); |
| [AVOID_SaveValue("configWindowMinimized")] | [AVOID_SaveValue("configWindowMinimized")] |
| protected VOID_SaveValue<bool> configWindowMinimized = true; | protected VOID_SaveValue<bool> configWindowMinimized = true; |
| [AVOID_SaveValue("VOIDIconPos")] | [AVOID_SaveValue("VOIDIconPos")] |
| protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 30, 30f, 30f); | protected VOID_SaveValue<Rect> VOIDIconPos = new Rect(Screen.width / 2 - 200, Screen.height - 30, 30f, 30f); |
| protected Texture2D VOIDIconOff = new Texture2D(30, 30, TextureFormat.ARGB32, false); | protected Texture2D VOIDIconOff = new Texture2D(30, 30, TextureFormat.ARGB32, false); |
| protected Texture2D VOIDIconOn = new Texture2D(30, 30, TextureFormat.ARGB32, false); | protected Texture2D VOIDIconOn = new Texture2D(30, 30, TextureFormat.ARGB32, false); |
| protected Texture2D VOIDIconTexture; | protected Texture2D VOIDIconTexture; |
| protected string VOIDIconOnPath = "VOID/Textures/void_icon_on"; | protected string VOIDIconOnPath = "VOID/Textures/void_icon_on"; |
| protected string VOIDIconOffPath = "VOID/Textures/void_icon_off"; | protected string VOIDIconOffPath = "VOID/Textures/void_icon_off"; |
| protected bool VOIDIconLocked = true; | |
| protected int windowBaseID = -96518722; | protected int windowBaseID = -96518722; |
| protected int _windowID = 0; | protected int _windowID = 0; |
| protected bool GUIStylesLoaded = false; | protected bool GUIStylesLoaded = false; |
| protected Dictionary<string, GUIStyle> _LabelStyles = new Dictionary<string, GUIStyle>(); | protected Dictionary<string, GUIStyle> _LabelStyles = new Dictionary<string, GUIStyle>(); |
| [AVOID_SaveValue("togglePower")] | [AVOID_SaveValue("togglePower")] |
| public VOID_SaveValue<bool> togglePower = true; | public VOID_SaveValue<bool> togglePower = true; |
| public bool powerAvailable = true; | public bool powerAvailable = true; |
| [AVOID_SaveValue("consumeResource")] | [AVOID_SaveValue("consumeResource")] |
| protected VOID_SaveValue<bool> consumeResource = false; | protected VOID_SaveValue<bool> consumeResource = false; |
| [AVOID_SaveValue("resourceName")] | [AVOID_SaveValue("resourceName")] |
| protected VOID_SaveValue<string> resourceName = "ElectricCharge"; | protected VOID_SaveValue<string> resourceName = "ElectricCharge"; |
| [AVOID_SaveValue("resourceRate")] | [AVOID_SaveValue("resourceRate")] |
| protected VOID_SaveValue<float> resourceRate = 0.2f; | protected VOID_SaveValue<float> resourceRate = 0.2f; |
| // Celestial Body Housekeeping | |
| protected List<CelestialBody> _allBodies = new List<CelestialBody>(); | |
| protected bool bodiesLoaded = false; | |
| // Vessel Type Housekeeping | |
| protected List<VesselType> _allVesselTypes = new List<VesselType>(); | |
| protected bool vesselTypesLoaded = false; | |
| public float saveTimer = 0; | public float saveTimer = 0; |
| protected string defaultSkin = "KSP window 2"; | [AVOID_SaveValue("defaultSkin")] |
| protected VOID_SaveValue<string> _skin; | protected VOID_SaveValue<string> defaultSkin = "KSP window 2"; |
| protected int _skinIdx = int.MinValue; | |
| protected List<GUISkin> skin_list; | |
| protected string[] forbiddenSkins = | |
| { | |
| "PlaqueDialogSkin", | |
| "FlagBrowserSkin", | |
| "SSUITextAreaDefault", | |
| "ExperimentsDialogSkin", | |
| "ExpRecoveryDialogSkin", | |
| "KSP window 5", | |
| "KSP window 6" | |
| }; | |
| protected bool skinsLoaded = false; | |
| public bool configDirty; | public bool configDirty; |
| /* | /* |
| * Properties | * Properties |
| * */ | * */ |
| public bool factoryReset | |
| { | |
| get | |
| { | |
| return this._factoryReset; | |
| } | |
| } | |
| public List<IVOID_Module> Modules | public List<IVOID_Module> Modules |
| { | { |
| get | get |
| { | { |
| return this._modules; | return this._modules; |
| } | } |
| } | } |
| public GUISkin Skin | public GUISkin Skin |
| { | { |
| get | get |
| { | { |
| if (this._skin == null) | if (this.skin_list == null || this._skinIdx < 0 || this._skinIdx > this.skin_list.Count) |
| { | { |
| this._skin = this.defaultSkin; | return AssetBase.GetGUISkin(this.defaultSkin); |
| } | } |
| return AssetBase.GetGUISkin(this._skin); | return this.skin_list[this._skinIdx]; |
| } | } |
| } | } |
| public int windowID | public int windowID |
| { | { |
| get | get |
| { | { |
| if (this._windowID == 0) | if (this._windowID == 0) |
| { | { |
| this._windowID = this.windowBaseID; | this._windowID = this.windowBaseID; |
| } | } |
| return this._windowID++; | return this._windowID++; |
| } | } |
| } | } |
| public Dictionary<string, GUIStyle> LabelStyles | public Dictionary<string, GUIStyle> LabelStyles |
| { | { |
| get | get |
| { | { |
| return this._LabelStyles; | return this._LabelStyles; |
| } | |
| } | |
| public List<CelestialBody> allBodies | |
| { | |
| get | |
| { | |
| return this._allBodies; | |
| } | |
| } | |
| public List<VesselType> allVesselTypes | |
| { | |
| get | |
| { | |
| return this._allVesselTypes; | |
| } | } |
| } | } |
| /* | /* |
| * Methods | * Methods |
| * */ | * */ |
| protected VOID_Core() | protected VOID_Core() |
| { | { |
| this._Name = "VOID Core"; | this._Name = "VOID Core"; |
| this._Active = true; | |
| this.VOIDIconOn = GameDatabase.Instance.GetTexture (this.VOIDIconOnPath, false); | this.VOIDIconOn = GameDatabase.Instance.GetTexture (this.VOIDIconOnPath, false); |
| this.VOIDIconOff = GameDatabase.Instance.GetTexture (this.VOIDIconOffPath, false); | this.VOIDIconOff = GameDatabase.Instance.GetTexture (this.VOIDIconOffPath, false); |
| this.LoadConfig (); | this.LoadConfig (); |
| } | } |
| protected void LoadModules() | protected void LoadModulesOfType<T>() |
| { | { |
| var types = AssemblyLoader.loadedAssemblies | var types = AssemblyLoader.loadedAssemblies |
| .Select (a => a.assembly.GetExportedTypes ()) | .Select (a => a.assembly.GetExportedTypes ()) |
| .SelectMany (t => t) | .SelectMany (t => t) |
| .Where (v => typeof(IVOID_Module).IsAssignableFrom (v) | .Where (v => typeof(T).IsAssignableFrom (v) |
| && !(v.IsInterface || v.IsAbstract) && | && !(v.IsInterface || v.IsAbstract) && |
| !typeof(VOID_Core).IsAssignableFrom (v) | !typeof(VOID_Core).IsAssignableFrom (v) |
| ); | ); |
| Tools.PostDebugMessage (string.Format ( | Tools.PostDebugMessage (string.Format ( |
| "{0}: Found {1} modules to check.", | "{0}: Found {1} modules to check.", |
| this.GetType ().Name, | this.GetType ().Name, |
| types.Count () | types.Count () |
| )); | )); |
| foreach (var voidType in types) | foreach (var voidType in types) |
| { | { |
| if (!HighLogic.LoadedSceneIsEditor && | |
| typeof(IVOID_EditorModule).IsAssignableFrom(voidType) | |
| ) | |
| { | |
| continue; | |
| } | |
| Tools.PostDebugMessage (string.Format ( | Tools.PostDebugMessage (string.Format ( |
| "{0}: found Type {1}", | "{0}: found Type {1}", |
| this.GetType ().Name, | this.GetType ().Name, |
| voidType.Name | voidType.Name |
| )); | )); |
| this.LoadModule(voidType); | this.LoadModule(voidType); |
| } | } |
| this._modulesLoaded = true; | this._modulesLoaded = true; |
| Tools.PostDebugMessage (string.Format ("VOID_Core: Loaded {0} modules.", this.Modules.Count)); | Tools.PostDebugMessage(string.Format( |
| "{0}: Loaded {1} modules.", | |
| this.GetType().Name, | |
| this.Modules.Count | |
| )); | |
| } | } |
| protected void LoadModule(Type T) | protected void LoadModule(Type T) |
| { | { |
| var existingModules = this._modules.Where (mod => mod.GetType ().Name == T.Name); | var existingModules = this._modules.Where (mod => mod.GetType ().Name == T.Name); |
| if (existingModules.Any()) | if (existingModules.Any()) |
| { | { |
| Tools.PostDebugMessage(string.Format( | Tools.PostDebugMessage(string.Format( |
| "{0}: refusing to load {1}: already loaded", | "{0}: refusing to load {1}: already loaded", |
| this.GetType().Name, | this.GetType().Name, |
| T.Name | T.Name |
| )); | )); |
| return; | return; |
| } | } |
| IVOID_Module module = Activator.CreateInstance (T) as IVOID_Module; | IVOID_Module module = Activator.CreateInstance (T) as IVOID_Module; |
| module.LoadConfig(); | module.LoadConfig(); |
| this._modules.Add (module); | this._modules.Add (module); |
| Tools.PostDebugMessage(string.Format( | Tools.PostDebugMessage(string.Format( |
| "{0}: loaded module {1}.", | "{0}: loaded module {1}.", |
| this.GetType().Name, | this.GetType().Name, |
| T.Name | T.Name |
| )); | )); |
| } | } |
| protected void Preload_BeforeUpdate() | |
| { | |
| if (!this.bodiesLoaded) | |
| { | |
| this.LoadAllBodies(); | |
| } | |
| if (!this.vesselTypesLoaded) | |
| { | |
| this.LoadVesselTypes(); | |
| } | |
| } | |
| public void Update() | public void Update() |
| { | { |
| this.saveTimer += Time.deltaTime; | this.Preload_BeforeUpdate (); |
| if (!this.guiRunning) | if (!this.guiRunning) |
| { | { |
| this.StartGUI (); | this.StartGUI (); |
| } | } |
| if (!HighLogic.LoadedSceneIsFlight && this.guiRunning) | if (!HighLogic.LoadedSceneIsFlight && this.guiRunning) |
| { | { |
| this.StopGUI (); | this.StopGUI (); |
| } | } |
| foreach (IVOID_Module module in this.Modules) | foreach (IVOID_Module module in this.Modules) |
| { | { |
| if (!module.guiRunning && module.toggleActive) | if (!module.guiRunning && module.toggleActive) |
| { | { |
| module.StartGUI (); | module.StartGUI (); |
| } | } |
| if (module.guiRunning && !module.toggleActive || !this.togglePower || !HighLogic.LoadedSceneIsFlight) | if (module.guiRunning && !module.toggleActive || |
| !this.togglePower || | |
| !HighLogic.LoadedSceneIsFlight | |
| || this.factoryReset | |
| ) | |
| { | { |
| module.StopGUI(); | module.StopGUI(); |
| } | } |
| } | |
| if (module is IVOID_BehaviorModule) | |
| if (this.saveTimer > 2f) | { |
| { | ((IVOID_BehaviorModule)module).Update(); |
| this.SaveConfig (); | } |
| this.saveTimer = 0; | } |
| } | |
| this.CheckAndSave (); | |
| } | } |
| public void FixedUpdate() | public void FixedUpdate() |
| { | { |
| if (this.consumeResource && | if (this.consumeResource && |
| this.vessel.vesselType != VesselType.EVA && | this.vessel.vesselType != VesselType.EVA && |
| TimeWarp.deltaTime != 0 | TimeWarp.deltaTime != 0 |
| ) | ) |
| { | { |
| float powerReceived = this.vessel.rootPart.RequestResource(this.resourceName, | float powerReceived = this.vessel.rootPart.RequestResource(this.resourceName, |
| this.resourceRate * TimeWarp.fixedDeltaTime); | this.resourceRate * TimeWarp.fixedDeltaTime); |
| if (powerReceived > 0) | if (powerReceived > 0) |
| { | { |
| this.powerAvailable = true; | this.powerAvailable = true; |
| } | } |
| else | else |
| { | { |
| this.powerAvailable = false; | this.powerAvailable = false; |
| } | } |
| } | } |
| foreach (IVOID_BehaviorModule module in | |
| this._modules.OfType<IVOID_BehaviorModule>().Where(m => !m.GetType().IsAbstract)) | |
| { | |
| module.FixedUpdate(); | |
| } | |
| } | |
| protected void LoadSkins() | |
| { | |
| this.skin_list = AssetBase.FindObjectsOfTypeIncludingAssets(typeof(GUISkin)) | |
| .Where(s => !this.forbiddenSkins.Contains(s.name)) | |
| .Select(s => s as GUISkin) | |
| .ToList(); | |
| Tools.PostDebugMessage(string.Format( | |
| "{0}: loaded {1} GUISkins.", | |
| this.GetType().Name, | |
| this.skin_list.Count | |
| )); | |
| if (this._skinIdx == int.MinValue) | |
| { | |
| this._skinIdx = this.skin_list.IndexOf(this.Skin); | |
| Tools.PostDebugMessage(string.Format( | |
| "{0}: resetting _skinIdx to default.", | |
| this.GetType().Name | |
| )); | |
| } | |
| Tools.PostDebugMessage(string.Format( | |
| "{0}: _skinIdx = {1}.", | |
| this.GetType().Name, | |
| this._skinIdx.ToString() | |
| )); | |
| this.skinsLoaded = true; | |
| } | } |
| protected void LoadGUIStyles() | protected void LoadGUIStyles() |
| { | { |
| this.LabelStyles["center"] = new GUIStyle(GUI.skin.label); | this.LabelStyles["center"] = new GUIStyle(GUI.skin.label); |
| this.LabelStyles["center"].normal.textColor = Color.white; | this.LabelStyles["center"].normal.textColor = Color.white; |
| this.LabelStyles["center"].alignment = TextAnchor.UpperCenter; | this.LabelStyles["center"].alignment = TextAnchor.UpperCenter; |
| this.LabelStyles["center_bold"] = new GUIStyle(GUI.skin.label); | this.LabelStyles["center_bold"] = new GUIStyle(GUI.skin.label); |
| this.LabelStyles["center_bold"].normal.textColor = Color.white; | this.LabelStyles["center_bold"].normal.textColor = Color.white; |
| this.LabelStyles["center_bold"].alignment = TextAnchor.UpperCenter; | this.LabelStyles["center_bold"].alignment = TextAnchor.UpperCenter; |
| this.LabelStyles["center_bold"].fontStyle = FontStyle.Bold; | this.LabelStyles["center_bold"].fontStyle = FontStyle.Bold; |
| this.LabelStyles["txt_right"] = new GUIStyle(GUI.skin.label); | this.LabelStyles["txt_right"] = new GUIStyle(GUI.skin.label); |
| this.LabelStyles["txt_right"].normal.textColor = Color.white; | this.LabelStyles["txt_right"].normal.textColor = Color.white; |
| this.LabelStyles["txt_right"].alignment = TextAnchor.UpperRight; | this.LabelStyles["txt_right"].alignment = TextAnchor.UpperRight; |
| this.GUIStylesLoaded = true; | this.GUIStylesLoaded = true; |
| } | } |
| protected void LoadAllBodies() | |
| { | |
| this._allBodies = FlightGlobals.Bodies; | |
| this.bodiesLoaded = true; | |
| } | |
| protected void LoadVesselTypes() | |
| { | |
| this._allVesselTypes = Enum.GetValues(typeof(VesselType)).OfType<VesselType>().ToList(); | |
| this.vesselTypesLoaded = true; | |
| } | |
| protected void CheckAndSave() | |
| { | |
| this.saveTimer += Time.deltaTime; | |
| Tools.PostDebugMessage (string.Format ( | |
| "{0}: Checking if time to save; saveTimer: {1}", | |
| this.GetType ().Name, | |
| this.saveTimer | |
| )); | |
| if (this.saveTimer > 2f) | |
| { | |
| Tools.PostDebugMessage (string.Format ( | |
| "{0}: Time to save, checking if configDirty: {1}", | |
| this.GetType ().Name, | |
| this.configDirty | |
| )); | |
| if (!this.configDirty) | |
| { | |
| return; | |
| } | |
| this.SaveConfig (); | |
| this.saveTimer = 0; | |
| } | |
| } | |
| public void VOIDMainWindow(int _) | public void VOIDMainWindow(int _) |
| { | { |
| GUILayout.BeginVertical(); | GUILayout.BeginVertical(); |
| if (this.powerAvailable) | if (this.powerAvailable || HighLogic.LoadedSceneIsEditor) |
| { | { |
| string str = "ON"; | if (!HighLogic.LoadedSceneIsEditor) |
| if (togglePower) str = "OFF"; | { |
| if (GUILayout.Button("Power " + str)) togglePower = !togglePower; | string str = "ON"; |
| if (togglePower) | if (togglePower) str = "OFF"; |
| if (GUILayout.Button("Power " + str)) togglePower = !togglePower; | |
| } | |
| if (togglePower || HighLogic.LoadedSceneIsEditor) | |
| { | { |
| foreach (IVOID_Module module in this.Modules) | foreach (IVOID_Module module in this.Modules) |
| { | { |
| module.toggleActive = GUILayout.Toggle (module.toggleActive, module.Name); | module.toggleActive = GUILayout.Toggle (module.toggleActive, module.Name); |
| } | } |
| } | } |
| } | } |
| else | else |
| { | { |
| GUIStyle label_txt_red = new GUIStyle(GUI.skin.label); | GUIStyle label_txt_red = new GUIStyle(GUI.skin.label); |
| label_txt_red.normal.textColor = Color.red; | label_txt_red.normal.textColor = Color.red; |
| label_txt_red.alignment = TextAnchor.MiddleCenter; | label_txt_red.alignment = TextAnchor.MiddleCenter; |
| GUILayout.Label("-- POWER LOST --", label_txt_red); | GUILayout.Label("-- POWER LOST --", label_txt_red); |
| } | } |
| this.configWindowMinimized = !GUILayout.Toggle (!this.configWindowMinimized, "Configuration"); | this.configWindowMinimized = !GUILayout.Toggle (!this.configWindowMinimized, "Configuration"); |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| GUI.DragWindow(); | GUI.DragWindow(); |
| } | } |
| public void VOIDConfigWindow(int _) | public void VOIDConfigWindow(int _) |
| { | { |
| GUILayout.BeginVertical (); | GUILayout.BeginVertical (); |
| this.DrawConfigurables (); | this.DrawConfigurables (); |
| GUILayout.EndVertical (); | GUILayout.EndVertical (); |
| GUI.DragWindow (); | GUI.DragWindow (); |
| } | } |
| public override void DrawConfigurables() | public override void DrawConfigurables() |
| { | { |
| this.consumeResource = GUILayout.Toggle (this.consumeResource, "Consume Resources"); | if (HighLogic.LoadedSceneIsFlight) |
| { | |
| this.consumeResource = GUILayout.Toggle (this.consumeResource, "Consume Resources"); | |
| this.VOIDIconLocked = GUILayout.Toggle (this.VOIDIconLocked, "Lock Icon Position"); | |
| } | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Skin:", GUILayout.ExpandWidth(false)); | |
| GUIContent _content = new GUIContent(); | |
| _content.text = "◄"; | |
| _content.tooltip = "Select previous skin"; | |
| if (GUILayout.Button(_content, GUILayout.ExpandWidth(true))) | |
| { | |
| this._skinIdx--; | |
| if (this._skinIdx < 0) this._skinIdx = skin_list.Count - 1; | |
| Tools.PostDebugMessage (string.Format ( | |
| "{0}: new this._skinIdx = {1} :: skin_list.Count = {2}", | |
| this.GetType().Name, | |
| this._skinIdx, | |
| this.skin_list.Count | |
| )); | |
| } | |
| string skin_name = skin_list[this._skinIdx].name; | |
| _content.text = skin_name; | |
| _content.tooltip = "Current skin"; | |
| GUILayout.Label(_content, this.LabelStyles["center"], GUILayout.ExpandWidth(true)); | |
| _content.text = "►"; | |
| _content.tooltip = "Select next skin"; | |
| if (GUILayout.Button(_content, GUILayout.ExpandWidth(true))) | |
| { | |
| this._skinIdx++; | |
| if (this._skinIdx >= skin_list.Count) this._skinIdx = 0; | |
| Tools.PostDebugMessage (string.Format ( | |
| "{0}: new this._skinIdx = {1} :: skin_list.Count = {2}", | |
| this.GetType().Name, | |
| this._skinIdx, | |
| this.skin_list.Count | |
| )); | |
| } | |
| if (this.Skin.name != this.defaultSkin) | |
| { | |
| this.defaultSkin = this.Skin.name; | |
| } | |
| GUILayout.EndHorizontal(); | |
| foreach (IVOID_Module mod in this.Modules) | foreach (IVOID_Module mod in this.Modules) |
| { | { |
| mod.DrawConfigurables (); | mod.DrawConfigurables (); |
| } | } |
| this._factoryReset = GUILayout.Toggle (this._factoryReset, "Factory Reset"); | |
| } | |
| public void OnGUI() | |
| { | |
| if (Event.current.type == EventType.Repaint) | |
| { | |
| return; | |
| } | |
| Tools.PostDebugMessage(string.Format( | |
| "Event.current.type: {0}" + | |
| "\nthis.VOIDIconLocked: {1}" + | |
| "\nEvent.current.mousePosition: {2}" + | |
| "\nVOIDIconPos: ({3}, {4}),({5}, {6})", | |
| Event.current.type, | |
| this.VOIDIconLocked, | |
| Event.current.mousePosition, | |
| this.VOIDIconPos.value.xMin, | |
| this.VOIDIconPos.value.yMin, | |
| this.VOIDIconPos.value.xMax, | |
| this.VOIDIconPos.value.yMax | |
| )); | |
| if (!this.VOIDIconLocked && | |
| VOIDIconPos.value.Contains(Event.current.mousePosition) | |
| && Event.current.type == EventType.mouseDrag | |
| ) | |
| { | |
| Tools.PostDebugMessage(string.Format( | |
| "Event.current.type: {0}" + | |
| "\ndelta.x: {1}; delta.y: {2}", | |
| Event.current.type, | |
| Event.current.delta.x, | |
| Event.current.delta.y | |
| )); | |
| Rect tmp = new Rect(VOIDIconPos); | |
| tmp.x = Event.current.mousePosition.x - tmp.width / 2; | |
| tmp.y = Event.current.mousePosition.y - tmp.height / 2; | |
| if (tmp.x > Screen.width - tmp.width) | |
| { | |
| tmp.x = Screen.width - tmp.width; | |
| } | |
| if (tmp.y > Screen.height - tmp.height) | |
| { | |
| tmp.y = Screen.height - tmp.height; | |
| } | |
| VOIDIconPos = tmp; | |
| } | |
| } | } |
| public override void DrawGUI() | public override void DrawGUI() |
| { | { |
| if (!this._modulesLoaded) | if (!this._modulesLoaded) |
| { | { |
| this.LoadModules (); | this.LoadModulesOfType<IVOID_Module> (); |
| } | } |
| this._windowID = this.windowBaseID; | this._windowID = this.windowBaseID; |
| if (!this.skinsLoaded) | |
| { | |
| this.LoadSkins(); | |
| } | |
| GUI.skin = this.Skin; | GUI.skin = this.Skin; |
| if (!this.GUIStylesLoaded) | if (!this.GUIStylesLoaded) |
| { | { |
| this.LoadGUIStyles (); | this.LoadGUIStyles (); |
| } | } |
| this.VOIDIconTexture = this.VOIDIconOff; //icon off default | this.VOIDIconTexture = this.VOIDIconOff; //icon off default |
| if (this.togglePower) this.VOIDIconTexture = this.VOIDIconOn; //or on if power_toggle==true | if (this.togglePower) this.VOIDIconTexture = this.VOIDIconOn; //or on if power_toggle==true |
| if (GUI.Button(new Rect(VOIDIconPos), VOIDIconTexture, new GUIStyle())) | if (GUI.Button(VOIDIconPos, VOIDIconTexture, new GUIStyle()) && this.VOIDIconLocked) |
| { | { |
| this.mainGuiMinimized = !this.mainGuiMinimized; | this.mainGuiMinimized = !this.mainGuiMinimized; |
| } | } |
| if (!this.mainGuiMinimized) | if (!this.mainGuiMinimized) |
| { | { |
| Rect _mainWindowPos = this.mainWindowPos; | Rect _mainWindowPos = this.mainWindowPos; |
| _mainWindowPos = GUILayout.Window ( | _mainWindowPos = GUILayout.Window ( |
| this.windowID, | this.windowID, |
| _mainWindowPos, | _mainWindowPos, |
| this.VOIDMainWindow, | this.VOIDMainWindow, |
| string.Join (" ", new string[] {this.VoidName, this.VoidVersion}), | string.Join (" ", new string[] {this.VoidName, this.VoidVersion}), |
| GUILayout.Width (250), | GUILayout.Width (250), |
| GUILayout.Height (50) | GUILayout.Height (50) |
| ); | ); |
| _mainWindowPos = Tools.ClampRectToScreen (_mainWindowPos); | |
| if (_mainWindowPos != this.mainWindowPos) | if (_mainWindowPos != this.mainWindowPos) |
| { | { |
| this.mainWindowPos = _mainWindowPos; | this.mainWindowPos = _mainWindowPos; |
| } | } |
| } | } |
| if (!this.configWindowMinimized) | if (!this.configWindowMinimized) |
| { | { |
| Rect _configWindowPos = this.configWindowPos; | Rect _configWindowPos = this.configWindowPos; |
| _configWindowPos = GUILayout.Window ( | _configWindowPos = GUILayout.Window ( |
| this.windowID, | this.windowID, |
| _configWindowPos, | _configWindowPos, |
| this.VOIDConfigWindow, | this.VOIDConfigWindow, |
| string.Join (" ", new string[] {this.VoidName, "Configuration"}), | string.Join (" ", new string[] {this.VoidName, "Configuration"}), |
| GUILayout.Width (250), | GUILayout.Width (250), |
| GUILayout.Height (50) | GUILayout.Height (50) |
| ); | ); |
| _configWindowPos = Tools.ClampRectToScreen (_configWindowPos); | |
| if (_configWindowPos != this.configWindowPos) | if (_configWindowPos != this.configWindowPos) |
| { | { |
| this.configWindowPos = _configWindowPos; | this.configWindowPos = _configWindowPos; |
| } | } |
| } | } |
| } | } |
| public override void LoadConfig() | public override void LoadConfig() |
| { | { |
| base.LoadConfig (); | base.LoadConfig (); |
| foreach (IVOID_Module module in this.Modules) | foreach (IVOID_Module module in this.Modules) |
| { | { |
| module.LoadConfig (); | module.LoadConfig (); |
| } | } |
| } | } |
| public void SaveConfig() | public void SaveConfig() |
| { | { |
| if (!this.configDirty) | |
| { | |
| return; | |
| } | |
| var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> (); | var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> (); |
| config.load (); | config.load (); |
| this._SaveToConfig(config); | this._SaveToConfig(config); |
| foreach (IVOID_Module module in this.Modules) | foreach (IVOID_Module module in this.Modules) |
| { | { |
| module._SaveToConfig (config); | module._SaveToConfig (config); |
| } | } |
| config.save(); | config.save(); |
| this.configDirty = false; | this.configDirty = false; |
| } | } |
| } | } |
| } | } |
| // | |
| // VOID_Orbital.cs | |
| // | |
| // Author: | |
| // toadicus <> | |
| // | |
| // Copyright (c) 2013 toadicus | |
| // | |
| // This program is free software: you can redistribute it and/or modify | |
| // it under the terms of the GNU General Public License as published by | |
| // the Free Software Foundation, either version 3 of the License, or | |
| // (at your option) any later version. | |
| // | |
| // This program is distributed in the hope that it will be useful, | |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| // GNU General Public License for more details. | |
| // | |
| // You should have received a copy of the GNU General Public License | |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| using KSP; | |
| using System; | |
| using System.Collections.Generic; | |
| using UnityEngine; | |
| namespace VOID | |
| { | |
| public class VOID_DataLogger : VOID_WindowModule, IVOID_BehaviorModule | |
| { | |
| /* | |
| * Fields | |
| * */ | |
| protected bool stopwatch1_running = false; | |
| protected bool csv_logging = false; | |
| protected bool first_write = true; | |
| protected double stopwatch1 = 0; | |
| protected string csv_log_interval_str = "0.5"; | |
| protected float csv_log_interval; | |
| protected double csvWriteTimer = 0; | |
| protected double csvCollectTimer = 0; | |
| protected List<string> csvList = new List<string>(); | |
| /* | |
| * Properties | |
| * */ | |
| /* | |
| * Methods | |
| * */ | |
| public VOID_DataLogger() | |
| { | |
| this._Name = "CSV Data Logger"; | |
| this.WindowPos.x = Screen.width - 520; | |
| this.WindowPos.y = 85; | |
| } | |
| public override void ModuleWindow(int _) | |
| { | |
| GUIStyle txt_white = new GUIStyle(GUI.skin.label); | |
| txt_white.normal.textColor = txt_white.focused.textColor = Color.white; | |
| txt_white.alignment = TextAnchor.UpperRight; | |
| GUIStyle txt_green = new GUIStyle(GUI.skin.label); | |
| txt_green.normal.textColor = txt_green.focused.textColor = Color.green; | |
| txt_green.alignment = TextAnchor.UpperRight; | |
| GUIStyle txt_yellow = new GUIStyle(GUI.skin.label); | |
| txt_yellow.normal.textColor = txt_yellow.focused.textColor = Color.yellow; | |
| txt_yellow.alignment = TextAnchor.UpperRight; | |
| GUILayout.BeginVertical(); | |
| GUILayout.Label("System time: " + DateTime.Now.ToString("HH:mm:ss")); | |
| GUILayout.Label(Tools.ConvertInterval(stopwatch1)); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| if (GUILayout.Button("Start")) | |
| { | |
| if (stopwatch1_running == false) stopwatch1_running = true; | |
| } | |
| if (GUILayout.Button("Stop")) | |
| { | |
| if (stopwatch1_running == true) stopwatch1_running = false; | |
| } | |
| if (GUILayout.Button("Reset")) | |
| { | |
| if (stopwatch1_running == true) stopwatch1_running = false; | |
| stopwatch1 = 0; | |
| } | |
| GUILayout.EndHorizontal(); | |
| GUIStyle label_style = txt_white; | |
| string log_label = "Inactive"; | |
| if (csv_logging && vessel.situation.ToString() == "PRELAUNCH") | |
| { | |
| log_label = "Awaiting launch"; | |
| label_style = txt_yellow; | |
| } | |
| if (csv_logging && vessel.situation.ToString() != "PRELAUNCH") | |
| { | |
| log_label = "Active"; | |
| label_style = txt_green; | |
| } | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| csv_logging = GUILayout.Toggle(csv_logging, "Data logging: ", GUILayout.ExpandWidth(false)); | |
| GUILayout.Label(log_label, label_style, GUILayout.ExpandWidth(true)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Interval: ", GUILayout.ExpandWidth(false)); | |
| csv_log_interval_str = GUILayout.TextField(csv_log_interval_str, GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| float new_log_interval; | |
| if (Single.TryParse(csv_log_interval_str, out new_log_interval)) csv_log_interval = new_log_interval; | |
| GUILayout.EndVertical(); | |
| GUI.DragWindow(); | |
| } | |
| public void Update() | |
| { | |
| // CSV Logging | |
| // from ISA MapSat | |
| if (csv_logging) | |
| { | |
| //data logging is on | |
| //increment timers | |
| csvWriteTimer += Time.deltaTime; | |
| csvCollectTimer += Time.deltaTime; | |
| if (csvCollectTimer >= csv_log_interval && vessel.situation != Vessel.Situations.PRELAUNCH) | |
| { | |
| //data logging is on, vessel is not prelaunch, and interval has passed | |
| //write a line to the list | |
| line_to_csvList(); //write to the csv | |
| } | |
| if (csvList.Count != 0 && csvWriteTimer >= 15f) | |
| { | |
| // csvList is not empty and interval between writings to file has elapsed | |
| //write it | |
| string[] csvData; | |
| csvData = (string[])csvList.ToArray(); | |
| Innsewerants_writeData(csvData); | |
| csvList.Clear(); | |
| csvWriteTimer = 0f; | |
| } | |
| } | |
| else | |
| { | |
| //data logging is off | |
| //reset any timers and clear anything from csvList | |
| csvWriteTimer = 0f; | |
| csvCollectTimer = 0f; | |
| if (csvList.Count > 0) csvList.Clear(); | |
| } | |
| if (stopwatch1_running) | |
| { | |
| stopwatch1 += Time.deltaTime; | |
| } | |
| } | |
| public void FixedUpdate() {} | |
| private void Innsewerants_writeData(string[] csvArray) | |
| { | |
| var efile = KSP.IO.File.AppendText<VOID_Core>(vessel.vesselName + "_data.csv", null); | |
| foreach (string line in csvArray) | |
| { | |
| efile.Write(line); | |
| } | |
| efile.Close(); | |
| } | |
| private void line_to_csvList() | |
| { | |
| //called if logging is on and interval has passed | |
| //writes one line to the csvList | |
| string line = ""; | |
| if (first_write && !KSP.IO.File.Exists<VOID_Core>(vessel.vesselName + "_data.csv", null)) | |
| { | |
| first_write = false; | |
| line += "Mission Elapsed Time (s);Altitude ASL (m);Altitude above terrain (m);Orbital Velocity (m/s);Surface Velocity (m/s);Vertical Speed (m/s);Horizontal Speed (m/s);Gee Force (gees);Temperature (°C);Gravity (m/s²);Atmosphere Density (g/m³);\n"; | |
| } | |
| //Mission time | |
| line += vessel.missionTime.ToString("F3") + ";"; | |
| //Altitude ASL | |
| line += vessel.orbit.altitude.ToString("F3") + ";"; | |
| //Altitude (true) | |
| double alt_true = vessel.orbit.altitude - vessel.terrainAltitude; | |
| if (vessel.terrainAltitude < 0) alt_true = vessel.orbit.altitude; | |
| line += alt_true.ToString("F3") + ";"; | |
| //Orbital velocity | |
| line += vessel.orbit.vel.magnitude.ToString("F3") + ";"; | |
| //surface velocity | |
| line += vessel.srf_velocity.magnitude.ToString("F3") + ";"; | |
| //vertical speed | |
| line += vessel.verticalSpeed.ToString("F3") + ";"; | |
| //horizontal speed | |
| line += vessel.horizontalSrfSpeed.ToString("F3") + ";"; | |
| //gee force | |
| line += vessel.geeForce.ToString("F3") + ";"; | |
| //temperature | |
| line += vessel.flightIntegrator.getExternalTemperature().ToString("F2") + ";"; | |
| //gravity | |
| double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass()); | |
| double g_vessel = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2); | |
| line += g_vessel.ToString("F3") + ";"; | |
| //atm density | |
| line += (vessel.atmDensity * 1000).ToString("F3") + ";"; | |
| line += "\n"; | |
| if (csvList.Contains(line) == false) csvList.Add(line); | |
| csvCollectTimer = 0f; | |
| } | |
| } | |
| } |
| // | |
| // VOID_EditorCore.cs | |
| // | |
| // Author: | |
| // toadicus <> | |
| // | |
| // Copyright (c) 2013 toadicus | |
| // | |
| // This program is free software: you can redistribute it and/or modify | |
| // it under the terms of the GNU General Public License as published by | |
| // the Free Software Foundation, either version 3 of the License, or | |
| // (at your option) any later version. | |
| // | |
| // This program is distributed in the hope that it will be useful, | |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| // GNU General Public License for more details. | |
| // | |
| // You should have received a copy of the GNU General Public License | |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| using Engineer.VesselSimulator; | |
| using KSP; | |
| using System; | |
| using System.Collections.Generic; | |
| using System.Linq; | |
| using UnityEngine; | |
| namespace VOID | |
| { | |
| public class VOID_EditorCore : VOID_Core | |
| { | |
| /* | |
| * Static Members | |
| * */ | |
| protected new static bool _initialized = false; | |
| public new static bool Initialized | |
| { | |
| get | |
| { | |
| return _initialized; | |
| } | |
| } | |
| protected new static VOID_EditorCore _instance; | |
| public new static VOID_EditorCore Instance | |
| { | |
| get | |
| { | |
| if (_instance == null) | |
| { | |
| _instance = new VOID_EditorCore(); | |
| _initialized = true; | |
| } | |
| return _instance; | |
| } | |
| } | |
| public new static void Reset() | |
| { | |
| if (_initialized) | |
| { | |
| _instance.StopGUI(); | |
| _instance = null; | |
| _initialized = false; | |
| } | |
| } | |
| public VOID_EditorCore() : base() | |
| { | |
| this._Name = "VOID Editor Core"; | |
| } | |
| public new void OnGUI() {} | |
| public override void DrawGUI() | |
| { | |
| if (!this._modulesLoaded) | |
| { | |
| this.LoadModulesOfType<IVOID_EditorModule>(); | |
| } | |
| Rect _iconPos = Tools.DockToWindow (this.VOIDIconPos, this.mainWindowPos); | |
| _iconPos = Tools.ClampRectToScreen (_iconPos, (int)_iconPos.width, (int)_iconPos.height); | |
| if (_iconPos != this.VOIDIconPos) | |
| { | |
| this.VOIDIconPos = _iconPos; | |
| } | |
| base.DrawGUI(); | |
| } | |
| public new void Update() | |
| { | |
| foreach (IVOID_EditorModule module in this.Modules) | |
| { | |
| if (EditorLogic.startPod == null) | |
| { | |
| module.StopGUI(); | |
| continue; | |
| } | |
| if (HighLogic.LoadedSceneIsEditor && module.toggleActive && EditorLogic.SortedShipList.Any()) | |
| { | |
| module.StartGUI(); | |
| } | |
| if (!HighLogic.LoadedSceneIsEditor || !module.toggleActive || !EditorLogic.SortedShipList.Any()) | |
| { | |
| module.StopGUI(); | |
| } | |
| } | |
| if (EditorLogic.startPod == null || !HighLogic.LoadedSceneIsEditor) | |
| { | |
| this.StopGUI(); | |
| return; | |
| } | |
| else if (!this.guiRunning && HighLogic.LoadedSceneIsEditor) | |
| { | |
| this.StartGUI(); | |
| } | |
| if (EditorLogic.SortedShipList.Count > 0) | |
| { | |
| SimManager.Instance.Gravity = 9.08665; | |
| SimManager.Instance.TryStartSimulation(); | |
| } | |
| this.CheckAndSave (); | |
| } | |
| public new void FixedUpdate() {} | |
| } | |
| } | |
| // | |
| // VOID_Hud.cs | |
| // | |
| // Author: | |
| // toadicus <> | |
| // | |
| // Copyright (c) 2013 toadicus | |
| // | |
| // This program is free software: you can redistribute it and/or modify | |
| // it under the terms of the GNU General Public License as published by | |
| // the Free Software Foundation, either version 3 of the License, or | |
| // (at your option) any later version. | |
| // | |
| // This program is distributed in the hope that it will be useful, | |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| // GNU General Public License for more details. | |
| // | |
| // You should have received a copy of the GNU General Public License | |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| // | |
| using Engineer.VesselSimulator; | |
| using KSP; | |
| using System; | |
| using System.Collections.Generic; | |
| using UnityEngine; | |
| namespace VOID | |
| { | |
| public class VOID_EditorHUD : VOID_Module, IVOID_EditorModule | |
| { | |
| /* | |
| * Fields | |
| * */ | |
| [AVOID_SaveValue("colorIndex")] | |
| protected VOID_SaveValue<int> _colorIndex = 0; | |
| protected List<Color> textColors = new List<Color>(); | |
| protected GUIStyle labelStyle; | |
| /* | |
| * Properties | |
| * */ | |
| public int ColorIndex | |
| { | |
| get | |
| { | |
| return this._colorIndex; | |
| } | |
| set | |
| { | |
| if (this._colorIndex >= this.textColors.Count - 1) | |
| { | |
| this._colorIndex = 0; | |
| return; | |
| } | |
| this._colorIndex = value; | |
| } | |
| } | |
| /* | |
| * Methods | |
| * */ | |
| public VOID_EditorHUD() : base() | |
| { | |
| this._Name = "Heads-Up Display"; | |
| this._Active = true; | |
| this.textColors.Add(Color.green); | |
| this.textColors.Add(Color.black); | |
| this.textColors.Add(Color.white); | |
| this.textColors.Add(Color.red); | |
| this.textColors.Add(Color.blue); | |
| this.textColors.Add(Color.yellow); | |
| this.textColors.Add(Color.gray); | |
| this.textColors.Add(Color.cyan); | |
| this.textColors.Add(Color.magenta); | |
| this.labelStyle = new GUIStyle (); | |
| // this.labelStyle.alignment = TextAnchor.UpperRight; | |
| this.labelStyle.normal.textColor = this.textColors [this.ColorIndex]; | |
| Tools.PostDebugMessage (this.GetType().Name + ": Constructed."); | |
| } | |
| public override void DrawGUI() | |
| { | |
| SimManager.Instance.RequestSimulation(); | |
| if (SimManager.Instance.LastStage == null) | |
| { | |
| return; | |
| } | |
| float hudLeft; | |
| if (EditorLogic.fetch.editorScreen == EditorLogic.EditorScreen.Parts) | |
| { | |
| hudLeft = EditorPanels.Instance.partsPanelWidth + 10; | |
| } | |
| else if (EditorLogic.fetch.editorScreen == EditorLogic.EditorScreen.Actions) | |
| { | |
| hudLeft = EditorPanels.Instance.actionsPanelWidth + 10; | |
| } | |
| else | |
| { | |
| return; | |
| } | |
| Rect hudPos = new Rect (hudLeft, 48, 300, 32); | |
| // GUI.skin = AssetBase.GetGUISkin("KSP window 2"); | |
| labelStyle.normal.textColor = textColors [ColorIndex]; | |
| GUI.Label ( | |
| hudPos, | |
| "Total Mass: " + SimManager.Instance.LastStage.totalMass.ToString("F3") + "t" + | |
| " Part Count: " + EditorLogic.SortedShipList.Count + | |
| "\nTotal Delta-V: " + Tools.MuMech_ToSI(SimManager.Instance.LastStage.totalDeltaV) + "m/s" + | |
| "\nBottom Stage Delta-V: " + Tools.MuMech_ToSI(SimManager.Instance.LastStage.deltaV) + "m/s" + | |
| "\nBottom Stage T/W Ratio: " + SimManager.Instance.LastStage.thrustToWeight.ToString("F3"), | |
| labelStyle); | |
| } | |
| public override void DrawConfigurables() | |
| { | |
| if (GUILayout.Button ("Change HUD color", GUILayout.ExpandWidth (false))) | |
| { | |
| ++this.ColorIndex; | |
| } | |
| } | |
| } | |
| } | |
| // | // |
| // VOID_Hud.cs | // VOID_Hud.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| // | // |
| using KSP; | using KSP; |
| using UnityEngine; | using UnityEngine; |
| using System; | using System; |
| using System.Collections.Generic; | using System.Collections.Generic; |
| namespace VOID | namespace VOID |
| { | { |
| public class VOID_HUD : VOID_Module, IVOID_Module | public class VOID_HUD : VOID_Module, IVOID_Module |
| { | { |
| /* | /* |
| * Fields | * Fields |
| * */ | * */ |
| [AVOID_SaveValue("colorIndex")] | [AVOID_SaveValue("colorIndex")] |
| protected VOID_SaveValue<int> _colorIndex = 0; | protected VOID_SaveValue<int> _colorIndex = 0; |
| protected List<Color> textColors = new List<Color>(); | protected List<Color> textColors = new List<Color>(); |
| protected GUIStyle labelStyle; | protected GUIStyle labelStyle; |
| protected Vessel vessel = null; | |
| /* | /* |
| * Properties | * Properties |
| * */ | * */ |
| public int ColorIndex | public int ColorIndex |
| { | { |
| get | get |
| { | { |
| return this._colorIndex; | return this._colorIndex; |
| } | } |
| set | set |
| { | { |
| if (this._colorIndex >= this.textColors.Count - 1) | if (this._colorIndex >= this.textColors.Count - 1) |
| { | { |
| this._colorIndex = 0; | this._colorIndex = 0; |
| return; | return; |
| } | } |
| this._colorIndex = value; | this._colorIndex = value; |
| } | } |
| } | } |
| /* | /* |
| * Methods | * Methods |
| * */ | * */ |
| public VOID_HUD() : base() | public VOID_HUD() : base() |
| { | { |
| this._Name = "Heads-Up Display"; | this._Name = "Heads-Up Display"; |
| this._Active = true; | |
| this.textColors.Add(Color.green); | this.textColors.Add(Color.green); |
| this.textColors.Add(Color.black); | this.textColors.Add(Color.black); |
| this.textColors.Add(Color.white); | this.textColors.Add(Color.white); |
| this.textColors.Add(Color.red); | this.textColors.Add(Color.red); |
| this.textColors.Add(Color.blue); | this.textColors.Add(Color.blue); |
| this.textColors.Add(Color.yellow); | this.textColors.Add(Color.yellow); |
| this.textColors.Add(Color.gray); | this.textColors.Add(Color.gray); |
| this.textColors.Add(Color.cyan); | this.textColors.Add(Color.cyan); |
| this.textColors.Add(Color.magenta); | this.textColors.Add(Color.magenta); |
| this.labelStyle = new GUIStyle (); | this.labelStyle = new GUIStyle (); |
| this.labelStyle.normal.textColor = this.textColors [this.ColorIndex]; | this.labelStyle.normal.textColor = this.textColors [this.ColorIndex]; |
| Tools.PostDebugMessage ("VOID_HUD: Constructed."); | Tools.PostDebugMessage ("VOID_HUD: Constructed."); |
| } | } |
| public override void DrawGUI() | public override void DrawGUI() |
| { | { |
| GUI.skin = VOID_Core.Instance.Skin; | GUI.skin = VOID_Core.Instance.Skin; |
| if (vessel == null) | |
| { | |
| vessel = FlightGlobals.ActiveVessel; | |
| } | |
| if (vessel != FlightGlobals.ActiveVessel) | |
| { | |
| vessel = FlightGlobals.ActiveVessel; | |
| } | |
| if (VOID_Core.Instance.powerAvailable) | if (VOID_Core.Instance.powerAvailable) |
| { | { |
| labelStyle.normal.textColor = textColors [ColorIndex]; | labelStyle.normal.textColor = textColors [ColorIndex]; |
| GUI.Label ( | GUI.Label ( |
| new Rect ((Screen.width * .2083f), 0, 300f, 70f), | new Rect ((Screen.width * .2083f), 0, 300f, 70f), |
| "Obt Alt: " + Tools.MuMech_ToSI (vessel.orbit.altitude) + "m" + | "Obt Alt: " + Tools.MuMech_ToSI (vessel.orbit.altitude) + "m" + |
| " Obt Vel: " + Tools.MuMech_ToSI (vessel.orbit.vel.magnitude) + "m/s" + | " Obt Vel: " + Tools.MuMech_ToSI (vessel.orbit.vel.magnitude) + "m/s" + |
| "\nAp: " + Tools.MuMech_ToSI (vessel.orbit.ApA) + "m" + | "\nAp: " + Tools.MuMech_ToSI (vessel.orbit.ApA) + "m" + |
| " ETA " + Tools.ConvertInterval (vessel.orbit.timeToAp) + | " ETA " + Tools.ConvertInterval (vessel.orbit.timeToAp) + |
| "\nPe: " + Tools.MuMech_ToSI (vessel.orbit.PeA) + "m" + | "\nPe: " + Tools.MuMech_ToSI (vessel.orbit.PeA) + "m" + |
| " ETA " + Tools.ConvertInterval (vessel.orbit.timeToPe) + | " ETA " + Tools.ConvertInterval (vessel.orbit.timeToPe) + |
| "\nInc: " + vessel.orbit.inclination.ToString ("F3") + "°", | "\nInc: " + vessel.orbit.inclination.ToString ("F3") + "°", |
| labelStyle); | labelStyle); |
| // Toadicus edit: Added "Biome: " line to surf/atmo HUD | // Toadicus edit: Added "Biome: " line to surf/atmo HUD |
| GUI.Label ( | GUI.Label ( |
| new Rect ((Screen.width * .625f), 0, 300f, 90f), | new Rect ((Screen.width * .625f), 0, 300f, 90f), |
| "Srf Alt: " + Tools.MuMech_ToSI (Tools.TrueAltitude (vessel)) + "m" + | "Srf Alt: " + Tools.MuMech_ToSI (Tools.TrueAltitude (vessel)) + "m" + |
| " Srf Vel: " + Tools.MuMech_ToSI (vessel.srf_velocity.magnitude) + "m/s" + | " Srf Vel: " + Tools.MuMech_ToSI (vessel.srf_velocity.magnitude) + "m/s" + |
| "\nVer: " + Tools.MuMech_ToSI (vessel.verticalSpeed) + "m/s" + | "\nVer: " + Tools.MuMech_ToSI (vessel.verticalSpeed) + "m/s" + |
| " Hor: " + Tools.MuMech_ToSI (vessel.horizontalSrfSpeed) + "m/s" + | " Hor: " + Tools.MuMech_ToSI (vessel.horizontalSrfSpeed) + "m/s" + |
| "\nLat: " + Tools.GetLatitudeString (vessel, "F3") + | "\nLat: " + Tools.GetLatitudeString (vessel, "F3") + |
| " Lon: " + Tools.GetLongitudeString (vessel, "F3") + | " Lon: " + Tools.GetLongitudeString (vessel, "F3") + |
| "\nHdg: " + Tools.MuMech_get_heading (vessel).ToString ("F2") + "° " + | "\nHdg: " + Tools.MuMech_get_heading (vessel).ToString ("F2") + "° " + |
| Tools.get_heading_text (Tools.MuMech_get_heading (vessel)) + | Tools.get_heading_text (Tools.MuMech_get_heading (vessel)) + |
| "\nBiome: " + Tools.Toadicus_GetAtt (vessel).name, | "\nBiome: " + Tools.Toadicus_GetAtt (vessel).name, |
| labelStyle); | labelStyle); |
| } | } |
| else | else |
| { | { |
| labelStyle.normal.textColor = Color.red; | labelStyle.normal.textColor = Color.red; |
| GUI.Label (new Rect ((Screen.width * .2083f), 0, 300f, 70f), "-- POWER LOST --", labelStyle); | GUI.Label (new Rect ((Screen.width * .2083f), 0, 300f, 70f), "-- POWER LOST --", labelStyle); |
| GUI.Label (new Rect ((Screen.width * .625f), 0, 300f, 70f), "-- POWER LOST --", labelStyle); | GUI.Label (new Rect ((Screen.width * .625f), 0, 300f, 70f), "-- POWER LOST --", labelStyle); |
| } | } |
| } | } |
| public override void DrawConfigurables() | public override void DrawConfigurables() |
| { | { |
| if (GUILayout.Button ("Change HUD color", GUILayout.ExpandWidth (false))) | if (GUILayout.Button ("Change HUD color", GUILayout.ExpandWidth (false))) |
| { | { |
| ++this.ColorIndex; | ++this.ColorIndex; |
| } | } |
| } | } |
| } | } |
| } | } |
| // | // |
| // VOID_Module.cs | // VOID_Module.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| using System; | using System; |
| using System.Collections.Generic; | using System.Collections.Generic; |
| using System.Linq; | using System.Linq; |
| using System.Reflection; | using System.Reflection; |
| using UnityEngine; | using UnityEngine; |
| namespace VOID | namespace VOID |
| { | { |
| public abstract class VOID_Module : IVOID_Module | public abstract class VOID_Module : IVOID_Module |
| { | { |
| /* | /* |
| * Fields | * Fields |
| * */ | * */ |
| [AVOID_SaveValue("Active")] | [AVOID_SaveValue("Active")] |
| protected VOID_SaveValue<bool> _Active = true; | protected VOID_SaveValue<bool> _Active = false; |
| protected bool _Running = false; | protected bool _Running = false; |
| protected string _Name; | protected string _Name; |
| /* | /* |
| * Properties | * Properties |
| * */ | * */ |
| public virtual bool toggleActive | public virtual bool toggleActive |
| { | { |
| get | get |
| { | { |
| return this._Active; | return this._Active; |
| } | } |
| set | set |
| { | { |
| this._Active = value; | this._Active = value; |
| } | } |
| } | } |
| public virtual bool guiRunning | public virtual bool guiRunning |
| { | { |
| get | get |
| { | { |
| return this._Running; | return this._Running; |
| } | } |
| } | } |
| public virtual string Name | public virtual string Name |
| { | { |
| get | get |
| { | { |
| return this._Name; | return this._Name; |
| } | } |
| } | } |
| public virtual Vessel vessel | public virtual Vessel vessel |
| { | { |
| get | get |
| { | { |
| return FlightGlobals.ActiveVessel; | return FlightGlobals.ActiveVessel; |
| } | } |
| } | } |
| /* | /* |
| * Methods | * Methods |
| * */ | * */ |
| public void StartGUI() | public void StartGUI() |
| { | { |
| if (!this.toggleActive) | if (!this.toggleActive || this.guiRunning) |
| { | { |
| return; | return; |
| } | } |
| Tools.PostDebugMessage (string.Format("Adding {0} to the draw queue.", this.GetType().Name)); | Tools.PostDebugMessage (string.Format("Adding {0} to the draw queue.", this.GetType().Name)); |
| RenderingManager.AddToPostDrawQueue (3, this.DrawGUI); | RenderingManager.AddToPostDrawQueue (3, this.DrawGUI); |
| this._Running = true; | this._Running = true; |
| } | } |
| public void StopGUI() | public void StopGUI() |
| { | { |
| if (!this.guiRunning) | |
| { | |
| return; | |
| } | |
| Tools.PostDebugMessage (string.Format("Removing {0} from the draw queue.", this.GetType().Name)); | Tools.PostDebugMessage (string.Format("Removing {0} from the draw queue.", this.GetType().Name)); |
| RenderingManager.RemoveFromPostDrawQueue (3, this.DrawGUI); | RenderingManager.RemoveFromPostDrawQueue (3, this.DrawGUI); |
| this._Running = false; | this._Running = false; |
| } | } |
| public abstract void DrawGUI(); | public abstract void DrawGUI(); |
| public virtual void DrawConfigurables() {} | public virtual void DrawConfigurables() {} |
| public virtual void LoadConfig() | public virtual void LoadConfig() |
| { | { |
| var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> (); | var config = KSP.IO.PluginConfiguration.CreateForType<VOID_Core> (); |
| config.load (); | config.load (); |
| foreach (var field in this.GetType().GetFields( | foreach (var field in this.GetType().GetFields( |
| BindingFlags.NonPublic | | BindingFlags.NonPublic | |
| BindingFlags.Public | | BindingFlags.Public | |
| BindingFlags.Instance | | BindingFlags.Instance | |
| BindingFlags.FlattenHierarchy | BindingFlags.FlattenHierarchy |
| )) | )) |
| { | { |
| object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false); | object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false); |
| if (attrs.Length == 0) { | if (attrs.Length == 0) { |
| continue; | continue; |
| } | } |
| AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue; | AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue; |
| string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name); | string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name); |
| object fieldValue = field.GetValue(this); | object fieldValue = field.GetValue(this); |
| bool convertBack = false; | bool convertBack = false; |
| if (fieldValue is IVOID_SaveValue) | if (fieldValue is IVOID_SaveValue) |
| { | { |
| fieldValue = (fieldValue as IVOID_SaveValue).AsType; | fieldValue = (fieldValue as IVOID_SaveValue).AsType; |
| convertBack = true; | convertBack = true; |
| } | } |
| fieldValue = config.GetValue(fieldName, fieldValue); | fieldValue = config.GetValue(fieldName, fieldValue); |
| if (convertBack) | if (convertBack) |
| { | { |
| Type type = typeof(VOID_SaveValue<>).MakeGenericType (fieldValue.GetType ()); | Type type = typeof(VOID_SaveValue<>).MakeGenericType (fieldValue.GetType ()); |
| IVOID_SaveValue convertValue = Activator.CreateInstance (type) as IVOID_SaveValue; | IVOID_SaveValue convertValue = Activator.CreateInstance (type) as IVOID_SaveValue; |
| convertValue.SetValue (fieldValue); | convertValue.SetValue (fieldValue); |
| fieldValue = convertValue; | fieldValue = convertValue; |
| } | } |
| field.SetValue (this, fieldValue); | field.SetValue (this, fieldValue); |
| Tools.PostDebugMessage(string.Format("{0}: Loaded field {1}.", this.GetType().Name, fieldName)); | Tools.PostDebugMessage(string.Format("{0}: Loaded field {1}.", this.GetType().Name, fieldName)); |
| } | } |
| } | } |
| public virtual void _SaveToConfig(KSP.IO.PluginConfiguration config) | public virtual void _SaveToConfig(KSP.IO.PluginConfiguration config) |
| { | { |
| foreach (var field in this.GetType().GetFields( | foreach (var field in this.GetType().GetFields( |
| BindingFlags.Instance | | BindingFlags.Instance | |
| BindingFlags.NonPublic | | BindingFlags.NonPublic | |
| BindingFlags.Public | | BindingFlags.Public | |
| BindingFlags.FlattenHierarchy | BindingFlags.FlattenHierarchy |
| )) | )) |
| { | { |
| object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false); | object[] attrs = field.GetCustomAttributes(typeof(AVOID_SaveValue), false); |
| if (attrs.Length == 0) { | if (attrs.Length == 0) { |
| continue; | continue; |
| } | } |
| AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue; | AVOID_SaveValue attr = attrs.FirstOrDefault () as AVOID_SaveValue; |
| string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name); | string fieldName = string.Format("{0}_{1}", this.GetType().Name, attr.Name); |
| object fieldValue = field.GetValue(this); | object fieldValue = field.GetValue(this); |
| if (fieldValue is IVOID_SaveValue) | if (fieldValue is IVOID_SaveValue) |
| { | { |
| fieldValue = (fieldValue as IVOID_SaveValue).AsType; | fieldValue = (fieldValue as IVOID_SaveValue).AsType; |
| } | } |
| config.SetValue(fieldName, fieldValue); | config.SetValue(fieldName, fieldValue); |
| Tools.PostDebugMessage(string.Format("{0}: Saved field {1}.", this.GetType().Name, fieldName)); | Tools.PostDebugMessage(string.Format("{0}: Saved field {1}.", this.GetType().Name, fieldName)); |
| } | } |
| } | } |
| } | } |
| public abstract class VOID_WindowModule : VOID_Module | public abstract class VOID_WindowModule : VOID_Module |
| { | { |
| [AVOID_SaveValue("WindowPos")] | [AVOID_SaveValue("WindowPos")] |
| protected Rect WindowPos = new Rect(Screen.width / 2, Screen.height / 2, 10f, 10f); | protected Rect WindowPos = new Rect(Screen.width / 2, Screen.height / 2, 250f, 50f); |
| protected float defWidth = 250f; | |
| protected float defHeight = 50f; | |
| public abstract void ModuleWindow(int _); | public abstract void ModuleWindow(int _); |
| public override void DrawGUI() | public override void DrawGUI() |
| { | { |
| Rect _Pos = this.WindowPos; | Rect _Pos = this.WindowPos; |
| _Pos = GUILayout.Window( | _Pos = GUILayout.Window( |
| VOID_Core.Instance.windowID, | VOID_Core.Instance.windowID, |
| _Pos, | _Pos, |
| this.ModuleWindow, | this.ModuleWindow, |
| this.Name, GUILayout.Width(250), | this.Name, |
| GUILayout.Height(50)); | GUILayout.Width(this.defWidth), |
| GUILayout.Height(this.defHeight) | |
| ); | |
| _Pos = Tools.ClampRectToScreen (_Pos); | |
| if (_Pos != this.WindowPos) | if (_Pos != this.WindowPos) |
| { | { |
| this.WindowPos = _Pos; | this.WindowPos = _Pos; |
| VOID_Core.Instance.configDirty = true; | VOID_Core.Instance.configDirty = true; |
| } | } |
| } | } |
| } | } |
| } | } |
| // | // |
| // VOID_Orbital.cs | // VOID_Orbital.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| using KSP; | using KSP; |
| using System; | using System; |
| using UnityEngine; | using UnityEngine; |
| namespace VOID | namespace VOID |
| { | { |
| public class VOID_Orbital : VOID_WindowModule | public class VOID_Orbital : VOID_WindowModule |
| { | { |
| [AVOID_SaveValue("toggleExtended")] | [AVOID_SaveValue("toggleExtended")] |
| protected VOID_SaveValue<bool> toggleExtended = false; | protected VOID_SaveValue<bool> toggleExtended = false; |
| public VOID_Orbital() | public VOID_Orbital() |
| { | { |
| this._Name = "Orbital Information"; | this._Name = "Orbital Information"; |
| this.WindowPos.x = Screen.width - 520f; | |
| this.WindowPos.y = 250f; | |
| } | } |
| public override void ModuleWindow(int _) | public override void ModuleWindow(int _) |
| { | { |
| // Toadicus edit: added local sidereal longitude. | // Toadicus edit: added local sidereal longitude. |
| double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle; | double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle; |
| LSL = Tools.FixDegreeDomain (LSL); | LSL = Tools.FixDegreeDomain (LSL); |
| GUILayout.BeginVertical(); | GUILayout.BeginVertical(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(VOIDLabels.void_primary + ":"); | GUILayout.Label(VOIDLabels.void_primary + ":"); |
| GUILayout.Label(vessel.mainBody.bodyName, GUILayout.ExpandWidth(false)); | GUILayout.Label(vessel.mainBody.bodyName, GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(VOIDLabels.void_altitude_asl + ":"); | GUILayout.Label(VOIDLabels.void_altitude_asl + ":"); |
| GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.altitude) + "m", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.altitude) + "m", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(VOIDLabels.void_velocity + ":"); | GUILayout.Label(VOIDLabels.void_velocity + ":"); |
| GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(VOIDLabels.void_apoapsis + ":"); | GUILayout.Label(VOIDLabels.void_apoapsis + ":"); |
| GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.ApA) + "m", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.ApA) + "m", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Time to Ap:"); | GUILayout.Label("Time to Ap:"); |
| GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToAp), GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToAp), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label(VOIDLabels.void_periapsis + ":"); | GUILayout.Label(VOIDLabels.void_periapsis + ":"); |
| GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.PeA) + "m", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(vessel.orbit.PeA) + "m", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Time to Pe:"); | GUILayout.Label("Time to Pe:"); |
| GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToPe), GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.ConvertInterval(vessel.orbit.timeToPe), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Inclination:"); | GUILayout.Label("Inclination:"); |
| GUILayout.Label(vessel.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label(vessel.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass()); | double r_vessel = vessel.mainBody.Radius + vessel.mainBody.GetAltitude(vessel.findWorldCenterOfMass()); |
| double g_vessel = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2); | double g_vessel = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(r_vessel, 2); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Gravity:"); | GUILayout.Label("Gravity:"); |
| GUILayout.Label(Tools.MuMech_ToSI(g_vessel) + "m/s²", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(g_vessel) + "m/s²", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| this.toggleExtended = GUILayout.Toggle(this.toggleExtended, "Extended info"); | this.toggleExtended = GUILayout.Toggle(this.toggleExtended, "Extended info"); |
| if (this.toggleExtended) | if (this.toggleExtended) |
| { | { |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Period:"); | GUILayout.Label("Period:"); |
| GUILayout.Label(Tools.ConvertInterval(vessel.orbit.period), GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.ConvertInterval(vessel.orbit.period), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Semi-major axis:"); | GUILayout.Label("Semi-major axis:"); |
| GUILayout.Label((vessel.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false)); | GUILayout.Label((vessel.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Eccentricity:"); | GUILayout.Label("Eccentricity:"); |
| GUILayout.Label(vessel.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false)); | GUILayout.Label(vessel.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| // Toadicus edit: convert mean anomaly into degrees. | // Toadicus edit: convert mean anomaly into degrees. |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Mean anomaly:"); | GUILayout.Label("Mean anomaly:"); |
| GUILayout.Label((vessel.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label((vessel.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("True anomaly:"); | GUILayout.Label("True anomaly:"); |
| GUILayout.Label(vessel.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label(vessel.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| // Toadicus edit: convert eccentric anomaly into degrees. | // Toadicus edit: convert eccentric anomaly into degrees. |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Eccentric anomaly:"); | GUILayout.Label("Eccentric anomaly:"); |
| GUILayout.Label((vessel.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label((vessel.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Long. ascending node:"); | GUILayout.Label("Long. ascending node:"); |
| GUILayout.Label(vessel.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label(vessel.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Arg. of periapsis:"); | GUILayout.Label("Arg. of periapsis:"); |
| GUILayout.Label(vessel.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label(vessel.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| // Toadicus edit: added local sidereal longitude. | // Toadicus edit: added local sidereal longitude. |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Local Sidereal Longitude:"); | GUILayout.Label("Local Sidereal Longitude:"); |
| GUILayout.Label(LSL.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"]); | GUILayout.Label(LSL.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"]); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| } | } |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| GUI.DragWindow(); | GUI.DragWindow(); |
| } | } |
| } | } |
| } | } |
| // | |
| // VOID_Orbital.cs | |
| // | |
| // Author: | |
| // toadicus <> | |
| // | |
| // Copyright (c) 2013 toadicus | |
| // | |
| // This program is free software: you can redistribute it and/or modify | |
| // it under the terms of the GNU General Public License as published by | |
| // the Free Software Foundation, either version 3 of the License, or | |
| // (at your option) any later version. | |
| // | |
| // This program is distributed in the hope that it will be useful, | |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| // GNU General Public License for more details. | |
| // | |
| // You should have received a copy of the GNU General Public License | |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| using KSP; | |
| using System; | |
| using System.Collections.Generic; | |
| using System.Linq; | |
| using UnityEngine; | |
| namespace VOID | |
| { | |
| public class VOID_Rendezvous : VOID_WindowModule | |
| { | |
| [AVOID_SaveValue("untoggleRegisterInfo")] | |
| protected VOID_SaveValue<bool> untoggleRegisterInfo = false; | |
| [AVOID_SaveValue("toggleExtendedOrbital")] | |
| protected VOID_SaveValue<bool> toggleExtendedOrbital = false; | |
| protected VOID_VesselRegister RegisterModule; | |
| public VOID_Rendezvous() | |
| { | |
| this._Name = "Rendezvous Information"; | |
| this.WindowPos.x = 845; | |
| this.WindowPos.y = 85; | |
| } | |
| public override void ModuleWindow(int _) | |
| { | |
| Vessel rendezvessel = new Vessel(); | |
| CelestialBody rendezbody = new CelestialBody(); | |
| this.RegisterModule = VOID_Core.Instance.Modules.Where(m => typeof(VOID_VesselRegister).IsAssignableFrom(m.GetType())).FirstOrDefault() as VOID_VesselRegister; | |
| GUILayout.BeginVertical(); | |
| //display both | |
| //Show Target Info | |
| GUILayout.Label("Target:", VOID_Core.Instance.LabelStyles["center_bold"]); | |
| if (FlightGlobals.fetch.VesselTarget != null) | |
| { | |
| //a KSP Target (body or vessel) is selected | |
| if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.Direction) | |
| { | |
| //a Body is selected | |
| rendezbody = vessel.patchedConicSolver.targetBody; | |
| display_rendezvous_info(null, rendezbody); | |
| } | |
| else if (FlightGlobals.fetch.vesselTargetMode == FlightGlobals.VesselTargetModes.DirectionAndVelocity) | |
| { | |
| //a Vessel is selected | |
| rendezvessel = FlightGlobals.fetch.VesselTarget.GetVessel(); | |
| display_rendezvous_info(rendezvessel, null); | |
| } | |
| //Show Unset button for both options above | |
| if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false))) | |
| { | |
| FlightGlobals.fetch.SetVesselTarget(null); | |
| Tools.PostDebugMessage("VOID_Rendezvous: KSP Target set to null"); | |
| } | |
| } | |
| else | |
| { | |
| //no KSP Target selected | |
| GUILayout.Label("No Target Selected", VOID_Core.Instance.LabelStyles["center_bold"]); | |
| } | |
| //Show Vessel Register vessel info | |
| if (untoggleRegisterInfo == false && this.RegisterModule != default(IVOID_Module)) | |
| { | |
| GUILayout.Label("Vessel Register:", VOID_Core.Instance.LabelStyles["center_bold"]); | |
| if (this.RegisterModule.selectedVessel != null) | |
| { | |
| rendezvessel = this.RegisterModule.selectedVessel; | |
| display_rendezvous_info(rendezvessel, null); | |
| //show set/unset buttons | |
| if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != this.RegisterModule.selectedVessel)) | |
| { | |
| //no Tgt set or Tgt is not this vessel | |
| //show a Set button | |
| if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false))) | |
| { | |
| FlightGlobals.fetch.SetVesselTarget(rendezvessel); | |
| Tools.PostDebugMessage("[VOID] KSP Target set to " + rendezvessel.vesselName); | |
| } | |
| } | |
| } | |
| else | |
| { | |
| //vesreg Vessel is null | |
| //targ = null; | |
| GUILayout.Label("No Vessel Selected", VOID_Core.Instance.LabelStyles["center_bold"]); | |
| } | |
| } | |
| untoggleRegisterInfo = GUILayout.Toggle(untoggleRegisterInfo, "Hide Vessel Register Info"); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label(" ", GUILayout.ExpandWidth(true)); | |
| if (GUILayout.Button("Close", GUILayout.ExpandWidth(false))) this._Active = false; | |
| GUILayout.EndHorizontal(); | |
| GUILayout.EndVertical(); | |
| GUI.DragWindow(); | |
| } | |
| private void display_rendezvous_info(Vessel v, CelestialBody cb) | |
| { | |
| if (cb == null && v != null) | |
| { | |
| //Display vessel rendezvous info | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label(v.vesselName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true)); | |
| GUILayout.EndHorizontal(); | |
| if (v.situation == Vessel.Situations.ESCAPING || v.situation == Vessel.Situations.FLYING || v.situation == Vessel.Situations.ORBITING || v.situation == Vessel.Situations.SUB_ORBITAL) | |
| { | |
| // Toadicus edit: added local sidereal longitude. | |
| // Toadicus edit: added local sidereal longitude. | |
| double LSL = vessel.longitude + vessel.orbit.referenceBody.rotationAngle; | |
| LSL = Tools.FixDegreeDomain (LSL); | |
| //display orbital info for orbiting/flying/suborbital/escaping vessels only | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Ap/Pe:"); | |
| GUILayout.Label(Tools.MuMech_ToSI(v.orbit.ApA) + "m / " + Tools.MuMech_ToSI(v.orbit.PeA) + "m", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Altitude:"); | |
| GUILayout.Label(Tools.MuMech_ToSI(v.orbit.altitude) + "m", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Inclination:"); | |
| GUILayout.Label(v.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| if (vessel.mainBody == v.mainBody) | |
| { | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Relative inclination:"); | |
| GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), v.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| //if (debugging) Debug.Log("[CHATR] v -> v relative incl OK"); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Velocity:"); | |
| GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Relative velocity:"); | |
| GUILayout.Label(Tools.MuMech_ToSI(v.orbit.vel.magnitude - vessel.orbit.vel.magnitude) + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Distance:"); | |
| GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| //target_vessel_extended_orbital_info = GUILayout.Toggle(target_vessel_extended_orbital_info, "Extended info"); | |
| if (toggleExtendedOrbital) | |
| { | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Period:"); | |
| GUILayout.Label(Tools.ConvertInterval(v.orbit.period), GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Semi-major axis:"); | |
| GUILayout.Label((v.orbit.semiMajorAxis / 1000).ToString("##,#") + "km", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Eccentricity:"); | |
| GUILayout.Label(v.orbit.eccentricity.ToString("F4"), GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| // Toadicus edit: convert mean anomaly into degrees. | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Mean anomaly:"); | |
| GUILayout.Label((v.orbit.meanAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("True anomaly:"); | |
| GUILayout.Label(v.orbit.trueAnomaly.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| // Toadicus edit: convert eccentric anomaly into degrees. | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Eccentric anomaly:"); | |
| GUILayout.Label((v.orbit.eccentricAnomaly * 180d / Math.PI).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Long. ascending node:"); | |
| GUILayout.Label(v.orbit.LAN.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Arg. of periapsis:"); | |
| GUILayout.Label(v.orbit.argumentOfPeriapsis.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| // Toadicus edit: added local sidereal longitude. | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Local Sidereal Longitude:"); | |
| GUILayout.Label(LSL.ToString("F3") + "°", VOID_Core.Instance.LabelStyles["txt_right"]); | |
| GUILayout.EndHorizontal(); | |
| } | |
| } | |
| else | |
| { | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Latitude:"); | |
| GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Longitude:"); | |
| GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Distance:"); | |
| GUILayout.Label(Tools.MuMech_ToSI((vessel.findWorldCenterOfMass() - v.findWorldCenterOfMass()).magnitude) + "m", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| } | |
| else if (cb != null && v == null) | |
| { | |
| //Display CelstialBody rendezvous info | |
| GUILayout.Label(cb.bodyName, VOID_Core.Instance.LabelStyles["center_bold"]); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Ap/Pe:"); | |
| GUILayout.Label(Tools.MuMech_ToSI(cb.orbit.ApA) + "m / " + Tools.MuMech_ToSI(cb.orbit.PeA) + "m", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| //if (debugging) Debug.Log("[VOID] Ap/Pe OK"); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Inclination:"); | |
| GUILayout.Label(cb.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| //if (debugging) Debug.Log("[VOID] Inclination OK"); | |
| if (cb.referenceBody == vessel.mainBody) | |
| { | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Relative inclination:"); | |
| GUILayout.Label(Vector3d.Angle(vessel.orbit.GetOrbitNormal(), cb.orbit.GetOrbitNormal()).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| //if (debugging) Debug.Log("[VOID] cb Relative inclination OK"); | |
| } | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Distance:"); | |
| GUILayout.Label(Tools.MuMech_ToSI((vessel.mainBody.position - cb.position).magnitude) + "m", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| //if (debugging) Debug.Log("[VOID] Distance OK"); | |
| //SUN2PLANET: | |
| if (vessel.mainBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody) | |
| { | |
| Tools.display_transfer_angles_SUN2PLANET(cb, vessel); | |
| //if (debugging) Debug.Log("[VOID] SUN2PLANET OK"); | |
| } | |
| //PLANET2PLANET | |
| else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody) | |
| { | |
| Tools.display_transfer_angles_PLANET2PLANET(cb, vessel); | |
| //if (debugging) Debug.Log("[VOID] PLANET2PLANET OK"); | |
| } | |
| //PLANET2MOON | |
| else if (vessel.mainBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody) | |
| { | |
| Tools.display_transfer_angles_PLANET2MOON(cb, vessel); | |
| //if (debugging) Debug.Log("[VOID] PLANET2MOON OK"); | |
| } | |
| //MOON2MOON | |
| else if (vessel.mainBody.referenceBody.referenceBody.bodyName == "Sun" && cb.referenceBody == vessel.mainBody.referenceBody) | |
| { | |
| Tools.display_transfer_angles_MOON2MOON(cb, vessel); | |
| //if (debugging) Debug.Log("[VOID] MOON2MOON OK"); | |
| } | |
| //else GUILayout.Label("Transfer angle information\nunavailable for this target"); | |
| } | |
| } | |
| } | |
| } |
| // | // |
| // VOID_Config.cs | // VOID_Config.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| using System; | using System; |
| using System.Collections.Generic; | using System.Collections.Generic; |
| using KSP; | using KSP; |
| using UnityEngine; | using UnityEngine; |
| namespace VOID | namespace VOID |
| { | { |
| public struct VOID_SaveValue<T> : IVOID_SaveValue | public struct VOID_SaveValue<T> : IVOID_SaveValue |
| { | { |
| private T _value; | private T _value; |
| private Type _type; | private Type _type; |
| public T value | public T value |
| { | { |
| get | get |
| { | { |
| return this._value; | return this._value; |
| } | } |
| set | set |
| { | { |
| this._value = value; | this._value = value; |
| } | } |
| } | } |
| public Type type | public Type type |
| { | { |
| get | get |
| { | { |
| return this._type; | return this._type; |
| } | } |
| set | set |
| { | { |
| this._type = value; | this._type = value; |
| } | } |
| } | } |
| public object AsType | public object AsType |
| { | { |
| get | get |
| { | { |
| return (T)this._value; | return (T)this._value; |
| } | } |
| } | } |
| public void SetValue(object v) | public void SetValue(object v) |
| { | { |
| this._value = (T)v; | this._value = (T)v; |
| } | } |
| public static implicit operator T(VOID_SaveValue<T> v) | public static implicit operator T(VOID_SaveValue<T> v) |
| { | { |
| return v.value; | return v.value; |
| } | } |
| public static implicit operator VOID_SaveValue<T>(T v) | public static implicit operator VOID_SaveValue<T>(T v) |
| { | { |
| VOID_SaveValue<T> r = new VOID_SaveValue<T>(); | VOID_SaveValue<T> r = new VOID_SaveValue<T>(); |
| r.value = v; | r.value = v; |
| r.type = v.GetType(); | r.type = v.GetType(); |
| if (VOID_Core.Initialized) | if (VOID_Core.Initialized) |
| { | { |
| VOID_Core.Instance.configDirty = true; | VOID_Core.Instance.configDirty = true; |
| } | } |
| if (VOID_EditorCore.Initialized) | |
| { | |
| VOID_EditorCore.Instance.configDirty = true; | |
| } | |
| return r; | return r; |
| } | |
| public new string ToString() | |
| { | |
| return this.value.ToString(); | |
| } | } |
| } | } |
| public interface IVOID_SaveValue | public interface IVOID_SaveValue |
| { | { |
| Type type { get; } | Type type { get; } |
| object AsType { get; } | object AsType { get; } |
| void SetValue(object v); | void SetValue(object v); |
| } | } |
| [AttributeUsage(AttributeTargets.Field)] | [AttributeUsage(AttributeTargets.Field)] |
| public class AVOID_SaveValue : Attribute | public class AVOID_SaveValue : Attribute |
| { | { |
| protected string _name; | protected string _name; |
| public string Name | public string Name |
| { | { |
| get | get |
| { | { |
| return this._name; | return this._name; |
| } | } |
| } | } |
| public AVOID_SaveValue(string fieldName) | public AVOID_SaveValue(string fieldName) |
| { | { |
| this._name = fieldName; | this._name = fieldName; |
| } | } |
| } | } |
| } | } |
| // | // |
| // VOID_Orbital.cs | // VOID_Orbital.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| using KSP; | using KSP; |
| using System; | using System; |
| using UnityEngine; | using UnityEngine; |
| namespace VOID | namespace VOID |
| { | { |
| public class VOID_SurfAtmo : VOID_WindowModule | public class VOID_SurfAtmo : VOID_WindowModule |
| { | { |
| public VOID_SurfAtmo() | public VOID_SurfAtmo() |
| { | { |
| this._Name = "Surface & Atmospheric Information"; | this._Name = "Surface & Atmospheric Information"; |
| this.WindowPos.x = Screen.width - 260f; | |
| this.WindowPos.y = 85; | |
| } | } |
| public override void ModuleWindow(int _) | public override void ModuleWindow(int _) |
| { | { |
| GUILayout.BeginVertical(); | GUILayout.BeginVertical(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Altitude (true):"); | GUILayout.Label("Altitude (true):"); |
| double alt_true = vessel.orbit.altitude - vessel.terrainAltitude; | double alt_true = vessel.orbit.altitude - vessel.terrainAltitude; |
| // HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m. | // HACK: This assumes that on worlds with oceans, all water is fixed at 0 m, and water covers the whole surface at 0 m. |
| if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean ) alt_true = vessel.orbit.altitude; | if (vessel.terrainAltitude < 0 && vessel.mainBody.ocean ) alt_true = vessel.orbit.altitude; |
| GUILayout.Label(Tools.MuMech_ToSI(alt_true) + "m", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(alt_true) + "m", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal (); | GUILayout.EndHorizontal (); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Latitude:"); | GUILayout.Label("Latitude:"); |
| GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.GetLatitudeString(vessel), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Longitude:"); | GUILayout.Label("Longitude:"); |
| GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.GetLongitudeString(vessel), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Heading:"); | GUILayout.Label("Heading:"); |
| GUILayout.Label(Tools.MuMech_get_heading(vessel).ToString("F2") + "° " + Tools.get_heading_text(Tools.MuMech_get_heading(vessel)), GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_get_heading(vessel).ToString("F2") + "° " + Tools.get_heading_text(Tools.MuMech_get_heading(vessel)), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Terrain elevation:"); | GUILayout.Label("Terrain elevation:"); |
| GUILayout.Label(Tools.MuMech_ToSI(vessel.terrainAltitude) + "m", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(vessel.terrainAltitude) + "m", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Surface velocity:"); | GUILayout.Label("Surface velocity:"); |
| GUILayout.Label(Tools.MuMech_ToSI(vessel.srf_velocity.magnitude) + "m/s", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(vessel.srf_velocity.magnitude) + "m/s", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Vertical speed:"); | GUILayout.Label("Vertical speed:"); |
| GUILayout.Label(Tools.MuMech_ToSI(vessel.verticalSpeed) + "m/s", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(vessel.verticalSpeed) + "m/s", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Horizontal speed:"); | GUILayout.Label("Horizontal speed:"); |
| GUILayout.Label(Tools.MuMech_ToSI(vessel.horizontalSrfSpeed) + "m/s", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(vessel.horizontalSrfSpeed) + "m/s", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Temperature:"); | GUILayout.Label("Temperature:"); |
| GUILayout.Label(vessel.flightIntegrator.getExternalTemperature().ToString("F2") + "° C", GUILayout.ExpandWidth(false)); | GUILayout.Label(vessel.flightIntegrator.getExternalTemperature().ToString("F2") + "° C", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Atmosphere density:"); | GUILayout.Label("Atmosphere density:"); |
| GUILayout.Label(Tools.MuMech_ToSI(vessel.atmDensity * 1000) + "g/m³", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(vessel.atmDensity * 1000) + "g/m³", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Pressure:"); | GUILayout.Label("Pressure:"); |
| GUILayout.Label(vessel.staticPressure.ToString("F2") + " atms", GUILayout.ExpandWidth(false)); | GUILayout.Label(vessel.staticPressure.ToString("F2") + " atms", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Atmosphere limit:"); | GUILayout.Label("Atmosphere limit:"); |
| GUILayout.Label("≈ " + Tools.MuMech_ToSI(vessel.mainBody.maxAtmosphereAltitude) + "m", GUILayout.ExpandWidth(false)); | GUILayout.Label("≈ " + Tools.MuMech_ToSI(vessel.mainBody.maxAtmosphereAltitude) + "m", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| // Toadicus edit: added Biome | // Toadicus edit: added Biome |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Biome:"); | GUILayout.Label("Biome:"); |
| GUILayout.Label(Tools.Toadicus_GetAtt(vessel).name, VOID_Core.Instance.LabelStyles["txt_right"]); | GUILayout.Label(Tools.Toadicus_GetAtt(vessel).name, VOID_Core.Instance.LabelStyles["txt_right"]); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| GUI.DragWindow(); | GUI.DragWindow(); |
| } | } |
| } | } |
| } | } |
| // | // |
| // VOID_Orbital.cs | // VOID_Orbital.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| using KSP; | using KSP; |
| using System; | using System; |
| using System.Collections.Generic; | using System.Collections.Generic; |
| using UnityEngine; | using UnityEngine; |
| namespace VOID | namespace VOID |
| { | { |
| public class VOID_Transfer : VOID_WindowModule | public class VOID_Transfer : VOID_WindowModule |
| { | { |
| [AVOID_SaveValue("toggleExtended")] | [AVOID_SaveValue("toggleExtended")] |
| protected VOID_SaveValue<bool> toggleExtended = false; | protected VOID_SaveValue<bool> toggleExtended = false; |
| protected List<CelestialBody> selectedBodies = new List<CelestialBody>(); | protected List<CelestialBody> selectedBodies = new List<CelestialBody>(); |
| public VOID_Transfer() | public VOID_Transfer() |
| { | { |
| this._Name = "Transfer Angle Information"; | this._Name = "Transfer Angle Information"; |
| this.WindowPos.x = 475; | |
| this.WindowPos.y = 85; | |
| this.defWidth = 315; | |
| } | } |
| public override void ModuleWindow(int _) | public override void ModuleWindow(int _) |
| { | { |
| GUILayout.BeginVertical(); | GUILayout.BeginVertical(); |
| if (vessel.mainBody.name == "Sun") //Vessel is orbiting the Sun | if (vessel.mainBody.name == "Sun") //Vessel is orbiting the Sun |
| { | { |
| foreach (CelestialBody body in vessel.mainBody.orbitingBodies) | foreach (CelestialBody body in vessel.mainBody.orbitingBodies) |
| { | { |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (GUILayout.Button(body.bodyName)) | if (GUILayout.Button(body.bodyName)) |
| { | { |
| //add or remove this body to this list of bodies to display more info on | //add or remove this body to this list of bodies to display more info on |
| if (selectedBodies.Contains(body)) selectedBodies.Remove(body); | if (selectedBodies.Contains(body)) selectedBodies.Remove(body); |
| else selectedBodies.Add(body); | else selectedBodies.Add(body); |
| } | } |
| GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| if (selectedBodies.Contains(body)) | if (selectedBodies.Contains(body)) |
| { | { |
| display_transfer_angles_SUN2PLANET(body); //show phase angles for each selected body | Tools.display_transfer_angles_SUN2PLANET(body, vessel); //show phase angles for each selected body |
| tad_targeting(body); //display Set/Unset Target button for each selected body | tad_targeting(body); //display Set/Unset Target button for each selected body |
| } | } |
| } | } |
| } | } |
| else if (vessel.mainBody.referenceBody.name == "Sun") //Vessel is orbiting a planet | else if (vessel.mainBody.referenceBody.name == "Sun") //Vessel is orbiting a planet |
| { | { |
| foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies) | foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies) |
| { | { |
| if (body.name != vessel.mainBody.name) // show other planets | if (body.name != vessel.mainBody.name) // show other planets |
| { | { |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (GUILayout.Button(body.bodyName)) | if (GUILayout.Button(body.bodyName)) |
| { | { |
| //add or remove this body to this list of bodies to display more info on | //add or remove this body to this list of bodies to display more info on |
| if (selectedBodies.Contains(body)) selectedBodies.Remove(body); | if (selectedBodies.Contains(body)) selectedBodies.Remove(body); |
| else selectedBodies.Add(body); | else selectedBodies.Add(body); |
| } | } |
| GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| if (selectedBodies.Contains(body)) | if (selectedBodies.Contains(body)) |
| { | { |
| display_transfer_angles_PLANET2PLANET(body); | Tools.display_transfer_angles_PLANET2PLANET(body, vessel); |
| tad_targeting(body); //display Set/Unset Target button | tad_targeting(body); //display Set/Unset Target button |
| } | } |
| } | } |
| } | } |
| foreach (CelestialBody body in vessel.mainBody.orbitingBodies) // show moons | foreach (CelestialBody body in vessel.mainBody.orbitingBodies) // show moons |
| { | { |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (GUILayout.Button(body.bodyName)) | if (GUILayout.Button(body.bodyName)) |
| { | { |
| //add or remove this body to this list of bodies to display more info on | //add or remove this body to this list of bodies to display more info on |
| if (selectedBodies.Contains(body)) selectedBodies.Remove(body); | if (selectedBodies.Contains(body)) selectedBodies.Remove(body); |
| else selectedBodies.Add(body); | else selectedBodies.Add(body); |
| } | } |
| GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| if (selectedBodies.Contains(body)) | if (selectedBodies.Contains(body)) |
| { | { |
| display_transfer_angles_PLANET2MOON(body); | Tools.display_transfer_angles_PLANET2MOON(body, vessel); |
| tad_targeting(body); //display Set/Unset Target button | tad_targeting(body); //display Set/Unset Target button |
| } | } |
| } | } |
| } | } |
| else if (vessel.mainBody.referenceBody.referenceBody.name == "Sun") // Vessel is orbiting a moon | else if (vessel.mainBody.referenceBody.referenceBody.name == "Sun") // Vessel is orbiting a moon |
| { | { |
| foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies) | foreach (CelestialBody body in vessel.mainBody.referenceBody.orbitingBodies) |
| { | { |
| if (body.name != vessel.mainBody.name) // show other moons | if (body.name != vessel.mainBody.name) // show other moons |
| { | { |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| if (GUILayout.Button(body.bodyName)) | if (GUILayout.Button(body.bodyName)) |
| { | { |
| //add or remove this body to this list of bodies to display more info on | //add or remove this body to this list of bodies to display more info on |
| if (selectedBodies.Contains(body)) selectedBodies.Remove(body); | if (selectedBodies.Contains(body)) selectedBodies.Remove(body); |
| else selectedBodies.Add(body); | else selectedBodies.Add(body); |
| } | } |
| GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | GUILayout.Label("Inclined " + body.orbit.inclination.ToString("F3") + "°", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| if (selectedBodies.Contains(body)) | if (selectedBodies.Contains(body)) |
| { | { |
| display_transfer_angles_MOON2MOON(body); | Tools.display_transfer_angles_MOON2MOON(body, vessel); |
| tad_targeting(body); //display Set/Unset Target button | tad_targeting(body); //display Set/Unset Target button |
| } | } |
| } | } |
| } | } |
| } | } |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| GUI.DragWindow(); | GUI.DragWindow(); |
| } | } |
| private void tad_targeting(CelestialBody body) | private void tad_targeting(CelestialBody body) |
| { | { |
| //Target Set/Unset buttons | //Target Set/Unset buttons |
| if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() == null)) | if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() == null)) |
| { | { |
| //No TGT set or TGT is a Body | //No TGT set or TGT is a Body |
| if ((CelestialBody)FlightGlobals.fetch.VesselTarget != body) | if ((CelestialBody)FlightGlobals.fetch.VesselTarget != body) |
| { | { |
| if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false))) | if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false))) |
| { | { |
| FlightGlobals.fetch.SetVesselTarget(body); | FlightGlobals.fetch.SetVesselTarget(body); |
| Tools.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName); | Tools.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName); |
| } | } |
| } | } |
| else if ((CelestialBody)FlightGlobals.fetch.VesselTarget == body) | else if ((CelestialBody)FlightGlobals.fetch.VesselTarget == body) |
| { | { |
| if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false))) | if (GUILayout.Button("Unset Target", GUILayout.ExpandWidth(false))) |
| { | { |
| FlightGlobals.fetch.SetVesselTarget(null); | FlightGlobals.fetch.SetVesselTarget(null); |
| Tools.PostDebugMessage("[VOID] KSP Target set to null"); | Tools.PostDebugMessage("[VOID] KSP Target set to null"); |
| } | } |
| } | } |
| } | } |
| else if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != null)) | else if (FlightGlobals.fetch.VesselTarget == null || (FlightGlobals.fetch.VesselTarget != null && FlightGlobals.fetch.VesselTarget.GetVessel() != null)) |
| { | { |
| //No TGT or TGT is a vessel | //No TGT or TGT is a vessel |
| if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false))) | if (GUILayout.Button("Set Target", GUILayout.ExpandWidth(false))) |
| { | { |
| FlightGlobals.fetch.SetVesselTarget(body); | FlightGlobals.fetch.SetVesselTarget(body); |
| Tools.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName); | Tools.PostDebugMessage("[VOID] KSP Target set to CelestialBody " + body.bodyName); |
| } | } |
| } | } |
| } | } |
| private void display_transfer_angles_SUN2PLANET(CelestialBody body) | |
| { | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Phase angle (curr/trans):"); | |
| GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter).ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Transfer velocity:"); | |
| GUILayout.Label((Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)) * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| private void display_transfer_angles_PLANET2PLANET(CelestialBody body) | |
| { | |
| double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)); | |
| double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1)); | |
| double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000)); | |
| double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360; | |
| double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle); | |
| double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle); | |
| double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Phase angle (curr/trans):"); | |
| GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Ejection angle (curr/trans):"); | |
| GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Transfer velocity:"); | |
| GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| private void display_transfer_angles_PLANET2MOON(CelestialBody body) | |
| { | |
| double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)); | |
| double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.gravParameter); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Phase angle (curr/trans):"); | |
| GUILayout.Label(Tools.mrenigma03_calcphase(vessel, body).ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Transfer velocity:"); | |
| GUILayout.Label((dv1 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| private void display_transfer_angles_MOON2MOON(CelestialBody body) | |
| { | |
| double dv1 = Tools.Younata_DeltaVToGetToOtherBody((vessel.mainBody.referenceBody.gravParameter / 1000000000), (vessel.mainBody.orbit.semiMajorAxis / 1000), (body.orbit.semiMajorAxis / 1000)); | |
| double dv2 = Tools.Younata_DeltaVToExitSOI((vessel.mainBody.gravParameter / 1000000000), (vessel.orbit.semiMajorAxis / 1000), (vessel.mainBody.sphereOfInfluence / 1000), Math.Abs(dv1)); | |
| double trans_ejection_angle = Tools.Younata_TransferBurnPoint((vessel.orbit.semiMajorAxis / 1000), dv2, (Math.PI / 2.0), (vessel.mainBody.gravParameter / 1000000000)); | |
| double curr_phase_angle = Tools.Adammada_CurrrentPhaseAngle(body.orbit.LAN, body.orbit.orbitPercent, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| double curr_ejection_angle = Tools.Adammada_CurrentEjectionAngle(FlightGlobals.ActiveVessel.longitude, FlightGlobals.ActiveVessel.orbit.referenceBody.rotationAngle, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.LAN, FlightGlobals.ActiveVessel.orbit.referenceBody.orbit.orbitPercent); | |
| double trans_phase_angle = Tools.Nivvy_CalcTransferPhaseAngle(vessel.mainBody.orbit.semiMajorAxis, body.orbit.semiMajorAxis, vessel.mainBody.referenceBody.gravParameter) % 360; | |
| double adj_phase_angle = Tools.adjustCurrPhaseAngle(trans_phase_angle, curr_phase_angle); | |
| //double adj_ejection_angle = adjustCurrEjectionAngle(trans_phase_angle, curr_ejection_angle); | |
| //new stuff | |
| // | |
| double adj_trans_ejection_angle = Tools.adjust_transfer_ejection_angle(trans_ejection_angle, trans_phase_angle); | |
| double adj_curr_ejection_angle = Tools.adjust_current_ejection_angle(curr_ejection_angle); | |
| // | |
| // | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Phase angle (curr/trans):"); | |
| GUILayout.Label(adj_phase_angle.ToString("F3") + "° / " + trans_phase_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Ejection angle (curr/trans):"); | |
| GUILayout.Label(adj_curr_ejection_angle.ToString("F3") + "° / " + adj_trans_ejection_angle.ToString("F3") + "°", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label("Transfer velocity:"); | |
| GUILayout.Label((dv2 * 1000).ToString("F2") + "m/s", GUILayout.ExpandWidth(false)); | |
| GUILayout.EndHorizontal(); | |
| } | |
| } | } |
| } | } |
| // | // |
| // VOID_Orbital.cs | // VOID_Orbital.cs |
| // | // |
| // Author: | // Author: |
| // toadicus <> | // toadicus <> |
| // | // |
| // Copyright (c) 2013 toadicus | // Copyright (c) 2013 toadicus |
| // | // |
| // This program is free software: you can redistribute it and/or modify | // This program is free software: you can redistribute it and/or modify |
| // it under the terms of the GNU General Public License as published by | // it under the terms of the GNU General Public License as published by |
| // the Free Software Foundation, either version 3 of the License, or | // the Free Software Foundation, either version 3 of the License, or |
| // (at your option) any later version. | // (at your option) any later version. |
| // | // |
| // This program is distributed in the hope that it will be useful, | // This program is distributed in the hope that it will be useful, |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | // but WITHOUT ANY WARRANTY; without even the implied warranty of |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| // GNU General Public License for more details. | // GNU General Public License for more details. |
| // | // |
| // You should have received a copy of the GNU General Public License | // You should have received a copy of the GNU General Public License |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | // along with this program. If not, see <http://www.gnu.org/licenses/>. |
| using KSP; | using KSP; |
| using System; | using System; |
| using UnityEngine; | using UnityEngine; |
| namespace VOID | namespace VOID |
| { | { |
| public class VOID_VesselInfo : VOID_WindowModule | public class VOID_VesselInfo : VOID_WindowModule |
| { | { |
| [AVOID_SaveValue("toggleExtended")] | [AVOID_SaveValue("toggleExtended")] |
| protected VOID_SaveValue<bool> toggleExtended = false; | protected VOID_SaveValue<bool> toggleExtended = false; |
| public VOID_VesselInfo() | public VOID_VesselInfo() |
| { | { |
| this._Name = "Vessel Information"; | this._Name = "Vessel Information"; |
| this.WindowPos.x = Screen.width - 260; | |
| this.WindowPos.y = 450; | |
| } | } |
| public override void ModuleWindow(int _) | public override void ModuleWindow(int _) |
| { | { |
| if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate)) | if ((TimeWarp.WarpMode == TimeWarp.Modes.LOW) || (TimeWarp.CurrentRate <= TimeWarp.MaxPhysicsRate)) |
| { | { |
| Engineer.VesselSimulator.SimManager.Instance.RequestSimulation(); | Engineer.VesselSimulator.SimManager.Instance.RequestSimulation(); |
| } | } |
| Engineer.VesselSimulator.Stage[] stages = Engineer.VesselSimulator.SimManager.Instance.Stages; | Engineer.VesselSimulator.Stage[] stages = Engineer.VesselSimulator.SimManager.Instance.Stages; |
| GUILayout.BeginVertical(); | GUILayout.BeginVertical(); |
| GUILayout.Label(vessel.vesselName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true)); | GUILayout.Label(vessel.vesselName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true)); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("G-force:"); | GUILayout.Label("G-force:"); |
| GUILayout.Label(vessel.geeForce.ToString("F2") + " gees", GUILayout.ExpandWidth(false)); | GUILayout.Label(vessel.geeForce.ToString("F2") + " gees", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| int num_parts = 0; | int num_parts = 0; |
| double total_mass = vessel.GetTotalMass(); | double total_mass = vessel.GetTotalMass(); |
| double resource_mass = 0; | double resource_mass = 0; |
| double max_thrust = 0; | double max_thrust = 0; |
| double final_thrust = 0; | double final_thrust = 0; |
| foreach (Part p in vessel.parts) | foreach (Part p in vessel.parts) |
| { | { |
| num_parts++; | num_parts++; |
| resource_mass += p.GetResourceMass(); | resource_mass += p.GetResourceMass(); |
| foreach (PartModule pm in p.Modules) | foreach (PartModule pm in p.Modules) |
| { | { |
| if ((pm.moduleName == "ModuleEngines") && ((p.State == PartStates.ACTIVE) || ((Staging.CurrentStage > Staging.lastStage) && (p.inverseStage == Staging.lastStage)))) | if ((pm.moduleName == "ModuleEngines") && ((p.State == PartStates.ACTIVE) || ((Staging.CurrentStage > Staging.lastStage) && (p.inverseStage == Staging.lastStage)))) |
| { | { |
| max_thrust += ((ModuleEngines)pm).maxThrust; | max_thrust += ((ModuleEngines)pm).maxThrust; |
| final_thrust += ((ModuleEngines)pm).finalThrust; | final_thrust += ((ModuleEngines)pm).finalThrust; |
| } | } |
| } | } |
| } | } |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Parts:"); | GUILayout.Label("Parts:"); |
| GUILayout.Label(num_parts.ToString("F0"), GUILayout.ExpandWidth(false)); | GUILayout.Label(num_parts.ToString("F0"), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Total mass:"); | GUILayout.Label("Total mass:"); |
| GUILayout.Label(total_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false)); | GUILayout.Label(total_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Resource mass:"); | GUILayout.Label("Resource mass:"); |
| GUILayout.Label(resource_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false)); | GUILayout.Label(resource_mass.ToString("F1") + " tons", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| if (stages.Length > Staging.lastStage) | if (stages.Length > Staging.lastStage) |
| { | { |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("DeltaV (Current Stage):"); | GUILayout.Label("DeltaV (Current Stage):"); |
| GUILayout.Label(Tools.MuMech_ToSI(stages[Staging.lastStage].deltaV).ToString() + "m/s", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(stages[Staging.lastStage].deltaV).ToString() + "m/s", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| } | } |
| if (stages.Length > 0) | if (stages.Length > 0) |
| { | { |
| double totalDeltaV = 0d; | double totalDeltaV = 0d; |
| for (int i = 0; i < stages.Length; ++i) | for (int i = 0; i < stages.Length; ++i) |
| { | { |
| totalDeltaV += stages [i].deltaV; | totalDeltaV += stages [i].deltaV; |
| } | } |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("DeltaV (Total):"); | GUILayout.Label("DeltaV (Total):"); |
| GUILayout.Label(Tools.MuMech_ToSI(totalDeltaV).ToString() + "m/s", GUILayout.ExpandWidth(false)); | GUILayout.Label(Tools.MuMech_ToSI(totalDeltaV).ToString() + "m/s", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| } | } |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Throttle:"); | GUILayout.Label("Throttle:"); |
| GUILayout.Label((vessel.ctrlState.mainThrottle * 100f).ToString("F0") + "%", GUILayout.ExpandWidth(false)); | GUILayout.Label((vessel.ctrlState.mainThrottle * 100f).ToString("F0") + "%", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Thrust (curr/max):"); | GUILayout.Label("Thrust (curr/max):"); |
| GUILayout.Label(final_thrust.ToString("F1") + " / " + max_thrust.ToString("F1") + " kN", GUILayout.ExpandWidth(false)); | GUILayout.Label(final_thrust.ToString("F1") + " / " + max_thrust.ToString("F1") + " kN", GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| double gravity = vessel.mainBody.gravParameter / Math.Pow(vessel.mainBody.Radius + vessel.altitude, 2); | double gravity = vessel.mainBody.gravParameter / Math.Pow(vessel.mainBody.Radius + vessel.altitude, 2); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("T:W (curr/max):"); | GUILayout.Label("T:W (curr/max):"); |
| GUILayout.Label((final_thrust / (total_mass * gravity)).ToString("F2") + " / " + (max_thrust / (total_mass * gravity)).ToString("F2"), GUILayout.ExpandWidth(false)); | GUILayout.Label((final_thrust / (total_mass * gravity)).ToString("F2") + " / " + (max_thrust / (total_mass * gravity)).ToString("F2"), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| double g_ASL = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(vessel.mainBody.Radius, 2); | double g_ASL = (VOID_Core.Constant_G * vessel.mainBody.Mass) / Math.Pow(vessel.mainBody.Radius, 2); |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); |
| GUILayout.Label("Max T:W @ surface:"); | GUILayout.Label("Max T:W @ surface:"); |
| GUILayout.Label((max_thrust / (total_mass * g_ASL)).ToString("F2"), GUILayout.ExpandWidth(false)); | GUILayout.Label((max_thrust / (total_mass * g_ASL)).ToString("F2"), GUILayout.ExpandWidth(false)); |
| GUILayout.EndHorizontal(); | GUILayout.EndHorizontal(); |
| GUILayout.EndVertical(); | GUILayout.EndVertical(); |
| GUI.DragWindow(); | GUI.DragWindow(); |
| } | } |
| } | } |
| } | } |
| // | |
| // VOID_Orbital.cs | |
| // | |
| // Author: | |
| // toadicus <> | |
| // | |
| // Copyright (c) 2013 toadicus | |
| // | |
| // This program is free software: you can redistribute it and/or modify | |
| // it under the terms of the GNU General Public License as published by | |
| // the Free Software Foundation, either version 3 of the License, or | |
| // (at your option) any later version. | |
| // | |
| // This program is distributed in the hope that it will be useful, | |
| // but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| // GNU General Public License for more details. | |
| // | |
| // You should have received a copy of the GNU General Public License | |
| // along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| using KSP; | |
| using System; | |
| using System.Linq; | |
| using UnityEngine; | |
| namespace VOID | |
| { | |
| public class VOID_VesselRegister : VOID_WindowModule | |
| { | |
| [AVOID_SaveValue("selectedBodyIdx")] | |
| protected VOID_SaveValue<int> selectedBodyIdx = 0; | |
| protected CelestialBody seletedBody; | |
| [AVOID_SaveValue("selectedVesselTypeIdx")] | |
| protected VOID_SaveValue<int> selectedVesselTypeIdx = 0; | |
| protected VesselType selectedVesselType; | |
| protected string vesselSituation = "Orbiting"; | |
| protected Vector2 selectorScrollPos = new Vector2(); | |
| protected Vessel _selectedVessel; | |
| public Vessel selectedVessel | |
| { | |
| get | |
| { | |
| return this._selectedVessel; | |
| } | |
| } | |
| public VOID_VesselRegister() | |
| { | |
| this._Name = "Vessel Register"; | |
| this.WindowPos.x = 845; | |
| this.WindowPos.y = 275; | |
| this.defHeight = 375; | |
| } | |
| public override void ModuleWindow(int _) | |
| { | |
| if (!VOID_Core.Instance.allVesselTypes.Any()) | |
| { | |
| return; | |
| } | |
| GUILayout.BeginVertical(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| if (GUILayout.Button("<")) | |
| { | |
| selectedBodyIdx--; | |
| if (selectedBodyIdx < 0) selectedBodyIdx = VOID_Core.Instance.allBodies.Count - 1; | |
| } | |
| GUILayout.Label(VOID_Core.Instance.allBodies[selectedBodyIdx].bodyName, VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true)); | |
| if (GUILayout.Button(">")) | |
| { | |
| selectedBodyIdx++; | |
| if (selectedBodyIdx > VOID_Core.Instance.allBodies.Count - 1) selectedBodyIdx = 0; | |
| } | |
| GUILayout.EndHorizontal(); | |
| seletedBody = VOID_Core.Instance.allBodies[selectedBodyIdx]; | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| if (GUILayout.Button("<")) | |
| { | |
| selectedVesselTypeIdx--; | |
| if (selectedVesselTypeIdx < 0) selectedVesselTypeIdx = VOID_Core.Instance.allVesselTypes.Count - 1; | |
| } | |
| GUILayout.Label(VOID_Core.Instance.allVesselTypes[selectedVesselTypeIdx].ToString(), VOID_Core.Instance.LabelStyles["center_bold"], GUILayout.ExpandWidth(true)); | |
| if (GUILayout.Button(">")) | |
| { | |
| selectedVesselTypeIdx++; | |
| if (selectedVesselTypeIdx > VOID_Core.Instance.allVesselTypes.Count - 1) selectedVesselTypeIdx = 0; | |
| } | |
| GUILayout.EndHorizontal(); | |
| selectedVesselType = VOID_Core.Instance.allVesselTypes[selectedVesselTypeIdx]; | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| if (GUILayout.Button("Landed", GUILayout.ExpandWidth(true))) vesselSituation = "Landed"; | |
| if (GUILayout.Button("Orbiting", GUILayout.ExpandWidth(true))) vesselSituation = "Orbiting"; | |
| GUILayout.EndHorizontal(); | |
| GUILayout.BeginHorizontal(GUILayout.ExpandWidth(true)); | |
| GUILayout.Label( | |
| Tools.UppercaseFirst(vesselSituation) + " " + selectedVesselType.ToString() + "s @ " + seletedBody.bodyName, | |
| VOID_Core.Instance.LabelStyles["center"], | |
| GUILayout.ExpandWidth(true)); | |
| GUILayout.EndHorizontal(); | |
| selectorScrollPos = GUILayout.BeginScrollView(selectorScrollPos, false, false); | |
| foreach (Vessel v in FlightGlobals.Vessels) | |
| { | |
| if (v != vessel && v.vesselType == selectedVesselType && v.mainBody == seletedBody) | |
| { | |
| if ((vesselSituation == "Landed" && | |
| (v.situation == Vessel.Situations.LANDED || | |
| v.situation == Vessel.Situations.PRELAUNCH || | |
| v.situation == Vessel.Situations.SPLASHED)) || | |
| (vesselSituation == "Orbiting" && | |
| (v.situation == Vessel.Situations.ESCAPING || | |
| v.situation == Vessel.Situations.FLYING || | |
| v.situation == Vessel.Situations.ORBITING || | |
| v.situation == Vessel.Situations.SUB_ORBITAL)) | |
| ) | |
| { | |
| if (GUILayout.Button(v.vesselName, GUILayout.ExpandWidth(true))) | |
| { | |
| if (_selectedVessel != v) | |
| { | |
| _selectedVessel = v; //set clicked vessel as selected_vessel | |
| this._Active = true; //turn bool on to open the window if closed | |
| } | |
| else | |
| { | |
| _selectedVessel = null; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| GUILayout.EndScrollView(); | |
| GUILayout.EndVertical(); | |
| GUI.DragWindow(); | |
| } | |
| } | |
| } |