using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using ComputerMod.Core;
using ComputerMod.Foundation.Classes;
using ComputerMod.Foundation.Compatibility;
using ComputerMod.Foundation.Items;
using ComputerMod.Foundation.UI;
using HarmonyLib;
using Jotunn.Configs;
using Jotunn.Entities;
using Jotunn.Managers;
using Jotunn.Utils;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Computer-classes")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.3.1.0")]
[assembly: AssemblyInformationalVersion("0.3.1")]
[assembly: AssemblyProduct("Computer-classes")]
[assembly: AssemblyTitle("Computer-classes")]
[assembly: AssemblyVersion("0.3.1.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace ComputerMod.Foundation
{
	[BepInPlugin("com.froze.computermod.foundation", "Computer-classes", "0.3.1")]
	[BepInDependency("com.jotunn.jotunn", "2.30.1")]
	[NetworkCompatibility(/*Could not decode attribute arguments.*/)]
	public sealed class ComputerModPlugin : BaseUnityPlugin
	{
		private Harmony? _harmony;

		internal static ManualLogSource Logger { get; private set; }

		private void Awake()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			ClassService.Initialize(((BaseUnityPlugin)this).Config, Logger);
			try
			{
				_harmony = new Harmony("com.froze.computermod.foundation");
				_harmony.PatchAll(typeof(ComputerModPlugin).Assembly);
				ClassStone.Install(Logger);
				if (!Application.isBatchMode)
				{
					ClassMenu.Install();
				}
				Logger.LogInfo((object)"Computer-classes 0.3.1 loaded; patches active. Class Stone registration queued.");
			}
			catch (Exception arg)
			{
				Harmony? harmony = _harmony;
				if (harmony != null)
				{
					harmony.UnpatchSelf();
				}
				ClassStone.Uninstall();
				Logger.LogError((object)string.Format("{0} initialization failed; patches removed: {1}", "Computer-classes", arg));
			}
		}

		private void OnDestroy()
		{
			ClassService.Save(Player.m_localPlayer);
			ClassStone.Uninstall();
			ClassMenu.Uninstall();
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
}
namespace ComputerMod.Foundation.UI
{
	internal sealed class ClassMenu : MonoBehaviour
	{
		private static ClassMenu? _instance;

		private bool _visible;

		private bool _confirm;

		private PlayerClass _selected = PlayerClass.Tank;

		private int _tab;

		private string? _backup;

		private string[] _backups = Array.Empty<string>();

		private Vector2 _scroll;

		private Texture2D? _pixel;

		private GUIStyle? _title;

		private GUIStyle? _body;

		private GUIStyle? _section;

		private GUIStyle? _button;

		private CursorLockMode _oldLock;

		private bool _oldCursor;

		private Player? _openedFor;

		internal static void Install()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			if (!((Object)(object)_instance != (Object)null))
			{
				GameObject val = new GameObject("ComputerMod.ClassMenu");
				Object.DontDestroyOnLoad((Object)(object)val);
				_instance = val.AddComponent<ClassMenu>();
			}
		}

		internal static void Uninstall()
		{
			if (!((Object)(object)_instance == (Object)null))
			{
				_instance.Close();
				Object.Destroy((Object)(object)((Component)_instance).gameObject);
				_instance = null;
			}
		}

		internal static void Toggle()
		{
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_instance == (Object)null) && !((Object)(object)Player.m_localPlayer == (Object)null))
			{
				if (_instance._visible)
				{
					_instance.Close();
					return;
				}
				ClassMenu instance = _instance;
				instance._openedFor = Player.m_localPlayer;
				PlayerClass current = ClassService.Current;
				instance._selected = ((current == PlayerClass.None) ? PlayerClass.Tank : current);
				instance._confirm = false;
				instance._tab = ((!ClassService.TutorialSeen) ? 3 : 0);
				instance._backups = ClassService.Backups();
				instance._backup = null;
				instance._scroll = Vector2.zero;
				instance._oldLock = Cursor.lockState;
				instance._oldCursor = Cursor.visible;
				instance._visible = true;
				GUIManager.BlockInput(true);
			}
		}

		private void Close()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (_visible)
			{
				_visible = false;
				GUIManager.BlockInput(false);
				Cursor.lockState = _oldLock;
				Cursor.visible = _oldCursor;
			}
		}

		private void Update()
		{
			if (_visible && ((Object)(object)Player.m_localPlayer == (Object)null || (Object)(object)Player.m_localPlayer != (Object)(object)_openedFor || ((Character)Player.m_localPlayer).IsDead()))
			{
				Close();
			}
		}

		private void LateUpdate()
		{
			if (_visible)
			{
				Cursor.lockState = (CursorLockMode)0;
				Cursor.visible = true;
			}
		}

		private void OnDestroy()
		{
			Close();
			if ((Object)(object)_pixel != (Object)null)
			{
				Object.Destroy((Object)(object)_pixel);
			}
		}

		private void Styles()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Expected O, but got Unknown
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			if (_title == null)
			{
				_title = new GUIStyle(GUI.skin.label)
				{
					fontSize = 25,
					fontStyle = (FontStyle)1,
					wordWrap = true
				};
				_body = new GUIStyle(GUI.skin.label)
				{
					fontSize = 15,
					wordWrap = true,
					richText = false
				};
				_section = new GUIStyle(_body)
				{
					fontSize = 17,
					fontStyle = (FontStyle)1
				};
				_button = new GUIStyle(GUI.skin.button)
				{
					fontSize = 16,
					wordWrap = true
				};
				_pixel = new Texture2D(1, 1);
				_pixel.SetPixel(0, 0, Color.white);
				_pixel.Apply();
			}
		}

		private void Fill(Rect rect, Color color)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: 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)
			Color color2 = GUI.color;
			GUI.color = color;
			GUI.DrawTexture(rect, (Texture)(object)_pixel);
			GUI.color = color2;
		}

		private void OnGUI()
		{
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_014a: 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)
			//IL_001e: Invalid comparison between Unknown and I4
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Invalid comparison between Unknown and I4
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			if (!_visible)
			{
				return;
			}
			if ((int)Event.current.type == 4 && (int)Event.current.keyCode == 27)
			{
				if (_confirm)
				{
					_confirm = false;
				}
				else
				{
					Close();
				}
				Event.current.Use();
				return;
			}
			Styles();
			Matrix4x4 matrix = GUI.matrix;
			Color color = GUI.color;
			bool enabled = GUI.enabled;
			try
			{
				GUI.color = Color.white;
				Fill(new Rect(0f, 0f, (float)Screen.width, (float)Screen.height), new Color(0f, 0f, 0f, 0.82f));
				float num = Mathf.Min(1.2f, Mathf.Min((float)Screen.width / 960f, (float)Screen.height / 730f));
				GUI.matrix = Matrix4x4.TRS(new Vector3(((float)Screen.width - 920f * num) / 2f, ((float)Screen.height - 690f * num) / 2f), Quaternion.identity, Vector3.one * num);
				DrawPanel();
			}
			finally
			{
				GUI.matrix = matrix;
				GUI.color = color;
				GUI.enabled = enabled;
			}
		}

		private void DrawPanel()
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0318: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_0322: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_05fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_04cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_0628: Unknown result type (might be due to invalid IL or missing references)
			//IL_062d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0476: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0774: Unknown result type (might be due to invalid IL or missing references)
			Fill(new Rect(0f, 0f, 920f, 690f), new Color(0.07f, 0.085f, 0.105f, 1f));
			Fill(new Rect(0f, 0f, 920f, 4f), new Color(0.8f, 0.61f, 0.3f, 1f));
			GUI.Label(new Rect(24f, 20f, 760f, 40f), "Computer-classes  v0.3.1", _title);
			GUI.Label(new Rect(24f, 67f, 865f, 44f), $"Active: {ClassService.Current}   |   {ClassService.SaveStatus}", _body);
			if (GUI.Button(new Rect(828f, 20f, 68f, 34f), "Close", _button))
			{
				Close();
			}
			string[] array = new string[4] { "Choose class", "Saved skills", "Backups", "How it works" };
			for (int i = 0; i < array.Length; i++)
			{
				GUI.color = (Color)((i == _tab) ? new Color(1f, 0.82f, 0.48f) : Color.white);
				if (GUI.Button(new Rect((float)(24 + i * 221), 117f, 214f, 36f), array[i], _button))
				{
					_tab = i;
					_confirm = false;
					_scroll = Vector2.zero;
				}
			}
			GUI.color = Color.white;
			if (_tab <= 1)
			{
				for (int j = 0; j < ClassDefinition.All.Length; j++)
				{
					ClassDefinition classDefinition = ClassDefinition.All[j];
					GUI.color = (Color)((classDefinition.Id == _selected) ? new Color(1f, 0.82f, 0.48f) : Color.white);
					string text = classDefinition.Title + ((classDefinition.Id == ClassService.Current) ? "  [active]" : "");
					if (GUI.Button(new Rect(24f, (float)(173 + j * 49), 218f, 41f), text, _button))
					{
						_selected = classDefinition.Id;
						_confirm = false;
						_scroll = Vector2.zero;
					}
				}
			}
			GUI.color = Color.white;
			Rect val = ((_tab <= 1) ? new Rect(263f, 174f, 630f, 380f) : new Rect(24f, 174f, 870f, 380f));
			GUILayout.BeginArea(val);
			_scroll = GUILayout.BeginScrollView(_scroll, Array.Empty<GUILayoutOption>());
			if (_tab == 0)
			{
				Details();
			}
			else if (_tab == 1)
			{
				GUILayout.Label($"{_selected} — saved progress", _section, Array.Empty<GUILayoutOption>());
				foreach (string item in ClassService.SkillSummary(_selected))
				{
					GUILayout.Label(item, _body, Array.Empty<GUILayoutOption>());
				}
			}
			else if (_tab == 2)
			{
				GUILayout.Label("Restore a previous class snapshot", _section, Array.Empty<GUILayoutOption>());
				GUILayout.Label("Backups belong to this character only. Restoring replaces all saved class progress with that snapshot. A backup of your current progress is made first.", _body, Array.Empty<GUILayoutOption>());
				if (_backups.Length == 0)
				{
					GUILayout.Label("No backups yet. One is created before your first class choice.", _body, Array.Empty<GUILayoutOption>());
				}
				string[] backups = _backups;
				foreach (string text2 in backups)
				{
					GUI.color = (Color)((_backup == text2) ? new Color(1f, 0.82f, 0.48f) : Color.white);
					if (GUILayout.Button(Path.GetFileNameWithoutExtension(text2), _button, (GUILayoutOption[])(object)new GUILayoutOption[1] { GUILayout.Height(34f) }))
					{
						_backup = text2;
						_confirm = false;
					}
				}
				GUI.color = Color.white;
			}
			else
			{
				GUILayout.Label("Your class can change. Your progress stays.", _title, Array.Empty<GUILayoutOption>());
				GUILayout.Label("1. Craft a Class Stone at a workbench using 1 Stone. Use it from your inventory or hotbar; it is reusable.", _body, Array.Empty<GUILayoutOption>());
				GUILayout.Space(10f);
				GUILayout.Label("2. Each class has separate skills, including modded skills and partial XP. A new class starts at zero. Returning restores its previous progress. Your pre-class skills are backed up on your first choice.", _body, Array.Empty<GUILayoutOption>());
				GUILayout.Space(10f);
				GUILayout.Label("3. The class preview lists XP bonuses and restrictions. Gathering remains available to everyone. Shields require Tank; bombs require Thrower. Other weapons remain usable, with class XP bonuses only for matching weapons.", _body, Array.Empty<GUILayoutOption>());
				GUILayout.Space(10f);
				GUILayout.Label("4. Restricted equipped items move into your normal inventory. If there is insufficient space, the change is refused. Attacking or taking damage delays switching; changes also have a 10-second cooldown.", _body, Array.Empty<GUILayoutOption>());
				GUILayout.Space(10f);
				GUILayout.Label("5. Multiplayer requires this exact mod version on every player and the server. Server-controlled balance settings synchronize through Jotunn. Character skill saves are client-owned, not an anti-cheat system.", _body, Array.Empty<GUILayoutOption>());
			}
			GUILayout.EndScrollView();
			GUILayout.EndArea();
			string text3 = ClassService.ChangeBlockReason();
			GUI.Label(new Rect(24f, 565f, 870f, 48f), (text3.Length > 0) ? text3 : ClassService.LastMessage, _body);
			if (_tab == 3)
			{
				if (GUI.Button(new Rect(24f, 626f, 870f, 42f), "Understood — choose a class", _button))
				{
					ClassService.DismissTutorial();
					_tab = 0;
					_scroll = Vector2.zero;
				}
			}
			else
			{
				if (_tab == 1)
				{
					return;
				}
				bool enabled = text3.Length == 0 && ((_tab == 2) ? (_backup != null) : (_selected != ClassService.Current));
				GUI.enabled = enabled;
				string text4 = ((_tab == 2) ? "Restore selected backup" : $"Change to {_selected}");
				if (_confirm)
				{
					GUI.Label(new Rect(24f, 607f, 870f, 22f), "Confirm: current skills will be saved, then selected progress will replace active skills.", _body);
					if (GUI.Button(new Rect(24f, 635f, 620f, 36f), "Confirm — " + text4, _button))
					{
						bool flag = ((_tab == 2) ? ClassService.RestoreBackup(_backup) : ClassService.Select(_selected));
						_confirm = false;
						if (flag)
						{
							_backups = ClassService.Backups();
						}
					}
					GUI.enabled = true;
					if (GUI.Button(new Rect(657f, 635f, 237f, 36f), "Cancel", _button))
					{
						_confirm = false;
					}
				}
				else if (GUI.Button(new Rect(24f, 626f, 870f, 42f), text4, _button))
				{
					_confirm = true;
				}
				GUI.enabled = true;
			}
		}

		private void Details()
		{
			ClassDefinition classDefinition = ClassDefinition.All.First((ClassDefinition c) => c.Id == _selected);
			GUILayout.Label(classDefinition.Title, _title, Array.Empty<GUILayoutOption>());
			GUILayout.Label(classDefinition.Summary, _body, Array.Empty<GUILayoutOption>());
			GUILayout.Space(10f);
			GUILayout.Label($"+{(ClassService.ExperienceMultiplier - 1f) * 100f:0.#}% experience", _section, Array.Empty<GUILayoutOption>());
			GUILayout.Label(classDefinition.BonusSkills, _body, Array.Empty<GUILayoutOption>());
			GUILayout.Space(10f);
			GUILayout.Label("Active effects", _section, Array.Empty<GUILayoutOption>());
			GUILayout.Label((_selected == PlayerClass.Tank) ? $"{ClassService.TankReduction * 100f:0.#}% less stamina for blocks and parries." : ((_selected == PlayerClass.Berserker) ? $"+{ClassService.RadiusBonus:0.#}m two-handed melee hit radius, including area attacks. This widens the existing attack; it does not create a separate explosion." : "No additional class combat effect."), _body, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Direct damage bonus: 0%. Direct damage penalty: 0%. Normal skill-based damage still applies.", _body, Array.Empty<GUILayoutOption>());
			GUILayout.Space(10f);
			GUILayout.Label("Equipment and skill rules", _section, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Shields: Tank only. Bombs: Thrower only. All classes may gather, craft, farm, cook and fish.", _body, Array.Empty<GUILayoutOption>());
			GUILayout.Label("Dual weapons, lances and tridents use Warrior bonuses. Other two-handed melee weapons use Berserker bonuses. Blood Magic receives no class XP bonus.", _body, Array.Empty<GUILayoutOption>());
			if (_selected == PlayerClass.Support)
			{
				GUILayout.Label("Also supports Mining, Lumberjacking, Blacksmithing, Sailing and PackHorse, plus Run, Jump, Swim, Sneak, Dodge and Ride. Unknown custom skills are not automatically treated as gathering.", _body, Array.Empty<GUILayoutOption>());
			}
		}
	}
}
namespace ComputerMod.Foundation.Patches
{
	[HarmonyPatch]
	internal static class BerserkerMeleeRadiusPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(Attack), "DoMeleeAttack", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(Attack), "DoAreaAttack", (Type[])null, (Type[])null);
		}

		private static void Prefix(Attack __instance, Humanoid ___m_character, ItemData ___m_weapon, out float? __state)
		{
			__state = null;
			if (!((Object)(object)Player.m_localPlayer == (Object)null) && !((Object)(object)___m_character != (Object)(object)Player.m_localPlayer) && ClassService.Current == PlayerClass.Berserker && ___m_weapon != null && WeaponRules.IsBerserker(___m_weapon))
			{
				__state = __instance.m_attackRayWidth;
				__instance.m_attackRayWidth += ClassService.RadiusBonus;
			}
		}

		private static void Finalizer(Attack __instance, float? __state)
		{
			if (__state.HasValue)
			{
				__instance.m_attackRayWidth = __state.Value;
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "EquipItem", new Type[]
	{
		typeof(ItemData),
		typeof(bool)
	})]
	internal static class ClassEquipmentRestrictionPatch
	{
		private static bool Prefix(Humanoid __instance, ItemData item, ref bool __result)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Invalid comparison between Unknown and I4
			if ((Object)(object)__instance != (Object)(object)Player.m_localPlayer || item == null || !WeaponRules.Locked(item, ClassService.Current))
			{
				return true;
			}
			__result = false;
			((Character)__instance).Message((MessageType)2, ((int)item.m_shared.m_itemType == 5) ? "Only Tanks can equip shields." : "Only Throwers can equip bombs.", 0, (Sprite)null, false);
			return false;
		}
	}
	[HarmonyPatch(typeof(Skills), "RaiseSkill")]
	internal static class ClassExperiencePatch
	{
		private static void Prefix(Skills __instance, SkillType skillType, ref float factor)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			factor *= ClassService.GetExperienceMultiplier(__instance, skillType);
		}
	}
	[HarmonyPatch(typeof(Player), "Save", new Type[] { typeof(ZPackage) })]
	internal static class ClassSavePatch
	{
		[HarmonyPriority(800)]
		private static void Prefix(Player __instance)
		{
			ClassService.Save(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "Load", new Type[] { typeof(ZPackage) })]
	internal static class ClassLoadPatch
	{
		private static void Postfix(Player __instance)
		{
			ClassService.OnLoaded(__instance);
		}
	}
	[HarmonyPatch(typeof(Player), "OnDamaged", new Type[] { typeof(HitData) })]
	internal static class ClassDamageLockPatch
	{
		private static void Postfix(Player __instance, HitData hit)
		{
			if (hit.GetTotalDamage() > 0f)
			{
				ClassService.MarkCombat(__instance);
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "StartAttack", new Type[]
	{
		typeof(Character),
		typeof(bool)
	})]
	internal static class ClassAttackLockPatch
	{
		private static void Postfix(Humanoid __instance, bool __result)
		{
			if (__result)
			{
				Player val = (Player)(object)((__instance is Player) ? __instance : null);
				if (val != null)
				{
					ClassService.MarkCombat(val);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Humanoid), "UseItem", new Type[]
	{
		typeof(Inventory),
		typeof(ItemData),
		typeof(bool)
	})]
	internal static class ClassStoneUsePatch
	{
		private static bool Prefix(Humanoid __instance, Inventory inventory, ItemData item)
		{
			if (!((Object)(object)__instance != (Object)(object)Player.m_localPlayer))
			{
				object obj;
				if (item == null)
				{
					obj = null;
				}
				else
				{
					GameObject dropPrefab = item.m_dropPrefab;
					obj = ((dropPrefab != null) ? ((Object)dropPrefab).name : null);
				}
				if (!((string?)obj != "ComputerMod_ClassStone"))
				{
					if ((inventory ?? __instance.GetInventory()).ContainsItem(item))
					{
						ClassMenu.Toggle();
					}
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Player), "GetEquipmentBlockStaminaModifier")]
	internal static class TankBlockStaminaPatch
	{
		private static void Postfix(Player __instance, ref float __result)
		{
			if ((Object)(object)__instance == (Object)(object)Player.m_localPlayer && ClassService.Current == PlayerClass.Tank)
			{
				__result = (1f + __result) * (1f - ClassService.TankReduction) - 1f;
			}
		}
	}
}
namespace ComputerMod.Foundation.Items
{
	internal static class ClassStone
	{
		internal const string PrefabName = "ComputerMod_ClassStone";

		private static bool _registered;

		private static ManualLogSource _logger;

		internal static void Install(ManualLogSource logger)
		{
			_logger = logger;
			PrefabManager.OnVanillaPrefabsAvailable -= Register;
			PrefabManager.OnVanillaPrefabsAvailable += Register;
		}

		internal static void Uninstall()
		{
			PrefabManager.OnVanillaPrefabsAvailable -= Register;
		}

		private static void Register()
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Expected O, but got Unknown
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			if (_registered)
			{
				return;
			}
			try
			{
				ItemConfig val = new ItemConfig();
				val.Name = "Class Stone";
				val.Description = "Use to choose a class, inspect bonuses and saved skills, or restore a class backup. Reusable.";
				val.CraftingStation = "piece_workbench";
				val.StackSize = 1;
				val.Requirements = (RequirementConfig[])(object)new RequirementConfig[1]
				{
					new RequirementConfig
					{
						Item = "Stone",
						Amount = 1
					}
				};
				ItemConfig val2 = val;
				CustomItem val3 = new CustomItem("ComputerMod_ClassStone", "Stone", val2);
				if ((Object)(object)val3.ItemDrop == (Object)null)
				{
					throw new InvalidOperationException("The Stone prefab is not available.");
				}
				val3.ItemDrop.m_itemData.m_shared.m_itemType = (ItemType)2;
				if (!ItemManager.Instance.AddItem(val3))
				{
					throw new InvalidOperationException("Jotunn rejected the Class Stone.");
				}
				_registered = true;
				Uninstall();
				_logger.LogInfo((object)"Registered Class Stone: craft from 1 Stone at a workbench; use to open the class menu.");
			}
			catch (Exception arg)
			{
				_logger.LogError((object)$"Class Stone registration failed: {arg}");
			}
		}
	}
}
namespace ComputerMod.Foundation.Compatibility
{
	internal sealed class EquipmentAdapter
	{
		private readonly Player _player;

		private readonly List<(ItemData Item, Vector2i Destination)> _moves = new List<(ItemData, Vector2i)>();

		private EquipmentAdapter(Player player)
		{
			_player = player;
		}

		internal static bool TryPlan(Player player, PlayerClass target, out EquipmentAdapter plan, out string error)
		{
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			plan = new EquipmentAdapter(player);
			error = "";
			Inventory inventory = ((Humanoid)player).GetInventory();
			int width = inventory.GetWidth();
			int num = inventory.GetHeight();
			Type type = AccessTools.TypeByName("AzuEPI.Core.InventoryHandlers.Layout");
			if (type != null)
			{
				try
				{
					num = Math.Min(num, (int)AccessTools.Property(type, "NormalInventoryRows").GetValue(null, null));
				}
				catch
				{
					error = "Cannot read equipment slots. Unequip restricted equipment manually before switching.";
					return false;
				}
			}
			List<ItemData> allItems = inventory.GetAllItems();
			HashSet<(int, int)> hashSet = new HashSet<(int, int)>(allItems.Select((ItemData i) => (x: i.m_gridPos.x, y: i.m_gridPos.y)));
			ItemData[] array = allItems.Where((ItemData i) => i.m_equipped && WeaponRules.Locked(i, target)).ToArray();
			foreach (ItemData val in array)
			{
				if (val.m_gridPos.y >= 0 && val.m_gridPos.y < num && val.m_gridPos.x >= 0 && val.m_gridPos.x < width)
				{
					plan._moves.Add((val, val.m_gridPos));
					continue;
				}
				Vector2i? val2 = null;
				for (int num3 = 0; num3 < num; num3++)
				{
					if (val2.HasValue)
					{
						break;
					}
					for (int num4 = 0; num4 < width; num4++)
					{
						if (hashSet.Add((num4, num3)))
						{
							val2 = new Vector2i(num4, num3);
							break;
						}
					}
				}
				if (!val2.HasValue)
				{
					error = "Cannot change class: clear space in your normal inventory for restricted equipment.";
					return false;
				}
				plan._moves.Add((val, val2.Value));
			}
			return true;
		}

		internal void Apply()
		{
			//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)
			foreach (var move in _moves)
			{
				((Humanoid)_player).UnequipItem(move.Item, false);
				if (move.Item.m_equipped)
				{
					throw new InvalidOperationException("Another mod prevented unequipping.");
				}
				if (!((Humanoid)_player).GetInventory().ContainsItem(move.Item) || ((Humanoid)_player).GetInventory().GetAllItems().Any((ItemData i) => i != move.Item && i.m_gridPos.x == move.Destination.x && i.m_gridPos.y == move.Destination.y))
				{
					throw new InvalidOperationException("Inventory changed while unequipping. No occupied slot was overwritten.");
				}
				move.Item.m_gridPos = move.Destination;
			}
			if (_moves.Count > 0)
			{
				AccessTools.Method(typeof(Inventory), "Changed", new Type[2]
				{
					typeof(bool),
					typeof(bool)
				}, (Type[])null).Invoke(((Humanoid)_player).GetInventory(), new object[2] { false, false });
			}
		}
	}
	internal static class WeaponRules
	{
		private static readonly string[] LifeNames = new string[9] { "Mining", "Lumberjacking", "Blacksmithing", "Cooking", "Farming", "Sailing", "PackHorse", "Fishing", "Crafting" };

		private static readonly Dictionary<SkillType, string> CustomLife = LifeNames.ToDictionary((string n) => (SkillType)StableId(n), (string n) => n);

		internal static readonly SkillType Throwing = (SkillType)StableId("Throwing");

		private static int StableId(string text)
		{
			int num = 5381;
			int num2 = num;
			for (int i = 0; i < text.Length; i += 2)
			{
				num = ((num << 5) + num) ^ text[i];
				if (i == text.Length - 1)
				{
					break;
				}
				num2 = ((num2 << 5) + num2) ^ text[i + 1];
			}
			return Math.Abs(num + num2 * 1566083941);
		}

		private static bool Has(ItemData item, params string[] names)
		{
			string name = (((Object)(object)item.m_dropPrefab != (Object)null) ? ((Object)item.m_dropPrefab).name : item.m_shared.m_name);
			return names.Any((string n) => name.IndexOf(n, StringComparison.OrdinalIgnoreCase) >= 0);
		}

		internal static bool IsBomb(ItemData item)
		{
			return Has(item, "Bomb", "Grenade");
		}

		internal static bool IsWarrior(ItemData item)
		{
			return Has(item, "Dual", "Lance", "Trident") || ((object)Unsafe.As<ItemType, ItemType>(ref item.m_shared.m_itemType)/*cast due to .constrained prefix*/).ToString().Equals("TwoHandedWeaponLeft");
		}

		internal static bool IsBerserker(ItemData item)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Invalid comparison between Unknown and I4
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Invalid comparison between Unknown and I4
			return (int)item.m_shared.m_itemType == 14 && !IsWarrior(item) && (int)item.m_shared.m_skillType != 9 && (int)item.m_shared.m_skillType != 10 && (int)item.m_shared.m_skillType != 12 && (int)item.m_shared.m_skillType != 8 && (int)item.m_shared.m_skillType != 14;
		}

		internal static bool Locked(ItemData item, PlayerClass target)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			return target != PlayerClass.None && (((int)item.m_shared.m_itemType == 5 && target != PlayerClass.Tank) || (IsBomb(item) && target != PlayerClass.Thrower));
		}

		internal static bool IsLife(SkillType skill)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Invalid comparison between Unknown and I4
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Invalid comparison between Unknown and I4
			bool flag = CustomLife.ContainsKey(skill);
			bool flag2 = flag;
			if (!flag2)
			{
				bool flag3 = ((skill - 12 <= 1 || skill - 100 <= 8 || (int)skill == 110) ? true : false);
				flag2 = flag3;
			}
			return flag2;
		}

		internal static bool Boosts(PlayerClass cls, SkillType skill, ItemData? weapon)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Invalid comparison between Unknown and I4
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Invalid comparison between Unknown and I4
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Invalid comparison between Unknown and I4
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Invalid comparison between Unknown and I4
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Invalid comparison between Unknown and I4
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Invalid comparison between Unknown and I4
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Invalid comparison between Unknown and I4
			switch (cls)
			{
			case PlayerClass.Support:
				return IsLife(skill);
			case PlayerClass.Tank:
				return (int)skill == 6;
			case PlayerClass.Ranger:
				return ((int)skill == 8 || (int)skill == 14) ? true : false;
			case PlayerClass.Magician:
				return (int)skill == 9;
			case PlayerClass.Thrower:
				if (skill == Throwing)
				{
					return true;
				}
				break;
			}
			bool flag = cls == PlayerClass.Rogue;
			bool flag2 = flag;
			bool flag3;
			if (flag2)
			{
				flag3 = (((int)skill == 11 || (int)skill == 101) ? true : false);
				flag2 = flag3;
			}
			if (flag2)
			{
				return true;
			}
			if (weapon == null || weapon.m_shared.m_skillType != skill || IsLife(skill))
			{
				return false;
			}
			if (1 == 0)
			{
			}
			flag3 = cls switch
			{
				PlayerClass.Rogue => !IsWarrior(weapon) && !IsBomb(weapon) && ((int)weapon.m_shared.m_itemType == 3 || (int)skill == 5), 
				PlayerClass.Berserker => IsBerserker(weapon), 
				PlayerClass.Warrior => IsWarrior(weapon), 
				PlayerClass.Thrower => IsBomb(weapon) || Has(weapon, "Throw"), 
				_ => false, 
			};
			if (1 == 0)
			{
			}
			return flag3;
		}

		internal unsafe static string SkillName(SkillType skill)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: 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_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Expected I4, but got Unknown
			if (CustomLife.TryGetValue(skill, out string value))
			{
				return value;
			}
			if (skill == Throwing)
			{
				return "Throwing";
			}
			string text = "$skill_" + (Enum.IsDefined(typeof(SkillType), skill) ? ((object)(*(SkillType*)(&skill))/*cast due to .constrained prefix*/).ToString().ToLowerInvariant() : ((int)skill).ToString());
			Localization instance = Localization.instance;
			string text2 = ((instance != null) ? instance.Localize(text) : null);
			return (string.IsNullOrEmpty(text2) || text2.Contains("skill_")) ? ((object)(*(SkillType*)(&skill))/*cast due to .constrained prefix*/).ToString() : text2;
		}
	}
}
namespace ComputerMod.Foundation.Classes
{
	public sealed class ClassDefinition
	{
		public static readonly ClassDefinition[] All = new ClassDefinition[8]
		{
			new ClassDefinition(PlayerClass.Tank, "Tank", "Defensive shield specialist.", "Blocking", "Only Tanks can equip shields. Blocking costs 15% less stamina."),
			new ClassDefinition(PlayerClass.Rogue, "Rogue", "Fast one-handed fighter and stealth user.", "One-handed weapons, Spears, Unarmed, Sneak", "Cannot equip shields."),
			new ClassDefinition(PlayerClass.Ranger, "Ranger", "Dedicated ranged weapon user.", "Bows, Crossbows", "Shields require Tank; bombs require Thrower."),
			new ClassDefinition(PlayerClass.Thrower, "Thrower", "Thrown-weapon and explosive specialist.", "Throwing weapons", "Only Throwers can equip bombs and thrown explosives."),
			new ClassDefinition(PlayerClass.Support, "Support", "Gathering, crafting, and life-skill specialist.", "Fishing, Cooking, Farming, Pickaxes, WoodCutting, Mining, Lumberjacking, Blacksmithing, Crafting, Sailing, PackHorse, Run, Jump, Swim, Sneak, Dodge, Ride", "Shields require Tank; bombs require Thrower."),
			new ClassDefinition(PlayerClass.Magician, "Magician", "Elemental spellcaster.", "Elemental Magic", "Shields require Tank; bombs require Thrower."),
			new ClassDefinition(PlayerClass.Berserker, "Berserker", "Two-handed melee area-damage specialist.", "Two-handed melee weapons, excluding Warrior weapons, magic, bows and gathering tools", "Shields require Tank; bombs require Thrower. Radius bonus is configurable."),
			new ClassDefinition(PlayerClass.Warrior, "Warrior", "Dual-wield, lance, and trident specialist.", "Dual-wield weapons, Lances, Tridents", "Shields require Tank; bombs require Thrower.")
		};

