using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Numerics;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Threading.Tasks;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DearImGuiInjection;
using DearImGuiInjection.BepInEx;
using HarmonyLib;
using ImGuiNET;
using Photon.Pun;
using Photon.Realtime;
using UnityEngine;
using UnityEngine.SceneManagement;
using Zorro.Core;
using Zorro.Core.Serizalization;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("PEAK-AIO")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("PEAK-AIO")]
[assembly: AssemblyCopyright("Copyright ©  2025")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("0e070e16-c355-4db0-804c-0510a5aa436e")]
[assembly: AssemblyFileVersion("1.0.2.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.2.0")]
[module: UnverifiableCode]
public static class ConfigManager
{
	public static ManualLogSource Logger;

	public static ConfigEntry<bool> InfiniteStamina;

	public static ConfigEntry<bool> FlyMod;

	public static ConfigEntry<float> FlySpeed;

	public static ConfigEntry<float> FlyAcceleration;

	public static ConfigEntry<bool> LockStatus;

	public static ConfigEntry<bool> NoWeight;

	public static ConfigEntry<bool> SpeedMod;

	public static ConfigEntry<bool> JumpMod;

	public static ConfigEntry<bool> NoFallDmg;

	public static ConfigEntry<bool> ClimbMod;

	public static ConfigEntry<bool> VineClimbMod;

	public static ConfigEntry<bool> RopeClimbMod;

	public static ConfigEntry<float> SpeedAmount;

	public static ConfigEntry<float> JumpAmount;

	public static ConfigEntry<float> ClimbAmount;

	public static ConfigEntry<float> VineClimbAmount;

	public static ConfigEntry<float> RopeClimbAmount;

	public static ConfigEntry<float> RechargeAmountSlot1;

	public static ConfigEntry<float> RechargeAmountSlot2;

	public static ConfigEntry<float> RechargeAmountSlot3;

	public static ConfigEntry<bool> TeleportToPing;

	public static ConfigEntry<KeyCode> MenuToggleKey;

	public static ConfigEntry<int> LanguageIndex;

	public static void Init(ConfigFile config, ManualLogSource logger)
	{
		//IL_021c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0226: Expected O, but got Unknown
		//IL_0254: Unknown result type (might be due to invalid IL or missing references)
		//IL_025e: Expected O, but got Unknown
		//IL_028c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0296: Expected O, but got Unknown
		//IL_02b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02c2: Expected O, but got Unknown
		Logger = logger;
		MenuToggleKey = config.Bind<KeyCode>("General", "MenuToggleKey", (KeyCode)277, "Key to toggle the mod menu overlay. Uses UnityEngine.KeyCode names (e.g. Insert, F1, F2, Home, RightShift).");
		InfiniteStamina = config.Bind<bool>("Cheats", "InfiniteStamina", false, "Enable infinite stamina");
		TeleportToPing = config.Bind<bool>("Cheats", "TeleportToPing", false, "Automatically teleport to ping location");
		FlyMod = config.Bind<bool>("Cheats", "Fly Mod", false, "Enables fly mode when checked.");
		FlySpeed = config.Bind<float>("Cheats", "Fly Speed", 100f, "Speed used when flying.");
		FlyAcceleration = config.Bind<float>("Cheats", "Fly Acceleration", 300f, "Acceleration used when flying.");
		LockStatus = config.Bind<bool>("Afflictions", "LockStatus", false, (ConfigDescription)null);
		NoWeight = config.Bind<bool>("Afflictions", "NoWeight", false, (ConfigDescription)null);
		SpeedMod = config.Bind<bool>("Character", "SpeedMod", false, (ConfigDescription)null);
		JumpMod = config.Bind<bool>("Character", "JumpMod", false, (ConfigDescription)null);
		NoFallDmg = config.Bind<bool>("Character", "NoFallDmg", false, (ConfigDescription)null);
		ClimbMod = config.Bind<bool>("Character", "ClimbMod", false, (ConfigDescription)null);
		VineClimbMod = config.Bind<bool>("Character", "VineClimbMod", false, (ConfigDescription)null);
		RopeClimbMod = config.Bind<bool>("Character", "RopeClimbMod", false, (ConfigDescription)null);
		SpeedAmount = config.Bind<float>("Character", "SpeedAmount", 1f, (ConfigDescription)null);
		JumpAmount = config.Bind<float>("Character", "JumpAmount", 10f, (ConfigDescription)null);
		ClimbAmount = config.Bind<float>("Character", "ClimbAmount", 1f, (ConfigDescription)null);
		VineClimbAmount = config.Bind<float>("Character", "VineClimbAmount", 1f, (ConfigDescription)null);
		RopeClimbAmount = config.Bind<float>("Character", "RopeClimbAmount", 1f, (ConfigDescription)null);
		RechargeAmountSlot1 = config.Bind<float>("Inventory", "RechargeAmountSlot1", 100f, new ConfigDescription("Recharge amount for slot 1", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 999f), Array.Empty<object>()));
		RechargeAmountSlot2 = config.Bind<float>("Inventory", "RechargeAmountSlot2", 100f, new ConfigDescription("Recharge amount for slot 2", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 999f), Array.Empty<object>()));
		RechargeAmountSlot3 = config.Bind<float>("Inventory", "RechargeAmountSlot3", 100f, new ConfigDescription("Recharge amount for slot 3", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 999f), Array.Empty<object>()));
		LanguageIndex = config.Bind<int>("UI", "Language", 0, new ConfigDescription("Language: 0=English, 1=简体中文, 2=日本語, 3=한국어", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 3), Array.Empty<object>()));
		Localization.SetLanguage(LanguageIndex.Value);
		Logger.LogInfo((object)"[PEAK AIO][ConfigManager] Config Loaded.");
	}
}
internal static class ConstantFields
{
	private static PropertyInfo infiniteStaminaProp;

	private static PropertyInfo statusLockProp;

	private static FieldInfo fallDamageTimeField;

	private static FieldInfo staminaField;

	private static FieldInfo movementModifierField;

	private static FieldInfo jumpGravityField;

	private static FieldInfo climbSpeedModField;

	private static FieldInfo vineClimbSpeedModField;

	private static FieldInfo ropeClimbSpeedModField;

	private static MethodInfo setStatusMethod;

	private static Array statusEnumValues;

