Add player-only configuration to module managers

Projects/TerraTech/TerraTech/ModuleEnergyManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -7,6 +8,7 @@ namespace TerraTech {
         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;
 
@@ -14,6 +16,9 @@ namespace TerraTech {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("Energy", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             outputMultiplier =
                 config.Bind("Energy", "Output Multiplier", 1f,
                             new ConfigDescription("Output Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -26,10 +31,16 @@ namespace TerraTech {
         }
 
         private static void ConfigureModuleEnergy(MultipliedObject<ModuleEnergy> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_OutputPerSecond", outputMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_OutputPerSecond", outputMultiplier, ShouldApply));
-            obj.AddField(new FieldConfiguration<float, float>("m_PowerUpDelay", powerUpDelayMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_PowerUpDelay", powerUpDelayMultiplier, ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleEnergy), "OnAttached")]
         static void PostfixCreate(ModuleEnergy __instance) {

Projects/TerraTech/TerraTech/ModuleEnergyStoreManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -7,12 +8,16 @@ namespace TerraTech {
         private static readonly MultipliedObjectManager<ModuleEnergyStore> manager =
             new MultipliedObjectManager<ModuleEnergyStore>(ConfigureModuleEnergyStore);
 
+        public static ConfigEntry<bool> playerOnly;
         public static ConfigEntry<float> capacityMultiplier;
 
         public static void Setup(ConfigFile config) {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("Energy", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             capacityMultiplier =
                 config.Bind("Energy", "Capacity Multiplier", 1f,
                             new ConfigDescription("Capacity Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -20,9 +25,15 @@ namespace TerraTech {
         }
 
         private static void ConfigureModuleEnergyStore(MultipliedObject<ModuleEnergyStore> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_Capacity", capacityMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_Capacity", capacityMultiplier, ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleEnergyStore), "OnAttached")]
         static void PostfixCreate(ModuleEnergyStore __instance) {

Projects/TerraTech/TerraTech/ModuleGyroManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -7,12 +8,16 @@ namespace TerraTech {
         private static readonly MultipliedObjectManager<ModuleGyro> manager =
             new MultipliedObjectManager<ModuleGyro>(ConfigureModuleGyro);
 
+        public static ConfigEntry<bool> playerOnly;
         public static ConfigEntry<float> activeSpeedMultiplier;
 
         public static void Setup(ConfigFile config) {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("Gyro", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             activeSpeedMultiplier = config.Bind(
                 "Gyro", "Active Speed Multiplier", 1f,
                 new ConfigDescription("Active Speed Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -20,9 +25,15 @@ namespace TerraTech {
         }
 
         private static void ConfigureModuleGyro(MultipliedObject<ModuleGyro> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_ActiveSpeed", activeSpeedMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_ActiveSpeed", activeSpeedMultiplier, ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleGyro), "OnAttached")]
         static void PostfixCreate(ModuleGyro __instance) {

Projects/TerraTech/TerraTech/ModuleItemHolderManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -16,6 +17,7 @@ namespace TerraTech {
         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;
@@ -27,6 +29,9 @@ namespace TerraTech {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("Item Holder", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             capacityPerStackMultiplier = config.Bind(
                 "Item Holder", "Capacity Per Stack Multiplier", 1f,
                 new ConfigDescription("Capacity Per Stack Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -60,27 +65,35 @@ namespace TerraTech {
         }
 
         private static void ConfigureBeam(MultipliedObject<ModuleItemHolder> obj) {
-            obj.AddField(new FieldConfiguration<int, float>("m_CapacityPerStack", capacityPerStackMultiplier));
+            obj.AddField(
+                new FieldConfiguration<int, float>("m_CapacityPerStack", capacityPerStackMultiplier, ShouldApply));
         }
 
         private static void ConfigureBeamHolder(MultipliedObject<ModuleItemHolderBeam> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_BeamStrength", beamStrengthMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_BeamStrength", beamStrengthMultiplier, ShouldApply));
-            obj.AddField(
+            obj.AddField(new FieldConfiguration<float, float>("m_HeightIncrementScale",
-                new FieldConfiguration<float, float>("m_HeightIncrementScale", beamHeightIncrementScaleMultiplier));
+                                                              beamHeightIncrementScaleMultiplier, ShouldApply));
         }
 
         private static void ConfigureBeamPickup(MultipliedObject<ModuleItemPickup> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_PickupRange", beamPickupRangeMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_PickupRange", beamPickupRangeMultiplier, ShouldApply));
         }
 
         private static void ConfigureMagnetHolder(MultipliedObject<ModuleItemHolderMagnet> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_Strength", magnetStrengthMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_Strength", magnetStrengthMultiplier, ShouldApply));
         }
 
         private static void ConfigureMagnetPickup(MultipliedObject<ModuleItemPickup> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_PickupRange", magnetPickupRangeMultiplier));
+            obj.AddField(
+                new FieldConfiguration<float, float>("m_PickupRange", magnetPickupRangeMultiplier, ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleItemHolder), "OnAttached")]
         static void PostfixCreate(ModuleItemHolder __instance) {

Projects/TerraTech/TerraTech/ModuleItemProducerManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -7,6 +8,7 @@ namespace TerraTech {
         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;
@@ -15,6 +17,9 @@ namespace TerraTech {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("Item Producer", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             resourceGroundRadiusMultiplier = config.Bind(
                 "Item Producer", "Resource Ground Radius Multiplier", 1f,
                 new ConfigDescription("Resource Ground Radius Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -32,12 +37,20 @@ namespace TerraTech {
         }
 
         private static void ConfigureModuleItemProducer(MultipliedObject<ModuleItemProducer> obj) {
-            obj.AddField(
+            obj.AddField(new FieldConfiguration<float, float>("m_ResourceGroundRadius", resourceGroundRadiusMultiplier,
-                new FieldConfiguration<float, float>("m_ResourceGroundRadius", resourceGroundRadiusMultiplier));
+                                                              ShouldApply));
-            obj.AddField(new FieldConfiguration<float, float>("m_MinDispenseInterval", minDispenseIntervalMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_MinDispenseInterval", minDispenseIntervalMultiplier,
-            obj.AddField(new FieldConfiguration<float, float>("m_SecPerItemProduced", secPerItemProducedMultiplier));
+                                                              ShouldApply));
+            obj.AddField(new FieldConfiguration<float, float>("m_SecPerItemProduced", secPerItemProducedMultiplier,
+                                                              ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleItemProducer), "GetClosestResourceReservoirInRange")]
         static void PostfixCreate(ModuleItemProducer __instance) {

Projects/TerraTech/TerraTech/ModuleRemoteChargerManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -7,6 +8,7 @@ namespace TerraTech {
         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;
@@ -15,6 +17,9 @@ namespace TerraTech {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("Remote Charger", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             arcFiringIntervalMultiplier = config.Bind(
                 "Remote Charger", "Arc Firing Interval Multiplier", 1f,
                 new ConfigDescription("Arc Firing Interval Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -32,11 +37,20 @@ namespace TerraTech {
         }
 
         private static void ConfigureModuleRemoteCharger(MultipliedObject<ModuleRemoteCharger> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_ArcFiringInterval", arcFiringIntervalMultiplier));
+            obj.AddField(
-            obj.AddField(new FieldConfiguration<float, float>("m_ChargingRadius", chargingRadiusMultiplier));
+                new FieldConfiguration<float, float>("m_ArcFiringInterval", arcFiringIntervalMultiplier, ShouldApply));
-            obj.AddField(new FieldConfiguration<float, float>("m_PowerTransferPerArc", powerTransferPerArcMultiplier));
+            obj.AddField(
+                new FieldConfiguration<float, float>("m_ChargingRadius", chargingRadiusMultiplier, ShouldApply));
+            obj.AddField(new FieldConfiguration<float, float>("m_PowerTransferPerArc", powerTransferPerArcMultiplier,
+                                                              ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleRemoteCharger), "OnAttached")]
         static void PostfixCreate(ModuleRemoteCharger __instance) {

Projects/TerraTech/TerraTech/ModuleShieldGeneratorManager.cs

@@ -1,4 +1,5 @@
-using BepInEx.Configuration;
+using System;
+using BepInEx.Configuration;
 using HarmonyLib;
 
 namespace TerraTech {
@@ -7,6 +8,7 @@ namespace TerraTech {
         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;
@@ -16,6 +18,9 @@ namespace TerraTech {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("Shield", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             radiusMultiplier =
                 config.Bind("Shield", "Radius Multiplier", 1f,
                             new ConfigDescription("Radius Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -38,17 +43,25 @@ namespace TerraTech {
         }
 
         private static void ConfigureShieldGenerator(MultipliedObject<ModuleShieldGenerator> obj) {
-            obj.AddField(
+            obj.AddField(new FieldConfiguration<float, float>("m_HealingHeartbeatInterval", heartbeatIntervalMultiplier,
-                new FieldConfiguration<float, float>("m_HealingHeartbeatInterval", heartbeatIntervalMultiplier));
+                                                              ShouldApply));
 
             obj.AddField(new FieldConfiguration<float, float>("m_Radius", radiusMultiplier, instance => {
+                if (!ShouldApply(instance))
+                    return radiusMultiplier;
                 var shield = (ModuleShieldGenerator)instance;
                 return shield.m_Healing ? radiusMultiplierHealing : radiusMultiplier;
             }));
 
-            obj.AddField(new FieldConfiguration<float, float>("m_PowerUpDelay", powerUpDelayMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_PowerUpDelay", powerUpDelayMultiplier, ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleShieldGenerator), "OnAttached")]
         static void PostfixCreate(ModuleShieldGenerator __instance) {

Projects/TerraTech/TerraTech/ModuleWeaponGunManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -9,6 +10,7 @@ namespace TerraTech {
         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;
@@ -21,6 +23,9 @@ namespace TerraTech {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("WeaponGun", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             kickbackStrengthMultiplier = config.Bind(
                 "FireData", "Kickback Strength Multiplier", 1f,
                 new ConfigDescription("Kickback Strength Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -58,18 +63,27 @@ namespace TerraTech {
         }
 
         private static void ConfigureManager(MultipliedObject<ModuleWeaponGun> obj) {
-            obj.AddBooleanField(new BooleanFieldConfiguration("m_SeekingRounds", seekingRoundsAll));
+            obj.AddBooleanField(new BooleanFieldConfiguration("m_SeekingRounds", seekingRoundsAll, ShouldApply));
-            obj.AddBooleanField(new BooleanFieldConfiguration("m_ResetBurstOnInterrupt", resetBurstOnInterruptAll));
+            obj.AddBooleanField(
-            obj.AddField(new FieldConfiguration<float, float>("m_BurstCooldown", burstCooldownMultiplier));
+                new BooleanFieldConfiguration("m_ResetBurstOnInterrupt", resetBurstOnInterruptAll, ShouldApply));
-            obj.AddField(new FieldConfiguration<int, float>("m_BurstShotCount", burstShotCountMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_BurstCooldown", burstCooldownMultiplier, ShouldApply));
-            obj.AddField(new FieldConfiguration<float, float>("m_ShotCooldown", shotCooldownMultiplier));
+            obj.AddField(new FieldConfiguration<int, float>("m_BurstShotCount", burstShotCountMultiplier, ShouldApply));
+            obj.AddField(new FieldConfiguration<float, float>("m_ShotCooldown", shotCooldownMultiplier, ShouldApply));
         }
 
         private static void ConfigureFireData(MultipliedObject<FireData> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_MuzzleVelocity", muzzleVelocityMultiplier));
+            obj.AddField(
-            obj.AddField(new FieldConfiguration<float, float>("m_KickbackStrength", kickbackStrengthMultiplier));
+                new FieldConfiguration<float, float>("m_MuzzleVelocity", muzzleVelocityMultiplier, ShouldApply));
+            obj.AddField(
+                new FieldConfiguration<float, float>("m_KickbackStrength", kickbackStrengthMultiplier, ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleWeaponGun), "OnAttached")]
         static void PostfixCreate(ModuleWeaponGun __instance) {

Projects/TerraTech/TerraTech/ModuleWeaponManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -7,12 +8,16 @@ namespace TerraTech {
         private static readonly MultipliedObjectManager<ModuleWeapon> manager =
             new MultipliedObjectManager<ModuleWeapon>(ConfigureManager);
 
+        public static ConfigEntry<bool> playerOnly;
         public static ConfigEntry<float> rotateSpeedMultiplier;
 
         public static void Setup(ConfigFile config) {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("ModuleWeapon", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             rotateSpeedMultiplier = config.Bind(
                 "ModuleWeapon", "Rotate Speed Multiplier", 1f,
                 new ConfigDescription("Rotate Speed Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -20,9 +25,15 @@ namespace TerraTech {
         }
 
         private static void ConfigureManager(MultipliedObject<ModuleWeapon> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("m_RotateSpeed", rotateSpeedMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("m_RotateSpeed", rotateSpeedMultiplier, ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleWeapon), "OnAttached")]
         static void PostfixCreate(ModuleWeapon __instance) {

Projects/TerraTech/TerraTech/ModuleWheelsManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -7,6 +8,7 @@ namespace TerraTech {
         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;
 
@@ -14,6 +16,9 @@ namespace TerraTech {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("TorqueParams", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             torqueRpmMultiplier =
                 config.Bind("TorqueParams", "Torque RPM Multiplier", 1f,
                             new ConfigDescription("Torque RPM Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -26,10 +31,16 @@ namespace TerraTech {
         }
 
         private static void ConfigureTorqueParams(MultipliedObject<ManWheels.TorqueParams> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("torqueCurveMaxRpm", torqueRpmMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("torqueCurveMaxRpm", torqueRpmMultiplier, ShouldApply));
-            obj.AddField(new FieldConfiguration<float, float>("torqueCurveMaxTorque", torqueMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("torqueCurveMaxTorque", torqueMultiplier, ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleWheels), "OnAttached")]
         static void PostfixCreate(ModuleWheels __instance) {

Projects/TerraTech/TerraTech/ModuleWingManager.cs

@@ -1,3 +1,4 @@
+using System;
 using BepInEx.Configuration;
 using HarmonyLib;
 
@@ -7,6 +8,7 @@ namespace TerraTech {
         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;
@@ -15,6 +17,9 @@ namespace TerraTech {
             float min = 0.01f;
             float max = 32f;
 
+            playerOnly = config.Bind("Aerofoil", "Player Only", false, new ConfigDescription("Player Only"));
+            playerOnly.SettingChanged += (sender, args) => DoPatch();
+
             angleRangeMultiplier =
                 config.Bind("Aerofoil", "Angle Range Multiplier", 1f,
                             new ConfigDescription("Angle Range Multiplier", new AcceptableValueRange<float>(min, max)));
@@ -32,13 +37,21 @@ namespace TerraTech {
         }
 
         private static void ConfigureAerofoil(MultipliedObject<ModuleWing.Aerofoil> obj) {
-            obj.AddField(new FieldConfiguration<float, float>("flapAngleRangeActual", angleRangeMultiplier));
+            obj.AddField(
-            obj.AddField(new FieldConfiguration<float, float>("flapAngleRangeVisual", angleRangeMultiplier));
+                new FieldConfiguration<float, float>("flapAngleRangeActual", angleRangeMultiplier, ShouldApply));
+            obj.AddField(
+                new FieldConfiguration<float, float>("flapAngleRangeVisual", angleRangeMultiplier, ShouldApply));
 
-            obj.AddField(new FieldConfiguration<float, float>("flapTurnSpeed", turnSpeedMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("flapTurnSpeed", turnSpeedMultiplier, ShouldApply));
-            obj.AddField(new FieldConfiguration<float, float>("liftStrength", liftStrengthMultiplier));
+            obj.AddField(new FieldConfiguration<float, float>("liftStrength", liftStrengthMultiplier, ShouldApply));
         }
 
+        private static readonly Func<object, bool> ShouldApply = obj => {
+            if (!playerOnly.Value)
+                return true;
+            return CykUtil.IsPlayerTank(obj as Module);
+        };
+
         [HarmonyPrefix]
         [HarmonyPatch(typeof(ModuleWing), "OnAttached")]
         static void PostfixCreate(ModuleWing __instance) {

Projects/TerraTech/TerraTech/TerraTech.csproj

@@ -70,6 +70,9 @@
     <Reference Include="UnityEngine.CoreModule">
       <HintPath>$(GAME_MANAGED)/UnityEngine.CoreModule.dll</HintPath>
     </Reference>
+    <Reference Include="UnityEngine.Networking">
+      <HintPath>$(GAME_MANAGED)/UnityEngine.Networking.dll</HintPath>
+    </Reference>
     <Reference Include="Assembly-CSharp">
       <HintPath>$(GAME_MANAGED)/Assembly-CSharp.dll</HintPath>
     </Reference>