		public PlayerClass Id { get; }

		public string Title { get; }

		public string Summary { get; }

		public string BonusSkills { get; }

		public string Restrictions { get; }

		public ClassDefinition(PlayerClass id, string title, string summary, string bonusSkills, string restrictions)
		{
			Id = id;
			Title = title;
			Summary = summary;
			BonusSkills = bonusSkills;
			Restrictions = restrictions;
		}
	}
	public static class ClassService
	{
		private const string SaveKey = "ComputerMod.Classes.v1";

		private static readonly MethodInfo GetSkill = AccessTools.Method(typeof(Skills), "GetSkill", (Type[])null, (Type[])null);

		private static readonly MethodInfo GetSkillDef = AccessTools.Method(typeof(Skills), "GetSkillDef", (Type[])null, (Type[])null);

		private static ConfigFile _config = null;

		private static ManualLogSource _logger = null;

		private static Player? _owner;

		private static ClassProgress? _progress;

		private static string? _loadError;

		private static float _nextChange;

		private static float _combatUntil;

		private static ConfigEntry<float> _xp = null;

		private static ConfigEntry<float> _tank = null;

		private static ConfigEntry<float> _radius = null;

		private static ConfigEntry<float> _combatLock = null;

		public static string LastMessage { get; private set; } = "";

