From 8fbabf39315e7898d94e9812d0bec72900a6da3d Mon Sep 17 00:00:00 2001 From: PhatPhuckDave Date: Tue, 25 Feb 2025 11:56:03 +0100 Subject: [PATCH] Add ModuleManagerMapper for dynamic module management --- Projects/TerraTech/TerraTech/Class1.cs | 14 ++-- Projects/TerraTech/TerraTech/CykUtil.cs | 2 +- .../TerraTech/ModuleBoosterManager.cs | 37 +++++---- .../TerraTech/ModuleEnergyManager.cs | 27 ++++--- .../TerraTech/ModuleEnergyStoreManager.cs | 25 +++--- .../TerraTech/ModuleFuelTankManager.cs | 30 +++++--- .../TerraTech/TerraTech/ModuleGyroManager.cs | 25 +++--- .../TerraTech/TerraTech/ModuleHeartManager.cs | 32 ++++---- .../TerraTech/ModuleItemHolderManager.cs | 75 +++++++++--------- .../TerraTech/ModuleItemProducerManager.cs | 29 ++++--- .../TerraTech/ModuleRemoteChargerManager.cs | 33 ++++---- .../TerraTech/ModuleShieldGeneratorManager.cs | 41 +++++----- .../TerraTech/ModuleWeaponGunManager.cs | 49 +++++++----- .../TerraTech/ModuleWeaponManager.cs | 29 ++++--- .../TerraTech/ModuleWheelsManager.cs | 31 +++++--- .../TerraTech/TerraTech/ModuleWingManager.cs | 36 +++++---- .../TerraTech/ObjectFieldMultiplier.cs | 76 +++++++++---------- Projects/TerraTech/TerraTech/Patches.cs | 2 +- .../TerraTech/SeekingProjectileManager.cs | 2 +- .../TerraTech/TerraTech/TankBeamManager.cs | 10 +-- 20 files changed, 350 insertions(+), 255 deletions(-) diff --git a/Projects/TerraTech/TerraTech/Class1.cs b/Projects/TerraTech/TerraTech/Class1.cs index 34bcb91..0e9ba2a 100644 --- a/Projects/TerraTech/TerraTech/Class1.cs +++ b/Projects/TerraTech/TerraTech/Class1.cs @@ -1,4 +1,6 @@ -using System.Linq; +using System; +using System.Collections.Generic; +using System.Linq; using BepInEx; using BepInEx.Configuration; using HarmonyLib; @@ -8,11 +10,11 @@ using HarmonyLib.Tools; // TODO: Maybe make props faster, thrusters work fine namespace TerraTech { - [BepInPlugin(pluginGuid, pluginName, pluginVersion)] + [BepInPlugin(PluginGuid, PluginName, PluginVersion)] public class Main : BaseUnityPlugin { - private const string pluginGuid = "CykaMod"; - private const string pluginName = "CykaMod"; - private const string pluginVersion = "1.0.0"; + private const string PluginGuid = "CykaMod"; + private const string PluginName = "CykaMod"; + private const string PluginVersion = "1.0.0"; public static ConfigEntry debug; public static ConfigEntry xpMultiplier; @@ -72,7 +74,7 @@ namespace TerraTech { Logger.LogInfo("Cyka mod loaded"); HarmonyFileLog.Enabled = true; - Harmony harmony = new Harmony(pluginGuid); + Harmony harmony = new Harmony(PluginGuid); harmony.PatchAll(); var originalMethods = harmony.GetPatchedMethods(); Logger.LogInfo("Patched " + originalMethods.Count() + " methods"); diff --git a/Projects/TerraTech/TerraTech/CykUtil.cs b/Projects/TerraTech/TerraTech/CykUtil.cs index 344d199..9ee2d09 100644 --- a/Projects/TerraTech/TerraTech/CykUtil.cs +++ b/Projects/TerraTech/TerraTech/CykUtil.cs @@ -14,7 +14,7 @@ namespace TerraTech { return tank.ControllableByLocalPlayer; } - public static Func IsObjectPlayerTank = obj => { + public static Func isObjectPlayerTank = obj => { if (obj == null) return false; try { diff --git a/Projects/TerraTech/TerraTech/ModuleBoosterManager.cs b/Projects/TerraTech/TerraTech/ModuleBoosterManager.cs index 4ce20b5..dbbebe9 100644 --- a/Projects/TerraTech/TerraTech/ModuleBoosterManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleBoosterManager.cs @@ -6,14 +6,14 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleBoosterManager { - private static readonly MultipliedObjectManager fanManager = + private static readonly MultipliedObjectManager FanManager = new MultipliedObjectManager(ConfigureFanThruster); - private static readonly MultipliedObjectManager jetManager = + private static readonly MultipliedObjectManager JetManager = new MultipliedObjectManager(ConfigureJetThruster); - public static ConfigEntry playerOnly; - public static ConfigEntry fanThrustMultiplier; - public static ConfigEntry jetThrustMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry fanThrustMultiplier; + private static ConfigEntry jetThrustMultiplier; public static void Setup(ConfigFile config) { float min = 0.01f; @@ -44,34 +44,41 @@ namespace TerraTech { private static readonly Func ShouldApply = obj => { if (!playerOnly.Value) return true; - return CykUtil.IsObjectPlayerTank(obj); + return CykUtil.isObjectPlayerTank(obj); }; [HarmonyPrefix] [HarmonyPatch(typeof(ModuleBooster), "OnAttached")] - static void PostfixCreate(ModuleBooster __instance) { + public static void PostfixCreate(ModuleBooster __instance) { var trav = Traverse.Create(__instance); var fans = trav.Field("fans").GetValue>(); var jets = trav.Field("jets").GetValue>(); - foreach (var fan in fans) fanManager.OnObjectAttached(fan); - foreach (var jet in jets) jetManager.OnObjectAttached(jet); + foreach (var fan in fans) FanManager.OnObjectAttached(fan); + foreach (var jet in jets) JetManager.OnObjectAttached(jet); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleBooster), "OnDetaching")] - static void PostfixDestroy(ModuleBooster __instance) { + public static void PostfixDestroy(ModuleBooster __instance) { var trav = Traverse.Create(__instance); var fans = trav.Field("fans").GetValue>(); var jets = trav.Field("jets").GetValue>(); - foreach (var fan in fans) fanManager.OnObjectDetached(fan); - foreach (var jet in jets) jetManager.OnObjectDetached(jet); + foreach (var fan in fans) FanManager.OnObjectDetached(fan); + foreach (var jet in jets) JetManager.OnObjectDetached(jet); } - public static void DoPatch() { - fanManager.ApplyAll(); - jetManager.ApplyAll(); + private static void DoPatch() { + FanManager.ApplyAll(); + JetManager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleBooster: {0}", obj); + PostfixCreate(obj as ModuleBooster); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleEnergyManager.cs b/Projects/TerraTech/TerraTech/ModuleEnergyManager.cs index 39e46fe..ac100b1 100644 --- a/Projects/TerraTech/TerraTech/ModuleEnergyManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleEnergyManager.cs @@ -5,12 +5,12 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleEnergyManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureModuleEnergy); - public static ConfigEntry playerOnly; - public static ConfigEntry outputMultiplier; - public static ConfigEntry powerUpDelayMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry outputMultiplier; + private static ConfigEntry powerUpDelayMultiplier; public static void Setup(ConfigFile config) { float min = 0.01f; @@ -43,18 +43,25 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleEnergy), "OnAnchorStatusChanged")] - static void PostfixCreate(ModuleEnergy __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleEnergy __instance) { + Manager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleEnergy), "OnDetaching")] - static void PostfixDestroy(ModuleEnergy __instance) { - manager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleEnergy __instance) { + Manager.OnObjectDetached(__instance); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleEnergy: {0}", obj); + PostfixCreate(obj as ModuleEnergy); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleEnergyStoreManager.cs b/Projects/TerraTech/TerraTech/ModuleEnergyStoreManager.cs index 90535b2..26c0537 100644 --- a/Projects/TerraTech/TerraTech/ModuleEnergyStoreManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleEnergyStoreManager.cs @@ -5,11 +5,11 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleEnergyStoreManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureModuleEnergyStore); - public static ConfigEntry playerOnly; - public static ConfigEntry capacityMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry capacityMultiplier; public static void Setup(ConfigFile config) { float min = 0.01f; @@ -36,18 +36,25 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleEnergyStore), "OnAttached")] - static void PostfixCreate(ModuleEnergyStore __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleEnergyStore __instance) { + Manager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleEnergyStore), "OnDetaching")] - static void PostfixDestroy(ModuleEnergyStore __instance) { - manager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleEnergyStore __instance) { + Manager.OnObjectDetached(__instance); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleEnergyStore: {0}", obj); + PostfixCreate(obj as ModuleEnergyStore); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleFuelTankManager.cs b/Projects/TerraTech/TerraTech/ModuleFuelTankManager.cs index db31e85..60d50c4 100644 --- a/Projects/TerraTech/TerraTech/ModuleFuelTankManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleFuelTankManager.cs @@ -1,17 +1,16 @@ using System; -using System.Collections.Generic; using BepInEx.Configuration; using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleFuelTankManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureFuelTank); - public static ConfigEntry playerOnly; - public static ConfigEntry fuelCapacityMultiplier; - public static ConfigEntry fuelRefillMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry fuelCapacityMultiplier; + private static ConfigEntry fuelRefillMultiplier; public static void Setup(ConfigFile config) { float min = 0.01f; @@ -39,23 +38,30 @@ namespace TerraTech { private static readonly Func ShouldApply = obj => { if (!playerOnly.Value) return true; - return CykUtil.IsObjectPlayerTank(obj); + return CykUtil.isObjectPlayerTank(obj); }; [HarmonyPrefix] [HarmonyPatch(typeof(ModuleFuelTank), "OnAttached")] - static void PostfixCreate(ModuleFuelTank __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleFuelTank __instance) { + Manager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleFuelTank), "OnDetaching")] - static void PostfixDestroy(ModuleFuelTank __instance) { - manager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleFuelTank __instance) { + Manager.OnObjectDetached(__instance); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleFuelTank: {0}", obj); + PostfixCreate(obj as ModuleFuelTank); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleGyroManager.cs b/Projects/TerraTech/TerraTech/ModuleGyroManager.cs index 9d412a8..e693ea0 100644 --- a/Projects/TerraTech/TerraTech/ModuleGyroManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleGyroManager.cs @@ -5,11 +5,11 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleGyroManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureModuleGyro); - public static ConfigEntry playerOnly; - public static ConfigEntry activeSpeedMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry activeSpeedMultiplier; public static void Setup(ConfigFile config) { float min = 0.01f; @@ -36,18 +36,25 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleGyro), "OnAttached")] - static void PostfixCreate(ModuleGyro __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleGyro __instance) { + Manager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleGyro), "OnDetaching")] - static void PostfixDestroy(ModuleGyro __instance) { - manager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleGyro __instance) { + Manager.OnObjectDetached(__instance); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleGyro: {0}", obj); + PostfixCreate(obj as ModuleGyro); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleHeartManager.cs b/Projects/TerraTech/TerraTech/ModuleHeartManager.cs index c4d632b..ec60e4d 100644 --- a/Projects/TerraTech/TerraTech/ModuleHeartManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleHeartManager.cs @@ -1,18 +1,17 @@ using System; -using System.Collections.Generic; using BepInEx.Configuration; using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleHeartManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureHeart); - public static ConfigEntry playerOnly; - public static ConfigEntry eventHorizonRadiusMultiplier; - public static ConfigEntry setupTimeMultiplier; - public static ConfigEntry startShrinkingRadiusMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry eventHorizonRadiusMultiplier; + private static ConfigEntry setupTimeMultiplier; + private static ConfigEntry startShrinkingRadiusMultiplier; public static void Setup(ConfigFile config) { float min = 0.01f; @@ -48,23 +47,30 @@ namespace TerraTech { private static readonly Func ShouldApply = obj => { if (!playerOnly.Value) return true; - return CykUtil.IsObjectPlayerTank(obj); + return CykUtil.isObjectPlayerTank(obj); }; [HarmonyPrefix] [HarmonyPatch(typeof(ModuleHeart), "OnAttached")] - static void PostfixCreate(ModuleHeart __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleHeart __instance) { + Manager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleHeart), "OnDetaching")] - static void PostfixDestroy(ModuleHeart __instance) { - manager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleHeart __instance) { + Manager.OnObjectDetached(__instance); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleHeart: {0}", obj); + PostfixCreate(obj as ModuleHeart); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleItemHolderManager.cs b/Projects/TerraTech/TerraTech/ModuleItemHolderManager.cs index f556f74..898eb14 100644 --- a/Projects/TerraTech/TerraTech/ModuleItemHolderManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleItemHolderManager.cs @@ -5,25 +5,25 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleItemHolderManager { - private static readonly MultipliedObjectManager beamManager = + private static readonly MultipliedObjectManager BeamManager = new MultipliedObjectManager(ConfigureBeam); - private static readonly MultipliedObjectManager beamHolderManager = + private static readonly MultipliedObjectManager BeamHolderManager = new MultipliedObjectManager(ConfigureBeamHolder); - private static readonly MultipliedObjectManager beamPickupManager = + private static readonly MultipliedObjectManager BeamPickupManager = new MultipliedObjectManager(ConfigureBeamPickup); - private static readonly MultipliedObjectManager magnetHolderManager = + private static readonly MultipliedObjectManager MagnetHolderManager = new MultipliedObjectManager(ConfigureMagnetHolder); - private static readonly MultipliedObjectManager magnetPickupManager = + private static readonly MultipliedObjectManager MagnetPickupManager = new MultipliedObjectManager(ConfigureMagnetPickup); - public static ConfigEntry playerOnly; - public static ConfigEntry capacityPerStackMultiplier; - public static ConfigEntry beamStrengthMultiplier; - public static ConfigEntry beamHeightIncrementScaleMultiplier; - public static ConfigEntry beamPickupRangeMultiplier; - public static ConfigEntry magnetStrengthMultiplier; - public static ConfigEntry magnetPickupRangeMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry capacityPerStackMultiplier; + private static ConfigEntry beamStrengthMultiplier; + private static ConfigEntry beamHeightIncrementScaleMultiplier; + private static ConfigEntry beamPickupRangeMultiplier; + private static ConfigEntry magnetStrengthMultiplier; + private static ConfigEntry magnetPickupRangeMultiplier; public static void Setup(ConfigFile config) { float min = 0.01f; @@ -96,62 +96,69 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleItemHolder), "OnAttached")] - static void PostfixCreate(ModuleItemHolder __instance) { - beamManager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleItemHolder __instance) { + BeamManager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleItemHolder), "OnDetaching")] - static void PostfixDestroy(ModuleItemHolder __instance) { - beamManager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleItemHolder __instance) { + BeamManager.OnObjectDetached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleItemHolderBeam), "OnAttached")] - static void PostfixCreate(ModuleItemHolderBeam __instance) { + public static void PostfixCreate(ModuleItemHolderBeam __instance) { var trav = Traverse.Create(__instance); var pickup = trav.Field("m_Pickup").GetValue(); - beamHolderManager.OnObjectAttached(__instance); - beamPickupManager.OnObjectAttached(pickup); + BeamHolderManager.OnObjectAttached(__instance); + BeamPickupManager.OnObjectAttached(pickup); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleItemHolderBeam), "OnDetaching")] - static void PostfixDestroy(ModuleItemHolderBeam __instance) { + public static void PostfixDestroy(ModuleItemHolderBeam __instance) { var trav = Traverse.Create(__instance); var pickup = trav.Field("m_Pickup").GetValue(); - beamHolderManager.OnObjectDetached(__instance); - beamPickupManager.OnObjectDetached(pickup); + BeamHolderManager.OnObjectDetached(__instance); + BeamPickupManager.OnObjectDetached(pickup); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleItemHolderMagnet), "OnAttached")] - static void PostfixCreate(ModuleItemHolderMagnet __instance) { + public static void PostfixCreate(ModuleItemHolderMagnet __instance) { var trav = Traverse.Create(__instance); var pickup = trav.Field("m_Pickup").GetValue(); - magnetHolderManager.OnObjectAttached(__instance); - magnetPickupManager.OnObjectAttached(pickup); + MagnetHolderManager.OnObjectAttached(__instance); + MagnetPickupManager.OnObjectAttached(pickup); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleItemHolderMagnet), "OnDetaching")] - static void PostfixDestroy(ModuleItemHolderMagnet __instance) { + public static void PostfixDestroy(ModuleItemHolderMagnet __instance) { var trav = Traverse.Create(__instance); var pickup = trav.Field("m_Pickup").GetValue(); - magnetHolderManager.OnObjectDetached(__instance); - magnetPickupManager.OnObjectDetached(pickup); + MagnetHolderManager.OnObjectDetached(__instance); + MagnetPickupManager.OnObjectDetached(pickup); } - public static void DoPatch() { - beamManager.ApplyAll(); - beamHolderManager.ApplyAll(); - beamPickupManager.ApplyAll(); - magnetHolderManager.ApplyAll(); - magnetPickupManager.ApplyAll(); + private static void DoPatch() { + BeamManager.ApplyAll(); + BeamHolderManager.ApplyAll(); + BeamPickupManager.ApplyAll(); + MagnetHolderManager.ApplyAll(); + MagnetPickupManager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleItemHolder: {0}", obj); + PostfixCreate(obj as ModuleItemHolder); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleItemProducerManager.cs b/Projects/TerraTech/TerraTech/ModuleItemProducerManager.cs index 4ace088..4b37b1e 100644 --- a/Projects/TerraTech/TerraTech/ModuleItemProducerManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleItemProducerManager.cs @@ -5,13 +5,13 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleItemProducerManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureModuleItemProducer); - public static ConfigEntry playerOnly; - public static ConfigEntry resourceGroundRadiusMultiplier; - public static ConfigEntry minDispenseIntervalMultiplier; - public static ConfigEntry secPerItemProducedMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry resourceGroundRadiusMultiplier; + private static ConfigEntry minDispenseIntervalMultiplier; + private static ConfigEntry secPerItemProducedMultiplier; public static void Setup(ConfigFile config) { float min = 0.01f; @@ -53,18 +53,25 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleItemProducer), "GetClosestResourceReservoirInRange")] - static void PostfixCreate(ModuleItemProducer __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleItemProducer __instance) { + Manager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleItemProducer), "OnDetaching")] - static void PostfixDestroy(ModuleItemProducer __instance) { - manager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleItemProducer __instance) { + Manager.OnObjectDetached(__instance); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleItemProducer: {0}", obj); + PostfixCreate(obj as ModuleItemProducer); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleRemoteChargerManager.cs b/Projects/TerraTech/TerraTech/ModuleRemoteChargerManager.cs index a201395..7b54cb8 100644 --- a/Projects/TerraTech/TerraTech/ModuleRemoteChargerManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleRemoteChargerManager.cs @@ -5,17 +5,17 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleRemoteChargerManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureModuleRemoteCharger); - public static ConfigEntry playerOnly; - public static ConfigEntry arcFiringIntervalMultiplier; - public static ConfigEntry chargingRadiusMultiplier; - public static ConfigEntry powerTransferPerArcMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry arcFiringIntervalMultiplier; + private static ConfigEntry chargingRadiusMultiplier; + private static ConfigEntry powerTransferPerArcMultiplier; public static void Setup(ConfigFile config) { - float min = 0.01f; - float max = 32f; + const float min = 0.01f; + const float max = 32f; playerOnly = config.Bind("Remote Charger", "Player Only", false, new ConfigDescription("Player Only")); playerOnly.SettingChanged += (sender, args) => DoPatch(); @@ -53,18 +53,25 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleRemoteCharger), "OnAttached")] - static void PostfixCreate(ModuleRemoteCharger __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleRemoteCharger __instance) { + Manager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleRemoteCharger), "OnDetaching")] - static void PostfixDestroy(ModuleRemoteCharger __instance) { - manager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleRemoteCharger __instance) { + Manager.OnObjectDetached(__instance); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleRemoteCharger: {0}", obj); + PostfixCreate(obj as ModuleRemoteCharger); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleShieldGeneratorManager.cs b/Projects/TerraTech/TerraTech/ModuleShieldGeneratorManager.cs index cbd6936..27122c3 100644 --- a/Projects/TerraTech/TerraTech/ModuleShieldGeneratorManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleShieldGeneratorManager.cs @@ -5,18 +5,18 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleShieldGeneratorManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureShieldGenerator); - public static ConfigEntry playerOnly; - public static ConfigEntry radiusMultiplier; - public static ConfigEntry radiusMultiplierHealing; - public static ConfigEntry heartbeatIntervalMultiplier; - public static ConfigEntry powerUpDelayMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry radiusMultiplier; + private static ConfigEntry radiusMultiplierHealing; + private static ConfigEntry heartbeatIntervalMultiplier; + private static ConfigEntry powerUpDelayMultiplier; public static void Setup(ConfigFile config) { - float min = 0.01f; - float max = 32f; + const float min = 0.01f; + const float max = 32f; playerOnly = config.Bind("Shield", "Player Only", false, new ConfigDescription("Player Only")); playerOnly.SettingChanged += (sender, args) => DoPatch(); @@ -46,10 +46,10 @@ namespace TerraTech { obj.AddField(new FieldConfiguration("m_HealingHeartbeatInterval", heartbeatIntervalMultiplier, ShouldApply)); - obj.AddField(new FieldConfiguration("m_Radius", radiusMultiplier, instance => { - if (!ShouldApply(instance)) + obj.AddField(new FieldConfiguration("m_Radius", radiusMultiplier, __instance => { + if (!ShouldApply(__instance)) return radiusMultiplier; - var shield = (ModuleShieldGenerator)instance; + var shield = (ModuleShieldGenerator)__instance; return shield.m_Healing ? radiusMultiplierHealing : radiusMultiplier; })); @@ -64,18 +64,25 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleShieldGenerator), "OnAttached")] - static void PostfixCreate(ModuleShieldGenerator __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleShieldGenerator __instance) { + Manager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleShieldGenerator), "OnDetaching")] - static void PostfixDestroy(ModuleShieldGenerator __instance) { - manager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleShieldGenerator __instance) { + Manager.OnObjectDetached(__instance); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleShieldGenerator: {0}", obj); + PostfixCreate(obj as ModuleShieldGenerator); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleWeaponGunManager.cs b/Projects/TerraTech/TerraTech/ModuleWeaponGunManager.cs index 46845a5..a549dcf 100644 --- a/Projects/TerraTech/TerraTech/ModuleWeaponGunManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleWeaponGunManager.cs @@ -5,23 +5,23 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleWeaponGunManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureManager); - private static readonly MultipliedObjectManager fireDataManager = + private static readonly MultipliedObjectManager FireDataManager = new MultipliedObjectManager(ConfigureFireData); - public static ConfigEntry playerOnly; - public static ConfigEntry kickbackStrengthMultiplier; - public static ConfigEntry muzzleVelocityMultiplier; - public static ConfigEntry burstCooldownMultiplier; - public static ConfigEntry burstShotCountMultiplier; - public static ConfigEntry shotCooldownMultiplier; - public static ConfigEntry seekingRoundsAll; - public static ConfigEntry resetBurstOnInterruptAll; + private static ConfigEntry playerOnly; + private static ConfigEntry kickbackStrengthMultiplier; + private static ConfigEntry muzzleVelocityMultiplier; + private static ConfigEntry burstCooldownMultiplier; + private static ConfigEntry burstShotCountMultiplier; + private static ConfigEntry shotCooldownMultiplier; + private static ConfigEntry seekingRoundsAll; + private static ConfigEntry resetBurstOnInterruptAll; public static void Setup(ConfigFile config) { - float min = 0.01f; - float max = 32f; + const float min = 0.01f; + const float max = 32f; playerOnly = config.Bind("WeaponGun", "Player Only", false, new ConfigDescription("Player Only")); playerOnly.SettingChanged += (sender, args) => DoPatch(); @@ -84,31 +84,38 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleWeaponGun), "OnAttached")] - static void PostfixCreate(ModuleWeaponGun __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleWeaponGun __instance) { + Manager.OnObjectAttached(__instance); if (playerOnly.Value && !CykUtil.IsPlayerTank(__instance)) return; var trav = Traverse.Create(__instance); var firingData = trav.Field("m_FiringData"); - fireDataManager.OnObjectAttached(firingData.GetValue()); + FireDataManager.OnObjectAttached(firingData.GetValue()); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleWeaponGun), "OnDetaching")] - static void PostfixDestroy(ModuleWeaponGun __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixDestroy(ModuleWeaponGun __instance) { + Manager.OnObjectAttached(__instance); var trav = Traverse.Create(__instance); if (playerOnly.Value && !CykUtil.IsPlayerTank(__instance)) return; var firingData = trav.Field("m_FiringData"); - fireDataManager.OnObjectDetached(firingData.GetValue()); + FireDataManager.OnObjectDetached(firingData.GetValue()); } - public static void DoPatch() { - fireDataManager.ApplyAll(); - manager.ApplyAll(); + private static void DoPatch() { + FireDataManager.ApplyAll(); + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleWeaponGun: {0}", obj); + PostfixCreate(obj as ModuleWeaponGun); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleWeaponManager.cs b/Projects/TerraTech/TerraTech/ModuleWeaponManager.cs index 29212fd..021c5e4 100644 --- a/Projects/TerraTech/TerraTech/ModuleWeaponManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleWeaponManager.cs @@ -5,15 +5,15 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleWeaponManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureManager); - public static ConfigEntry playerOnly; - public static ConfigEntry rotateSpeedMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry rotateSpeedMultiplier; public static void Setup(ConfigFile config) { - float min = 0.01f; - float max = 32f; + const float min = 0.01f; + const float max = 32f; playerOnly = config.Bind("ModuleWeapon", "Player Only", false, new ConfigDescription("Player Only")); playerOnly.SettingChanged += (sender, args) => DoPatch(); @@ -36,18 +36,25 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleWeapon), "OnAttached")] - static void PostfixCreate(ModuleWeapon __instance) { - manager.OnObjectAttached(__instance); + public static void PostfixCreate(ModuleWeapon __instance) { + Manager.OnObjectAttached(__instance); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleWeapon), "OnDetaching")] - static void PostfixDestroy(ModuleWeapon __instance) { - manager.OnObjectDetached(__instance); + public static void PostfixDestroy(ModuleWeapon __instance) { + Manager.OnObjectDetached(__instance); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleWeapon: {0}", obj); + PostfixCreate(obj as ModuleWeapon); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleWheelsManager.cs b/Projects/TerraTech/TerraTech/ModuleWheelsManager.cs index b4eab7d..3d3ead8 100644 --- a/Projects/TerraTech/TerraTech/ModuleWheelsManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleWheelsManager.cs @@ -5,16 +5,16 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleWheelsManager { - private static readonly MultipliedObjectManager torqueParamsManager = + private static readonly MultipliedObjectManager TorqueParamsManager = new MultipliedObjectManager(ConfigureTorqueParams); - public static ConfigEntry playerOnly; - public static ConfigEntry torqueRpmMultiplier; - public static ConfigEntry torqueMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry torqueRpmMultiplier; + private static ConfigEntry torqueMultiplier; public static void Setup(ConfigFile config) { - float min = 0.01f; - float max = 32f; + const float min = 0.01f; + const float max = 32f; playerOnly = config.Bind("TorqueParams", "Player Only", false, new ConfigDescription("Player Only")); playerOnly.SettingChanged += (sender, args) => DoPatch(); @@ -43,22 +43,29 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleWheels), "OnAttached")] - static void PostfixCreate(ModuleWheels __instance) { + public static void PostfixCreate(ModuleWheels __instance) { var trav = Traverse.Create(__instance); var torqueParams = trav.Field("torqueParams"); - torqueParamsManager.OnObjectAttached(torqueParams.GetValue()); + TorqueParamsManager.OnObjectAttached(torqueParams.GetValue()); } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleWheels), "OnDetaching")] - static void PostfixDestroy(ModuleWheels __instance) { + public static void PostfixDestroy(ModuleWheels __instance) { var trav = Traverse.Create(__instance); var torqueParams = trav.Field("torqueParams"); - torqueParamsManager.OnObjectDetached(torqueParams.GetValue()); + TorqueParamsManager.OnObjectDetached(torqueParams.GetValue()); } - public static void DoPatch() { - torqueParamsManager.ApplyAll(); + private static void DoPatch() { + TorqueParamsManager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleWheels: {0}", obj); + PostfixCreate(obj as ModuleWheels); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ModuleWingManager.cs b/Projects/TerraTech/TerraTech/ModuleWingManager.cs index 0166fc9..5239312 100644 --- a/Projects/TerraTech/TerraTech/ModuleWingManager.cs +++ b/Projects/TerraTech/TerraTech/ModuleWingManager.cs @@ -5,17 +5,17 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class ModuleWingManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureAerofoil); - public static ConfigEntry playerOnly; - public static ConfigEntry angleRangeMultiplier; - public static ConfigEntry turnSpeedMultiplier; - public static ConfigEntry liftStrengthMultiplier; + private static ConfigEntry playerOnly; + private static ConfigEntry angleRangeMultiplier; + private static ConfigEntry turnSpeedMultiplier; + private static ConfigEntry liftStrengthMultiplier; public static void Setup(ConfigFile config) { - float min = 0.01f; - float max = 32f; + const float min = 0.01f; + const float max = 32f; playerOnly = config.Bind("Aerofoil", "Player Only", false, new ConfigDescription("Player Only")); playerOnly.SettingChanged += (sender, args) => DoPatch(); @@ -52,28 +52,32 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(ModuleWing), "OnAttached")] - static void PostfixCreate(ModuleWing __instance) { + public static void PostfixCreate(ModuleWing __instance) { if (playerOnly.Value && !CykUtil.IsPlayerTank(__instance)) return; for (int i = 0; i < __instance.m_Aerofoils.Length; i++) { var aerofoil = __instance.m_Aerofoils[i]; - manager.OnObjectAttached(aerofoil); + Manager.OnObjectAttached(aerofoil); } } [HarmonyPrefix] [HarmonyPatch(typeof(ModuleWing), "OnDetaching")] - static void PostfixDestroy(ModuleWing __instance) { + public static void PostfixDestroy(ModuleWing __instance) { if (playerOnly.Value && !CykUtil.IsPlayerTank(__instance)) return; - for (int i = 0; i < __instance.m_Aerofoils.Length; i++) { - var aerofoil = __instance.m_Aerofoils[i]; - manager.OnObjectDetached(aerofoil); - } + foreach (var aerofoil in __instance.m_Aerofoils) Manager.OnObjectDetached(aerofoil); } - public static void DoPatch() { - manager.ApplyAll(); + private static void DoPatch() { + Manager.ApplyAll(); } + + public static readonly Func Register = obj => { + if (Main.debug.Value) + Console.WriteLine("Registering ModuleWing: {0}", obj); + PostfixCreate(obj as ModuleWing); + return true; + }; } } diff --git a/Projects/TerraTech/TerraTech/ObjectFieldMultiplier.cs b/Projects/TerraTech/TerraTech/ObjectFieldMultiplier.cs index b668c9a..5be20bf 100644 --- a/Projects/TerraTech/TerraTech/ObjectFieldMultiplier.cs +++ b/Projects/TerraTech/TerraTech/ObjectFieldMultiplier.cs @@ -71,18 +71,18 @@ namespace TerraTech { _applyCondition = applyCondition; } - public ConfigEntry GetMultiplier(object instance) { + public ConfigEntry GetMultiplier(object __instance) { if (_conditionalMultiplier == null) { return _defaultMultiplier; } - return _conditionalMultiplier(instance); + return _conditionalMultiplier(__instance); } - public bool ShouldApply(object instance) { + public bool ShouldApply(object __instance) { if (_applyCondition == null) { return true; } - return _applyCondition(instance); + return _applyCondition(__instance); } } @@ -247,18 +247,18 @@ namespace TerraTech { _applyCondition = applyCondition; } - public ConfigEntry GetValue(object instance) { + public ConfigEntry GetValue(object __instance) { if (_conditionalValue == null) { return _value; } - return _conditionalValue(instance); + return _conditionalValue(__instance); } - public bool ShouldApply(object instance) { + public bool ShouldApply(object __instance) { if (_applyCondition == null) { return true; } - return _applyCondition(instance); + return _applyCondition(__instance); } } @@ -353,9 +353,9 @@ namespace TerraTech { private readonly Traverse _objectTraverse; private readonly Dictionary _fields; - public MultipliedObject(T instance) { - _instance = instance; - _objectTraverse = Traverse.Create(instance); + public MultipliedObject(T __instance) { + _instance = __instance; + _objectTraverse = Traverse.Create(__instance); _fields = new Dictionary(); } @@ -413,68 +413,68 @@ namespace TerraTech { _managedObjects = new Dictionary>(); } - private void SafeRemove(T instance) { - if (instance == null) + private void SafeRemove(T __instance) { + if (__instance == null) return; try { - _managedObjects.Remove(instance); + _managedObjects.Remove(__instance); } catch (Exception e) { - Console.WriteLine("Error removing instance from _managedObjects: {0}", e); + Console.WriteLine("Error removing __instance from _managedObjects: {0}", e); } } - public void OnObjectAttached(T instance) { + public void OnObjectAttached(T __instance) { if (Main.debug.Value) Console.WriteLine("{0}.OnAttached", typeof(T).Name); - if (instance == null) { - Console.WriteLine("Attempted to attach null instance"); + if (__instance == null) { + Console.WriteLine("Attempted to attach null __instance"); return; } try { - if (_managedObjects.ContainsKey(instance)) { + if (_managedObjects.ContainsKey(__instance)) { if (Main.debug.Value) Console.WriteLine("{0} already managed, skipping", typeof(T).Name); return; } - var multipliedObject = new MultipliedObject(instance); + var multipliedObject = new MultipliedObject(__instance); _configureObject(multipliedObject); multipliedObject.CaptureFrom(); - _managedObjects.Add(instance, multipliedObject); + _managedObjects.Add(__instance, multipliedObject); multipliedObject.LogValues("Patching"); - ApplyTo(instance); + ApplyTo(__instance); multipliedObject.LogValues("Patched"); } catch (Exception e) { Console.WriteLine("Error in OnObjectAttached: {0}", e); } } - public void OnObjectDetached(T instance) { + public void OnObjectDetached(T __instance) { if (Main.debug.Value) Console.WriteLine("{0}.OnDetaching", typeof(T).Name); - if (instance == null) { - Console.WriteLine("Attempted to detach null instance"); + if (__instance == null) { + Console.WriteLine("Attempted to detach null __instance"); return; } try { MultipliedObject multipliedObject; - if (_managedObjects.TryGetValue(instance, out multipliedObject)) { + if (_managedObjects.TryGetValue(__instance, out multipliedObject)) { if (Main.debug.Value) multipliedObject.LogValues("Restoring"); try { - RestoreTo(instance); + RestoreTo(__instance); multipliedObject.LogValues("Restored"); } catch (Exception e) { Console.WriteLine("Error restoring values: {0}", e); } - SafeRemove(instance); + SafeRemove(__instance); } } catch (Exception e) { Console.WriteLine("Error in OnObjectDetached: {0}", e); @@ -488,40 +488,40 @@ namespace TerraTech { // Make a copy of the keys to avoid modification during enumeration var instances = _managedObjects.Keys.ToList(); - foreach (var instance in instances) { + foreach (var __instance in instances) { try { - RestoreTo(instance, fieldNames); - ApplyTo(instance, fieldNames); + RestoreTo(__instance, fieldNames); + ApplyTo(__instance, fieldNames); } catch (Exception e) { - Console.WriteLine("Error applying to instance: {0}", e); + Console.WriteLine("Error applying to __instance: {0}", e); } } } - public void ApplyTo(T instance, IEnumerable fieldNames = null) { + public void ApplyTo(T __instance, IEnumerable fieldNames = null) { if (Main.debug.Value) Console.WriteLine("Applying {0}", typeof(T).Name); - if (instance == null) + if (__instance == null) return; try { MultipliedObject obj; - if (_managedObjects.TryGetValue(instance, out obj)) + if (_managedObjects.TryGetValue(__instance, out obj)) obj.ApplyTo(fieldNames); } catch (Exception e) { Console.WriteLine("Error in ApplyTo: {0}", e); } } - public void RestoreTo(T instance, IEnumerable fieldNames = null) { + public void RestoreTo(T __instance, IEnumerable fieldNames = null) { if (Main.debug.Value) Console.WriteLine("Restoring {0}", typeof(T).Name); - if (instance == null) + if (__instance == null) return; try { MultipliedObject obj; - if (_managedObjects.TryGetValue(instance, out obj)) + if (_managedObjects.TryGetValue(__instance, out obj)) obj.RestoreTo(fieldNames); } catch (Exception e) { Console.WriteLine("Error in RestoreTo: {0}", e); diff --git a/Projects/TerraTech/TerraTech/Patches.cs b/Projects/TerraTech/TerraTech/Patches.cs index 440d558..2395bac 100644 --- a/Projects/TerraTech/TerraTech/Patches.cs +++ b/Projects/TerraTech/TerraTech/Patches.cs @@ -5,7 +5,7 @@ namespace TerraTech { public class Patches { [HarmonyPrefix] [HarmonyPatch(typeof(ManLicenses), "AddXP")] - static void XPMulti(FactionSubTypes corporation, ref int xp, bool showUI = true) { + static void XpMulti(FactionSubTypes corporation, ref int xp, bool showUI = true) { xp = (int)(xp * Main.xpMultiplier.Value); } diff --git a/Projects/TerraTech/TerraTech/SeekingProjectileManager.cs b/Projects/TerraTech/TerraTech/SeekingProjectileManager.cs index 07a6553..3123598 100644 --- a/Projects/TerraTech/TerraTech/SeekingProjectileManager.cs +++ b/Projects/TerraTech/TerraTech/SeekingProjectileManager.cs @@ -5,7 +5,7 @@ namespace TerraTech { public class SeekingProjectileManager { [HarmonyPatch(typeof(SeekingProjectile), "OnSpawn")] class Patch { - static void Postfix(SeekingProjectile __instance) { + public static void Postfix(SeekingProjectile __instance) { if (Main.debug.Value) Console.WriteLine("SeekingProjectile created"); diff --git a/Projects/TerraTech/TerraTech/TankBeamManager.cs b/Projects/TerraTech/TerraTech/TankBeamManager.cs index 5014558..759bbbd 100644 --- a/Projects/TerraTech/TerraTech/TankBeamManager.cs +++ b/Projects/TerraTech/TerraTech/TankBeamManager.cs @@ -4,7 +4,7 @@ using HarmonyLib; namespace TerraTech { [HarmonyPatch] public class TankBeamManager { - private static readonly MultipliedObjectManager manager = + private static readonly MultipliedObjectManager Manager = new MultipliedObjectManager(ConfigureBeam); public static ConfigEntry hoverClearanceMultiplier; @@ -39,15 +39,15 @@ namespace TerraTech { [HarmonyPrefix] [HarmonyPatch(typeof(TankBeam), "EnableBeam")] - static void PostfixCreate(TankBeam __instance, ref bool enable) { + public static void PostfixCreate(TankBeam __instance, ref bool enable) { if (enable) - manager.OnObjectAttached(__instance); + Manager.OnObjectAttached(__instance); else - manager.OnObjectDetached(__instance); + Manager.OnObjectDetached(__instance); } public static void DoPatch() { - manager.ApplyAll(); + Manager.ApplyAll(); } } }