Added SimManager.HardReset calls to both Awake()s.
Added SimManager.HardReset calls to both Awake()s.

/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// //
// 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 ("VOIDFlightMaster: Waking up."); Tools.PostDebugMessage ("VOIDFlightMaster: Waking up.");
this.Core = (VOID_Core)VOID_Core.Instance; this.Core = (VOID_Core)VOID_Core.Instance;
this.Core.ResetGUI (); this.Core.ResetGUI ();
  SimManager.HardReset();
Tools.PostDebugMessage ("VOIDFlightMaster: Awake."); Tools.PostDebugMessage ("VOIDFlightMaster: Awake.");
} }
   
public void Update() public void Update()
{ {
if (!HighLogic.LoadedSceneIsFlight && this.Core != null) if (!HighLogic.LoadedSceneIsFlight && this.Core != null)
{ {
this.Core.SaveConfig (); this.Core.SaveConfig ();
this.Core = null; this.Core = null;
VOID_Core.Reset(); VOID_Core.Reset();
return; return;
} }
   
if (this.Core == null) if (this.Core == null)
{ {
this.Awake(); this.Awake();
} }
   
this.Core.Update (); this.Core.Update ();
   
if (this.Core.vessel != null) if (this.Core.vessel != null)
{ {
SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter / SimManager.Instance.Gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /
Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2); Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);
SimManager.Instance.TryStartSimulation(); SimManager.Instance.TryStartSimulation();
} }
   
if (this.Core.factoryReset) if (this.Core.factoryReset)
{ {
KSP.IO.File.Delete<VOID_Core>("config.xml"); KSP.IO.File.Delete<VOID_Core>("config.xml");
this.Core = null; this.Core = null;
VOID_Core.Reset(); VOID_Core.Reset();
} }
} }
   
public void FixedUpdate() public void FixedUpdate()
{ {
if (this.Core == null || !HighLogic.LoadedSceneIsFlight) if (this.Core == null || !HighLogic.LoadedSceneIsFlight)
{ {
return; return;
} }
   
this.Core.FixedUpdate (); this.Core.FixedUpdate ();
} }
   
public void OnGUI() public void OnGUI()
{ {
if (this.Core == null) if (this.Core == null)
{ {
return; return;
} }
   
this.Core.OnGUI(); this.Core.OnGUI();
} }
} }
   
[KSPAddon(KSPAddon.Startup.EditorAny, false)] [KSPAddon(KSPAddon.Startup.EditorAny, false)]
public class VOIDEditorMaster : MonoBehaviour public class VOIDEditorMaster : MonoBehaviour
{ {
protected VOID_EditorCore Core; protected VOID_EditorCore Core;
   
public void Awake() public void Awake()
{ {
Tools.PostDebugMessage ("VOIDEditorMaster: Waking up."); Tools.PostDebugMessage ("VOIDEditorMaster: Waking up.");
this.Core = VOID_EditorCore.Instance; this.Core = VOID_EditorCore.Instance;
this.Core.ResetGUI (); this.Core.ResetGUI ();
  SimManager.HardReset();
Tools.PostDebugMessage ("VOIDEditorMaster: Awake."); Tools.PostDebugMessage ("VOIDEditorMaster: Awake.");
} }
   
public void Update() public void Update()
{ {
if (!HighLogic.LoadedSceneIsEditor && this.Core != null) if (!HighLogic.LoadedSceneIsEditor && this.Core != null)
{ {
this.Core.SaveConfig (); this.Core.SaveConfig ();
this.Core = null; this.Core = null;
VOID_EditorCore.Reset(); VOID_EditorCore.Reset();
return; return;
} }
   
if (this.Core == null) if (this.Core == null)
{ {
this.Awake(); this.Awake();
} }
   
this.Core.Update (); this.Core.Update ();
   
if (this.Core.factoryReset) if (this.Core.factoryReset)
{ {
KSP.IO.File.Delete<VOID_EditorCore>("config.xml"); KSP.IO.File.Delete<VOID_EditorCore>("config.xml");
this.Core = null; this.Core = null;
VOID_EditorCore.Reset(); VOID_EditorCore.Reset();
} }
} }
   
public void FixedUpdate() public void FixedUpdate()
{ {
if (this.Core == null || !HighLogic.LoadedSceneIsEditor) if (this.Core == null || !HighLogic.LoadedSceneIsEditor)
{ {
return; return;
} }
   
this.Core.FixedUpdate (); this.Core.FixedUpdate ();
} }
   
public void OnGUI() public void OnGUI()
{ {
if (this.Core == null) if (this.Core == null)
{ {
return; return;
} }
   
this.Core.OnGUI(); this.Core.OnGUI();
} }
} }
} }
   
// //
// VOID_Orbital.cs // VOID_Orbital.cs
// //
// Author: // Author:
// toadicus <> // toadicus <>
// //
// Copyright (c) 2013 toadicus // Copyright (c) 2013 toadicus
// //
// This program is free software: you can redistribute it and/or modify // This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or // the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version. // (at your option) any later version.
// //
// This program is distributed in the hope that it will be useful, // This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of // but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details. // GNU General Public License for more details.
// //
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>. // along with this program. If not, see <http://www.gnu.org/licenses/>.
using KSP; using KSP;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using UnityEngine; using UnityEngine;
  using Engineer.VesselSimulator;
   
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;
   