	public static PropertyInfo GetInfiniteStaminaProperty()
	{
		if (infiniteStaminaProp == null)
		{
			infiniteStaminaProp = typeof(Character).GetProperty("infiniteStam", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return infiniteStaminaProp;
	}

	public static PropertyInfo GetStatusLockProperty()
	{
		if (statusLockProp == null)
		{
			statusLockProp = typeof(Character).GetProperty("statusesLocked", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return statusLockProp;
	}

	public static FieldInfo GetFallDamageTimeField()
	{
		if (fallDamageTimeField == null)
		{
			fallDamageTimeField = typeof(CharacterMovement).GetField("fallDamageTime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return fallDamageTimeField;
	}

	public static FieldInfo GetStaminaField()
	{
		if (staminaField == null)
		{
			staminaField = typeof(CharacterData).GetField("_stam", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return staminaField;
	}

	public static FieldInfo GetMovementModifierField()
	{
		if (movementModifierField == null)
		{
			movementModifierField = typeof(CharacterMovement).GetField("movementModifier", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return movementModifierField;
	}

	public static FieldInfo GetJumpGravityField()
	{
		if (jumpGravityField == null)
		{
			jumpGravityField = typeof(CharacterMovement).GetField("jumpGravity", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return jumpGravityField;
	}

	public static FieldInfo GetClimbSpeedModField()
	{
		if (climbSpeedModField == null)
		{
			climbSpeedModField = typeof(CharacterClimbing).GetField("climbSpeedMod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return climbSpeedModField;
	}

	public static FieldInfo GetVineClimbSpeedModField()
	{
		if (vineClimbSpeedModField == null)
		{
			vineClimbSpeedModField = typeof(CharacterVineClimbing).GetField("climbSpeedMod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return vineClimbSpeedModField;
	}

	public static FieldInfo GetRopeClimbSpeedModField()
	{
		if (ropeClimbSpeedModField == null)
		{
			ropeClimbSpeedModField = typeof(CharacterRopeHandling).GetField("climbSpeedMod", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return ropeClimbSpeedModField;
	}

	public static MethodInfo GetSetStatusMethod()
	{
		if (setStatusMethod == null)
		{
			setStatusMethod = typeof(CharacterAfflictions).GetMethod("SetStatus", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		}
		return setStatusMethod;
	}

	public static Array GetStatusEnumValues()
	{
		if (statusEnumValues == null)
		{
			statusEnumValues = Enum.GetValues(typeof(STATUSTYPE));
		}
		return statusEnumValues;
	}

	public static void RefreshAll()
	{
		infiniteStaminaProp = null;
		statusLockProp = null;
		fallDamageTimeField = null;
		staminaField = null;
		movementModifierField = null;
		jumpGravityField = null;
		climbSpeedModField = null;
		vineClimbSpeedModField = null;
		ropeClimbSpeedModField = null;
		setStatusMethod = null;
		statusEnumValues = null;
	}
}
public class EventComponent : MonoBehaviour
{
	private float stateTimer;

	private float validationTimer;

	private const float STATE_INTERVAL = 0.1f;

	private const float VALIDATION_INTERVAL = 1f;

	private void Update()
	{
		validationTimer += Time.deltaTime;
		if (validationTimer >= 1f)
		{
			validationTimer = 0f;
			GameHelpers.InvalidateCache();
		}
		if (ConfigManager.SpeedMod.Value || ConfigManager.JumpMod.Value)
		{
			CharacterMovement movementComponent = GameHelpers.GetMovementComponent();
			if ((Object)(object)movementComponent != (Object)null)
			{
				if (ConfigManager.SpeedMod.Value)
				{
					ConstantFields.GetMovementModifierField()?.SetValue(movementComponent, ConfigManager.SpeedAmount.Value);
				}
				if (ConfigManager.JumpMod.Value)
				{
					ConstantFields.GetJumpGravityField()?.SetValue(movementComponent, ConfigManager.JumpAmount.Value);
					if (ConfigManager.NoFallDmg.Value)
					{
						ConstantFields.GetFallDamageTimeField()?.SetValue(movementComponent, 999f);
					}
				}
			}
		}
		if (ConfigManager.ClimbMod.Value)
		{
			CharacterClimbing climbingComponent = GameHelpers.GetClimbingComponent();
			if ((Object)(object)climbingComponent != (Object)null)
			{
				ConstantFields.GetClimbSpeedModField()?.SetValue(climbingComponent, ConfigManager.ClimbAmount.Value);
			}
		}
		if (ConfigManager.VineClimbMod.Value)
		{
			CharacterVineClimbing vineClimbComponent = GameHelpers.GetVineClimbComponent();
			if ((Object)(object)vineClimbComponent != (Object)null)
			{
				ConstantFields.GetVineClimbSpeedModField()?.SetValue(vineClimbComponent, ConfigManager.VineClimbAmount.Value);
			}
		}
		if (ConfigManager.RopeClimbMod.Value)
		{
			CharacterRopeHandling ropeClimbComponent = GameHelpers.GetRopeClimbComponent();
			if ((Object)(object)ropeClimbComponent != (Object)null)
			{
				ConstantFields.GetRopeClimbSpeedModField()?.SetValue(ropeClimbComponent, ConfigManager.RopeClimbAmount.Value);
			}
		}
		stateTimer += Time.deltaTime;
		if (stateTimer < 0.1f)
		{
			return;
		}
		stateTimer = 0f;
		if (!ConfigManager.InfiniteStamina.Value && !ConfigManager.LockStatus.Value)
		{
			return;
		}
		Character characterComponent = GameHelpers.GetCharacterComponent();
		if ((Object)(object)characterComponent != (Object)null)
		{
			if (ConfigManager.InfiniteStamina.Value)
			{
				ConstantFields.GetInfiniteStaminaProperty()?.SetValue(characterComponent, true);
			}
			if (ConfigManager.LockStatus.Value)
			{
				ConstantFields.GetStatusLockProperty()?.SetValue(characterComponent, true);
			}
		}
	}
}
internal static class GameHelpers
{
	private static Character character;

	private static CharacterData characterData;

	private static CharacterMovement movementComponent;

	private static CharacterAfflictions afflictionsComponent;

	private static CharacterClimbing climbingComponent;

	private static CharacterVineClimbing vineClimbingComponent;

	private static CharacterRopeHandling ropeClimbingComponent;

	private static bool cacheValid;

	public static void InvalidateCache()
	{
		if (cacheValid)
		{
			Character localCharacter = Character.localCharacter;
			if (character != localCharacter || (Object)(object)character == (Object)null || !((Behaviour)character).isActiveAndEnabled)
			{
				Refresh();
			}
		}
	}

	public static Character GetCharacterComponent()
	{
		Character localCharacter = Character.localCharacter;
		if (character != localCharacter)
		{
			character = localCharacter;
			characterData = null;
			movementComponent = null;
			afflictionsComponent = null;
			climbingComponent = null;
			vineClimbingComponent = null;
			ropeClimbingComponent = null;
		}
		cacheValid = character != null;
		return character;
	}

	public static CharacterData GetCharacterData()
	{
		Character characterComponent = GetCharacterComponent();
		if (characterComponent != null)
		{
			return characterComponent.data;
		}
		if (characterData == null)
		{
			characterData = Object.FindFirstObjectByType<CharacterData>();
		}
		return characterData;
	}

	public static CharacterMovement GetMovementComponent()
	{
		if (movementComponent == null)
		{
			Character characterComponent = GetCharacterComponent();
			if (characterComponent != null)
			{
				movementComponent = ((Component)characterComponent).GetComponent<CharacterMovement>();
			}
		}
		return movementComponent;
	}

	public static CharacterAfflictions GetAfflictionsComponent()
	{
		if (afflictionsComponent == null)
		{
			Character characterComponent = GetCharacterComponent();
			if (characterComponent != null)
			{
				afflictionsComponent = ((Component)characterComponent).GetComponent<CharacterAfflictions>();
			}
		}
		return afflictionsComponent;
	}

	public static CharacterClimbing GetClimbingComponent()
	{
		if (climbingComponent == null)
		{
			Character characterComponent = GetCharacterComponent();
			if (characterComponent != null)
			{
				climbingComponent = ((Component)characterComponent).GetComponent<CharacterClimbing>();
			}
		}
		return climbingComponent;
	}

	public static CharacterVineClimbing GetVineClimbComponent()
	{
		if (vineClimbingComponent == null)
		{
			Character characterComponent = GetCharacterComponent();
			if (characterComponent != null)
			{
				vineClimbingComponent = ((Component)characterComponent).GetComponent<CharacterVineClimbing>();
			}
		}
		return vineClimbingComponent;
	}

	public static CharacterRopeHandling GetRopeClimbComponent()
	{
		if (ropeClimbingComponent == null)
		{
			Character characterComponent = GetCharacterComponent();
			if (characterComponent != null)
			{
				ropeClimbingComponent = ((Component)characterComponent).GetComponent<CharacterRopeHandling>();
			}
		}
		return ropeClimbingComponent;
	}

	public static void Refresh()
	{
		character = null;
		characterData = null;
		movementComponent = null;
		afflictionsComponent = null;
		climbingComponent = null;
		vineClimbingComponent = null;
		ropeClimbingComponent = null;
		cacheValid = false;
	}
}
public static class Globals
{
	public static bool anyAfflictionEnabled;

	public static Character character;

	public static CharacterData characterData;

	public static FieldInfo staminaField;

	public static PropertyInfo infiniteStamProp;

	public static FieldInfo sinceFallSlideField;

	public static FieldInfo sinceGroundedField;

	public static object movementComp;

	public static FieldInfo movementModifierField;

	public static FieldInfo jumpGravityField;

	public static FieldInfo fallDamageTimeField;

	public static object characterClimb;

	public static FieldInfo climbSpeedModifierField;

	public static object characterVineClimb;

	public static FieldInfo vineClimbSpeedModifierField;

	public static object characterRopeHandling;

	public static FieldInfo ropeClimbSpeedModifierField;

	public static object afflictionsObj;

	public static MethodInfo setStatusMethod;

	public static object weightEnumValue;

	public static object poisonEnumValue;

	public static object hotEnumValue;

	public static object coldEnumValue;

	public static object curseEnumValue;

	public static object injuryEnumValue;

	public static object drowsyEnumValue;

	public static object hungerEnumValue;

	public static List<Item> items = new List<Item>();

	public static List<string> itemNames = new List<string>();

	public static int[] selectedItems = new int[3] { -1, -1, -1 };

	public static string[] itemDisplayNames = new string[3] { "None", "None", "None" };

	public static string[] itemSearchBuffers = new string[3];

	public static Player playerObj;

	public static List<Character> allPlayers = new List<Character>();

	public static List<string> playerNames = new List<string>();

	public static int selectedPlayer = -1;

	public static bool excludeSelfFromAllActions = true;

	public static bool teleportToPingEnabled = false;

	public static float teleportX = 0f;

	public static float teleportY = 0f;

	public static float teleportZ = 0f;

	public static int selectedLuggageIndex = -1;

	public static List<string> luggageLabels = new List<string>();

	public static List<Luggage> luggageObject = new List<Luggage>();

	public static List<Luggage> allOpenedLuggage = new List<Luggage>();
}
[HarmonyPatch(typeof(PointPinger), "ReceivePoint_Rpc")]
public class PointPingPatch
{
	private static void Postfix(Vector3 point, Vector3 hitNormal, PointPinger __instance)
	{
		//IL_0059: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (ConfigManager.TeleportToPing.Value)
			{
				Character character = __instance.character;
				object obj;
				if (character == null)
				{
					obj = null;
				}
				else
				{
					PhotonView photonView = ((MonoBehaviourPun)character).photonView;
					obj = ((photonView != null) ? photonView.Owner : null);
				}
				Player val = (Player)obj;
				if (val != null && val == PhotonNetwork.LocalPlayer && (Object)(object)Character.localCharacter != (Object)null && !Character.localCharacter.data.dead)
				{
					Vector3 val2 = point + Vector3.up;
					((MonoBehaviourPun)Character.localCharacter).photonView.RPC("WarpPlayerRPC", (RpcTarget)0, new object[2] { val2, true });
					ConfigManager.Logger.LogInfo((object)"[Patch] Teleported to ping!");
				}
			}
		}
		catch (Exception ex)
		{
			ConfigManager.Logger.LogError((object)("[Patch] Exception: " + ex));
		}
	}
}
[HarmonyPatch(typeof(Character), "Update")]
public class FlyPatch
{
	private static bool isFlying = false;

	private static Vector3 flyVelocity = Vector3.zero;

	public static bool IsFlying => isFlying;

	public static void SetFlying(bool enable)
	{
		//IL_0006: Unknown result type (might be due to invalid IL or missing references)
		//IL_000b: Unknown result type (might be due to invalid IL or missing references)
		isFlying = enable;
		flyVelocity = Vector3.zero;
		ConfigManager.Logger.LogInfo((object)("[FlyMod] Flight " + (enable ? "enabled" : "disabled") + "."));
	}

	private static void Postfix(Character __instance)
	{
		//IL_009e: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00b9: 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_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00db: Unknown result type (might be due to invalid IL or missing references)
		//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
		//IL_0100: 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_0137: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0145: Unknown result type (might be due to invalid IL or missing references)
		//IL_0152: 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_0113: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Unknown result type (might be due to invalid IL or missing references)
		//IL_0119: Unknown result type (might be due to invalid IL or missing references)
		//IL_011e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		if ((!ConfigManager.FlyMod.Value && !isFlying) || !__instance.IsLocal)
		{
			return;
		}
		if (!ConfigManager.FlyMod.Value)
		{
			if (isFlying)
			{
				isFlying = false;
				flyVelocity = Vector3.zero;
				ConfigManager.Logger.LogInfo((object)"[FlyMod] Flight disabled.");
			}
			return;
		}
		if (!isFlying)
		{
			isFlying = true;
			ConfigManager.Logger.LogInfo((object)"[FlyMod] Flight enabled.");
		}
		__instance.data.isGrounded = true;
		__instance.data.sinceGrounded = 0f;
		__instance.data.sinceJump = 0f;
		Vector3 val = Vector2.op_Implicit(__instance.input.movementInput);
		Vector3 normalized = ((Vector3)(ref __instance.data.lookDirection_Flat)).normalized;
		Vector3 val2 = Vector3.Cross(Vector3.up, normalized);
		Vector3 normalized2 = ((Vector3)(ref val2)).normalized;
		Vector3 val3 = normalized * val.y + normalized2 * val.x;
		if (__instance.input.jumpIsPressed)
		{
			val3 += Vector3.up;
		}
		if (__instance.input.crouchIsPressed)
		{
			val3 += Vector3.down;
		}
		float value = ConfigManager.FlySpeed.Value;
		float value2 = ConfigManager.FlyAcceleration.Value;
		flyVelocity = Vector3.Lerp(flyVelocity, ((Vector3)(ref val3)).normalized * value, Time.deltaTime * value2);
		List<Bodypart> partList = __instance.refs.ragdoll.partList;
		for (int i = 0; i < partList.Count; i++)
		{
			Bodypart obj = partList[i];
			Rigidbody val4 = ((obj != null) ? obj.Rig : null);
			if ((Object)(object)val4 != (Object)null)
			{
				val4.linearVelocity = flyVelocity;
			}
		}
	}
}
public static class CJKFontPatch
{
	private static bool fontsLoaded = false;

	private static GCHandle cjkRangesHandle;

	private static GCHandle koreanRangesHandle;

	public static ImFontPtr CjkFont;

	public static ImFontPtr KoreanFont;

	public static bool HasCjkFont = false;

	public static bool HasKoreanFont = false;

	private static readonly ushort[] CjkRanges = new ushort[13]
	{
		32, 255, 8192, 8303, 12288, 12543, 12784, 12799, 19968, 40959,
		65280, 65519, 0
	};

	private static readonly ushort[] KoreanRanges = new ushort[11]
	{
		32, 255, 8192, 8303, 12593, 12643, 44032, 55203, 65280, 65519,
		0
	};

	private static readonly string[] CjkFontCandidates = new string[3] { "C:\\Windows\\Fonts\\msyh.ttc", "C:\\Windows\\Fonts\\meiryo.ttc", "C:\\Windows\\Fonts\\yugothm.ttc" };

	private static readonly string[] KoreanFontCandidates = new string[2] { "C:\\Windows\\Fonts\\malgun.ttf", "C:\\Windows\\Fonts\\malgunsl.ttf" };

	private static string FindFirst(string[] paths)
	{
		foreach (string text in paths)
		{
			if (File.Exists(text))
			{
				return text;
			}
		}
		return null;
	}

	public unsafe static void Prefix()
	{
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_001b: 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)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
		//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
		if (fontsLoaded)
		{
			return;
		}
		fontsLoaded = true;
		try
		{
			ImGuiIOPtr iO = ImGui.GetIO();
			ImFontAtlasPtr fonts = ((ImGuiIOPtr)(ref iO)).Fonts;
			cjkRangesHandle = GCHandle.Alloc(CjkRanges, GCHandleType.Pinned);
			koreanRangesHandle = GCHandle.Alloc(KoreanRanges, GCHandleType.Pinned);
			IntPtr intPtr = cjkRangesHandle.AddrOfPinnedObject();
			IntPtr intPtr2 = koreanRangesHandle.AddrOfPinnedObject();
			string text = FindFirst(CjkFontCandidates);
			string text2 = FindFirst(KoreanFontCandidates);
			if (text != null)
			{
				CjkFont = ((ImFontAtlasPtr)(ref fonts)).AddFontFromFileTTF(text, 14f, default(ImFontConfigPtr), intPtr);
				HasCjkFont = ((ImFontPtr)(ref CjkFont)).NativePtr != null;
				ConfigManager.Logger.LogInfo((object)("[PEAK AIO] CJK font (" + Path.GetFileName(text) + "): " + (HasCjkFont ? "OK" : "FAILED")));
			}
			if (text2 != null)
			{
				KoreanFont = ((ImFontAtlasPtr)(ref fonts)).AddFontFromFileTTF(text2, 14f, default(ImFontConfigPtr), intPtr2);
				HasKoreanFont = ((ImFontPtr)(ref KoreanFont)).NativePtr != null;
				ConfigManager.Logger.LogInfo((object)("[PEAK AIO] Korean font (" + Path.GetFileName(text2) + "): " + (HasKoreanFont ? "OK" : "FAILED")));
			}
			if (HasCjkFont)
			{
				((ImGuiIO)((ImGuiIOPtr)(ref iO)).NativePtr).FontDefault = ((ImFontPtr)(ref CjkFont)).NativePtr;
			}
			else if (HasKoreanFont)
			{
				((ImGuiIO)((ImGuiIOPtr)(ref iO)).NativePtr).FontDefault = ((ImFontPtr)(ref KoreanFont)).NativePtr;
			}
			else
			{
				ConfigManager.Logger.LogWarning((object)"[PEAK AIO] No CJK/Korean fonts found, using default font.");
			}
			bool flag = ((ImFontAtlasPtr)(ref fonts)).Build();
			ConfigManager.Logger.LogInfo((object)string.Format("[PEAK AIO] Atlas build: {0}, size: {1}x{2}, fonts: {3}", flag ? "OK" : "FAILED", ((ImFontAtlasPtr)(ref fonts)).TexWidth, ((ImFontAtlasPtr)(ref fonts)).TexHeight, ((ImFontAtlasPtr)(ref fonts)).Fonts.Size));
			if (cjkRangesHandle.IsAllocated)
			{
				cjkRangesHandle.Free();
			}
			if (koreanRangesHandle.IsAllocated)
			{
				koreanRangesHandle.Free();
			}
		}
		catch (Exception ex)
		{
			if (cjkRangesHandle.IsAllocated)
			{
				cjkRangesHandle.Free();
			}
			if (koreanRangesHandle.IsAllocated)
			{
				koreanRangesHandle.Free();
			}
			ConfigManager.Logger.LogWarning((object)("[PEAK AIO] Font loading failed: " + ex.Message));
		}
	}
}
public static class ImGuiInputPatch
{
	private struct POINT
	{
		public int X;

		public int Y;
	}

	private const int VK_LBUTTON = 1;

	private const int VK_RBUTTON = 2;

	private const int VK_MBUTTON = 4;

	private static bool cachedLButton;

	private static bool cachedRButton;

	private static bool cachedMButton;

	private static float cachedScroll;

	private static float cachedMouseX;

	private static float cachedMouseY;

	private static bool forceInput;

	private static int logFrames;

	private static int renderLogFrames;

	private static bool nativeApiWorks = true;

	private static IntPtr gameWindowHandle = IntPtr.Zero;

	[DllImport("user32.dll")]
	private static extern short GetAsyncKeyState(int vKey);

	[DllImport("user32.dll")]
	private static extern bool GetCursorPos(out POINT lpPoint);

	[DllImport("user32.dll")]
	private static extern bool ScreenToClient(IntPtr hWnd, ref POINT lpPoint);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	private unsafe static extern void ImGuiIO_AddMouseButtonEvent(ImGuiIO* self, int mouse_button, byte mouse_down);

	[DllImport("cimgui", CallingConvention = CallingConvention.Cdecl)]
	private unsafe static extern void ImGuiIO_AddMouseWheelEvent(ImGuiIO* self, float wheel_x, float wheel_y);

	private static IntPtr GetGameWindow()
	{
		if (gameWindowHandle == IntPtr.Zero)
		{
			try
			{
				gameWindowHandle = Process.GetCurrentProcess().MainWindowHandle;
			}
			catch
			{
			}
		}
		return gameWindowHandle;
	}

	public static void SetForceInput(bool enabled)
	{
		forceInput = enabled;
	}

	public static void ResetLogs()
	{
		logFrames = 0;
		renderLogFrames = 0;
	}

	public static void CaptureInput()
	{
		//IL_003c: Unknown result type (might be due to invalid IL or missing references)
		cachedLButton = (GetAsyncKeyState(1) & 0x8000) != 0;
		cachedRButton = (GetAsyncKeyState(2) & 0x8000) != 0;
		cachedMButton = (GetAsyncKeyState(4) & 0x8000) != 0;
		try
		{
			cachedScroll = Input.mouseScrollDelta.y;
		}
		catch
		{
			cachedScroll = 0f;
		}
		try
		{
			if (GetCursorPos(out var lpPoint))
			{
				POINT lpPoint2 = lpPoint;
				IntPtr gameWindow = GetGameWindow();
				if (gameWindow != IntPtr.Zero && ScreenToClient(gameWindow, ref lpPoint2))
				{
					cachedMouseX = lpPoint2.X;
					cachedMouseY = lpPoint2.Y;
				}
			}
		}
		catch
		{
		}
	}

	public unsafe static void ApplyToImGui()
	{
		//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_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_00d5: Unknown result type (might be due to invalid IL or missing references)
		//IL_00da: Unknown result type (might be due to invalid IL or missing references)
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		//IL_000e: Unknown result type (might be due to invalid IL or missing references)
		if (!forceInput)
		{
			return;
		}
		try
		{
			ImGuiIOPtr iO = ImGui.GetIO();
			int configFlags = (int)((ImGuiIOPtr)(ref iO)).ConfigFlags;
			ref ImGuiConfigFlags configFlags2 = ref ((ImGuiIOPtr)(ref iO)).ConfigFlags;
			configFlags2 = (ImGuiConfigFlags)((uint)configFlags2 & 0xFFFFFFEFu);
			((ImGuiIOPtr)(ref iO)).MousePos = new Vector2(cachedMouseX, cachedMouseY);
			if (nativeApiWorks)
			{
				try
				{
					ImGuiIO* nativePtr = ((ImGuiIOPtr)(ref iO)).NativePtr;
					ImGuiIO_AddMouseButtonEvent(nativePtr, 0, cachedLButton ? ((byte)1) : ((byte)0));
					ImGuiIO_AddMouseButtonEvent(nativePtr, 1, cachedRButton ? ((byte)1) : ((byte)0));
					ImGuiIO_AddMouseButtonEvent(nativePtr, 2, cachedMButton ? ((byte)1) : ((byte)0));
					ImGuiIO_AddMouseWheelEvent(nativePtr, 0f, cachedScroll);
				}
				catch
				{
					nativeApiWorks = false;
					ConfigManager.Logger.LogWarning((object)"[InputPatch] Native event API failed, using legacy.");
				}
			}
			((ImGuiIOPtr)(ref iO)).MouseDown[0] = cachedLButton;
			((ImGuiIOPtr)(ref iO)).MouseDown[1] = cachedRButton;
			((ImGuiIOPtr)(ref iO)).MouseDown[2] = cachedMButton;
			((ImGuiIOPtr)(ref iO)).MouseWheel = cachedScroll;
			if (logFrames < 5)
			{
				logFrames++;
				bool flag = (configFlags & 0x10) != 0;
				ConfigManager.Logger.LogInfo((object)($"[InputPatch] nativeApi={nativeApiWorks} hadNoMouse={flag} " + $"win32Pos=({cachedMouseX:F0},{cachedMouseY:F0}) " + $"imguiPos=({((ImGuiIOPtr)(ref iO)).MousePos.X:F0},{((ImGuiIOPtr)(ref iO)).MousePos.Y:F0}) " + $"displaySize=({((ImGuiIOPtr)(ref iO)).DisplaySize.X:F0},{((ImGuiIOPtr)(ref iO)).DisplaySize.Y:F0}) " + $"hwnd={gameWindowHandle}"));
			}
		}
		catch (Exception arg)
		{
			if (logFrames < 5)
			{
				logFrames++;
				ConfigManager.Logger.LogError((object)$"[InputPatch] Error: {arg}");
			}
		}
	}

	public static void LogPostNewFrame()
	{
		//IL_0013: Unknown result type (might be due to invalid IL or missing references)
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		if (!forceInput || renderLogFrames >= 15)
		{
			return;
		}
		try
		{
			ImGuiIOPtr iO = ImGui.GetIO();
			Vector2 windowPos = ImGui.GetWindowPos();
			Vector2 windowSize = ImGui.GetWindowSize();
			bool flag = ImGui.IsWindowHovered((ImGuiHoveredFlags)131);
			ImGui.IsAnyItemHovered();
			bool flag2 = ImGui.IsWindowFocused((ImGuiFocusedFlags)3);
			bool flag3 = ImGui.IsMouseHoveringRect(windowPos, new Vector2(windowPos.X + windowSize.X, windowPos.Y + windowSize.Y), false);
			if (cachedLButton)
			{
				renderLogFrames++;
				ConfigManager.Logger.LogInfo((object)("[InputPatch-Render] CLICK " + $"winHovered={flag} rectHover={flag3} winFocused={flag2} " + $"wantCapture={((ImGuiIOPtr)(ref iO)).WantCaptureMouse} configFlags=0x{(int)((ImGuiIOPtr)(ref iO)).ConfigFlags:X} " + $"imguiPos=({((ImGuiIOPtr)(ref iO)).MousePos.X:F0},{((ImGuiIOPtr)(ref iO)).MousePos.Y:F0}) " + $"winPos=({windowPos.X:F0},{windowPos.Y:F0}) winSize=({windowSize.X:F0},{windowSize.Y:F0})"));
			}
			else if (renderLogFrames < 5)
			{
				renderLogFrames++;
				ConfigManager.Logger.LogInfo((object)("[InputPatch-Render] " + $"winHovered={flag} rectHover={flag3} winFocused={flag2} " + $"wantCapture={((ImGuiIOPtr)(ref iO)).WantCaptureMouse} configFlags=0x{(int)((ImGuiIOPtr)(ref iO)).ConfigFlags:X} " + $"imguiPos=({((ImGuiIOPtr)(ref iO)).MousePos.X:F0},{((ImGuiIOPtr)(ref iO)).MousePos.Y:F0}) " + $"winPos=({windowPos.X:F0},{windowPos.Y:F0}) winSize=({windowSize.X:F0},{windowSize.Y:F0})"));
			}
		}
		catch
		{
		}
	}

	public static void Prefix()
	{
		ApplyToImGui();
	}
}
[HarmonyPatch(typeof(CharacterAfflictions), "UpdateWeight")]
public class Patch_UpdateWeight
{
	private static CharacterAfflictions cachedLocalAfflictions;

	private static Character cachedLocalCharacter;

	private static void Postfix(CharacterAfflictions __instance)
	{
		if (!ConfigManager.NoWeight.Value)
		{
			return;
		}
		Character localCharacter = Character.localCharacter;
		if (localCharacter != null)
		{
			if (localCharacter != cachedLocalCharacter)
			{
				cachedLocalCharacter = localCharacter;
				cachedLocalAfflictions = ((Component)localCharacter).GetComponent<CharacterAfflictions>();
			}
			if (__instance == cachedLocalAfflictions)
			{
				__instance.SetStatus((STATUSTYPE)7, 0f, true);
			}
		}
	}
}
public enum Language
{
	English,
	SimplifiedChinese,
	Japanese,
	Korean,
	Italian,
	TraditionalChinese
}
public static class Localization
{
	public static Language CurrentLanguage = Language.English;

	private static readonly Dictionary<string, Dictionary<Language, string>> Strings = new Dictionary<string, Dictionary<Language, string>>
	{
		{
			"tab.player",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"PLAYER"
				},
				{
					Language.SimplifiedChinese,
					"玩家"
				},
				{
					Language.TraditionalChinese,
					"玩家"
				},
				{
					Language.Japanese,
					"プレイヤー"
				},
				{
					Language.Korean,
					"플레이어"
				},
				{
					Language.Italian,
					"GIOCATORE"
				}
			}
		},
		{
			"tab.items",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"ITEMS"
				},
				{
					Language.SimplifiedChinese,
					"物品"
				},
				{
					Language.TraditionalChinese,
					"物品"
				},
				{
					Language.Japanese,
					"アイテム"
				},
				{
					Language.Korean,
					"아이템"
				},
				{
					Language.Italian,
					"OGGETTI"
				}
			}
		},
		{
			"tab.lobby",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"LOBBY"
				},
				{
					Language.SimplifiedChinese,
					"大厅"
				},
				{
					Language.TraditionalChinese,
					"大廳"
				},
				{
					Language.Japanese,
					"ロビー"
				},
				{
					Language.Korean,
					"로비"
				},
				{
					Language.Italian,
					"LOBBY"
				}
			}
		},
		{
			"tab.world",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"WORLD"
				},
				{
					Language.SimplifiedChinese,
					"世界"
				},
				{
					Language.TraditionalChinese,
					"世界"
				},
				{
					Language.Japanese,
					"ワールド"
				},
				{
					Language.Korean,
					"월드"
				},
				{
					Language.Italian,
					"MONDO"
				}
			}
		},
		{
			"tab.about",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"ABOUT"
				},
				{
					Language.SimplifiedChinese,
					"关于"
				},
				{
					Language.TraditionalChinese,
					"關於"
				},
				{
					Language.Japanese,
					"情報"
				},
				{
					Language.Korean,
					"정보"
				},
				{
					Language.Italian,
					"INFO"
				}
			}
		},
		{
			"tab.language",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"LANG"
				},
				{
					Language.SimplifiedChinese,
					"语言"
				},
				{
					Language.TraditionalChinese,
					"語言"
				},
				{
					Language.Japanese,
					"言語"
				},
				{
					Language.Korean,
					"언어"
				},
				{
					Language.Italian,
					"LINGUA"
				}
			}
		},
		{
			"player.selfmods",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Self Mods"
				},
				{
					Language.SimplifiedChinese,
					"自身模组"
				},
				{
					Language.TraditionalChinese,
					"自身模組"
				},
				{
					Language.Japanese,
					"セルフMOD"
				},
				{
					Language.Korean,
					"셀프 모드"
				},
				{
					Language.Italian,
					"Mod Personali"
				}
			}
		},
		{
			"player.infinite_stamina",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Infinite Stamina"
				},
				{
					Language.SimplifiedChinese,
					"无限体力"
				},
				{
					Language.TraditionalChinese,
					"無限體力"
				},
				{
					Language.Japanese,
					"無限スタミナ"
				},
				{
					Language.Korean,
					"무한 스태미나"
				},
				{
					Language.Italian,
					"Stamina Infinita"
				}
			}
		},
		{
			"player.freeze_afflictions",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Freeze Afflictions"
				},
				{
					Language.SimplifiedChinese,
					"冻结状态异常"
				},
				{
					Language.TraditionalChinese,
					"凍結狀態異常"
				},
				{
					Language.Japanese,
					"状態異常凍結"
				},
				{
					Language.Korean,
					"상태이상 동결"
				},
				{
					Language.Italian,
					"Blocca Afflizioni"
				}
			}
		},
		{
			"player.no_weight",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"No Weight"
				},
				{
					Language.SimplifiedChinese,
					"无重量"
				},
				{
					Language.TraditionalChinese,
					"無重量"
				},
				{
					Language.Japanese,
					"重量無効"
				},
				{
					Language.Korean,
					"무게 무시"
				},
				{
					Language.Italian,
					"Nessun Peso"
				}
			}
		},
		{
			"player.change_speed",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Change Speed"
				},
				{
					Language.SimplifiedChinese,
					"修改速度"
				},
				{
					Language.TraditionalChinese,
					"修改速度"
				},
				{
					Language.Japanese,
					"速度変更"
				},
				{
					Language.Korean,
					"속도 변경"
				},
				{
					Language.Italian,
					"Modifica Velocità"
				}
			}
		},
		{
			"player.change_jump",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Change Jump"
				},
				{
					Language.SimplifiedChinese,
					"修改跳跃"
				},
				{
					Language.TraditionalChinese,
					"修改跳躍"
				},
				{
					Language.Japanese,
					"ジャンプ変更"
				},
				{
					Language.Korean,
					"점프 변경"
				},
				{
					Language.Italian,
					"Modifica Salto"
				}
			}
		},
		{
			"player.change_climb",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Change Climb"
				},
				{
					Language.SimplifiedChinese,
					"修改攀爬"
				},
				{
					Language.TraditionalChinese,
					"修改攀爬"
				},
				{
					Language.Japanese,
					"登攀速度変更"
				},
				{
					Language.Korean,
					"등반 변경"
				},
				{
					Language.Italian,
					"Modifica Arrampicata"
				}
			}
		},
		{
			"player.change_vine_climb",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Change Vine Climb"
				},
				{
					Language.SimplifiedChinese,
					"修改藤蔓攀爬"
				},
				{
					Language.TraditionalChinese,
					"修改藤蔓攀爬"
				},
				{
					Language.Japanese,
					"ツル登攀変更"
				},
				{
					Language.Korean,
					"덩굴 등반 변경"
				},
				{
					Language.Italian,
					"Modifica Arrampicata su Liane"
				}
			}
		},
		{
			"player.change_rope_climb",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Change Rope Climb"
				},
				{
					Language.SimplifiedChinese,
					"修改绳索攀爬"
				},
				{
					Language.TraditionalChinese,
					"修改繩索攀爬"
				},
				{
					Language.Japanese,
					"ロープ登攀変更"
				},
				{
					Language.Korean,
					"로프 등반 변경"
				},
				{
					Language.Italian,
					"Modifica Arrampicata su Corda"
				}
			}
		},
		{
			"player.teleport_to_ping",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Teleport to Ping"
				},
				{
					Language.SimplifiedChinese,
					"传送到标记点"
				},
				{
					Language.TraditionalChinese,
					"傳送到標記點"
				},
				{
					Language.Japanese,
					"ピンに移動"
				},
				{
					Language.Korean,
					"핑으로 텔레포트"
				},
				{
					Language.Italian,
					"Teletrasporto al Ping"
				}
			}
		},
		{
			"player.fly_mode",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Fly Mode"
				},
				{
					Language.SimplifiedChinese,
					"飞行模式"
				},
				{
					Language.TraditionalChinese,
					"飛行模式"
				},
				{
					Language.Japanese,
					"飛行モード"
				},
				{
					Language.Korean,
					"비행 모드"
				},
				{
					Language.Italian,
					"Modalità Volo"
				}
			}
		},
		{
			"player.no_fall_dmg",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"No Fall Dmg"
				},
				{
					Language.SimplifiedChinese,
					"无坠落伤害"
				},
				{
					Language.TraditionalChinese,
					"無墜落傷害"
				},
				{
					Language.Japanese,
					"落下ダメージ無効"
				},
				{
					Language.Korean,
					"낙하 피해 없음"
				},
				{
					Language.Italian,
					"Nessun Danno da Caduta"
				}
			}
		},
		{
			"player.teleport",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Teleport"
				},
				{
					Language.SimplifiedChinese,
					"传送"
				},
				{
					Language.TraditionalChinese,
					"傳送"
				},
				{
					Language.Japanese,
					"テレポート"
				},
				{
					Language.Korean,
					"텔레포트"
				},
				{
					Language.Italian,
					"Teletrasporto"
				}
			}
		},
		{
			"player.teleport_to_coords",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Teleport to coords"
				},
				{
					Language.SimplifiedChinese,
					"传送到坐标"
				},
				{
					Language.TraditionalChinese,
					"傳送到座標"
				},
				{
					Language.Japanese,
					"座標にテレポート"
				},
				{
					Language.Korean,
					"좌표로 텔레포트"
				},
				{
					Language.Italian,
					"Teletrasporto alle coordinate"
				}
			}
		},
		{
			"player.details",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Details"
				},
				{
					Language.SimplifiedChinese,
					"详细设置"
				},
				{
					Language.TraditionalChinese,
					"詳細設定"
				},
				{
					Language.Japanese,
					"詳細設定"
				},
				{
					Language.Korean,
					"상세 설정"
				},
				{
					Language.Italian,
					"Dettagli"
				}
			}
		},
		{
			"player.jump_mult",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Jump Mult: %.2f"
				},
				{
					Language.SimplifiedChinese,
					"跳跃倍率: %.2f"
				},
				{
					Language.TraditionalChinese,
					"跳躍倍率: %.2f"
				},
				{
					Language.Japanese,
					"ジャンプ倍率: %.2f"
				},
				{
					Language.Korean,
					"점프 배율: %.2f"
				},
				{
					Language.Italian,
					"Moltiplicatore Salto: %.2f"
				}
			}
		},
		{
			"player.move_speed",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Move Speed: %.2f"
				},
				{
					Language.SimplifiedChinese,
					"移动速度: %.2f"
				},
				{
					Language.TraditionalChinese,
					"移動速度: %.2f"
				},
				{
					Language.Japanese,
					"移動速度: %.2f"
				},
				{
					Language.Korean,
					"이동 속도: %.2f"
				},
				{
					Language.Italian,
					"Velocità Movimento: %.2f"
				}
			}
		},
		{
			"player.climb_speed",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Climb Speed: %.2f"
				},
				{
					Language.SimplifiedChinese,
					"攀爬速度: %.2f"
				},
				{
					Language.TraditionalChinese,
					"攀爬速度: %.2f"
				},
				{
					Language.Japanese,
					"登攀速度: %.2f"
				},
				{
					Language.Korean,
					"등반 속도: %.2f"
				},
				{
					Language.Italian,
					"Velocità Arrampicata: %.2f"
				}
			}
		},
		{
			"player.vine_speed",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Vine Speed: %.2f"
				},
				{
					Language.SimplifiedChinese,
					"藤蔓速度: %.2f"
				},
				{
					Language.TraditionalChinese,
					"藤蔓速度: %.2f"
				},
				{
					Language.Japanese,
					"ツル速度: %.2f"
				},
				{
					Language.Korean,
					"덩굴 속도: %.2f"
				},
				{
					Language.Italian,
					"Velocità Liane: %.2f"
				}
			}
		},
		{
			"player.rope_speed",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Rope Speed: %.2f"
				},
				{
					Language.SimplifiedChinese,
					"绳索速度: %.2f"
				},
				{
					Language.TraditionalChinese,
					"繩索速度: %.2f"
				},
				{
					Language.Japanese,
					"ロープ速度: %.2f"
				},
				{
					Language.Korean,
					"로프 속도: %.2f"
				},
				{
					Language.Italian,
					"Velocità Corda: %.2f"
				}
			}
		},
		{
			"player.fly_speed",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Fly Speed: %.2f"
				},
				{
					Language.SimplifiedChinese,
					"飞行速度: %.2f"
				},
				{
					Language.TraditionalChinese,
					"飛行速度: %.2f"
				},
				{
					Language.Japanese,
					"飛行速度: %.2f"
				},
				{
					Language.Korean,
					"비행 속도: %.2f"
				},
				{
					Language.Italian,
					"Velocità Volo: %.2f"
				}
			}
		},
		{
			"player.fly_acceleration",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Fly Acceleration: %.2f"
				},
				{
					Language.SimplifiedChinese,
					"飞行加速度: %.2f"
				},
				{
					Language.TraditionalChinese,
					"飛行加速度: %.2f"
				},
				{
					Language.Japanese,
					"飛行加速度: %.2f"
				},
				{
					Language.Korean,
					"비행 가속도: %.2f"
				},
				{
					Language.Italian,
					"Accelerazione Volo: %.2f"
				}
			}
		},
		{
			"tip.infinite_stamina",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Prevents stamina from decreasing, allowing unlimited sprinting and actions."
				},
				{
					Language.SimplifiedChinese,
					"防止体力下降，允许无限冲刺和执行动作。"
				},
				{
					Language.TraditionalChinese,
					"防止體力下降，允許無限衝刺和執行動作。"
				},
				{
					Language.Japanese,
					"スタミナの減少を防ぎ、無制限のダッシュとアクションを可能にします。"
				},
				{
					Language.Korean,
					"스태미나 감소를 방지하여 무제한 달리기와 행동이 가능합니다."
				},
				{
					Language.Italian,
					"Impedisce alla stamina di diminuire, permettendo scatti e azioni illimitate."
				}
			}
		},
		{
			"tip.freeze_afflictions",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Prevents your statuses from changing."
				},
				{
					Language.SimplifiedChinese,
					"防止你的状态发生变化。"
				},
				{
					Language.TraditionalChinese,
					"防止你的狀態發生變化。"
				},
				{
					Language.Japanese,
					"ステータスの変化を防ぎます。"
				},
				{
					Language.Korean,
					"상태 변화를 방지합니다."
				},
				{
					Language.Italian,
					"Impedisce ai tuoi stati di cambiare."
				}
			}
		},
		{
			"tip.no_weight",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Disables weight penalties from carried items and backpack."
				},
				{
					Language.SimplifiedChinese,
					"禁用携带物品和背包的重量惩罚。"
				},
				{
					Language.TraditionalChinese,
					"禁用攜帶物品和背包的重量懲罰。"
				},
				{
					Language.Japanese,
					"所持アイテムやバックパックの重量ペナルティを無効にします。"
				},
				{
					Language.Korean,
					"소지품 및 배낭의 무게 패널티를 비활성화합니다."
				},
				{
					Language.Italian,
					"Disabilita le penalità di peso dagli oggetti trasportati e dallo zaino."
				}
			}
		},
		{
			"tip.change_speed",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Overrides your character's movement speed with a custom multiplier."
				},
				{
					Language.SimplifiedChinese,
					"使用自定义倍率覆盖角色的移动速度。"
				},
				{
					Language.TraditionalChinese,
					"使用自訂倍率覆蓋角色的移動速度。"
				},
				{
					Language.Japanese,
					"キャラクターの移動速度をカスタム倍率で上書きします。"
				},
				{
					Language.Korean,
					"캐릭터의 이동 속도를 사용자 정의 배율로 변경합니다."
				},
				{
					Language.Italian,
					"Sostituisce la velocità di movimento del personaggio con un moltiplicatore personalizzato."
				}
			}
		},
		{
			"tip.change_jump",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Modifies jump height, allowing higher or lower jumps depending on your settings."
				},
				{
					Language.SimplifiedChinese,
					"修改跳跃高度，根据设置允许更高或更低的跳跃。"
				},
				{
					Language.TraditionalChinese,
					"修改跳躍高度，根據設定允許更高或更低的跳躍。"
				},
				{
					Language.Japanese,
					"ジャンプの高さを変更し、設定に応じて高くまたは低くジャンプできます。"
				},
				{
					Language.Korean,
					"점프 높이를 수정하여 설정에 따라 더 높거나 낮게 점프할 수 있습니다."
				},
				{
					Language.Italian,
					"Modifica l'altezza del salto, permettendo salti più alti o più bassi in base alle impostazioni."
				}
			}
		},
		{
			"tip.change_climb",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Adjusts the speed at which you climb ladders and surfaces."
				},
				{
					Language.SimplifiedChinese,
					"调整攀爬梯子和表面的速度。"
				},
				{
					Language.TraditionalChinese,
					"調整攀爬梯子和表面的速度。"
				},
				{
					Language.Japanese,
					"はしごや壁を登る速度を調整します。"
				},
				{
					Language.Korean,
					"사다리와 표면을 오르는 속도를 조정합니다."
				},
				{
					Language.Italian,
					"Regola la velocità con cui ti arrampichi su scale e superfici."
				}
			}
		},
		{
			"tip.change_vine_climb",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Changes climbing speed specifically for vines."
				},
				{
					Language.SimplifiedChinese,
					"专门修改藤蔓的攀爬速度。"
				},
				{
					Language.TraditionalChinese,
					"專門修改藤蔓的攀爬速度。"
				},
				{
					Language.Japanese,
					"ツルの登攀速度を変更します。"
				},
				{
					Language.Korean,
					"덩굴 등반 속도를 변경합니다."
				},
				{
					Language.Italian,
					"Modifica la velocità di arrampicata per le liane."
				}
			}
		},
		{
			"tip.change_rope_climb",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Modifies climbing speed when using ropes or rope-based obstacles."
				},
				{
					Language.SimplifiedChinese,
					"修改使用绳索或绳索障碍物时的攀爬速度。"
				},
				{
					Language.TraditionalChinese,
					"修改使用繩索或繩索障礙物時的攀爬速度。"
				},
				{
					Language.Japanese,
					"ロープやロープ系障害物での登攀速度を変更します。"
				},
				{
					Language.Korean,
					"로프 또는 로프 장애물 사용 시 등반 속도를 수정합니다."
				},
				{
					Language.Italian,
					"Modifica la velocità di arrampicata quando si usano corde o ostacoli basati su corde."
				}
			}
		},
		{
			"tip.teleport_to_ping",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Teleports your character to the pinged location on the map."
				},
				{
					Language.SimplifiedChinese,
					"将角色传送到地图上的标记位置。"
				},
				{
					Language.TraditionalChinese,
					"將角色傳送到地圖上的標記位置。"
				},
				{
					Language.Japanese,
					"マップ上のピンの位置にキャラクターをテレポートします。"
				},
				{
					Language.Korean,
					"캐릭터를 맵에서 핑한 위치로 텔레포트합니다."
				},
				{
					Language.Italian,
					"Teletrasporta il tuo personaggio alla posizione del ping sulla mappa."
				}
			}
		},
		{
			"tip.fly_mode",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Allows free movement in all directions while ignoring gravity."
				},
				{
					Language.SimplifiedChinese,
					"允许忽略重力在所有方向自由移动。"
				},
				{
					Language.TraditionalChinese,
					"允許忽略重力在所有方向自由移動。"
				},
				{
					Language.Japanese,
					"重力を無視して全方向に自由移動できます。"
				},
				{
					Language.Korean,
					"중력을 무시하고 모든 방향으로 자유 이동이 가능합니다."
				},
				{
					Language.Italian,
					"Permette il movimento libero in tutte le direzioni ignorando la gravità."
				}
			}
		},
		{
			"items.slot",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Slot"
				},
				{
					Language.SimplifiedChinese,
					"槽位"
				},
				{
					Language.TraditionalChinese,
					"槽位"
				},
				{
					Language.Japanese,
					"スロット"
				},
				{
					Language.Korean,
					"슬롯"
				},
				{
					Language.Italian,
					"Slot"
				}
			}
		},
		{
			"items.item_n",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Item {0}:"
				},
				{
					Language.SimplifiedChinese,
					"物品 {0}:"
				},
				{
					Language.TraditionalChinese,
					"物品 {0}:"
				},
				{
					Language.Japanese,
					"アイテム {0}:"
				},
				{
					Language.Korean,
					"아이템 {0}:"
				},
				{
					Language.Italian,
					"Oggetto {0}:"
				}
			}
		},
		{
			"items.none",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"None"
				},
				{
					Language.SimplifiedChinese,
					"无"
				},
				{
					Language.TraditionalChinese,
					"無"
				},
				{
					Language.Japanese,
					"なし"
				},
				{
					Language.Korean,
					"없음"
				},
				{
					Language.Italian,
					"Nessuno"
				}
			}
		},
		{
			"items.search",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Search items..."
				},
				{
					Language.SimplifiedChinese,
					"搜索物品..."
				},
				{
					Language.TraditionalChinese,
					"搜尋物品..."
				},
				{
					Language.Japanese,
					"アイテム検索..."
				},
				{
					Language.Korean,
					"아이템 검색..."
				},
				{
					Language.Italian,
					"Cerca oggetti..."
				}
			}
		},
		{
			"items.charge_format",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Charge: %.1f"
				},
				{
					Language.SimplifiedChinese,
					"充能: %.1f"
				},
				{
					Language.TraditionalChinese,
					"充能: %.1f"
				},
				{
					Language.Japanese,
					"チャージ: %.1f"
				},
				{
					Language.Korean,
					"충전: %.1f"
				},
				{
					Language.Italian,
					"Carica: %.1f"
				}
			}
		},
		{
			"items.recharge",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Recharge"
				},
				{
					Language.SimplifiedChinese,
					"充能"
				},
				{
					Language.TraditionalChinese,
					"充能"
				},
				{
					Language.Japanese,
					"チャージ"
				},
				{
					Language.Korean,
					"충전"
				},
				{
					Language.Italian,
					"Ricarica"
				}
			}
		},
		{
			"items.refresh",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Refresh Item List"
				},
				{
					Language.SimplifiedChinese,
					"刷新物品列表"
				},
				{
					Language.TraditionalChinese,
					"重新整理物品列表"
				},
				{
					Language.Japanese,
					"アイテムリスト更新"
				},
				{
					Language.Korean,
					"아이템 목록 새로고침"
				},
				{
					Language.Italian,
					"Aggiorna Lista Oggetti"
				}
			}
		},
		{
			"tip.item_search",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Search and assign any available item to this slot."
				},
				{
					Language.SimplifiedChinese,
					"搜索并分配任何可用物品到此槽位。"
				},
				{
					Language.TraditionalChinese,
					"搜尋並分配任何可用物品到此槽位。"
				},
				{
					Language.Japanese,
					"利用可能なアイテムを検索してこのスロットに割り当てます。"
				},
				{
					Language.Korean,
					"사용 가능한 아이템을 검색하여 이 슬롯에 할당합니다."
				},
				{
					Language.Italian,
					"Cerca e assegna qualsiasi oggetto disponibile a questo slot."
				}
			}
		},
		{
			"tip.recharge",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Set how much to recharge the item's charges when clicking 'Recharge'."
				},
				{
					Language.SimplifiedChinese,
					"设置点击「充能」时为物品充能的数量。"
				},
				{
					Language.TraditionalChinese,
					"設定點擊「充能」時為物品充能的數量。"
				},
				{
					Language.Japanese,
					"「チャージ」クリック時のチャージ量を設定します。"
				},
				{
					Language.Korean,
					"'충전' 클릭 시 아이템 충전량을 설정합니다."
				},
				{
					Language.Italian,
					"Imposta quanta carica aggiungere all'oggetto quando clicchi 'Ricarica'."
				}
			}
		},
		{
			"tip.refresh_items",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Reloads the list of available items in case something was missed or updated."
				},
				{
					Language.SimplifiedChinese,
					"重新加载可用物品列表，以防遗漏或更新。"
				},
				{
					Language.TraditionalChinese,
					"重新載入可用物品列表，以防遺漏或更新。"
				},
				{
					Language.Japanese,
					"見落としや更新に備え、利用可能なアイテムリストを再読み込みします。"
				},
				{
					Language.Korean,
					"누락되거나 업데이트된 경우 사용 가능한 아이템 목록을 다시 불러옵니다."
				},
				{
					Language.Italian,
					"Ricarica l'elenco degli oggetti disponibili nel caso qualcosa sia stato perso o aggiornato."
				}
			}
		},
		{
			"lobby.players",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Lobby Players"
				},
				{
					Language.SimplifiedChinese,
					"大厅玩家"
				},
				{
					Language.TraditionalChinese,
					"大廳玩家"
				},
				{
					Language.Japanese,
					"ロビープレイヤー"
				},
				{
					Language.Korean,
					"로비 플레이어"
				},
				{
					Language.Italian,
					"Giocatori nella Lobby"
				}
			}
		},
		{
			"lobby.select_player",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Select Player"
				},
				{
					Language.SimplifiedChinese,
					"选择玩家"
				},
				{
					Language.TraditionalChinese,
					"選擇玩家"
				},
				{
					Language.Japanese,
					"プレイヤー選択"
				},
				{
					Language.Korean,
					"플레이어 선택"
				},
				{
					Language.Italian,
					"Seleziona Giocatore"
				}
			}
		},
		{
			"lobby.all_players",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"All Players"
				},
				{
					Language.SimplifiedChinese,
					"所有玩家"
				},
				{
					Language.TraditionalChinese,
					"所有玩家"
				},
				{
					Language.Japanese,
					"全プレイヤー"
				},
				{
					Language.Korean,
					"모든 플레이어"
				},
				{
					Language.Italian,
					"Tutti i Giocatori"
				}
			}
		},
		{
			"lobby.revive_all",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Revive All"
				},
				{
					Language.SimplifiedChinese,
					"复活全部"
				},
				{
					Language.TraditionalChinese,
					"復活全部"
				},
				{
					Language.Japanese,
					"全員復活"
				},
				{
					Language.Korean,
					"전원 부활"
				},
				{
					Language.Italian,
					"Rianima Tutti"
				}
			}
		},
		{
			"lobby.kill_all",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Kill All"
				},
				{
					Language.SimplifiedChinese,
					"击杀全部"
				},
				{
					Language.TraditionalChinese,
					"擊殺全部"
				},
				{
					Language.Japanese,
					"全員キル"
				},
				{
					Language.Korean,
					"전원 처치"
				},
				{
					Language.Italian,
					"Uccidi Tutti"
				}
			}
		},
		{
			"lobby.exclude_self",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Exclude Self from Kill All"
				},
				{
					Language.SimplifiedChinese,
					"击杀全部时排除自己"
				},
				{
					Language.TraditionalChinese,
					"擊殺全部時排除自己"
				},
				{
					Language.Japanese,
					"全員キルから自分を除外"
				},
				{
					Language.Korean,
					"전원 처치에서 자신 제외"
				},
				{
					Language.Italian,
					"Escludi Te Stesso da Uccidi Tutti"
				}
			}
		},
		{
			"lobby.warp_all_to_me",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Warp All To Me"
				},
				{
					Language.SimplifiedChinese,
					"将所有人传送到我身边"
				},
				{
					Language.TraditionalChinese,
					"將所有人傳送到我身邊"
				},
				{
					Language.Japanese,
					"全員を自分の元へ"
				},
				{
					Language.Korean,
					"전원 내게 워프"
				},
				{
					Language.Italian,
					"Teletrasporta Tutti da Me"
				}
			}
		},
		{
			"lobby.refresh_players",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Refresh Players List"
				},
				{
					Language.SimplifiedChinese,
					"刷新玩家列表"
				},
				{
					Language.TraditionalChinese,
					"重新整理玩家列表"
				},
				{
					Language.Japanese,
					"プレイヤーリスト更新"
				},
				{
					Language.Korean,
					"플레이어 목록 새로고침"
				},
				{
					Language.Italian,
					"Aggiorna Lista Giocatori"
				}
			}
		},
		{
			"tip.refresh_players",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Manually reloads the list of players in case it didn't update automatically."
				},
				{
					Language.SimplifiedChinese,
					"手动重新加载玩家列表，以防未自动更新。"
				},
				{
					Language.TraditionalChinese,
					"手動重新載入玩家列表，以防未自動更新。"
				},
				{
					Language.Japanese,
					"自動更新されなかった場合に手動でプレイヤーリストを再読み込みします。"
				},
				{
					Language.Korean,
					"자동 업데이트되지 않은 경우 수동으로 플레이어 목록을 다시 불러옵니다."
				},
				{
					Language.Italian,
					"Ricarica manualmente l'elenco dei giocatori nel caso non si sia aggiornato automaticamente."
				}
			}
		},
		{
			"lobby.actions",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Actions"
				},
				{
					Language.SimplifiedChinese,
					"操作"
				},
				{
					Language.TraditionalChinese,
					"操作"
				},
				{
					Language.Japanese,
					"アクション"
				},
				{
					Language.Korean,
					"행동"
				},
				{
					Language.Italian,
					"Azioni"
				}
			}
		},
		{
			"lobby.revive",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Revive"
				},
				{
					Language.SimplifiedChinese,
					"复活"
				},
				{
					Language.TraditionalChinese,
					"復活"
				},
				{
					Language.Japanese,
					"復活"
				},
				{
					Language.Korean,
					"부활"
				},
				{
					Language.Italian,
					"Rianima"
				}
			}
		},
		{
			"lobby.kill",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Kill"
				},
				{
					Language.SimplifiedChinese,
					"击杀"
				},
				{
					Language.TraditionalChinese,
					"擊殺"
				},
				{
					Language.Japanese,
					"キル"
				},
				{
					Language.Korean,
					"처치"
				},
				{
					Language.Italian,
					"Uccidi"
				}
			}
		},
		{
			"lobby.warp_to",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Warp To"
				},
				{
					Language.SimplifiedChinese,
					"传送至"
				},
				{
					Language.TraditionalChinese,
					"傳送至"
				},
				{
					Language.Japanese,
					"ワープ"
				},
				{
					Language.Korean,
					"워프"
				},
				{
					Language.Italian,
					"Teletrasporta a"
				}
			}
		},
		{
			"lobby.warp_to_me",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Warp To Me"
				},
				{
					Language.SimplifiedChinese,
					"传送到我身边"
				},
				{
					Language.TraditionalChinese,
					"傳送到我身邊"
				},
				{
					Language.Japanese,
					"自分の元へ"
				},
				{
					Language.Korean,
					"내게 워프"
				},
				{
					Language.Italian,
					"Teletrasporta da Me"
				}
			}
		},
		{
			"lobby.special_actions",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Special Actions"
				},
				{
					Language.SimplifiedChinese,
					"特殊操作"
				},
				{
					Language.TraditionalChinese,
					"特殊操作"
				},
				{
					Language.Japanese,
					"特殊アクション"
				},
				{
					Language.Korean,
					"특수 행동"
				},
				{
					Language.Italian,
					"Azioni Speciali"
				}
			}
		},
		{
			"lobby.spawn_scoutmaster",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Spawn Scoutmaster"
				},
				{
					Language.SimplifiedChinese,
					"生成Scoutmaster"
				},
				{
					Language.TraditionalChinese,
					"生成Scoutmaster"
				},
				{
					Language.Japanese,
					"スカウトマスター召喚"
				},
				{
					Language.Korean,
					"스카우트마스터 소환"
				},
				{
					Language.Italian,
					"Genera Scoutmaster"
				}
			}
		},
		{
			"tip.spawn_scoutmaster",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Spawns a Scoutmaster near the selected player. Only works for host. Forces aggro."
				},
				{
					Language.SimplifiedChinese,
					"在选定玩家附近生成Scoutmaster。仅限房主使用。强制仇恨。"
				},
				{
					Language.TraditionalChinese,
					"在選定玩家附近生成Scoutmaster。僅限房主使用。強制仇恨。"
				},
				{
					Language.Japanese,
					"選択したプレイヤーの近くにスカウトマスターを召喚します。ホスト専用。アグロ強制。"
				},
				{
					Language.Korean,
					"선택한 플레이어 근처에 스카우트마스터를 소환합니다. 호스트 전용. 어그로 강제."
				},
				{
					Language.Italian,
					"Genera uno Scoutmaster vicino al giocatore selezionato. Funziona solo per l'host. Forza l'aggro."
				}
			}
		},
		{
			"lobby.no_player_selected",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"No player selected."
				},
				{
					Language.SimplifiedChinese,
					"未选择玩家。"
				},
				{
					Language.TraditionalChinese,
					"未選擇玩家。"
				},
				{
					Language.Japanese,
					"プレイヤーが選択されていません。"
				},
				{
					Language.Korean,
					"플레이어가 선택되지 않았습니다."
				},
				{
					Language.Italian,
					"Nessun giocatore selezionato."
				}
			}
		},
		{
			"world.containers",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Containers"
				},
				{
					Language.SimplifiedChinese,
					"容器"
				},
				{
					Language.TraditionalChinese,
					"容器"
				},
				{
					Language.Japanese,
					"コンテナ"
				},
				{
					Language.Korean,
					"컨테이너"
				},
				{
					Language.Italian,
					"Contenitori"
				}
			}
		},
		{
			"world.select_container",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Select Container"
				},
				{
					Language.SimplifiedChinese,
					"选择容器"
				},
				{
					Language.TraditionalChinese,
					"選擇容器"
				},
				{
					Language.Japanese,
					"コンテナ選択"
				},
				{
					Language.Korean,
					"컨테이너 선택"
				},
				{
					Language.Italian,
					"Seleziona Contenitore"
				}
			}
		},
		{
			"world.no_containers",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"No containers found."
				},
				{
					Language.SimplifiedChinese,
					"未找到容器。"
				},
				{
					Language.TraditionalChinese,
					"未找到容器。"
				},
				{
					Language.Japanese,
					"コンテナが見つかりません。"
				},
				{
					Language.Korean,
					"컨테이너를 찾을 수 없습니다."
				},
				{
					Language.Italian,
					"Nessun contenitore trovato."
				}
			}
		},
		{
			"world.refresh_luggage",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Refresh Luggage List"
				},
				{
					Language.SimplifiedChinese,
					"刷新行李列表"
				},
				{
					Language.TraditionalChinese,
					"重新整理行李列表"
				},
				{
					Language.Japanese,
					"荷物リスト更新"
				},
				{
					Language.Korean,
					"수하물 목록 새로고침"
				},
				{
					Language.Italian,
					"Aggiorna Lista Bagagli"
				}
			}
		},
		{
			"tip.refresh_luggage",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Reloads the list of luggage within 300m of your position."
				},
				{
					Language.SimplifiedChinese,
					"重新加载你位置300米内的行李列表。"
				},
				{
					Language.TraditionalChinese,
					"重新載入你位置300公尺內的行李列表。"
				},
				{
					Language.Japanese,
					"現在地から300m以内の荷物リストを再読み込みします。"
				},
				{
					Language.Korean,
					"현재 위치에서 300m 이내의 수하물 목록을 다시 불러옵니다."
				},
				{
					Language.Italian,
					"Ricarica l'elenco dei bagagli entro 300m dalla tua posizione."
				}
			}
		},
		{
			"world.all_nearby",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"All Nearby Containers"
				},
				{
					Language.SimplifiedChinese,
					"附近所有容器"
				},
				{
					Language.TraditionalChinese,
					"附近所有容器"
				},
				{
					Language.Japanese,
					"近くの全コンテナ"
				},
				{
					Language.Korean,
					"주변 모든 컨테이너"
				},
				{
					Language.Italian,
					"Tutti i Contenitori Vicini"
				}
			}
		},
		{
			"world.open_all_nearby",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Open All Nearby"
				},
				{
					Language.SimplifiedChinese,
					"打开附近所有"
				},
				{
					Language.TraditionalChinese,
					"打開附近所有"
				},
				{
					Language.Japanese,
					"近くを全て開く"
				},
				{
					Language.Korean,
					"주변 모두 열기"
				},
				{
					Language.Italian,
					"Apri Tutti i Vicini"
				}
			}
		},
		{
			"world.warp_to_luggage",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Warp To Luggage"
				},
				{
					Language.SimplifiedChinese,
					"传送到行李"
				},
				{
					Language.TraditionalChinese,
					"傳送到行李"
				},
				{
					Language.Japanese,
					"荷物にワープ"
				},
				{
					Language.Korean,
					"수하물로 워프"
				},
				{
					Language.Italian,
					"Teletrasporta al Bagaglio"
				}
			}
		},
		{
			"world.open_luggage",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Open Luggage"
				},
				{
					Language.SimplifiedChinese,
					"打开行李"
				},
				{
					Language.TraditionalChinese,
					"打開行李"
				},
				{
					Language.Japanese,
					"荷物を開く"
				},
				{
					Language.Korean,
					"수하물 열기"
				},
				{
					Language.Italian,
					"Apri Bagaglio"
				}
			}
		},
		{
			"world.no_luggage_selected",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"No luggage selected."
				},
				{
					Language.SimplifiedChinese,
					"未选择行李。"
				},
				{
					Language.TraditionalChinese,
					"未選擇行李。"
				},
				{
					Language.Japanese,
					"荷物が選択されていません。"
				},
				{
					Language.Korean,
					"수하물이 선택되지 않았습니다."
				},
				{
					Language.Italian,
					"Nessun bagaglio selezionato."
				}
			}
		},
		{
			"about.title",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"PEAK AIO Mod"
				},
				{
					Language.SimplifiedChinese,
					"PEAK AIO 模组"
				},
				{
					Language.TraditionalChinese,
					"PEAK AIO 模組"
				},
				{
					Language.Japanese,
					"PEAK AIO MOD"
				},
				{
					Language.Korean,
					"PEAK AIO 모드"
				},
				{
					Language.Italian,
					"PEAK AIO Mod"
				}
			}
		},
		{
			"about.version",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Version: 1.1.2"
				},
				{
					Language.SimplifiedChinese,
					"版本: 1.1.2"
				},
				{
					Language.TraditionalChinese,
					"版本: 1.1.2"
				},
				{
					Language.Japanese,
					"バージョン: 1.1.2"
				},
				{
					Language.Korean,
					"버전: 1.1.2"
				},
				{
					Language.Italian,
					"Versione: 1.1.2"
				}
			}
		},
		{
			"about.author",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Author: K1rito (Inspired by OniGremlin)"
				},
				{
					Language.SimplifiedChinese,
					"作者: K1rito (启发于OniGremlin)"
				},
				{
					Language.TraditionalChinese,
					"作者: K1rito (啟發於OniGremlin)"
				},
				{
					Language.Japanese,
					"作者: K1rito (OniGremlin からインスパイア)"
				},
				{
					Language.Korean,
					"제작자: K1rito (OniGremlin 에서 영감)"
				},
				{
					Language.Italian,
					"Autore: K1rito (Ispirato da OniGremlin)"
				}
			}
		},
		{
			"about.description",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"PEAK AIO is a quality-of-life and utility mod designed for the game PEAK. It brings together a wide range of player enhancements, inventory tools, world manipulation, and lobby control features in one sleek ImGui-powered interface."
				},
				{
					Language.SimplifiedChinese,
					"PEAK AIO 是为游戏 PEAK 设计的生活质量和实用模组。它将广泛的玩家增强、物品工具、世界操控和大厅控制功能集成在一个简洁的 ImGui 界面中。"
				},
				{
					Language.TraditionalChinese,
					"PEAK AIO 是為遊戲 PEAK 設計的生活品質和實用模組。它將廣泛的玩家增強、物品工具、世界操控和大廳控制功能整合在一個簡潔的 ImGui 介面中。"
				},
				{
					Language.Japanese,
					"PEAK AIO はゲーム PEAK 向けに設計されたQOL・ユーティリティMODです。プレイヤー強化、インベントリツール、ワールド操作、ロビー制御機能を、洗練されたImGuiインターフェースにまとめています。"
				},
				{
					Language.Korean,
					"PEAK AIO는 게임 PEAK를 위해 설계된 편의성 및 유틸리티 모드입니다. 플레이어 강화, 인벤토리 도구, 월드 조작, 로비 제어 기능을 세련된 ImGui 인터페이스에 통합했습니다."
				},
				{
					Language.Italian,
					"PEAK AIO è una mod di qualità di vita e utilità progettata per il gioco PEAK. Riunisce una vasta gamma di miglioramenti per il giocatore, strumenti per l'inventario, manipolazione del mondo e funzionalità di controllo della lobby in un'elegante interfaccia basata su ImGui."
				}
			}
		},
		{
			"about.key_features",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Key Features:"
				},
				{
					Language.SimplifiedChinese,
					"主要功能:"
				},
				{
					Language.TraditionalChinese,
					"主要功能:"
				},
				{
					Language.Japanese,
					"主な機能:"
				},
				{
					Language.Korean,
					"주요 기능:"
				},
				{
					Language.Italian,
					"Caratteristiche Principali:"
				}
			}
		},
		{
			"about.feature1",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Infinite stamina and affliction immunity"
				},
				{
					Language.SimplifiedChinese,
					"无限体力和状态异常免疫"
				},
				{
					Language.TraditionalChinese,
					"無限體力和狀態異常免疫"
				},
				{
					Language.Japanese,
					"無限スタミナと状態異常免疫"
				},
				{
					Language.Korean,
					"무한 스태미나 및 상태이상 면역"
				},
				{
					Language.Italian,
					"Stamina infinita e immunità alle afflizioni"
				}
			}
		},
		{
			"about.feature2",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Adjustable movement: speed, jump, and climb mods"
				},
				{
					Language.SimplifiedChinese,
					"可调节移动: 速度、跳跃和攀爬模组"
				},
				{
					Language.TraditionalChinese,
					"可調節移動: 速度、跳躍和攀爬模組"
				},
				{
					Language.Japanese,
					"速度・ジャンプ・登攀の調整可能なMOD"
				},
				{
					Language.Korean,
					"조정 가능한 이동: 속도, 점프, 등반 모드"
				},
				{
					Language.Italian,
					"Movimento regolabile: mod di velocità, salto e arrampicata"
				}
			}
		},
		{
			"about.feature3",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Real-time inventory editing and recharge"
				},
				{
					Language.SimplifiedChinese,
					"实时物品编辑和充能"
				},
				{
					Language.TraditionalChinese,
					"即時物品編輯和充能"
				},
				{
					Language.Japanese,
					"リアルタイムインベントリ編集とチャージ"
				},
				{
					Language.Korean,
					"실시간 인벤토리 편집 및 충전"
				},
				{
					Language.Italian,
					"Modifica e ricarica dell'inventario in tempo reale"
				}
			}
		},
		{
			"about.feature4",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Player-to-player warp, revive, and kill tools"
				},
				{
					Language.SimplifiedChinese,
					"玩家间传送、复活和击杀工具"
				},
				{
					Language.TraditionalChinese,
					"玩家間傳送、復活和擊殺工具"
				},
				{
					Language.Japanese,
					"プレイヤー間ワープ・復活・キルツール"
				},
				{
					Language.Korean,
					"플레이어 간 워프, 부활, 처치 도구"
				},
				{
					Language.Italian,
					"Strumenti di teletrasporto, rianimazione e uccisione tra giocatori"
				}
			}
		},
		{
			"about.feature5",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Custom teleportation and ping-based movement"
				},
				{
					Language.SimplifiedChinese,
					"自定义传送和基于标记的移动"
				},
				{
					Language.TraditionalChinese,
					"自訂傳送和基於標記的移動"
				},
				{
					Language.Japanese,
					"カスタムテレポートとピングベース移動"
				},
				{
					Language.Korean,
					"사용자 정의 텔레포트 및 핑 기반 이동"
				},
				{
					Language.Italian,
					"Teletrasporto personalizzato e movimento basato su ping"
				}
			}
		},
		{
			"about.feature6",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Stylized UI with tabbed interface"
				},
				{
					Language.SimplifiedChinese,
					"风格化的标签页界面"
				},
				{
					Language.TraditionalChinese,
					"具有分頁介面的風格化UI"
				},
				{
					Language.Japanese,
					"タブ付きスタイリッシュUI"
				},
				{
					Language.Korean,
					"탭 인터페이스를 갖춘 스타일리시 UI"
				},
				{
					Language.Italian,
					"Interfaccia stilizzata con schede"
				}
			}
		},
		{
			"about.thanks",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Special Thanks:"
				},
				{
					Language.SimplifiedChinese,
					"特别感谢:"
				},
				{
					Language.TraditionalChinese,
					"特別感謝:"
				},
				{
					Language.Japanese,
					"スペシャルサンクス:"
				},
				{
					Language.Korean,
					"특별 감사:"
				},
				{
					Language.Italian,
					"Ringraziamenti Speciali:"
				}
			}
		},
		{
			"about.thanks1",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Penswer for insight, and guidance"
				},
				{
					Language.SimplifiedChinese,
					"Penswer 提供的见解和指导"
				},
				{
					Language.TraditionalChinese,
					"Penswer 提供的見解和指導"
				},
				{
					Language.Japanese,
					"Penswer 氏の洞察とガイダンス"
				},
				{
					Language.Korean,
					"Penswer의 통찰과 안내"
				},
				{
					Language.Italian,
					"Penswer per intuizione e guida"
				}
			}
		},
		{
			"about.thanks2",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"BepInEx team for the modding framework"
				},
				{
					Language.SimplifiedChinese,
					"BepInEx 团队提供的模组框架"
				},
				{
					Language.TraditionalChinese,
					"BepInEx 團隊提供的模組框架"
				},
				{
					Language.Japanese,
					"BepInEx チームのMODフレームワーク"
				},
				{
					Language.Korean,
					"BepInEx 팀의 모딩 프레임워크"
				},
				{
					Language.Italian,
					"Team BepInEx per il framework di modding"
				}
			}
		},
		{
			"about.thanks3",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"DearImGuiInjection for seamless UI integration"
				},
				{
					Language.SimplifiedChinese,
					"DearImGuiInjection 提供的无缝UI集成"
				},
				{
					Language.TraditionalChinese,
					"DearImGuiInjection 提供的無縫UI整合"
				},
				{
					Language.Japanese,
					"DearImGuiInjection のシームレスなUI統合"
				},
				{
					Language.Korean,
					"DearImGuiInjection의 원활한 UI 통합"
				},
				{
					Language.Italian,
					"DearImGuiInjection per l'integrazione UI senza soluzione di continuità"
				}
			}
		},
		{
			"about.thanks4",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"HarmonyX for runtime patching support"
				},
				{
					Language.SimplifiedChinese,
					"HarmonyX 提供的运行时补丁支持"
				},
				{
					Language.TraditionalChinese,
					"HarmonyX 提供的執行時修補支援"
				},
				{
					Language.Japanese,
					"HarmonyX のランタイムパッチサポート"
				},
				{
					Language.Korean,
					"HarmonyX의 런타임 패치 지원"
				},
				{
					Language.Italian,
					"HarmonyX per il supporto al patching runtime"
				}
			}
		},
		{
			"about.disclaimer",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"This mod is provided as-is for educational and personal use. Not affiliated with or endorsed by the developers of PEAK. Use responsibly."
				},
				{
					Language.SimplifiedChinese,
					"此模组按原样提供，仅供教育和个人使用。与PEAK的开发者无关，也未获得其认可。请负责任地使用。"
				},
				{
					Language.TraditionalChinese,
					"此模組按原樣提供，僅供教育和個人使用。與PEAK的開發者無關，也未獲得其認可。請負責任地使用。"
				},
				{
					Language.Japanese,
					"このMODは教育および個人使用を目的として現状のまま提供されます。PEAKの開発者とは無関係であり、推奨もされていません。責任を持ってご使用ください。"
				},
				{
					Language.Korean,
					"이 모드는 교육 및 개인 용도로 있는 그대로 제공됩니다. PEAK 개발자와 관련이 없으며 승인을 받지 않았습니다. 책임감 있게 사용하세요."
				},
				{
					Language.Italian,
					"Questa mod è fornita così com'è per uso educativo e personale. Non affiliata o approvata dagli sviluppatori di PEAK. Usare responsabilmente."
				}
			}
		},
		{
			"lang.title",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Language Settings"
				},
				{
					Language.SimplifiedChinese,
					"语言设置"
				},
				{
					Language.TraditionalChinese,
					"語言設定"
				},
				{
					Language.Japanese,
					"言語設定"
				},
				{
					Language.Korean,
					"언어 설정"
				},
				{
					Language.Italian,
					"Impostazioni Lingua"
				}
			}
		},
		{
			"lang.select",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Select Language:"
				},
				{
					Language.SimplifiedChinese,
					"选择语言:"
				},
				{
					Language.TraditionalChinese,
					"選擇語言:"
				},
				{
					Language.Japanese,
					"言語を選択:"
				},
				{
					Language.Korean,
					"언어 선택:"
				},
				{
					Language.Italian,
					"Seleziona Lingua:"
				}
			}
		},
		{
			"lang.current",
			new Dictionary<Language, string>
			{
				{
					Language.English,
					"Current Language: English"
				},
				{
					Language.SimplifiedChinese,
					"当前语言: 简体中文"
				},
				{
					Language.TraditionalChinese,
					"當前語言: 繁體中文"
				},
				{
					Language.Japanese,
					"現在の言語: 日本語"
				},
				{
					Language.Korean,
					"현재 언어: 한국어"
				},
				{
					Language.Italian,
					"Lingua Corrente: Italiano"
				}
			}
		}
	};

	public static readonly string[] LanguageNames = new string[6] { "English", "简体中文", "日本語", "한국어", "Italiano", "繁體中文" };

	public static string T(string key)
	{
		if (Strings.TryGetValue(key, out var value))
		{
			if (value.TryGetValue(CurrentLanguage, out var value2))
			{
				return value2;
			}
			if (value.TryGetValue(Language.English, out var value3))
			{
				return value3;
			}
		}
		return key;
	}

	public static string T(string key, params object[] args)
	{
		return string.Format(T(key), args);
	}

	public static void SetLanguage(Language lang)
	{
		CurrentLanguage = lang;
	}

	public static void SetLanguage(int index)
	{
		if (index >= 0 && index < LanguageNames.Length)
		{
			CurrentLanguage = (Language)index;
		}
	}
}
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInPlugin("com.onigremlin.peakaio", "PEAK AIO Mod", "1.1.2")]
public class PeakMod : BaseUnityPlugin
{
	private bool styleApplied;

