dave/BepInEx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 2 Wiki Activity

Add player-only configuration to module managers

Browse Source
This commit is contained in:
PhatPhuckDave
2025-02-24 15:51:16 +01:00
parent 0b4883ed6c
commit dc7be36bdb
12 changed files with 174 additions and 36 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
Projects/TerraTech/TerraTech/ModuleEnergyManager.cs
View File

@@ -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_PowerUpDelay", powerUpDelayMultiplier));
obj.AddField(new FieldConfiguration<float, float>("m_OutputPerSecond", outputMultiplier, ShouldApply));
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) {

13
Projects/TerraTech/TerraTech/ModuleEnergyStoreManager.cs
View File

@@ -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) {

13
Projects/TerraTech/TerraTech/ModuleGyroManager.cs
View File

@@ -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) {

27
Projects/TerraTech/TerraTech/ModuleItemHolderManager.cs
View File

@@ -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_HeightIncrementScale", beamHeightIncrementScaleMultiplier));
obj.AddField(new FieldConfiguration<float, float>("m_BeamStrength", beamStrengthMultiplier, ShouldApply));
obj.AddField(new FieldConfiguration<float, float>("m_HeightIncrementScale",
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) {

21
Projects/TerraTech/TerraTech/ModuleItemProducerManager.cs
View File

@@ -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(
new FieldConfiguration<float, float>("m_ResourceGroundRadius", resourceGroundRadiusMultiplier));
obj.AddField(new FieldConfiguration<float, float>("m_MinDispenseInterval", minDispenseIntervalMultiplier));
obj.AddField(new FieldConfiguration<float, float>("m_SecPerItemProduced", secPerItemProducedMultiplier));
obj.AddField(new FieldConfiguration<float, float>("m_ResourceGroundRadius", resourceGroundRadiusMultiplier,
ShouldApply));
obj.AddField(new FieldConfiguration<float, float>("m_MinDispenseInterval", minDispenseIntervalMultiplier,
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) {

20
Projects/TerraTech/TerraTech/ModuleRemoteChargerManager.cs
View File

@@ -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(new FieldConfiguration<float, float>("m_ChargingRadius", chargingRadiusMultiplier));
obj.AddField(new FieldConfiguration<float, float>("m_PowerTransferPerArc", powerTransferPerArcMultiplier));
obj.AddField(
new FieldConfiguration<float, float>("m_ArcFiringInterval", arcFiringIntervalMultiplier, ShouldApply));
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) {

21
Projects/TerraTech/TerraTech/ModuleShieldGeneratorManager.cs
View File

@@ -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(
new FieldConfiguration<float, float>("m_HealingHeartbeatInterval", heartbeatIntervalMultiplier));
obj.AddField(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) {

28
Projects/TerraTech/TerraTech/ModuleWeaponGunManager.cs
View File

@@ -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_ResetBurstOnInterrupt", resetBurstOnInterruptAll));
obj.AddField(new FieldConfiguration<float, float>("m_BurstCooldown", burstCooldownMultiplier));
obj.AddField(new FieldConfiguration<int, float>("m_BurstShotCount", burstShotCountMultiplier));
obj.AddField(new FieldConfiguration<float, float>("m_ShotCooldown", shotCooldownMultiplier));
obj.AddBooleanField(new BooleanFieldConfiguration("m_SeekingRounds", seekingRoundsAll, ShouldApply));
obj.AddBooleanField(
new BooleanFieldConfiguration("m_ResetBurstOnInterrupt", resetBurstOnInterruptAll, ShouldApply));
obj.AddField(new FieldConfiguration<float, float>("m_BurstCooldown", burstCooldownMultiplier, ShouldApply));
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(new FieldConfiguration<float, float>("m_KickbackStrength", kickbackStrengthMultiplier));
obj.AddField(
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) {

13
Projects/TerraTech/TerraTech/ModuleWeaponManager.cs
View File

@@ -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) {

15
Projects/TerraTech/TerraTech/ModuleWheelsManager.cs
View File

@@ -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>("torqueCurveMaxTorque", torqueMultiplier));
obj.AddField(new FieldConfiguration<float, float>("torqueCurveMaxRpm", torqueRpmMultiplier, ShouldApply));
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) {

21
Projects/TerraTech/TerraTech/ModuleWingManager.cs
View File

@@ -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(new FieldConfiguration<float, float>("flapAngleRangeVisual", angleRangeMultiplier));
obj.AddField(
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>("liftStrength", liftStrengthMultiplier));
obj.AddField(new FieldConfiguration<float, float>("flapTurnSpeed", turnSpeedMultiplier, ShouldApply));
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) {

3
Projects/TerraTech/TerraTech/TerraTech.csproj
View File

@@ -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>