Merge pull request #128 from post-kerbin-mining-corporation/dev

ChrisAdderley · web-flow · commit 6fedc9ae4813 · 2024-12-05T08:14:05.000-08:00
Release 0.8.1
diff --git a/GameData/SystemHeat/Plugin/SystemHeat.dll b/GameData/SystemHeat/Plugin/SystemHeat.dll
diff --git a/GameData/SystemHeat/Versioning/SystemHeat.version b/GameData/SystemHeat/Versioning/SystemHeat.version
@@ -6,7 +6,7 @@
     {
         "MAJOR":0,
         "MINOR":8,
-        "PATCH":0,
+        "PATCH":1,
         "BUILD":0
     },
     "KSP_VERSION":
diff --git a/SystemHeat/SystemHeat/HeatLoop.cs b/SystemHeat/SystemHeat/HeatLoop.cs
@@ -196,7 +196,7 @@ protected float CalculatePositiveFlux()
       return currentPosFlux;
     }
     /// <summary>
-    /// Calculates the total positive flux of the loop
+    /// Calculates the total negative flux of the loop
     /// </summary>
     protected float CalculateNegativeFlux()
     {
@@ -220,7 +220,7 @@ void SimulateIteration(float simTimeStep)
       // Calculate the loop net flux
       float currentNetFlux = CalculateNetFlux();
       PositiveFlux = CalculatePositiveFlux();
-      NegativeFlux = CalculatePositiveFlux();
+      NegativeFlux = CalculateNegativeFlux();
       float absFlux = Mathf.Abs(currentNetFlux);
 
       AllocateFlux(PositiveFlux);
diff --git a/SystemHeat/SystemHeat/Modules/ModuleSystemHeatAsteroidHarvester.cs b/SystemHeat/SystemHeat/Modules/ModuleSystemHeatAsteroidHarvester.cs
@@ -104,7 +104,12 @@ protected void GenerateHeatFlight()
     {
       if (base.ModuleIsActive())
       {
-        heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower, true);
+        float fluxScale = 1f;
+        if (base.lastTimeFactor == 0d)
+        {
+          fluxScale = 0f;
+        }
+        heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower * fluxScale, true);
       }
       else
       {
diff --git a/SystemHeat/SystemHeat/Modules/ModuleSystemHeatBaseConverterAdapter.cs b/SystemHeat/SystemHeat/Modules/ModuleSystemHeatBaseConverterAdapter.cs
@@ -111,7 +111,12 @@ void GenerateHeatFlight()
     {
       if (converterModule.ModuleIsActive())
       {
-        heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower, true);
+        float fluxScale = 1f;
+        if (converterModule.lastTimeFactor == 0d)
+        {
+          fluxScale = 0f;
+        }
+        heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower * fluxScale, true);
       }
       else
       {
diff --git a/SystemHeat/SystemHeat/Modules/ModuleSystemHeatCometHarvester.cs b/SystemHeat/SystemHeat/Modules/ModuleSystemHeatCometHarvester.cs
@@ -91,7 +91,12 @@ protected void GenerateHeatEditor()
     {
       if (base.IsActivated)
       {
-        heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower, true);
+        float fluxScale = 1f;
+        if (base.lastTimeFactor == 0d)
+        {
+          fluxScale = 0f;
+        }
+        heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower * fluxScale, true);
       }
       else
       {
diff --git a/SystemHeat/SystemHeat/Modules/ModuleSystemHeatConverter.cs b/SystemHeat/SystemHeat/Modules/ModuleSystemHeatConverter.cs
@@ -27,7 +27,7 @@ public class ModuleSystemHeatConverter : ModuleResourceConverter
 
     // Map system outlet temperature (K) to heat generation (kW)
     [KSPField(isPersistant = false)]
-    public float systemPower =0f;
+    public float systemPower = 0f;
 
 
     // 
@@ -65,7 +65,7 @@ public override string GetInfo()
         return info;
       else
         return info.Substring(0, pos) + Localizer.Format("#LOC_SystemHeat_ModuleSystemHeatConverter_PartInfoAdd",
-          Utils.ToSI(systemPower,"F0"),
+          Utils.ToSI(systemPower, "F0"),
           systemOutletTemperature.ToString("F0"),
           shutdownTemperature.ToString("F0")
           ) + info.Substring(pos);
@@ -131,14 +131,19 @@ protected void GenerateHeatEditor()
 
     protected void GenerateHeatFlight()
     {
-        if (base.ModuleIsActive())
-        {
-          heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower, true);
-        }
-        else
+      if (base.ModuleIsActive())
+      {
+        float fluxScale = 1f;
+        if (base.lastTimeFactor == 0d)
         {
-          heatModule.AddFlux(moduleID, 0f, 0f, false);
+          fluxScale = 0f;
         }
+        heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower * fluxScale, true);
+      }
+      else
+      {
+        heatModule.AddFlux(moduleID, 0f, 0f, false);
+      }
     }
     protected void UpdateSystemHeatFlight()
     {
@@ -153,9 +158,9 @@ protected void UpdateSystemHeatFlight()
                                                              3.0f,
                                                              ScreenMessageStyle.UPPER_CENTER));
           ToggleResourceConverterAction(new KSPActionParam(0, KSPActionType.Activate));
