OverclockEverything: fix on loading

OverclockEverything/BeltFix.cs

@@ -7,8 +7,7 @@ namespace OverclockEverything;
 [HarmonyPatch]
 public static class BeltFix
 {
-    private static CodeInstruction[] LdcInstrs = new[]
+    private static readonly CodeInstruction[] LdcInstrs = {
-    {
         new CodeInstruction(OpCodes.Ldc_I4_0), new CodeInstruction(OpCodes.Ldc_I4_1), new CodeInstruction(OpCodes.Ldc_I4_2),
         new CodeInstruction(OpCodes.Ldc_I4_3), new CodeInstruction(OpCodes.Ldc_I4_4), new CodeInstruction(OpCodes.Ldc_I4_5),
         new CodeInstruction(OpCodes.Ldc_I4_6), new CodeInstruction(OpCodes.Ldc_I4_7), new CodeInstruction(OpCodes.Ldc_I4_8),
@@ -17,7 +16,7 @@ public static class BeltFix
     [HarmonyTranspiler, HarmonyPatch(typeof(CargoTraffic), "AlterBeltRenderer")]
     public static IEnumerable<CodeInstruction> CargoTraffic_AlterBeltRenderer_Transpiler(IEnumerable<CodeInstruction> instructions)
     {
-        bool lastIsSpeed = false;
+        var lastIsSpeed = false;
         foreach (var instr in instructions)
         {
             if (lastIsSpeed)
@@ -25,11 +24,11 @@ public static class BeltFix
                 lastIsSpeed = false;
                 if (instr.opcode == OpCodes.Ldc_I4_1)
                 {
-                    yield return LdcInstrs[Patch.beltSpeed[0]];
+                    yield return LdcInstrs[Patch.Cfg.BeltSpeed[0]];
                 }
                 else if (instr.opcode == OpCodes.Ldc_I4_2)
                 {
-                    yield return LdcInstrs[Patch.beltSpeed[1]];
+                    yield return LdcInstrs[Patch.Cfg.BeltSpeed[1]];
                 }
                 else
                 {
@@ -51,7 +50,7 @@ public static class BeltFix
     [HarmonyPatch(typeof(ConnGizmoRenderer), "AddBlueprintBeltConn")]
     public static void ConnGizmoRenderer_AddBlueprintBelt_Prefix(ref ConnGizmoRenderer __instance, ref uint color)
     {
-        var bspeed = Patch.beltSpeed;
+        var bspeed = Patch.Cfg.BeltSpeed;
         color = color >= bspeed[2] ? 3u : color >= bspeed[1] ? 2u : 1u;
     }
 
@@ -71,7 +70,7 @@ public static class BeltFix
                     var label1 = generator.DefineLabel();
                     var label2 = generator.DefineLabel();
                     yield return new CodeInstruction(OpCodes.Ldloc_S, 6);
-                    yield return LdcInstrs[Patch.beltSpeed[1]];
+                    yield return LdcInstrs[Patch.Cfg.BeltSpeed[1]];
                     yield return new CodeInstruction(OpCodes.Bne_Un_S, label1);
                     yield return new CodeInstruction(OpCodes.Ldloca_S, 0);
                     yield return new CodeInstruction(OpCodes.Ldc_I4_2);
@@ -79,7 +78,7 @@ public static class BeltFix
                         AccessTools.Field(typeof(ConnGizmoObj), nameof(ConnGizmoObj.color)));
                     yield return new CodeInstruction(OpCodes.Br, label2);
                     yield return new CodeInstruction(OpCodes.Ldloc_S, 6).WithLabels(label1);
-                    yield return LdcInstrs[Patch.beltSpeed[0]];
+                    yield return LdcInstrs[Patch.Cfg.BeltSpeed[0]];
                     yield return new CodeInstruction(OpCodes.Bne_Un_S, label2);
                     yield return new CodeInstruction(OpCodes.Ldloca_S, 0);
                     yield return new CodeInstruction(OpCodes.Ldc_I4_1);

OverclockEverything/Cfg.cs

@@ -0,0 +1,26 @@
+namespace OverclockEverything;
+
+public struct Cfg
+{
+    public Cfg()
+    {
+    }
+
+    public readonly uint[] BeltSpeed = {
+        2, 5, 10
+    };
+    public int SorterSpeedMultiplier = 1;
+    public int SorterPowerConsumptionMultiplier = 1;
+    public int AssembleSpeedMultiplier = 1;
+    public int AssemblePowerConsumptionMultiplier = 1;
+    public int ResearchSpeedMultiplier = 1;
+    public int LabPowerConsumptionMultiplier = 1;
+    public int MinerSpeedMultiplier = 1;
+    public int MinerPowerConsumptionMultiplier = 1;
+    public long PowerGenerationMultiplier = 1;
+    public long PowerFuelConsumptionMultiplier = 1;
+    public long PowerSupplyAreaMultiplier = 1;
+    public int EjectMultiplier = 1;
+    public int SiloMultiplier = 1;
+    public int InventoryStackMultiplier = 1;
+}

OverclockEverything/OverclockEverything.cs

@@ -1,83 +1,114 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Reflection.Emit;
 using BepInEx;
 using BepInEx.Configuration;
+using crecheng.DSPModSave;
 using HarmonyLib;
 using UnityEngine;
 
 namespace OverclockEverything;
 
 [BepInPlugin(PluginInfo.PLUGIN_GUID, PluginInfo.PLUGIN_NAME, PluginInfo.PLUGIN_VERSION)]
-public class Patch : BaseUnityPlugin
+[BepInDependency(DSPModSavePlugin.MODGUID)]
+public class Patch : BaseUnityPlugin, IModCanSave
 {
     private new static readonly BepInEx.Logging.ManualLogSource Logger =
         BepInEx.Logging.Logger.CreateLogSource(PluginInfo.PLUGIN_NAME);
 
-    private bool _cfgEnabled = true;
+    private const ushort SaveVersion = 1;
-    public static uint[] beltSpeed = {
+    private static bool _initialized = false;
-        2, 5, 10
+    public static Cfg Cfg = new();
-    };
+    private static Cfg _oldCfg;
-
-    private static bool initialized = false;
-    private static int sorterSpeedMultiplier = 2;
-    private static int sorterPowerConsumptionMultiplier = 2;
-    private static int assembleSpeedMultiplier = 2;
-    private static int assemblePowerConsumptionMultiplier = 2;
-    private static int researchSpeedMultiplier = 2;
-    private static int labPowerConsumptionMultiplier = 2;
-    private static int minerSpeedMultiplier = 2;
-    private static int minerPowerConsumptionMultiplier = 2;
-    private static long powerGenerationMultiplier = 4;
-    private static long powerFuelConsumptionMultiplier = 1;
-    private static long powerSupplyAreaMultiplier = 2;
-    private static int ejectMultiplier = 2;
-    private static int siloMultiplier = 2;
-    private static int inventoryStackMultiplier = 5;
 
     private void Awake()
     {
-        _cfgEnabled = Config.Bind("General", "Enabled", _cfgEnabled, "enable/disable this plugin").Value;
+        var cfgEnabled = Config.Bind("General", "Enabled", true, "Enable/Disable this plugin").Value;
-        if (!_cfgEnabled) return;
+        if (!cfgEnabled) return;
-        beltSpeed[0] = Config.Bind("Belt", "MkI_Speed", beltSpeed[0],
+        Cfg.BeltSpeed[0] = Config.Bind("Belt", "MkI_Speed", Cfg.BeltSpeed[0],
             new ConfigDescription("Speed for Belt Mk.I.\n  1: 6/s\n  2: 12/s\n  3: 15/s(Displayed as 18/s)\n  4: 20/s(Displayed as 24/s)\n  5+: 6*n/s", new AcceptableValueRange<uint>(1, 10))).Value;
-        beltSpeed[1] = Config.Bind("Belt", "MkII_Speed", beltSpeed[1],
+        Cfg.BeltSpeed[1] = Config.Bind("Belt", "MkII_Speed", Cfg.BeltSpeed[1],
             new ConfigDescription("Speed for Belt Mk.II", new AcceptableValueRange<uint>(1, 10))).Value;
-        beltSpeed[2] = Config.Bind("Belt", "MkIII_Speed", beltSpeed[2],
+        Cfg.BeltSpeed[2] = Config.Bind("Belt", "MkIII_Speed", Cfg.BeltSpeed[2],
             new ConfigDescription("Speed for Belt Mk.III", new AcceptableValueRange<uint>(1, 10))).Value;
-        sorterSpeedMultiplier = Config.Bind("Sorter", "SpeedMultiplier", sorterSpeedMultiplier,
+        Cfg.SorterSpeedMultiplier = Config.Bind("Sorter", "SpeedMultiplier", Cfg.SorterSpeedMultiplier,
             new ConfigDescription("Speed multiplier for Sorters", new AcceptableValueRange<int>(1, 5))).Value;
-        sorterPowerConsumptionMultiplier = Config.Bind("Sorter", "PowerConsumptionMultiplier", sorterPowerConsumptionMultiplier,
+        Cfg.SorterPowerConsumptionMultiplier = Config.Bind("Sorter", "PowerConsumptionMultiplier", Cfg.SorterPowerConsumptionMultiplier,
             new ConfigDescription("Power consumption multiplier for Smelters and Assembling Machines", new AcceptableValueRange<int>(1, 100))).Value;
-        assembleSpeedMultiplier = Config.Bind("Assemble", "SpeedMultiplier", assembleSpeedMultiplier,
+        Cfg.AssembleSpeedMultiplier = Config.Bind("Assemble", "SpeedMultiplier", Cfg.AssembleSpeedMultiplier,
             new ConfigDescription("Speed multiplier for Smelters, Assembling Machines and Lab Matrices", new AcceptableValueRange<int>(1, 10))).Value;
-        assemblePowerConsumptionMultiplier = Config.Bind("Assemble", "PowerConsumptionMultiplier", assemblePowerConsumptionMultiplier,
+        Cfg.AssemblePowerConsumptionMultiplier = Config.Bind("Assemble", "PowerConsumptionMultiplier", Cfg.AssemblePowerConsumptionMultiplier,
             new ConfigDescription("Power consumption multiplier for Smelters and Assembling Machines", new AcceptableValueRange<int>(1, 100))).Value;
-        researchSpeedMultiplier = Config.Bind("Lab", "SpeedMultiplier", researchSpeedMultiplier,
+        Cfg.ResearchSpeedMultiplier = Config.Bind("Lab", "SpeedMultiplier", Cfg.ResearchSpeedMultiplier,
             new ConfigDescription("Speed multiplier for Lab Researches", new AcceptableValueRange<int>(1, 10))).Value;
-        labPowerConsumptionMultiplier = Config.Bind("Lab", "PowerConsumptionMultiplier", labPowerConsumptionMultiplier,
+        Cfg.LabPowerConsumptionMultiplier = Config.Bind("Lab", "PowerConsumptionMultiplier", Cfg.LabPowerConsumptionMultiplier,
             new ConfigDescription("Power consumption multiplier for Labs", new AcceptableValueRange<int>(1, 100))).Value;
-        minerSpeedMultiplier = Config.Bind("Miner", "SpeedMultiplier", minerSpeedMultiplier,
+        Cfg.MinerSpeedMultiplier = Config.Bind("Miner", "SpeedMultiplier", Cfg.MinerSpeedMultiplier,
             new ConfigDescription("Speed multiplier for Smelters and Assembling Machines", new AcceptableValueRange<int>(1, 10))).Value;
-        minerPowerConsumptionMultiplier = Config.Bind("Miner", "PowerConsumptionMultiplier", minerPowerConsumptionMultiplier,
+        Cfg.MinerPowerConsumptionMultiplier = Config.Bind("Miner", "PowerConsumptionMultiplier", Cfg.MinerPowerConsumptionMultiplier,
             new ConfigDescription("Power consumption multiplier for Smelters and Assembling Machines", new AcceptableValueRange<int>(1, 100))).Value;
-        powerGenerationMultiplier = Config.Bind("Power", "GenerationMultiplier", powerGenerationMultiplier,
+        Cfg.PowerGenerationMultiplier = Config.Bind("Power", "GenerationMultiplier", Cfg.PowerGenerationMultiplier,
             new ConfigDescription("Power generation multiplier for all power providers", new AcceptableValueRange<long>(1, 100))).Value;
-        powerFuelConsumptionMultiplier = Config.Bind("Power", "FuelConsumptionMultiplier", powerFuelConsumptionMultiplier,
+        Cfg.PowerFuelConsumptionMultiplier = Config.Bind("Power", "FuelConsumptionMultiplier", Cfg.PowerFuelConsumptionMultiplier,
             new ConfigDescription("Fuel consumption multiplier for all fuel-consuming power providers", new AcceptableValueRange<long>(1, 10))).Value;
-        powerSupplyAreaMultiplier = Config.Bind("Power", "SupplyAreaMultiplier", powerSupplyAreaMultiplier,
+        Cfg.PowerSupplyAreaMultiplier = Config.Bind("Power", "SupplyAreaMultiplier", Cfg.PowerSupplyAreaMultiplier,
             new ConfigDescription("Connection length and supply area radius multiplier for power providers", new AcceptableValueRange<long>(1, 10))).Value;
-        ejectMultiplier = Config.Bind("DysonSphere", "EjectMultiplier", ejectMultiplier,
+        Cfg.EjectMultiplier = Config.Bind("DysonSphere", "EjectMultiplier", Cfg.EjectMultiplier,
             new ConfigDescription("Speed multiplier for EM-Rail Ejectors", new AcceptableValueRange<int>(1, 10))).Value;
-        siloMultiplier = Config.Bind("DysonSphere", "SiloMultiplier", siloMultiplier,
+        Cfg.SiloMultiplier = Config.Bind("DysonSphere", "SiloMultiplier", Cfg.SiloMultiplier,
             new ConfigDescription("Speed multiplier for Rocket Silos", new AcceptableValueRange<int>(1, 10))).Value;
-        inventoryStackMultiplier = Config.Bind("Inventory", "StackMultiplier", inventoryStackMultiplier,
+        Cfg.InventoryStackMultiplier = Config.Bind("Inventory", "StackMultiplier", Cfg.InventoryStackMultiplier,
             new ConfigDescription("Stack count multiplier for inventory items", new AcceptableValueRange<int>(1, 10))).Value;
         Harmony.CreateAndPatchAll(typeof(Patch));
         Harmony.CreateAndPatchAll(typeof(BeltFix));
     }
 
+    public void Export(BinaryWriter w)
+    {
+        w.Write(SaveVersion);
+        w.Write(Cfg.SorterSpeedMultiplier);
+        w.Write(Cfg.SorterPowerConsumptionMultiplier);
+        w.Write(Cfg.AssembleSpeedMultiplier);
+        w.Write(Cfg.AssemblePowerConsumptionMultiplier);
+        w.Write(Cfg.ResearchSpeedMultiplier);
+        w.Write(Cfg.LabPowerConsumptionMultiplier);
+        w.Write(Cfg.MinerSpeedMultiplier);
+        w.Write(Cfg.MinerPowerConsumptionMultiplier);
+        w.Write(Cfg.PowerGenerationMultiplier);
+        w.Write(Cfg.PowerFuelConsumptionMultiplier);
+        w.Write(Cfg.PowerSupplyAreaMultiplier);
+        w.Write(Cfg.EjectMultiplier);
+        w.Write(Cfg.SiloMultiplier);
+    }
+
+    public void Import(BinaryReader r)
+    {
+        var version = r.ReadUInt16();
+        if (version <= 0) return;
+
+        _oldCfg.SorterSpeedMultiplier = r.ReadInt32();
+        _oldCfg.SorterPowerConsumptionMultiplier = r.ReadInt32();
+        _oldCfg.AssembleSpeedMultiplier = r.ReadInt32();
+        _oldCfg.AssemblePowerConsumptionMultiplier = r.ReadInt32();
+        _oldCfg.ResearchSpeedMultiplier = r.ReadInt32();
+        _oldCfg.LabPowerConsumptionMultiplier = r.ReadInt32();
+        _oldCfg.MinerSpeedMultiplier = r.ReadInt32();
+        _oldCfg.MinerPowerConsumptionMultiplier = r.ReadInt32();
+        _oldCfg.PowerGenerationMultiplier = r.ReadInt64();
+        _oldCfg.PowerFuelConsumptionMultiplier = r.ReadInt64();
+        _oldCfg.PowerSupplyAreaMultiplier = r.ReadInt64();
+        _oldCfg.EjectMultiplier = r.ReadInt32();
+        _oldCfg.SiloMultiplier = r.ReadInt32();
+    }
+
+    public void IntoOtherSave()
+    {
+    }
+
+    /* Belt fix for GalacticScale old versions, should be of no use now.
     [HarmonyTranspiler, HarmonyPatch(typeof(BuildTool_Path), "CheckBuildConditions")]
     private static IEnumerable<CodeInstruction> BuildTool_Path_CheckBuildConditions_Transpiler(
         IEnumerable<CodeInstruction> instructions)
@@ -91,6 +122,7 @@ public class Patch : BaseUnityPlugin
             yield return instr;
         }
     }
+    */
 
     [HarmonyTranspiler]
     [HarmonyPatch(typeof(UIReplicatorWindow), "OnOkButtonClick")]
@@ -103,6 +135,7 @@ public class Patch : BaseUnityPlugin
                 instr.opcode = OpCodes.Ldc_I4;
                 instr.operand = 1000;
             }
+
             yield return instr;
         }
     }
@@ -146,34 +179,17 @@ public class Patch : BaseUnityPlugin
                 instr.opcode = OpCodes.Ldc_I4;
                 instr.operand = 1000;
             }
+
             yield return instr;
         }
     }
 
-    [HarmonyTranspiler, HarmonyPatch(typeof(LabComponent), "SetFunction")]
+    [HarmonyPostfix, HarmonyPatch(typeof(LabComponent), "SetFunction")]
-    private static IEnumerable<CodeInstruction> LabComponent_SetFunction_Transpiler(IEnumerable<CodeInstruction> instructions)
+    private static void LabComponent_SetFunction_Postfix(ref LabComponent __instance)
     {
-        var lastIsLdc10000 = false;
+        if (__instance.researchMode) return;
-        foreach (var instr in instructions)
+        __instance.speed *= Cfg.AssembleSpeedMultiplier;
-        {
+        __instance.speedOverride *= Cfg.AssembleSpeedMultiplier;
-            if (instr.opcode == OpCodes.Ldc_I4 && instr.OperandIs(10000))
-            {
-                lastIsLdc10000 = true;
-            }
-            else
-            {
-                if (lastIsLdc10000)
-                {
-                    lastIsLdc10000 = false;
-                    if (instr.opcode == OpCodes.Stfld)
-                    {
-                        yield return new CodeInstruction(OpCodes.Ldc_I4, assembleSpeedMultiplier);
-                        yield return new CodeInstruction(OpCodes.Mul);
-                    }
-                }
-            }
-            yield return instr;
-        }
     }
 
     [HarmonyTranspiler, HarmonyPatch(typeof(MechaForge), "GameTick")]
@@ -183,7 +199,7 @@ public class Patch : BaseUnityPlugin
         {
             if (instr.opcode == OpCodes.Ldc_R4 && instr.OperandIs(10000f))
             {
-                yield return new CodeInstruction(OpCodes.Ldc_R4, 10000f * assembleSpeedMultiplier);
+                yield return new CodeInstruction(OpCodes.Ldc_R4, 10000f * Cfg.AssembleSpeedMultiplier);
             }
             else
             {
@@ -198,15 +214,16 @@ public class Patch : BaseUnityPlugin
         if (StorageComponent.staticLoaded) return false;
         foreach (var proto in LDB.items.dataArray)
         {
-            proto.StackSize *= inventoryStackMultiplier;
+            proto.StackSize *= Cfg.InventoryStackMultiplier;
         }
+
         return true;
     }
 
     [HarmonyPostfix, HarmonyPatch(typeof(StorageComponent), "Import")]
     private static void StorageComponent_Import_Postfix(StorageComponent __instance)
     {
-        if (inventoryStackMultiplier <= 1) return;
+        if (Cfg.InventoryStackMultiplier <= 1) return;
         var size = __instance.size;
         for (var i = 0; i < size; i++)
         {
@@ -218,22 +235,235 @@ public class Patch : BaseUnityPlugin
         }
     }
 
+    [HarmonyPrefix]
+    [HarmonyPatch(typeof(GameSave), nameof(GameSave.LoadCurrentGame))]
+    private static void GameSave_LoadCurrentGame_Prefix()
+    {
+        if (DSPGame.IsMenuDemo) return;
+        _oldCfg = new Cfg();
+    }
+
+    [HarmonyPostfix]
+    [HarmonyPriority(Priority.Last)]
+    [HarmonyPatch(typeof(GameSave), nameof(GameSave.LoadCurrentGame))]
+    private static void GameSave_LoadCurrentGame_Postfix()
+    {
+        if (DSPGame.IsMenuDemo) return;
+        var needFix = _oldCfg.SorterSpeedMultiplier != Cfg.SorterSpeedMultiplier || _oldCfg.SorterPowerConsumptionMultiplier != Cfg.SorterPowerConsumptionMultiplier ||
+                      _oldCfg.AssembleSpeedMultiplier != Cfg.AssembleSpeedMultiplier || _oldCfg.AssemblePowerConsumptionMultiplier != Cfg.AssemblePowerConsumptionMultiplier ||
+                      _oldCfg.ResearchSpeedMultiplier != Cfg.ResearchSpeedMultiplier || _oldCfg.LabPowerConsumptionMultiplier != Cfg.LabPowerConsumptionMultiplier ||
+                      _oldCfg.MinerSpeedMultiplier != Cfg.MinerSpeedMultiplier || _oldCfg.MinerPowerConsumptionMultiplier != Cfg.MinerPowerConsumptionMultiplier ||
+                      _oldCfg.PowerGenerationMultiplier != Cfg.PowerGenerationMultiplier || _oldCfg.PowerFuelConsumptionMultiplier != Cfg.PowerFuelConsumptionMultiplier ||
+                      _oldCfg.PowerSupplyAreaMultiplier != Cfg.PowerSupplyAreaMultiplier || _oldCfg.EjectMultiplier != Cfg.EjectMultiplier || _oldCfg.SiloMultiplier != Cfg.SiloMultiplier;
+        if (!needFix) return;
+        Logger.LogInfo("Config changed, fixing parameters for builds...");
+        var stopwatch = new Stopwatch();
+        stopwatch.Start();
+        foreach (var factory in GameMain.data.factories)
+        {
+            var factorySystem = factory?.factorySystem;
+            if (factorySystem == null) continue;
+            var powerSystem = factory.powerSystem;
+            if (_oldCfg.SorterSpeedMultiplier != Cfg.SorterSpeedMultiplier)
+            {
+                var om = _oldCfg.SorterSpeedMultiplier;
+                var nm = Cfg.SorterSpeedMultiplier;
+                var om2 = _oldCfg.SorterPowerConsumptionMultiplier;
+                var nm2 = Cfg.SorterPowerConsumptionMultiplier;
+                for (var i = 1; i < factorySystem.inserterCursor; i++)
+                {
+                    ref var sorter = ref factorySystem.inserterPool[i];
+                    if (sorter.id != i) continue;
+                    sorter.stt = sorter.stt * om / nm;
+                    if (sorter.time > sorter.stt)
+                    {
+                        sorter.time = sorter.stt - sorter.speed;
+                    }
+
+                    if (powerSystem == null) continue;
+                    ref var entity = ref factory.entityPool[sorter.entityId];
+                    if (entity.powerConId <= 0) continue;
+                    ref var consumer = ref powerSystem.consumerPool[entity.powerConId];
+                    consumer.idleEnergyPerTick = consumer.idleEnergyPerTick / om2 * nm2;
+                    consumer.workEnergyPerTick = consumer.workEnergyPerTick / om2 * nm2;
+                }
+            }
+
+            if (_oldCfg.AssembleSpeedMultiplier != Cfg.AssembleSpeedMultiplier || _oldCfg.LabPowerConsumptionMultiplier != Cfg.LabPowerConsumptionMultiplier)
+            {
+                var om = _oldCfg.AssembleSpeedMultiplier;
+                var nm = Cfg.AssembleSpeedMultiplier;
+                var om2 = _oldCfg.LabPowerConsumptionMultiplier;
+                var nm2 = Cfg.LabPowerConsumptionMultiplier;
+                for (var i = 1; i < factorySystem.labCursor; i++)
+                {
+                    ref var lab = ref factorySystem.labPool[i];
+                    if (lab.id != i) continue;
+                    if (!lab.researchMode)
+                    {
+                        lab.speed = lab.speed / om * nm;
+                        lab.speedOverride = lab.speedOverride / om * nm;
+                    }
+
+                    if (powerSystem == null) continue;
+                    ref var entity = ref factory.entityPool[lab.entityId];
+                    if (entity.powerConId <= 0) continue;
+                    ref var consumer = ref powerSystem.consumerPool[entity.powerConId];
+                    consumer.idleEnergyPerTick = consumer.idleEnergyPerTick / om2 * nm2;
+                    consumer.workEnergyPerTick = consumer.workEnergyPerTick / om2 * nm2;
+                }
+            }
+
+            if (_oldCfg.AssembleSpeedMultiplier != Cfg.AssembleSpeedMultiplier || _oldCfg.AssemblePowerConsumptionMultiplier != Cfg.AssemblePowerConsumptionMultiplier)
+            {
+                var om = _oldCfg.AssembleSpeedMultiplier;
+                var nm = Cfg.AssembleSpeedMultiplier;
+                var om2 = _oldCfg.AssemblePowerConsumptionMultiplier;
+                var nm2 = Cfg.AssemblePowerConsumptionMultiplier;
+                for (var i = 1; i < factorySystem.assemblerCursor; i++)
+                {
+                    ref var assembler = ref factorySystem.assemblerPool[i];
+                    if (assembler.id != i) continue;
+                    assembler.speed = assembler.speed / om * nm;
+                    assembler.speedOverride = assembler.speedOverride / om * nm;
+
+                    if (powerSystem == null) continue;
+                    ref var entity = ref factory.entityPool[assembler.entityId];
+                    if (entity.powerConId <= 0) continue;
+                    ref var consumer = ref powerSystem.consumerPool[entity.powerConId];
+                    consumer.idleEnergyPerTick = consumer.idleEnergyPerTick / om2 * nm2;
+                    consumer.workEnergyPerTick = consumer.workEnergyPerTick / om2 * nm2;
+                }
+            }
+
+            if (_oldCfg.MinerSpeedMultiplier != Cfg.MinerSpeedMultiplier || _oldCfg.MinerPowerConsumptionMultiplier != Cfg.MinerPowerConsumptionMultiplier)
+            {
+                var om = _oldCfg.MinerSpeedMultiplier;
+                var nm = Cfg.MinerSpeedMultiplier;
+                var om2 = _oldCfg.MinerPowerConsumptionMultiplier;
+                var nm2 = Cfg.MinerPowerConsumptionMultiplier;
+                for (var i = 1; i < factorySystem.minerCursor; i++)
+                {
+                    ref var miner = ref factorySystem.minerPool[i];
+                    if (miner.id != i) continue;
+                    miner.speed = miner.speed / om * nm;
+
+                    if (powerSystem == null) continue;
+                    ref var entity = ref factory.entityPool[miner.entityId];
+                    if (entity.powerConId <= 0) continue;
+                    ref var consumer = ref powerSystem.consumerPool[entity.powerConId];
+                    consumer.idleEnergyPerTick = consumer.idleEnergyPerTick / om2 * nm2;
+                    consumer.workEnergyPerTick = consumer.workEnergyPerTick / om2 * nm2;
+                }
+            }
+
+            if (powerSystem != null && (_oldCfg.PowerGenerationMultiplier != Cfg.PowerGenerationMultiplier || _oldCfg.PowerFuelConsumptionMultiplier != Cfg.PowerFuelConsumptionMultiplier))
+            {
+                var om = _oldCfg.PowerFuelConsumptionMultiplier;
+                var nm = Cfg.PowerFuelConsumptionMultiplier;
+                var om2 = _oldCfg.PowerGenerationMultiplier;
+                var nm2 = Cfg.PowerGenerationMultiplier;
+                Logger.LogInfo($"{om2} => {nm2}   {om} => {nm}");
+                for (var i = 1; i < powerSystem.genCursor; i++)
+                {
+                    ref var gen = ref powerSystem.genPool[i];
+                    if (gen.id != i) continue;
+                    gen.genEnergyPerTick = gen.genEnergyPerTick / om2 * nm2;
+                    gen.useFuelPerTick = gen.useFuelPerTick / om * nm;
+                    ref var entity = ref factory.entityPool[gen.entityId];
+                    if (entity.powerConId <= 0) continue;
+                    ref var consumer = ref powerSystem.consumerPool[entity.powerConId];
+                    consumer.idleEnergyPerTick = consumer.idleEnergyPerTick / om2 * nm2;
+                    consumer.workEnergyPerTick = consumer.workEnergyPerTick / om2 * nm2;
+                }
+
+                for (var i = 1; i < powerSystem.excCursor; i++)
+                {
+                    ref var exc = ref powerSystem.excPool[i];
+                    if (exc.id != i) continue;
+                    exc.energyPerTick = exc.energyPerTick / om * nm;
+                    ref var entity = ref factory.entityPool[exc.entityId];
+                    if (entity.powerConId <= 0) continue;
+                    ref var consumer = ref powerSystem.consumerPool[entity.powerConId];
+                    consumer.idleEnergyPerTick = consumer.idleEnergyPerTick / om2 * nm2;
+                    consumer.workEnergyPerTick = consumer.workEnergyPerTick / om2 * nm2;
+                }
+
+                for (var i = 1; i < powerSystem.accCursor; i++)
+                {
+                    ref var acc = ref powerSystem.accPool[i];
+                    if (acc.id != i) continue;
+                    acc.maxEnergy = acc.maxEnergy / om2 * nm2;
+                    acc.inputEnergyPerTick = acc.inputEnergyPerTick / om2 * nm2;
+                    acc.outputEnergyPerTick = acc.outputEnergyPerTick / om2 * nm2;
+                    ref var entity = ref factory.entityPool[acc.entityId];
+                    if (entity.powerConId <= 0) continue;
+                    ref var consumer = ref powerSystem.consumerPool[entity.powerConId];
+                    consumer.idleEnergyPerTick = consumer.idleEnergyPerTick / om2 * nm2;
+                    consumer.workEnergyPerTick = consumer.workEnergyPerTick / om2 * nm2;
+                }
+            }
+
+            if (powerSystem != null && _oldCfg.PowerSupplyAreaMultiplier != Cfg.PowerSupplyAreaMultiplier)
+            {
+                for (var i = 1; i < powerSystem.nodeCursor; i++)
+                {
+                    ref var node = ref powerSystem.nodePool[i];
+                    if (node.id != i) continue;
+                    ref var entity = ref factory.entityPool[node.entityId];
+                    var prefabDesc = LDB.items.Select(entity.protoId).prefabDesc;
+                    node.connectDistance = prefabDesc.powerConnectDistance;
+                    node.coverRadius = prefabDesc.powerCoverRadius;
+                }
+            }
+
+            if (_oldCfg.EjectMultiplier != Cfg.EjectMultiplier)
+            {
+                for (var i = 1; i < factorySystem.ejectorCursor; i++)
+                {
+                    ref var ejector = ref factorySystem.ejectorPool[i];
+                    if (ejector.id != i) continue;
+                    ref var entity = ref factory.entityPool[ejector.entityId];
+                    var prefabDesc = LDB.items.Select(entity.protoId).prefabDesc;
+                    ejector.chargeSpend = prefabDesc.ejectorChargeFrame * 10000;
+                    ejector.coldSpend = prefabDesc.ejectorColdFrame * 10000;
+                }
+            }
+
+            if (_oldCfg.SiloMultiplier != Cfg.SiloMultiplier)
+            {
+                for (var i = 1; i < factorySystem.siloCursor; i++)
+                {
+                    ref var silo = ref factorySystem.siloPool[i];
+                    if (silo.id != i) continue;
+                    ref var entity = ref factory.entityPool[silo.entityId];
+                    var prefabDesc = LDB.items.Select(entity.protoId).prefabDesc;
+                    silo.chargeSpend = prefabDesc.siloChargeFrame * 10000;
+                    silo.coldSpend = prefabDesc.siloColdFrame * 10000;
+                }
+            }
+        }
+
+        stopwatch.Stop();
+        Logger.LogInfo($"Finished in {stopwatch.ElapsedMilliseconds}ms.");
+    }
+
     [HarmonyPostfix, HarmonyPriority(Priority.Last), HarmonyPatch(typeof(VFPreload), "InvokeOnLoadWorkEnded")]
     private static void VFPreload_InvokeOnLoadWorkEnded_Postfix()
     {
-        if (initialized) return;
+        if (_initialized) return;
-        initialized = true;
+        _initialized = true;
         // Belts
-        LDB.items.Select(2001).prefabDesc.beltSpeed = (int)beltSpeed[0];
+        LDB.items.Select(2001).prefabDesc.beltSpeed = (int)Cfg.BeltSpeed[0];
-        LDB.items.Select(2002).prefabDesc.beltSpeed = (int)beltSpeed[1];
+        LDB.items.Select(2002).prefabDesc.beltSpeed = (int)Cfg.BeltSpeed[1];
-        LDB.items.Select(2003).prefabDesc.beltSpeed = (int)beltSpeed[2];
+        LDB.items.Select(2003).prefabDesc.beltSpeed = (int)Cfg.BeltSpeed[2];
         foreach (var proto in LDB.recipes.dataArray)
         {
             if (proto.Type == ERecipeType.Fractionate)
             {
                 for (int i = 0; i < proto.ItemCounts.Length; i++)
                 {
-                    proto.ItemCounts[i] *= assembleSpeedMultiplier;
+                    proto.ItemCounts[i] *= Cfg.AssembleSpeedMultiplier;
                 }
             }
         }
@@ -241,6 +471,7 @@ public class Patch : BaseUnityPlugin
         foreach (var proto in LDB.items.dataArray)
         {
             var prefabDesc = proto.prefabDesc;
+            /* Fix collision sizes, for GalacticScale old versions, should be of no use now.
             FixExtValue(ref prefabDesc.buildCollider.ext.x);
             FixExtValue(ref prefabDesc.buildCollider.ext.y);
             FixExtValue(ref prefabDesc.buildCollider.ext.z);
@@ -253,81 +484,95 @@ public class Patch : BaseUnityPlugin
                     FixExtValue(ref prefabDesc.buildColliders[i].ext.z);
                 }
             }
+            */
+
             if (prefabDesc.isInserter)
             {
-                prefabDesc.inserterSTT /= sorterSpeedMultiplier;
+                prefabDesc.inserterSTT /= Cfg.SorterSpeedMultiplier;
-                prefabDesc.inserterDelay /= sorterSpeedMultiplier;
+                prefabDesc.inserterDelay /= Cfg.SorterSpeedMultiplier;
-                prefabDesc.idleEnergyPerTick *= sorterPowerConsumptionMultiplier;
+                prefabDesc.idleEnergyPerTick *= Cfg.SorterPowerConsumptionMultiplier;
-                prefabDesc.workEnergyPerTick *= sorterPowerConsumptionMultiplier;
+                prefabDesc.workEnergyPerTick *= Cfg.SorterPowerConsumptionMultiplier;
             }
+
             if (prefabDesc.isLab)
             {
-                prefabDesc.labAssembleSpeed *= assembleSpeedMultiplier;
+                prefabDesc.labAssembleSpeed *= Cfg.AssembleSpeedMultiplier;
-                prefabDesc.labResearchSpeed *= researchSpeedMultiplier;
+                prefabDesc.labResearchSpeed *= Cfg.ResearchSpeedMultiplier;
-                prefabDesc.idleEnergyPerTick *= labPowerConsumptionMultiplier;
+                prefabDesc.idleEnergyPerTick *= Cfg.LabPowerConsumptionMultiplier;
-                prefabDesc.workEnergyPerTick *= labPowerConsumptionMultiplier;
+                prefabDesc.workEnergyPerTick *= Cfg.LabPowerConsumptionMultiplier;
             }
+
             if (prefabDesc.isAssembler)
             {
-                prefabDesc.assemblerSpeed *= assembleSpeedMultiplier;
+                prefabDesc.assemblerSpeed *= Cfg.AssembleSpeedMultiplier;
-                prefabDesc.idleEnergyPerTick *= assemblePowerConsumptionMultiplier;
+                prefabDesc.idleEnergyPerTick *= Cfg.AssemblePowerConsumptionMultiplier;
-                prefabDesc.workEnergyPerTick *= assemblePowerConsumptionMultiplier;
+                prefabDesc.workEnergyPerTick *= Cfg.AssemblePowerConsumptionMultiplier;
             }
+
             if (prefabDesc.minerType != EMinerType.None)
             {
-                prefabDesc.minerPeriod /= minerSpeedMultiplier;
+                prefabDesc.minerPeriod /= Cfg.MinerSpeedMultiplier;
-                prefabDesc.idleEnergyPerTick *= minerPowerConsumptionMultiplier;
+                prefabDesc.idleEnergyPerTick *= Cfg.MinerPowerConsumptionMultiplier;
-                prefabDesc.workEnergyPerTick *= minerPowerConsumptionMultiplier;
+                prefabDesc.workEnergyPerTick *= Cfg.MinerPowerConsumptionMultiplier;
             }
+
             if (prefabDesc.isPowerGen || prefabDesc.isPowerExchanger || prefabDesc.isAccumulator)
             {
-                prefabDesc.genEnergyPerTick *= powerGenerationMultiplier;
+                prefabDesc.genEnergyPerTick *= Cfg.PowerGenerationMultiplier;
-                prefabDesc.useFuelPerTick *= powerFuelConsumptionMultiplier;
+                prefabDesc.useFuelPerTick *= Cfg.PowerFuelConsumptionMultiplier;
                 if (prefabDesc.isPowerConsumer)
                 {
-                    prefabDesc.idleEnergyPerTick *= powerGenerationMultiplier;
+                    prefabDesc.idleEnergyPerTick *= Cfg.PowerGenerationMultiplier;
-                    prefabDesc.workEnergyPerTick *= powerGenerationMultiplier;
+                    prefabDesc.workEnergyPerTick *= Cfg.PowerGenerationMultiplier;
                 }
+
                 if (prefabDesc.isPowerExchanger)
                 {
-                    prefabDesc.exchangeEnergyPerTick *= powerFuelConsumptionMultiplier;
+                    prefabDesc.exchangeEnergyPerTick *= Cfg.PowerFuelConsumptionMultiplier;
                 }
+
                 if (prefabDesc.isAccumulator)
                 {
-                    prefabDesc.maxAcuEnergy *= powerGenerationMultiplier;
+                    prefabDesc.maxAcuEnergy *= Cfg.PowerGenerationMultiplier;
-                    prefabDesc.inputEnergyPerTick *= powerGenerationMultiplier;
+                    prefabDesc.inputEnergyPerTick *= Cfg.PowerGenerationMultiplier;
-                    prefabDesc.outputEnergyPerTick *= powerGenerationMultiplier;
+                    prefabDesc.outputEnergyPerTick *= Cfg.PowerGenerationMultiplier;
                 }
             }
+
             if (prefabDesc.isPowerNode)
             {
                 var ival = Mathf.Floor(prefabDesc.powerConnectDistance);
                 prefabDesc.powerConnectDistance =
-                    ival * powerSupplyAreaMultiplier + (prefabDesc.powerConnectDistance - ival);
+                    ival * Cfg.PowerSupplyAreaMultiplier + (prefabDesc.powerConnectDistance - ival);
                 ival = Mathf.Floor(prefabDesc.powerCoverRadius);
                 prefabDesc.powerCoverRadius =
-                    ival * powerSupplyAreaMultiplier + (prefabDesc.powerCoverRadius - ival);
+                    ival * Cfg.PowerSupplyAreaMultiplier + (prefabDesc.powerCoverRadius - ival);
             }
+
             if (prefabDesc.isEjector)
             {
-                prefabDesc.ejectorChargeFrame /= ejectMultiplier;
+                prefabDesc.ejectorChargeFrame /= Cfg.EjectMultiplier;
-                prefabDesc.ejectorColdFrame /= ejectMultiplier;
+                prefabDesc.ejectorColdFrame /= Cfg.EjectMultiplier;
             }
+
             if (prefabDesc.isSilo)
             {
-                prefabDesc.siloChargeFrame /= siloMultiplier;
+                prefabDesc.siloChargeFrame /= Cfg.SiloMultiplier;
-                prefabDesc.siloColdFrame /= siloMultiplier;
+                prefabDesc.siloColdFrame /= Cfg.SiloMultiplier;
             }
         }
     }
 
+    /*
     private static void FixExtValue(ref float v)
     {
         if (v == 0f)
         {
             return;
         }
+
         var b = Math.Abs(v);
         v = (v - b) * 0.75f + b;
     }
-}
+    */
+}

OverclockEverything/OverclockEverything.csproj

@@ -15,6 +15,7 @@
     <PackageReference Include="BepInEx.Core" Version="5.*" />
     <PackageReference Include="BepInEx.PluginInfoProps" Version="1.*" />
     <PackageReference Include="DysonSphereProgram.GameLibs" Version="*-r.*" />
+    <PackageReference Include="DysonSphereProgram.Modding.DSPModSave" Version="1.*" />
     <PackageReference Include="UnityEngine.Modules" Version="2018.4.12" IncludeAssets="compile" />
   </ItemGroup>
   

OverclockEverything/package/manifest.json

@@ -4,6 +4,7 @@
   "website_url": "https://github.com/soarqin/DSP_Mods/tree/master/OverclockEverything",
   "description": "Overclock everything in game / 加速游戏中的所有建筑",
   "dependencies": [
-    "xiaoye97-BepInEx-5.4.17"
+    "xiaoye97-BepInEx-5.4.17",
+    "CommonAPI-DSPModSave-1.1.4"
   ]
 }