Some mods target the Mono version of the game, which is available by opting into the Steam beta branch "alternate"
Decompiled source of ATMDepositLimitMod v1.0.0
Mods/ATMDepositLimitMod.dll
Decompiled a month agousing System; using System.Collections; using System.Collections.Generic; using System.Diagnostics; using System.IO; using System.Reflection; using System.Reflection.Emit; using System.Runtime.CompilerServices; using System.Runtime.InteropServices; using System.Runtime.Versioning; using ATMDepositLimitMod; using HarmonyLib; using MelonLoader; using MelonLoader.Utils; using ScheduleOne.Money; using ScheduleOne.UI.ATM; [assembly: MelonInfo(typeof(global::ATMDepositLimitMod.ATMDepositLimitMod), "ATM Deposit Limit Mod", "1.1.0", "YourName", null)] [assembly: MelonGame("ScheduleOne", "ScheduleOne")] [assembly: CompilationRelaxations(8)] [assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)] [assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)] [assembly: AssemblyTitle("Atm25K")] [assembly: AssemblyDescription("A mod to set the weekly deposit limit of ATMs to 25,000")] [assembly: AssemblyConfiguration("")] [assembly: AssemblyCompany("")] [assembly: AssemblyProduct("Atm25K")] [assembly: AssemblyCopyright("Copyright © 2025")] [assembly: AssemblyTrademark("")] [assembly: MelonInfo(typeof(global::ATMDepositLimitMod.ATMDepositLimitMod), "Atm25K", "1.0.0", "cathair", null)] [assembly: MelonGame("TVGS", "Schedule I")] [assembly: ComVisible(false)] [assembly: Guid("6ad0c76d-0e06-4420-8d82-c1bee895be9d")] [assembly: AssemblyFileVersion("1.0.0.0")] [assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")] [assembly: AssemblyVersion("1.0.0.0")] namespace ATMDepositLimitMod; public class ATMDepositLimitMod : MelonMod { private const float DEFAULT_LIMIT = 25000f; private float _depositLimit = 25000f; private float _configLimit = 25000f; public override void OnInitializeMelon() { LoadConfig(); try { ((MelonBase)this).HarmonyInstance.PatchAll(); MelonLogger.Msg($"[ATM Deposit Limit Mod] Successfully patched all methods with deposit limit set to {_configLimit}"); } catch (Exception ex) { MelonLogger.Error("[ATM Deposit Limit Mod] Failed to patch methods: " + ex.Message); } } private void LoadConfig() { try { string path = Path.Combine(MelonEnvironment.UserDataDirectory, "Mods", "atmconfig.txt"); string directoryName = Path.GetDirectoryName(path); if (!Directory.Exists(directoryName)) { Directory.CreateDirectory(directoryName); } if (!File.Exists(path)) { string contents = "DepositLimit=25000"; File.WriteAllText(path, contents); MelonLogger.Msg("[ATM Deposit Limit Mod] Created default config file"); } string[] array = File.ReadAllLines(path); string[] array2 = array; foreach (string text in array2) { if (text.StartsWith("DepositLimit=")) { if (float.TryParse(text.Split(new char[1] { '=' })[1], out var result)) { _configLimit = result; _depositLimit = result; } break; } } } catch (Exception ex) { MelonLogger.Error("[ATM Deposit Limit Mod] Error handling config file: " + ex.Message); } } public float GetDepositLimit() { return _depositLimit; } } [HarmonyPatch(typeof(ATM))] [HarmonyPatch(/*Could not decode attribute arguments.*/)] public static class ATM_Constructor_Patch { [CompilerGenerated] private sealed class <Transpiler>d__0 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator { private int <>1__state; private CodeInstruction <>2__current; private int <>l__initialThreadId; private IEnumerable<CodeInstruction> instructions; public IEnumerable<CodeInstruction> <>3__instructions; private ATMDepositLimitMod <mod>5__1; private float <limit>5__2; private IEnumerator<CodeInstruction> <>s__3; private CodeInstruction <instruction>5__4; private float <f>5__5; CodeInstruction IEnumerator<CodeInstruction>.Current { [DebuggerHidden] get { return <>2__current; } } object IEnumerator.Current { [DebuggerHidden] get { return <>2__current; } } [DebuggerHidden] public <Transpiler>d__0(int <>1__state) { this.<>1__state = <>1__state; <>l__initialThreadId = Environment.CurrentManagedThreadId; } [DebuggerHidden] void IDisposable.Dispose() { int num = <>1__state; if (num == -3 || (uint)(num - 1) <= 1u) { try { } finally { <>m__Finally1(); } } <mod>5__1 = null; <>s__3 = null; <instruction>5__4 = null; <>1__state = -2; } private bool MoveNext() { //IL_00e0: Unknown result type (might be due to invalid IL or missing references) //IL_00ea: Expected O, but got Unknown try { switch (<>1__state) { default: return false; case 0: <>1__state = -1; <mod>5__1 = Melon<ATMDepositLimitMod>.Instance; <limit>5__2 = <mod>5__1.GetDepositLimit(); <>s__3 = instructions.GetEnumerator(); <>1__state = -3; break; case 1: <>1__state = -3; goto IL_0121; case 2: { <>1__state = -3; goto IL_0121; } IL_0121: <instruction>5__4 = null; break; } if (<>s__3.MoveNext()) { <instruction>5__4 = <>s__3.Current; if (<instruction>5__4.opcode == OpCodes.Ldc_R4) { object operand = <instruction>5__4.operand; if (operand is float) { <f>5__5 = (float)operand; if (<f>5__5 == 10000f) { <>2__current = new CodeInstruction(OpCodes.Ldc_R4, (object)<limit>5__2); <>1__state = 1; return true; } } } <>2__current = <instruction>5__4; <>1__state = 2; return true; } <>m__Finally1(); <>s__3 = null; return false; } catch { //try-fault ((IDisposable)this).Dispose(); throw; } } bool IEnumerator.MoveNext() { //ILSpy generated this explicit interface implementation from .override directive in MoveNext return this.MoveNext(); } private void <>m__Finally1() { <>1__state = -1; if (<>s__3 != null) { <>s__3.Dispose(); } } [DebuggerHidden] void IEnumerator.Reset() { throw new NotSupportedException(); } [DebuggerHidden] IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator() { <Transpiler>d__0 <Transpiler>d__; if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId) { <>1__state = 0; <Transpiler>d__ = this; } else { <Transpiler>d__ = new <Transpiler>d__0(0); } <Transpiler>d__.instructions = <>3__instructions; return <Transpiler>d__; } [DebuggerHidden] IEnumerator IEnumerable.GetEnumerator() { return ((IEnumerable<CodeInstruction>)this).GetEnumerator(); } } [IteratorStateMachine(typeof(<Transpiler>d__0))] [HarmonyTranspiler] private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) { //yield-return decompiler failed: Unexpected instruction in Iterator.Dispose() return new <Transpiler>d__0(-2) { <>3__instructions = instructions }; } } [HarmonyPatch(typeof(ATMInterface))] public static class ATMInterface_Patches { [CompilerGenerated] private sealed class <ReplaceDepositLimit>d__2 : IEnumerable<CodeInstruction>, IEnumerable, IEnumerator<CodeInstruction>, IDisposable, IEnumerator { private int <>1__state; private CodeInstruction <>2__current; private int <>l__initialThreadId; private IEnumerable<CodeInstruction> instructions; public IEnumerable<CodeInstruction> <>3__instructions; private ATMDepositLimitMod <mod>5__1; private float <limit>5__2; private IEnumerator<CodeInstruction> <>s__3; private CodeInstruction <instruction>5__4; private float <f>5__5; CodeInstruction IEnumerator<CodeInstruction>.Current { [DebuggerHidden] get { return <>2__current; } } object IEnumerator.Current { [DebuggerHidden] get { return <>2__current; } } [DebuggerHidden] public <ReplaceDepositLimit>d__2(int <>1__state) { this.<>1__state = <>1__state; <>l__initialThreadId = Environment.CurrentManagedThreadId; } [DebuggerHidden] void IDisposable.Dispose() { int num = <>1__state; if (num == -3 || (uint)(num - 1) <= 1u) { try { } finally { <>m__Finally1(); } } <mod>5__1 = null; <>s__3 = null; <instruction>5__4 = null; <>1__state = -2; } private bool MoveNext() { //IL_00e0: Unknown result type (might be due to invalid IL or missing references) //IL_00ea: Expected O, but got Unknown try { switch (<>1__state) { default: return false; case 0: <>1__state = -1; <mod>5__1 = Melon<ATMDepositLimitMod>.Instance; <limit>5__2 = <mod>5__1.GetDepositLimit(); <>s__3 = instructions.GetEnumerator(); <>1__state = -3; break; case 1: <>1__state = -3; goto IL_0121; case 2: { <>1__state = -3; goto IL_0121; } IL_0121: <instruction>5__4 = null; break; } if (<>s__3.MoveNext()) { <instruction>5__4 = <>s__3.Current; if (<instruction>5__4.opcode == OpCodes.Ldc_R4) { object operand = <instruction>5__4.operand; if (operand is float) { <f>5__5 = (float)operand; if (<f>5__5 == 10000f) { <>2__current = new CodeInstruction(OpCodes.Ldc_R4, (object)<limit>5__2); <>1__state = 1; return true; } } } <>2__current = <instruction>5__4; <>1__state = 2; return true; } <>m__Finally1(); <>s__3 = null; return false; } catch { //try-fault ((IDisposable)this).Dispose(); throw; } } bool IEnumerator.MoveNext() { //ILSpy generated this explicit interface implementation from .override directive in MoveNext return this.MoveNext(); } private void <>m__Finally1() { <>1__state = -1; if (<>s__3 != null) { <>s__3.Dispose(); } } [DebuggerHidden] void IEnumerator.Reset() { throw new NotSupportedException(); } [DebuggerHidden] IEnumerator<CodeInstruction> IEnumerable<CodeInstruction>.GetEnumerator() { <ReplaceDepositLimit>d__2 <ReplaceDepositLimit>d__; if (<>1__state == -2 && <>l__initialThreadId == Environment.CurrentManagedThreadId) { <>1__state = 0; <ReplaceDepositLimit>d__ = this; } else { <ReplaceDepositLimit>d__ = new <ReplaceDepositLimit>d__2(0); } <ReplaceDepositLimit>d__.instructions = <>3__instructions; return <ReplaceDepositLimit>d__; } [DebuggerHidden] IEnumerator IEnumerable.GetEnumerator() { return ((IEnumerable<CodeInstruction>)this).GetEnumerator(); } } [HarmonyPatch("get_remainingAllowedDeposit")] [HarmonyTranspiler] private static IEnumerable<CodeInstruction> Transpiler_RemainingAllowedDeposit(IEnumerable<CodeInstruction> instructions) { return ReplaceDepositLimit(instructions); } [HarmonyPatch("Update")] [HarmonyTranspiler] private static IEnumerable<CodeInstruction> Transpiler_Update(IEnumerable<CodeInstruction> instructions) { return ReplaceDepositLimit(instructions); } [IteratorStateMachine(typeof(<ReplaceDepositLimit>d__2))] private static IEnumerable<CodeInstruction> ReplaceDepositLimit(IEnumerable<CodeInstruction> instructions) { //yield-return decompiler failed: Unexpected instruction in Iterator.Dispose() return new <ReplaceDepositLimit>d__2(-2) { <>3__instructions = instructions }; } }
