Add multi-buy functionality for block purchasing

Projects/TerraTech/TerraTech/Class1.cs

@@ -8,13 +8,17 @@ 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<bool> debug;
+        public static ConfigEntry<bool> debugBuyAll;
+        public static ConfigEntry<bool> debugMultiBuy;
+        public static ConfigEntry<int> multiBuyAmount;
+
         public static ConfigEntry<float> xpMultiplier;
         public static ConfigEntry<float> moneyMultiplier;
         public static ConfigEntry<float> heartbeatIntervalMultiplier;
@@ -25,6 +29,11 @@ namespace TerraTech {
 
         public void Awake() {
             debug = Config.Bind("General", "Debug", false);
+            debugBuyAll = Config.Bind("General", "Debug Buy All", false);
+            debugMultiBuy = Config.Bind("General", "Debug Multi Buy", false);
+            multiBuyAmount =
+                Config.Bind("General", "Multi Buy Amount", 10,
+                            new ConfigDescription("Multi Buy Amount", new AcceptableValueRange<int>(1, 10000)));
             float min = 0.01f;
             float max = 32f;
 
@@ -43,6 +52,7 @@ namespace TerraTech {
             ModuleWeaponManager.Setup(Config);
             ModuleHeartManager.Setup(Config);
             ModuleFuelTankManager.Setup(Config);
+            TankManager.Setup(Config);
 
             xpMultiplier =
                 Config.Bind("General", "XP Multiplier", 1f,
@@ -72,7 +82,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");

Projects/TerraTech/TerraTech/CykUtil.cs

@@ -14,7 +14,7 @@ namespace TerraTech {
             return tank.ControllableByLocalPlayer;
         }
 
-        public static Func<object, bool> IsObjectPlayerTank = obj => {
+        public static Func<object, bool> isObjectPlayerTank = obj => {
             if (obj == null)
                 return false;
             try {

Projects/TerraTech/TerraTech/ModuleBoosterManager.cs

@@ -6,14 +6,14 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleBoosterManager {
-        private static readonly MultipliedObjectManager<FanJet> fanManager =
+        private static readonly MultipliedObjectManager<FanJet> FanManager =
             new MultipliedObjectManager<FanJet>(ConfigureFanThruster);
-        private static readonly MultipliedObjectManager<BoosterJet> jetManager =
+        private static readonly MultipliedObjectManager<BoosterJet> JetManager =
             new MultipliedObjectManager<BoosterJet>(ConfigureJetThruster);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> fanThrustMultiplier;
-        public static ConfigEntry<float> jetThrustMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> fanThrustMultiplier;
+        private static ConfigEntry<float> jetThrustMultiplier;
 
         public static void Setup(ConfigFile config) {
             float min = 0.01f;
@@ -44,34 +44,41 @@ namespace TerraTech {
         private static readonly Func<object, bool> 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<List<FanJet>>();
             var jets = trav.Field("jets").GetValue<List<BoosterJet>>();
 
-            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<List<FanJet>>();
             var jets = trav.Field("jets").GetValue<List<BoosterJet>>();
 
-            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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleBooster: {0}", obj);
+            PostfixCreate(obj as ModuleBooster);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleEnergyManager.cs

@@ -5,12 +5,12 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleEnergyManager {
-        private static readonly MultipliedObjectManager<ModuleEnergy> manager =
+        private static readonly MultipliedObjectManager<ModuleEnergy> Manager =
             new MultipliedObjectManager<ModuleEnergy>(ConfigureModuleEnergy);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> outputMultiplier;
-        public static ConfigEntry<float> powerUpDelayMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> outputMultiplier;
+        private static ConfigEntry<float> 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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleEnergy: {0}", obj);
+            PostfixCreate(obj as ModuleEnergy);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleEnergyStoreManager.cs

@@ -5,11 +5,11 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleEnergyStoreManager {
-        private static readonly MultipliedObjectManager<ModuleEnergyStore> manager =
+        private static readonly MultipliedObjectManager<ModuleEnergyStore> Manager =
             new MultipliedObjectManager<ModuleEnergyStore>(ConfigureModuleEnergyStore);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> capacityMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> 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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleEnergyStore: {0}", obj);
+            PostfixCreate(obj as ModuleEnergyStore);
+            return true;
+        };
     }
 }

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<ModuleFuelTank> manager =
+        private static readonly MultipliedObjectManager<ModuleFuelTank> Manager =
             new MultipliedObjectManager<ModuleFuelTank>(ConfigureFuelTank);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> fuelCapacityMultiplier;
-        public static ConfigEntry<float> fuelRefillMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> fuelCapacityMultiplier;
+        private static ConfigEntry<float> fuelRefillMultiplier;
 
         public static void Setup(ConfigFile config) {
             float min = 0.01f;
@@ -39,23 +38,30 @@ namespace TerraTech {
         private static readonly Func<object, bool> 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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleFuelTank: {0}", obj);
+            PostfixCreate(obj as ModuleFuelTank);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleGyroManager.cs

@@ -5,11 +5,11 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleGyroManager {
-        private static readonly MultipliedObjectManager<ModuleGyro> manager =
+        private static readonly MultipliedObjectManager<ModuleGyro> Manager =
             new MultipliedObjectManager<ModuleGyro>(ConfigureModuleGyro);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> activeSpeedMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> 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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleGyro: {0}", obj);
+            PostfixCreate(obj as ModuleGyro);
+            return true;
+        };
     }
 }

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<ModuleHeart> manager =
+        private static readonly MultipliedObjectManager<ModuleHeart> Manager =
             new MultipliedObjectManager<ModuleHeart>(ConfigureHeart);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> eventHorizonRadiusMultiplier;
-        public static ConfigEntry<float> setupTimeMultiplier;
-        public static ConfigEntry<float> startShrinkingRadiusMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> eventHorizonRadiusMultiplier;
+        private static ConfigEntry<float> setupTimeMultiplier;
+        private static ConfigEntry<float> startShrinkingRadiusMultiplier;
 
         public static void Setup(ConfigFile config) {
             float min = 0.01f;
@@ -48,23 +47,30 @@ namespace TerraTech {
         private static readonly Func<object, bool> 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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleHeart: {0}", obj);
+            PostfixCreate(obj as ModuleHeart);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleItemHolderManager.cs

@@ -5,25 +5,25 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleItemHolderManager {
-        private static readonly MultipliedObjectManager<ModuleItemHolder> beamManager =
+        private static readonly MultipliedObjectManager<ModuleItemHolder> BeamManager =
             new MultipliedObjectManager<ModuleItemHolder>(ConfigureBeam);
-        private static readonly MultipliedObjectManager<ModuleItemHolderBeam> beamHolderManager =
+        private static readonly MultipliedObjectManager<ModuleItemHolderBeam> BeamHolderManager =
             new MultipliedObjectManager<ModuleItemHolderBeam>(ConfigureBeamHolder);
-        private static readonly MultipliedObjectManager<ModuleItemPickup> beamPickupManager =
+        private static readonly MultipliedObjectManager<ModuleItemPickup> BeamPickupManager =
             new MultipliedObjectManager<ModuleItemPickup>(ConfigureBeamPickup);
 
-        private static readonly MultipliedObjectManager<ModuleItemHolderMagnet> magnetHolderManager =
+        private static readonly MultipliedObjectManager<ModuleItemHolderMagnet> MagnetHolderManager =
             new MultipliedObjectManager<ModuleItemHolderMagnet>(ConfigureMagnetHolder);
-        private static readonly MultipliedObjectManager<ModuleItemPickup> magnetPickupManager =
+        private static readonly MultipliedObjectManager<ModuleItemPickup> MagnetPickupManager =
             new MultipliedObjectManager<ModuleItemPickup>(ConfigureMagnetPickup);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> capacityPerStackMultiplier;
-        public static ConfigEntry<float> beamStrengthMultiplier;
-        public static ConfigEntry<float> beamHeightIncrementScaleMultiplier;
-        public static ConfigEntry<float> beamPickupRangeMultiplier;
-        public static ConfigEntry<float> magnetStrengthMultiplier;
-        public static ConfigEntry<float> magnetPickupRangeMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> capacityPerStackMultiplier;
+        private static ConfigEntry<float> beamStrengthMultiplier;
+        private static ConfigEntry<float> beamHeightIncrementScaleMultiplier;
+        private static ConfigEntry<float> beamPickupRangeMultiplier;
+        private static ConfigEntry<float> magnetStrengthMultiplier;
+        private static ConfigEntry<float> 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<ModuleItemPickup>();
 
-            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<ModuleItemPickup>();
 
-            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<ModuleItemPickup>();
 
-            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<ModuleItemPickup>();
 
-            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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleItemHolder: {0}", obj);
+            PostfixCreate(obj as ModuleItemHolder);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleItemProducerManager.cs

@@ -5,13 +5,13 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleItemProducerManager {
-        private static readonly MultipliedObjectManager<ModuleItemProducer> manager =
+        private static readonly MultipliedObjectManager<ModuleItemProducer> Manager =
             new MultipliedObjectManager<ModuleItemProducer>(ConfigureModuleItemProducer);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> resourceGroundRadiusMultiplier;
-        public static ConfigEntry<float> minDispenseIntervalMultiplier;
-        public static ConfigEntry<float> secPerItemProducedMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> resourceGroundRadiusMultiplier;
+        private static ConfigEntry<float> minDispenseIntervalMultiplier;
+        private static ConfigEntry<float> 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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleItemProducer: {0}", obj);
+            PostfixCreate(obj as ModuleItemProducer);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleRemoteChargerManager.cs

@@ -5,17 +5,17 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleRemoteChargerManager {
-        private static readonly MultipliedObjectManager<ModuleRemoteCharger> manager =
+        private static readonly MultipliedObjectManager<ModuleRemoteCharger> Manager =
             new MultipliedObjectManager<ModuleRemoteCharger>(ConfigureModuleRemoteCharger);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> arcFiringIntervalMultiplier;
-        public static ConfigEntry<float> chargingRadiusMultiplier;
-        public static ConfigEntry<float> powerTransferPerArcMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> arcFiringIntervalMultiplier;
+        private static ConfigEntry<float> chargingRadiusMultiplier;
+        private static ConfigEntry<float> 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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleRemoteCharger: {0}", obj);
+            PostfixCreate(obj as ModuleRemoteCharger);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleShieldGeneratorManager.cs

@@ -5,18 +5,18 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleShieldGeneratorManager {
-        private static readonly MultipliedObjectManager<ModuleShieldGenerator> manager =
+        private static readonly MultipliedObjectManager<ModuleShieldGenerator> Manager =
             new MultipliedObjectManager<ModuleShieldGenerator>(ConfigureShieldGenerator);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> radiusMultiplier;
-        public static ConfigEntry<float> radiusMultiplierHealing;
-        public static ConfigEntry<float> heartbeatIntervalMultiplier;
-        public static ConfigEntry<float> powerUpDelayMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> radiusMultiplier;
+        private static ConfigEntry<float> radiusMultiplierHealing;
+        private static ConfigEntry<float> heartbeatIntervalMultiplier;
+        private static ConfigEntry<float> 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<float, float>("m_HealingHeartbeatInterval", heartbeatIntervalMultiplier,
                                                               ShouldApply));
 
-            obj.AddField(new FieldConfiguration<float, float>("m_Radius", radiusMultiplier, instance => {
-                if (!ShouldApply(instance))
+            obj.AddField(new FieldConfiguration<float, float>("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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleShieldGenerator: {0}", obj);
+            PostfixCreate(obj as ModuleShieldGenerator);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleWeaponGunManager.cs

@@ -5,23 +5,23 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleWeaponGunManager {
-        private static readonly MultipliedObjectManager<ModuleWeaponGun> manager =
+        private static readonly MultipliedObjectManager<ModuleWeaponGun> Manager =
             new MultipliedObjectManager<ModuleWeaponGun>(ConfigureManager);
-        private static readonly MultipliedObjectManager<FireData> fireDataManager =
+        private static readonly MultipliedObjectManager<FireData> FireDataManager =
             new MultipliedObjectManager<FireData>(ConfigureFireData);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> kickbackStrengthMultiplier;
-        public static ConfigEntry<float> muzzleVelocityMultiplier;
-        public static ConfigEntry<float> burstCooldownMultiplier;
-        public static ConfigEntry<float> burstShotCountMultiplier;
-        public static ConfigEntry<float> shotCooldownMultiplier;
-        public static ConfigEntry<bool> seekingRoundsAll;
-        public static ConfigEntry<bool> resetBurstOnInterruptAll;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> kickbackStrengthMultiplier;
+        private static ConfigEntry<float> muzzleVelocityMultiplier;
+        private static ConfigEntry<float> burstCooldownMultiplier;
+        private static ConfigEntry<float> burstShotCountMultiplier;
+        private static ConfigEntry<float> shotCooldownMultiplier;
+        private static ConfigEntry<bool> seekingRoundsAll;
+        private static ConfigEntry<bool> 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<FireData>());
+            FireDataManager.OnObjectAttached(firingData.GetValue<FireData>());
         }
 
         [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<FireData>());
+            FireDataManager.OnObjectDetached(firingData.GetValue<FireData>());
         }
 
-        public static void DoPatch() {
-            fireDataManager.ApplyAll();
-            manager.ApplyAll();
+        private static void DoPatch() {
+            FireDataManager.ApplyAll();
+            Manager.ApplyAll();
         }
+
+        public static readonly Func<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleWeaponGun: {0}", obj);
+            PostfixCreate(obj as ModuleWeaponGun);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleWeaponManager.cs

@@ -5,15 +5,15 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleWeaponManager {
-        private static readonly MultipliedObjectManager<ModuleWeapon> manager =
+        private static readonly MultipliedObjectManager<ModuleWeapon> Manager =
             new MultipliedObjectManager<ModuleWeapon>(ConfigureManager);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> rotateSpeedMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> 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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleWeapon: {0}", obj);
+            PostfixCreate(obj as ModuleWeapon);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleWheelsManager.cs

@@ -5,16 +5,16 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleWheelsManager {
-        private static readonly MultipliedObjectManager<ManWheels.TorqueParams> torqueParamsManager =
+        private static readonly MultipliedObjectManager<ManWheels.TorqueParams> TorqueParamsManager =
             new MultipliedObjectManager<ManWheels.TorqueParams>(ConfigureTorqueParams);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> torqueRpmMultiplier;
-        public static ConfigEntry<float> torqueMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> torqueRpmMultiplier;
+        private static ConfigEntry<float> 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<ManWheels.TorqueParams>());
+            TorqueParamsManager.OnObjectAttached(torqueParams.GetValue<ManWheels.TorqueParams>());
         }
 
         [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<ManWheels.TorqueParams>());
+            TorqueParamsManager.OnObjectDetached(torqueParams.GetValue<ManWheels.TorqueParams>());
         }
 
-        public static void DoPatch() {
-            torqueParamsManager.ApplyAll();
+        private static void DoPatch() {
+            TorqueParamsManager.ApplyAll();
         }
+
+        public static readonly Func<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleWheels: {0}", obj);
+            PostfixCreate(obj as ModuleWheels);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/ModuleWingManager.cs

@@ -5,17 +5,17 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class ModuleWingManager {
-        private static readonly MultipliedObjectManager<ModuleWing.Aerofoil> manager =
+        private static readonly MultipliedObjectManager<ModuleWing.Aerofoil> Manager =
             new MultipliedObjectManager<ModuleWing.Aerofoil>(ConfigureAerofoil);
 
-        public static ConfigEntry<bool> playerOnly;
-        public static ConfigEntry<float> angleRangeMultiplier;
-        public static ConfigEntry<float> turnSpeedMultiplier;
-        public static ConfigEntry<float> liftStrengthMultiplier;
+        private static ConfigEntry<bool> playerOnly;
+        private static ConfigEntry<float> angleRangeMultiplier;
+        private static ConfigEntry<float> turnSpeedMultiplier;
+        private static ConfigEntry<float> 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<Module, bool> Register = obj => {
+            if (Main.debug.Value)
+                Console.WriteLine("Registering ModuleWing: {0}", obj);
+            PostfixCreate(obj as ModuleWing);
+            return true;
+        };
     }
 }

Projects/TerraTech/TerraTech/MultiBuy.cs

@@ -0,0 +1,71 @@
+using System;
+using System.Reflection;
+using HarmonyLib;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace TerraTech {
+    [HarmonyPatch]
+    public class MultiBuy {
+        public static UIShopBlockSelect panel;
+        public static Traverse panelTraverse;
+
+        [HarmonyPostfix]
+        [HarmonyPatch(typeof(UIShopBlockSelect), "OnSpawn")]
+        public static void PostfixCreate(UIShopBlockSelect __instance) {
+            panel = __instance;
+            if (Main.debugBuyAll.Value)
+                Console.WriteLine("UISnapshotPanel.OnPool: {0}", __instance);
+            panelTraverse = Traverse.Create(__instance);
+            var placeButton = panelTraverse.Field("m_PurchaseBlockButton").GetValue<Button>();
+            placeButton.gameObject.AddComponent<MultiBuyRightClickHandler>();
+        }
+    }
+
+    class MultiBuyRightClickHandler : MonoBehaviour, IPointerClickHandler {
+        // private void Awake() {
+        // }
+
+        public void OnPointerClick(PointerEventData eventData) {
+            if (Main.debugBuyAll.Value)
+                Console.WriteLine("MultiBuyRightClickHandler.OnPointerClick: {0} {1}", gameObject.name,
+                                  eventData.button);
+            try {
+                if (eventData.button == PointerEventData.InputButton.Right) {
+                    UIBlockSelectGrid grid = MultiBuy.panelTraverse.Field("m_Grid").GetValue<UIBlockSelectGrid>();
+                    BlockTypes blockTypes;
+                    bool ok = grid.TryGetSelection(out blockTypes);
+                    if (!ok) {
+                        if (Main.debugBuyAll.Value)
+                            Console.WriteLine(
+                                "MultiBuyRightClickHandler.OnPointerClick: Failed to get block selection from grid");
+                        return;
+                    }
+                    uint shopBlockPoolID = MultiBuy.panelTraverse.Field("m_ShopBlockPoolID").GetValue<uint>();
+
+                    MethodInfo canPurchaseMethod =
+                        AccessTools.Method(typeof(UIShopBlockSelect), "CanPurchaseBlock", new[] { typeof(BlockTypes) });
+                    Func<BlockTypes, bool> canPurchase = (Func<BlockTypes, bool>)Delegate.CreateDelegate(
+                        typeof(Func<BlockTypes, bool>), MultiBuy.panel, canPurchaseMethod);
+
+                    for (int i = 0; i < Main.multiBuyAmount.Value; i++) {
+                        if (!canPurchase.Invoke(blockTypes)) {
+                            if (Main.debugBuyAll.Value)
+                                Console.WriteLine("MultiBuyRightClickHandler.OnPointerClick: Can purchase no more {0}",
+                                                  blockTypes);
+                            return;
+                        }
+                        Singleton.Manager<ManPurchases>.inst.RequestPurchaseBlock(shopBlockPoolID, blockTypes, 1);
+                        if (Main.debugBuyAll.Value)
+                            Console.WriteLine("MultiBuyRightClickHandler.OnPointerClick: Purchased {0} block",
+                                              blockTypes);
+                    }
+                }
+            } catch (Exception e) {
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("MultiBuyRightClickHandler.OnPointerClick: Exception occurred: {0}", e);
+            }
+        }
+    }
+}

Projects/TerraTech/TerraTech/ObjectFieldMultiplier.cs

@@ -71,18 +71,18 @@ namespace TerraTech {
             _applyCondition = applyCondition;
         }
 
-        public ConfigEntry<TMul> GetMultiplier(object instance) {
+        public ConfigEntry<TMul> 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<bool> GetValue(object instance) {
+        public ConfigEntry<bool> 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<string, IFieldModifier> _fields;
 
-        public MultipliedObject(T instance) {
-            _instance = instance;
-            _objectTraverse = Traverse.Create(instance);
+        public MultipliedObject(T __instance) {
+            _instance = __instance;
+            _objectTraverse = Traverse.Create(__instance);
             _fields = new Dictionary<string, IFieldModifier>();
         }
 
@@ -413,68 +413,68 @@ namespace TerraTech {
             _managedObjects = new Dictionary<T, MultipliedObject<T>>();
         }
 
-        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<T>(instance);
+                var multipliedObject = new MultipliedObject<T>(__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<T> 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<string> fieldNames = null) {
+        public void ApplyTo(T __instance, IEnumerable<string> fieldNames = null) {
             if (Main.debug.Value)
                 Console.WriteLine("Applying {0}", typeof(T).Name);
-            if (instance == null)
+            if (__instance == null)
                 return;
 
             try {
                 MultipliedObject<T> 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<string> fieldNames = null) {
+        public void RestoreTo(T __instance, IEnumerable<string> fieldNames = null) {
             if (Main.debug.Value)
                 Console.WriteLine("Restoring {0}", typeof(T).Name);
-            if (instance == null)
+            if (__instance == null)
                 return;
 
             try {
                 MultipliedObject<T> 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);

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);
         }
 

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");
 

Projects/TerraTech/TerraTech/TankBeamManager.cs

@@ -4,7 +4,7 @@ using HarmonyLib;
 namespace TerraTech {
     [HarmonyPatch]
     public class TankBeamManager {
-        private static readonly MultipliedObjectManager<TankBeam> manager =
+        private static readonly MultipliedObjectManager<TankBeam> Manager =
             new MultipliedObjectManager<TankBeam>(ConfigureBeam);
 
         public static ConfigEntry<float> 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();
         }
     }
 }

Projects/TerraTech/TerraTech/TankManager.cs

@@ -0,0 +1,53 @@
+using System;
+using System.Collections.Generic;
+using BepInEx.Configuration;
+using HarmonyLib;
+using UnityEngine;
+
+namespace TerraTech {
+    [HarmonyPatch]
+    public class TankManager {
+        public static ConfigEntry<bool> recheck;
+        public static Dictionary<Type, Func<Module, bool>> moduleManagerMapper =
+            new Dictionary<Type, Func<Module, bool>>();
+
+        public static void Setup(ConfigFile config) {
+            recheck = config.Bind("Tank", "Recheck", false, new ConfigDescription("Recheck"));
+            moduleManagerMapper.Add(typeof(ModuleBooster), ModuleBoosterManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleEnergy), ModuleEnergyManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleEnergyStore), ModuleEnergyStoreManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleFuelTank), ModuleFuelTankManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleGyro), ModuleGyroManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleHeart), ModuleHeartManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleItemHolder), ModuleItemHolderManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleItemProducer), ModuleItemProducerManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleRemoteCharger), ModuleRemoteChargerManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleShieldGenerator), ModuleShieldGeneratorManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleWeaponGun), ModuleWeaponGunManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleWeapon), ModuleWeaponManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleWheels), ModuleWheelsManager.Register);
+            moduleManagerMapper.Add(typeof(ModuleWing), ModuleWingManager.Register);
+        }
+
+        [HarmonyPrefix]
+        [HarmonyPatch(typeof(Tank), "NotifyAnchor")]
+        public static void PostfixCreate(Tank __instance, ModuleAnchor anchor, bool anchored) {
+            if (Main.debug.Value)
+                Console.WriteLine("TankManager.NotifyAnchor: {0}", __instance);
+            if (!__instance.ControllableByLocalPlayer)
+                return;
+            if (!recheck.Value)
+                return;
+
+            foreach (Transform child in __instance.transform) {
+                GameObject childObj = child.gameObject;
+                Component[] components = childObj.GetComponents<Component>();
+                foreach (Component component in components) {
+                    Func<Module, bool> manager;
+                    if (moduleManagerMapper.TryGetValue(component.GetType(), out manager))
+                        manager(component as Module);
+                }
+            }
+        }
+    }
+}

Projects/TerraTech/TerraTech/TerraTech.csproj

@@ -59,6 +59,9 @@
     <Compile Include="ModuleHeartManager.cs" />
     <Compile Include="ModuleFuelTankManager.cs" />
     <Compile Include="ProjectilePatch.cs" />
+    <Compile Include="TankManager.cs" />
+    <Compile Include="UISnapshotPanelBuyAll.cs" />
+    <Compile Include="MultiBuy.cs" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="0Harmony">
@@ -73,6 +76,9 @@
     <Reference Include="UnityEngine.CoreModule">
       <HintPath>$(GAME_MANAGED)/UnityEngine.CoreModule.dll</HintPath>
     </Reference>
+    <Reference Include="UnityEngine.UI">
+      <HintPath>$(GAME_MANAGED)/UnityEngine.UI.dll</HintPath>
+    </Reference>
     <Reference Include="UnityEngine.Networking">
       <HintPath>$(GAME_MANAGED)/UnityEngine.Networking.dll</HintPath>
     </Reference>

Projects/TerraTech/TerraTech/UISnapshotPanelBuyAll.cs

@@ -0,0 +1,181 @@
+using System;
+using System.Collections.Generic;
+using HarmonyLib;
+using Snapshots;
+using UnityEngine;
+using UnityEngine.EventSystems;
+using UnityEngine.UI;
+
+namespace TerraTech {
+    [HarmonyPatch]
+    public class UISnapshotPanelBuyAll {
+        public static UISnapshotPanel panel;
+        public static Traverse panelTraverse;
+        public static SnapshotLiveData selectedData;
+
+        [HarmonyPostfix]
+        [HarmonyPatch(typeof(UISnapshotPanel), "OnPool")]
+        public static void PostfixCreate(UISnapshotPanel __instance) {
+            if (Main.debugBuyAll.Value)
+                Console.WriteLine("UISnapshotPanel.OnPool: {0}", __instance);
+            panel = __instance;
+            panelTraverse = Traverse.Create(__instance);
+            var placeButton = panelTraverse.Field("m_PlaceButton").GetValue<Button>();
+            placeButton.gameObject.AddComponent<RightClickHandler>();
+
+            var swapButton = panelTraverse.Field("m_SwapButton").GetValue<Button>();
+            swapButton.gameObject.AddComponent<RightClickHandlerSwap>();
+        }
+
+        [HarmonyPostfix]
+        [HarmonyPatch(typeof(UISnapshotPanel), "OnSelectedChanged")]
+        public static void PostfixCreate(UISnapshotPanel __instance, ref SnapshotLiveData selectedData) {
+            if (Main.debugBuyAll.Value)
+                Console.WriteLine("UISnapshotPanel.OnSelectedChanged: {0}", __instance);
+            UISnapshotPanelBuyAll.selectedData = selectedData;
+        }
+    }
+
+    public abstract class BaseRightClickHandler : MonoBehaviour, IPointerClickHandler {
+        protected static Traverse m_TechAvailLookupTraverse;
+        protected static Dictionary<Snapshot, TechDataAvailValidation> m_TechAvailLookup;
+
+        protected virtual void Awake() {
+            var trav = Traverse.Create(Singleton.Manager<ManSnapshots>.inst);
+            m_TechAvailLookupTraverse = trav.Field("m_TechAvailLookup");
+            m_TechAvailLookup = m_TechAvailLookupTraverse.GetValue<Dictionary<Snapshot, TechDataAvailValidation>>();
+        }
+
+        protected Dictionary<BlockTypes, int> CalculateMissingBlocks(
+            Dictionary<BlockTypes, TechDataAvailValidation.BlockTypeAvailability> blockAvailability, bool isSpawning) {
+            Dictionary<BlockTypes, int> missing = new Dictionary<BlockTypes, int>();
+
+            foreach (var kvp in blockAvailability) {
+                int numMissing;
+                if (isSpawning)
+                    numMissing = kvp.Value.numRequired - kvp.Value.numInInventory;
+                else
+                    numMissing = kvp.Value.numRequired - kvp.Value.numInInventory - kvp.Value.numOnPlayerTech;
+            }
+
+            if (missing.Count == 0)
+                foreach (var kvp in blockAvailability) missing.Add(kvp.Key, kvp.Value.numRequired);
+            return missing;
+        }
+
+        protected int CalculateTotalCost(Dictionary<BlockTypes, int> missingBlocks) {
+            int totalCost = 0;
+            RecipeManager recipeManager = Singleton.Manager<RecipeManager>.inst;
+
+            foreach (var kvp in missingBlocks) {
+                int cost = recipeManager.GetBlockBuyPrice(kvp.Key) * kvp.Value;
+                totalCost += cost;
+
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("{0} of {1} would cost {2}, total now {3}", kvp.Value, kvp.Key, cost, totalCost);
+            }
+            return totalCost;
+        }
+
+        protected bool TryPurchaseBlocks(Dictionary<BlockTypes, int> missingBlocks, int totalCost) {
+            ManPlayer player = Singleton.Manager<ManPlayer>.inst;
+            if (player.GetCurrentMoney() < totalCost) {
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("Not enough money, have {0} but need {1}, nothing to do",
+                                      player.GetCurrentMoney(), totalCost);
+                return false;
+            }
+
+            player.PayMoney(totalCost);
+            foreach (var kvp in missingBlocks) {
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("Buying {0} of {1}", kvp.Value, kvp.Key);
+                player.PlayerInventory.HostAddItem(kvp.Key, kvp.Value);
+            }
+            return true;
+        }
+
+        protected bool ProcessPurchase(
+            Dictionary<BlockTypes, TechDataAvailValidation.BlockTypeAvailability> blockAvailability, bool isSpawning) {
+            try {
+                if (blockAvailability == null) {
+                    if (Main.debugBuyAll.Value)
+                        Console.WriteLine("Block availability is null (wtf?), nothing to do");
+                    return false;
+                }
+
+                var missingBlocks = CalculateMissingBlocks(blockAvailability, isSpawning);
+                int totalCost = CalculateTotalCost(missingBlocks);
+
+                if (totalCost > 0) {
+                    if (Main.debugBuyAll.Value)
+                        Console.WriteLine("Total cost: {0}", totalCost);
+                    return TryPurchaseBlocks(missingBlocks, totalCost);
+                }
+
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("No blocks missing or no cost calculated");
+                return false;
+            } catch (Exception e) {
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("Error during purchase processing: {0}", e);
+                return false;
+            }
+        }
+
+        protected Dictionary<BlockTypes, TechDataAvailValidation.BlockTypeAvailability> GetCurrentBlockAvailability() {
+            SnapshotLiveData selectedSnapshotData = UISnapshotPanelBuyAll.selectedData;
+            Snapshot selectedSnapshot = selectedSnapshotData.m_Snapshot;
+            if (selectedSnapshot == null) {
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("Selected snapshot is null wtf??: {0}", gameObject.name);
+                return null;
+            }
+
+            TechDataAvailValidation techDataAvail;
+            if (!m_TechAvailLookup.TryGetValue(selectedSnapshot, out techDataAvail)) {
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("Failed to find TechDataAvailValidation for snapshot: {0}", selectedSnapshot);
+                return null;
+            }
+
+            var trav = Traverse.Create(techDataAvail);
+            var mBlockAvailabilityField = trav.Field("m_BlockAvailability");
+            var mBlockAvailability =
+                mBlockAvailabilityField
+                    .GetValue<Dictionary<BlockTypes, TechDataAvailValidation.BlockTypeAvailability>>();
+
+            return mBlockAvailability;
+        }
+
+        public abstract void OnPointerClick(PointerEventData eventData);
+    }
+
+    public class RightClickHandler : BaseRightClickHandler {
+        public override void OnPointerClick(PointerEventData eventData) {
+            if (Main.debugBuyAll.Value)
+                Console.WriteLine("UISnapshotPanel.OnPointerClick: {0} {1}", gameObject.name, eventData.button);
+            try {
+                if (eventData.button == PointerEventData.InputButton.Right)
+                    ProcessPurchase(GetCurrentBlockAvailability(), true);
+            } catch (Exception e) {
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("Shit exploded fml: {0}", e);
+            }
+        }
+    }
+
+    public class RightClickHandlerSwap : BaseRightClickHandler {
+        public override void OnPointerClick(PointerEventData eventData) {
+            if (Main.debugBuyAll.Value)
+                Console.WriteLine("UISnapshotPanel.OnPointerClick: {0} {1}", gameObject.name, eventData.button);
+            try {
+                if (eventData.button == PointerEventData.InputButton.Right)
+                    ProcessPurchase(GetCurrentBlockAvailability(), false);
+            } catch (Exception e) {
+                if (Main.debugBuyAll.Value)
+                    Console.WriteLine("Shit exploded fml: {0}", e);
+            }
+        }
+    }
+}

Projects/TerraTech/TerraTech/log.cs

@@ -0,0 +1,14 @@
+static void Postfix(UIItemSelectGrid __instance) {
+    try {
+        StringBuilder sb = new StringBuilder();
+        sb.AppendLine("--------------------");
+        sb.AppendLine("void UIItemSelectGrid::Repopulate()");
+        sb.Append("- __instance: ").AppendLine(__instance.ToString());
+        foreach (var item in __instance.m_FilteredItemList) {
+            sb.Append("- item: ").AppendLine(item.ToString());
+        }
+        UnityExplorer.ExplorerCore.Log(sb.ToString());
+    } catch (System.Exception ex) {
+        UnityExplorer.ExplorerCore.LogWarning($"Exception in patch of void UIItemSelectGrid::Repopulate():\n{ex}");
+    }
+}