		public static PlayerClass Current
		{
			get
			{
				EnsurePlayer();
				ClassProgress? progress = _progress;
				return (progress != null) ? ((PlayerClass)progress.CurrentClass) : PlayerClass.None;
			}
		}

		public static float ExperienceMultiplier => _xp.Value;

		public static float TankReduction => _tank.Value;

		public static float RadiusBonus => _radius.Value;

		public static bool TutorialSeen
		{
			get
			{
				ClassProgress? progress = _progress;
				return progress != null && progress.TutorialSeen;
			}
		}

		public static string SaveStatus => _loadError ?? "Class levels and partial XP are saved with this character.";

		private static string BackupDirectory => Path.Combine(Path.GetDirectoryName(_config.ConfigFilePath), "ComputerModBackups");

		public static void Initialize(ConfigFile config, ManualLogSource logger)
		{
			_config = config;
			_logger = logger;
			_xp = Setting("Class XP multiplier", 1.5f, 1f, 5f, "XP multiplier for skills supported by your class.");
			_tank = Setting("Tank block stamina reduction", 0.15f, 0f, 0.9f, "Reduces blocking and parrying stamina cost. 0.15 = 15%.");
			_radius = Setting("Berserker melee radius bonus", 1f, 0f, 5f, "Extra metres of hit radius for two-handed melee and area attacks.");
			_combatLock = Setting("Combat class change lock", 30f, 0f, 300f, "Seconds after attacking or taking damage before switching or restoring.");
		}