protected VOID_DoubleValue geeForce = new VOID_DoubleValue( protected VOID_DoubleValue geeForce = new VOID_DoubleValue(
"G-force", "G-force",
new Func<double>(() => VOID_Core.Instance.vessel.geeForce), new Func<double>(() => VOID_Core.Instance.vessel.geeForce),
"gees" "gees"
); );
   
protected VOID_IntValue partCount = new VOID_IntValue( protected VOID_IntValue partCount = new VOID_IntValue(
"Parts", "Parts",
new Func<int>(() => VOID_Core.Instance.vessel.Parts.Count), new Func<int>(() => VOID_Core.Instance.vessel.Parts.Count),
"" ""
); );
   
protected VOID_DoubleValue totalMass = new VOID_DoubleValue( protected VOID_DoubleValue totalMass = new VOID_DoubleValue(
"Total Mass", "Total Mass",
new Func<double>(() => VOID_Core.Instance.vessel.GetTotalMass()), new Func<double>(() => VOID_Core.Instance.vessel.GetTotalMass()),
"tons" "tons"
); );
   
protected VOID_DoubleValue resourceMass = new VOID_DoubleValue( protected VOID_DoubleValue resourceMass = new VOID_DoubleValue(
"Resource Mass", "Resource Mass",
delegate() delegate()
{ {
double rscMass = 0; double rscMass = 0;
foreach (Part part in VOID_Core.Instance.vessel.Parts) foreach (Part part in VOID_Core.Instance.vessel.Parts)
{ {
rscMass += part.GetResourceMass(); rscMass += part.GetResourceMass();
} }
return rscMass; return rscMass;
}, },
"tons" "tons"
); );
   
protected VOID_DoubleValue stageDeltaV = new VOID_DoubleValue( protected VOID_DoubleValue stageDeltaV = new VOID_DoubleValue(
"DeltaV (Current Stage)", "DeltaV (Current Stage)",
delegate() delegate()
{ {
if (Engineer.VesselSimulator.SimManager.Instance.Stages == null || if (SimManager.Instance.Stages == null ||
Engineer.VesselSimulator.SimManager.Instance.Stages.Length <= Staging.lastStage SimManager.Instance.Stages.Length <= Staging.lastStage
) )
return double.NaN; return double.NaN;
return Engineer.VesselSimulator.SimManager.Instance.Stages[Staging.lastStage].deltaV; return SimManager.Instance.Stages[Staging.lastStage].deltaV;
}, },
"m/s" "m/s"
); );
   
protected VOID_DoubleValue totalDeltaV = new VOID_DoubleValue( protected VOID_DoubleValue totalDeltaV = new VOID_DoubleValue(
"DeltaV (Total)", "DeltaV (Total)",
delegate() delegate()
{ {
if (Engineer.VesselSimulator.SimManager.Instance.Stages == null) if (SimManager.Instance.Stages == null)
return double.NaN; return double.NaN;
return Engineer.VesselSimulator.SimManager.Instance.LastStage.totalDeltaV; return SimManager.Instance.LastStage.totalDeltaV;
}, },
"m/s" "m/s"
); );
   
protected VOID_FloatValue mainThrottle = new VOID_FloatValue( protected VOID_FloatValue mainThrottle = new VOID_FloatValue(
"Throttle", "Throttle",
new Func<float>(() => VOID_Core.Instance.vessel.ctrlState.mainThrottle * 100f), new Func<float>(() => VOID_Core.Instance.vessel.ctrlState.mainThrottle * 100f),
"%" "%"
); );
   
protected VOID_StrValue currmaxThrust = new VOID_StrValue( protected VOID_StrValue currmaxThrust = new VOID_StrValue(
"Thrust (curr/max)", "Thrust (curr/max)",
delegate() delegate()
{ {
if (Engineer.VesselSimulator.SimManager.Instance.Stages == null) if (SimManager.Instance.Stages == null)
return "N/A"; return "N/A";
   
double currThrust = Engineer.VesselSimulator.SimManager.Instance.LastStage.actualThrust; double currThrust = SimManager.Instance.LastStage.actualThrust;
double maxThrust = Engineer.VesselSimulator.SimManager.Instance.LastStage.thrust; double maxThrust = SimManager.Instance.LastStage.thrust;
   
return string.Format( return string.Format(
"{0} / {1}", "{0} / {1}",
currThrust.ToString("F1"), currThrust.ToString("F1"),
maxThrust.ToString("F1") maxThrust.ToString("F1")
); );
} }
); );
   