-         
-            Utils.Log("[ModuleSystemHeatConverter]: Overheated, shutdown fired", LogType.Modules);
-          
+
+          Utils.Log("[ModuleSystemHeatConverter]: Overheated, shutdown fired", LogType.Modules);
+
         }
         base._recipe = ModuleUtils.RecalculateRatios(systemEfficiency.Evaluate(heatModule.currentLoopTemperature), inputs, outputs, inputList, outputList, base._recipe);
       }
diff --git a/SystemHeat/SystemHeat/Modules/ModuleSystemHeatFissionReactor.cs b/SystemHeat/SystemHeat/Modules/ModuleSystemHeatFissionReactor.cs
@@ -95,6 +95,13 @@ public class ModuleSystemHeatFissionReactor : PartModule, IContractObjectiveModu
     [KSPField(isPersistant = true)]
     public float CurrentElectricalGeneration = 0f;
 
+    /// <summary>
+    /// Amount of power that could generated by reactor
+    /// </summary>
+    [KSPField(isPersistant = true)]
+    public float MaxElectricalGeneration = 0f;
+
+
     // Reactor Status string
     [KSPField(isPersistant = false, guiActive = true, guiName = "#LOC_SystemHeat_ModuleSystemHeatFissionReactor_Field_GeneratorStatus", groupName = "fissionreactor", groupDisplayName = "#LOC_SystemHeat_ModuleSystemHeatFissionReactor_UIGroup_Title")]
     public string GeneratorStatus;
@@ -663,6 +670,7 @@ public virtual void FixedUpdate()
         if (GeneratesElectricity)
         {
           CurrentElectricalGeneration = ElectricalGeneration.Evaluate(CurrentThrottle);
+          MaxElectricalGeneration = CurrentElectricalGeneration;
         }
 
       }
@@ -695,6 +703,7 @@ public virtual void FixedUpdate()
         else
         {
           CurrentElectricalGeneration = 0f;
+          MaxElectricalGeneration = 0f;
         }
       }
     }
@@ -783,21 +792,34 @@ private void HandleCore()
       }
     }
 
+    private double[] ecDeltas = new double[60];
     protected virtual float CalculateGoalThrottle(float timeStep)
     {
-      double shipEC = 0d;
-      double shipMaxEC = 0d;
-      // Determine need for power
-      part.GetConnectedResourceTotals(PartResourceLibrary.ElectricityHashcode, out shipEC, out shipMaxEC, true);
 
-      float maxGeneration = ElectricalGeneration.Evaluate(100f) * CoreIntegrity / 100f;
+      // Determine need for power this frame
+      part.GetConnectedResourceTotals(PartResourceLibrary.ElectricityHashcode, out double shipEC, out double shipMaxEC, true);
+      double[] ecDeltas2 = new double[10];
+      for (int i = 1; i < ecDeltas2.Length; i++)
+      {
+        ecDeltas2[i] = ecDeltas[i - 1];
+      }
+      ecDeltas = ecDeltas2;
+      ecDeltas[0] = shipMaxEC - shipEC;
+
+      double weightedAvgNeed = 0d;
+      for (int i = 0; i < ecDeltas.Length; i++)
+      {
+        weightedAvgNeed += ecDeltas[i];
+      }
+      weightedAvgNeed /= (double)ecDeltas.Length;
+
+      float maxGeneration = ElectricalGeneration.Evaluate(100f) * CoreIntegrity / 100f * timeStep;
       float minGeneration = ElectricalGeneration.Evaluate(MinimumThrottle) * timeStep;
-      float idealGeneration = Mathf.Min(maxGeneration * timeStep, (float)(shipMaxEC - shipEC));
+      float idealGeneration = Mathf.Min(maxGeneration, (float)weightedAvgNeed * 1.05f);
       float powerToGenerate = Mathf.Max(minGeneration, idealGeneration);
 
-      return (powerToGenerate / timeStep) / maxGeneration * 100f;
+      return (powerToGenerate / maxGeneration) * 100f;
     }
