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 System.Text;
using System.Threading;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using IEVO.UI.uGUIDirectedNavigation;
using Microsoft.CodeAnalysis;
using Steamworks;
using Steamworks.Data;
using Steamworks.Ugc;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.UI;
using VGFunctions;
[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("LessRam")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("title")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+786e633056fcf309aed952b5636e8ad233e9f3d2")]
[assembly: AssemblyProduct("LessRam")]
[assembly: AssemblyTitle("LessRam")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
[CompilerGenerated]
[Embedded]
internal sealed class EmbeddedAttribute : Attribute
{
}
}
namespace System.Runtime.CompilerServices
{
[CompilerGenerated]
[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]
[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]
[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 LessRam
{
[HarmonyPatch(typeof(GameManager))]
public static class GameManagerPatch
{
[HarmonyPatch("LoadAudio")]
[HarmonyPrefix]
public static bool PreLoadAudio(ref IEnumerator __result, VGLevel _level)
{
if (!SingletonBase<GameManager>.Inst.IsArcade || Object.op_Implicit((Object)(object)_level.LevelMusic))
{
return true;
}
__result = LoadAudio(SingletonBase<ArcadeManager>.Inst.CurrentArcadeLevel);
return false;
}
private static IEnumerator LoadAudio(VGLevel _level)
{
VGLevelWrapper valueOrDefault = LessRam.Levels.GetValueOrDefault(((Object)_level).name, null);
Coroutine val = ((MonoBehaviour)DataManager.inst).StartCoroutine(LevelLoaderHelper.LoadAudio(_level, valueOrDefault.AudioPath));
Coroutine coroutine2 = ((MonoBehaviour)DataManager.inst).StartCoroutine(LevelLoaderHelper.LoadImage(_level, valueOrDefault.ImagePath));
yield return val;
yield return coroutine2;
SingletonBase<GameManager>.Inst.LevelAudio = _level.LevelMusic;
SingletonBase<GameManager>.Inst.CurLoadingState.Audio = true;
}
[HarmonyPatch("PlayGame")]
[HarmonyPostfix]
private static void OnPlayGame()
{
ArcadeMenuPatch.CleanLevels();
}
}
public static class LevelLoaderHelper
{
public static IEnumerator LoadAudio(VGLevel level, string path)
{
DownloadHandlerAudioClip val = new DownloadHandlerAudioClip(path, (AudioType)14);
val.streamAudio = true;
UnityWebRequest audioUwr = new UnityWebRequest(path, "GET", (DownloadHandler)(object)val, (UploadHandler)null);
try
{
yield return audioUwr.SendWebRequest();
if ((int)audioUwr.result != 1)
{
LessRam.Logger.LogError((object)audioUwr.error);
}
else if (Object.op_Implicit((Object)(object)level))
{
AudioClip content = DownloadHandlerAudioClip.GetContent(audioUwr);
if (!Object.op_Implicit((Object)(object)content))
{
LessRam.Logger.LogError((object)("Remove invalid song from arcade. No audio file. [" + ((Object)level).name + "]"));
yield break;
}
ArcadeMenuPatch.activeClips.Add(content);
((Object)content).name = ((Object)level).name;
level.LevelMusic = content;
}
}
finally
{
((IDisposable)audioUwr)?.Dispose();
}
}
public static IEnumerator LoadImage(VGLevel level, string path)
{
Task<Sprite> spriteTask = Task.Run(() => InternalLoadImage(path));
while (!spriteTask.IsCompleted)
{
yield return null;
}
if (Object.op_Implicit((Object)(object)spriteTask.Result))
{
Sprite result = spriteTask.Result;
if (!Object.op_Implicit((Object)(object)level))
{
Object.Destroy((Object)(object)result.texture);
Object.Destroy((Object)(object)result);
}
else
{
ArcadeMenuPatch.activeSprites.Add(result);
level.AlbumArt = result;
}
}
}
private static async Task<Sprite?> InternalLoadImage(string path)
{
UnityWebRequest uwr = UnityWebRequestTexture.GetTexture(path, false);
try
{
SimpleCoroutineAwaiter<AsyncOperation> val = IEnumeratorAwaitExtensions.GetAwaiter((AsyncOperation)(object)uwr.SendWebRequest());
if (!val.IsCompleted)
{
await val;
object obj = default(object);
val = (SimpleCoroutineAwaiter<AsyncOperation>)obj;
}
val.GetResult();
if ((int)uwr.result != 1)
{
LessRam.Logger.LogError((object)uwr.error);
return null;
}
Texture2D content = DownloadHandlerTexture.GetContent(uwr);
int width = ((Texture)content).width;
int height = ((Texture)content).height;
if (width <= 512 && height <= 512 && width == height)
{
return Sprite.Create(content, new Rect(0f, 0f, (float)width, (float)height), new Vector2(0.5f, 0.5f), 72f, 0u, (SpriteMeshType)0);
}
return null;
}
finally
{
((IDisposable)uwr)?.Dispose();
}
}
}
public static class VGLevelExtension
{
public static bool InitSteamInfoFix(this VGLevel level, ulong _id, string _folder)
{
//IL_000b: Unknown result type (might be due to invalid IL or missing references)
//IL_0010: Unknown result type (might be due to invalid IL or missing references)
//IL_0012: Unknown result type (might be due to invalid IL or missing references)
//IL_0017: Unknown result type (might be due to invalid IL or missing references)
//IL_0021: Expected O, but got Unknown
//IL_0022: Unknown result type (might be due to invalid IL or missing references)
//IL_0027: Unknown result type (might be due to invalid IL or missing references)
//IL_0034: Unknown result type (might be due to invalid IL or missing references)
//IL_0040: Expected O, but got Unknown
if (string.IsNullOrEmpty(_folder))
{
return false;
}
level.SteamInfo = new SteamData
{
ItemID = PublishedFileId.op_Implicit(_id)
};
level.BaseLevelData = new LevelDataBase
{
LevelID = _id.ToString(),
LocalFolder = _folder
};
level.LevelData = level.BaseLevelData;
return true;
}
}
[BepInPlugin("me.ytarame.LessRam", "LessRam", "1.0.3")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class LessRam : BaseUnityPlugin
{
private Harmony _harmony;
private const string Guid = "me.ytarame.LessRam";
private const string Name = "LessRam";
private const string Version = "1.0.3";
internal static readonly Dictionary<string, VGLevelWrapper> Levels = new Dictionary<string, VGLevelWrapper>();
internal static ManualLogSource Logger;
internal static int SemaphoreCount = 5;
private void Awake()
{
//IL_0011: Unknown result type (might be due to invalid IL or missing references)
//IL_001b: Expected O, but got Unknown
//IL_0036: Unknown result type (might be due to invalid IL or missing references)
//IL_0042: Expected O, but got Unknown
Logger = ((BaseUnityPlugin)this).Logger;
_harmony = new Harmony("me.ytarame.LessRam");
_harmony.PatchAll();
SemaphoreCount = ((BaseUnityPlugin)this).Config.Bind<int>(new ConfigDefinition("LessRam", "Semaphore count"), 5, (ConfigDescription)null).Value;
Logger.LogInfo((object)"Plugin me.ytarame.LessRam is loaded!");
}
}
[HarmonyPatch(typeof(SteamWorkshopFacepunch))]
public static class SteamWorkshopPatch
{
private static object _lockObject = new object();
[HarmonyPatch("DownloadLevels")]
[HarmonyPrefix]
public static bool PreStart(SteamWorkshopFacepunch __instance, ref Task __result)
{
__result = LoadLevels(__instance);
return false;
}
private static async Task LoadLevels(SteamWorkshopFacepunch facepunch)
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
facepunch.TotalSteamWorkshopSubscriptions = 0;
facepunch.TotalSteamWorkshopSubscriptionsDone = 0;
SteamWorkshopFacepunch.inst.isLoadingLevels = true;
Query val = Query.ItemsReadyToUse;
val = ((Query)(ref val)).WhereUserSubscribed(default(SteamId));
Query q = ((Query)(ref val)).SortByCreationDate();
ResultPage? val2 = await ((Query)(ref q)).GetPageAsync(1);
if (!val2.HasValue)
{
stopWatch.Stop();
LessRam.Logger.LogError((object)$"Level loading failure [{stopWatch.ElapsedMilliseconds}]");
return;
}
facepunch.TotalSteamWorkshopSubscriptions = val2.Value.TotalCount;
ResultPage value = val2.Value;
foreach (Item entry in ((ResultPage)(ref value)).Entries)
{
Item current = entry;
if (SingletonBase<ArcadeManager>.Inst.skippedLoad)
{
return;
}
if (((Item)(ref current)).IsInstalled)
{
(VGLevel, VGLevelWrapper)? tuple = CreateEntry(facepunch, current);
if (tuple.HasValue)
{
LessRam.Levels.Add(((Object)tuple.Value.Item1).name, tuple.Value.Item2);
SingletonBase<ArcadeLevelDataManager>.Inst.ArcadeLevels.Add(tuple.Value.Item1);
SteamWorkshopFacepunch obj = facepunch;
obj.TotalSteamWorkshopSubscriptionsDone++;
}
}
}
int totalPages = Mathf.CeilToInt((float)val2.Value.TotalCount / (float)val2.Value.ResultCount);
SemaphoreSlim semaphore = new SemaphoreSlim(LessRam.SemaphoreCount);
try
{
List<Task> tasks = new List<Task>();
for (int i = 2; i < totalPages; i++)
{
await semaphore.WaitAsync();
LessRam.Logger.LogInfo((object)$"loading page {i}");
int iteration = i;
tasks.Add(Task.Run(async delegate
{
try
{
ResultPage? val3 = await ((Query)(ref q)).GetPageAsync(iteration);
if (!val3.HasValue)
{
LessRam.Logger.LogError((object)$"{iteration} no value");
return;
}
List<(VGLevel, VGLevelWrapper)> list = new List<(VGLevel, VGLevelWrapper)>(val3.Value.ResultCount);
ResultPage value2 = val3.Value;
foreach (Item entry2 in ((ResultPage)(ref value2)).Entries)
{
Item current2 = entry2;
if (SingletonBase<ArcadeManager>.Inst.skippedLoad)
{
return;
}
if (((Item)(ref current2)).IsInstalled)
{
(VGLevel, VGLevelWrapper)? tuple2 = CreateEntry(facepunch, current2);
if (tuple2.HasValue)
{
list.Add(tuple2.Value);
}
}
}
lock (_lockObject)
{
foreach (var item in list)
{
LessRam.Levels.Add(((Object)item.Item1).name, item.Item2);
SingletonBase<ArcadeLevelDataManager>.Inst.ArcadeLevels.Add(item.Item1);
SteamWorkshopFacepunch obj2 = facepunch;
obj2.TotalSteamWorkshopSubscriptionsDone++;
}
}
}
finally
{
LessRam.Logger.LogError((object)$"{iteration} Release");
semaphore.Release();
}
}));
}
await Task.WhenAll(tasks);
stopWatch.Stop();
SteamWorkshopFacepunch.inst.isLoadingLevels = false;
LessRam.Logger.LogInfo((object)$"Time to load levels [{stopWatch.ElapsedMilliseconds}ms]");
}
finally
{
if (semaphore != null)
{
((IDisposable)semaphore).Dispose();
}
}
}
private static (VGLevel, VGLevelWrapper)? CreateEntry(SteamWorkshopFacepunch facepunch, Item entry)
{
//IL_0002: Unknown result type (might be due to invalid IL or missing references)
//IL_0007: Unknown result type (might be due to invalid IL or missing references)
//IL_0047: Unknown result type (might be due to invalid IL or missing references)
//IL_0062: Unknown result type (might be due to invalid IL or missing references)
//IL_0067: Unknown result type (might be due to invalid IL or missing references)
VGLevelWrapper vGLevelWrapper = MakeLevelRealmObject(((object)((Item)(ref entry)).Id/*cast due to .constrained prefix*/).ToString(), ((Item)(ref entry)).Directory);
if (vGLevelWrapper == null)
{
return null;
}
VGLevel val = ScriptableObject.CreateInstance<VGLevel>();
if (val.InitArcadeData(((Item)(ref entry)).Directory) && val.InitSteamInfoFix(PublishedFileId.op_Implicit(((Item)(ref entry)).Id), ((Item)(ref entry)).Directory))
{
((Object)val).name = ((object)((Item)(ref entry)).Id/*cast due to .constrained prefix*/).ToString();
return (val, vGLevelWrapper);
}
return null;
}
private static VGLevelWrapper? MakeLevelRealmObject(string id, string directory)
{
if (string.IsNullOrEmpty(directory))
{
return null;
}
VGLevelWrapper obj = new VGLevelWrapper
{
LevelPath = directory
};
FileTypeDefinition fileTypeInfo = DataManager.inst.GetFileTypeInfo((FileType)5);
string text = directory + "\\" + fileTypeInfo.CurrentFile;
if (!LSFile.FileExists(text))
{
text = directory + "\\" + fileTypeInfo.LegacyFile;
}
obj.ImagePath = text;
FileTypeDefinition fileTypeInfo2 = DataManager.inst.GetFileTypeInfo((FileType)2);
string text2 = directory + "\\" + fileTypeInfo2.CurrentFile;
if (!LSFile.FileExists(text2))
{
text2 = directory + "\\" + fileTypeInfo2.LegacyFile;
}
obj.AudioPath = text2;
return obj;
}
}
[HarmonyPatch(typeof(ArcadeMenu))]
public static class ArcadeMenuPatch
{
private static List<Coroutine> activeCoroutines = new List<Coroutine>();
public static readonly List<Sprite> activeSprites = new List<Sprite>();
public static readonly List<AudioClip> activeClips = new List<AudioClip>();
[HarmonyPatch("SelectPage", new Type[]
{
typeof(int),
typeof(bool)
})]
[HarmonyPrefix]
private static bool PreSelectPage(int _page, bool _forceButton, ArcadeMenu __instance)
{
((MonoBehaviour)__instance).StartCoroutine(SelectPage(_page, _forceButton, __instance));
return false;
}
public static void CleanLevels()
{
foreach (Coroutine activeCoroutine in activeCoroutines)
{
if (activeCoroutine != null)
{
((MonoBehaviour)SingletonBase<ArcadeLevelDataManager>.Inst).StopCoroutine(activeCoroutine);
}
}
activeCoroutines.Clear();
int num = 0;
while (num < activeClips.Count)
{
if (Object.op_Implicit((Object)(object)activeClips[num]) && (Object)(object)SingletonBase<AudioManager>.Inst.CurrentAudioClip != (Object)(object)activeClips[num] && (!Object.op_Implicit((Object)(object)SingletonBase<ArcadeManager>.Inst.CurrentArcadeLevel) || (Object)(object)SingletonBase<ArcadeManager>.Inst.CurrentArcadeLevel.LevelMusic != (Object)(object)activeClips[num]))
{
Object.Destroy((Object)(object)activeClips[num]);
activeClips.RemoveAt(num);
}
else
{
num++;
}
}
int num2 = 0;
while (num2 < activeSprites.Count)
{
if (Object.op_Implicit((Object)(object)activeSprites[num2]) && (!Object.op_Implicit((Object)(object)SingletonBase<ArcadeManager>.Inst.CurrentArcadeLevel) || (Object)(object)SingletonBase<ArcadeManager>.Inst.CurrentArcadeLevel.AlbumArt != (Object)(object)activeSprites[num2]))
{
Object.Destroy((Object)(object)activeSprites[num2].texture);
Object.Destroy((Object)(object)activeSprites[num2]);
activeSprites.RemoveAt(num2);
}
else
{
num2++;
}
}
}
private static IEnumerator SelectPage(int _page, bool _forceButton, ArcadeMenu arcadeMenu)
{
CleanLevels();
if (arcadeMenu.Page != _page)
{
SingletonBase<AudioManager>.Inst.PlaySound("PageSwap", 1f);
}
if (arcadeMenu.SearchedLevels.Count <= 0)
{
if (arcadeMenu.SearchedLevels.Count > 0)
{
arcadeMenu.ShowNoResults();
}
else
{
arcadeMenu.ShowNoLevels();
}
}
else
{
if (_page < 0 || (arcadeMenu.SearchedLevels.Count > 0 && _page * 12 >= arcadeMenu.SearchedLevels.Count))
{
yield break;
}
if (((UIElement)arcadeMenu.NoResults).IsVisible)
{
((UIElement)arcadeMenu.NoResults).Hide((Action)null);
}
if (((UIElement)arcadeMenu.NoLevels).IsVisible)
{
((UIElement)arcadeMenu.NoLevels).Hide((Action)null);
}
if (((UIElement)arcadeMenu.KeyboardButtons[0].UIButton).IsVisible)
{
arcadeMenu.HideAllKeyboardButtons();
}
arcadeMenu.PageIsChanging = true;
((MonoBehaviour)arcadeMenu).StartCoroutine(arcadeMenu.DelayAnim(_forceButton));
arcadeMenu.Page = _page;
int num = _page * 12;
int num2 = Mathf.Clamp(num + 12, 0, arcadeMenu.SearchedLevels.Count - 1) - num;
arcadeMenu.PageSlider.UpdateValueAndRange((float)_page, new Vector2(0f, Mathf.Ceil((float)((arcadeMenu.SearchedLevels.Count - 1) / 12))), new Vector2(0f, 9f));
arcadeMenu.PageSlider.UpdateValue(false);
((Selectable)arcadeMenu.PageSlider.LeftButton).interactable = !arcadeMenu.IsFirstPage();
((Selectable)arcadeMenu.PageSlider.RightButton).interactable = !arcadeMenu.IsLastPage();
((Component)arcadeMenu.LeftPageTrigger).gameObject.SetActive(true);
((Component)arcadeMenu.RightPageTrigger).gameObject.SetActive(true);
((Selectable)arcadeMenu.LeftPageTrigger).interactable = !arcadeMenu.IsFirstPage();
((Selectable)arcadeMenu.RightPageTrigger).interactable = !arcadeMenu.IsLastPage();
int num3 = 0;
foreach (ArcadeButtonRefs button in arcadeMenu.LevelButtons)
{
if (num3 > num2)
{
button.Button.ClearActions();
button.Button.LockButtonState(true);
((UnityEventBase)((Button)button.Button).onClick).RemoveAllListeners();
if (((UIElement)button.LevelButton).IsVisible)
{
LSHelpers.Delay(Random.Range(0f, 0.025f), (Action)delegate
{
((UIElement)button.LevelButton).Hide((Action)null);
});
}
}
else
{
activeCoroutines.Add(((MonoBehaviour)SingletonBase<ArcadeLevelDataManager>.Inst).StartCoroutine(CreateButton(button, arcadeMenu.SearchedLevels[num + num3], arcadeMenu)));
}
num3++;
}
}
}
private static IEnumerator CreateButton(ArcadeButtonRefs button, VGLevel level, ArcadeMenu arcadeMenu)
{
VGLevelWrapper valueOrDefault = LessRam.Levels.GetValueOrDefault(((Object)level).name, null);
if (valueOrDefault != null)
{
Coroutine val = ((MonoBehaviour)arcadeMenu).StartCoroutine(LevelLoaderHelper.LoadAudio(level, valueOrDefault.AudioPath));
Coroutine coroutine2 = ((MonoBehaviour)arcadeMenu).StartCoroutine(LevelLoaderHelper.LoadImage(level, valueOrDefault.ImagePath));
yield return val;
yield return coroutine2;
}
DifficultySetting difficulty = arcadeMenu.GetDifficulty(level.Difficulty);
((Component)button.Button).GetComponent<DirectedNavigation>().Active = false;
button.Button.LockButtonState(true);
((UnityEventBase)((Button)button.Button).onClick).RemoveAllListeners();
button.Button.ClearActions();
button.Button.OnSelectButton += delegate
{
arcadeMenu.LastSelectedButtonOffset = 0;
arcadeMenu.LastSelectedButton = ((Component)button.Button).gameObject;
arcadeMenu.selectedLevelGO = ((Component)button.Button).gameObject;
arcadeMenu._songPreviewDebounce.Run((Action)delegate
{
arcadeMenu.PlaySongPreview(level);
}, 0.6f, (MonoBehaviour)(object)arcadeMenu);
};
button.Button.OnHoverEnterButton += delegate
{
arcadeMenu.LastSelectedButtonOffset = 0;
arcadeMenu.LastSelectedButton = ((Component)button.Button).gameObject;
arcadeMenu.selectedLevelGO = ((Component)button.Button).gameObject;
arcadeMenu._songPreviewDebounce.Run((Action)delegate
{
arcadeMenu.PlaySongPreview(level);
}, 0.3f, (MonoBehaviour)(object)arcadeMenu);
};
((UnityEvent)((Button)button.Button).onClick).AddListener((UnityAction)delegate
{
arcadeMenu.LastSelectedButtonOffset = 0;
arcadeMenu.LastSelectedButton = ((Component)button.Button).gameObject;
arcadeMenu.selectedLevelGO = ((Component)button.Button).gameObject;
if (SingletonBase<AudioManager>.Inst.currentSongGroup == level.TrackName)
{
arcadeMenu._songPreviewDebounce.ResetTime((MonoBehaviour)(object)arcadeMenu);
}
arcadeMenu.SetupSongMenu(level);
((Selectable)arcadeMenu.LeftPageTrigger).interactable = false;
((Selectable)arcadeMenu.RightPageTrigger).interactable = false;
arcadeMenu.SetSelectedGO((GameObject)null);
arcadeMenu.ViewManager.SwapPage("Song Menu");
});
button.LevelButton.UpdateTitle(LSText.ClampString(level.TrackName, 20, " -"));
button.LevelButton.UpdateDifficulty(difficulty);
button.LevelButton.UpdateAlbumArt(level.AlbumArt);
button.LevelButton.UpdateContent(arcadeMenu.getLevelButtonContent(level));
button.LevelButton.UpdateRank(SingletonBase<SavesManager>.Inst.FetchArcadeSave(level.LevelData.LevelID, true).LevelRank);
((UIElement)button.LevelButton).Stutter(true, (Action)null);
((UIElement)button.LevelButton).Show(0f, 0.1f);
((Component)button.Button).GetComponent<DirectedNavigation>().Active = true;
button.Button.LockButtonState(false);
}
}
[HarmonyPatch(typeof(ArcadeLevelDataManager))]
public static class ArcadeDataPatch
{
[HarmonyPatch("GetLocalCustomLevel")]
[HarmonyPostfix]
private static void preGetLevel(ArcadeLevelDataManager __instance, string _id, ref VGLevel __result)
{
if (Object.op_Implicit((Object)(object)__result) && !Object.op_Implicit((Object)(object)__result.LevelMusic))
{
VGLevelWrapper valueOrDefault = LessRam.Levels.GetValueOrDefault(_id, null);
if (valueOrDefault != null)
{
((MonoBehaviour)__instance).StartCoroutine(LevelLoaderHelper.LoadAudio(__result, valueOrDefault.AudioPath));
((MonoBehaviour)__instance).StartCoroutine(LevelLoaderHelper.LoadImage(__result, valueOrDefault.ImagePath));
}
}
}
}
[HarmonyPatch(typeof(LSText))]
public static class LSTextPatch
{
[HarmonyPatch("ClampString")]
[HarmonyPrefix]
private static bool PreClamp(ref string __result, string _inputStr, int _maxLength, string _end)
{
if (!SteamWorkshopFacepunch.inst.isLoadingLevels)
{
return true;
}
if (string.IsNullOrEmpty(_inputStr) || _inputStr.Length <= _maxLength)
{
__result = _inputStr;
return false;
}
StringBuilder stringBuilder = new StringBuilder();
if (_end == null)
{
stringBuilder.Append(_inputStr.Substring(0, _maxLength));
}
else
{
stringBuilder.Append(_inputStr.Substring(0, _maxLength - (_end.Length - 1)));
stringBuilder.Append(_end);
}
__result = stringBuilder.ToString();
return false;
}
}
public class VGLevelWrapper
{
public string ImagePath { get; set; }
public string AudioPath { get; set; }
public string LevelPath { get; set; }
}
public static class MyPluginInfo
{
public const string PLUGIN_GUID = "LessRam";
public const string PLUGIN_NAME = "LessRam";
public const string PLUGIN_VERSION = "1.0.0";
}
}