protected VOID_StrValue currmaxThrustWeight = new VOID_StrValue( protected VOID_StrValue currmaxThrustWeight = new VOID_StrValue(
"T:W (curr/max)", "T:W (curr/max)",
delegate() delegate()
{ {
if (Engineer.VesselSimulator.SimManager.Instance.Stages == null) if (SimManager.Instance.Stages == null)
return "N/A"; return "N/A";
   
double currThrust = Engineer.VesselSimulator.SimManager.Instance.LastStage.actualThrust; double currThrust = SimManager.Instance.LastStage.actualThrust;
double maxThrust = Engineer.VesselSimulator.SimManager.Instance.LastStage.thrust; double maxThrust = SimManager.Instance.LastStage.thrust;
double mass = VOID_Core.Instance.vessel.GetTotalMass(); double mass = VOID_Core.Instance.vessel.GetTotalMass();
double gravity = VOID_Core.Instance.vessel.mainBody.gravParameter / double gravity = VOID_Core.Instance.vessel.mainBody.gravParameter /
Math.Pow( Math.Pow(
VOID_Core.Instance.vessel.mainBody.Radius + VOID_Core.Instance.vessel.altitude, VOID_Core.Instance.vessel.mainBody.Radius + VOID_Core.Instance.vessel.altitude,
2 2
); );
double weight = mass * gravity; double weight = mass * gravity;
   
return string.Format( return string.Format(
"{0} / {1}", "{0} / {1}",
(currThrust / weight).ToString("F2"), (currThrust / weight).ToString("F2"),
(maxThrust / weight).ToString("F2") (maxThrust / weight).ToString("F2")
); );
} }
); );
   
protected VOID_DoubleValue surfaceThrustWeight = new VOID_DoubleValue( protected VOID_DoubleValue surfaceThrustWeight = new VOID_DoubleValue(
"Max T:W @ surface", "Max T:W @ surface",
delegate() delegate()
{ {
if (Engineer.VesselSimulator.SimManager.Instance.Stages == null) if (SimManager.Instance.Stages == null)
return double.NaN; return double.NaN;
   
double maxThrust = Engineer.VesselSimulator.SimManager.Instance.LastStage.thrust; double maxThrust = SimManager.Instance.LastStage.thrust;
double mass = VOID_Core.Instance.vessel.GetTotalMass(); double mass = VOID_Core.Instance.vessel.GetTotalMass();
double gravity = (VOID_Core.Constant_G * VOID_Core.Instance.vessel.mainBody.Mass) / double gravity = (VOID_Core.Constant_G * VOID_Core.Instance.vessel.mainBody.Mass) /
Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2); Math.Pow(VOID_Core.Instance.vessel.mainBody.Radius, 2);
double weight = mass * gravity; double weight = mass * gravity;
   
return maxThrust / weight; return maxThrust / weight;
}, },
"" ""
); );
   
public VOID_VesselInfo() : base() public VOID_VesselInfo() : base()
{ {
this._Name = "Vessel Information"; this._Name = "Vessel Information";
   
this.WindowPos.x = Screen.width - 260; this.WindowPos.x = Screen.width - 260;
this.WindowPos.y = 450; this.WindowPos.y = 450;
} }
   
public override void ModuleWindow(int _) public override void ModuleWindow(int _)
{ {
base.ModuleWindow (_); base.ModuleWindow (_);
   
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(); SimManager.Instance.RequestSimulation();
} }
   
Engineer.VesselSimulator.Stage[] stages = Engineer.VesselSimulator.SimManager.Instance.Stages; Stage[] stages = SimManager.Instance.Stages;
   
GUILayout.BeginVertical(); GUILayout.BeginVertical();
   
GUILayout.Label( GUILayout.Label(
vessel.vesselName, vessel.vesselName,
VOID_Core.Instance.LabelStyles["center_bold"], VOID_Core.Instance.LabelStyles["center_bold"],
GUILayout.ExpandWidth(true)); GUILayout.ExpandWidth(true));
   
this.geeForce.DoGUIHorizontal ("F2"); this.geeForce.DoGUIHorizontal ("F2");
   
this.partCount.DoGUIHorizontal (); this.partCount.DoGUIHorizontal ();
   
this.totalMass.DoGUIHorizontal ("F1"); this.totalMass.DoGUIHorizontal ("F1");
   
this.resourceMass.DoGUIHorizontal ("F1"); this.resourceMass.DoGUIHorizontal ("F1");
   
this.stageDeltaV.DoGUIHorizontal (3, false); this.stageDeltaV.DoGUIHorizontal (3, false);
   
this.totalDeltaV.DoGUIHorizontal (3, false); this.totalDeltaV.DoGUIHorizontal (3, false);
   
this.mainThrottle.DoGUIHorizontal ("F0"); this.mainThrottle.DoGUIHorizontal ("F0");
   
this.currmaxThrust.DoGUIHorizontal (); this.currmaxThrust.DoGUIHorizontal ();
   
this.currmaxThrustWeight.DoGUIHorizontal (); this.currmaxThrustWeight.DoGUIHorizontal ();
   
this.surfaceThrustWeight.DoGUIHorizontal ("F2"); this.surfaceThrustWeight.DoGUIHorizontal ("F2");
   
GUILayout.EndVertical(); GUILayout.EndVertical();
GUI.DragWindow(); GUI.DragWindow();
} }
} }
} }