using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using Il2CppFishNet;
using Il2CppInterop.Runtime;
using Il2CppInterop.Runtime.InteropTypes;
using Il2CppInterop.Runtime.InteropTypes.Arrays;
using Il2CppScheduleOne;
using Il2CppScheduleOne.DevUtilities;
using Il2CppScheduleOne.GameTime;
using Il2CppScheduleOne.ItemFramework;
using Il2CppScheduleOne.PlayerScripts;
using Il2CppSystem;
using Il2CppSystem.Collections.Generic;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using NoMoreTrash;
using NoMoreTrash.Helpers;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(global::NoMoreTrash.NoMoreTrash), "NoMoreTrash", "1.0.0", "me", null)]
[assembly: MelonColor(1, 255, 0, 0)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyCompany("NoMoreTrash-IL2CPP")]
[assembly: AssemblyConfiguration("Debug IL2CPP")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("NoMoreTrash-IL2CPP")]
[assembly: AssemblyTitle("NoMoreTrash-IL2CPP")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace NoMoreTrash
{
public static class BuildInfo
{
public const string Name = "NoMoreTrash";
public const string Description = "Automatically clears trash to keep your game clean";
public const string Author = "me";
public const string Version = "1.0.0";
}
public class NoMoreTrash : MelonMod
{
[CompilerGenerated]
private sealed class <InitializeSaveDetection>d__14 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public NoMoreTrash <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InitializeSaveDetection>d__14(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
ModLogger.Debug("Waiting for player before initializing save detection", "InitializeSaveDetection", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 169);
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (!SaveEventEnabledEntry.Value)
{
ModLogger.Msg("Automatic trash cleanup disabled - manual cleanup only");
return false;
}
if (<>4__this.SubscribeToSleepEndEvent())
{
ModLogger.Msg("Automatic trash cleanup enabled - clearing after sleep");
return false;
}
ModLogger.Msg("Automatic trash cleanup enabled - cleaning every 24 minutes");
ModLogger.Debug("Using coroutine-based save detection (fallback approach)", "InitializeSaveDetection", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 187);
<>4__this._saveCoroutineRunning = true;
MelonCoroutines.Start(<>4__this.SaveCoroutine());
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <SaveCoroutine>d__15 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public NoMoreTrash <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SaveCoroutine>d__15(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
if (<>4__this._saveCoroutineRunning && SaveEventEnabledEntry.Value)
{
ModLogger.Debug("Save interval reached, executing command", "SaveCoroutine", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 207);
<>4__this.ExecuteClearTrashCommand();
}
break;
}
if (<>4__this._saveCoroutineRunning && SaveEventEnabledEntry.Value)
{
<>2__current = (object)new WaitForSeconds(1440f);
<>1__state = 1;
return true;
}
<>4__this._saveCoroutineRunning = false;
ModLogger.Debug("Save coroutine stopped", "SaveCoroutine", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 213);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static NoMoreTrash Instance;
private static MelonPreferences_Category ConfigCategory;
private static MelonPreferences_Entry<KeyCode> HotkeyEntry;
private static MelonPreferences_Entry<bool> SaveEventEnabledEntry;
private static MelonPreferences_Entry<bool> HotkeyEnabledEntry;
private static MelonPreferences_Entry<string> CommandEntry;
private bool _saveCoroutineRunning = false;
private bool _sleepEndEventSubscribed = false;
public override void OnInitializeMelon()
{
//IL_0043: Unknown result type (might be due to invalid IL or missing references)
Instance = this;
ModLogger.Initialize(((MelonBase)this).LoggerInstance);
ModLogger.Msg("NoMoreTrash - Automatic trash cleanup initialized!");
InitializePreferences();
ModLogger.Msg($"Ready to keep things clean! Press [{HotkeyEntry.Value}] to manually clear trash.");
}
private void InitializePreferences()
{
ConfigCategory = MelonPreferences.CreateCategory("NoMoreTrash");
HotkeyEntry = ConfigCategory.CreateEntry<KeyCode>("Hotkey", (KeyCode)112, "Trash cleanup hotkey", "Press this key to manually clear all trash", false, false, (ValueValidator)null, (string)null);
HotkeyEnabledEntry = ConfigCategory.CreateEntry<bool>("HotkeyEnabled", true, "Enable hotkey trash clearing", "Allow manual trash cleanup using the hotkey", false, false, (ValueValidator)null, (string)null);
SaveEventEnabledEntry = ConfigCategory.CreateEntry<bool>("SaveEventEnabled", true, "Auto-clear trash on save", "Automatically clear trash whenever the game saves", false, false, (ValueValidator)null, (string)null);
CommandEntry = ConfigCategory.CreateEntry<string>("Command", "cleartrash", "Cleanup command", "The console command used to clear trash", false, false, (ValueValidator)null, (string)null);
MelonPreferences.Save();
}
private void ExecuteClearTrashCommand()
{
try
{
string value = CommandEntry.Value;
if (string.IsNullOrEmpty(value))
{
ModLogger.Warning("Cleanup command not configured - trash remains");
return;
}
ModLogger.Debug("Executing console command: " + value, "ExecuteClearTrashCommand", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 110);
Console.SubmitCommand(value);
ModLogger.Msg("✓ Trash cleared successfully!");
}
catch (Exception ex)
{
ModLogger.Error("Failed to clear trash: " + ex.Message);
ModLogger.Debug("Stack trace: " + ex.StackTrace, "ExecuteClearTrashCommand", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 123);
}
}
public override void OnUpdate()
{
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Unknown result type (might be due to invalid IL or missing references)
if (HotkeyEnabledEntry.Value && Input.GetKeyDown(HotkeyEntry.Value))
{
ModLogger.Debug($"Hotkey {HotkeyEntry.Value} pressed", "OnUpdate", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 132);
ExecuteClearTrashCommand();
}
}
public override void OnSceneWasLoaded(int buildIndex, string sceneName)
{
ModLogger.Debug("Scene loaded: " + sceneName, "OnSceneWasLoaded", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 139);
if (sceneName == "Main")
{
ModLogger.Debug("Main scene loaded, initializing save detection", "OnSceneWasLoaded", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 142);
MelonCoroutines.Start(Utils.WaitForPlayer(InitializeSaveDetection()));
}
}
public override void OnSceneWasUnloaded(int buildIndex, string sceneName)
{
if (_saveCoroutineRunning)
{
ModLogger.Debug("Scene unloaded: " + sceneName + ", stopping save coroutine", "OnSceneWasUnloaded", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 152);
_saveCoroutineRunning = false;
}
if (_sleepEndEventSubscribed)
{
UnsubscribeFromSleepEndEvent();
}
}
[IteratorStateMachine(typeof(<InitializeSaveDetection>d__14))]
private IEnumerator InitializeSaveDetection()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InitializeSaveDetection>d__14(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<SaveCoroutine>d__15))]
private IEnumerator SaveCoroutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SaveCoroutine>d__15(0)
{
<>4__this = this
};
}
private void OnSaveEvent()
{
if (!SaveEventEnabledEntry.Value)
{
ModLogger.Debug("Save event detected but execution is disabled in preferences", "OnSaveEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 223);
return;
}
ModLogger.Debug("Save event detected, executing command", "OnSaveEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 227);
ExecuteClearTrashCommand();
}
private bool SubscribeToSleepEndEvent()
{
try
{
TimeManager instance = NetworkSingleton<TimeManager>.Instance;
instance.onSleepEnd += Action.op_Implicit((Action)OnSleepEndHandler);
_sleepEndEventSubscribed = true;
ModLogger.Debug("Subscribed to TimeManager.Instance.onSleepEnd", "SubscribeToSleepEndEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 242);
return true;
}
catch (Exception ex)
{
ModLogger.Debug("Failed to subscribe to onSleepEnd: " + ex.Message, "SubscribeToSleepEndEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 247);
return false;
}
}
private void UnsubscribeFromSleepEndEvent()
{
try
{
TimeManager instance = NetworkSingleton<TimeManager>.Instance;
instance.onSleepEnd -= Action.op_Implicit((Action)OnSleepEndHandler);
_sleepEndEventSubscribed = false;
ModLogger.Debug("Unsubscribed from TimeManager.Instance.onSleepEnd", "UnsubscribeFromSleepEndEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 263);
}
catch (Exception ex)
{
ModLogger.Debug("Failed to unsubscribe from onSleepEnd: " + ex.Message, "UnsubscribeFromSleepEndEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 267);
}
}
private void OnSleepEndHandler()
{
ModLogger.Debug("Sleep end detected, triggering trash cleanup", "OnSleepEndHandler", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 274);
OnSaveEvent();
}
}
}
namespace NoMoreTrash.Helpers
{
public static class ModLogger
{
private static Instance _logger;
public static bool IsInitialized => _logger != null;
public static void Initialize(string modName)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
_logger = new Instance(modName);
}
public static void Initialize(Instance loggerInstance)
{
_logger = loggerInstance;
}
public static void Msg(string message)
{
Instance logger = _logger;
if (logger != null)
{
logger.Msg(message);
}
}
public static void Debug(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
{
}
public static void Warning(string message)
{
Instance logger = _logger;
if (logger != null)
{
logger.Warning(message);
}
}
public static void Error(string message)
{
Instance logger = _logger;
if (logger != null)
{
logger.Error(message);
}
}
public static void Msg(ConsoleColor color, string message)
{
Instance logger = _logger;
if (logger != null)
{
logger.Msg(color, message);
}
}
}
public static class Il2CppListExtensions
{
public static IEnumerable<T> AsEnumerable<T>(this List<T> list)
{
return list ?? new List<T>();
}
public static List<T> ToIl2CppList<T>(this IEnumerable<T> source)
{
List<T> val = new List<T>();
foreach (T item in source)
{
val.Add(item);
}
return val;
}
public static List<T> ConvertToList<T>(List<T> il2CppList)
{
List<T> list = new List<T>();
T[] collection = Il2CppArrayBase<T>.op_Implicit(il2CppList.ToArray());
list.AddRange(collection);
return list;
}
public static IEnumerable<T> AsEnumerable<T>(this List<T> list)
{
IEnumerable<T> result;
if (list != null)
{
result = ((IEnumerable<T>)list._items).Take(list._size);
}
else
{
IEnumerable<T> enumerable = Array.Empty<T>();
result = enumerable;
}
return result;
}
}
public static class Utils
{
[CompilerGenerated]
private sealed class <WaitForNetwork>d__6 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IEnumerator routine;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForNetwork>d__6(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if (!InstanceFinder.IsServer && !InstanceFinder.IsClient)
{
<>2__current = null;
<>1__state = 1;
return true;
}
MelonCoroutines.Start(routine);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <WaitForNetworkSingleton>d__8<T> : IEnumerator<object>, IEnumerator, IDisposable where T : notnull, NetworkSingleton<T>
{
private int <>1__state;
private object <>2__current;
public IEnumerator coroutine;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForNetworkSingleton>d__8(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
goto IL_0044;
case 1:
<>1__state = -1;
goto IL_0044;
case 2:
{
<>1__state = -1;
return false;
}
IL_0044:
if (!NetworkSingleton<T>.InstanceExists)
{
<>2__current = null;
<>1__state = 1;
return true;
}
<>2__current = coroutine;
<>1__state = 2;
return true;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <WaitForNotNull>d__7 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public object obj;
public float timeout;
public Action onTimeout;
public Action onFinish;
private float <startTime>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForNotNull>d__7(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<startTime>5__1 = Time.time;
break;
case 1:
<>1__state = -1;
break;
}
if (obj == null)
{
if (!float.IsNaN(timeout) && Time.time - <startTime>5__1 > timeout)
{
onTimeout?.Invoke();
return false;
}
<>2__current = null;
<>1__state = 1;
return true;
}
onFinish?.Invoke();
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <WaitForPlayer>d__5 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IEnumerator routine;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForPlayer>d__5(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if ((Object)(object)Player.Local == (Object)null || (Object)(object)((Component)Player.Local).gameObject == (Object)null)
{
<>2__current = null;
<>1__state = 1;
return true;
}
MelonCoroutines.Start(routine);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static readonly Instance Logger = new Instance("NoMoreTrash-Utils");
public static T FindObjectByName<T>(string objectName) where T : Object
{
try
{
foreach (T item in Resources.FindObjectsOfTypeAll<T>())
{
if (((Object)item).name != objectName)
{
continue;
}
ModLogger.Debug($"Found {typeof(T).Name} '{objectName}' directly in loaded objects", "FindObjectByName", "D:\\Schedule 1 Modding\\NoMoreTrash\\Helpers\\Utils.cs", 115);
return item;
}
return default(T);
}
catch (Exception ex)
{
Logger.Error($"Error finding {typeof(T).Name} '{objectName}': {ex.Message}");
return default(T);
}
}
public static List<T> GetAllComponentsInChildrenRecursive<T>(GameObject obj) where T : Component
{
List<T> list = new List<T>();
if ((Object)(object)obj == (Object)null)
{
return list;
}
T[] array = Il2CppArrayBase<T>.op_Implicit(obj.GetComponents<T>());
if (array.Length != 0)
{
list.AddRange(array);
}
for (int i = 0; i < obj.transform.childCount; i++)
{
Transform child = obj.transform.GetChild(i);
list.AddRange(GetAllComponentsInChildrenRecursive<T>(((Component)child).gameObject));
}
return list;
}
public static bool Is<T>(object obj, out T result) where T : Object
{
Object val = (Object)((obj is Object) ? obj : null);
if (val != null)
{
Type val2 = Il2CppType.Of<T>();
Type il2CppType = val.GetIl2CppType();
if (val2.IsAssignableFrom(il2CppType))
{
result = ((Il2CppObjectBase)val).TryCast<T>();
return result != null;
}
}
result = default(T);
return false;
}
public static List<StorableItemDefinition> GetAllStorableItemDefinitions()
{
List<ItemRegister> list = Il2CppListExtensions.ConvertToList<ItemRegister>(Singleton<Registry>.Instance.ItemRegistry);
List<StorableItemDefinition> list2 = new List<StorableItemDefinition>();
foreach (ItemRegister item in list)
{
if (Utils.Is<StorableItemDefinition>((object)item.Definition, out StorableItemDefinition result))
{
list2.Add(result);
}
else
{
Logger.Warning("Definition " + ((object)item.Definition)?.GetType().FullName + " is not a StorableItemDefinition");
}
}
return list2.ToList();
}
[IteratorStateMachine(typeof(<WaitForPlayer>d__5))]
public static IEnumerator WaitForPlayer(IEnumerator routine)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForPlayer>d__5(0)
{
routine = routine
};
}
[IteratorStateMachine(typeof(<WaitForNetwork>d__6))]
public static IEnumerator WaitForNetwork(IEnumerator routine)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForNetwork>d__6(0)
{
routine = routine
};
}
[IteratorStateMachine(typeof(<WaitForNotNull>d__7))]
public static IEnumerator WaitForNotNull(object? obj, float timeout = float.NaN, Action onTimeout = null, Action onFinish = null)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForNotNull>d__7(0)
{
obj = obj,
timeout = timeout,
onTimeout = onTimeout,
onFinish = onFinish
};
}
[IteratorStateMachine(typeof(<WaitForNetworkSingleton>d__8<>))]
public static IEnumerator WaitForNetworkSingleton<T>(IEnumerator coroutine) where T : NetworkSingleton<T>
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForNetworkSingleton>d__8<T>(0)
{
coroutine = coroutine
};
}
}
}
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using FishNet;
using MelonLoader;
using MelonLoader.Preferences;
using Microsoft.CodeAnalysis;
using NoMoreTrash;
using NoMoreTrash.Helpers;
using ScheduleOne;
using ScheduleOne.DevUtilities;
using ScheduleOne.GameTime;
using ScheduleOne.PlayerScripts;
using UnityEngine;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: MelonInfo(typeof(global::NoMoreTrash.NoMoreTrash), "NoMoreTrash", "1.0.0", "SirTidez", null)]
[assembly: MelonColor(1, 255, 0, 0)]
[assembly: MelonGame("TVGS", "Schedule I")]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("NoMoreTrash-Mono")]
[assembly: AssemblyConfiguration("Debug Mono")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("NoMoreTrash-Mono")]
[assembly: AssemblyTitle("NoMoreTrash-Mono")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
internal sealed class NullableAttribute : Attribute
{
public readonly byte[] NullableFlags;
public NullableAttribute(byte P_0)
{
NullableFlags = new byte[1] { P_0 };
}
public NullableAttribute(byte[] P_0)
{
NullableFlags = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
internal sealed class NullableContextAttribute : Attribute
{
public readonly byte Flag;
public NullableContextAttribute(byte P_0)
{
Flag = P_0;
}
}
[CompilerGenerated]
[Microsoft.CodeAnalysis.Embedded]
[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
internal sealed class RefSafetyRulesAttribute : Attribute
{
public readonly int Version;
public RefSafetyRulesAttribute(int P_0)
{
Version = P_0;
}
}
}
namespace NoMoreTrash
{
public static class BuildInfo
{
public const string Name = "NoMoreTrash";
public const string Description = "Automatically clears trash to keep your game clean";
public const string Author = "SirTidez";
public const string Version = "1.0.0";
}
public class NoMoreTrash : MelonMod
{
[CompilerGenerated]
private sealed class <InitializeSaveDetection>d__14 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public NoMoreTrash <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <InitializeSaveDetection>d__14(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
ModLogger.Debug("Waiting for player before initializing save detection", "InitializeSaveDetection", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 169);
<>2__current = null;
<>1__state = 1;
return true;
case 1:
<>1__state = -1;
if (!SaveEventEnabledEntry.Value)
{
ModLogger.Msg("Automatic trash cleanup disabled - manual cleanup only");
return false;
}
if (<>4__this.SubscribeToSleepEndEvent())
{
ModLogger.Msg("Automatic trash cleanup enabled - clearing after sleep");
return false;
}
ModLogger.Msg("Automatic trash cleanup enabled - cleaning every 24 minutes");
ModLogger.Debug("Using coroutine-based save detection (fallback approach)", "InitializeSaveDetection", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 187);
<>4__this._saveCoroutineRunning = true;
MelonCoroutines.Start(<>4__this.SaveCoroutine());
return false;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <SaveCoroutine>d__15 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public NoMoreTrash <>4__this;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <SaveCoroutine>d__15(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
//IL_0029: Unknown result type (might be due to invalid IL or missing references)
//IL_0033: Expected O, but got Unknown
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
if (<>4__this._saveCoroutineRunning && SaveEventEnabledEntry.Value)
{
ModLogger.Debug("Save interval reached, executing command", "SaveCoroutine", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 207);
<>4__this.ExecuteClearTrashCommand();
}
break;
}
if (<>4__this._saveCoroutineRunning && SaveEventEnabledEntry.Value)
{
<>2__current = (object)new WaitForSeconds(1440f);
<>1__state = 1;
return true;
}
<>4__this._saveCoroutineRunning = false;
ModLogger.Debug("Save coroutine stopped", "SaveCoroutine", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 213);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static NoMoreTrash Instance;
private static MelonPreferences_Category ConfigCategory;
private static MelonPreferences_Entry<KeyCode> HotkeyEntry;
private static MelonPreferences_Entry<bool> SaveEventEnabledEntry;
private static MelonPreferences_Entry<bool> HotkeyEnabledEntry;
private static MelonPreferences_Entry<string> CommandEntry;
private bool _saveCoroutineRunning = false;
private bool _sleepEndEventSubscribed = false;
public override void OnInitializeMelon()
{
//IL_002f: Unknown result type (might be due to invalid IL or missing references)
Instance = this;
ModLogger.Initialize(((MelonBase)this).LoggerInstance);
ModLogger.Msg("NoMoreTrash - Automatic trash cleanup initialized!");
InitializePreferences();
ModLogger.Msg($"Ready to keep things clean! Press [{HotkeyEntry.Value}] to manually clear trash.");
}
private void InitializePreferences()
{
ConfigCategory = MelonPreferences.CreateCategory("NoMoreTrash");
HotkeyEntry = ConfigCategory.CreateEntry<KeyCode>("Hotkey", (KeyCode)112, "Trash cleanup hotkey", "Press this key to manually clear all trash", false, false, (ValueValidator)null, (string)null);
HotkeyEnabledEntry = ConfigCategory.CreateEntry<bool>("HotkeyEnabled", true, "Enable hotkey trash clearing", "Allow manual trash cleanup using the hotkey", false, false, (ValueValidator)null, (string)null);
SaveEventEnabledEntry = ConfigCategory.CreateEntry<bool>("SaveEventEnabled", true, "Auto-clear trash on save", "Automatically clear trash whenever the game saves", false, false, (ValueValidator)null, (string)null);
CommandEntry = ConfigCategory.CreateEntry<string>("Command", "cleartrash", "Cleanup command", "The console command used to clear trash", false, false, (ValueValidator)null, (string)null);
MelonPreferences.Save();
}
private void ExecuteClearTrashCommand()
{
try
{
string value = CommandEntry.Value;
if (string.IsNullOrEmpty(value))
{
ModLogger.Warning("Cleanup command not configured - trash remains");
return;
}
ModLogger.Debug("Executing console command: " + value, "ExecuteClearTrashCommand", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 110);
Console.SubmitCommand(value);
ModLogger.Msg("✓ Trash cleared successfully!");
}
catch (Exception ex)
{
ModLogger.Error("Failed to clear trash: " + ex.Message);
ModLogger.Debug("Stack trace: " + ex.StackTrace, "ExecuteClearTrashCommand", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 123);
}
}
public override void OnUpdate()
{
//IL_0012: 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)
if (HotkeyEnabledEntry.Value && Input.GetKeyDown(HotkeyEntry.Value))
{
ModLogger.Debug($"Hotkey {HotkeyEntry.Value} pressed", "OnUpdate", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 132);
ExecuteClearTrashCommand();
}
}
public override void OnSceneWasLoaded(int buildIndex, string sceneName)
{
ModLogger.Debug("Scene loaded: " + sceneName, "OnSceneWasLoaded", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 139);
if (sceneName == "Main")
{
ModLogger.Debug("Main scene loaded, initializing save detection", "OnSceneWasLoaded", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 142);
MelonCoroutines.Start(Utils.WaitForPlayer(InitializeSaveDetection()));
}
}
public override void OnSceneWasUnloaded(int buildIndex, string sceneName)
{
if (_saveCoroutineRunning)
{
ModLogger.Debug("Scene unloaded: " + sceneName + ", stopping save coroutine", "OnSceneWasUnloaded", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 152);
_saveCoroutineRunning = false;
}
if (_sleepEndEventSubscribed)
{
UnsubscribeFromSleepEndEvent();
}
}
[IteratorStateMachine(typeof(<InitializeSaveDetection>d__14))]
private IEnumerator InitializeSaveDetection()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <InitializeSaveDetection>d__14(0)
{
<>4__this = this
};
}
[IteratorStateMachine(typeof(<SaveCoroutine>d__15))]
private IEnumerator SaveCoroutine()
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <SaveCoroutine>d__15(0)
{
<>4__this = this
};
}
private void OnSaveEvent()
{
if (!SaveEventEnabledEntry.Value)
{
ModLogger.Debug("Save event detected but execution is disabled in preferences", "OnSaveEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 223);
return;
}
ModLogger.Debug("Save event detected, executing command", "OnSaveEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 227);
ExecuteClearTrashCommand();
}
private bool SubscribeToSleepEndEvent()
{
try
{
TimeManager instance = NetworkSingleton<TimeManager>.Instance;
instance.onSleepEnd = (Action)Delegate.Combine(instance.onSleepEnd, new Action(OnSleepEndHandler));
_sleepEndEventSubscribed = true;
ModLogger.Debug("Subscribed to TimeManager.Instance.onSleepEnd", "SubscribeToSleepEndEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 242);
return true;
}
catch (Exception ex)
{
ModLogger.Debug("Failed to subscribe to onSleepEnd: " + ex.Message, "SubscribeToSleepEndEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 247);
return false;
}
}
private void UnsubscribeFromSleepEndEvent()
{
try
{
TimeManager instance = NetworkSingleton<TimeManager>.Instance;
instance.onSleepEnd = (Action)Delegate.Remove(instance.onSleepEnd, new Action(OnSleepEndHandler));
_sleepEndEventSubscribed = false;
ModLogger.Debug("Unsubscribed from TimeManager.Instance.onSleepEnd", "UnsubscribeFromSleepEndEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 263);
}
catch (Exception ex)
{
ModLogger.Debug("Failed to unsubscribe from onSleepEnd: " + ex.Message, "UnsubscribeFromSleepEndEvent", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 267);
}
}
private void OnSleepEndHandler()
{
ModLogger.Debug("Sleep end detected, triggering trash cleanup", "OnSleepEndHandler", "D:\\Schedule 1 Modding\\NoMoreTrash\\MainMod.cs", 274);
OnSaveEvent();
}
}
}
namespace NoMoreTrash.Helpers
{
public static class ModLogger
{
private static Instance _logger;
public static bool IsInitialized => _logger != null;
public static void Initialize(string modName)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_000c: Expected O, but got Unknown
_logger = new Instance(modName);
}
public static void Initialize(Instance loggerInstance)
{
_logger = loggerInstance;
}
public static void Msg(string message)
{
Instance logger = _logger;
if (logger != null)
{
logger.Msg(message);
}
}
public static void Debug(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string sourceFilePath = "", [CallerLineNumber] int sourceLineNumber = 0)
{
}
public static void Warning(string message)
{
Instance logger = _logger;
if (logger != null)
{
logger.Warning(message);
}
}
public static void Error(string message)
{
Instance logger = _logger;
if (logger != null)
{
logger.Error(message);
}
}
public static void Msg(ConsoleColor color, string message)
{
Instance logger = _logger;
if (logger != null)
{
logger.Msg(color, message);
}
}
}
public static class Il2CppListExtensions
{
public static IEnumerable<T> AsEnumerable<T>(this List<T> list)
{
return list ?? new List<T>();
}
}
public static class Utils
{
[CompilerGenerated]
private sealed class <WaitForNetwork>d__5 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IEnumerator routine;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForNetwork>d__5(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if (!InstanceFinder.IsServer && !InstanceFinder.IsClient)
{
<>2__current = null;
<>1__state = 1;
return true;
}
MelonCoroutines.Start(routine);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <WaitForNetworkSingleton>d__7<T> : IEnumerator<object>, IEnumerator, IDisposable where T : notnull, NetworkSingleton<T>
{
private int <>1__state;
private object <>2__current;
public IEnumerator coroutine;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForNetworkSingleton>d__7(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
goto IL_0044;
case 1:
<>1__state = -1;
goto IL_0044;
case 2:
{
<>1__state = -1;
return false;
}
IL_0044:
if (!NetworkSingleton<T>.InstanceExists)
{
<>2__current = null;
<>1__state = 1;
return true;
}
<>2__current = coroutine;
<>1__state = 2;
return true;
}
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <WaitForNotNull>d__6 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public object obj;
public float timeout;
public Action onTimeout;
public Action onFinish;
private float <startTime>5__1;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForNotNull>d__6(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
<startTime>5__1 = Time.time;
break;
case 1:
<>1__state = -1;
break;
}
if (obj == null)
{
if (!float.IsNaN(timeout) && Time.time - <startTime>5__1 > timeout)
{
onTimeout?.Invoke();
return false;
}
<>2__current = null;
<>1__state = 1;
return true;
}
onFinish?.Invoke();
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
[CompilerGenerated]
private sealed class <WaitForPlayer>d__4 : IEnumerator<object>, IEnumerator, IDisposable
{
private int <>1__state;
private object <>2__current;
public IEnumerator routine;
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return <>2__current;
}
}
[DebuggerHidden]
public <WaitForPlayer>d__4(int <>1__state)
{
this.<>1__state = <>1__state;
}
[DebuggerHidden]
void IDisposable.Dispose()
{
<>1__state = -2;
}
private bool MoveNext()
{
switch (<>1__state)
{
default:
return false;
case 0:
<>1__state = -1;
break;
case 1:
<>1__state = -1;
break;
}
if ((Object)(object)Player.Local == (Object)null || (Object)(object)((Component)Player.Local).gameObject == (Object)null)
{
<>2__current = null;
<>1__state = 1;
return true;
}
MelonCoroutines.Start(routine);
return false;
}
bool IEnumerator.MoveNext()
{
//ILSpy generated this explicit interface implementation from .override directive in MoveNext
return this.MoveNext();
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
}
private static readonly Instance Logger = new Instance("NoMoreTrash-Utils");
public static T FindObjectByName<T>(string objectName) where T : Object
{
try
{
T[] array = Resources.FindObjectsOfTypeAll<T>();
foreach (T val in array)
{
if (!(((Object)val).name != objectName))
{
ModLogger.Debug("Found " + typeof(T).Name + " '" + objectName + "' directly in loaded objects", "FindObjectByName", "D:\\Schedule 1 Modding\\NoMoreTrash\\Helpers\\Utils.cs", 115);
return val;
}
}
return default(T);
}
catch (Exception ex)
{
Logger.Error("Error finding " + typeof(T).Name + " '" + objectName + "': " + ex.Message);
return default(T);
}
}
public static List<T> GetAllComponentsInChildrenRecursive<T>(GameObject obj) where T : Component
{
List<T> list = new List<T>();
if ((Object)(object)obj == (Object)null)
{
return list;
}
T[] components = obj.GetComponents<T>();
if (components.Length != 0)
{
list.AddRange(components);
}
for (int i = 0; i < obj.transform.childCount; i++)
{
Transform child = obj.transform.GetChild(i);
list.AddRange(GetAllComponentsInChildrenRecursive<T>(((Component)child).gameObject));
}
return list;
}
public static bool Is<T>(object obj, out T result) where T : class
{
if (obj is T val)
{
result = val;
return true;
}
result = null;
return false;
}
[IteratorStateMachine(typeof(<WaitForPlayer>d__4))]
public static IEnumerator WaitForPlayer(IEnumerator routine)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForPlayer>d__4(0)
{
routine = routine
};
}
[IteratorStateMachine(typeof(<WaitForNetwork>d__5))]
public static IEnumerator WaitForNetwork(IEnumerator routine)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForNetwork>d__5(0)
{
routine = routine
};
}
[IteratorStateMachine(typeof(<WaitForNotNull>d__6))]
public static IEnumerator WaitForNotNull(object? obj, float timeout = float.NaN, Action onTimeout = null, Action onFinish = null)
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForNotNull>d__6(0)
{
obj = obj,
timeout = timeout,
onTimeout = onTimeout,
onFinish = onFinish
};
}
[IteratorStateMachine(typeof(<WaitForNetworkSingleton>d__7<>))]
public static IEnumerator WaitForNetworkSingleton<T>(IEnumerator coroutine) where T : NetworkSingleton<T>
{
//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
return new <WaitForNetworkSingleton>d__7<T>(0)
{
coroutine = coroutine
};
}
}
}
namespace System.Runtime.CompilerServices
{
[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
internal sealed class IgnoresAccessChecksToAttribute : Attribute
{
public IgnoresAccessChecksToAttribute(string assemblyName)
{
}
}
}