-
     public virtual string GetContractObjectiveType()
     {
       return "Generator";
@@ -814,7 +836,9 @@ private void HandleResourceActivities(float timeStep)
     {
 
       if (!ManualControl)
+      {
         CurrentReactorThrottle = CalculateGoalThrottle(timeStep);
+      }
 
       fuelCheckPassed = true;
       burnRate = 0d;
@@ -858,7 +882,7 @@ private void HandleResourceActivities(float timeStep)
           }
         }
         if (ratio.ResourceName == FuelName)
-        {          
+        {
           burnRate = fuelThrottle * ratio.Ratio;
         }
       }
@@ -876,10 +900,19 @@ private void HandleResourceActivities(float timeStep)
         if (HighLogic.LoadedSceneIsEditor)
         {
           CurrentElectricalGeneration = ElectricalGeneration.Evaluate(CurrentReactorThrottle);
+          MaxElectricalGeneration = CurrentElectricalGeneration;
         }
         if (fuelCheckPassed)
         {
           CurrentElectricalGeneration = ElectricalGeneration.Evaluate(CurrentThrottle);
+          if (ManualControl)
+          {
+            MaxElectricalGeneration = CurrentElectricalGeneration;
+          }
+          else
+          {
+            MaxElectricalGeneration = ElectricalGeneration.Evaluate(100f) * CoreIntegrity / 100f;
+          }
           this.part.RequestResource(PartResourceLibrary.ElectricityHashcode, -CurrentElectricalGeneration * timeStep, ResourceFlowMode.ALL_VESSEL);
         }
       }