		private static ConfigEntry<float> Setting(string key, float value, float min, float max, string description)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Expected O, but got Unknown
			return _config.Bind<float>("Class Bonuses", key, value, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(min, max), new object[1] { (object)new ConfigurationManagerAttributes
			{
				IsAdminOnly = true
			} }));
		}

		private static void EnsurePlayer()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			Player localPlayer = Player.m_localPlayer;
			if ((Object)(object)localPlayer == (Object)(object)_owner)
			{
				return;
			}
			_owner = localPlayer;
			_progress = null;
			_loadError = null;
			_nextChange = (_combatUntil = 0f);
			if ((Object)(object)localPlayer == (Object)null)
			{
				return;
			}
			try
			{
				_progress = (ClassProgress?)(localPlayer.m_customData.TryGetValue("ComputerMod.Classes.v1", out var value) ? ((object)ClassProgress.Parse(value, localPlayer.GetPlayerID())) : ((object)new ClassProgress
				{
					PlayerId = localPlayer.GetPlayerID()
				}));
			}
			catch (Exception arg)
			{
				_loadError = "Class save could not be read. Switching is disabled to preserve your data.";
				_logger.LogError((object)$"Class data for character {localPlayer.GetPlayerID()} was preserved: {arg}");
			}
		}

		public static void OnLoaded(Player player)
		{
			if ((Object)(object)player == (Object)(object)_owner)
			{
				_owner = null;
				_progress = null;
			}
		}

		public static void MarkCombat(Player player)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)Player.m_localPlayer))
			{
				EnsurePlayer();
				_combatUntil = Time.unscaledTime + _combatLock.Value;
			}
		}

		public static string ChangeBlockReason()
		{
			EnsurePlayer();
			if ((Object)(object)_owner == (Object)null)
			{
				return "Enter a world to choose a class.";
			}
			if (_loadError != null)
			{
				return _loadError;
			}
			if (((Character)_owner).IsDead() || ((Character)_owner).IsTeleporting() || ((Character)_owner).InAttack())
			{
				return "Finish your current action before changing class.";
			}
			int num = Mathf.CeilToInt(Mathf.Max(_combatUntil, _nextChange) - Time.unscaledTime);
			return (num > 0) ? $"Class changes available in {num}s." : "";
		}

		public static bool Select(PlayerClass target)
		{
			if (!Enum.IsDefined(typeof(PlayerClass), target) || target == PlayerClass.None)
			{
				return false;
			}
			string text = ChangeBlockReason();
			if (text.Length > 0)
			{
				return Message(text);
			}
			if (Current == target)
			{
				return Message("This class is already active.");
			}
			return ApplyChange(null, target);
		}

		private static bool ApplyChange(ClassProgress? restore, PlayerClass target)
		{
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_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_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			Player owner = _owner;
			ClassProgress progress = _progress;
			if (!EquipmentAdapter.TryPlan(owner, target, out EquipmentAdapter plan, out string error))
			{
				return Message(error);
			}
			Capture(owner, progress);
			string text = progress.Serialize();
			Dictionary<Skill, SkillProgress> dictionary = ((IEnumerable<Skill>)((Character)owner).GetSkills().GetSkillList()).ToDictionary((Func<Skill, Skill>)((Skill s) => s), (Func<Skill, SkillProgress>)((Skill s) => new SkillProgress(s.m_level, s.m_accumulator)));
			try
			{
				Directory.CreateDirectory(BackupDirectory);
				File.WriteAllText(Path.Combine(BackupDirectory, $"{owner.GetPlayerID()}-{DateTime.UtcNow:yyyyMMdd-HHmmss-fffffff}.xml"), text);
				ClassProgress val = restore ?? ClassProgress.Parse(text, owner.GetPlayerID());
				val.CurrentClass = (int)target;
				Dictionary<Skill, SkillProgress> dictionary2 = BuildTargets(owner, val, target);
				plan.Apply();
				foreach (KeyValuePair<Skill, SkillProgress> item in dictionary2)
				{
					Skill key = item.Key;
					SkillProgress value = item.Value;
					key.m_level = ((SkillProgress)(ref value)).Level;
					Skill key2 = item.Key;
					value = item.Value;
					key2.m_accumulator = ((SkillProgress)(ref value)).Experience;
				}
				_progress = val;
				owner.m_customData["ComputerMod.Classes.v1"] = val.Serialize();
				_nextChange = Time.unscaledTime + 10f;
				_logger.LogInfo((object)$"Character {owner.GetPlayerID()} selected {target}; skill levels and partial XP restored.");
				LastMessage = $"{target} active. Your previous class skills are saved.";
				return true;
			}
			catch (Exception arg)
			{
				_progress = progress;
				foreach (Skill skill in ((Character)owner).GetSkills().GetSkillList())
				{
					SkillProgress value2;
					SkillProgress val2 = (SkillProgress)(dictionary.TryGetValue(skill, out value2) ? value2 : new SkillProgress(0f, 0f));
					skill.m_level = ((SkillProgress)(ref val2)).Level;
					skill.m_accumulator = ((SkillProgress)(ref val2)).Experience;
				}
				owner.m_customData["ComputerMod.Classes.v1"] = text;
				_logger.LogError((object)$"Class switch failed: {arg}");
				return Message("Could not finish changing class. Your previous skills were restored; see the log.");
			}
		}

		private static Dictionary<Skill, SkillProgress> BuildTargets(Player player, ClassProgress data, PlayerClass target)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Expected O, but got Unknown
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			Skills skills = ((Character)player).GetSkills();
			Dictionary<Skill, SkillProgress> dictionary = (from s in skills.GetSkillList()
				where s.m_info != null
				select s).ToDictionary((Func<Skill, Skill>)((Skill s) => s), (Func<Skill, SkillProgress>)((Skill _) => new SkillProgress(0f, 0f)));
			if (data.Classes.TryGetValue((int)target, out var value))
			{
				foreach (KeyValuePair<int, SkillProgress> item in value)
				{
					SkillType val = (SkillType)item.Key;
					if (GetSkillDef.Invoke(skills, new object[1] { val }) != null)
					{
						Skill key = (Skill)GetSkill.Invoke(skills, new object[1] { val });
						dictionary[key] = item.Value;
					}
				}
			}
			return dictionary;
		}

		private static void Capture(Player player, ClassProgress data)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected I4, but got Unknown
			if (!data.Classes.TryGetValue(data.CurrentClass, out var value))
			{
				value = (data.Classes[data.CurrentClass] = new Dictionary<int, SkillProgress>());
			}
			foreach (Skill item in from s in ((Character)player).GetSkills().GetSkillList()
				where s.m_info != null
				select s)
			{
				value[(int)item.m_info.m_skill] = new SkillProgress(item.m_level, item.m_accumulator);
			}
		}

		public static void Save(Player player)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player != (Object)(object)Player.m_localPlayer)
			{
				return;
			}
			EnsurePlayer();
			if (_progress == null)
			{
				return;
			}
			try
			{
				Capture(player, _progress);
				player.m_customData["ComputerMod.Classes.v1"] = _progress.Serialize();
			}
			catch (Exception arg)
			{
				_logger.LogError((object)$"Could not update class save: {arg}");
			}
		}

		public static void DismissTutorial()
		{
			EnsurePlayer();
			if (_progress != null)
			{
				_progress.TutorialSeen = true;
				Save(_owner);
			}
		}

		public static string[] Backups()
		{
			EnsurePlayer();
			if ((Object)(object)_owner == (Object)null || !Directory.Exists(BackupDirectory))
			{
				return Array.Empty<string>();
			}
			return Directory.GetFiles(BackupDirectory, $"{_owner.GetPlayerID()}-*.xml").OrderByDescending(Path.GetFileName).Take(20)
				.ToArray();
		}

		public static bool RestoreBackup(string path)
		{
			string text = ChangeBlockReason();
			if (text.Length > 0)
			{
				return Message(text);
			}
			if (!Backups().Contains(path))
			{
				return Message("Choose a backup for this character.");
			}
			try
			{
				ClassProgress val = ClassProgress.Parse(File.ReadAllText(path), _owner.GetPlayerID());
				return ApplyChange(val, (PlayerClass)val.CurrentClass);
			}
			catch (Exception ex)
			{
				_logger.LogError((object)ex);
				return Message("Backup is invalid; nothing was restored.");
			}
		}

		public static IEnumerable<string> SkillSummary(PlayerClass target)
		{
			EnsurePlayer();
			if ((Object)(object)_owner == (Object)null || _progress == null)
			{
				return Array.Empty<string>();
			}
			if (target == Current)
			{
				Capture(_owner, _progress);
			}
			if (!_progress.Classes.TryGetValue((int)target, out var value) || value.Count == 0)
			{
				return new string[1] { "New class: all skills start at level 0." };
			}
			return value.OrderBy((KeyValuePair<int, SkillProgress> p) => WeaponRules.SkillName((SkillType)p.Key)).Select(delegate(KeyValuePair<int, SkillProgress> p)
			{
				//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)
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002c: Unknown result type (might be due to invalid IL or missing references)
				string arg = WeaponRules.SkillName((SkillType)p.Key);
				SkillProgress value2 = p.Value;
				object arg2 = ((SkillProgress)(ref value2)).Level;
				value2 = p.Value;
				return $"{arg}: {arg2:0.#} / 100  |  XP progress: {((SkillProgress)(ref value2)).Experience:0.##}";
			}).ToArray();
		}

		public static float GetExperienceMultiplier(Skills skills, SkillType type)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			return ((Object)(object)Player.m_localPlayer != (Object)null && (Object)(object)((Character)Player.m_localPlayer).GetSkills() == (Object)(object)skills && WeaponRules.Boosts(Current, type, ((Humanoid)Player.m_localPlayer).GetCurrentWeapon())) ? ExperienceMultiplier : 1f;
		}

		private static bool Message(string text)
		{
			LastMessage = text;
			Player localPlayer = Player.m_localPlayer;
			if (localPlayer != null)
			{
				((Character)localPlayer).Message((MessageType)2, text, 0, (Sprite)null, false);
			}
			return false;
		}
	}
	public enum PlayerClass
	{
		None,
		Tank,
		Rogue,
		Ranger,
		Thrower,
		Support,
		Magician,
		Berserker,
		Warrior
	}
}