using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AnotherClassMod.Class;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Peak;
using Peak.Afflictions;
using Photon.Pun;
using TMPro;
using UnityEngine;
using UnityEngine.InputSystem;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("AnotherClassMod")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("0.0.2.0")]
[assembly: AssemblyInformationalVersion("0.0.2")]
[assembly: AssemblyProduct("com.github.little_imp.AnotherClassMod")]
[assembly: AssemblyTitle("AnotherClassMod")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.0.2.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[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 AnotherClassMod
{
	public class GlobalPunishment
	{
		public static float MaxStaminaBarPercentCoefficient { get; set; }

		public static float StaminaUsageCoefficient { get; set; }

		public static bool RandomInstantiateZombie { get; set; }

		public static float RandomInstantiateZombieDuration { get; set; }

		public static float RandomInstantiateZombieTimeTicker { get; set; }

		public static bool RandomInstantiateGhostBall { get; set; }

		public static float RandomInstantiateGhostBallDuration { get; set; }

		public static float RandomInstantiateGhostBallTimeTicker { get; set; }

		public static ConfigFile Config { get; set; }

		public static void UpdateGlobalPunishment()
		{
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0230: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.IsConnectedAndReady && PhotonNetwork.InRoom && PhotonNetwork.IsMasterClient)
			{
				ReadConfig(Config);
				SelectedClass instance = SelectedClass.Instance;
				if (instance != null)
				{
					PhotonView obj = instance.PVReadyByTicker(hasDuration: true);
					if (obj != null)
					{
						obj.RPC("RPC_SyncGlobalPunishment", (RpcTarget)0, new object[4] { MaxStaminaBarPercentCoefficient, StaminaUsageCoefficient, RandomInstantiateZombie, RandomInstantiateZombieDuration });
					}
				}
				if (RandomInstantiateZombie)
				{
					RandomInstantiateZombieTimeTicker += Time.deltaTime * Random.Range(0.7f, 1.3f);
					if (RandomInstantiateZombieTimeTicker > RandomInstantiateZombieDuration)
					{
						Character[] array = Character.AllCharacters.Where((Character t) => t.IsPlayerControlled && !t.data.dead && !t.data.passedOut).ToArray();
						MushroomZombie component = PhotonNetwork.Instantiate("MushroomZombie", array[Random.Range(0, array.Count())].Center + Vector3.up * 2f, Random.rotation, (byte)0, (object[])null).GetComponent<MushroomZombie>();
						ZombieManager.Instance.RegisterZombie(component);
						component.lifetime = 10f;
						RandomInstantiateZombieTimeTicker = 0f;
					}
				}
				if (RandomInstantiateGhostBall)
				{
					RandomInstantiateGhostBallTimeTicker += Time.deltaTime * Random.Range(0.7f, 1.3f);
					if (RandomInstantiateGhostBallTimeTicker > RandomInstantiateGhostBallDuration)
					{
						Character[] array2 = Character.AllCharacters.Where((Character t) => t.IsPlayerControlled && !t.data.dead && !t.data.passedOut).ToArray();
						Character val = array2[Random.Range(0, array2.Count())];
						GhostBall component2 = PhotonNetwork.Instantiate("GhostBall", val.Center + Vector3.back * 25f, Quaternion.identity, (byte)0, (object[])null).GetComponent<GhostBall>();
						component2.maxHeight = val.Center.y + (Vector3.up * 200f).y;
						component2.chaseHeight = val.Center.y - (Vector3.up * 200f).y;
						RandomInstantiateGhostBallTimeTicker = 0f;
					}
				}
			}
			if ((Object)(object)Character.localCharacter != (Object)null && MaxStaminaBarPercentCoefficient <= 1f)
			{
				Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)4, 1f - MaxStaminaBarPercentCoefficient, true);
			}
		}

		public static void ReadConfig(ConfigFile config)
		{
			Config = config;
			MaxStaminaBarPercentCoefficient = Config.Bind<float>("Stamina", "MaxStaminaBarPrecentCoefficient", 0.8f, "value must <= 1").Value;
			StaminaUsageCoefficient = Config.Bind<float>("Stamina", "StaminaUsageCoefficient", 1.2f, "value>1 use more samina, value<1 use less samina").Value;
			RandomInstantiateZombie = config.Bind<bool>("Zombie", "RandomInstantiateZombie", false, "Random instantiate zombie on player head").Value;
			RandomInstantiateZombieDuration = config.Bind<float>("Zombie", "RandomInstantiateZombieDuration", 180f, "Base duration with a random jitter of ±30%.").Value;
			RandomInstantiateGhostBall = config.Bind<bool>("GhostBall", "RandomInstantiateGhostBall", false, "Random instantiate GhostBall").Value;
			RandomInstantiateGhostBallDuration = config.Bind<float>("GhostBall", "RandomInstantiateGhostBallDuration", 180f, "Base duration with a random jitter of ±30%.").Value;
		}
	}
	public static class HarmonyTemp
	{
		public static float GameGrabbingDistance = 4f;

		public static float GameMaxBackpackSlots = 4f;

		public static float WeightReduce = 0f;
	}
	[HarmonyPatch(typeof(RichPresenceService))]
	public class RichPresenceServicePatch
	{
		[HarmonyPatch("SetState")]
		[HarmonyPostfix]
		private static void SetStatePostfix(RichPresenceService __instance, RichPresenceState state)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			Plugin.GameStage = state;
		}
	}
	[HarmonyPatch(typeof(GUIManager))]
	public class GUIManagerPatch
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix(GUIManager __instance)
		{
			if ((Object)(object)Plugin.playerClassSelector == (Object)null)
			{
				Plugin.playerClassSelector = Plugin.PluginGameObject.AddComponent<PlayerClassSelector>();
			}
		}
	}
	[HarmonyPatch(typeof(MainCameraMovement))]
	public class MainCameraMovementPatches
	{
		[HarmonyPostfix]
		[HarmonyPatch("CharacterCam")]
		public static void CharacterCamPostfix(MainCameraMovement __instance)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			if (SelectedClass.isLockCurrentClass && SelectedClass.CurrentClass is Crypto && ((Crypto)SelectedClass.CurrentClass).isCamMoving)
			{
				Transform transform = ((Component)__instance).transform;
				transform.position += ((Crypto)SelectedClass.CurrentClass).camOffset;
			}
		}
	}
	[HarmonyPatch(typeof(CharacterInput))]
	public class CharacterInputPatches
	{
		[HarmonyPrefix]
		[HarmonyPatch("Sample")]
		public static bool SamplePrefix(CharacterInput __instance, ref bool playerMovementActive)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			if (!SelectedClass.isLockCurrentClass)
			{
				return true;
			}
			MethodInfo methodInfo = AccessTools.Method(typeof(CharacterInput), "ResetInput", (Type[])null, (Type[])null);
			if (SelectedClass.CurrentClass is Crypto && ((Crypto)SelectedClass.CurrentClass).isCamMoving)
			{
				methodInfo.Invoke(__instance, null);
				__instance.interactWasPressed = CharacterInput.action_interact.WasPressedThisFrame();
				__instance.interactIsPressed = CharacterInput.action_interact.IsPressed();
				__instance.interactWasReleased = CharacterInput.action_interact.WasReleasedThisFrame();
				if (playerMovementActive)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(CharacterInput), "action_look");
					__instance.lookInput = ((InputAction)fieldInfo.GetValue(null)).ReadValue<Vector2>();
					__instance.pingWasPressed = CharacterInput.action_ping.WasPressedThisFrame();
					__instance.useSecondaryWasPressed = CharacterInput.action_useSecondary.WasPressedThisFrame();
					__instance.useSecondaryIsPressed = CharacterInput.action_useSecondary.IsPressed();
					__instance.useSecondaryWasReleased = CharacterInput.action_useSecondary.WasReleasedThisFrame();
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterGrabbing))]
	public class CharacterGrabbingPatches
	{
		[HarmonyPatch("TargetCanBeHelped")]
		[HarmonyPatch(new Type[]
		{
			typeof(Character),
			typeof(Character)
		})]
		[HarmonyPostfix]
		private static void TargetCanBeHelpedPostfix(CharacterGrabbing __instance, ref Character target, ref Character helper, ref bool __result)
		{
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			if (SelectedClass.CurrentClass != null && SelectedClass.CurrentClass is Crypto && ((Crypto)SelectedClass.CurrentClass).isCamMoving)
			{
				__result = false;
			}
			bool flag = false;
			bool flag2 = false;
			if (SelectedClass.Instance.PartyClass != null && SelectedClass.Instance.PartyClass.ContainsKey(((MonoBehaviourPun)helper).photonView.Owner.ActorNumber) && SelectedClass.Instance.PartyClass[((MonoBehaviourPun)helper).photonView.Owner.ActorNumber]?.TypeName != "Gibbon")
			{
				flag = true;
			}
			if (SelectedClass.Instance.PartyClass != null && SelectedClass.Instance.PartyClass.ContainsKey(((MonoBehaviourPun)helper).photonView.Owner.ActorNumber) && SelectedClass.Instance.PartyClass[((MonoBehaviourPun)helper).photonView.Owner.ActorNumber]?.TypeName != "Gibbon")
			{
				flag2 = true;
			}
			if (flag && flag2)
			{
				__result = __result && Vector3.Distance(helper.Center, target.Center) <= HarmonyTemp.GameGrabbingDistance;
			}
		}

		[HarmonyPatch("Reach")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			FieldInfo grabbingDistanceField = AccessTools.Field(typeof(Gibbon), "PullRange");
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Ldc_R4 && (float)instruction.operand == 4f)
				{
					instruction.opcode = OpCodes.Ldsfld;
					instruction.operand = grabbingDistanceField;
				}
				yield return instruction;
			}
		}
	}
	[HarmonyPatch(typeof(Character))]
	public class CharacterPatches
	{
		[HarmonyPatch("UseStamina")]
		[HarmonyPrefix]
		private static void UseStaminaPrefix(Character __instance, ref float usage, bool useBonusStamina)
		{
			if ((Object)(object)__instance != (Object)null && __instance.IsLocal)
			{
				usage *= GlobalPunishment.StaminaUsageCoefficient;
			}
		}
	}
	[HarmonyPatch(typeof(BackpackData))]
	public class BackpackPatches
	{
		[HarmonyPatch("DeserializeValue")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Ldc_I4_4)
				{
					instruction.opcode = OpCodes.Call;
					instruction.operand = AccessTools.Method(typeof(PatchUtils), "GetDynamicMaxSlots", (Type[])null, (Type[])null);
				}
				yield return instruction;
			}
		}

		[HarmonyPatch("Init")]
		[HarmonyPrefix]
		private static bool InitPrefix(BackpackData __instance)
		{
			if (SelectedClass.isLockCurrentClass && SelectedClass.Instance.PartyClass.Values.Any((SelectedClass.PartyClassInfo? info) => info.Value.TypeName == typeof(Porter).Name))
			{
				__instance.itemSlots = (ItemSlot[])(object)new ItemSlot[Porter.maxBackpackSlots];
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(BackpackVisuals))]
	public class BackpackVisualsPatches
	{
		[HarmonyPatch("RefreshVisuals")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			foreach (CodeInstruction instruction in instructions)
			{
				if (instruction.opcode == OpCodes.Ldc_I4_4)
				{
					instruction.opcode = OpCodes.Call;
					instruction.operand = AccessTools.Method(typeof(PatchUtils), "GetDynamicMaxSlots", (Type[])null, (Type[])null);
				}
				yield return instruction;
			}
		}
	}
	[HarmonyPatch(typeof(BackpackWheel))]
	public class BackpackWheelPatches
	{
		[HarmonyPatch("InitWheel")]
		[HarmonyPrefix]
		private static bool InitWheelPrefix(BackpackWheel __instance, ref BackpackReference bp, ref int slotCount, ref BackpackType backpackType)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: 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_0137: 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_0150: Unknown result type (might be due to invalid IL or missing references)
			bool flag = SelectedClass.isLockCurrentClass && SelectedClass.Instance.PartyClass.Values.Any((SelectedClass.PartyClassInfo? info) => info.Value.TypeName == typeof(Porter).Name);
			if ((int)backpackType != 1 || !flag)
			{
				return true;
			}
			slotCount = Porter.maxBackpackSlots;
			if (__instance.slices.Length < Porter.maxBackpackSlots + 1)
			{
				BackpackWheelSlice[] slices = __instance.slices;
				List<BackpackWheelSlice> list = new List<BackpackWheelSlice>(slices.Length);
				list.AddRange(slices);
				for (int num = 5; num < Porter.maxBackpackSlots + 1; num++)
				{
					BackpackWheelSlice item = Object.Instantiate<BackpackWheelSlice>(__instance.slices[1], ((Component)__instance.slices[1]).transform.parent);
					list.Add(item);
				}
				__instance.slices = list.ToArray();
			}
			Quaternion localRotation = ((Component)__instance.slices[0]).transform.localRotation;
			float num2 = 360f / (float)__instance.slices.Length;
			for (int num3 = 0; num3 < __instance.slices.Length; num3++)
			{
				((Component)__instance.slices[num3]).transform.localRotation = localRotation;
				Transform transform = ((Component)__instance.slices[num3]).transform;
				transform.localRotation *= Quaternion.Euler(0f, 0f, (float)num3 * num2);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions))]
	public class CharacterAfflictionsPatches
	{
		[HarmonyPatch("UpdateWeight")]
		[HarmonyPostfix]
		private static void UpdatePostfix(CharacterAfflictions __instance)
		{
			if (!SelectedClass.isLockCurrentClass || !SelectedClass.Instance.PartyClass.Values.Any((SelectedClass.PartyClassInfo? info) => info.Value.TypeName == typeof(Porter).Name))
			{
				HarmonyTemp.WeightReduce = 0f;
			}
			__instance.SetStatus((STATUSTYPE)7, __instance.currentStatuses[7] * (1f - HarmonyTemp.WeightReduce), true);
		}
	}
	public static class PatchUtils
	{
		public static int GetDynamicMaxSlots()
		{
			if (SelectedClass.isLockCurrentClass && SelectedClass.Instance.PartyClass.Values.Any((SelectedClass.PartyClassInfo? info) => info.Value.TypeName == typeof(Porter).Name))
			{
				return Porter.maxBackpackSlots;
			}
			return 4;
		}
	}
	public static class Localization
	{
		public static Dictionary<Language, PluginText> LocalizationTexts;

		public static Language[] InnerLanguage;

		public static PluginText CurrentText
		{
			get
			{
				//IL_0006: 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)
				if (LocalizationTexts.ContainsKey(LocalizedText.CURRENT_LANGUAGE))
				{
					return LocalizationTexts[LocalizedText.CURRENT_LANGUAGE];
				}
				return LocalizationTexts[InnerLanguage[0]];
			}
		}

		static Localization()
		{
			LocalizationTexts = new Dictionary<Language, PluginText>();
			InnerLanguage = (Language[])(object)new Language[2]
			{
				default(Language),
				(Language)9
			};
			LocalizationTexts.Add((Language)0, new PluginText
			{
				Selector_CurrentClass = "Current Class",
				Selector_ChangeClass = "Change Class",
				Selector_CancelCD = "Cancel Cool Down"
			});
			LocalizationTexts.Add((Language)9, new PluginText
			{
				Selector_CurrentClass = "当前职业",
				Selector_ChangeClass = "变更职业",
				Selector_CancelCD = "取消主动技能CD"
			});
		}
	}
	public class PluginText
	{
		public string Selector_CurrentClass { get; set; } = "Current Class";

		public string Selector_ChangeClass { get; set; } = "Change Class";

		public string Selector_CancelCD { get; set; } = "Cancel Cool Down";
	}
	[DisallowMultipleComponent]
	public class PlayerClassSelector : MonoBehaviourPun
	{
		private int currentClassIndex;

		public TextMeshProUGUI classInfoText;

		private GameObject canvasGO;

		private void Awake()
		{
			Plugin.Logger.LogInfo((object)"PlayerClassSelector Awake called");
			SelectedClass selectedClass = default(SelectedClass);
			if (!Plugin.PluginGameObject.TryGetComponent<SelectedClass>(ref selectedClass))
			{
				Plugin.PluginGameObject.AddComponent<SelectedClass>();
				Plugin.Logger.LogInfo((object)"AddComponent: SelectedClass");
			}
		}

		private void Start()
		{
			if (SelectedClass.CurrentClass != null)
			{
				currentClassIndex = SelectedClass.CurrentClass.ClassIndexInList();
			}
			else
			{
				currentClassIndex = Plugin.savedClassIndexInList.Value;
				SetClass();
			}
			try
			{
				CreateClassNameUI();
			}
			catch
			{
			}
		}

		private void OnDestroy()
		{
			Plugin.Logger.LogInfo((object)"PlayerClassSelector Destroy called");
			Object.Destroy((Object)(object)classInfoText);
			Object.Destroy((Object)(object)canvasGO);
		}

		private void OnDisable()
		{
			if ((Object)(object)classInfoText != (Object)null)
			{
				((Behaviour)classInfoText).enabled = false;
			}
		}

		private void OnEnable()
		{
			if ((Object)(object)classInfoText != (Object)null)
			{
				((Behaviour)classInfoText).enabled = true;
			}
		}

		private void Update()
		{
			if (Input.GetKeyDown((KeyCode)276) || Input.GetKeyDown((KeyCode)275))
			{
				int count = BaseClass.GetClassArray().Count;
				if (count > 0)
				{
					if (Input.GetKeyDown((KeyCode)276))
					{
						currentClassIndex = (currentClassIndex - 1 + count) % count;
					}
					else if (Input.GetKeyDown((KeyCode)275))
					{
						currentClassIndex = (currentClassIndex + 1) % count;
					}
					SetClass();
				}
			}
			if ((Object)(object)canvasGO == (Object)null)
			{
				try
				{
					CreateClassNameUI();
					return;
				}
				catch (Exception ex)
				{
					Plugin.Logger.LogError((object)("UI Create Error: " + ex.Message));
					return;
				}
			}
			UpdateClassNameUI();
		}

		public void SetClass()
		{
			List<Type> classArray = BaseClass.GetClassArray();
			int count = classArray.Count;
			if (currentClassIndex >= 0 && currentClassIndex < count)
			{
				Type type = classArray[currentClassIndex];
				if (SelectedClass.CurrentClass != null)
				{
					SelectedClass.CurrentClass.Dispose();
				}
				SelectedClass.CurrentClass = (BaseClass)Activator.CreateInstance(type);
				Plugin.Logger.LogInfo((object)("Current Class: " + SelectedClass.CurrentClass.InnerText_ClassName()));
			}
		}

		private void CreateClassNameUI()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Expected O, but got Unknown
			//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)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: 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_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("GAME/GUIManager");
			GUIManager component = val.GetComponent<GUIManager>();
			TMP_FontAsset font = ((TMP_Text)component.interactNameText).font;
			canvasGO = new GameObject("canvasInfoGO");
			Object.DontDestroyOnLoad((Object)(object)canvasGO);
			Canvas val2 = canvasGO.AddComponent<Canvas>();
			canvasGO.SetActive(true);
			val2.renderMode = (RenderMode)0;
			CanvasScaler val3 = canvasGO.AddComponent<CanvasScaler>();
			if ((Object)(object)val3 != (Object)null)
			{
				val3.uiScaleMode = (ScaleMode)1;
				val3.referenceResolution = new Vector2(1920f, 1080f);
				val3.matchWidthOrHeight = 0.5f;
			}
			canvasGO.AddComponent<GraphicRaycaster>();
			GameObject val4 = new GameObject("classInfoText");
			val4.transform.SetParent(((Component)val2).transform, false);
			classInfoText = val4.AddComponent<TextMeshProUGUI>();
			((TMP_Text)classInfoText).font = font;
			((TMP_Text)classInfoText).fontSize = 22f;
			((TMP_Text)classInfoText).alignment = (TextAlignmentOptions)257;
			((TMP_Text)classInfoText).enableVertexGradient = true;
			((TMP_Text)classInfoText).colorGradient = new VertexGradient(Color32.op_Implicit(new Color32(byte.MaxValue, (byte)242, (byte)194, byte.MaxValue)), Color32.op_Implicit(new Color32(byte.MaxValue, (byte)242, (byte)194, byte.MaxValue)), Color32.op_Implicit(new Color32((byte)217, (byte)158, (byte)50, byte.MaxValue)), Color32.op_Implicit(new Color32((byte)217, (byte)158, (byte)50, byte.MaxValue)));
			RectTransform component2 = ((Component)classInfoText).GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0f, 0.5f);
			component2.anchorMax = new Vector2(0f, 0.5f);
			component2.pivot = new Vector2(0f, 0.5f);
			component2.anchoredPosition = new Vector2(20f, 240f);
			component2.sizeDelta = new Vector2(400f, 200f);
		}

		private void UpdateClassNameUI()
		{
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.AppendFormat(Localization.CurrentText.Selector_CurrentClass + ": <color=#FF5555>" + SelectedClass.CurrentClass?.InnerText_ClassName() + "</color>\n");
			stringBuilder.AppendFormat("<color=#FF5555>" + SelectedClass.CurrentClass?.InnerText_ClassDescription() + "</color>\n");
			stringBuilder.AppendLine("← / →  " + Localization.CurrentText.Selector_ChangeClass + "\n");
			((TMP_Text)classInfoText).text = stringBuilder.ToString();
		}
	}
	[BepInPlugin("AnotherClassMod", "com.github.little_imp.AnotherClassMod", "0.0.2")]
	public class Plugin : BaseUnityPlugin
	{
		private static Harmony harmony;

		public static ManualLogSource Logger { get; private set; }

		public ConfigEntry<bool> modEnabled { get; private set; }

		public static ConfigEntry<KeyCode> skillKey { get; private set; }

		public static ConfigEntry<int> savedClassIndexInList { get; private set; }

		public static GameObject PluginGameObject { get; private set; }

		public static PlayerClassSelector playerClassSelector { get; set; }

		public static RichPresenceState GameStage { get; set; }

		private void Awake()
		{
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Expected O, but got Unknown
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			Logger = ((BaseUnityPlugin)this).Logger;
			modEnabled = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Enable", true, "Enable Mod");
			skillKey = ((BaseUnityPlugin)this).Config.Bind<KeyCode>("General", "Key", (KeyCode)102, "Key to activate skill");
			savedClassIndexInList = ((BaseUnityPlugin)this).Config.Bind<int>("General", "Current Class Index In List", 1, "The class that last game saved");
			GlobalPunishment.ReadConfig(((BaseUnityPlugin)this).Config);
			if (!modEnabled.Value)
			{
				ManualLogSource logger = Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"com.github.little_imp.AnotherClassMod is disabled, exiting load.");
				}
			}
			else
			{
				harmony = new Harmony("AnotherClassMod");
				harmony.PatchAll();
				Logger.LogInfo((object)"com.github.little_imp.AnotherClassMod load，0.0.2");
				PluginGameObject = new GameObject("AnotherClassMod");
				Object.DontDestroyOnLoad((Object)(object)PluginGameObject);
				PhotonView val = PluginGameObject.AddComponent<PhotonView>();
				val.ViewID = 999994869;
			}
		}

		private void Update()
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			PlayerClassSelector playerClassSelector2 = default(PlayerClassSelector);
			if ((int)GameStage == 1)
			{
				PlayerClassSelector playerClassSelector = default(PlayerClassSelector);
				if (PluginGameObject.TryGetComponent<PlayerClassSelector>(ref playerClassSelector))
				{
					((Behaviour)playerClassSelector).enabled = true;
				}
			}
			else if (PluginGameObject.TryGetComponent<PlayerClassSelector>(ref playerClassSelector2))
			{
				((Behaviour)playerClassSelector2).enabled = false;
			}
			SelectedClass selectedClass2 = default(SelectedClass);
			if ((int)GameStage == 0)
			{
				SelectedClass selectedClass = default(SelectedClass);
				if (PluginGameObject.TryGetComponent<SelectedClass>(ref selectedClass))
				{
					((Behaviour)selectedClass).enabled = false;
				}
			}
			else if (PluginGameObject.TryGetComponent<SelectedClass>(ref selectedClass2))
			{
				((Behaviour)selectedClass2).enabled = true;
			}
		}

		private void OnDestroy()
		{
			Logger.LogInfo((object)"com.github.little_imp.AnotherClassMod exiting load.");
			if (SelectedClass.CurrentClass != null)
			{
				savedClassIndexInList.Value = SelectedClass.CurrentClass.ClassIndexInList();
			}
			harmony.UnpatchSelf();
		}
	}
	[DisallowMultipleComponent]
	public class SelectedClass : MonoBehaviourPun
	{
		public struct PartyClassInfo
		{
			public string DisplayName;

			public string TypeName;
		}

		public Dictionary<int, PartyClassInfo?> PartyClass { get; set; } = new Dictionary<int, PartyClassInfo?>();

		public static BaseClass CurrentClass { get; set; }

		public static SelectedClass Instance { get; set; }

		public static bool isLockCurrentClass
		{
			get
			{
				if ((Object)(object)Instance == (Object)null)
				{
					return false;
				}
				if (CurrentClass == null)
				{
					return false;
				}
				return true;
			}
		}

		public float RPCTicker { get; set; }

		public float RPCDuration { get; } = 1f;

		private void Awake()
		{
			Instance = this;
		}

		private void Update()
		{
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			RPCTicker += Time.deltaTime;
			if (CurrentClass == null || (Object)(object)Character.localCharacter == (Object)null)
			{
				return;
			}
			if ((Object)(object)CurrentClass.canvasGO == (Object)null)
			{
				CurrentClass.CreateUI();
			}
			try
			{
				PhotonView obj = PVReadyByTicker(hasDuration: true);
				if (obj != null)
				{
					obj.RPC("RPC_ChangeClass", (RpcTarget)0, new object[3]
					{
						((MonoBehaviourPun)Character.localCharacter).photonView.OwnerActorNr,
						"<color=" + CurrentClass.ClassColor + ">" + CurrentClass.InnerText_ClassName() + "</color>",
						CurrentClass.GetType().Name
					});
				}
				CurrentClass.ClassTrigger();
			}
			catch (Exception ex)
			{
				Plugin.Logger.LogError((object)ex);
			}
			GlobalPunishment.UpdateGlobalPunishment();
			if (Input.GetKeyDown(CurrentClass.SkillKeyCode) && !CurrentClass.IsCoolDown && CurrentClass.ClassSkill())
			{
				CurrentClass.IsCoolDown = true;
				CurrentClass.CDTicker = CurrentClass.ClassSkillCoolDown;
				CurrentClass.ShowCooldownUI();
			}
			CurrentClass.UpdateInfoText();
			if (CurrentClass.IsCoolDown)
			{
				CurrentClass.CDTicker -= Time.deltaTime;
				if (CurrentClass.CDTicker <= 0f)
				{
					CurrentClass.CDTicker = 0f;
					CurrentClass.IsCoolDown = false;
					CurrentClass.HideCooldownUI();
				}
				CurrentClass.UpdateCooldownVisual();
				if ((Object)(object)CurrentClass.CDText != (Object)null)
				{
					((TMP_Text)CurrentClass.CDText).text = CurrentClass.CDTicker.ToString("F1");
				}
			}
			if (RPCTicker > RPCDuration)
			{
				RPCTicker = 0f;
			}
		}

		private void OnDestroy()
		{
			Instance = null;
			CurrentClass.Dispose();
		}

		private void OnDisable()
		{
			if (CurrentClass != null)
			{
				if ((Object)(object)CurrentClass.CDBackCircle != (Object)null)
				{
					((Behaviour)CurrentClass.CDBackCircle).enabled = false;
				}
				if ((Object)(object)CurrentClass.CDCircle != (Object)null)
				{
					((Behaviour)CurrentClass.CDBackCircle).enabled = false;
				}
				if ((Object)(object)CurrentClass.CDText != (Object)null)
				{
					((Behaviour)CurrentClass.CDBackCircle).enabled = false;
				}
				if ((Object)(object)CurrentClass.InfoText != (Object)null)
				{
					((Behaviour)CurrentClass.CDBackCircle).enabled = false;
				}
			}
		}

		private void OnEnable()
		{
			if (CurrentClass != null)
			{
				if ((Object)(object)CurrentClass.CDBackCircle != (Object)null)
				{
					((Behaviour)CurrentClass.CDBackCircle).enabled = true;
				}
				if ((Object)(object)CurrentClass.CDCircle != (Object)null)
				{
					((Behaviour)CurrentClass.CDBackCircle).enabled = true;
				}
				if ((Object)(object)CurrentClass.CDText != (Object)null)
				{
					((Behaviour)CurrentClass.CDBackCircle).enabled = true;
				}
				if ((Object)(object)CurrentClass.InfoText != (Object)null)
				{
					((Behaviour)CurrentClass.CDBackCircle).enabled = true;
				}
			}
		}

		public PhotonView PVReadyByTicker(bool hasDuration)
		{
			if (PhotonNetwork.IsConnectedAndReady && PhotonNetwork.InRoom && (Object)(object)((MonoBehaviourPun)this).photonView != (Object)null)
			{
				if (hasDuration && RPCTicker < RPCDuration)
				{
					return null;
				}
				return ((MonoBehaviourPun)this).photonView;
			}
			return null;
		}

		[PunRPC]
		public void RPC_SubtractStatus(Vector3 classPostion, float maxDistance, STATUSTYPE statusType, float value)
		{
			//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)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (Vector3.Distance(Character.localCharacter.Center, classPostion) <= maxDistance)
			{
				Character.localCharacter.refs.afflictions.SubtractStatus(statusType, value, false, false);
			}
		}

		[PunRPC]
		public void RPC_AddStatus(Vector3 classPostion, float maxDistance, STATUSTYPE statusType, float value)
		{
			//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)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (Vector3.Distance(Character.localCharacter.Center, classPostion) <= maxDistance)
			{
				Character.localCharacter.refs.afflictions.AddStatus(statusType, value, false, true, true, false);
			}
		}

		[PunRPC]
		public void RPC_SetStatus_Chain_Skill(float average_Hunger, float average_Injury, float average_Poison, float average_Spores, float average_Drowsy, float average_Hot, float average_Cold)
		{
			if (!Character.localCharacter.data.dead)
			{
				Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)1, average_Hunger, true);
				Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)0, average_Injury, true);
				Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)3, average_Poison, true);
				Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)10, average_Spores, true);
				Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)6, average_Drowsy, true);
				Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)8, average_Hot, true);
				Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)2, average_Cold, true);
			}
		}

		[PunRPC]
		public void RPC_AvgStatus_Chain_Aura()
		{
			if (!Character.localCharacter.data.dead)
			{
				IEnumerable<Character> source = Character.AllCharacters.Where((Character c) => !c.data.dead && c.IsPlayerControlled);
				float num = source.Average((Character t) => t.refs.afflictions.GetCurrentStatus((STATUSTYPE)0));
				Character.localCharacter.refs.afflictions.AdjustStatus((STATUSTYPE)0, num - Character.localCharacter.refs.afflictions.GetCurrentStatus((STATUSTYPE)0), false);
			}
		}

		[PunRPC]
		public void RPC_AddStatus_WithPvId(STATUSTYPE statusType, float value, int pvId)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (((MonoBehaviourPun)Character.localCharacter).photonView.ViewID == pvId)
			{
				Character.localCharacter.refs.afflictions.AddStatus(statusType, value, false, true, true, false);
			}
		}

		[PunRPC]
		public void RPC_SetSavedStatus(float[] savedStatus, int pvId)
		{
			if (((MonoBehaviourPun)Character.localCharacter).photonView.ViewID == pvId)
			{
				Array.Copy(savedStatus, Character.localCharacter.refs.afflictions.currentStatuses, savedStatus.Length);
			}
		}

		[PunRPC]
		public void RPC_SubtractStatus_WhoPassOut(Vector3 classPostion, float maxDistance, STATUSTYPE statusType, float value)
		{
			//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)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (Vector3.Distance(Character.localCharacter.Center, classPostion) <= maxDistance && Character.localCharacter.data.fullyPassedOut)
			{
				Character.localCharacter.refs.afflictions.SubtractStatus(statusType, value, false, false);
			}
		}

		[PunRPC]
		public void RPC_AddAffliction_InvincibilityFromMilk(Vector3 classPostion, float maxDistance, float value)
		{
			//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)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (Vector3.Distance(Character.localCharacter.Center, classPostion) <= maxDistance)
			{
				Affliction_Invincibility val = new Affliction_Invincibility();
				((Affliction)val).totalTime = value;
				val.isFromMilk = true;
				Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
			}
		}

		[PunRPC]
		public void RPC_AddAffliction_InfiniteStamina(Vector3 classPostion, float maxDistance, float value)
		{
			//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)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (Vector3.Distance(Character.localCharacter.Center, classPostion) <= maxDistance)
			{
				Affliction_InfiniteStamina val = new Affliction_InfiniteStamina();
				((Affliction)val).totalTime = value;
				Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
			}
		}

		[PunRPC]
		public void RPC_Affliction_LowGravity(Vector3 classPostion, float maxDistance, int lowGravAmount, float totalTime)
		{
			//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)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (Vector3.Distance(Character.localCharacter.Center, classPostion) <= maxDistance)
			{
				Affliction_LowGravity val = new Affliction_LowGravity();
				((Affliction)val).totalTime = totalTime;
				val.lowGravAmount = lowGravAmount;
				Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
			}
		}

		[PunRPC]
		public void RPC_AddAffliction_Affliction_FasterBoi(Vector3 classPostion, float maxDistance, float amount)
		{
			//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)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (Vector3.Distance(Character.localCharacter.Center, classPostion) <= maxDistance)
			{
				Affliction_FasterBoi val = new Affliction_FasterBoi();
				((Affliction)val).totalTime = amount;
				val.climbDelay = 0f;
				Character.localCharacter.refs.afflictions.AddAffliction((Affliction)(object)val, false);
			}
		}

		[PunRPC]
		public void RPC_AddExtraStamina(Vector3 classPostion, float maxDistance, float maxExtraStamina, float value)
		{
			//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)
			if (Vector3.Distance(Character.localCharacter.Center, classPostion) <= maxDistance && Character.localCharacter.data.extraStamina < maxExtraStamina && !Character.localCharacter.data.isClimbingAnything && !Character.localCharacter.data.isJumping)
			{
				Character.localCharacter.AddExtraStamina(value);
			}
		}

		[PunRPC]
		public void RPC_ChangeClass(int OAN, string className, string classTypename)
		{
			try
			{
				className = className ?? "NoClass";
				classTypename = classTypename ?? "";
				if (!isLockCurrentClass)
				{
					return;
				}
				if (PartyClass == null)
				{
					PartyClass = new Dictionary<int, PartyClassInfo?>();
				}
				PartyClass[OAN] = new PartyClassInfo
				{
					DisplayName = className,
					TypeName = classTypename
				};
				if ((Object)(object)GUIManager.instance == (Object)null || (Object)(object)GUIManager.instance.playerNames == (Object)null)
				{
					return;
				}
				PlayerName[] playerNameText = GUIManager.instance.playerNames.playerNameText;
				if (playerNameText == null)
				{
					return;
				}
				PlayerName[] array = playerNameText;
				foreach (PlayerName val in array)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.characterInteractable == (Object)null) && !((Object)(object)val.text == (Object)null))
					{
						int ownerActorNr = ((MonoBehaviourPun)val.characterInteractable.character).photonView.OwnerActorNr;
						string name = val.characterInteractable.GetName();
						if (!string.IsNullOrEmpty(name) && PartyClass.ContainsKey(ownerActorNr))
						{
							((TMP_Text)val.text).text = "<" + PartyClass[ownerActorNr]?.DisplayName + ">" + name;
						}
					}
				}
				List<int> list = new List<int>();
				foreach (KeyValuePair<int, PartyClassInfo?> item in PartyClass)
				{
					if (!PhotonNetwork.CurrentRoom.Players.ContainsKey(item.Key))
					{
						list.Add(item.Key);
					}
				}
				foreach (int item2 in list)
				{
					PartyClass.Remove(item2);
				}
			}
			catch (Exception arg)
			{
				Plugin.Logger.LogError((object)$"RPC_ChangeClass 内部发生异常: {arg}");
			}
		}

		[PunRPC]
		public void RPC_WarpPlayer(Vector3 postion, int pvId)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			if (pvId == ((MonoBehaviourPun)Character.localCharacter).photonView.ViewID)
			{
				Character.localCharacter.WarpPlayerRPC(postion, false);
			}
		}

		[PunRPC]
		public void RPC_WeightReduce(Vector3 classPostion, float maxDistance, float reduce)
		{
			//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)
			if (Vector3.Distance(Character.localCharacter.Center, classPostion) <= maxDistance)
			{
				HarmonyTemp.WeightReduce = reduce;
			}
			else
			{
				HarmonyTemp.WeightReduce = 0f;
			}
		}

		[PunRPC]
		public void RPC_SyncGlobalPunishment(float _maxStaminaBarCoefficient, float _staminaUsageCoefficient, bool _randomInstantiateZombie, float _randomInstantiateZombieDuration)
		{
			GlobalPunishment.MaxStaminaBarPercentCoefficient = _maxStaminaBarCoefficient;
			GlobalPunishment.StaminaUsageCoefficient = _staminaUsageCoefficient;
			GlobalPunishment.RandomInstantiateZombie = _randomInstantiateZombie;
			GlobalPunishment.RandomInstantiateZombieDuration = _randomInstantiateZombieDuration;
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "AnotherClassMod";

		public const string PLUGIN_NAME = "com.github.little_imp.AnotherClassMod";

		public const string PLUGIN_VERSION = "0.0.2";
	}
}
namespace AnotherClassMod.Class
{
	public abstract class BaseClass : IDisposable
	{
		public static List<Type> ClassTypes { get; private set; }