	private bool showMenu;

	private bool wasMenuScene;

	private int selectedTab = 1;

	private static readonly FieldInfo cursorVisibleField = typeof(DearImGuiInjection).GetField("<IsCursorVisible>k__BackingField", BindingFlags.Static | BindingFlags.NonPublic);

	private static readonly MethodInfo updateCursorMethod = typeof(DearImGuiInjection).GetMethod("UpdateCursorVisibility", BindingFlags.Static | BindingFlags.NonPublic);

	private void ApplyCustomStyle()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		//IL_000d: Unknown result type (might be due to invalid IL or missing references)
		ImGuiStylePtr style = ImGui.GetStyle();
		RangeAccessor<Vector4> colors = ((ImGuiStylePtr)(ref style)).Colors;
		Vector4 vector = new Vector4(0.953f, 0.941f, 0.902f, 1f);
		Vector4 vector2 = new Vector4(0.361f, 0.294f, 0.231f, 1f);
		Vector4 vector3 = new Vector4(0.18f, 0.18f, 0.18f, 1f);
		Vector4 vector4 = new Vector4(0.18f, 0.28f, 0.22f, 1f);
		Vector4 vector5 = new Vector4(0.866f, 0.827f, 0.741f, 1f);
		Vector4 vector6 = new Vector4(0.8f, 0.78f, 0.65f, 1f);
		Vector4 vector7 = new Vector4(0.75f, 0.72f, 0.61f, 1f);
		Vector4 vector8 = new Vector4(0.55f, 0.42f, 0.28f, 1f);
		new Vector4(0.75f, 0.6f, 0.5f, 1f);
		new Vector4(0.76f, 0.44f, 0.39f, 1f);
		Vector4 vector9 = new Vector4(0.318f, 0.569f, 0.384f, 1f);
		colors[2] = vector;
		colors[5] = vector3;
		colors[10] = vector9;
		colors[11] = vector9;
		colors[0] = vector3;
		colors[1] = vector8;
		colors[18] = vector4;
		colors[7] = vector5;
		colors[8] = vector6;
		colors[9] = vector7;
		colors[5] = vector8;
		colors[4] = vector;
		colors[44] = vector9;
		colors[45] = vector8;
		colors[46] = vector8;
		colors[3] = vector5;
		colors[21] = vector5;
		colors[22] = vector6;
		colors[23] = vector7;
		colors[24] = vector5;
		colors[25] = vector5;
		colors[26] = vector5;
		colors[27] = vector8;
		colors[14] = vector2;
		colors[15] = vector4;
		colors[16] = new Vector4(vector4.X + 0.1f, vector4.Y + 0.1f, vector4.Z + 0.1f, 1f);
		colors[17] = new Vector4(vector4.X - 0.05f, vector4.Y - 0.05f, vector4.Z - 0.05f, 1f);
		colors[19] = vector4;
		colors[20] = new Vector4(vector4.X - 0.05f, vector4.Y - 0.05f, vector4.Z - 0.05f, 1f);
		((ImGuiStylePtr)(ref style)).WindowRounding = 6f;
		((ImGuiStylePtr)(ref style)).FrameRounding = 4f;
		((ImGuiStylePtr)(ref style)).ChildRounding = 4f;
		((ImGuiStylePtr)(ref style)).FrameBorderSize = 1f;
		((ImGuiStylePtr)(ref style)).GrabRounding = 4f;
		((ImGuiStylePtr)(ref style)).WindowPadding = new Vector2(4f, 4f);
		((ImGuiStylePtr)(ref style)).CellPadding = new Vector2(4f, 4f);
		((ImGuiStylePtr)(ref style)).FrameBorderSize = 1f;
		((ImGuiStylePtr)(ref style)).ItemSpacing = new Vector2(2f, 4f);
	}

	private void Awake()
	{
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Mod Initialized");
		((Component)this).gameObject.AddComponent<EventComponent>();
	}

	private void OnEnable()
	{
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Expected O, but got Unknown
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0092: Expected O, but got Unknown
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_016b: Expected O, but got Unknown
		((BaseUnityPlugin)this).Logger.LogInfo((object)"[PEAK AIO] OnEnable called");
		Globals.itemSearchBuffers = new string[3] { "", "", "" };
		ConfigManager.Init(((BaseUnityPlugin)this).Config, ((BaseUnityPlugin)this).Logger);
		DearImGuiInjection.Render += MyUI;
		Harmony val = new Harmony("com.onigremlin.peakaio");
		val.PatchAll();
		Assembly assembly = typeof(DearImGuiInjection).Assembly;
		HarmonyMethod val2 = new HarmonyMethod(typeof(CJKFontPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.Public));
		string[] array = new string[2] { "DearImGuiInjection.Backends.ImGuiDX12Impl", "DearImGuiInjection.Backends.ImGuiDX11Impl" };
		foreach (string text in array)
		{
			try
			{
				Type type = assembly.GetType(text);
				if (!(type == null))
				{
					MethodInfo method = type.GetMethod("NewFrame", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					if (!(method == null))
					{
						val.Patch((MethodBase)method, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
						((BaseUnityPlugin)this).Logger.LogInfo((object)("[PEAK AIO] Patched " + text + ".NewFrame for CJK fonts."));
					}
				}
			}
			catch (Exception ex)
			{
				((BaseUnityPlugin)this).Logger.LogWarning((object)("[PEAK AIO] Failed to patch " + text + ".NewFrame: " + ex.Message));
			}
		}
		HarmonyMethod val3 = new HarmonyMethod(typeof(ImGuiInputPatch).GetMethod("Prefix", BindingFlags.Static | BindingFlags.Public));
		MethodInfo method2 = typeof(ImGui).GetMethod("NewFrame", BindingFlags.Static | BindingFlags.Public);
		if (method2 != null)
		{
			val.Patch((MethodBase)method2, val3, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"[PEAK AIO] Patched ImGui.NewFrame for input override.");
		}
		else
		{
			((BaseUnityPlugin)this).Logger.LogWarning((object)"[PEAK AIO] Could not find ImGui.NewFrame to patch for input.");
		}
		((BaseUnityPlugin)this).Logger.LogInfo((object)"Harmony patches applied.");
	}

	private void OnDisable()
	{
		((BaseUnityPlugin)this).Logger.LogInfo((object)"[PEAK AIO] OnDisable called");
		DearImGuiInjection.Render -= MyUI;
		if (!showMenu || wasMenuScene)
		{
			return;
		}
		try
		{
			CursorHandler instance = Singleton<CursorHandler>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.isMenuScene = false;
			}
		}
		catch
		{
		}
	}

	private void Update()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		if (Input.GetKeyDown(ConfigManager.MenuToggleKey.Value))
		{
			showMenu = !showMenu;
			try
			{
				CursorHandler instance = Singleton<CursorHandler>.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					if (showMenu)
					{
						wasMenuScene = instance.isMenuScene;
						if (!wasMenuScene)
						{
							instance.isMenuScene = true;
						}
					}
					else if (!wasMenuScene)
					{
						instance.isMenuScene = false;
					}
				}
			}
			catch
			{
			}
			cursorVisibleField?.SetValue(null, showMenu);
			updateCursorMethod?.Invoke(null, null);
			ImGuiInputPatch.ResetLogs();
		}
		if (showMenu)
		{
			ImGuiInputPatch.SetForceInput(enabled: true);
			ImGuiInputPatch.CaptureInput();
		}
		else
		{
			ImGuiInputPatch.SetForceInput(enabled: false);
		}
	}

	private void DrawCheckbox(ConfigEntry<bool> config, string label, Action<bool> mainThreadAction = null)
	{
		bool value = config.Value;
		if (!ImGui.Checkbox(label, ref value))
		{
			return;
		}
		config.Value = value;
		((BaseUnityPlugin)this).Logger.LogInfo((object)("[Menu] " + label + " toggled to " + (value ? "ON" : "OFF")));
		if (mainThreadAction != null)
		{
			UnityMainThreadDispatcher.Enqueue((Action)delegate
			{
				mainThreadAction(value);
			});
		}
	}

	private void DrawSliderFloat(ConfigEntry<float> config, string label, float min, float max, string format = "%.2f")
	{
		float value = config.Value;
		if (ImGui.SliderFloat(label, ref value, min, max, format))
		{
			config.Value = value;
		}
	}

	private bool DrawSearchableCombo(string label, ref int selectedIndex, List<string> items, ref string searchBuffer)
	{
		bool result = false;
		string text = "Search##" + label;
		ImGui.PushItemWidth(ImGui.GetContentRegionAvail().X - 4f);
		ImGui.InputText("##" + text, ref searchBuffer, 100u);
		ImGui.PopItemWidth();
		if (string.IsNullOrEmpty(searchBuffer) && !ImGui.IsItemActive())
		{
			Vector2 itemRectMin = ImGui.GetItemRectMin();
			ImGui.SameLine();
			ImGui.SetCursorScreenPos(itemRectMin + new Vector2(4f, 2f));
			ImGui.PushStyleColor((ImGuiCol)0, new Vector4(0.18f, 0.18f, 0.18f, 1f));
			ImGui.TextUnformatted(Localization.T("items.search"));
			ImGui.PopStyleColor();
		}
		if (ImGui.BeginCombo(label, (selectedIndex >= 0 && selectedIndex < items.Count) ? items[selectedIndex] : Localization.T("items.none")))
		{
			for (int i = 0; i < items.Count; i++)
			{
				if (string.IsNullOrEmpty(searchBuffer) || items[i].ToLower().Contains(searchBuffer.ToLower()))
				{
					bool flag = selectedIndex == i;
					if (ImGui.Selectable($"{items[i]}##{i}", flag))
					{
						selectedIndex = i;
						result = true;
					}
					if (flag)
					{
						ImGui.SetItemDefaultFocus();
					}
				}
			}
			ImGui.EndCombo();
		}
		return result;
	}

	private void DrawToolTip(string text)
	{
		ImGui.SameLine();
		ImGui.TextDisabled("(?)");
		if (ImGui.IsItemHovered())
		{
			ImGui.PushStyleColor((ImGuiCol)4, new Vector4(0.89f, 0.82f, 0.7f, 1f));
			ImGui.PushStyleColor((ImGuiCol)0, new Vector4(0.18f, 0.18f, 0.18f, 1f));
			ImGui.PushStyleVar((ImGuiStyleVar)4, 1f);
			ImGui.BeginTooltip();
			ImGui.PushTextWrapPos(450f);
			ImGui.TextUnformatted(text);
			ImGui.PopTextWrapPos();
			ImGui.EndTooltip();
			ImGui.PopStyleVar();
			ImGui.PopStyleColor(2);
		}
	}

	private void MyUI()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0068: Unknown result type (might be due to invalid IL or missing references)
		//IL_1193: Unknown result type (might be due to invalid IL or missing references)
		//IL_1198: Unknown result type (might be due to invalid IL or missing references)
		//IL_11aa: Unknown result type (might be due to invalid IL or missing references)
		//IL_11b1: Unknown result type (might be due to invalid IL or missing references)
		//IL_11b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_1408: Unknown result type (might be due to invalid IL or missing references)
		//IL_1418: Unknown result type (might be due to invalid IL or missing references)
		bool flag = false;
		try
		{
			if (!showMenu)
			{
				return;
			}
			ImGuiInputPatch.ApplyToImGui();
			ImGuiIOPtr iO = ImGui.GetIO();
			ref ImGuiConfigFlags configFlags = ref ((ImGuiIOPtr)(ref iO)).ConfigFlags;
			configFlags = (ImGuiConfigFlags)((uint)configFlags & 0xFFFFFFEFu);
			if (!styleApplied)
			{
				ApplyCustomStyle();
				styleApplied = true;
			}
			if (Localization.CurrentLanguage == Language.Korean && CJKFontPatch.HasKoreanFont)
			{
				ImGui.PushFont(CJKFontPatch.KoreanFont);
				flag = true;
			}
			else if (Localization.CurrentLanguage != Language.Korean && CJKFontPatch.HasCjkFont)
			{
				ImGui.PushFont(CJKFontPatch.CjkFont);
				flag = true;
			}
			ImGui.SetNextWindowPos(new Vector2(20f, 20f), (ImGuiCond)2);
			ImGui.SetNextWindowSize(new Vector2(500f, 300f), (ImGuiCond)2);
			ImGui.SetNextWindowFocus();
			if (ImGui.Begin("PEAK AIO##Main", (ImGuiWindowFlags)32))
			{
				ImGui.BeginChild("Sidebar", new Vector2(85f, 0f), true);
				ImGui.Dummy(new Vector2(4f, 2f));
				string[] array = new string[6] { "tab.player", "tab.items", "tab.lobby", "tab.world", "tab.about", "tab.language" };
				for (int i = 0; i < array.Length; i++)
				{
					bool flag2 = selectedTab == i + 1;
					string text = Localization.T(array[i]);
					Vector4 vector = (flag2 ? new Vector4(0.318f, 0.569f, 0.384f, 1f) : new Vector4(0.18f, 0.18f, 0.18f, 1f));
					ImGui.PushStyleColor((ImGuiCol)0, vector);
					float x = ImGui.CalcTextSize(text).X;
					ImGui.SetCursorPosX((ImGui.GetContentRegionAvail().X - x) * 0.5f);
					if (ImGui.Selectable(text + "##tab" + i, flag2))
					{
						selectedTab = i + 1;
					}
					ImGui.PopStyleColor();
				}
				ImGui.EndChild();
				ImGui.SameLine()