diff --git a/SystemHeat/SystemHeat/Modules/ModuleSystemHeatHarvester.cs b/SystemHeat/SystemHeat/Modules/ModuleSystemHeatHarvester.cs
@@ -118,7 +118,12 @@ protected void GenerateHeatFlight()
     {
       if (base.ModuleIsActive())
       {
-        heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower, true);
+        float fluxScale = 1f;
+        if (base.lastTimeFactor == 0d)
+        {
+          fluxScale = 0f;
+        }
+        heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower * fluxScale, true);
       }
       else
       {
diff --git a/SystemHeat/SystemHeat/SystemHeat.cs b/SystemHeat/SystemHeat/SystemHeat.cs
@@ -165,6 +165,7 @@ public static void Load()
 
         settingsNode.TryGetValue("SimulationRateEditor", ref SimulationRateEditor);
         settingsNode.TryGetValue("AbsFluxThreshold", ref AbsFluxThreshold);
+        settingsNode.TryGetValue("HeatLoopDecayCoefficient", ref HeatLoopDecayCoefficient);
 
         settingsNode.TryGetValue("UIScrollSensitivity", ref UISrollSensitivity);
 
diff --git a/changelog.txt b/changelog.txt
@@ -1,3 +1,10 @@
+v0.8.1
+------
+- Fixed an issue which would cause the heat loop animation in the overlay not to play if there was a loop with only negative fluxes (#125)
+- Behavior of things based on stock Converter code (converters, drills, harvesters) should now be more consistent
+- Tweaked reporting of Fission Reactor power generation (related to DBS bug)
+- Added configurable HeatLoopDecayCoefficient to Settings.cfg
+
 v0.8.0
 ------
 - Updates to zn-ch localization
diff --git a/readme.txt b/readme.txt
@@ -1,5 +1,5 @@
 ================
-SystemHeat 0.8.0
+SystemHeat 0.8.1
 ================
 
 A mod for Kerbal Space Program, intended to provide a better experience for heat management, particularly geared towards resource extraction, high energy engines, and nuclear reactors.

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@`
`6`	`6`	`{`
`7`	`7`	`"MAJOR":0,`
`8`	`8`	`"MINOR":8,`
`9`		`- "PATCH":0,`
	`9`	`+ "PATCH":1,`
`10`	`10`	`"BUILD":0`
`11`	`11`	`},`
`12`	`12`	`"KSP_VERSION":`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,12 @@ protected void GenerateHeatFlight()`
`104`	`104`	`{`
`105`	`105`	`if (base.ModuleIsActive())`
`106`	`106`	`{`
`107`		`- heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower, true);`
	`107`	`+ float fluxScale = 1f;`
	`108`	`+ if (base.lastTimeFactor == 0d)`
	`109`	`+ {`
	`110`	`+ fluxScale = 0f;`
	`111`	`+ }`
	`112`	`+ heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower * fluxScale, true);`
`108`	`113`	`}`
`109`	`114`	`else`
`110`	`115`	`{`
Original file line number	Diff line number	Diff line change
`@@ -111,7 +111,12 @@ void GenerateHeatFlight()`
`111`	`111`	`{`
`112`	`112`	`if (converterModule.ModuleIsActive())`
`113`	`113`	`{`
`114`		`- heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower, true);`
	`114`	`+ float fluxScale = 1f;`
	`115`	`+ if (converterModule.lastTimeFactor == 0d)`
	`116`	`+ {`
	`117`	`+ fluxScale = 0f;`
	`118`	`+ }`
	`119`	`+ heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower * fluxScale, true);`
`115`	`120`	`}`
`116`	`121`	`else`
`117`	`122`	`{`
Original file line number	Diff line number	Diff line change
`@@ -91,7 +91,12 @@ protected void GenerateHeatEditor()`
`91`	`91`	`{`
`92`	`92`	`if (base.IsActivated)`
`93`	`93`	`{`
`94`		`- heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower, true);`
	`94`	`+ float fluxScale = 1f;`
	`95`	`+ if (base.lastTimeFactor == 0d)`
	`96`	`+ {`
	`97`	`+ fluxScale = 0f;`
	`98`	`+ }`
	`99`	`+ heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower * fluxScale, true);`
`95`	`100`	`}`
`96`	`101`	`else`
`97`	`102`	`{`
Original file line number	Diff line number	Diff line change
`@@ -95,6 +95,13 @@ public class ModuleSystemHeatFissionReactor : PartModule, IContractObjectiveModu`
`95`	`95`	`[KSPField(isPersistant = true)]`
`96`	`96`	`public float CurrentElectricalGeneration = 0f;`
`97`	`97`
	`98`	`+ /// <summary>`
	`99`	`+ /// Amount of power that could generated by reactor`
	`100`	`+ /// </summary>`
	`101`	`+ [KSPField(isPersistant = true)]`
	`102`	`+ public float MaxElectricalGeneration = 0f;`
	`103`	`+`
	`104`	`+`
`98`	`105`	`// Reactor Status string`
`99`	`106`	`[KSPField(isPersistant = false, guiActive = true, guiName = "#LOC_SystemHeat_ModuleSystemHeatFissionReactor_Field_GeneratorStatus", groupName = "fissionreactor", groupDisplayName = "#LOC_SystemHeat_ModuleSystemHeatFissionReactor_UIGroup_Title")]`
`100`	`107`	`public string GeneratorStatus;`
`@@ -663,6 +670,7 @@ public virtual void FixedUpdate()`
`663`	`670`	`if (GeneratesElectricity)`
`664`	`671`	`{`
`665`	`672`	`CurrentElectricalGeneration = ElectricalGeneration.Evaluate(CurrentThrottle);`
	`673`	`+ MaxElectricalGeneration = CurrentElectricalGeneration;`
`666`	`674`	`}`
`667`	`675`
`668`	`676`	`}`
`@@ -695,6 +703,7 @@ public virtual void FixedUpdate()`
`695`	`703`	`else`
`696`	`704`	`{`
`697`	`705`	`CurrentElectricalGeneration = 0f;`
	`706`	`+ MaxElectricalGeneration = 0f;`
`698`	`707`	`}`
`699`	`708`	`}`
`700`	`709`	`}`
`@@ -783,21 +792,34 @@ private void HandleCore()`
`783`	`792`	`}`
`784`	`793`	`}`
`785`	`794`
	`795`	`+ private double[] ecDeltas = new double[60];`
`786`	`796`	`protected virtual float CalculateGoalThrottle(float timeStep)`
`787`	`797`	`{`
`788`		`- double shipEC = 0d;`
`789`		`- double shipMaxEC = 0d;`
`790`		`- // Determine need for power`
`791`		`- part.GetConnectedResourceTotals(PartResourceLibrary.ElectricityHashcode, out shipEC, out shipMaxEC, true);`
`792`	`798`
`793`		`- float maxGeneration = ElectricalGeneration.Evaluate(100f) * CoreIntegrity / 100f;`
	`799`	`+ // Determine need for power this frame`
	`800`	`+ part.GetConnectedResourceTotals(PartResourceLibrary.ElectricityHashcode, out double shipEC, out double shipMaxEC, true);`
	`801`	`+ double[] ecDeltas2 = new double[10];`
	`802`	`+ for (int i = 1; i < ecDeltas2.Length; i++)`
	`803`	`+ {`
	`804`	`+ ecDeltas2[i] = ecDeltas[i - 1];`
	`805`	`+ }`
	`806`	`+ ecDeltas = ecDeltas2;`
	`807`	`+ ecDeltas[0] = shipMaxEC - shipEC;`
	`808`	`+`
	`809`	`+ double weightedAvgNeed = 0d;`
	`810`	`+ for (int i = 0; i < ecDeltas.Length; i++)`
	`811`	`+ {`
	`812`	`+ weightedAvgNeed += ecDeltas[i];`
	`813`	`+ }`
	`814`	`+ weightedAvgNeed /= (double)ecDeltas.Length;`
	`815`	`+`
	`816`	`+ float maxGeneration = ElectricalGeneration.Evaluate(100f) * CoreIntegrity / 100f * timeStep;`
`794`	`817`	`float minGeneration = ElectricalGeneration.Evaluate(MinimumThrottle) * timeStep;`
`795`		`- float idealGeneration = Mathf.Min(maxGeneration * timeStep, (float)(shipMaxEC - shipEC));`
	`818`	`+ float idealGeneration = Mathf.Min(maxGeneration, (float)weightedAvgNeed * 1.05f);`
`796`	`819`	`float powerToGenerate = Mathf.Max(minGeneration, idealGeneration);`
`797`	`820`
`798`		`- return (powerToGenerate / timeStep) / maxGeneration * 100f;`
	`821`	`+ return (powerToGenerate / maxGeneration) * 100f;`
`799`	`822`	`}`
`800`		`-`
`801`	`823`	`public virtual string GetContractObjectiveType()`
`802`	`824`	`{`
`803`	`825`	`return "Generator";`
`@@ -814,7 +836,9 @@ private void HandleResourceActivities(float timeStep)`
`814`	`836`	`{`
`815`	`837`
`816`	`838`	`if (!ManualControl)`
	`839`	`+ {`
`817`	`840`	`CurrentReactorThrottle = CalculateGoalThrottle(timeStep);`
	`841`	`+ }`
`818`	`842`
`819`	`843`	`fuelCheckPassed = true;`
`820`	`844`	`burnRate = 0d;`
`@@ -858,7 +882,7 @@ private void HandleResourceActivities(float timeStep)`
`858`	`882`	`}`
`859`	`883`	`}`
`860`	`884`	`if (ratio.ResourceName == FuelName)`
`861`		`- {`
	`885`	`+ {`
`862`	`886`	`burnRate = fuelThrottle * ratio.Ratio;`
`863`	`887`	`}`
`864`	`888`	`}`
`@@ -876,10 +900,19 @@ private void HandleResourceActivities(float timeStep)`
`876`	`900`	`if (HighLogic.LoadedSceneIsEditor)`
`877`	`901`	`{`
`878`	`902`	`CurrentElectricalGeneration = ElectricalGeneration.Evaluate(CurrentReactorThrottle);`
	`903`	`+ MaxElectricalGeneration = CurrentElectricalGeneration;`
`879`	`904`	`}`
`880`	`905`	`if (fuelCheckPassed)`
`881`	`906`	`{`
`882`	`907`	`CurrentElectricalGeneration = ElectricalGeneration.Evaluate(CurrentThrottle);`
	`908`	`+ if (ManualControl)`
	`909`	`+ {`
	`910`	`+ MaxElectricalGeneration = CurrentElectricalGeneration;`
	`911`	`+ }`
	`912`	`+ else`
	`913`	`+ {`
	`914`	`+ MaxElectricalGeneration = ElectricalGeneration.Evaluate(100f) * CoreIntegrity / 100f;`
	`915`	`+ }`
`883`	`916`	`this.part.RequestResource(PartResourceLibrary.ElectricityHashcode, -CurrentElectricalGeneration * timeStep, ResourceFlowMode.ALL_VESSEL);`
`884`	`917`	`}`
`885`	`918`	`}`
Original file line number	Diff line number	Diff line change
`@@ -118,7 +118,12 @@ protected void GenerateHeatFlight()`
`118`	`118`	`{`
`119`	`119`	`if (base.ModuleIsActive())`
`120`	`120`	`{`
`121`		`- heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower, true);`
	`121`	`+ float fluxScale = 1f;`
	`122`	`+ if (base.lastTimeFactor == 0d)`
	`123`	`+ {`
	`124`	`+ fluxScale = 0f;`
	`125`	`+ }`
	`126`	`+ heatModule.AddFlux(moduleID, systemOutletTemperature, systemPower * fluxScale, true);`
`122`	`127`	`}`
`123`	`128`	`else`
`124`	`129`	`{`