		public KeyCode SkillKeyCode { get; set; } = Plugin.skillKey.Value;

		public Func<bool> ClassSkill { get; set; } = () => false;

		public Action ClassTrigger { get; set; } = delegate
		{
		};

		public float ClassSkillCoolDown { get; set; } = 0f;

		public string ClassColor { get; set; } = "#FFFFFF";

		public float CDTicker { get; set; }

		public bool IsCoolDown { get; set; } = false;

		public GameObject canvasGO { get; set; } = null;

		public GameObject CDCircleGO { get; set; } = null;

		public GameObject CDBackCircleGO { get; set; } = null;

		public Image CDCircle { get; set; } = null;

		public Image CDBackCircle { get; set; } = null;

		public GameObject CDTextGO { get; set; } = null;

		public TextMeshProUGUI CDText { get; set; } = null;

		public GameObject InfoTextGO { get; set; } = null;

		public TextMeshProUGUI InfoText { get; set; } = null;

		public float infoDuration { get; } = 2f;

		public float infoTick { get; set; } = 0f;

		public abstract string InnerText_ClassName();

		public abstract string InnerText_ClassDescription();

		public void CreateUI()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02da: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			//IL_035a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Expected O, but got Unknown
			//IL_041d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0422: Unknown result type (might be due to invalid IL or missing references)
			//IL_0449: Unknown result type (might be due to invalid IL or missing references)
			//IL_045f: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0495: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d3: Expected O, but got Unknown
			//IL_054d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0552: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			canvasGO = new GameObject("SkillCooldownCanvas");
			Canvas val = canvasGO.AddComponent<Canvas>();
			val.renderMode = (RenderMode)0;
			CanvasScaler val2 = canvasGO.AddComponent<CanvasScaler>();
			if ((Object)(object)val2 != (Object)null)
			{
				val2.uiScaleMode = (ScaleMode)1;
				val2.referenceResolution = new Vector2(1920f, 1080f);
				val2.matchWidthOrHeight = 0.5f;
			}
			canvasGO.AddComponent<GraphicRaycaster>();
			CDCircleGO = new GameObject("CooldownCircle");
			CDBackCircleGO = new GameObject("CDBackCircleGO");
			CDCircleGO.transform.SetParent(canvasGO.transform, false);
			CDBackCircleGO.transform.SetParent(canvasGO.transform, false);
			CDCircle = CDCircleGO.AddComponent<Image>();
			CDBackCircle = CDBackCircleGO.AddComponent<Image>();
			UI_UseItemProgress val3 = Object.FindFirstObjectByType<UI_UseItemProgress>();
			if ((Object)(object)val3 != (Object)null)
			{
				CDBackCircle.sprite = val3.fill.sprite;
				CDCircle.sprite = val3.fill.sprite;
			}
			CDCircle.type = (Type)3;
			CDCircle.fillMethod = (FillMethod)4;
			CDCircle.fillOrigin = 2;
			CDCircle.fillClockwise = false;
			CDCircle.fillAmount = 0f;
			((Graphic)CDCircle).color = Color32.op_Implicit(new Color32((byte)0, (byte)242, (byte)254, byte.MaxValue));
			((Behaviour)CDCircle).enabled = false;
			CDBackCircle.type = (Type)3;
			CDBackCircle.fillMethod = (FillMethod)4;
			CDBackCircle.fillOrigin = 2;
			CDBackCircle.fillClockwise = false;
			CDBackCircle.fillAmount = 1f;
			((Graphic)CDBackCircle).color = Color32.op_Implicit(new Color32((byte)26, (byte)31, (byte)44, byte.MaxValue));
			((Behaviour)CDBackCircle).enabled = false;
			((Graphic)CDCircle).rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			((Graphic)CDCircle).rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			((Graphic)CDCircle).rectTransform.pivot = new Vector2(0.5f, 0.5f);
			((Graphic)CDCircle).rectTransform.anchoredPosition = new Vector2(200f, -200f);
			((Graphic)CDCircle).rectTransform.sizeDelta = new Vector2(80f, 80f);
			((Graphic)CDBackCircle).rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			((Graphic)CDBackCircle).rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			((Graphic)CDBackCircle).rectTransform.pivot = new Vector2(0.5f, 0.5f);
			((Graphic)CDBackCircle).rectTransform.anchoredPosition = new Vector2(200f, -200f);
			((Graphic)CDBackCircle).rectTransform.sizeDelta = new Vector2(80f, 80f);
			((Transform)((Graphic)CDBackCircle).rectTransform).SetAsFirstSibling();
			GUIManager component = GameObject.Find("GAME/GUIManager").GetComponent<GUIManager>();
			TMP_FontAsset font = ((TMP_Text)component.heroDayText).font;
			CDTextGO = new GameObject("CooldownText");
			CDTextGO.transform.SetParent(((Component)CDCircle).transform, false);
			CDText = CDTextGO.AddComponent<TextMeshProUGUI>();
			((TMP_Text)CDText).font = font;
			((TMP_Text)CDText).fontSize = 20f;
			((TMP_Text)CDText).alignment = (TextAlignmentOptions)514;
			((Graphic)CDText).color = Color32.op_Implicit(new Color32((byte)230, (byte)238, (byte)244, byte.MaxValue));
			((TMP_Text)CDText).text = "0.0";
			((TMP_Text)CDText).rectTransform.anchorMin = Vector2.zero;
			((TMP_Text)CDText).rectTransform.anchorMax = Vector2.one;
			((TMP_Text)CDText).rectTransform.pivot = new Vector2(0.5f, 0.5f);
			((TMP_Text)CDText).rectTransform.anchoredPosition = Vector2.zero;
			((TMP_Text)CDText).rectTransform.sizeDelta = Vector2.zero;
			((Behaviour)CDText).enabled = false;
			InfoTextGO = new GameObject("InfoTextGO");
			InfoTextGO.transform.SetParent(canvasGO.transform, false);
			InfoText = InfoTextGO.AddComponent<TextMeshProUGUI>();
			((TMP_Text)InfoText).font = font;
			((TMP_Text)InfoText).fontSize = 32f;
			((TMP_Text)InfoText).alignment = (TextAlignmentOptions)514;
			((Graphic)InfoText).color = Color32.op_Implicit(new Color32((byte)224, byte.MaxValue, byte.MaxValue, byte.MaxValue));
			((TMP_Text)InfoText).text = "";
			((TMP_Text)InfoText).rectTransform.anchoredPosition = new Vector2(0f, -200f);
			((Behaviour)InfoText).enabled = false;
		}

