459 lines
19 KiB
C#
459 lines
19 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using Eremite.Buildings;
|
|
using Eremite.Model;
|
|
using Eremite.Model.Meta;
|
|
using Eremite.Services;
|
|
using HarmonyLib;
|
|
|
|
// Patch maxSupPoints in PlatoonSupplyModule
|
|
// Patch Operational Authority point gain
|
|
|
|
namespace AgainstTheStorm {
|
|
[HarmonyPatch]
|
|
public class Patches {
|
|
static Dictionary<string, float> baseValues = new Dictionary<string, float>();
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(BonusEmbarkRangeMetaRewardModel), "OnConsume")]
|
|
static void Test(BonusEmbarkRangeMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(BonusFarmAreaMetaRewardModel), "OnConsume")]
|
|
static void Test(BonusFarmAreaMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(ConstructionSpeedMetaRewardModel), "OnConsume")]
|
|
static void Test(ConstructionSpeedMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(CornerstonesRerollsMetaRewardModel), "OnConsume")]
|
|
static void Test(CornerstonesRerollsMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(CurrencyMultiplayerMetaRewardModel), "OnConsume")]
|
|
static void Test(CurrencyMultiplayerMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(EmbarkGoodsAmountMetaRewardModel), "OnConsume")]
|
|
static void Test(EmbarkGoodsAmountMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(FarmingRateMetaRewardModel), "OnConsume")]
|
|
static void Test(FarmingRateMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(FuelRateMetaRewardModel), "OnConsume")]
|
|
static void Test(FuelRateMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(GlobalBuildingStorageMetaRewardModel), "OnConsume")]
|
|
static void Test(GlobalBuildingStorageMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(GlobalCapacityMetaRewardModel), "OnConsume")]
|
|
static void Test(GlobalCapacityMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(GlobalExtraProductionChanceMetaRewardModel), "OnConsume")]
|
|
static void Test(GlobalExtraProductionChanceMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(GlobalProductionSpeedMetaRewardModel), "OnConsume")]
|
|
static void Test(GlobalProductionSpeedMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(GracePeriodMetaRewardModel), "OnConsume")]
|
|
static void Test(GracePeriodMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(GrassAmountMetaRewardModel), "OnConsume")]
|
|
static void Test(GrassAmountMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(HearthSacraficeTimeRateMetaRewardModel), "OnConsume")]
|
|
static void Test(HearthSacraficeTimeRateMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(NewcommersGoodsRateMetaRewardModel), "OnConsume")]
|
|
static void Test(NewcommersGoodsRateMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
// [HarmonyPrefix]
|
|
// [HarmonyPatch(typeof(PreparationPointsMetaRewardModel), "OnConsume")]
|
|
// static void Test(PreparationPointsMetaRewardModel __instance) {
|
|
// DoPatch(__instance);
|
|
// }
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(RawDepositsChargesMetaRewardModel), "OnConsume")]
|
|
static void Test(RawDepositsChargesMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(RelicsWorkingSpeedMetaRewardModel), "OnConsume")]
|
|
static void Test(RelicsWorkingSpeedMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(ReputationPenaltyRateMetaRewardModel), "OnConsume")]
|
|
static void Test(ReputationPenaltyRateMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(ReputationRewardPicksMetaRewardModel), "OnConsume")]
|
|
static void Test(ReputationRewardPicksMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(SeasonRewardsAmountMetaRewardModel), "OnConsume")]
|
|
static void Test(SeasonRewardsAmountMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(TownsVisionRangeMetaRewardModel), "OnConsume")]
|
|
static void Test(TownsVisionRangeMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(TraderIntervalMetaRewardModel), "OnConsume")]
|
|
static void Test(TraderIntervalMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(TraderMerchAmountMetaRewardModel), "OnConsume")]
|
|
static void Test(TraderMerchAmountMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(TraderMerchandisePriceReductionMetaRewardModel), "OnConsume")]
|
|
static void Test(TraderMerchandisePriceReductionMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(TradeRoutesLimitMetaReward), "OnConsume")]
|
|
static void Test(TradeRoutesLimitMetaReward __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(TraderSellPriceMetaRewardModel), "OnConsume")]
|
|
static void Test(TraderSellPriceMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(VillagersSpeedMetaRewardModel), "OnConsume")]
|
|
static void Test(VillagersSpeedMetaRewardModel __instance) {
|
|
DoPatch(__instance);
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(ProductionCalculator), nameof(ProductionCalculator.GetProductionMultiplier))]
|
|
static void PatchProductionCalculator(ref int __result) {
|
|
// Console.WriteLine("ProdMulti {0}", __result);
|
|
__result *= Main.ProductionMultiplier.Value;
|
|
}
|
|
|
|
// There seems to be a lot of good shit in effetsService!!
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetRawDepositsChargesBonus))]
|
|
static void PatchEffectsService(ref int __result) {
|
|
__result *= Main.DepositChargesMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetActorSpeed))]
|
|
static void PatchEffectsService2(ref float __result) {
|
|
__result *= Main.VillagerSpeedMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetBuildingProductionRate))]
|
|
static void PatchEffectsService3(ref float __result) {
|
|
__result *= Main.ProductionSpeedMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetNewcomersIntervalRate))]
|
|
static void PatchEffectsService4(ref float __result) {
|
|
__result *= Main.NewcomverRateMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetVillagerCapacity))]
|
|
static void PatchEffectsService5(ref int __result) {
|
|
__result *= Main.VillagerCapacityMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetTraderIntervalRate))]
|
|
static void PatchEffectsService6(ref float __result) {
|
|
__result *= Main.TraderRateMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetTraderMerchsAmount))]
|
|
static void PatchEffectsService7(ref int __result) {
|
|
__result *= Main.TraderMerchMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetHearthRange))]
|
|
static void PatchEffectsService8(ref float __result) {
|
|
__result *= Main.HearthRangeMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetHouseCapacity), typeof(HouseModel))]
|
|
static void PatchEffectsService9(ref int __result) {
|
|
__result = (int)(Main.HouseCapacityMultiplier.Value * __result);
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetHouseCapacity), typeof(House))]
|
|
static void PatchEffectsService9_2(ref int __result) {
|
|
__result = (int)(Main.HouseCapacityMultiplier.Value * __result);
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetNewcomersBonus))]
|
|
static void PatchEffectsService10(ref int __result) {
|
|
__result = (int)(Main.NewcomerBonusMultiplier.Value * __result);
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetNewcomersRaceBonus))]
|
|
static void PatchEffectsService11(ref int __result) {
|
|
__result += Main.AdditionalNewcomerBonus.Value;
|
|
}
|
|
|
|
[HarmonyPostfix]
|
|
[HarmonyPatch(typeof(EffectsService), nameof(EffectsService.GetTradeRoutesSpeed))]
|
|
static void PatchEffectsService12(ref float __result) {
|
|
__result += Main.TradeRouteSpeedMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(TimeScaleService), "SetScale")]
|
|
static void PatchGameSpeeds(ref float scale) {
|
|
scale *= Main.GameSpeedMultiplier.Value;
|
|
}
|
|
|
|
[HarmonyPrefix]
|
|
[HarmonyPatch(typeof(MetaEconomyService), nameof(MetaEconomyService.Add))]
|
|
static void PatchMetaCurrencyGain(ref MetaCurrency currency) {
|
|
currency.amount = (int)(currency.amount * Main.MetaCurrencyMultiplier.Value);
|
|
}
|
|
|
|
static void DoPatch(BasePercentageMetaReward model) {
|
|
string upgName = model.displayName.ToString();
|
|
if (!baseValues.ContainsKey(upgName)) {
|
|
Console.WriteLine("Base value does not exist yet for {0} (class: {1}), adding", upgName,
|
|
model.GetType().Name);
|
|
baseValues.Add(upgName, model.amount);
|
|
}
|
|
|
|
if (Math.Abs(baseValues[upgName] - model.amount) < 0.01f) {
|
|
float newValue = baseValues[upgName] * 64;
|
|
Console.WriteLine("Base value is different for {0}, updating from {1} to {2}", upgName,
|
|
baseValues[upgName],
|
|
newValue);
|
|
baseValues[upgName] = newValue;
|
|
}
|
|
else {
|
|
Console.WriteLine("Base value is the same for {0}, skipping {1}", upgName, baseValues[upgName]);
|
|
}
|
|
}
|
|
|
|
static void DoPatch(BaseFlatMetaReward model) {
|
|
string upgName = model.displayName.ToString();
|
|
if (!baseValues.ContainsKey(upgName)) {
|
|
Console.WriteLine("Base value does not exist yet for {0} (class: {1}), adding", upgName,
|
|
model.GetType().Name);
|
|
baseValues.Add(upgName, model.amount);
|
|
}
|
|
|
|
if (Math.Abs(baseValues[upgName] - model.amount) < 0.01f) {
|
|
float newValue = baseValues[upgName] * 64;
|
|
Console.WriteLine("Base value is different for {0}, updating from {1} to {2}", upgName,
|
|
baseValues[upgName],
|
|
newValue);
|
|
baseValues[upgName] = newValue;
|
|
}
|
|
else {
|
|
Console.WriteLine("Base value is the same for {0}, skipping {1}", upgName, baseValues[upgName]);
|
|
}
|
|
}
|
|
|
|
// [HarmonyPrefix]
|
|
// [HarmonyPatch(typeof(TacAidPointsController), "AddTP")]
|
|
// static void TpMultiplier(ref float val) {
|
|
// if (val == 0) {
|
|
// return;
|
|
// }
|
|
//
|
|
// float multiplier = Main.TPMultiplier.Value;
|
|
// // Console.WriteLine("Multiplying TP {0} by {1}", val, multiplier);
|
|
// val *= multiplier;
|
|
// }
|
|
//
|
|
// [HarmonyPrefix]
|
|
// [HarmonyPatch(typeof(MapZoneFactory), "MakeRefitZone")]
|
|
// static void SupplyAoeMultiplier(ref eSides side, ref Vector3 position, ref float size) {
|
|
// float multiplier = Main.SupplyAOEMultiplier.Value;
|
|
// Console.WriteLine("Multiplying supply aoe {0} by {1}", size, multiplier);
|
|
// size *= multiplier;
|
|
// }
|
|
//
|
|
// [HarmonyPrefix]
|
|
// [HarmonyPatch(typeof(PlatoonHQVisuals), "Start")]
|
|
// static void HqAoeMultiplier(PlatoonHQVisuals __instance) {
|
|
// Console.WriteLine("Patching HQ radius - base range {0}", baseHqValue);
|
|
// if (baseHqValue == 0) {
|
|
// baseHqValue = __instance.platoon.parameters.HQRadius;
|
|
// Console.WriteLine("Base range is 0, assigning new: {0}", baseHqValue);
|
|
// }
|
|
//
|
|
// __instance.platoon.parameters.HQRadius = baseHqValue * Main.HQAOEMultiplier.Value;
|
|
// Console.WriteLine("HQ radius patched to: {0}", __instance.platoon.parameters.HQRadius);
|
|
// }
|
|
//
|
|
// [HarmonyPrefix]
|
|
// [HarmonyPatch(typeof(PlatoonSupplyModule), "Start")]
|
|
// static void SupplyAoeMultiplier(PlatoonSupplyModule __instance) {
|
|
// Console.WriteLine("Patching supply amount - base amount {0}", baseSupplyValue);
|
|
// if (baseSupplyValue == 0) {
|
|
// baseSupplyValue = __instance.platoon.parameters.supplyPointsPerUnit;
|
|
// Console.WriteLine("Base amount is 0, assigning new: {0}", baseSupplyValue);
|
|
// }
|
|
//
|
|
// __instance.platoon.parameters.supplyPointsPerUnit =
|
|
// (int)(baseSupplyValue * Main.SupplyAmountMultiplier.Value);
|
|
// Console.WriteLine("Supply amount patched to: {0}", __instance.platoon.parameters.supplyPointsPerUnit);
|
|
// }
|
|
//
|
|
// [HarmonyPostfix]
|
|
// [HarmonyPatch(typeof(WeaponAttackBase), "GetReloadInterval")]
|
|
// static void FireRateMultiplier(ref float __result) {
|
|
// Console.WriteLine("Patching fire rate");
|
|
//
|
|
// __result *= Main.FireRateMultiplier.Value;
|
|
// Console.WriteLine("Fire rate patched to: {0}", __result);
|
|
// }
|
|
//
|
|
// [HarmonyPostfix]
|
|
// [HarmonyPatch(typeof(WeaponAttackBase), "GetAimInterval")]
|
|
// static void AimingIntervalMultiplier(ref float __result) {
|
|
// Console.WriteLine("Patching aim interval - base amount {0}", baseSupplyValue);
|
|
//
|
|
// __result *= Main.AimIntervalMultiplier.Value;
|
|
// Console.WriteLine("Aim interval patched to: {0}", __result);
|
|
// }
|
|
//
|
|
// [HarmonyPrefix]
|
|
// [HarmonyPatch(typeof(TimerManager), "GetPersistentTimer")]
|
|
// static void Transpiler(ref float interval, ref string hint) {
|
|
// if (hint == "burst") {
|
|
// Console.WriteLine("Patching burst interval from: {0}", interval);
|
|
// interval *= Main.FireRateMultiplier.Value;
|
|
// Console.WriteLine("Burst interval patched to: {0}", interval);
|
|
// }
|
|
// }
|
|
//
|
|
// [HarmonyPostfix]
|
|
// [HarmonyPatch(typeof(RefitZone), "OnRefitStep")]
|
|
// static void SupplyRateMultiplier(ref float hpVal, ref float ammoVal) {
|
|
// Console.WriteLine("Patching refit step from: {0} {1}", hpVal, ammoVal);
|
|
// hpVal *= Main.SupplyRateMultiplier.Value;
|
|
// ammoVal *= Main.SupplyRateMultiplier.Value;
|
|
// Console.WriteLine("Patching refit step to: {0} {1}", hpVal, ammoVal);
|
|
// }
|
|
//
|
|
// // [HarmonyPatch(typeof(AdvancedRulesData), "Validate")]
|
|
// // static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) {
|
|
// // var codes = new List<CodeInstruction>(instructions);
|
|
// //
|
|
// // foreach (var code in codes) {
|
|
// // if (code.opcode == OpCodes.Ldc_R4) {
|
|
// // Console.WriteLine("Changing " + code);
|
|
// // code.operand = (float)code.operand * 2;
|
|
// // Console.WriteLine("Changed " + code);
|
|
// // }
|
|
// // }
|
|
// //
|
|
// // return codes.AsEnumerable();
|
|
// // }
|
|
//
|
|
// // [HarmonyPatch(typeof(AdvancedRulesData), "IsWithinLimits")]
|
|
// // static IEnumerable<CodeInstruction> Transpiler2(IEnumerable<CodeInstruction> instructions) {
|
|
// // var codes = new List<CodeInstruction>(instructions);
|
|
// //
|
|
// // foreach (var code in codes) {
|
|
// // if (code.opcode == OpCodes.Ldc_R4) {
|
|
// // Console.WriteLine("Changing " + code);
|
|
// // code.operand = (float)code.operand * 2;
|
|
// // Console.WriteLine("Changed " + code);
|
|
// // }
|
|
// // }
|
|
// //
|
|
// // return codes.AsEnumerable();
|
|
// // }
|
|
//
|
|
// // private static float baseAccuracy;
|
|
// //
|
|
// // [HarmonyPostfix]
|
|
// // [HarmonyPatch(typeof(SkirmishAdvancedRules), "Update")]
|
|
// // static void AccuracyPatch(SkirmishAdvancedRules __instance) {
|
|
// // var accMod = Traverse.Create(__instance).Field("currentARD").Field("accuracyModifier");
|
|
// // if (baseAccuracy == 0) {
|
|
// // baseAccuracy = (float)accMod.GetValue();
|
|
// // Console.WriteLine("Base accuracy set to {0}", baseAccuracy);
|
|
// // }
|
|
// //
|
|
// // accMod.SetValue(baseAccuracy * 4f);
|
|
// // Console.WriteLine("Accuracy now: {0}", accMod.GetValue());
|
|
// // }
|
|
}
|
|
}
|