using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Text;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("EndlessResources")]
[assembly: AssemblyDescription("Dyson Sphere Program BepInEx mod. All planet vein sources (ore, oil, Icarus, ILS / PLS vein collector) and source ILS / PLS storage stay non-depleting.")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("EndlessResources")]
[assembly: AssemblyCopyright("Copyright (c) 2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("00000000-0000-0000-0000-000000000000")]
[assembly: AssemblyFileVersion("1.1.3.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = "")]
[assembly: AssemblyVersion("1.1.3.0")]
namespace EndlessResources;
internal sealed class PluginConfig
{
public readonly ConfigEntry<bool> EnableMinerPatchFlag;
public readonly ConfigEntry<bool> EnableOilPatchFlag;
public readonly ConfigEntry<bool> EnableIcarusPatchFlag;
public readonly ConfigEntry<bool> EnableILSVeinCollectionFlag;
public readonly ConfigEntry<bool> EnableILSSourceFlag;
public readonly ConfigEntry<bool> EnablePlanetMinerFastCompatFlag;
public readonly ConfigEntry<bool> HealNegativeStationOrders;
public readonly ConfigEntry<bool> DebugLog;
public PluginConfig(ConfigFile config)
{
EnableMinerPatchFlag = config.Bind<bool>("General", "EnableMinerPatchFlag", true, "Restore vein amount after miner extract (ore). When true, regular miners cannot deplete a vein. The ILS / PLS vein collector (which uses the same MinerComponent) is also covered.");
EnableOilPatchFlag = config.Bind<bool>("General", "EnableOilPatchFlag", true, "Restore vein amount after oil extractor. When true, oil extractors cannot deplete an oil seep.");
EnableIcarusPatchFlag = config.Bind<bool>("General", "EnableIcarusPatchFlag", true, "Restore vein amount after Icarus hand-mining (right-click a resource node). When true, the player can hand-mine indefinitely.");
EnableILSVeinCollectionFlag = config.Bind<bool>("General", "EnableILSVeinCollectionFlag", true, "Keep the ILS vein collector miner's productCount full (stellar stations only; Advanced Mining Machine / PLS local collectors are excluded). When true, an ILS vein collector can pull from the miner every tick without waiting for the next InternalUpdate cycle. Note: the vein amount itself is covered by EnableMinerPatchFlag (the ILS / PLS uses a regular MinerComponent under the hood).");
EnableILSSourceFlag = config.Bind<bool>("General", "EnableILSSourceFlag", true, "Restore the source ILS / PLS storage after each dispatch. When true, the source station's storage buffer is restored to its pre-dispatch value, so the station can ship indefinitely.");
EnablePlanetMinerFastCompatFlag = config.Bind<bool>("General", "EnablePlanetMinerFastCompatFlag", true, "Compatibility layer for PlanetMinerFast (DysonSphereMods). PlanetMinerFast bypasses MinerComponent.InternalUpdate and does its own vein mining in its own slow-tick handler, so Patch A does not cover it. When this flag is true, EndlessResources detects PlanetMinerFast via reflection and patches its OnSlowTick method with a snapshot (prefix) + restore (postfix) pair, so the station vein is also restored to its pre-call amount. If PlanetMinerFast is not installed, this flag is a no-op. Set to false to disable the compat layer (the station will then deplete the vein via PlanetMinerFast as normal).");
HealNegativeStationOrders = config.Bind<bool>("General", "HealNegativeStationOrders", true, "On each game load / new game, clear negative localOrder / remoteOrder (In Transit) only on Demand-side slots (Local Demand / Remote Receiver). Negative orders on Supply slots are normal outbound bookings and are left alone. Fixes slots left broken by older EndlessResources builds. Does not change item counts or limits. Safe to leave on; set false to skip the scan.");
DebugLog = config.Bind<bool>("Diagnostics", "DebugLog", false, "Enable verbose diagnostic logging. Off by default; toggle on for first-run verification. Prints category-tagged lines ([config], [patch], [error]) to the BepInEx console.");
}
}
internal static class EndlessResourcesLog
{
private static ManualLogSource logger;
private static ConfigEntry<bool> debugEntry;
public static void Init(ManualLogSource src, ConfigEntry<bool> debug)
{
logger = src;
debugEntry = debug;
}
public static void Info(string msg)
{
if (debugEntry != null && debugEntry.Value && logger != null)
{
logger.LogInfo((object)("[EndlessResources] " + msg));
}
}
public static void Warn(string msg)
{
if (logger != null)
{
logger.LogWarning((object)("[EndlessResources] " + msg));
}
}
public static void Error(string msg)
{
if (logger != null)
{
logger.LogError((object)("[EndlessResources] " + msg));
}
}
public static bool IsDebugEnabled()
{
if (debugEntry != null)
{
return debugEntry.Value;
}
return false;
}
}
[HarmonyPatch(typeof(PlayerAction_Mine), "GameTick")]
internal static class IcarusPatch
{
internal sealed class Snapshot
{
public int veinId;
public int amount;
public short groupIndex;
public long groupAmount;
}
private static bool firstFireLogged = true;
private static void Prefix(PlayerAction_Mine __instance, long timei, ref Snapshot __state)
{
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_006f: Unknown result type (might be due to invalid IL or missing references)
//IL_0070: Unknown result type (might be due to invalid IL or missing references)
//IL_0088: Unknown result type (might be due to invalid IL or missing references)
//IL_0094: Unknown result type (might be due to invalid IL or missing references)
//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!Plugin.Config.EnableIcarusPatchFlag.Value || __instance == null)
{
return;
}
PlanetFactory val = GameMain.localPlanet?.factory;
if (val == null || val.veinPool == null || val.veinGroups == null)
{
return;
}
int miningId = __instance.miningId;
if (miningId <= 0 || miningId >= val.veinPool.Length)
{
return;
}
VeinData val2 = val.veinPool[miningId];
if (val2.id != 0)
{
__state = new Snapshot
{
veinId = miningId,
amount = val2.amount,
groupIndex = val2.groupIndex
};
if (val2.groupIndex > 0 && val2.groupIndex < val.veinGroups.Length)
{
__state.groupAmount = val.veinGroups[val2.groupIndex].amount;
}
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("Patch B (Icarus) prefix threw: " + ex);
}
}
[HarmonyPriority(600)]
private static void Postfix(PlayerAction_Mine __instance, long timei, ref Snapshot __state)
{
try
{
if (__state == null || __state.veinId == 0 || !Plugin.Config.EnableIcarusPatchFlag.Value)
{
return;
}
PlanetFactory val = GameMain.localPlanet?.factory;
if (val == null || val.veinPool == null || val.veinGroups == null)
{
return;
}
int veinId = __state.veinId;
if (veinId > 0 && veinId < val.veinPool.Length && val.veinPool[veinId].id != 0 && val.veinPool[veinId].amount != __state.amount)
{
val.veinPool[veinId].amount = __state.amount;
int groupIndex = __state.groupIndex;
if (groupIndex > 0 && groupIndex < val.veinGroups.Length)
{
val.veinGroups[groupIndex].amount = __state.groupAmount;
}
if (firstFireLogged && EndlessResourcesLog.IsDebugEnabled())
{
EndlessResourcesLog.Info("[patch] Patch B (Icarus) fired: vein " + veinId + " restored to " + __state.amount);
firstFireLogged = false;
}
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("Patch B (Icarus) postfix threw: " + ex);
}
}
}
[HarmonyPatch(typeof(MinerComponent), "InternalUpdate")]
internal static class MinerPatch
{
internal sealed class Snapshot
{
public int[] veinIds;
public int[] amounts;
public short[] groupIndices;
public long[] groupAmounts;
}
private static bool firstFireLogged = true;
[HarmonyPriority(700)]
private static void Prefix(MinerComponent __instance, PlanetFactory factory, VeinData[] veinPool, float power, float miningRate, float miningSpeed, int[] productRegister, ref Snapshot __state)
{
//IL_0000: Unknown result type (might be due to invalid IL or missing references)
//IL_0008: Unknown result type (might be due to invalid IL or missing references)
//IL_002e: Unknown result type (might be due to invalid IL or missing references)
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
//IL_0035: Invalid comparison between Unknown and I4
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
//IL_00de: Unknown result type (might be due to invalid IL or missing references)
//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
//IL_010c: Unknown result type (might be due to invalid IL or missing references)
//IL_0114: Unknown result type (might be due to invalid IL or missing references)
//IL_011e: Unknown result type (might be due to invalid IL or missing references)
//IL_013e: Unknown result type (might be due to invalid IL or missing references)
try
{
if (__instance.veins == null || __instance.veins.Length == 0 || factory == null || factory.veinPool == null || factory.veinGroups == null)
{
return;
}
bool flag = (int)__instance.type == 3;
if ((flag && !Plugin.Config.EnableOilPatchFlag.Value) || (!flag && !Plugin.Config.EnableMinerPatchFlag.Value))
{
return;
}
int num = __instance.veins.Length;
__state = new Snapshot
{
veinIds = new int[num],
amounts = new int[num],
groupIndices = new short[num],
groupAmounts = new long[num]
};
for (int i = 0; i < num; i++)
{
int num2 = __instance.veins[i];
if (num2 <= 0 || num2 >= factory.veinPool.Length)
{
continue;
}
VeinData val = factory.veinPool[num2];
if (val.id != 0)
{
__state.veinIds[i] = num2;
__state.amounts[i] = val.amount;
__state.groupIndices[i] = val.groupIndex;
if (val.groupIndex > 0 && val.groupIndex < factory.veinGroups.Length)
{
__state.groupAmounts[i] = factory.veinGroups[val.groupIndex].amount;
}
}
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("Patch A (Miner) prefix threw: " + ex);
}
}
[HarmonyPriority(700)]
private unsafe static void Postfix(MinerComponent __instance, PlanetFactory factory, VeinData[] veinPool, float power, float miningRate, float miningSpeed, int[] productRegister, ref Snapshot __state)
{
try
{
if (__state == null || __state.veinIds == null || factory == null || factory.veinPool == null || factory.veinGroups == null)
{
return;
}
int num = 0;
for (int i = 0; i < __state.veinIds.Length; i++)
{
int num2 = __state.veinIds[i];
if (num2 > 0 && num2 < factory.veinPool.Length && factory.veinPool[num2].id != 0)
{
factory.veinPool[num2].amount = __state.amounts[i];
int num3 = __state.groupIndices[i];
if (num3 > 0 && num3 < factory.veinGroups.Length)
{
factory.veinGroups[num3].amount = __state.groupAmounts[i];
}
num++;
}
}
if (num <= 0 || !firstFireLogged || !EndlessResourcesLog.IsDebugEnabled())
{
return;
}
int num4 = 0;
int num5 = 0;
for (int j = 0; j < __state.veinIds.Length; j++)
{
if (__state.veinIds[j] > 0)
{
num4 = __state.veinIds[j];
num5 = __state.amounts[j];
break;
}
}
EndlessResourcesLog.Info("[patch] Patch A fired: type=" + ((object)(*(EMinerType*)(&__instance.type))/*cast due to .constrained prefix*/).ToString() + ", miner.veins.len=" + __state.veinIds.Length + ", restored=" + num + ", firstVid=" + num4 + ", firstAmt=" + num5);
firstFireLogged = false;
}
catch (Exception ex)
{
EndlessResourcesLog.Error("Patch A (Miner) postfix threw: " + ex);
}
}
}
internal static class PlanetMinerFastCompat
{
private static bool _applied = false;
private static bool _loggedNotDetected = false;
private static bool _firstRestoreLogged = true;
private static Harmony _storedHarmony = null;
private static readonly Dictionary<int, int[]> _veinSnapshots = new Dictionary<int, int[]>();
private static readonly Dictionary<int, long[]> _groupSnapshots = new Dictionary<int, long[]>();
public static void Apply(Harmony harmony)
{
_storedHarmony = harmony;
TryApply();
}
public static void Retry()
{
if (_storedHarmony == null)
{
EndlessResourcesLog.Warn("[compat] Retry called before Apply; skipping.");
}
else
{
TryApply();
}
}
private static void TryApply()
{
//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
//IL_00da: Expected O, but got Unknown
//IL_00da: Expected O, but got Unknown
if (_applied)
{
return;
}
try
{
Type type = null;
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
for (int i = 0; i < assemblies.Length; i++)
{
type = assemblies[i].GetType("PlanetMinerFast.PlanetMinerFastPlugin", throwOnError: false);
if (type != null)
{
break;
}
}
if (type == null)
{
if (!_loggedNotDetected)
{
EndlessResourcesLog.Info("[compat] PlanetMinerFast not detected yet; will retry on Start.");
_loggedNotDetected = true;
}
return;
}
_loggedNotDetected = false;
MethodInfo method = type.GetMethod("OnSlowTick", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
if (method == null)
{
EndlessResourcesLog.Warn("[compat] PlanetMinerFast detected but OnSlowTick method not found; skipping compat patch.");
return;
}
MethodInfo method2 = typeof(PlanetMinerFastCompat).GetMethod("SnapshotPrefix", BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo method3 = typeof(PlanetMinerFastCompat).GetMethod("RestorePostfix", BindingFlags.Static | BindingFlags.NonPublic);
_storedHarmony.Patch((MethodBase)method, new HarmonyMethod(method2), new HarmonyMethod(method3), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
_applied = true;
EndlessResourcesLog.Info("[compat] PlanetMinerFast detected; applied snapshot/restore patch on PlanetMinerFastPlugin.OnSlowTick.");
}
catch (Exception ex)
{
EndlessResourcesLog.Error("[compat] Failed to apply PlanetMinerFast compat patch: " + ex);
}
}
private static void SnapshotPrefix()
{
try
{
if (GameMain.data == null || GameMain.data.factories == null)
{
return;
}
_veinSnapshots.Clear();
_groupSnapshots.Clear();
PlanetFactory[] factories = GameMain.data.factories;
foreach (PlanetFactory val in factories)
{
if (val == null || val.veinPool == null)
{
continue;
}
int[] array = new int[val.veinPool.Length];
for (int j = 0; j < val.veinPool.Length; j++)
{
array[j] = val.veinPool[j].amount;
}
_veinSnapshots[val.index] = array;
if (val.veinGroups != null)
{
long[] array2 = new long[val.veinGroups.Length];
for (int k = 0; k < val.veinGroups.Length; k++)
{
array2[k] = val.veinGroups[k].amount;
}
_groupSnapshots[val.index] = array2;
}
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("[compat] SnapshotPrefix threw: " + ex);
}
}
private static void RestorePostfix()
{
try
{
if (GameMain.data == null || GameMain.data.factories == null)
{
return;
}
int num = 0;
int num2 = 0;
PlanetFactory[] factories = GameMain.data.factories;
foreach (PlanetFactory val in factories)
{
if (val == null || val.veinPool == null)
{
continue;
}
if (_veinSnapshots.TryGetValue(val.index, out var value) && value.Length == val.veinPool.Length)
{
for (int j = 0; j < val.veinPool.Length; j++)
{
if (val.veinPool[j].id != 0 && val.veinPool[j].amount != value[j])
{
val.veinPool[j].amount = value[j];
num++;
}
}
}
if (val.veinGroups == null || !_groupSnapshots.TryGetValue(val.index, out var value2) || value2.Length != val.veinGroups.Length)
{
continue;
}
for (int k = 0; k < val.veinGroups.Length; k++)
{
if (val.veinGroups[k].amount != value2[k])
{
val.veinGroups[k].amount = value2[k];
num2++;
}
}
}
if ((num > 0 || num2 > 0) && _firstRestoreLogged && EndlessResourcesLog.IsDebugEnabled())
{
EndlessResourcesLog.Info("[compat] PlanetMinerFast restore: " + num + " veins, " + num2 + " groups.");
_firstRestoreLogged = false;
}
_veinSnapshots.Clear();
_groupSnapshots.Clear();
}
catch (Exception ex)
{
EndlessResourcesLog.Error("[compat] RestorePostfix threw: " + ex);
}
}
}
[HarmonyPatch(typeof(StationComponent), "DetermineDispatch")]
internal static class StationDispatchPatch
{
internal sealed class Snapshot
{
public int[] count;
public int[] inc;
}
private static bool firstFireLogged = true;
[HarmonyPriority(600)]
private static void Prefix(StationComponent __instance, float shipSailSpeed, float shipWarpSpeed, int shipCarries, int priorityIndex, StationComponent[] gStationPool, FactoryProductionStat[] factoryStatPool, PlanetFactory[] factories, GalaxyData galaxy, TrafficStatistics tstat, ref Snapshot __state)
{
try
{
if (Plugin.Config.EnableILSSourceFlag.Value && __instance != null && __instance.storage != null)
{
StationStore[] storage = __instance.storage;
int num = storage.Length;
int[] array = new int[num];
int[] array2 = new int[num];
for (int i = 0; i < num; i++)
{
array[i] = storage[i].count;
array2[i] = storage[i].inc;
}
__state = new Snapshot
{
count = array,
inc = array2
};
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("Patch D (Station dispatch) prefix threw: " + ex);
}
}
[HarmonyPriority(600)]
private static void Postfix(StationComponent __instance, float shipSailSpeed, float shipWarpSpeed, int shipCarries, int priorityIndex, StationComponent[] gStationPool, FactoryProductionStat[] factoryStatPool, PlanetFactory[] factories, GalaxyData galaxy, TrafficStatistics tstat, ref Snapshot __state)
{
try
{
if (__state == null || __state.count == null || __state.inc == null || !Plugin.Config.EnableILSSourceFlag.Value || __instance == null || __instance.storage == null)
{
return;
}
int[] count = __state.count;
int[] inc = __state.inc;
if (__instance.storage.Length != count.Length || __instance.storage.Length != inc.Length)
{
return;
}
bool flag = false;
for (int i = 0; i < count.Length; i++)
{
if (__instance.storage[i].count != count[i] || __instance.storage[i].inc != inc[i])
{
__instance.storage[i].count = count[i];
__instance.storage[i].inc = inc[i];
flag = true;
}
}
if (flag && firstFireLogged && EndlessResourcesLog.IsDebugEnabled())
{
EndlessResourcesLog.Info("[patch] Patch D (Station dispatch) fired: first count/inc restoration. slots=" + count.Length);
firstFireLogged = false;
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("Patch D (Station dispatch) postfix threw: " + ex);
}
}
}
[HarmonyPatch(typeof(GameMain), "Begin")]
internal static class StationOrderHealPatch
{
[HarmonyPostfix]
private static void Postfix()
{
//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
//IL_00e8: Invalid comparison between Unknown and I4
//IL_0125: Unknown result type (might be due to invalid IL or missing references)
//IL_012b: Invalid comparison between Unknown and I4
try
{
if (Plugin.Config == null || !Plugin.Config.HealNegativeStationOrders.Value || GameMain.data == null || GameMain.data.factories == null)
{
return;
}
int num = 0;
int num2 = 0;
PlanetFactory[] factories = GameMain.data.factories;
foreach (PlanetFactory val in factories)
{
if (val == null || val.transport == null)
{
continue;
}
PlanetTransport transport = val.transport;
StationComponent[] stationPool = transport.stationPool;
if (stationPool == null)
{
continue;
}
int num3 = transport.stationCursor;
if (num3 > stationPool.Length)
{
num3 = stationPool.Length;
}
for (int j = 1; j < num3; j++)
{
StationComponent val2 = stationPool[j];
if (val2 == null || val2.id != j || val2.storage == null)
{
continue;
}
bool flag = false;
for (int k = 0; k < val2.storage.Length; k++)
{
bool flag2 = false;
bool flag3 = false;
if ((int)val2.storage[k].localLogic == 2 && val2.storage[k].localOrder < 0)
{
val2.storage[k].localOrder = 0;
flag2 = true;
}
if ((int)val2.storage[k].remoteLogic == 2 && val2.storage[k].remoteOrder < 0)
{
val2.storage[k].remoteOrder = 0;
flag3 = true;
}
if (flag2 || flag3)
{
num++;
flag = true;
if (EndlessResourcesLog.IsDebugEnabled())
{
EndlessResourcesLog.Info("[heal] station gid=" + val2.gid + " slot=" + k + " itemId=" + val2.storage[k].itemId + " cleared local=" + flag2 + " remote=" + flag3);
}
}
}
if (flag)
{
num2++;
}
}
}
if (num > 0)
{
EndlessResourcesLog.Warn("[heal] Cleared negative Demand In-Transit orders on " + num + " slot(s) across " + num2 + " station(s). Set General > HealNegativeStationOrders = false to disable.");
}
else if (EndlessResourcesLog.IsDebugEnabled())
{
EndlessResourcesLog.Info("[heal] No negative Demand station orders found.");
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("[heal] Station order heal threw: " + ex);
}
}
}
[HarmonyPatch(typeof(StationComponent), "UpdateVeinCollection")]
internal static class StationVeinCollectionPatch
{
internal sealed class Snapshot
{
public int minerId;
public int productCount;
}
private static bool firstFireLogged = true;
private static void Prefix(StationComponent __instance, PlanetFactory factory, int[] productRegister, ref Snapshot __state)
{
//IL_0056: Unknown result type (might be due to invalid IL or missing references)
//IL_005b: Unknown result type (might be due to invalid IL or missing references)
//IL_006a: Unknown result type (might be due to invalid IL or missing references)
try
{
if (!Plugin.Config.EnableILSVeinCollectionFlag.Value || __instance == null || !__instance.isStellar || factory == null || factory.factorySystem == null)
{
return;
}
MinerComponent[] minerPool = factory.factorySystem.minerPool;
if (minerPool != null)
{
int minerId = __instance.minerId;
if (minerId > 0 && minerId < minerPool.Length)
{
MinerComponent val = minerPool[minerId];
__state = new Snapshot
{
minerId = minerId,
productCount = val.productCount
};
}
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("Patch C (Station vein collection) prefix threw: " + ex);
}
}
[HarmonyPriority(600)]
private static void Postfix(StationComponent __instance, PlanetFactory factory, int[] productRegister, ref Snapshot __state)
{
try
{
if (__state == null || !Plugin.Config.EnableILSVeinCollectionFlag.Value || __instance == null || !__instance.isStellar || factory == null || factory.factorySystem == null)
{
return;
}
MinerComponent[] minerPool = factory.factorySystem.minerPool;
if (minerPool != null && __state.minerId > 0 && __state.minerId < minerPool.Length && minerPool[__state.minerId].productCount != __state.productCount)
{
minerPool[__state.minerId].productCount = __state.productCount;
if (firstFireLogged && EndlessResourcesLog.IsDebugEnabled())
{
EndlessResourcesLog.Info("[patch] Patch C (Station vein collection) fired: miner " + __state.minerId + " productCount restored to " + __state.productCount);
firstFireLogged = false;
}
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("Patch C (Station vein collection) postfix threw: " + ex);
}
}
}
[BepInPlugin("com.zicarius.EndlessResources", "EndlessResources", "1.1.3")]
[BepInProcess("DSPGAME.exe")]
public sealed class Plugin : BaseUnityPlugin
{
public const string GUID = "com.zicarius.EndlessResources";
public const string NAME = "EndlessResources";
public const string VERSION = "1.1.3";
internal static PluginConfig Config;
private static Harmony _harmony;
private void Awake()
{
//IL_0152: Unknown result type (might be due to invalid IL or missing references)
//IL_015c: Expected O, but got Unknown
Config = new PluginConfig(((BaseUnityPlugin)this).Config);
EndlessResourcesLog.Init(((BaseUnityPlugin)this).Logger, Config.DebugLog);
EndlessResourcesLog.Info("[config] Loaded with config: miner=" + Config.EnableMinerPatchFlag.Value + ", oil=" + Config.EnableOilPatchFlag.Value + ", icarus=" + Config.EnableIcarusPatchFlag.Value + ", ils_vein=" + Config.EnableILSVeinCollectionFlag.Value + ", ils_source=" + Config.EnableILSSourceFlag.Value + ", planetminerfast=" + Config.EnablePlanetMinerFastCompatFlag.Value + ", heal_orders=" + Config.HealNegativeStationOrders.Value + ", debug=" + Config.DebugLog.Value);
try
{
_harmony = new Harmony("com.zicarius.EndlessResources");
_harmony.PatchAll(typeof(Plugin).Assembly);
int num = 0;
Type[] types = typeof(Plugin).Assembly.GetTypes();
for (int i = 0; i < types.Length; i++)
{
if (types[i].GetCustomAttributes(typeof(HarmonyPatch), inherit: true).Length != 0)
{
num++;
}
}
EndlessResourcesLog.Info("[patch] Applied " + num + " Harmony patches: MinerPatch, IcarusPatch, StationVeinCollectionPatch, StationDispatchPatch, StationOrderHealPatch.");
if (Config.EnablePlanetMinerFastCompatFlag.Value)
{
PlanetMinerFastCompat.Apply(_harmony);
}
}
catch (Exception ex)
{
EndlessResourcesLog.Error("Harmony PatchAll failed: " + ex);
}
DumpTargetMethodSignatures();
}
private static void DumpTargetMethodSignatures()
{
string[][] array = new string[4][]
{
new string[2] { "MinerComponent", "InternalUpdate" },
new string[2] { "PlayerAction_Mine", "GameTick" },
new string[2] { "StationComponent", "UpdateVeinCollection" },
new string[2] { "StationComponent", "DetermineDispatch" }
};
foreach (string[] array2 in array)
{
try
{
Type type = AccessTools.TypeByName(array2[0]);
if (type == null)
{
EndlessResourcesLog.Warn("[diag] Type not found: " + array2[0]);
continue;
}
MethodInfo methodInfo = AccessTools.Method(type, array2[1], (Type[])null, (Type[])null);
if (methodInfo == null)
{
EndlessResourcesLog.Warn("[diag] Method not found: " + array2[0] + "." + array2[1]);
continue;
}
ParameterInfo[] parameters = methodInfo.GetParameters();
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.Append("[diag] ").Append(array2[0]).Append(".")
.Append(array2[1])
.Append("(");
for (int j = 0; j < parameters.Length; j++)
{
if (j > 0)
{
stringBuilder.Append(", ");
}
stringBuilder.Append(parameters[j].ParameterType.Name).Append(" ").Append(parameters[j].Name);
}
stringBuilder.Append(")");
EndlessResourcesLog.Info(stringBuilder.ToString());
}
catch (Exception ex)
{
EndlessResourcesLog.Error("[diag] Failed to inspect " + array2[0] + "." + array2[1] + ": " + ex.Message);
}
}
}
private void Start()
{
if (Config.EnablePlanetMinerFastCompatFlag.Value)
{
PlanetMinerFastCompat.Retry();
}
}
private void OnDestroy()
{
Harmony harmony = _harmony;
if (harmony != null)
{
harmony.UnpatchSelf();
}
_harmony = null;
}
}
