using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyCompany("EasyDeliveryAPI")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("Modding API for truck game.")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("EasyDeliveryAPI")]
[assembly: AssemblyTitle("EasyDeliveryAPI")]
[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.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace EasyDeliveryAPI
{
	internal static class Configuration
	{
		public static ConfigEntry<bool> DragEnabled;

		public static ConfigEntry<bool> MoreEnabled;

		public static void Awake(ConfigFile Config)
		{
			DragEnabled = Config.Bind<bool>("General.Toggles", "DragEnabled", true, "Wether or not files can be dragged.");
			MoreEnabled = Config.Bind<bool>("General.Toggles", "MoreEnabled", true, "Wether or not files can be dragged.");
			DragEnabled.SettingChanged += delegate
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_001f: Expected O, but got Unknown
				Object[] array2 = Resources.FindObjectsOfTypeAll(typeof(DesktopDotExe));
				for (int j = 0; j < array2.Length; j++)
				{
					DesktopDotExe val2 = (DesktopDotExe)array2[j];
					val2.drag = DragEnabled.Value;
				}
			};
			MoreEnabled.SettingChanged += delegate
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Expected O, but got Unknown
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0047: Invalid comparison between Unknown and I4
				//IL_007e: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
				Object[] array = Resources.FindObjectsOfTypeAll(typeof(DesktopDotExe));
				for (int i = 0; i < array.Length; i++)
				{
					DesktopDotExe val = (DesktopDotExe)array[i];
					foreach (File file in val.files)
					{
						if ((int)file.type == 3 && file.name == "more")
						{
							if (!MoreEnabled.Value)
							{
								foreach (File file2 in ((Folder)file).files)
								{
									val.files.Add(file2);
								}
								((Folder)file).files.Clear();
							}
							file.visible = MoreEnabled.Value;
						}
					}
				}
			};
		}
	}
	internal class DesktopPatches : MonoBehaviour
	{
		[HarmonyPatch(typeof(DesktopDotExe), "Setup")]
		private class SetupPatch : HarmonyPatch
		{
			private static void Prefix(DesktopDotExe __instance)
			{
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b9: Expected O, but got Unknown
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c0: Expected O, but got Unknown
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_0227: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				EasyAPI.DesktopLocation desktopLocation = EasyAPI.DesktopLocation.Main;
				foreach (File file in __instance.files)
				{
					if (file.name == "more")
					{
						return;
					}
					if (file.name == "play")
					{
						desktopLocation = EasyAPI.DesktopLocation.MainMenu;
					}
					if (file.name == "birds")
					{
						desktopLocation = EasyAPI.DesktopLocation.Weird;
					}
					file.cantFolder = false;
				}
				if (Configuration.DragEnabled.Value)
				{
					__instance.drag = true;
				}
				File val = new File(((ScreenProgram)__instance).R, __instance);
				Folder val2 = new Folder(val);
				((File)val2).icon = 3;
				((File)val2).iconHover = 4;
				((File)val2).name = "more";
				((File)val2).position = new Vector2(6f, 4f);
				((File)val2).visible = Configuration.MoreEnabled.Value;
				__instance.files.Add((File)(object)val2);
				if (1 == 0)
				{
				}
				List<File> list = desktopLocation switch
				{
					EasyAPI.DesktopLocation.Main => EasyAPI.MainGameFiles, 
					EasyAPI.DesktopLocation.MainMenu => EasyAPI.MainMenuFiles, 
					EasyAPI.DesktopLocation.Weird => EasyAPI.WeirdAreaFiles, 
					_ => throw new Exception("Invalid file location(???) this shouldnt be remotely possible."), 
				};
				if (1 == 0)
				{
				}
				List<File> list2 = list;
				foreach (File item in list2)
				{
					__instance.files.Add(item);
				}
				if (EasyAPI.handler.data.Positions == null || EasyAPI.handler.data.InFolder == null)
				{
					return;
				}
				foreach (File file2 in __instance.files)
				{
					if (EasyAPI.handler.data.Positions.ContainsKey(file2.name))
					{
						simplevec2 simplevec3 = EasyAPI.handler.data.Positions[file2.name];
						file2.position = new Vector2(simplevec3.x, simplevec3.y);
					}
				}
			}

			private static void Postfix(DesktopDotExe __instance)
			{
				if (EasyAPI.handler.data.InFolder != null)
				{
					Folder val = null;
					List<File> list = new List<File>();
					foreach (File file3 in __instance.files)
					{
						if (file3.name == "more")
						{
							File obj = file3;
							val = (Folder)(object)((obj is Folder) ? obj : null);
						}
						else if ((EasyAPI.handler.data.InFolder.ContainsKey(file3.name) && EasyAPI.handler.data.InFolder[file3.name]) || (!EasyAPI.handler.data.InFolder.ContainsKey(file3.name) && (EasyAPI.WeirdAreaFiles.Any((File file2) => file3 == file2) || EasyAPI.MainGameFiles.Any((File file2) => file3 == file2))))
						{
							list.Add(file3);
						}
					}
					if (val != null && Configuration.MoreEnabled.Value)
					{
						foreach (File item in list)
						{
							val.files.Add(item);
							__instance.files.Remove(item);
						}
					}
				}
				foreach (GameObject listener in EasyAPI.Listeners)
				{
					GameObject val2 = Object.Instantiate<GameObject>(listener, ((Component)__instance).transform);
					((Object)val2).name = ((Object)listener).name;
					((Object)val2).hideFlags = (HideFlags)0;
				}
				foreach (GameObject value in EasyAPI.CustomOptionsMenus.Values)
				{
					GameObject val3 = Object.Instantiate<GameObject>(value, ((Component)__instance).transform);
					((Object)val3).name = "optionsmenu" + ((Object)value).name;
					((Object)val3).hideFlags = (HideFlags)0;
				}
				GameObject val4 = Object.Instantiate<GameObject>(EasyAPI.OptionsMenu.Item1, ((Component)__instance).transform);
				((Object)val4).name = ((Object)EasyAPI.OptionsMenu.Item1).name;
				((Object)val4).hideFlags = (HideFlags)0;
				GameObject val5 = Object.Instantiate<GameObject>(EasyAPI.OptionsMenu.Item2, ((Component)__instance).transform);
				((Object)val5).name = ((Object)EasyAPI.OptionsMenu.Item2).name;
				((Object)val5).hideFlags = (HideFlags)0;
			}
		}

		[HarmonyPatch(typeof(ScreenSystem), "Init")]
		private class SetupPatch2 : HarmonyPatch
		{
			private static void Prefix(ScreenSystem __instance)
			{
				List<ScreenProgram> list = __instance.programs.ToList();
				foreach (ScreenProgram program in EasyAPI.Programs)
				{
					ScreenProgram val = Object.Instantiate<ScreenProgram>(program);
					((Object)val).hideFlags = (HideFlags)0;
					((Behaviour)val).enabled = true;
					list.Add(val);
				}
				__instance.programs = list.ToArray();
			}
		}

		[HarmonyPatch(typeof(DesktopDotExe), "Draw")]
		private class SaveDataPatch : HarmonyPatch
		{
			private static void Prefix(DesktopDotExe __instance)
			{
				if (EasyAPI.handler.data.Positions == null)
				{
					EasyAPI.handler.data.Positions = new Dictionary<string, simplevec2>();
				}
				if (EasyAPI.handler.data.InFolder == null)
				{
					EasyAPI.handler.data.InFolder = new Dictionary<string, bool>();
				}
				Folder val = null;
				foreach (File file in __instance.files)
				{
					if (file.name == "more")
					{
						val = (Folder)(object)((file is Folder) ? file : null);
					}
					if (file.name != "play")
					{
						EasyAPI.handler.data.Positions[file.name] = new simplevec2(file.position.x, file.position.y);
						EasyAPI.handler.data.InFolder[file.name] = false;
					}
				}
				if (val == null)
				{
					return;
				}
				foreach (File file2 in val.files)
				{
					EasyAPI.handler.data.Positions.Remove(file2.name);
					EasyAPI.handler.data.InFolder[file2.name] = true;
				}
			}

			private static void Postfix()
			{
				bool flag = default(bool);
				for (int num = EasyAPI.OldWindowViewers.Count - 1; num > 0; num--)
				{
					WindowView val = EasyAPI.OldWindowViewers[num];
					val.Draw(ref flag);
					if (flag)
					{
						EasyAPI.OldWindowViewers.Remove(val);
					}
				}
			}
		}

		[HarmonyPatch(typeof(File), "Execute")]
		private class ExecutePatch : HarmonyPatch
		{
			private static bool Prefix(File __instance, out WindowView view)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0012: Invalid comparison between Unknown and I4
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003f: Expected O, but got Unknown
				view = null;
				__instance.notification = false;
				if ((int)__instance.type == 1)
				{
					if (__instance.data.Contains("listener_"))
					{
						view = new WindowView(__instance.M, __instance);
					}
					else if (__instance.data.Contains("modded_"))
					{
						for (int i = 0; i < ((ScreenProgram)__instance.M).screenSystem.programs.Length; i++)
						{
							ScreenProgram val = ((ScreenProgram)__instance.M).screenSystem.programs[i];
							if (val.title == __instance.data.Substring(7))
							{
								((ScreenProgram)__instance.M).screenSystem.SetMenu(i);
								((ScreenProgram)__instance.M).screenSystem.OpenMenu();
							}
						}
					}
					else
					{
						((ScreenProgram)__instance.M).screenSystem.SetMenu(int.Parse(__instance.data));
						((ScreenProgram)__instance.M).screenSystem.OpenMenu();
					}
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch]
		private class LockInput : HarmonyPatch
		{
			private static MethodInfo TargetMethod()
			{
				return typeof(sInputManager).GetMethod("GetInput", BindingFlags.Instance | BindingFlags.NonPublic);
			}

			private static void Postfix(sInputManager __instance)
			{
				if (Object.op_Implicit((Object)(object)EventSystem.current) && Object.op_Implicit((Object)(object)EventSystem.current.currentSelectedGameObject) && (Object)(object)EventSystem.current.currentSelectedGameObject.GetComponent<InputField>() != (Object)null)
				{
					LockInputMethod.Invoke(__instance, Array.Empty<object>());
					__instance.pausePressed = false;
				}
			}
		}

		[HarmonyPatch]
		private class InputFieldFix1 : HarmonyPatch
		{
			private static MethodInfo TargetMethod()
			{
				return typeof(InputField).GetMethod("IsValidChar", BindingFlags.Instance | BindingFlags.NonPublic);
			}

			private static bool Prefix(InputField __instance, char c, ref bool __result)
			{
				if (!Object.op_Implicit((Object)(object)__instance.textComponent))
				{
					__result = c != 0 && c != '\u007f';
					return false;
				}
				return true;
			}
		}

		internal static FieldInfo heldFile = typeof(DesktopDotExe).GetField("heldFile", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static FieldInfo clickedOn = typeof(File).GetField("clickedOn", BindingFlags.Instance | BindingFlags.NonPublic);

		private static MethodInfo LockInputMethod = typeof(sInputManager).GetMethod("LockInput", BindingFlags.Instance | BindingFlags.NonPublic);
	}
	public class ModdedSaveSystem<T> where T : struct
	{
		public delegate T parseSaveDelegate(object save);

		private string ModID;

		public T data;

		public parseSaveDelegate ParseSave;

		private void Save()
		{
			EasyAPI.ModdedSaveHandlers[ModID] = JsonConvert.SerializeObject((object)data);
		}

		private T defaultParse(object input)
		{
			return (T)input;
		}

		public ModdedSaveSystem(string modID)
		{
			ModID = modID;
			EasyAPI.ModsLoaded[modID] = true;
			EasyAPI.OnSave = (Action)Delegate.Combine(EasyAPI.OnSave, new Action(Save));
			EasyAPI.OnLoad = (Action<Dictionary<string, string>>)Delegate.Combine(EasyAPI.OnLoad, new Action<Dictionary<string, string>>(OnDataLoaded));
			ParseSave = defaultParse;
		}

		public void OnDataLoaded(Dictionary<string, string> string_data)
		{
			if (string_data.ContainsKey(ModID))
			{
				Load(string_data[ModID]);
			}
			else
			{
				data = new T();
			}
		}

		public void Load(string string_data)
		{
			object save = JsonConvert.DeserializeObject<T>(string_data);
			data = ParseSave(save);
			EasyAPI.ModdedSaveHandlers[ModID] = string_data;
		}
	}
	internal class ModSettingsMenu : MonoBehaviour
	{
		public WindowView windowViewer;

		private UIUtil util = new UIUtil();

		private int PageNum = 0;

		public void FrameUpdate(WindowView view)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			//IL_030b: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0351: Unknown result type (might be due to invalid IL or missing references)
			util.M = (ScreenProgram)(object)view.M;
			util.R = view.R;
			util.nav = view.M.nav;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(view.position * 8f, view.size * 8f);
			string text = "Page - " + PageNum;
			float num = text.Length * 8 / 2;
			float num2 = ((Rect)(ref val)).x + ((Rect)(ref val)).width / 2f;
			float num3 = 20f;
			float num4 = 12f;
			int num5 = (int)Math.Floor((((Rect)(ref val)).height - num3) / num4);
			if (util.Button("<", num2 - num - 8f, ((Rect)(ref val)).y + ((Rect)(ref val)).height - 8f, smol: true))
			{
				PageNum = Math.Max(PageNum - 1, 0);
			}
			util.R.put(text, num2 - num, ((Rect)(ref val)).y + ((Rect)(ref val)).height - 8f);
			if (util.Button(">", num2 + num, ((Rect)(ref val)).y + ((Rect)(ref val)).height - 8f, smol: true) && EasyAPI.ConfigList.Count > PageNum * num5)
			{
				PageNum++;
			}
			float num6 = 8f;
			List<string> list = EasyAPI.ConfigList.Keys.ToList();
			for (int i = 0; i < Math.Min(num5, EasyAPI.ConfigList.Count - PageNum * num5); i++)
			{
				string text2 = list[PageNum * num5 + i];
				ConfigFile targetFile = EasyAPI.ConfigList[text2];
				num = text2.Length * 8 / 2;
				if (util.Button(text2, num2 - num - 8f, ((Rect)(ref val)).y + num6, smol: true))
				{
					if (EasyAPI.CustomOptionsMenus.ContainsKey(text2))
					{
						windowViewer = EasyAPI.MakeWindow(view.M, text2, "optionsmenu" + text2);
					}
					else
					{
						ModSettingsPage.TargetFile = targetFile;
						ModSettingsPage.BuildVals();
						windowViewer = EasyAPI.MakeWindow(view.M, text2, "modsettingssingle");
					}
				}
				num6 += num4;
			}
			util.R.put("foxfoxfox.gay", ((Rect)(ref val)).x + ((Rect)(ref val)).width - (float)"foxfoxfox.gay".Length * 8f, ((Rect)(ref val)).y + ((Rect)(ref val)).height);
			if (windowViewer != null)
			{
				windowViewer.size = new Vector2(32f, 25f);
				if (!windowViewer.kill)
				{
					windowViewer.targetPosition = new Vector2(20f - windowViewer.size.x / 2f, 3f);
				}
				util.nav.zones.Clear();
				bool flag = default(bool);
				windowViewer.Draw(ref flag);
				if (flag)
				{
					windowViewer = null;
				}
			}
		}

		public void BackButtonPressed()
		{
			if (windowViewer != null && !windowViewer.kill)
			{
				windowViewer.Kill();
				((Component)util.M).SendMessage("InterruptBackButton", (SendMessageOptions)1);
				return;
			}
			ScreenProgram m = util.M;
			if (EasyAPI.ChangeWindow((DesktopDotExe)(object)((m is DesktopDotExe) ? m : null), "settings", "OptionsMenu"))
			{
				((Component)util.M).SendMessage("InterruptBackButton", (SendMessageOptions)1);
			}
		}
	}
	internal class ModSettingsPage : MonoBehaviour
	{
		public static List<Func<ConfigEntryBase, Func<UIUtil, float, float, ConfigEntryBase, string, string>>> CustomDrawHandler = new List<Func<ConfigEntryBase, Func<UIUtil, float, float, ConfigEntryBase, string, string>>>();

		public static ConfigFile TargetFile;

		private static Dictionary<string, InputField> Fields = new Dictionary<string, InputField>();

		private static List<(string, ConfigEntryBase, Func<UIUtil, float, float, ConfigEntryBase, string, string>)> builtVals = new List<(string, ConfigEntryBase, Func<UIUtil, float, float, ConfigEntryBase, string, string>)>();

		private int PageNum = 0;

		private UIUtil util = new UIUtil();

		private void DrawDescription(UIUtil util, Rect p, string str, string title)
		{
			int num = util.R.lget();
			util.R.lset(4);
			((Rect)(ref p)).y = ((Rect)(ref p)).y - 8f;
			float num2 = ((Rect)(ref p)).width / 8f - 2f;
			util.drawBox(((Rect)(ref p)).x / 8f, (((Rect)(ref p)).y + ((Rect)(ref p)).height) / 8f - 8f, num2, 7f, hasTop: false, title);
			util.R.spr(8f, 8f, ((Rect)(ref p)).x + 8f, ((Rect)(ref p)).y + ((Rect)(ref p)).height - 64f + 8f, 8f, 8f, false, num2 * 8f - 8f, 48f);
			string[] array = str.Split(new char[1] { '\n' });
			string text = "";
			for (int i = 0; i < array.Length; i++)
			{
				text += UIUtil.FormatLine(array[i], num2 - 2f);
				text += "\n";
			}
			util.R.put(text, ((Rect)(ref p)).x + 16f, ((Rect)(ref p)).y + ((Rect)(ref p)).height - 64f);
			util.R.lset(num);
		}

		private static string DrawBool(UIUtil util, float xpos, float ypos, ConfigEntryBase entry, string Name)
		{
			bool Hovered = false;
			bool? flag = util.Toggle(Name, entry.GetSerializedValue() == "true", xpos, ypos, out Hovered);
			if (flag.HasValue)
			{
				entry.SetSerializedValue(flag.Value.ToString());
			}
			return Hovered ? entry.Description.Description : null;
		}

		private static string DrawInt(UIUtil util, float xpos, float ypos, ConfigEntryBase entry, string Name)
		{
			bool Hovered = false;
			float? num = util.Adjustable(Name, entry.GetSerializedValue(), 1f, xpos, ypos, out Hovered);
			if (num.HasValue)
			{
				entry.SetSerializedValue((int.Parse(entry.GetSerializedValue()) + (int)num.Value).ToString());
			}
			return Hovered ? entry.Description.Description : null;
		}

		private static string DrawFloat(UIUtil util, float xpos, float ypos, ConfigEntryBase entry, string Name)
		{
			bool Hovered = false;
			float? num = util.Slider(Name, float.Parse(entry.GetSerializedValue()), xpos, ypos, out Hovered);
			if (num.HasValue)
			{
				entry.SetSerializedValue(num.Value.ToString());
			}
			return Hovered ? entry.Description.Description : null;
		}

		private static string DrawString(UIUtil util, float xpos, float ypos, ConfigEntryBase entry, string Name)
		{
			bool Hovered = false;
			util.R.put(Name + ": ", xpos - (float)((Name + ":").Length * 8), ypos);
			util.DrawInput(Fields[Name], "text here", xpos + 8f, ypos, out Hovered);
			return Hovered ? entry.Description.Description : null;
		}

		private static string DrawEnum(UIUtil util, float xpos, float ypos, ConfigEntryBase entry, string Name)
		{
			List<string> list = new List<string>();
			foreach (object value in Enum.GetValues(entry.SettingType))
			{
				list.Add(value.ToString());
			}
			bool Hovered = false;
			int num = list.IndexOf(entry.GetSerializedValue());
			num = ((num != -1) ? num : 0);
			string text = util.Dropdown(Name, num, list.ToArray(), xpos, ypos, out Hovered);
			if (text != null)
			{
				entry.SetSerializedValue(text);
			}
			return Hovered ? entry.Description.Description : null;
		}

		private static string DrawLabel(UIUtil util, float xpos, float ypos, ConfigEntryBase entry, string Name)
		{
			util.R.put(Name, xpos - (float)(Name.Length * 4), ypos);
			return null;
		}

		public static void BuildVals()
		{
			//IL_04b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ba: Expected O, but got Unknown
			foreach (KeyValuePair<string, InputField> field in Fields)
			{
				Object.Destroy((Object)(object)((Component)field.Value).gameObject);
			}
			builtVals.Clear();
			Fields.Clear();
			Dictionary<string, Dictionary<string, ConfigEntryBase>> dictionary = new Dictionary<string, Dictionary<string, ConfigEntryBase>>();
			Dictionary<string, Func<UIUtil, float, float, ConfigEntryBase, string, string>> dictionary2 = new Dictionary<string, Func<UIUtil, float, float, ConfigEntryBase, string, string>>();
			foreach (ConfigDefinition key in TargetFile.Keys)
			{
				Type settingType = TargetFile[key].SettingType;
				bool flag = false;
				foreach (Func<ConfigEntryBase, Func<UIUtil, float, float, ConfigEntryBase, string, string>> item2 in CustomDrawHandler)
				{
					Func<UIUtil, float, float, ConfigEntryBase, string, string> func = item2(TargetFile[key]);
					if (func != null)
					{
						dictionary2.Add(key.Key, func);
						if (!dictionary.ContainsKey(key.Section))
						{
							dictionary[key.Section] = new Dictionary<string, ConfigEntryBase>();
						}
						dictionary[key.Section][key.Key] = TargetFile[key];
						flag = true;
						break;
					}
				}
				if (!flag && (settingType.IsEnum || settingType == typeof(int) || settingType.IsEnum || settingType == typeof(bool) || settingType == typeof(string) || settingType == typeof(char) || settingType == typeof(double) || settingType == typeof(float)))
				{
					if (!dictionary.ContainsKey(key.Section))
					{
						dictionary[key.Section] = new Dictionary<string, ConfigEntryBase>();
					}
					dictionary[key.Section][key.Key] = TargetFile[key];
				}
			}
			List<string> list = dictionary.Keys.ToList();
			list.Sort();
			for (int i = 0; i < list.Count; i++)
			{
				string item = list[i];
				Dictionary<string, ConfigEntryBase> dictionary3 = dictionary[list[i]];
				builtVals.Add((item, null, DrawLabel));
				List<string> list2 = dictionary3.Keys.ToList();
				list2.Sort();
				for (int j = 0; j < list2.Count; j++)
				{
					string text = list2[j];
					ConfigEntryBase ConfigEntry = dictionary3[text];
					EasyAPI.Log.LogInfo((object)ConfigEntry.SettingType);
					if (dictionary2.ContainsKey(text))
					{
						builtVals.Add((text, ConfigEntry, dictionary2[text]));
					}
					else if (ConfigEntry.SettingType == typeof(bool))
					{
						builtVals.Add((text, ConfigEntry, DrawBool));
					}
					else if (ConfigEntry.SettingType == typeof(int))
					{
						builtVals.Add((text, ConfigEntry, DrawInt));
					}
					else if (ConfigEntry.SettingType == typeof(float))
					{
						builtVals.Add((text, ConfigEntry, DrawFloat));
					}
					else if (ConfigEntry.SettingType == typeof(string) || ConfigEntry.SettingType == typeof(char))
					{
						GameObject val = new GameObject();
						((Object)val).hideFlags = (HideFlags)61;
						InputField val2 = EasyAPI.MakeInputField(val);
						val2.text = ConfigEntry.GetSerializedValue();
						val2.characterLimit = ((!(ConfigEntry.SettingType == typeof(string))) ? 1 : 1600);
						((UnityEvent<string>)(object)val2.onSubmit).AddListener((UnityAction<string>)delegate(string submittedname)
						{
							ConfigEntry.SetSerializedValue(submittedname);
						});
						Fields.Add(text, val2);
						builtVals.Add((text, ConfigEntry, DrawString));
					}
					else if (ConfigEntry.SettingType.IsEnum)
					{
						builtVals.Add((text, ConfigEntry, DrawEnum));
					}
				}
			}
		}

		public void FrameUpdate(WindowView view)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			util.M = (ScreenProgram)(object)view.M;
			util.R = view.R;
			util.nav = view.M.nav;
			Rect val = default(Rect);
			((Rect)(ref val))..ctor(view.position * 8f, view.size * 8f);
			float num = 8f;
			int num2 = (int)Math.Floor((((Rect)(ref val)).height - 88f) / 12f);
			string str = "";
			string title = "";
			for (int i = 0; i < Math.Min(num2, builtVals.Count - PageNum * num2); i++)
			{
				(string, ConfigEntryBase, Func<UIUtil, float, float, ConfigEntryBase, string, string>) tuple = builtVals[i + PageNum * num2];
				string text = tuple.Item3(util, ((Rect)(ref val)).x + ((Rect)(ref val)).width / 2f, ((Rect)(ref val)).y + num, tuple.Item2, tuple.Item1);
				if (text != null)
				{
					str = text;
					(title, _, _) = tuple;
				}
				num += 12f;
			}
			Math.Min(num2, builtVals.Count - PageNum * num2);
			string text2 = "Page - " + PageNum;
			if (util.Button("<", ((Rect)(ref val)).x + ((Rect)(ref val)).width / 2f - 8f - (float)(text2.Length * 4), ((Rect)(ref val)).y + ((Rect)(ref val)).height - 72f, smol: true))
			{
				PageNum = Math.Max(PageNum - 1, 0);
			}
			util.R.put(text2, ((Rect)(ref val)).x + ((Rect)(ref val)).width / 2f - (float)(text2.Length * 4), ((Rect)(ref val)).y + ((Rect)(ref val)).height - 72f);
			if (util.Button(">", ((Rect)(ref val)).x + ((Rect)(ref val)).width / 2f + (float)text2.Length * 4f, ((Rect)(ref val)).y + ((Rect)(ref val)).height - 72f, smol: true) && builtVals.Count - 1 > (PageNum + 1) * num2)
			{
				PageNum++;
			}
			DrawDescription(util, new Rect(((Rect)(ref val)).x + 8f, ((Rect)(ref val)).y + 8f, ((Rect)(ref val)).width, ((Rect)(ref val)).height), str, title);
		}
	}
	internal struct simplevec2
	{
		public float x;

		public float y;

		public simplevec2(float x, float y)
		{
			this.x = x;
			this.y = y;
		}
	}
	internal struct filepositions
	{
		public Dictionary<string, simplevec2> Positions;

		public Dictionary<string, bool> InFolder;
	}
	[BepInPlugin("EasyDeliveryAPI", "EasyDeliveryAPI", "1.0.0")]
	public class EasyAPI : BaseUnityPlugin
	{
		[Flags]
		public enum DesktopLocation
		{
			Main = 0,
			MainMenu = 1,
			Weird = 2
		}

		internal static List<string> SaveFileNames = new List<string>();

		internal static Dictionary<string, string> ModdedSaveHandlers = new Dictionary<string, string>();

		internal static Action OnSave;

		internal static Action<Dictionary<string, string>> OnLoad;

		internal static Dictionary<string, bool> ModsLoaded = new Dictionary<string, bool>();

		internal static List<File> WeirdAreaFiles = new List<File>();

		internal static List<File> MainGameFiles = new List<File>();

		internal static List<File> MainMenuFiles = new List<File>();

		internal static List<ScreenProgram> Programs = new List<ScreenProgram>();

		internal static List<GameObject> Listeners = new List<GameObject>();

		internal static List<GameObject> sHUDListeners = new List<GameObject>();

		internal static (GameObject, GameObject) OptionsMenu;

		internal static Dictionary<string, GameObject> CustomOptionsMenus = new Dictionary<string, GameObject>();

		internal static Dictionary<string, ConfigFile> ConfigList = new Dictionary<string, ConfigFile>();

		internal static ModdedSaveSystem<filepositions> handler = new ModdedSaveSystem<filepositions>("EasyAPI");

		internal static ManualLogSource Log;

		private static MiniRenderer annoyingrenderer = new MiniRenderer();

		private static DesktopDotExe annoyingdesktop = new DesktopDotExe();

		internal static InputField RenameSaveFileInput;

		internal static FieldInfo windowViewer = typeof(DesktopDotExe).GetField("windowViewer", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static List<WindowView> OldWindowViewers = new List<WindowView>();

		private static MethodInfo UpdateFileName = typeof(sSaveSystem).GetMethod("UpdateFileName", BindingFlags.Instance | BindingFlags.NonPublic);

		public static WindowView MakeWindow(DesktopDotExe __instance, string name, string target)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			File val = InstantiateFile();
			val.data = "listener_" + target;
			val.name = name;
			val.openSound = __instance.select;
			return new WindowView(__instance, val);
		}

		public static bool ChangeWindow(DesktopDotExe __instance, string name, string target)
		{
			object? value = windowViewer.GetValue(__instance);
			WindowView val = (WindowView)((value is WindowView) ? value : null);
			if (val != null)
			{
				val.Kill();
				windowViewer.SetValue(__instance, MakeWindow(__instance, name, target));
				OldWindowViewers.Add(val);
				return true;
			}
			return false;
		}

		public static void FetchSaveNames()
		{
			List<string> list = new List<string>();
			string[] files = Directory.GetFiles(Application.persistentDataPath);
			foreach (string fileName in files)
			{
				FileInfo fileInfo = new FileInfo(fileName);
				if (fileInfo.Extension == ".txt" && fileInfo.Name.Length >= 22 && fileInfo.Name.Substring(0, 22) == "EasyDeliveryCoSaveData")
				{
					list.Add(fileInfo.Name.Substring(0, fileInfo.Name.Length - 4));
				}
			}
			list.Sort();
			SaveFileNames = list;
		}

		public static void AddProgram(ScreenProgram Program)
		{
			Programs.Add(Program);
		}

		public static T AddListener<T>(string Name) where T : Component
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			GameObject val = new GameObject(Name);
			T result = val.AddComponent<T>();
			((Object)val).hideFlags = (HideFlags)61;
			Listeners.Add(val);
			return result;
		}

		public static T AddCustomOptionsMenu<T>(string Name) where T : Component
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			GameObject val = new GameObject(Name);
			T result = val.AddComponent<T>();
			((Object)val).hideFlags = (HideFlags)61;
			CustomOptionsMenus.Add(Name, val);
			return result;
		}

		public static T AddsHUDListener<T>(string Name) where T : Component
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			GameObject val = new GameObject(Name);
			T result = val.AddComponent<T>();
			((Object)val).hideFlags = (HideFlags)61;
			sHUDListeners.Add(val);
			return result;
		}

		public static void AddConfig(string Name, ConfigFile target)
		{
			ConfigList.Add(Name, target);
		}

		public static InputField MakeInputField(GameObject Target)
		{
			return Target.AddComponent<InputField>();
		}

		public static File InstantiateFile()
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			return new File(annoyingrenderer, annoyingdesktop);
		}

		public static void AddFile(DesktopLocation Location, File File)
		{
			if ((Location & DesktopLocation.Main) == 0)
			{
				MainGameFiles.Add(File);
			}
			if ((Location & DesktopLocation.MainMenu) == DesktopLocation.MainMenu)
			{
				MainMenuFiles.Add(File);
			}
			if ((Location & DesktopLocation.Weird) == DesktopLocation.Weird)
			{
				WeirdAreaFiles.Add(File);
			}
		}

		public static void AddCustomSettingsDrawHandler(Func<ConfigEntryBase, Func<UIUtil, float, float, ConfigEntryBase, string, string>> Target)
		{
			ModSettingsPage.CustomDrawHandler.Add(Target);
		}

		private void Awake()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Expected O, but got Unknown
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			GameObject val = new GameObject();
			((Object)val).hideFlags = (HideFlags)61;
			RenameSaveFileInput = MakeInputField(val);
			RenameSaveFileInput.characterLimit = 12;
			((UnityEvent<string>)(object)RenameSaveFileInput.onSubmit).AddListener((UnityAction<string>)delegate(string submittedname)
			{
				string text = Application.persistentDataPath + "/EasyDeliveryCoSaveData_" + submittedname + ".txt";
				if (!File.Exists(text))
				{
					string destFileName = Application.persistentDataPath + "/modded-EasyDeliveryCoSaveData_" + submittedname + ".json";
					string text2 = Application.persistentDataPath + "/" + sSaveSystem.instance.saveFileName + ".txt";
					string text3 = Application.persistentDataPath + "/modded-" + sSaveSystem.instance.saveFileName + ".json";
					if (File.Exists(text2))
					{
						File.Copy(text2, text);
						if (File.Exists(text3))
						{
							File.Copy(text3, destFileName);
							File.Delete(text3);
						}
						File.Delete(text2);
					}
					sSaveSystem.instance.saveFileName = "EasyDeliveryCoSaveData_" + submittedname;
					UpdateFileName.Invoke(sSaveSystem.instance, Array.Empty<object>());
					FetchSaveNames();
				}
				else
				{
					RenameSaveFileInput.text = sSaveSystem.instance.saveFileName.Substring(23).Substring(0, Math.Min(sSaveSystem.instance.saveFileName.Length - 23, 12));
				}
			});
			Log = ((BaseUnityPlugin)this).Logger;
			Harmony val2 = new Harmony("EasyDesktopAPI");
			val2.PatchAll();
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Plugin EasyDeliveryAPI is loaded!");
			GameObject val3 = new GameObject("modsettingslist");
			val3.AddComponent<ModSettingsMenu>();
			((Object)val3).hideFlags = (HideFlags)61;
			GameObject val4 = new GameObject("modsettingssingle");
			val4.AddComponent<ModSettingsPage>();
			((Object)val4).hideFlags = (HideFlags)61;
			OptionsMenu = (val3, val4);
			Configuration.Awake(((BaseUnityPlugin)this).Config);
			AddConfig("easy delivery api", ((BaseUnityPlugin)this).Config);
			AddCustomSettingsDrawHandler(delegate(ConfigEntryBase Base)
			{
				Log.LogInfo((object)Base.Description.Tags.Length);
				if (Base.Description.Tags.Length != 0)
				{
					Log.LogInfo((object)"HIT!");
					return delegate(UIUtil util, float xpos, float ypos, ConfigEntryBase entry, string Name)
					{
						util.R.put(Name, xpos - (float)(Name.Length * 4), ypos);
						return null;
					};
				}
				return null;
			});
		}
	}
	internal class SavePatches : MonoBehaviour
	{
		[HarmonyPatch(typeof(IntroDotExe), "Awake")]
		private class AwakePatch : HarmonyPatch
		{
			private static void Prefix(IntroDotExe __instance)
			{
				PageNum = 0;
				Parent = __instance.saveFiles[0].transform.parent;
				GameObject[] saveFiles = __instance.saveFiles;
				foreach (GameObject val in saveFiles)
				{
					Object.Destroy((Object)(object)val);
				}
				__instance.saveFiles = Array.Empty<GameObject>();
				EasyAPI.FetchSaveNames();
			}
		}

		[HarmonyPatch]
		private class SelectorPatch : HarmonyPatch
		{
			private static MethodBase TargetMethod()
			{
				return typeof(IntroDotExe).GetMethod("FileSelectScreen", BindingFlags.Instance | BindingFlags.NonPublic);
			}

			private static bool Prefix(IntroDotExe __instance)
			{
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_0071: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
				//IL_010b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0123: Unknown result type (might be due to invalid IL or missing references)
				//IL_0129: Unknown result type (might be due to invalid IL or missing references)
				//IL_0163: Unknown result type (might be due to invalid IL or missing references)
				//IL_016f: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
				//IL_021e: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Unknown result type (might be due to invalid IL or missing references)
				object? value = nav.GetValue(__instance);
				GamepadNavigation pnav = (GamepadNavigation)((value is GamepadNavigation) ? value : null);
				UIUtil uIUtil = new UIUtil(((ScreenProgram)__instance).R, (ScreenProgram)(object)__instance, pnav);
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor((float)(((ScreenProgram)__instance).R.width / 2 - 64), (float)(((ScreenProgram)__instance).R.height / 2 - 32));
				float num = 16f;
				for (int i = 0; i < Math.Min(4, EasyAPI.SaveFileNames.Count - PageNum * 4); i++)
				{
					FileButton.Invoke(__instance, new object[5]
					{
						val.x,
						val.y + (num + 8f) * (float)(i % 4),
						128f,
						num,
						i + PageNum * 4
					});
				}
				((ScreenProgram)__instance).R.put("Page - " + PageNum, val.x + 32f, val.y - 12f);
				if (uIUtil.Button("<", val.x, val.y - 12f, smol: true) && PageNum > 0)
				{
					PageNum--;
				}
				if (uIUtil.Button(">", val.x + 122f, val.y - 12f, smol: true) && EasyAPI.SaveFileNames.Count > (PageNum + 1) * 4)
				{
					PageNum++;
				}
				if (uIUtil.Button("back", val.x, val.y + 90f))
				{
					GoBack.Invoke(__instance, Array.Empty<object>());
				}
				if (uIUtil.Button("refresh saves", val.x, val.y + 98f))
				{
					EasyAPI.FetchSaveNames();
				}
				if (uIUtil.Button("new save", val.x + 64f, val.y + 90f))
				{
					int num2 = EasyAPI.SaveFileNames.Count;
					string text = "";
					while (true)
					{
						text = "EasyDeliveryCoSaveData_File" + num2;
						if (!EasyAPI.SaveFileNames.Contains(text))
						{
							break;
						}
						num2++;
					}
					EasyAPI.SaveFileNames.Add(text);
					if (EasyAPI.SaveFileNames.Count > (PageNum + 1) * 4)
					{
						PageNum = EasyAPI.SaveFileNames.Count / 4;
					}
				}
				return false;
			}
		}

		[HarmonyPatch]
		private class ButtonPatch : HarmonyPatch
		{
			private static MethodBase TargetMethod()
			{
				return FileButton;
			}

			private static bool Prefix(IntroDotExe __instance, ref float x, float y, float w, float h, int index)
			{
				//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Expected O, but got Unknown
				string text = EasyAPI.SaveFileNames[index];
				text = ((text.Length > 23) ? text.Substring(23).Substring(0, Math.Min(text.Length - 23, 12)) : "File1");
				bool flag = false;
				int num = 96;
				object? value = nav.GetValue(__instance);
				GamepadNavigation pnav = (GamepadNavigation)((value is GamepadNavigation) ? value : null);
				UIUtil uIUtil = new UIUtil(((ScreenProgram)__instance).R, (ScreenProgram)(object)__instance, pnav);
				if (uIUtil.MouseOver(x, y, w, h))
				{
					num = 80;
					x += 4f;
					((ScreenProgram)__instance).mouseIcon = 128;
					flag = true;
					if (((ScreenProgram)__instance).mouseButton)
					{
						((ScreenProgram)__instance).mouseIcon = 160;
						x -= 4f;
					}
					if (((ScreenProgram)__instance).mouseButtonUp)
					{
						if (Object.op_Implicit((Object)(object)sSaveSystem.instance))
						{
							Object.Destroy((Object)(object)((Component)sSaveSystem.instance).gameObject);
						}
						GameObject val = new GameObject();
						val.SetActive(false);
						val.AddComponent<sSaveSystem>().saveFileName = EasyAPI.SaveFileNames[index];
						EasyAPI.RenameSaveFileInput.text = text;
						val.transform.SetParent(Parent.parent);
						selectedSaveFile.SetValue(__instance, val);
						val.SetActive(true);
						ToNextScreen.Invoke(__instance, Array.Empty<object>());
					}
				}
				((ScreenProgram)__instance).drawBox((x - 4f) / 8f, (y - 4f) / 8f, w / 8f, h / 8f);
				((ScreenProgram)__instance).R.put(text, x + 24f, y + h / 2f - 4f);
				((ScreenProgram)__instance).R.spr((float)num, 0f, x + 8f, y + 3f, 10f, 10f);
				return false;
			}
		}

		[HarmonyPatch]
		private class DeletePatch : HarmonyPatch
		{
			private static MethodBase TargetMethod()
			{
				return NewGame;
			}

			private static bool Prefix(IntroDotExe __instance)
			{
				string path = Application.persistentDataPath + "/" + sSaveSystem.instance.saveFileName + ".txt";
				string path2 = Application.persistentDataPath + "/modded-" + sSaveSystem.instance.saveFileName + ".json";
				InterSceneData val = Object.FindObjectOfType<InterSceneData>();
				if (Object.op_Implicit((Object)(object)val))
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
				Object.DestroyImmediate((Object)(object)sSaveSystem.instance);
				DeleteSaveAndGoBack.Invoke(__instance, Array.Empty<object>());
				if (File.Exists(path))
				{
					File.Delete(path);
					EasyAPI.FetchSaveNames();
				}
				if (File.Exists(path2))
				{
					File.Delete(path2);
				}
				return false;
			}
		}

		[HarmonyPatch]
		private class StartGamePatch : HarmonyPatch
		{
			private static MethodBase TargetMethod()
			{
				return typeof(IntroDotExe).GetMethod("StartGameScreen", BindingFlags.Instance | BindingFlags.NonPublic);
			}

			private static void Prefix(IntroDotExe __instance)
			{
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Unknown result type (might be due to invalid IL or missing references)
				Vector2 val = default(Vector2);
				((Vector2)(ref val))..ctor((float)(((ScreenProgram)__instance).R.width / 2 - 72), (float)(((ScreenProgram)__instance).R.height / 2 - 64));
				object? value = nav.GetValue(__instance);
				GamepadNavigation pnav = (GamepadNavigation)((value is GamepadNavigation) ? value : null);
				UIUtil uIUtil = new UIUtil(((ScreenProgram)__instance).R, (ScreenProgram)(object)__instance, pnav);
				if (!sSaveSystem.HasKey("deliveryMoney"))
				{
					string text = "";
					bool smol = false;
					if (uIUtil.Button("delete", val.x + 8f, val.y + 138f, smol))
					{
						NewGame.Invoke(__instance, Array.Empty<object>());
					}
				}
				string[] array = EasyAPI.ModdedSaveHandlers.Keys.ToArray();
				if (array.Length != 0)
				{
					((ScreenProgram)__instance).R.put("Mods:", (float)(((ScreenProgram)__instance).R.width / 2 + 72), (float)(((ScreenProgram)__instance).R.height / 2 - 64));
					int num = 12;
					string[] array2 = array;
					foreach (string text2 in array2)
					{
						((ScreenProgram)__instance).R.put(text2, (float)(((ScreenProgram)__instance).R.width / 2 + 72), (float)(((ScreenProgram)__instance).R.height / 2 - 64 + num));
						num += 12;
					}
				}
				uIUtil.DrawInput(EasyAPI.RenameSaveFileInput, "File Name", ((ScreenProgram)__instance).R.width / 2 - 64, ((ScreenProgram)__instance).R.height / 2 - 80);
			}
		}

		[HarmonyPatch(typeof(sSaveSystem), "SaveData")]
		private class SaveDataPatch : HarmonyPatch
		{
			private static void Postfix(sSaveSystem __instance)
			{
				string path = Application.persistentDataPath + "/modded-" + sSaveSystem.instance.saveFileName + ".json";
				Dictionary<string, string> dictionary = new Dictionary<string, string>();
				EasyAPI.OnSave?.Invoke();
				sSaveSystem.SetString("timeLastSaved", DateTime.Now.ToString());
				string text = JsonConvert.SerializeObject((object)EasyAPI.ModdedSaveHandlers);
				if (!File.Exists(path))
				{
					File.WriteAllText(path, text);
					Debug.Log((object)"Making new modded file - Saved Successfuwwy :3");
					return;
				}
				using (StreamWriter streamWriter = new StreamWriter(path, append: false))
				{
					streamWriter.Write(text);
				}
				Debug.Log((object)"Mods saved Successfuwwy :3");
			}
		}

		[HarmonyPatch]
		private class LoadDataPatch : HarmonyPatch
		{
			private static MethodInfo TargetMethod()
			{
				return typeof(sSaveSystem).GetMethod("ParseFileContents", BindingFlags.Instance | BindingFlags.NonPublic);
			}

			private static void Postfix(sSaveSystem __instance)
			{
				EasyAPI.ModdedSaveHandlers.Clear();
				string path = Application.persistentDataPath + "/modded-" + sSaveSystem.instance.saveFileName + ".json";
				if (!File.Exists(path))
				{
					return;
				}
				StreamReader streamReader = new StreamReader(path);
				string text = streamReader.ReadToEnd();
				streamReader.Close();
				Dictionary<string, string> dictionary = JsonConvert.DeserializeObject<Dictionary<string, string>>(text);
				foreach (KeyValuePair<string, string> item in dictionary)
				{
					if (!EasyAPI.ModsLoaded.ContainsKey(item.Key) || !EasyAPI.ModsLoaded[item.Key])
					{
						EasyAPI.ModdedSaveHandlers[item.Key] = item.Value;
					}
				}
				EasyAPI.OnLoad?.Invoke(dictionary);
			}
		}

		private static FieldInfo nav = typeof(IntroDotExe).GetField("nav", BindingFlags.Instance | BindingFlags.NonPublic);

		private static MethodInfo FileButton = typeof(IntroDotExe).GetMethod("FileButton", BindingFlags.Instance | BindingFlags.NonPublic);

		private static MethodInfo GoBack = typeof(IntroDotExe).GetMethod("GoBack", BindingFlags.Instance | BindingFlags.NonPublic);

		private static FieldInfo selectedSaveFile = typeof(IntroDotExe).GetField("selectedSaveFile", BindingFlags.Instance | BindingFlags.NonPublic);

		private static MethodInfo ToNextScreen = typeof(IntroDotExe).GetMethod("ToNextScreen", BindingFlags.Instance | BindingFlags.NonPublic);

		private static MethodInfo DeleteSaveAndGoBack = typeof(IntroDotExe).GetMethod("DeleteSaveAndGoBack", BindingFlags.Instance | BindingFlags.NonPublic);

		private static FieldInfo deleteConfirmation = typeof(IntroDotExe).GetField("deleteConfirmation", BindingFlags.Instance | BindingFlags.NonPublic);

		private static MethodInfo stopDeleteConfirmation = typeof(IntroDotExe).GetMethod("stopDeleteConfirmation", BindingFlags.Instance | BindingFlags.NonPublic);

		private static MethodInfo startDeleteConfirmation = typeof(IntroDotExe).GetMethod("startDeleteConfirmation", BindingFlags.Instance | BindingFlags.NonPublic);

		private static MethodInfo NewGame = typeof(IntroDotExe).GetMethod("NewGame", BindingFlags.Instance | BindingFlags.NonPublic);

		private static int PageNum = 0;

		private static Transform Parent;
	}
	internal class sHUDPatches : MonoBehaviour
	{
		[HarmonyPatch(typeof(sHUD), "Init")]
		private class InitPatch : HarmonyPatch
		{
			private static void Postfix(DesktopDotExe __instance)
			{
				foreach (GameObject listener in EasyAPI.Listeners)
				{
					GameObject val = Object.Instantiate<GameObject>(listener, ((Component)__instance).transform);
					((Object)val).name = ((Object)listener).name;
					((Object)val).hideFlags = (HideFlags)0;
				}
			}
		}

		[HarmonyPatch(typeof(sHUD), "FrameUpdate")]
		private class FramePatch : HarmonyPatch
		{
			private static void Postfix(sHUD __instance)
			{
				foreach (GameObject sHUDListener in EasyAPI.sHUDListeners)
				{
					GameObject.Find(((Object)sHUDListener).name).gameObject.SendMessage("FrameUpdate", (object)__instance);
				}
			}
		}

		internal static FieldInfo heldFile = typeof(DesktopDotExe).GetField("heldFile", BindingFlags.Instance | BindingFlags.NonPublic);

		internal static FieldInfo clickedOn = typeof(File).GetField("clickedOn", BindingFlags.Instance | BindingFlags.NonPublic);
	}
	internal class UIPatches
	{
		[HarmonyPatch(typeof(GamepadNavigation), "GetZone")]
		private class GamepadPatch : HarmonyPatch
		{
			private static bool Prefix(GamepadNavigation __instance, Vector2 input, out Rect __result)
			{
				//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_0033: 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_0070: Unknown result type (might be due to invalid IL or missing references)
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_0091: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: 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_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
				//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_0127: Unknown result type (might be due to invalid IL or missing references)
				//IL_012b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0130: Unknown result type (might be due to invalid IL or missing references)
				//IL_0135: Unknown result type (might be due to invalid IL or missing references)
				//IL_0136: Unknown result type (might be due to invalid IL or missing references)
				//IL_013b: Unknown result type (might be due to invalid IL or missing references)
				//IL_013d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_0146: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0151: Unknown result type (might be due to invalid IL or missing references)
				//IL_0157: Unknown result type (might be due to invalid IL or missing references)
				//IL_015c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0161: Unknown result type (might be due to invalid IL or missing references)
				//IL_0177: Unknown result type (might be due to invalid IL or missing references)
				//IL_017c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
				Rect val = (hoveredZones.GetValue(__instance) as List<Rect>)[0];
				if ((double)((Vector2)(ref input)).magnitude < 0.4)
				{
					__result = val;
					return false;
				}
				object? value = program.GetValue(__instance);
				ScreenProgram val2 = (ScreenProgram)((value is ScreenProgram) ? value : null);
				if (val2.mouseButton)
				{
					__result = val;
					return false;
				}
				input.y = 0f - input.y;
				List<(Rect, float, float)> list = new List<(Rect, float, float)>();
				Vector2 normalized = ((Vector2)(ref input)).normalized;
				float num = 10000f;
				Rect val3 = val;
				Vector2 val4 = default(Vector2);
				foreach (Rect zone in __instance.zones)
				{
					Rect current = zone;
					if (!((double)Vector2.Dot(((Rect)(ref current)).center - ((Rect)(ref val)).center, normalized) < 0.1))
					{
						((Vector2)(ref val4))..ctor(Mathf.Clamp(((Rect)(ref val)).center.x, ((Rect)(ref current)).xMin, ((Rect)(ref current)).xMax), Mathf.Clamp(((Rect)(ref val)).center.y, ((Rect)(ref current)).yMin, ((Rect)(ref current)).yMax));
						Vector2 val5 = (val4 - ((Rect)(ref val)).center) * normalized;
						Vector2 val6 = (val4 - ((Rect)(ref val)).center) * new Vector2(normalized.y, normalized.x);
						Vector2 val7 = new Vector2(((Vector2)(ref val6)).magnitude * 100f, ((Vector2)(ref val5)).magnitude);
						float magnitude = ((Vector2)(ref val7)).magnitude;
						if (!(magnitude < 1f) && magnitude < num)
						{
							num = magnitude;
							val3 = current;
						}
					}
				}
				__result = val3;
				return false;
			}
		}

		[HarmonyPatch(typeof(GamepadNavigation), "GoToZone")]
		private class DragPatch : HarmonyPatch
		{
			private static bool Prefix(GamepadNavigation __instance)
			{
				//IL_003d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_004d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0057: Unknown result type (might be due to invalid IL or missing references)
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006b: 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_0075: Unknown result type (might be due to invalid IL or missing references)
				if ((double)((Vector2)(ref __instance.menuInput)).magnitude < 0.4)
				{
					return false;
				}
				object? value = program.GetValue(__instance);
				ScreenProgram val = (ScreenProgram)((value is ScreenProgram) ? value : null);
				if (val.mouseButton)
				{
					ScreenSystem.mouse += __instance.menuInput * Time.deltaTime * 100f * new Vector2(1f, -1f);
					return false;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(GamepadNavigation), "DoZones")]
		private class DragPatch2 : HarmonyPatch
		{
			private static void Postfix(GamepadNavigation __instance)
			{
				//IL_0028: 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_0038: 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)
				//IL_0051: Unknown result type (might be due to invalid IL or missing references)
				//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_0060: Unknown result type (might be due to invalid IL or missing references)
				object? value = program.GetValue(__instance);
				ScreenProgram val = (ScreenProgram)((value is ScreenProgram) ? value : null);
				if (!__instance.menuInputChanged && val.mouseButton)
				{
					ScreenSystem.mouse += __instance.menuInput * Time.deltaTime * 100f * new Vector2(1f, -1f);
				}
			}
		}

		[HarmonyPatch]
		private class SliderFix : HarmonyPatch
		{
			private static MethodInfo TargetMethod()
			{
				return typeof(sOptionsMenu).GetMethod("Slider", BindingFlags.Instance | BindingFlags.NonPublic);
			}

			private static bool Prefix(sOptionsMenu __instance, string name, float value, float x, float y, Action<float> action)
			{
				object? value2 = R.GetValue(__instance);
				MiniRenderer val = (MiniRenderer)((value2 is MiniRenderer) ? value2 : null);
				object? value3 = M.GetValue(__instance);
				DesktopDotExe val2 = (DesktopDotExe)((value3 is DesktopDotExe) ? value3 : null);
				int num = 10;
				for (int i = 0; i < num; i++)
				{
					val.spr(32f, 0f, x + 4f + (float)(i * 8), y, 8f, 8f);
				}
				float num2 = x + value * (float)num * 8f;
				val.spr(0f, 24f, num2, y, 8f, 8f);
				if (val2.MouseOver((int)x - 8, (int)y, num * 8 + 16, 8))
				{
					((ScreenProgram)val2).mouseIcon = 128;
					name = ">" + name;
					if (((ScreenProgram)val2).mouseButton)
					{
						if (val2.nav.menuInput.x < 0f)
						{
							action(Mathf.Clamp01(value - Time.unscaledDeltaTime / 2f));
						}
						if (val2.nav.menuInput.x > 0f)
						{
							action(Mathf.Clamp01(value + Time.unscaledDeltaTime / 2f));
						}
						((ScreenProgram)val2).mouseIcon = 160;
						value = Mathf.InverseLerp(x + 4f, x + 4f + (float)(num * 8), ((ScreenProgram)val2).mouse.x);
						value = Mathf.Clamp01(value);
						action(value);
					}
				}
				val.put(name, x - (float)(name.Length * 8) - 4f, y);
				return false;
			}
		}

		[HarmonyPatch]
		private class OptionsPatch : HarmonyPatch
		{
			private static MethodInfo TargetMethod()
			{
				return typeof(sOptionsMenu).GetMethod("DrawMenu", BindingFlags.Instance | BindingFlags.NonPublic);
			}

			private static void Prefix(sOptionsMenu __instance, Rect p)
			{
				object? value = M.GetValue(__instance);
				DesktopDotExe val = (DesktopDotExe)((value is DesktopDotExe) ? value : null);
				object? value2 = R.GetValue(__instance);
				MiniRenderer pR = (MiniRenderer)((value2 is MiniRenderer) ? value2 : null);
				UIUtil uIUtil = new UIUtil(pR, (ScreenProgram)(object)val, val.nav);
				float num = ((Rect)(ref p)).x + ((Rect)(ref p)).width / 2f - 16f;
				float num2 = ((Rect)(ref p)).y + 10f;
				uIUtil.nav.Add(((Rect)(ref p)).x + ((Rect)(ref p)).width - 40f, ((Rect)(ref p)).y + ((Rect)(ref p)).height - 84f, 1000f, 8f);
				if (uIUtil.Button("mods", ((Rect)(ref p)).x + ((Rect)(ref p)).width - 40f, ((Rect)(ref p)).y + ((Rect)(ref p)).height - 8f, smol: true))
				{
					EasyAPI.ChangeWindow(val, "modded settings", "modsettingslist");
				}
			}
		}

		private static FieldInfo M = typeof(sOptionsMenu).GetField("M", BindingFlags.Instance | BindingFlags.NonPublic);

		private static FieldInfo R = typeof(sOptionsMenu).GetField("R", BindingFlags.Instance | BindingFlags.NonPublic);

		private static FieldInfo hoveredZones = typeof(GamepadNavigation).GetField("hoveredZones", BindingFlags.Instance | BindingFlags.NonPublic);

		private static FieldInfo program = typeof(GamepadNavigation).GetField("program", BindingFlags.Instance | BindingFlags.NonPublic);
	}
	public class UIUtil
	{
		private static MethodInfo ActivateInputFieldInternal = typeof(InputField).GetMethod("ActivateInputFieldInternal", BindingFlags.Instance | BindingFlags.NonPublic);

		public bool NavEnabled;

		public ScreenProgram M;

		public GamepadNavigation nav;

		public MiniRenderer R;

		public bool MouseOver(float x, float y, float w, float h)
		{
			bool flag = M.mouse.x > x && M.mouse.x < x + w;
			bool flag2 = M.mouse.y > y && M.mouse.y < y + h;
			nav.Add(x, y, w, h);
			return flag && flag2;
		}

		public bool MouseOver(int x, int y, int w, int h)
		{
			bool flag = M.mouse.x > (float)x && M.mouse.x < (float)(x + w);
			bool flag2 = M.mouse.y > (float)y && M.mouse.y < (float)(y + h);
			nav.Add((float)x, (float)y, (float)w, (float)h);
			return flag && flag2;
		}

		public float? Adjustable(string name, string value, float delta, float x, float y)
		{
			bool Hovered;
			return Adjustable(name, value, delta, x, y, out Hovered);
		}

		public float? Adjustable(string name, string value, float delta, float x, float y, out bool Hovered)
		{
			x -= 4f;
			Hovered = false;
			float? result = null;
			R.put(name, x - (float)(name.Length * 8), y);
			if (Button("[-]", x - (float)(name.Length * 8) - 24f, y, out Hovered, smol: true))
			{
				result = delta * -1f;
			}
			x += 32f;
			R.put(value, x - (float)(value.Length * 8), y);
			string name2 = "[+]";
			if (Button(name2, x, y, out Hovered, smol: true))
			{
				result = delta;
			}
			return result;
		}

		public bool Button(string name, float x, float y, bool smol = false, bool manualhover = false)
		{
			bool Hovered;
			return Button(name, x, y, out Hovered, smol, manualhover);
		}

		public bool Button(string name, float x, float y, out bool Hovered, bool smol = false, bool manualhover = false)
		{
			Hovered = false;
			bool result = false;
			if (MouseOver((int)x - 2, (int)y, name.Length * 8 + 4, 8))
			{
				Hovered = true;
				if (!smol)
				{
					x += 4f;
					name = ">" + name;
				}
				M.mouseIcon = 128;
				if (M.mouseButton)
				{
					M.mouseIcon = 160;
				}
				if (M.mouseButtonUp)
				{
					result = true;
				}
			}
			else if (manualhover)
			{
				x += 4f;
				name = ">" + name;
			}
			R.put(name, x, y);
			return result;
		}

		public void DrawInput(InputField Field, string PlaceholderText, float x, float y)
		{
			DrawInput(Field, PlaceholderText, x, y, out var _);
		}

		public void DrawInput(InputField Field, string PlaceholderText, float x, float y, out bool Hovered)
		{
			Hovered = false;
			if (Button((Field.text == "") ? PlaceholderText : Field.text, x, y, out Hovered, smol: false, Field.isFocused))
			{
				ActivateInputFieldInternal.Invoke(Field, Array.Empty<object>());
			}
		}

		public string Dropdown(string name, int value, string[] options, float x, float y)
		{
			bool Hovered;
			return Dropdown(name, value, options, x, y, out Hovered);
		}

		public string Dropdown(string name, int value, string[] options, float x, float y, out bool Hovered)
		{
			Hovered = false;
			string result = null;
			string text = "[" + options[value] + "]";
			R.put(text, x + 4f, y);
			if (MouseOver((int)x - 2, (int)y, text.Length * 8 + 4, 8))
			{
				Hovered = true;
				M.mouseIcon = 128;
				name = ">" + name;
				if (M.mouseButton)
				{
					M.mouseIcon = 160;
				}
				if (M.mouseButtonUp)
				{
					result = options[(value + 1) % options.Length];
				}
			}
			R.put(name, x - (float)(name.Length * 8) - 4f, y);
			return result;
		}

		public bool? Toggle(string name, bool state, float x, float y, out bool Hovered)
		{
			Hovered = false;
			return Toggle(name, state, x, y, "on", "off", out Hovered);
		}

		public bool? Toggle(string name, bool state, float x, float y)
		{
			bool Hovered;
			return Toggle(name, state, x, y, "on", "off", out Hovered);
		}

		public bool? Toggle(string name, bool state, float x, float y, string on, string off)
		{
			bool Hovered;
			return Toggle(name, state, x, y, on, off, out Hovered);
		}

		public bool? Toggle(string name, bool state, float x, float y, string on, string off, out bool Hovered)
		{
			Hovered = false;
			bool? result = null;
			string text = "[" + (state ? on : off) + "]";
			R.put(text, x + 4f, y);
			if (MouseOver((int)x - 2, (int)y, text.Length * 8 + 4, 8))
			{
				Hovered = true;
				M.mouseIcon = 128;
				name = ">" + name;
				if (M.mouseButton)
				{
					M.mouseIcon = 160;
				}
				if (M.mouseButtonUp)
				{
					result = !state;
				}
			}
			R.put(name, x - (float)(name.Length * 8) - 4f, y);
			return result;
		}

		public float? Slider(string name, float value, float x, float y)
		{
			bool Hovered;
			return Slider(name, value, x, y, out Hovered);
		}

		public float? Slider(string name, float value, float x, float y, out bool Hovered)
		{
			Hovered = false;
			float? result = null;
			int num = 10;
			for (int i = 0; i < num; i++)
			{
				R.spr(32f, 0f, x + 4f + (float)(i * 8), y, 8f, 8f);
			}
			float num2 = x + value * (float)num * 8f;
			R.spr(0f, 24f, num2, y, 8f, 8f);
			if (MouseOver((int)x - 8, (int)y, num * 8 + 16, 8))
			{
				Hovered = true;
				M.mouseIcon = 128;
				name = ">" + name;
				if (M.mouseButton)
				{
					if (nav.menuInput.x < 0f)
					{
						result = Mathf.Clamp01(value - Time.unscaledDeltaTime / 2f);
					}
					if (nav.menuInput.x > 0f)
					{
						result = Mathf.Clamp01(value + Time.unscaledDeltaTime / 2f);
					}
					M.mouseIcon = 160;
					value = Mathf.InverseLerp(x + 4f, x + 4f + (float)(num * 8), M.mouse.x);
					value = Mathf.Clamp01(value);
					result = value;
				}
			}
			R.put(name, x - (float)(name.Length * 8) - 4f, y);
			return result;
		}

		public static string FormatLine(string input, float w)
		{
			string[] array = input.Split(new char[1] { ' ' });
			string text = array[0];
			string text2 = "";
			for (int i = 1; i < array.Length; i++)
			{
				if ((float)(text.Length + array[i].Length) <= w)
				{
					text = text + " " + array[i];
					continue;
				}
				text2 = text2 + "\n" + text;
				text = array[i];
			}
			return text2 + "\n" + text;
		}

		public void tile(float sx, float sy, float x, float y)
		{
			R.spr(sx, sy, x * 8f, y * 8f, 8f, 8f);
		}

		public static void tile(MiniRenderer R, float sx, float sy, float x, float y)
		{
			R.spr(sx, sy, x * 8f, y * 8f, 8f, 8f);
		}

		public void drawBox(float x, float y, float w, float h, bool hasTop)
		{
			int num = (hasTop ? 24 : 0);
			int num2 = (hasTop ? 16 : 0);
			for (int i = (int)x + 1; (float)i < x + w; i++)
			{
				tile(8 + num, num2, i, y);
				tile(8f, 16f, i, y + h);
			}
			for (int j = (int)y + 1; (float)j < y + h; j++)
			{
				tile(0f, 8f, x, j);
				tile(16f, 8f, x + w, j);
			}
			tile(0f, 16f, x, y + h);
			tile(16f, 16f, x + w, y + h);
			tile(num, num2, x, y);
			tile(16 + num, num2, x + w, y);
		}

		public static void drawBox(MiniRenderer R, float x, float y, float w, float h, bool hasTop)
		{
			int num = (hasTop ? 24 : 0);
			int num2 = (hasTop ? 16 : 0);
			for (int i = (int)x + 1; (float)i < x + w; i++)
			{
				tile(R, 8 + num, num2, i, y);
				tile(R, 8f, 16f, i, y + h);
			}
			for (int j = (int)y + 1; (float)j < y + h; j++)
			{
				tile(R, 0f, 8f, x, j);
				tile(R, 16f, 8f, x + w, j);
			}
			tile(R, 0f, 16f, x, y + h);
			tile(R, 16f, 16f, x + w, y + h);
			tile(R, num, num2, x, y);
			tile(R, 16 + num, num2, x + w, y);
		}

		public static void drawBox(MiniRenderer R, float x, float y, float w, float h, bool hasTop, string title)
		{
			drawBox(R, x, y, w, h, hasTop);
			R.put(title, x * 8f + 8f, y * 8f);
		}

		public void drawBox(float x, float y, float w, float h, bool hasTop, string title)
		{
			drawBox(x, y, w, h, hasTop);
			R.put(title, x * 8f + 8f, y * 8f);
		}

		public UIUtil(MiniRenderer PR, ScreenProgram PM, GamepadNavigation pnav)
		{
			R = PR;
			M = PM;
			nav = pnav;
		}

		public UIUtil()
		{
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "EasyDeliveryAPI";

		public const string PLUGIN_NAME = "EasyDeliveryAPI";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}