		public void ShowCooldownUI()
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)CDCircle != (Object)null)
			{
				((Behaviour)CDCircle).enabled = true;
				((Behaviour)CDBackCircle).enabled = true;
				((Behaviour)CDText).enabled = true;
				CDCircle.fillAmount = 1f;
				((Component)CDCircle).transform.localScale = Vector3.zero;
				TweenSettingsExtensions.SetEase<TweenerCore<Vector3, Vector3, VectorOptions>>(ShortcutExtensions.DOScale(((Component)CDCircle).transform, 1f, 0.25f), (Ease)27);
			}
		}

		public void HideCooldownUI()
		{
			if ((Object)(object)CDCircle != (Object)null)
			{
				((Behaviour)CDCircle).enabled = false;
				((Behaviour)CDBackCircle).enabled = false;
				((Behaviour)CDText).enabled = false;
			}
		}

		public void UpdateCooldownVisual()
		{
			if ((Object)(object)CDCircle != (Object)null)
			{
				if (CDTicker > ClassSkillCoolDown)
				{
					CDTicker = ClassSkillCoolDown;
				}
				CDCircle.fillAmount = CDTicker / ClassSkillCoolDown;
			}
		}

		public void UpdateInfoText()
		{
			if ((Object)(object)InfoText != (Object)null && ((Behaviour)InfoText).enabled)
			{
				infoTick -= Time.deltaTime;
				if (infoTick <= 0f)
				{
					((Behaviour)InfoText).enabled = false;
				}
			}
		}

		public void RestartInfoText(string info)
		{
			if ((Object)(object)InfoText != (Object)null)
			{
				infoTick = infoDuration;
				((TMP_Text)InfoText).text = info;
				((Behaviour)InfoText).enabled = true;
			}
		}

		public bool SpawnItemInHand(string itemName)
		{
			if ((Object)(object)Character.localCharacter != (Object)null && Character.localCharacter.IsLocal)
			{
				CharacterItems items = Character.localCharacter.refs.items;
				if ((Object)(object)items != (Object)null)
				{
					MethodInfo methodInfo = AccessTools.Method(typeof(CharacterItems), "SpawnItemInHand", new Type[1] { typeof(string) }, (Type[])null);
					try
					{
						methodInfo.Invoke(items, new object[1] { itemName });
						return true;
					}
					catch
					{
					}
				}
			}
			return false;
		}

		public void Dispose()
		{
			Object.Destroy((Object)(object)CDTextGO);
			Object.Destroy((Object)(object)CDCircleGO);
			Object.Destroy((Object)(object)CDBackCircleGO);
			Object.Destroy((Object)(object)InfoTextGO);
			Object.Destroy((Object)(object)canvasGO);
		}

		public static List<Type> GetClassArray()
		{
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			if (ClassTypes == null)
			{
				ClassTypes = executingAssembly.GetTypes().Where(delegate(Type t)
				{
					int result;
					if (t.IsClass && !t.IsAbstract)
					{
						string? text = t.Namespace;
						if (text != null && text.StartsWith("AnotherClassMod.Class"))
						{
							result = (typeof(BaseClass).IsAssignableFrom(t) ? 1 : 0);
							goto IL_003c;
						}
					}
					result = 0;
					goto IL_003c;
					IL_003c:
					return (byte)result != 0;
				}).ToList();
			}
			return ClassTypes;
		}

		public int ClassIndexInList()
		{
			return GetClassArray().IndexOf(GetType());
		}
	}
	public class Cook : BaseClass
	{
		private float range = 100f;

		private float lessPrecent = 0.3f;

		public Cook()
		{
			base.ClassTrigger = CookAura;
			base.ClassSkill = CookSkill;
			base.ClassSkillCoolDown = 25f;
			base.ClassColor = "#FFB703";
		}

		public void CookAura()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.dead)
			{
				return;
			}
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: true);
				if (obj != null)
				{
					obj.RPC("RPC_SubtractStatus", (RpcTarget)0, new object[4]
					{
						Character.localCharacter.Center,
						range,
						(object)(STATUSTYPE)1,
						0.0005f * lessPrecent
					});
				}
			}
		}

		public bool CookSkill()
		{
			if (Character.localCharacter.data.fullyPassedOut || Character.localCharacter.data.dead)
			{
				return false;
			}
			return SpawnItemInHand("PortableStovetopItem");
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "厨师";
			}
			return "Cook";
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "技能：生成锅；被动：抗饿光环";
			}
			return "[Skill] Spawn Stovetop. [Passive] emits a hunger-reduction Aura.";
		}
	}
	public class Crypto : BaseClass
	{
		private Vector3 lockPostion;

		private float camSpeed = 6f;

		private GameObject currentLocalModel;

		public Vector3 camOffset { get; set; }

		public bool isCamMoving { get; set; } = false;

		public Crypto()
		{
			base.ClassTrigger = Aura;
			base.ClassSkill = Skill;
			base.ClassSkillCoolDown = 1f;
			base.ClassColor = "#70E000";
		}

		private void Aura()
		{
			//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_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: 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_0084: 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_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: 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_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: 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_00ef: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.fullyPassedOut || Character.localCharacter.data.dead)
			{
				isCamMoving = false;
			}
			if (isCamMoving)
			{
				Transform transform = ((Component)Camera.main).transform;
				Vector3 val = Vector3.zero;
				if (Input.GetKey((KeyCode)119))
				{
					val += transform.forward;
				}
				if (Input.GetKey((KeyCode)115))
				{
					val -= transform.forward;
				}
				if (Input.GetKey((KeyCode)97))
				{
					val -= transform.right;
				}
				if (Input.GetKey((KeyCode)100))
				{
					val += transform.right;
				}
				if (Input.GetKey((KeyCode)32))
				{
					val += transform.up;
				}
				if (Input.GetKey((KeyCode)306))
				{
					val -= transform.up;
				}
				camOffset += val * Time.deltaTime * camSpeed;
				LoadItemToScreenCenter();
			}
			else
			{
				ClearCurrentModel();
			}
		}

		private bool Skill()
		{
			//IL_0080: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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)
			if (Character.localCharacter.data.fullyPassedOut || Character.localCharacter.data.dead)
			{
				isCamMoving = false;
				return false;
			}
			isCamMoving = !isCamMoving;
			if (isCamMoving)
			{
				camOffset = Vector3.up * 3f;
				lockPostion = Character.localCharacter.Center;
			}
			else
			{
				Character.localCharacter.WarpPlayerRPC(lockPostion, false);
			}
			return true;
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "技能：召唤皇帝的新无人机（可交互、右键、ping）";
			}
			return "[Skill] Summon the Emperor's New Drone(right click, ping).";
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "DJI高手";
			}
			return "Crypto";
		}

		public void LoadItemToScreenCenter()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: 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_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: 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_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			ClearCurrentModel();
			string text = "0_Items/Glider";
			GameObject val = Resources.Load<GameObject>(text);
			if (!((Object)(object)val == (Object)null))
			{
				Camera main = Camera.main;
				if (!((Object)(object)main == (Object)null))
				{
					Vector3 val2 = ((Component)main).transform.position + ((Component)main).transform.forward * 4f + ((Component)main).transform.up * -0.5f;
					currentLocalModel = Object.Instantiate<GameObject>(val, val2, ((Component)main).transform.rotation);
					Transform transform = currentLocalModel.transform;
					transform.localScale *= 0.3f;
					currentLocalModel.transform.SetParent(((Component)main).transform);
				}
			}
		}

		public void ClearCurrentModel()
		{
			if ((Object)(object)currentLocalModel != (Object)null)
			{
				Object.Destroy((Object)(object)currentLocalModel);
				currentLocalModel = null;
			}
		}
	}
	public class Dancer : BaseClass
	{
		private float range = 8f;

		private Character partner = Character.localCharacter;

		private float amountTime = 2f;

		private float buffDuration = 8f;

		private float buffDuration_range_down = 6f;

		private float buffDuration_range_up = 10f;

		private float buffTicker = 0f;

		public Dancer()
		{
			base.ClassTrigger = Aura;
			base.ClassSkill = Skill;
			base.ClassSkillCoolDown = 1f;
			base.ClassColor = "#F72585";
		}

		public void Aura()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			buffTicker += Time.deltaTime;
			Affliction val = default(Affliction);
			if (buffTicker > buffDuration && !Character.localCharacter.data.dead && Character.AllCharacters.IndexOf(partner) != -1 && (Object)(object)partner != (Object)(object)Character.localCharacter && Vector3.Distance(partner.Center, Character.localCharacter.Center) < range && !partner.refs.afflictions.HasAfflictionType((AfflictionType)2, ref val))
			{
				SelectedClass instance = SelectedClass.Instance;
				if (instance != null)
				{
					PhotonView obj = instance.PVReadyByTicker(hasDuration: false);
					if (obj != null)
					{
						obj.RPC("RPC_AddAffliction_Affliction_FasterBoi", ((MonoBehaviourPun)partner).photonView.Owner, new object[3]
						{
							Character.localCharacter.Center,
							range,
							amountTime
						});
					}
				}
				SelectedClass instance2 = SelectedClass.Instance;
				if (instance2 != null)
				{
					PhotonView obj2 = instance2.PVReadyByTicker(hasDuration: false);
					if (obj2 != null)
					{
						obj2.RPC("RPC_AddAffliction_Affliction_FasterBoi", ((MonoBehaviourPun)Character.localCharacter).photonView.Owner, new object[3]
						{
							Character.localCharacter.Center,
							range,
							amountTime
						});
					}
				}
			}
			if (buffTicker > buffDuration)
			{
				buffTicker = 0f;
				buffDuration = Random.Range(buffDuration_range_down, buffDuration_range_up);
			}
		}

		public bool Skill()
		{
			List<Character> allCharacters = Character.AllCharacters;
			partner = Character.localCharacter;
			if (allCharacters != null && allCharacters.Count > 1)
			{
				int num = allCharacters.IndexOf(partner);
				int num2 = 0;
				while ((Object)(object)partner == (Object)(object)Character.localCharacter && num2++ < 10)
				{
					partner = allCharacters[++num % allCharacters.Count];
				}
				if ((Object)(object)partner != (Object)(object)Character.localCharacter && partner.IsPlayerControlled)
				{
					RestartInfoText("<color=#03543F>Partner: " + partner.characterName + "</color>");
					return true;
				}
			}
			RestartInfoText("<color=#E6A23C>No Partner</color>");
			return false;
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "舞者";
			}
			return "Dancer";
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "技能：更换舞伴；被动：靠近舞伴获得增强！";
			}
			return "[Skill] Switch Partner. [Passive] Proximity to partner grants a buff.";
		}
	}
	public class Endurer : BaseClass
	{
		private float range = 15f;

		private float max_extra_stamina = 0.2f;

		private float amount = 0.05f;

		private float time = 2.5f;

		public Endurer()
		{
			base.ClassTrigger = Aura;
			base.ClassSkill = Skill;
			base.ClassSkillCoolDown = 30f;
			base.ClassColor = "#E07A5F";
		}

		private void Aura()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.dead)
			{
				return;
			}
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: true);
				if (obj != null)
				{
					obj.RPC("RPC_AddExtraStamina", (RpcTarget)0, new object[4]
					{
						Character.localCharacter.Center,
						range,
						max_extra_stamina,
						amount
					});
				}
			}
		}

		private bool Skill()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.fullyPassedOut || Character.localCharacter.data.dead)
			{
				return false;
			}
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: false);
				if (obj != null)
				{
					obj.RPC("RPC_AddAffliction_InfiniteStamina", (RpcTarget)0, new object[3]
					{
						Character.localCharacter.Center,
						range,
						time
					});
				}
			}
			Plugin.Logger.LogInfo((object)"Endurer Skill RPC...");
			return true;
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "技能：吹响号角！被动：恢复额外耐力条光环";
			}
			return "[Skill] Sound the Horn! [Passive] Aura: Extra Stamina Recovery";
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "忍耐者";
			}
			return "Endurer";
		}
	}
	public class Gibbon : BaseClass
	{
		public static float PullRange = 6f;

		private float maxSkillPullRange = 12f;

		public Gibbon()
		{
			base.ClassTrigger = Aura;
			base.ClassSkill = Skill;
			base.ClassSkillCoolDown = 30f;
			base.ClassColor = "#D4A373";
		}

		private void Aura()
		{
		}

		private bool Skill()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: 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_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.fullyPassedOut || Character.localCharacter.data.dead)
			{
				return false;
			}
			Character val = null;
			float num = float.MinValue;
			foreach (Character item in Character.AllCharacters.Where((Character c) => c.IsPlayerControlled).ToList())
			{
				if (item.data.dead)
				{
					break;
				}
				float num2 = Vector3.Distance(item.Center, Character.localCharacter.Center);
				if (num2 <= maxSkillPullRange && num2 > num)
				{
					num = num2;
					val = item;
				}
			}
			if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)Character.localCharacter)
			{
				((MonoBehaviourPun)val).photonView.RPC("WarpPlayerRPC", ((MonoBehaviourPun)val).photonView.Owner, new object[2]
				{
					Character.localCharacter.Center + Vector3.up * 2f,
					false
				});
				Plugin.Logger.LogInfo((object)"Gibbon Skill RPC...");
				return true;
			}
			return false;
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "技能：把最远队友拉向自己(存在距离限制)；被动：右键拉队友的距离增大";
			}
			return "[Skill] Pulls the farthest ally toward you (Max distance applies). [Passive] Extends the pull range when dragging allies via Right-Click";
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "长臂猿";
			}
			return "Gibbon";
		}
	}
	public class Medic : BaseClass
	{
		private float medicRange = 8f;

		private float medicAmount = 0.01f;

		private float milkTime = 4f;

		public Medic()
		{
			base.ClassTrigger = MedicAura;
			base.ClassSkill = MedicSkill;
			base.ClassSkillCoolDown = 40f;
			base.ClassColor = "#FF5E7E";
		}

		public void MedicAura()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: 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)
			if (Character.localCharacter.data.dead)
			{
				return;
			}
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: true);
				if (obj != null)
				{
					obj.RPC("RPC_SubtractStatus", (RpcTarget)0, new object[4]
					{
						Character.localCharacter.Center,
						medicRange,
						(object)(STATUSTYPE)0,
						medicAmount
					});
				}
			}
			SelectedClass instance2 = SelectedClass.Instance;
			if (instance2 != null)
			{
				PhotonView obj2 = instance2.PVReadyByTicker(hasDuration: true);
				if (obj2 != null)
				{
					obj2.RPC("RPC_SubtractStatus", (RpcTarget)0, new object[4]
					{
						Character.localCharacter.Center,
						medicRange,
						(object)(STATUSTYPE)3,
						medicAmount
					});
				}
			}
			SelectedClass instance3 = SelectedClass.Instance;
			if (instance3 != null)
			{
				PhotonView obj3 = instance3.PVReadyByTicker(hasDuration: true);
				if (obj3 != null)
				{
					obj3.RPC("RPC_SubtractStatus", (RpcTarget)0, new object[4]
					{
						Character.localCharacter.Center,
						medicRange,
						(object)(STATUSTYPE)10,
						medicAmount
					});
				}
			}
		}

		public bool MedicSkill()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.fullyPassedOut || Character.localCharacter.data.dead)
			{
				return false;
			}
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: false);
				if (obj != null)
				{
					obj.RPC("RPC_AddAffliction_InvincibilityFromMilk", (RpcTarget)0, new object[3]
					{
						Character.localCharacter.Center,
						medicRange,
						milkTime
					});
				}
			}
			Plugin.Logger.LogInfo((object)"Medic Skill RPC...");
			return true;
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "医生";
			}
			return "Medic";
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "技能：对范围内队友使用奶白金；被动：范围治疗光环";
			}
			return "[Active] use Fortified Milk on allies. [Passive] Emits a Healing Aura.";
		}
	}
	public class Porter : BaseClass
	{
		public static sbyte maxBackpackSlots = 6;

		private int lowGravAmount = 5;

		private float totalTime = 1f;

		private float gravRange = 10f;

		private float range = 100f;

		private float weightReduce = 0.3f;

		public Porter()
		{
			base.ClassTrigger = Aura;
			base.ClassSkill = Skill;
			base.ClassSkillCoolDown = 30f;
			base.ClassColor = "#FF7F11";
		}

		private void Aura()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.dead)
			{
				return;
			}
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: true);
				if (obj != null)
				{
					obj.RPC("RPC_WeightReduce", (RpcTarget)0, new object[3]
					{
						Character.localCharacter.Center,
						range,
						weightReduce
					});
				}
			}
		}

		private bool Skill()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.fullyPassedOut || Character.localCharacter.data.dead)
			{
				return false;
			}
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: false);
				if (obj != null)
				{
					obj.RPC("RPC_Affliction_LowGravity", (RpcTarget)0, new object[4]
					{
						Character.localCharacter.Center,
						gravRange,
						lowGravAmount,
						totalTime
					});
				}
			}
			Plugin.Logger.LogInfo((object)"Porter Skill RPC...");
			return true;
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "主动：改变重力；被动：队友背包格子+2; 减重光环";
			}
			return "[Skill]Change Gravity. [Passive] Ally Backpack Slots +2; Aura: Weight Reduce";
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "负重者";
			}
			return "Porter";
		}
	}
	public class Rescuer : BaseClass
	{
		private float amount_1f = 0.01f;

		public Rescuer()
		{
			base.ClassTrigger = Aura;
			base.ClassSkill = Skill;
			base.ClassSkillCoolDown = 30f;
			base.ClassColor = "#00F5D4";
		}

		private void Aura()
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.dead)
			{
				return;
			}
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: true);
				if (obj != null)
				{
					obj.RPC("RPC_SubtractStatus_WhoPassOut", (RpcTarget)1, new object[4]
					{
						Character.localCharacter.Center,
						5f,
						(object)(STATUSTYPE)0,
						amount_1f
					});
				}
			}
		}

		private bool Skill()
		{
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.fullyPassedOut || Character.localCharacter.data.dead)
			{
				return false;
			}
			Character val = null;
			float num = float.MaxValue;
			foreach (Character item in Character.AllCharacters.Where((Character c) => c.IsPlayerControlled).ToList())
			{
				if (item.data.dead)
				{
					break;
				}
				if (item.Center.y < num)
				{
					num = item.Center.y;
					val = item;
				}
			}
			if ((Object)(object)val != (Object)null && (Object)(object)Character.localCharacter != (Object)(object)val)
			{
				Character.localCharacter.WarpPlayerRPC(val.Center + Vector3.up * 2f, false);
				return true;
			}
			return false;
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "技能：飞向位置最低的落后队友；被动：能缓慢治疗晕倒队友的光环";
			}
			return "[Skill] Flies to the ally with the lowest position. [Passive] Emits an aura that slowly heals knocked-out allies.";
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "救援者";
			}
			return "Rescuer";
		}
	}
	public class SoulChainer : BaseClass
	{
		private float skillDuration = 15f;

		private float skillTicker = 0f;

		private bool useSkill = false;

		public SoulChainer()
		{
			base.ClassTrigger = Aura;
			base.ClassSkill = Skill;
			base.ClassSkillCoolDown = 60f;
			base.ClassColor = "#111625";
		}

		public void Aura()
		{
			if (Character.localCharacter.data.dead)
			{
				return;
			}
			if (useSkill)
			{
				skillTicker += Time.deltaTime;
				if (skillTicker > skillDuration)
				{
					useSkill = false;
					skillTicker = 0f;
				}
				return;
			}
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: true);
				if (obj != null)
				{
					obj.RPC("RPC_AvgStatus_Chain_Aura", (RpcTarget)0, new object[0]);
				}
			}
		}

		public bool Skill()
		{
			if (Character.localCharacter.data.dead)
			{
				return false;
			}
			float num = Character.AllCharacters.Where((Character c) => !c.data.dead && c.IsPlayerControlled).Sum((Character t) => t.refs.afflictions.GetCurrentStatus((STATUSTYPE)1));
			float num2 = Character.AllCharacters.Where((Character c) => !c.data.dead && c.IsPlayerControlled).Sum((Character t) => t.refs.afflictions.GetCurrentStatus((STATUSTYPE)0));
			float num3 = Character.AllCharacters.Where((Character c) => !c.data.dead && c.IsPlayerControlled).Sum((Character t) => t.refs.afflictions.GetCurrentStatus((STATUSTYPE)3));
			float num4 = Character.AllCharacters.Where((Character c) => !c.data.dead && c.IsPlayerControlled).Sum((Character t) => t.refs.afflictions.GetCurrentStatus((STATUSTYPE)10));
			float num5 = Character.AllCharacters.Where((Character c) => !c.data.dead && c.IsPlayerControlled).Sum((Character t) => t.refs.afflictions.GetCurrentStatus((STATUSTYPE)6));
			float num6 = Character.AllCharacters.Where((Character c) => !c.data.dead && c.IsPlayerControlled).Sum((Character t) => t.refs.afflictions.GetCurrentStatus((STATUSTYPE)8));
			float num7 = Character.AllCharacters.Where((Character c) => !c.data.dead && c.IsPlayerControlled).Sum((Character t) => t.refs.afflictions.GetCurrentStatus((STATUSTYPE)2));
			float num8 = 0f;
			if ((num8 = num + num2 + num3 + num4 + num5 + num6 + num7) > 2f)
			{
				float num9 = 2f / num8;
				num *= num9;
				num2 *= num9;
				num3 *= num9;
				num4 *= num9;
				num5 *= num9;
				num6 *= num9;
				num7 *= num9;
			}
			Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)1, num, true);
			Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)0, num2, true);
			Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)3, num3, true);
			Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)10, num4, true);
			Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)6, num5, true);
			Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)8, num6, true);
			Character.localCharacter.refs.afflictions.SetStatus((STATUSTYPE)2, num7, true);
			SelectedClass instance = SelectedClass.Instance;
			if (instance != null)
			{
				PhotonView obj = instance.PVReadyByTicker(hasDuration: false);
				if (obj != null)
				{
					obj.RPC("RPC_SetStatus_Chain_Skill", (RpcTarget)1, new object[7] { 0f, 0f, 0f, 0f, 0f, 0f, 0f });
				}
			}
			useSkill = true;
			return true;
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "灵魂锁链者(Beta)";
			}
			return "SoulChainer(Beta)";
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "被动：受伤状态会进行均分。主动：从队友处吸收异常状态（最多200%）。";
			}
			return "[Passive] Injury status build-up is shared equally. [Active] Absorbs up to 200% of negative status effects from allies for a duration";
		}
	}
	public class TimeTraveler : BaseClass
	{
		private struct savedCharacter
		{
			public float[] savedStatus;

			public Vector3 savedPosition;
		}

		private KeyCode savedKeys;

		private float saveDuration = 0.5f;

		private float saveTicker = 0f;

		private int maxSavedCount = 60;

		private Dictionary<int, savedCharacter> savedCharacters = new Dictionary<int, savedCharacter>();

		public TimeTraveler()
		{
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			base.ClassTrigger = Aura;
			base.ClassSkill = Skill;
			base.ClassSkillCoolDown = 40f;
			base.ClassColor = "#00B4D8";
			savedKeys = (KeyCode)118;
		}

		private void Aura()
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: 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_0096: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			if (!Input.GetKeyDown(savedKeys))
			{
				return;
			}
			foreach (Character item in Character.AllCharacters.Where((Character ct) => ct.IsPlayerControlled).ToList())
			{
				savedCharacter value = new savedCharacter
				{
					savedStatus = new float[item.refs.afflictions.currentStatuses.Length],
					savedPosition = new Vector3(item.Center.x, item.Center.y, item.Center.z)
				};
				Array.Copy(item.refs.afflictions.currentStatuses, value.savedStatus, item.refs.afflictions.currentStatuses.Length);
				savedCharacters[((MonoBehaviourPun)item).photonView.ViewID] = value;
			}
			RestartInfoText("<color=#22C55E>Time Saved</color>");
		}

		private bool Skill()
		{
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			if (Character.localCharacter.data.dead)
			{
				return false;
			}
			foreach (Character item in Character.AllCharacters.Where((Character ct) => ct.IsPlayerControlled).ToList())
			{
				if (item.data.dead && savedCharacters[((MonoBehaviourPun)item).photonView.ViewID].savedStatus != null)
				{
					_ = savedCharacters[((MonoBehaviourPun)item).photonView.ViewID];
					if (true)
					{
						continue;
					}
				}
				savedCharacter savedCharacter = savedCharacters[((MonoBehaviourPun)item).photonView.ViewID];
				((MonoBehaviourPun)item).photonView.RPC("WarpPlayerRPC", ((MonoBehaviourPun)item).photonView.Owner, new object[2] { savedCharacter.savedPosition, false });
				SelectedClass instance = SelectedClass.Instance;
				if (instance != null)
				{
					PhotonView obj = instance.PVReadyByTicker(hasDuration: false);
					if (obj != null)
					{
						obj.RPC("RPC_SetSavedStatus", (RpcTarget)0, new object[2]
						{
							savedCharacter.savedStatus,
							((MonoBehaviourPun)item).photonView.ViewID
						});
					}
				}
			}
			return true;
		}

		public override string InnerText_ClassDescription()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "技能：回到过去；被动：记录时间点(V键)";
			}
			return "[Skill] Time Rewind. [Passive] Record Timeline.(key：V)";
		}

		public override string InnerText_ClassName()
		{
			//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_0008: 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_000a: 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)
			//IL_000e: Invalid comparison between Unknown and I4
			Language cURRENT_LANGUAGE = LocalizedText.CURRENT_LANGUAGE;
			Language val = cURRENT_LANGUAGE;
			Language val2 = val;
			if ((int)val2 == 9)
			{
				return "时间旅行者";
			}
			return "TimeTraveler";
		}
	}
	public class Warlock : BaseClass
	{
		private float CeremonyLastTime { get; set; } = 0f;

		public Warlock()
		{
			base.ClassTrigger = Aura;
			base.ClassSkill = Skill;
			base.ClassSkillCoolDown = 3f;
			base.ClassColor = "#9B5DE5";
		}

		private void Aura()
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0157: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			List<int> list = new List<int>();
			List<Character> list2 = new List<Character>();
			bool flag = true;
			int num = 0;
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (!allCharacter.IsPlayerControlled || allCharacter.data.dead || allCharacter.data.fullyPassedOut)
				{
					list2.Add(allCharacter);
					continue;
				}
				num++;
				float num2 = Vector3.Distance(allCharacter.Center, Character.localCharacter.Center);
				if (num2 > 4f || !allCharacter.input.useSecondaryIsPressed)
				{
					flag = false;
				}
				else
				{
					list.Add(((MonoBehaviourPun)allCharacter).photonView.ViewID);
				}
			}
			if (num > 1 && flag)
			{
				CeremonyLastTime += Time.de