From b454a1400f25edfc4086984b09fe0cb2f85ce87f Mon Sep 17 00:00:00 2001 From: Soar Qin Date: Wed, 23 Aug 2023 20:33:14 +0800 Subject: [PATCH] OverclockEverything: fix on loading --- OverclockEverything/BeltFix.cs | 15 +- OverclockEverything/Cfg.cs | 26 + OverclockEverything/OverclockEverything.cs | 447 ++++++++++++++---- .../OverclockEverything.csproj | 1 + OverclockEverything/package/manifest.json | 3 +- 5 files changed, 382 insertions(+), 110 deletions(-) create mode 100644 OverclockEverything/Cfg.cs diff --git a/OverclockEverything/BeltFix.cs b/OverclockEverything/BeltFix.cs index 0e1a357..606958b 100644 --- a/OverclockEverything/BeltFix.cs +++ b/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 CargoTraffic_AlterBeltRenderer_Transpiler(IEnumerable 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); diff --git a/OverclockEverything/Cfg.cs b/OverclockEverything/Cfg.cs new file mode 100644 index 0000000..6dbc5d9 --- /dev/null +++ b/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; +} diff --git a/OverclockEverything/OverclockEverything.cs b/OverclockEverything/OverclockEverything.cs index 096fc8d..303d029 100644 --- a/OverclockEverything/OverclockEverything.cs +++ b/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; - public static uint[] beltSpeed = { - 2, 5, 10 - }; - - 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 const ushort SaveVersion = 1; + private static bool _initialized = false; + public static Cfg Cfg = new(); + private static Cfg _oldCfg; private void Awake() { - _cfgEnabled = Config.Bind("General", "Enabled", _cfgEnabled, "enable/disable this plugin").Value; - if (!_cfgEnabled) return; - beltSpeed[0] = Config.Bind("Belt", "MkI_Speed", beltSpeed[0], + var cfgEnabled = Config.Bind("General", "Enabled", true, "Enable/Disable this plugin").Value; + if (!cfgEnabled) return; + 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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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(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 BuildTool_Path_CheckBuildConditions_Transpiler( IEnumerable 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")] - private static IEnumerable LabComponent_SetFunction_Transpiler(IEnumerable instructions) + [HarmonyPostfix, HarmonyPatch(typeof(LabComponent), "SetFunction")] + private static void LabComponent_SetFunction_Postfix(ref LabComponent __instance) { - var lastIsLdc10000 = false; - foreach (var instr in instructions) - { - 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; - } + if (__instance.researchMode) return; + __instance.speed *= Cfg.AssembleSpeedMultiplier; + __instance.speedOverride *= Cfg.AssembleSpeedMultiplier; } [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; - initialized = true; + if (_initialized) return; + _initialized = true; // Belts - LDB.items.Select(2001).prefabDesc.beltSpeed = (int)beltSpeed[0]; - LDB.items.Select(2002).prefabDesc.beltSpeed = (int)beltSpeed[1]; - LDB.items.Select(2003).prefabDesc.beltSpeed = (int)beltSpeed[2]; + LDB.items.Select(2001).prefabDesc.beltSpeed = (int)Cfg.BeltSpeed[0]; + LDB.items.Select(2002).prefabDesc.beltSpeed = (int)Cfg.BeltSpeed[1]; + 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.inserterDelay /= sorterSpeedMultiplier; - prefabDesc.idleEnergyPerTick *= sorterPowerConsumptionMultiplier; - prefabDesc.workEnergyPerTick *= sorterPowerConsumptionMultiplier; + prefabDesc.inserterSTT /= Cfg.SorterSpeedMultiplier; + prefabDesc.inserterDelay /= Cfg.SorterSpeedMultiplier; + prefabDesc.idleEnergyPerTick *= Cfg.SorterPowerConsumptionMultiplier; + prefabDesc.workEnergyPerTick *= Cfg.SorterPowerConsumptionMultiplier; } + if (prefabDesc.isLab) { - prefabDesc.labAssembleSpeed *= assembleSpeedMultiplier; - prefabDesc.labResearchSpeed *= researchSpeedMultiplier; - prefabDesc.idleEnergyPerTick *= labPowerConsumptionMultiplier; - prefabDesc.workEnergyPerTick *= labPowerConsumptionMultiplier; + prefabDesc.labAssembleSpeed *= Cfg.AssembleSpeedMultiplier; + prefabDesc.labResearchSpeed *= Cfg.ResearchSpeedMultiplier; + prefabDesc.idleEnergyPerTick *= Cfg.LabPowerConsumptionMultiplier; + prefabDesc.workEnergyPerTick *= Cfg.LabPowerConsumptionMultiplier; } + if (prefabDesc.isAssembler) { - prefabDesc.assemblerSpeed *= assembleSpeedMultiplier; - prefabDesc.idleEnergyPerTick *= assemblePowerConsumptionMultiplier; - prefabDesc.workEnergyPerTick *= assemblePowerConsumptionMultiplier; + prefabDesc.assemblerSpeed *= Cfg.AssembleSpeedMultiplier; + prefabDesc.idleEnergyPerTick *= Cfg.AssemblePowerConsumptionMultiplier; + prefabDesc.workEnergyPerTick *= Cfg.AssemblePowerConsumptionMultiplier; } + if (prefabDesc.minerType != EMinerType.None) { - prefabDesc.minerPeriod /= minerSpeedMultiplier; - prefabDesc.idleEnergyPerTick *= minerPowerConsumptionMultiplier; - prefabDesc.workEnergyPerTick *= minerPowerConsumptionMultiplier; + prefabDesc.minerPeriod /= Cfg.MinerSpeedMultiplier; + prefabDesc.idleEnergyPerTick *= Cfg.MinerPowerConsumptionMultiplier; + prefabDesc.workEnergyPerTick *= Cfg.MinerPowerConsumptionMultiplier; } + if (prefabDesc.isPowerGen || prefabDesc.isPowerExchanger || prefabDesc.isAccumulator) { - prefabDesc.genEnergyPerTick *= powerGenerationMultiplier; - prefabDesc.useFuelPerTick *= powerFuelConsumptionMultiplier; + prefabDesc.genEnergyPerTick *= Cfg.PowerGenerationMultiplier; + prefabDesc.useFuelPerTick *= Cfg.PowerFuelConsumptionMultiplier; if (prefabDesc.isPowerConsumer) { - prefabDesc.idleEnergyPerTick *= powerGenerationMultiplier; - prefabDesc.workEnergyPerTick *= powerGenerationMultiplier; + prefabDesc.idleEnergyPerTick *= Cfg.PowerGenerationMultiplier; + prefabDesc.workEnergyPerTick *= Cfg.PowerGenerationMultiplier; } + if (prefabDesc.isPowerExchanger) { - prefabDesc.exchangeEnergyPerTick *= powerFuelConsumptionMultiplier; + prefabDesc.exchangeEnergyPerTick *= Cfg.PowerFuelConsumptionMultiplier; } + if (prefabDesc.isAccumulator) { - prefabDesc.maxAcuEnergy *= powerGenerationMultiplier; - prefabDesc.inputEnergyPerTick *= powerGenerationMultiplier; - prefabDesc.outputEnergyPerTick *= powerGenerationMultiplier; + prefabDesc.maxAcuEnergy *= Cfg.PowerGenerationMultiplier; + prefabDesc.inputEnergyPerTick *= Cfg.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.ejectorColdFrame /= ejectMultiplier; + prefabDesc.ejectorChargeFrame /= Cfg.EjectMultiplier; + prefabDesc.ejectorColdFrame /= Cfg.EjectMultiplier; } + if (prefabDesc.isSilo) { - prefabDesc.siloChargeFrame /= siloMultiplier; - prefabDesc.siloColdFrame /= siloMultiplier; + prefabDesc.siloChargeFrame /= Cfg.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; } -} + */ +} \ No newline at end of file diff --git a/OverclockEverything/OverclockEverything.csproj b/OverclockEverything/OverclockEverything.csproj index cf39599..d2b31a2 100644 --- a/OverclockEverything/OverclockEverything.csproj +++ b/OverclockEverything/OverclockEverything.csproj @@ -15,6 +15,7 @@ + diff --git a/OverclockEverything/package/manifest.json b/OverclockEverything/package/manifest.json index cf346cb..7728254 100644 --- a/OverclockEverything/package/manifest.json +++ b/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" ] }