using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Logging;
using HarmonyLib;
using Peak.Afflictions;
using PeakClassMod.Handlers;
using PeakClassMod.Utils;
using Photon.Pun;
using Photon.Realtime;
using TMPro;
using UnityEngine;
using UnityEngine.Networking;
using UnityEngine.Rendering;
using UnityEngine.UI;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: AssemblyTitle("Mod_Peak_2026")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("Mod_Peak_2026")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("6f7cd0cf-eafa-4617-93d2-7739adc5a0a0")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETFramework,Version=v4.7.2", FrameworkDisplayName = ".NET Framework 4.7.2")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace Mod_Peak_2026.src.Patches
{
	[HarmonyPatch(typeof(Backpack), "Wear")]
	public class BackpackBlocker
	{
		private static bool Prefix(Character interactor)
		{
			if (ClassCheckUtil.IsWolf(interactor))
			{
				Debug.LogWarning((object)"Cannot carry backpacks!");
				return false;
			}
			return true;
		}
	}
}
namespace PeakClassMod
{
	public static class ClassBalance
	{
		public const string BLOWGUN = "HealingDart Variant";

		public const float GOBELIN_SIZE = 0.5f;

		public const float GOBELIN_CURSE_PER_SHOT = 0.05f;

		public const float ASTRONAUT_JUMP_IMPULSE = 1200f;

		public const float ASTRONAUT_SPRINT_MULT = 1.7f;

		public const float ASTRONAUT_HUNGER_MULT = 1.3f;

		public const float ASTRONAUT_MAX_WALK_SPEED = 1.6f;

		public const float ASTRONAUT_LOW_GRAV_DURATION = 3f;

		public const float GENERAL_CURSE_MIN = 0.35f;

		public const float GENERAL_HUNGER_MULT = 2f;

		public const float GENERAL_WEIGHT_MULT = 2f;

		public const float GENERAL_SPEED_MULT = 0.75f;

		public const float MEDIC_CURSE = 0.15f;

		public const int MEDIC_MAX_HEALS = 10;

		public const float MEDIC_HEAL_AMOUNT = 0.1f;

		public const float MEDIC_HEAL_COOLDOWN = 1f;

		public const float SCOUT_STAMINA_MULT = 0.8f;

		public const float SCOUT_HUNGER_MULT = 1.7f;

		public const float SCOUT_WEIGHT_MULT = 0.5f;

		public const float ROGUE_STAMINA_MULT = 1.7f;

		public const int ROGUE_EXTRA_JUMPS = 2;

		public const float GREATEPEE_SLEEP_MIN = 30f;

		public const float GREATEPEE_SLEEP_MAX = 60f;

		public const float GREATEPEE_EFFECT_DURATION = 99999f;

		public const float MUSHROOM_STAMINA_COOLDOWN = 10f;

		public const float MUSHROOM_CURSE_AMOUNT = 0.02f;

		public const float ITEM_REQUEST_DELAY = 0.3f;

		public const float ITEM_GIVE_COOLDOWN = 2f;

		public const float ITEM_CACHE_DURATION = 300f;

		public const float SIZE_CHECK_INTERVAL = 0.5f;

		public const float TECH_PRIEST_HUNGER_MULT = 1.5f;

		public const float WOLF_CLIMB_SPEED_MULT = 1.3f;

		public const float WOLF_SPRINT_SPEED_MULT = 1.3f;

		public const float WOLF_HUNGER_MULT = 1.3f;

		public const float WOLF_EFFECT_TICK_INTERVAL = 3f;
	}
	public static class ClassManager
	{
		[CompilerGenerated]
		private sealed class <GreatEpeePermanentEffects>d__33 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Character character;

			private bool <hasFaster>5__1;

			private List<Affliction> <list>5__2;

			private int <i>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GreatEpeePermanentEffects>d__33(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<list>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0109: Unknown result type (might be due to invalid IL or missing references)
				//IL_0113: Expected O, but got Unknown
				//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					<list>5__2 = null;
					break;
				}
				if (PeakClassModPlugin.greatEpeeActive && (Object)(object)character != (Object)null && character.IsLocal)
				{
					<hasFaster>5__1 = false;
					<list>5__2 = character.refs?.afflictions?.afflictionList;
					if (<list>5__2 != null)
					{
						<i>5__3 = 0;
						while (<i>5__3 < <list>5__2.Count)
						{
							if (((object)<list>5__2[<i>5__3]).GetType().Name.Contains("FasterBoi"))
							{
								<hasFaster>5__1 = true;
								break;
							}
							<i>5__3++;
						}
					}
					if (!<hasFaster>5__1)
					{
						character.refs.afflictions.AddAffliction((Affliction)new Affliction_FasterBoi
						{
							totalTime = 99999f
						}, false);
					}
					<>2__current = (object)new WaitForSeconds(2f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <GreatEpeeStaminaRoutine>d__34 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Character character;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <GreatEpeeStaminaRoutine>d__34(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				//IL_0063: Unknown result type (might be due to invalid IL or missing references)
				//IL_006d: Expected O, but got Unknown
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				//IL_0102: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_018e;
				case 2:
					<>1__state = -1;
					if (!PeakClassModPlugin.greatEpeeActive)
					{
						return false;
					}
					goto IL_008c;
				case 3:
					{
						<>1__state = -1;
						if ((Object)(object)character?.refs?.afflictions == (Object)null || !PeakClassModPlugin.greatEpeeActive)
						{
							return false;
						}
						if (character.refs.afflictions.GetCurrentStatus((STATUSTYPE)6) < 0.1f)
						{
							character.refs.afflictions.AddStatus((STATUSTYPE)6, 1f, false, true, true);
						}
						goto IL_018e;
					}
					IL_008c:
					if ((Object)(object)character?.refs?.afflictions != (Object)null && character.refs.afflictions.GetCurrentStatus((STATUSTYPE)6) > 0.05f)
					{
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 2;
						return true;
					}
					if ((Object)(object)character == (Object)null)
					{
						return false;
					}
					<>2__current = (object)new WaitForSeconds(Random.Range(30f, 60f));
					<>1__state = 3;
					return true;
					IL_018e:
					if (!PeakClassModPlugin.greatEpeeActive || !((Object)(object)character != (Object)null) || !character.IsLocal)
					{
						break;
					}
					goto IL_008c;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <MushroomancerGiveItemDelayed>d__32 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Character character;

			public ushort itemId;

			private float <timeout>5__1;

			private bool <hasSpaceInBaseSlots>5__2;

			private int <maxSlotsToCheck>5__3;

			private int <i>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <MushroomancerGiveItemDelayed>d__32(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0046: Unknown result type (might be due to invalid IL or missing references)
				//IL_0050: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<timeout>5__1 = 5f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((Object)(object)character != (Object)null && (Object)(object)character.data != (Object)null && (!character.data.isGrounded || character.data.isSprinting) && <timeout>5__1 > 0f)
				{
					<timeout>5__1 -= 0.1f;
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				}
				if ((Object)(object)character != (Object)null && (Object)(object)character.player != (Object)null && character.player.itemSlots != null)
				{
					<hasSpaceInBaseSlots>5__2 = false;
					<maxSlotsToCheck>5__3 = Mathf.Min(3, character.player.itemSlots.Length);
					<i>5__4 = 0;
					while (<i>5__4 < <maxSlotsToCheck>5__3)
					{
						if (character.player.itemSlots[<i>5__4] != null && character.player.itemSlots[<i>5__4].IsEmpty())
						{
							<hasSpaceInBaseSlots>5__2 = true;
							break;
						}
						<i>5__4++;
					}
					if (<hasSpaceInBaseSlots>5__2 && character.player.HasEmptySlot(itemId))
					{
						ItemSlot val = default(ItemSlot);
						character.player.AddItem(itemId, (ItemInstanceData)null, ref val);
					}
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <MushroomancerLocalStaminaWatch>d__30 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public Character character;

			private bool <isKnockedOut>5__1;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <MushroomancerLocalStaminaWatch>d__30(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d2: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if ((Object)(object)character != (Object)null && PeakClassModPlugin.mushroomancerActive && character.IsLocal)
				{
					<isKnockedOut>5__1 = false;
					if ((Object)(object)character.data != (Object)null && (character.data.passedOut || character.data.fullyPassedOut || character.data.dead))
					{
						<isKnockedOut>5__1 = true;
					}
					if (!<isKnockedOut>5__1 && character.data.currentStamina <= 0.02f)
					{
						TryActivateStaminaZeroMechanic(character);
					}
					<>2__current = (object)new WaitForSeconds(0.1f);
					<>1__state = 1;
					return true;
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static readonly Dictionary<int, float> lastStaminaZeroTime = new Dictionary<int, float>();

		private static readonly Dictionary<int, int> staminaZeroCount = new Dictionary<int, int>();

		private static Coroutine _mushroomCoroutine;

		private static Coroutine _greatEpeeEffectsCoroutine;

		private static Coroutine _greatEpeeStaminaCoroutine;

		private static readonly string[] ZeroStaminaFungi = new string[3] { "ShelfShroom", "BounceShroom", "CloudFungus" };

		public static void ResetAllFlags()
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter != (Object)null)
			{
				if (_mushroomCoroutine != null)
				{
					((MonoBehaviour)localCharacter).StopCoroutine(_mushroomCoroutine);
				}
				if (_greatEpeeEffectsCoroutine != null)
				{
					((MonoBehaviour)localCharacter).StopCoroutine(_greatEpeeEffectsCoroutine);
				}
				if (_greatEpeeStaminaCoroutine != null)
				{
					((MonoBehaviour)localCharacter).StopCoroutine(_greatEpeeStaminaCoroutine);
				}
				((Component)localCharacter).transform.localScale = Vector3.one;
			}
			PeakClassModPlugin.scoutActive = false;
			PeakClassModPlugin.medicActive = false;
			PeakClassModPlugin.techPriestActive = false;
			PeakClassModPlugin.mushroomancerActive = false;
			PeakClassModPlugin.greatEpeeActive = false;
			PeakClassModPlugin.rogueActive = false;
			PeakClassModPlugin.generalActive = false;
			PeakClassModPlugin.astronautActive = false;
			PeakClassModPlugin.gobelinActive = false;
			PeakClassModPlugin.wolfActive = false;
			PeakClassModPlugin.currentClass = "None";
		}

		public static void ActivateScoutClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.scoutActive = true;
			PeakClassModPlugin.currentClass = "Scout";
		}

		public static void ActivateMedicClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.medicActive = true;
			PeakClassModPlugin.currentClass = "Medic";
		}

		public static void ActivateTechPriestClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.techPriestActive = true;
			PeakClassModPlugin.currentClass = "Tech-Priest";
		}

		public static void ActivateMushroomancerClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.mushroomancerActive = true;
			PeakClassModPlugin.currentClass = "Mushroomancer";
		}

		public static void ActivateGreatEpeeClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.greatEpeeActive = true;
			PeakClassModPlugin.currentClass = "GreatEpee";
		}

		public static void ActivateRogueClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.rogueActive = true;
			PeakClassModPlugin.currentClass = "Rogue";
			if ((Object)(object)Character.localCharacter != (Object)null)
			{
				Character.localCharacter.data.jumpsRemaining = 2;
			}
		}

		public static void ActivateGeneralClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.generalActive = true;
			PeakClassModPlugin.currentClass = "General";
		}

		public static void ActivateAstronautClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.astronautActive = true;
			PeakClassModPlugin.currentClass = "Astronaut";
		}

		public static void ActivateGobelinClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.gobelinActive = true;
			PeakClassModPlugin.currentClass = "Gobelin";
		}

		public static void ActivateWolfClass()
		{
			ResetAllFlags();
			PeakClassModPlugin.wolfActive = true;
			PeakClassModPlugin.currentClass = "Wolf";
		}

		public static void DeactivateAllClasses()
		{
			ResetAllFlags();
			if ((Object)(object)Character.localCharacter != (Object)null)
			{
				Character.localCharacter.data.jumpsRemaining = 1;
			}
		}

		public static bool IsScoutActive()
		{
			return PeakClassModPlugin.scoutActive;
		}

		public static bool IsMedicActive()
		{
			return PeakClassModPlugin.medicActive;
		}

		public static bool IsTechPriestActive()
		{
			return PeakClassModPlugin.techPriestActive;
		}

		public static bool IsMushroomancerActive()
		{
			return PeakClassModPlugin.mushroomancerActive;
		}

		public static bool IsGreatEpeeActive()
		{
			return PeakClassModPlugin.greatEpeeActive;
		}

		public static bool IsRogueActive()
		{
			return PeakClassModPlugin.rogueActive;
		}

		public static bool IsGeneralActive()
		{
			return PeakClassModPlugin.generalActive;
		}

		public static bool IsAstronautActive()
		{
			return PeakClassModPlugin.astronautActive;
		}

		public static bool IsGobelinActive()
		{
			return PeakClassModPlugin.gobelinActive;
		}

		public static bool IsWolfActive()
		{
			return PeakClassModPlugin.wolfActive;
		}

		public static void StartMushroomancerWatch(Character character)
		{
			if ((Object)(object)character != (Object)null)
			{
				_mushroomCoroutine = ((MonoBehaviour)character).StartCoroutine(MushroomancerLocalStaminaWatch(character));
			}
		}

		public static void StartGreatEpeeRoutines(Character character)
		{
			if ((Object)(object)character != (Object)null)
			{
				_greatEpeeEffectsCoroutine = ((MonoBehaviour)character).StartCoroutine(GreatEpeePermanentEffects(character));
				_greatEpeeStaminaCoroutine = ((MonoBehaviour)character).StartCoroutine(GreatEpeeStaminaRoutine(character));
			}
		}

		[IteratorStateMachine(typeof(<MushroomancerLocalStaminaWatch>d__30))]
		public static IEnumerator MushroomancerLocalStaminaWatch(Character character)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MushroomancerLocalStaminaWatch>d__30(0)
			{
				character = character
			};
		}

		public static void TryActivateStaminaZeroMechanic(Character character)
		{
			object obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				PhotonView photonView = ((MonoBehaviourPun)character).photonView;
				obj = ((photonView != null) ? photonView.Owner : null);
			}
			if (obj == null)
			{
				return;
			}
			int actorNumber = ((MonoBehaviourPun)character).photonView.Owner.ActorNumber;
			if (lastStaminaZeroTime.TryGetValue(actorNumber, out var value) && Time.time - value < 10f)
			{
				return;
			}
			lastStaminaZeroTime[actorNumber] = Time.time;
			if (!staminaZeroCount.ContainsKey(actorNumber))
			{
				staminaZeroCount[actorNumber] = 0;
			}
			staminaZeroCount[actorNumber]++;
			if (staminaZeroCount[actorNumber] % 2 == 0)
			{
				CharacterRefs refs = character.refs;
				if (refs != null)
				{
					CharacterAfflictions afflictions = refs.afflictions;
					if (afflictions != null)
					{
						afflictions.AddStatus((STATUSTYPE)5, 0.02f, false, true, true);
					}
				}
			}
			string name = ZeroStaminaFungi[Random.Range(0, ZeroStaminaFungi.Length)];
			Item val = ItemCache.Get(name);
			if (!((Object)(object)val == (Object)null))
			{
				ushort itemID = val.itemID;
				if ((Object)(object)character != (Object)null)
				{
					((MonoBehaviour)character).StartCoroutine(MushroomancerGiveItemDelayed(character, itemID));
				}
			}
		}

		[IteratorStateMachine(typeof(<MushroomancerGiveItemDelayed>d__32))]
		private static IEnumerator MushroomancerGiveItemDelayed(Character character, ushort itemId)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <MushroomancerGiveItemDelayed>d__32(0)
			{
				character = character,
				itemId = itemId
			};
		}

		[IteratorStateMachine(typeof(<GreatEpeePermanentEffects>d__33))]
		public static IEnumerator GreatEpeePermanentEffects(Character character)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GreatEpeePermanentEffects>d__33(0)
			{
				character = character
			};
		}

		[IteratorStateMachine(typeof(<GreatEpeeStaminaRoutine>d__34))]
		public static IEnumerator GreatEpeeStaminaRoutine(Character character)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GreatEpeeStaminaRoutine>d__34(0)
			{
				character = character
			};
		}
	}
	[BepInPlugin("com.peakmod.classmod", "PEAK Class Mod", "5.1.0")]
	public class PeakClassModPlugin : BaseUnityPlugin
	{
		public static PeakClassModPlugin Instance;

		internal static ManualLogSource Log;

		private static Harmony harmony;

		public static bool scoutActive = false;

		public static bool medicActive = false;

		public static bool techPriestActive = false;

		public static bool mushroomancerActive = false;

		public static bool greatEpeeActive = false;

		public static bool rogueActive = false;

		public static bool generalActive = false;

		public static bool astronautActive = false;

		public static bool gobelinActive = false;

		public static bool wolfActive = false;

		public static string currentClass = "None";

		private GameObject _callbacksGO;

		private static readonly string[] StartBerries = new string[5] { "Shroomberry_Red", "Shroomberry_Yellow", "Shroomberry_Purple", "Shroomberry_Blue", "Shroomberry_Green" };

		private void Awake()
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Expected O, but got Unknown
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected O, but got Unknown
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			harmony = new Harmony("com.peakmod.classmod");
			harmony.PatchAll();
			_callbacksGO = new GameObject("PeakClassModCallbacks");
			Object.DontDestroyOnLoad((Object)(object)_callbacksGO);
			_callbacksGO.AddComponent<PeakClassModCallbacks>();
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)"[ClassMod] Ready. Version 5.1.0 loaded (Infinite Fix).");
			}
		}

		private void OnDestroy()
		{
			try
			{
				Harmony obj = harmony;
				if (obj != null)
				{
					obj.UnpatchSelf();
				}
			}
			catch
			{
			}
			if ((Object)(object)_callbacksGO != (Object)null)
			{
				Object.Destroy((Object)(object)_callbacksGO);
			}
		}

		public void EnsureComponent<T>(GameObject go) where T : Component
		{
			if ((Object)(object)go != (Object)null && (Object)(object)go.GetComponent<T>() == (Object)null)
			{
				go.AddComponent<T>();
			}
		}

		public static List<string> BuildStartItemsByHatName(string hatName)
		{
			List<string> list = new List<string>();
			if (string.IsNullOrEmpty(hatName))
			{
				return list;
			}
			switch (hatName)
			{
			case "Hat_Mushroom":
			{
				for (int i = 0; i < 3; i++)
				{
					list.Add(StartBerries[Random.Range(0, StartBerries.Length)]);
				}
				break;
			}
			case "Hat_Medic":
				list.Add("FirstAidKit");
				list.Add("Cure-All");
				break;
			case "Hat_Crab":
				list.Add("ChainShooter");
				list.Add("ChainShooter");
				break;
			case "Hat_NinjaHeadband":
				list.Add("RopeSpool");
				list.Add("RopeSpool");
				break;
			case "Hat_Astronaut":
				list.Add("BalloonBunch");
				break;
			case "Hat_Midsummer":
				list.Add("HealingDart Variant");
				list.Add("MagicBean");
				break;
			}
			return list;
		}
	}
}
namespace PeakClassMod.Utils
{
	public static class ClassCheckUtil
	{
		public static bool IsGeneral(Character ch)
		{
			return HatUtils.HasAnyHat(ch, "Hat_Bandana", "Hat_Captain");
		}

		public static bool IsTechPriest(Character ch)
		{
			return HatUtils.HasHat(ch, "Hat_Crab");
		}

		public static bool IsMedicHat(Character ch)
		{
			return HatUtils.HasAnyHat(ch, "Hat_Medic", "MedicHelmet");
		}

		public static bool IsMushroom(Character ch)
		{
			return HatUtils.HasHat(ch, "Hat_Mushroom");
		}

		public static bool IsRogueHat(Character ch)
		{
			return HatUtils.HasHat(ch, "Hat_NinjaHeadband");
		}

		public static bool IsGreatEpeeHat(Character ch)
		{
			return HatUtils.HasHat(ch, "Hat_Propeller");
		}

		public static bool IsAstronaut(Character ch)
		{
			return HatUtils.HasHat(ch, "Hat_Astronaut");
		}

		public static bool IsGobelin(Character ch)
		{
			return HatUtils.HasAnyHat(ch, "Hat_Midsummer");
		}

		public static bool IsScout(Character ch)
		{
			return HatUtils.HasHat(ch, "Hat_Scoutmaster");
		}

		public static bool IsWolf(Character ch)
		{
			return HatUtils.HasHat(ch, "Hat_WolfEars");
		}
	}
	internal class DaySegmentUtils
	{
		public bool IsDay()
		{
			string text = DayNightManager.instance.TimeOfDayString();
			if (text == "night" || text == "evening")
			{
				return false;
			}
			return true;
		}
	}
	public static class GobelinDiet
	{
		public static bool IsPackagedFood(Item item)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Invalid comparison between Unknown and I4
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			return (item.itemTags & 2) > 0;
		}
	}
	[HarmonyPatch(typeof(AirportCheckInKiosk), "Start")]
	public class HatSignUtils
	{
		public static GameObject hatSign;

		private static void Postfix()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)hatSign != (Object)null)
			{
				return;
			}
			hatSign = new GameObject("HatSignPanel");
			Canvas val = hatSign.AddComponent<Canvas>();
			val.renderMode = (RenderMode)2;
			hatSign.AddComponent<CanvasScaler>();
			hatSign.AddComponent<GraphicRaycaster>();
			int width = 2048;
			int height = 1349;
			GameObject panelObj = new GameObject("Panel");
			panelObj.transform.SetParent(hatSign.transform, false);
			Image val2 = panelObj.AddComponent<Image>();
			((Graphic)val2).color = new Color(0f, 0f, 0f, 0f);
			GameObject imageObj = new GameObject("CustomImage");
			imageObj.transform.SetParent(panelObj.transform, false);
			Image img = imageObj.AddComponent<Image>();
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			string name = "Mod_Peak_2026.assets.image.HatSign.png";
			string text = Path.Combine(Paths.PluginPath, "PeakClassModAssets");
			Directory.CreateDirectory(text);
			string path = Path.Combine(text, "temp_HatSign.png");
			using (Stream stream = executingAssembly.GetManifestResourceStream(name))
			{
				if (stream == null)
				{
					Debug.LogError((object)"Image introuvable dans le DLL !");
					return;
				}
				using FileStream destination = new FileStream(path, FileMode.Create, FileAccess.Write);
				stream.CopyTo(destination);
			}
			if ((Object)(object)ImageLoader.Instance == (Object)null)
			{
				new GameObject("ImageLoader").AddComponent<ImageLoader>();
			}
			ImageLoader.Instance.Load(path, delegate(Texture2D tex)
			{
				//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_0065: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d1: 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_0132: Unknown result type (might be due to invalid IL or missing references)
				if ((Object)(object)tex == (Object)null)
				{
					Debug.LogError((object)"Texture NULL");
				}
				else
				{
					Sprite sprite = Sprite.Create(tex, new Rect(0f, 0f, (float)((Texture)tex).width, (float)((Texture)tex).height), new Vector2(0.5f, 0.5f));
					img.sprite = sprite;
					((Graphic)img).color = Color.white;
					hatSign.transform.position = new Vector3(-6.4f, 5.15f, 122.5f);
					hatSign.transform.rotation = Quaternion.Euler(0f, 0f, 0f);
					hatSign.transform.localScale = new Vector3(0.038f, 0.035f, 0.035f);
					RectTransform component = panelObj.GetComponent<RectTransform>();
					component.sizeDelta = new Vector2(400f, 300f);
					RectTransform component2 = imageObj.GetComponent<RectTransform>();
					float num = 1.1f;
					float num2 = 380f * num;
					float num3 = num2 * ((float)height / (float)width);
					component2.sizeDelta = new Vector2(num2, num3);
				}
			});
		}
	}
	public static class HatUtils
	{
		private static string _lastLocalHatName;

		public static void SetLastLocalHatName(string hatName)
		{
			if (!string.IsNullOrEmpty(hatName))
			{
				_lastLocalHatName = hatName;
			}
		}

		public static bool TryGetHatName(Character ch, out string hatName)
		{
			hatName = null;
			if ((Object)(object)ch == (Object)null)
			{
				return false;
			}
			PersistentPlayerDataService service = GameHandler.GetService<PersistentPlayerDataService>();
			PersistentPlayerData val = null;
			PhotonView photonView = ((MonoBehaviourPun)ch).photonView;
			if (((photonView != null) ? photonView.Owner : null) != null)
			{
				val = ((service != null) ? service.GetPlayerData(((MonoBehaviourPun)ch).photonView.Owner) : null);
			}
			if (val == null && ch.IsLocal && PhotonNetwork.LocalPlayer != null)
			{
				val = ((service != null) ? service.GetPlayerData(PhotonNetwork.LocalPlayer) : null);
			}
			if (val != null)
			{
				CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
				int currentHat = val.customizationData.currentHat;
				if (array != null && currentHat >= 0 && currentHat < array.Length && (Object)(object)array[currentHat] != (Object)null)
				{
					hatName = ((Object)array[currentHat]).name;
				}
			}
			if (string.IsNullOrEmpty(hatName) && ch.IsLocal)
			{
				hatName = _lastLocalHatName;
			}
			return !string.IsNullOrEmpty(hatName);
		}

		public static bool HasAnyHat(Character ch, params string[] names)
		{
			if (!TryGetHatName(ch, out var hatName))
			{
				return false;
			}
			return names.Contains<string>(hatName, StringComparer.OrdinalIgnoreCase);
		}

		public static bool HasHat(Character ch, string expected)
		{
			string hatName;
			return TryGetHatName(ch, out hatName) && string.Equals(hatName, expected, StringComparison.OrdinalIgnoreCase);
		}
	}
	public class ImageLoader : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <LoadCoroutine>d__3 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string path;

			public Action<Texture2D> callback;

			public ImageLoader <>4__this;

			private string <url>5__1;

			private UnityWebRequest <request>5__2;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <LoadCoroutine>d__3(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<url>5__1 = null;
				<request>5__2 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Invalid comparison between Unknown and I4
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<url>5__1 = "file://" + path;
					<request>5__2 = UnityWebRequestTexture.GetTexture(<url>5__1);
					<>2__current = <request>5__2.SendWebRequest();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if ((int)<request>5__2.result != 1)
					{
						Debug.LogError((object)<request>5__2.error);
						callback(null);
					}
					else
					{
						callback(DownloadHandlerTexture.GetContent(<request>5__2));
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		public static ImageLoader Instance;

		private void Awake()
		{
			Instance = this;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
		}

		public void Load(string path, Action<Texture2D> callback)
		{
			((MonoBehaviour)this).StartCoroutine(LoadCoroutine(path, callback));
		}

		[IteratorStateMachine(typeof(<LoadCoroutine>d__3))]
		private IEnumerator LoadCoroutine(string path, Action<Texture2D> callback)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LoadCoroutine>d__3(0)
			{
				<>4__this = this,
				path = path,
				callback = callback
			};
		}
	}
	public static class ItemCache
	{
		private static Dictionary<string, Item> _byName;

		private static float _lastRefreshTime;

		public static Item Get(string name)
		{
			if (_byName == null || Time.time - _lastRefreshTime > 300f)
			{
				_byName = new Dictionary<string, Item>(StringComparer.OrdinalIgnoreCase);
				Item[] array = Resources.FindObjectsOfTypeAll<Item>();
				foreach (Item val in array)
				{
					if ((Object)(object)val != (Object)null && !string.IsNullOrEmpty(((Object)val).name) && !_byName.ContainsKey(((Object)val).name))
					{
						_byName[((Object)val).name] = val;
					}
				}
				_lastRefreshTime = Time.time;
			}
			Item value;
			return _byName.TryGetValue(name, out value) ? value : null;
		}
	}
	internal static class TechPriestBlocker
	{
		private static readonly HashSet<string> BlockedTypeNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "heal", "cure", "medicine", "restorehealth" };

		private static readonly HashSet<string> BlockedItemNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "bandage", "firstaid", "medkit", "cure", "marshmallow" };

		private static Dictionary<int, bool> _blockCache = new Dictionary<int, bool>();

		public static bool ShouldBlockItem(Item item)
		{
			if ((Object)(object)item == (Object)null)
			{
				return false;
			}
			int instanceID = ((Object)item).GetInstanceID();
			if (_blockCache.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			bool flag = false;
			if ((Object)(object)((Component)item).GetComponent<Action_RestoreHunger>() != (Object)null || (Object)(object)((Component)item).GetComponent<Action_GiveExtraStamina>() != (Object)null)
			{
				flag = true;
			}
			if (!flag)
			{
				string text = ((Object)item).name?.Replace("(Clone)", "").Trim() ?? "";
				foreach (string blockedItemName in BlockedItemNames)
				{
					if (text.IndexOf(blockedItemName, StringComparison.OrdinalIgnoreCase) >= 0)
					{
						flag = true;
						break;
					}
				}
			}
			if (!flag)
			{
				MonoBehaviour[] components = ((Component)item).GetComponents<MonoBehaviour>();
				foreach (MonoBehaviour val in components)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					string name = ((object)val).GetType().Name;
					foreach (string blockedTypeName in BlockedTypeNames)
					{
						if (name.IndexOf(blockedTypeName, StringComparison.OrdinalIgnoreCase) >= 0)
						{
							flag = true;
							break;
						}
					}
					if (flag)
					{
						break;
					}
				}
			}
			_blockCache[instanceID] = flag;
			return flag;
		}

		public static void ClearCache()
		{
			_blockCache.Clear();
		}
	}
	internal static class TechPriestItemChecker
	{
		public static bool ShouldBlockUse(Item item)
		{
			if ((Object)(object)item == (Object)null || (Object)(object)item.holderCharacter == (Object)null || !ClassCheckUtil.IsTechPriest(item.holderCharacter))
			{
				return false;
			}
			if (TechPriestBlocker.ShouldBlockItem(item))
			{
				return true;
			}
			Action_ApplyAffliction component = ((Component)item).GetComponent<Action_ApplyAffliction>();
			return component?.affliction != null && ((object)component.affliction).GetType().Name.Contains("FasterBoi");
		}
	}
}
namespace PeakClassMod.Handlers
{
	public class AstronautStatHandler : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <ApplyWindWalkDelayed>d__14 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public AstronautStatHandler <>4__this;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <ApplyWindWalkDelayed>d__14(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				//IL_0030: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (ClassManager.IsAstronautActive() && (Object)(object)<>4__this._character != (Object)null && !<>4__this._character.data.isGrounded)
					{
						<>4__this.TriggerWindWalk();
					}
					return false;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Character _character;

		private CharacterMovement _movement;

		private Traverse _travMove;

		private float _defJump = 400f;

		private float _defSprintMult = 2f;

		private bool _defaultsCaptured = false;

		private bool _isModified = false;

		private Traverse _jumpImpulseField;

		private Traverse _sprintMultiplierField;

		private Traverse _velocityField;

		private bool _fieldsInitialized = false;

		private void Start()
		{
			_character = ((Component)this).GetComponent<Character>();
			_movement = ((Component)this).GetComponent<CharacterMovement>();
			if ((Object)(object)_movement != (Object)null)
			{
				_travMove = Traverse.Create((object)_movement);
				InitializeFields();
			}
		}

		private void InitializeFields()
		{
			if (!_fieldsInitialized && _travMove != null)
			{
				_jumpImpulseField = _travMove.Field("jumpImpulse");
				_sprintMultiplierField = _travMove.Field("sprintMultiplier");
				_velocityField = _travMove.Field("velocity");
				_fieldsInitialized = true;
			}
		}

		private void Update()
		{
			if (!((Object)(object)_character == (Object)null) && _character.IsLocal && ClassManager.IsAstronautActive() && _character.input.jumpWasPressed && _character.data.isGrounded)
			{
				((MonoBehaviour)this).StopAllCoroutines();
				((MonoBehaviour)this).StartCoroutine(ApplyWindWalkDelayed());
			}
		}

		[IteratorStateMachine(typeof(<ApplyWindWalkDelayed>d__14))]
		private IEnumerator ApplyWindWalkDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyWindWalkDelayed>d__14(0)
			{
				<>4__this = this
			};
		}

		private void TriggerWindWalk()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			try
			{
				CharacterRefs refs = _character.refs;
				if (refs != null)
				{
					CharacterAfflictions afflictions = refs.afflictions;
					if (afflictions != null)
					{
						afflictions.AddAffliction((Affliction)new Affliction_LowGravity(3, 3f), true);
					}
				}
			}
			catch
			{
			}
		}

		private void FixedUpdate()
		{
			if ((Object)(object)_character == (Object)null || !_character.IsLocal || !_fieldsInitialized)
			{
				return;
			}
			if (ClassManager.IsAstronautActive())
			{
				if (!_defaultsCaptured && !_isModified)
				{
					CaptureDefaults();
				}
				ApplyAstronautStats();
				_isModified = true;
			}
			else if (_isModified)
			{
				RestoreDefaults();
			}
		}

		private void CaptureDefaults()
		{
			Traverse jumpImpulseField = _jumpImpulseField;
			float? num = ((jumpImpulseField != null) ? new float?(jumpImpulseField.GetValue<float>()) : null);
			if (num.HasValue && num.Value > 0f)
			{
				_defJump = num.Value;
			}
			Traverse sprintMultiplierField = _sprintMultiplierField;
			float? num2 = ((sprintMultiplierField != null) ? new float?(sprintMultiplierField.GetValue<float>()) : null);
			if (num2.HasValue)
			{
				_defSprintMult = num2.Value;
			}
			_defaultsCaptured = true;
		}

		private void ApplyAstronautStats()
		{
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: 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_015a: Unknown result type (might be due to invalid IL or missing references)
			Traverse jumpImpulseField = _jumpImpulseField;
			if (jumpImpulseField != null)
			{
				jumpImpulseField.SetValue((object)1200f);
			}
			Traverse sprintMultiplierField = _sprintMultiplierField;
			if (sprintMultiplierField != null)
			{
				sprintMultiplierField.SetValue((object)1.7f);
			}
			if (_character.data.isGrounded)
			{
				List<Affliction> list = _character.refs?.afflictions?.afflictionList;
				if (list != null)
				{
					for (int num = list.Count - 1; num >= 0; num--)
					{
						if (list[num] is Affliction_LowGravity)
						{
							_character.refs.afflictions.RemoveAffliction(list[num], false, true);
						}
					}
				}
			}
			if (!_character.data.isSprinting && _velocityField != null)
			{
				Vector3 value = _velocityField.GetValue<Vector3>();
				Vector3 val = default(Vector3);
				((Vector3)(ref val))..ctor(value.x, 0f, value.z);
				if (((Vector3)(ref val)).magnitude > 1.6f)
				{
					Vector3 val2 = ((Vector3)(ref val)).normalized * 1.6f;
					_velocityField.SetValue((object)new Vector3(val2.x, value.y, val2.z));
				}
			}
		}

		private void RestoreDefaults()
		{
			Traverse jumpImpulseField = _jumpImpulseField;
			if (jumpImpulseField != null)
			{
				jumpImpulseField.SetValue((object)_defJump);
			}
			Traverse sprintMultiplierField = _sprintMultiplierField;
			if (sprintMultiplierField != null)
			{
				sprintMultiplierField.SetValue((object)_defSprintMult);
			}
			_isModified = false;
			_defaultsCaptured = false;
		}
	}
	public class ClassModNetwork : MonoBehaviourPun
	{
		[CompilerGenerated]
		private sealed class <HostGiveItemsRoutine>d__11 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public string hatName;

			public Player requestor;

			public ClassModNetwork <>4__this;

			private List<string> <itemsToGive>5__1;

			private Character <targetChar>5__2;

			private int <actorNumber>5__3;

			private Character <cachedChar>5__4;

			private List<Character>.Enumerator <>s__5;

			private Character <ch>5__6;

			private List<string>.Enumerator <>s__7;

			private string <itemName>5__8;

			private Item <item>5__9;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <HostGiveItemsRoutine>d__11(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || num == 1)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<itemsToGive>5__1 = null;
				<targetChar>5__2 = null;
				<cachedChar>5__4 = null;
				<>s__5 = default(List<Character>.Enumerator);
				<ch>5__6 = null;
				<>s__7 = default(List<string>.Enumerator);
				<itemName>5__8 = null;
				<item>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0220: Unknown result type (might be due to invalid IL or missing references)
				//IL_022a: Expected O, but got Unknown
				try
				{
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						<itemsToGive>5__1 = PeakClassModPlugin.BuildStartItemsByHatName(hatName);
						if (<itemsToGive>5__1.Count == 0)
						{
							return false;
						}
						<targetChar>5__2 = null;
						<actorNumber>5__3 = requestor.ActorNumber;
						if (_characterCache.TryGetValue(<actorNumber>5__3, out <cachedChar>5__4) && (Object)(object)<cachedChar>5__4 != (Object)null)
						{
							<targetChar>5__2 = <cachedChar>5__4;
						}
						else
						{
							<>s__5 = Character.AllCharacters.GetEnumerator();
							try
							{
								while (<>s__5.MoveNext())
								{
									<ch>5__6 = <>s__5.Current;
									Character obj = <ch>5__6;
									object obj2;
									if (obj == null)
									{
										obj2 = null;
									}
									else
									{
										PhotonView photonView = ((MonoBehaviourPun)obj).photonView;
										obj2 = ((photonView != null) ? photonView.Owner : null);
									}
									if (obj2 == requestor)
									{
										<targetChar>5__2 = <ch>5__6;
										_characterCache[<actorNumber>5__3] = <ch>5__6;
										break;
									}
									<ch>5__6 = null;
								}
							}
							finally
							{
								((IDisposable)<>s__5).Dispose();
							}
							<>s__5 = default(List<Character>.Enumerator);
						}
						Character obj3 = <targetChar>5__2;
						if ((Object)(object)((obj3 != null) ? obj3.player : null) == (Object)null)
						{
							return false;
						}
						HasReceivedStartItems.Add(<actorNumber>5__3);
						<>s__7 = <itemsToGive>5__1.GetEnumerator();
						<>1__state = -3;
						break;
					}
					case 1:
						<>1__state = -3;
						<item>5__9 = null;
						<itemName>5__8 = null;
						break;
					}
					if (<>s__7.MoveNext())
					{
						<itemName>5__8 = <>s__7.Current;
						<item>5__9 = ItemCache.Get(<itemName>5__8);
						if ((Object)(object)<item>5__9 != (Object)null && <targetChar>5__2.player.HasEmptySlot(<item>5__9.itemID))
						{
							ItemSlot val = default(ItemSlot);
							<targetChar>5__2.player.AddItem(<item>5__9.itemID, (ItemInstanceData)null, ref val);
						}
						<>2__current = (object)new WaitForSeconds(0.02f);
						<>1__state = 1;
						return true;
					}
					<>m__Finally1();
					<>s__7 = default(List<string>.Enumerator);
					return false;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>s__7).Dispose();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		[CompilerGenerated]
		private sealed class <RequestItemsRoutine>d__9 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public ClassModNetwork <>4__this;

			private float <timeout>5__1;

			private bool <inventoryReady>5__2;

			private string <myHatName>5__3;

			private string <d>5__4;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <RequestItemsRoutine>d__9(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<myHatName>5__3 = null;
				<d>5__4 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0044: Expected O, but got Unknown
				//IL_0141: Unknown result type (might be due to invalid IL or missing references)
				//IL_014b: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.3f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					goto IL_006d;
				case 2:
					<>1__state = -1;
					goto IL_006d;
				case 3:
					{
						<>1__state = -1;
						break;
					}
					IL_006d:
					if (!PhotonNetwork.InRoom)
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					if ((Object)(object)<>4__this._character == (Object)null)
					{
						<>4__this._character = ((Component)<>4__this).GetComponent<Character>();
					}
					<timeout>5__1 = 5f;
					<inventoryReady>5__2 = false;
					break;
				}
				if (<timeout>5__1 > 0f)
				{
					Character character = <>4__this._character;
					if (((character == null) ? null : character.player?.itemSlots) == null || <>4__this._character.player.itemSlots.Length == 0 || <>4__this._character.player.itemSlots[0].IsEmpty())
					{
						<timeout>5__1 -= 0.1f;
						<>2__current = (object)new WaitForSeconds(0.1f);
						<>1__state = 3;
						return true;
					}
					<inventoryReady>5__2 = true;
				}
				<myHatName>5__3 = "None";
				if (HatUtils.TryGetHatName(<>4__this._character, out <d>5__4))
				{
					<myHatName>5__3 = <d>5__4;
				}
				if (<inventoryReady>5__2 || <timeout>5__1 <= 0f)
				{
					((MonoBehaviourPun)<>4__this).photonView.RPC("RPC_HostGiveItems", (RpcTarget)2, new object[1] { <myHatName>5__3 });
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private Character _character;

		private bool _hasRequestedItems = false;

		private static Dictionary<int, float> _hostGiveCooldown = new Dictionary<int, float>();

		private static Dictionary<int, Character> _characterCache = new Dictionary<int, Character>();

		public static HashSet<int> HasReceivedStartItems = new HashSet<int>();

		private void Awake()
		{
			ClassModNetwork[] components = ((Component)this).GetComponents<ClassModNetwork>();
			if (components.Length > 1)
			{
				Object.Destroy((Object)(object)this);
			}
			else
			{
				_character = ((Component)this).GetComponent<Character>();
			}
		}

		private void Start()
		{
			if ((Object)(object)((MonoBehaviourPun)this).photonView != (Object)null && ((MonoBehaviourPun)this).photonView.IsMine && !_hasRequestedItems)
			{
				_hasRequestedItems = true;
				((MonoBehaviour)this).StartCoroutine(RequestItemsRoutine());
			}
		}

		private void OnDestroy()
		{
			Character character = _character;
			object obj;
			if (character == null)
			{
				obj = null;
			}
			else
			{
				PhotonView photonView = ((MonoBehaviourPun)character).photonView;
				obj = ((photonView != null) ? photonView.Owner : null);
			}
			if (obj != null)
			{
				_characterCache.Remove(((MonoBehaviourPun)_character).photonView.Owner.ActorNumber);
			}
		}

		public static void ClearPlayerCache(int actorNumber)
		{
			_characterCache.Remove(actorNumber);
			_hostGiveCooldown.Remove(actorNumber);
			HasReceivedStartItems.Remove(actorNumber);
		}

		[IteratorStateMachine(typeof(<RequestItemsRoutine>d__9))]
		private IEnumerator RequestItemsRoutine()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <RequestItemsRoutine>d__9(0)
			{
				<>4__this = this
			};
		}

		[PunRPC]
		public void RPC_HostGiveItems(string clientHatName, PhotonMessageInfo info)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (PhotonNetwork.IsMasterClient)
			{
				int actorNumber = info.Sender.ActorNumber;
				if (!HasReceivedStartItems.Contains(actorNumber) && (!_hostGiveCooldown.TryGetValue(actorNumber, out var value) || !(Time.time - value < 2f)))
				{
					_hostGiveCooldown[actorNumber] = Time.time;
					((MonoBehaviour)this).StartCoroutine(HostGiveItemsRoutine(clientHatName, info.Sender));
				}
			}
		}

		[IteratorStateMachine(typeof(<HostGiveItemsRoutine>d__11))]
		private IEnumerator HostGiveItemsRoutine(string hatName, Player requestor)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <HostGiveItemsRoutine>d__11(0)
			{
				<>4__this = this,
				hatName = hatName,
				requestor = requestor
			};
		}

		[PunRPC]
		public void RPC_ApplyWolfHeal(float amount)
		{
			if ((Object)(object)_character == (Object)null)
			{
				_character = ((Component)this).GetComponent<Character>();
			}
			CharacterAfflictions val = _character?.refs?.afflictions;
			if (!((Object)(object)val == (Object)null))
			{
				val.SubtractStatus((STATUSTYPE)0, amount, false, false);
			}
		}

		[PunRPC]
		public void RPC_ApplyWolfDamage(float amount)
		{
			if ((Object)(object)_character == (Object)null)
			{
				_character = ((Component)this).GetComponent<Character>();
			}
			CharacterAfflictions val = _character?.refs?.afflictions;
			if (!((Object)(object)val == (Object)null))
			{
				val.AddStatus((STATUSTYPE)0, amount, false, true, true);
			}
		}

		[PunRPC]
		public void ShowMedicHealEffectRPC(int remainingHeals)
		{
			ManualLogSource log = PeakClassModPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[ClassMod] Medic heal: {remainingHeals}");
			}
		}

		[PunRPC]
		public void RPC_SyncClassActivation(string className, int actorNumber)
		{
			ManualLogSource log = PeakClassModPlugin.Log;
			if (log != null)
			{
				log.LogInfo((object)$"[ClassMod] Player {actorNumber} class: {className}");
			}
		}
	}
	public class GobelinSizeHandler : MonoBehaviour
	{
		private Character _character;

		private float _lastCheckTime = 0f;

		private void Start()
		{
			_character = ((Component)this).GetComponent<Character>();
		}

		private void Update()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			if (Time.time - _lastCheckTime < 0.2f)
			{
				return;
			}
			_lastCheckTime = Time.time;
			if (!((Object)(object)_character == (Object)null))
			{
				bool flag = false;
				flag = ((!_character.IsLocal) ? ClassCheckUtil.IsGobelin(_character) : ClassManager.IsGobelinActive());
				float x = ((Component)_character).transform.localScale.x;
				float num = (flag ? 0.5f : 1f);
				if (Mathf.Abs(x - num) > 0.05f)
				{
					((Component)_character).transform.localScale = Vector3.one * num;
				}
			}
		}
	}
	public class MedicStatHandler : MonoBehaviour
	{
		private Character _character;

		private ClassModNetwork _network;

		private CharacterAfflictions _afflictions;

		private int _healsRemaining = 10;

		private float _lastHealTime = 0f;

		private void Start()
		{
			_character = ((Component)this).GetComponent<Character>();
			_network = ((Component)this).GetComponent<ClassModNetwork>();
			if (_character?.refs != null)
			{
				_afflictions = _character.refs.afflictions;
			}
		}

		private void Update()
		{
			if ((Object)(object)_character == (Object)null || !_character.IsLocal)
			{
				return;
			}
			if (ClassManager.IsMedicActive())
			{
				if (Input.GetKeyDown((KeyCode)104) && Time.time - _lastHealTime > 1f)
				{
					TrySelfHeal();
				}
			}
			else if (_healsRemaining < 10)
			{
				_healsRemaining = 10;
			}
		}

		private void TrySelfHeal()
		{
			if (_healsRemaining <= 0)
			{
				return;
			}
			if ((Object)(object)_afflictions == (Object)null && _character?.refs != null)
			{
				_afflictions = _character.refs.afflictions;
			}
			if ((Object)(object)_afflictions != (Object)null && _afflictions.GetCurrentStatus((STATUSTYPE)0) > 0f)
			{
				_healsRemaining--;
				_lastHealTime = Time.time;
				_afflictions.SubtractStatus((STATUSTYPE)0, 0.1f, false, false);
				ClassModNetwork network = _network;
				if ((Object)(object)((network != null) ? ((MonoBehaviourPun)network).photonView : null) != (Object)null)
				{
					((MonoBehaviourPun)_network).photonView.RPC("ShowMedicHealEffectRPC", (RpcTarget)0, new object[1] { _healsRemaining });
				}
			}
		}
	}
	public class PeakClassModCallbacks : MonoBehaviourPunCallbacks
	{
		public override void OnPlayerLeftRoom(Player otherPlayer)
		{
			ClassModNetwork.ClearPlayerCache(otherPlayer.ActorNumber);
		}
	}
	public class WolfHandler : MonoBehaviour
	{
		private static WolfHandler _localInstance;

		private Character _character;

		private ClassModNetwork _network;

		private CharacterClimbing _characterClimbing;

		private CharacterMovement _characterMovement;

		private Transform _followTarget;

		private float _baseClimbSpeed;

		private float _baseSprintSpeed;

		private float _nextEffectTime = 0f;

		private CharacterController _cc;

		private TextMeshProUGUI _timeTextComponent;

		private Dictionary<Character, float> _lastHitTime = new Dictionary<Character, float>();

		private const float EFFECT_RADIUS = 10f;

		private const float CIRCLE_PULSE_SPEED = 3f;

		private const float CIRCLE_PULSE_AMPLITUDE = 0.3f;

		private const float CIRCLE_BASE_WIDTH = 0.3f;

		private GameObject _effectAnchor;

		private LineRenderer _circleRenderer;

		private void Start()
		{
			_character = ((Component)this).GetComponent<Character>();
			_followTarget = ((Component)_character).transform.Find("animationPosition");
			if ((Object)(object)_followTarget == (Object)null)
			{
				_followTarget = ((Component)_character).transform.Find("Scout");
			}
			if ((Object)(object)_followTarget == (Object)null)
			{
				_followTarget = ((Component)_character).transform.Find("MainMesh");
			}
			if ((Object)(object)_followTarget == (Object)null)
			{
				_followTarget = ((Component)_character).transform;
			}
			if (ClassCheckUtil.IsWolf(_character) && _character.IsLocal)
			{
				_cc = ((Component)this).GetComponent<CharacterController>();
				if ((Object)(object)_localInstance != (Object)null && (Object)(object)_localInstance != (Object)(object)this)
				{
					Object.Destroy((Object)(object)this);
					return;
				}
				_localInstance = this;
				CreateUI();
				CreateEffectAnchor();
				CreateVisibleCircle();
				_network = ((Component)this).GetComponent<ClassModNetwork>();
				_characterClimbing = ((Component)this).GetComponent<CharacterClimbing>();
				_characterMovement = ((Component)this).GetComponent<CharacterMovement>();
				_baseSprintSpeed = _characterMovement.sprintMultiplier;
				_baseClimbSpeed = _characterClimbing.climbSpeed;
			}
		}

		private void Update()
		{
			//IL_01b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_character == (Object)null || !_character.IsLocal || !ClassCheckUtil.IsWolf(_character))
			{
				return;
			}
			float num = 1f + Mathf.Sin(Time.time * 3f) * 0.3f;
			float widthMultiplier = 0.3f * num;
			_circleRenderer.widthMultiplier = widthMultiplier;
			DaySegmentUtils daySegmentUtils = new DaySegmentUtils();
			if (_character.IsGhost)
			{
				if (daySegmentUtils.IsDay())
				{
					((TMP_Text)_timeTextComponent).text = "Day";
				}
				else
				{
					((TMP_Text)_timeTextComponent).text = "Night";
				}
				if ((Object)(object)_circleRenderer != (Object)null)
				{
					((Renderer)_circleRenderer).enabled = false;
				}
				return;
			}
			if ((Object)(object)_circleRenderer != (Object)null)
			{
				((Renderer)_circleRenderer).enabled = true;
			}
			if (Time.time >= _nextEffectTime)
			{
				_nextEffectTime = Time.time + 1f;
				if (daySegmentUtils.IsDay())
				{
					((TMP_Text)_timeTextComponent).text = "Day";
					HealFriends();
					_circleRenderer.startColor = Color.green;
					_circleRenderer.endColor = Color.green;
					_characterClimbing.climbSpeed = _baseClimbSpeed * 1.3f;
					_characterMovement.sprintMultiplier = _baseSprintSpeed;
				}
				else
				{
					((TMP_Text)_timeTextComponent).text = "Night";
					DamageFriends();
					_circleRenderer.startColor = Color.red;
					_circleRenderer.endColor = Color.red;
					_characterClimbing.climbSpeed = _baseClimbSpeed;
					_characterMovement.sprintMultiplier = _baseSprintSpeed * 1.3f;
				}
			}
		}

		private void LateUpdate()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_effectAnchor == (Object)null))
			{
				Vector3 playerRealPosition = GetPlayerRealPosition();
				_effectAnchor.transform.position = playerRealPosition;
				if ((Object)(object)_circleRenderer != (Object)null)
				{
					((Component)_circleRenderer).transform.position = playerRealPosition + Vector3.up * 0.05f;
				}
			}
		}

		private void OnDestroy()
		{
			if ((Object)(object)_localInstance == (Object)(object)this)
			{
				_localInstance = null;
			}
		}

		private void CreateEffectAnchor()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			_effectAnchor = new GameObject("WolfEffectAnchor");
			_effectAnchor.transform.position = GetPlayerRealPosition();
		}

		private void UpdateEffectAnchor()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_effectAnchor == (Object)null))
			{
				Vector3 playerRealPosition = GetPlayerRealPosition();
				_effectAnchor.transform.position = playerRealPosition + new Vector3(0f, 0.1f, 0f);
			}
		}

		private Vector3 GetPlayerRealPosition()
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)Camera.main != (Object)null)
			{
				Vector3 position = ((Component)Camera.main).transform.position;
				return new Vector3(position.x, position.y - 2f, position.z);
			}
			return Vector3.zero;
		}

		private Vector3 GetEffectCenterPosition()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: 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_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_effectAnchor != (Object)null)
			{
				return _effectAnchor.transform.position;
			}
			return GetPlayerRealPosition();
		}

		public void HealFriends()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!_character.refs.view.IsMine)
			{
				return;
			}
			Collider[] array = Physics.OverlapSphere(GetEffectCenterPosition(), 10f);
			HashSet<Character> hashSet = new HashSet<Character>();
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				Character componentInParent = ((Component)val).GetComponentInParent<Character>();
				if ((Object)(object)componentInParent == (Object)null || (Object)(object)componentInParent == (Object)(object)_character || hashSet.Contains(componentInParent))
				{
					continue;
				}
				hashSet.Add(componentInParent);
				float time = Time.time;
				if (_lastHitTime.ContainsKey(componentInParent) && time - _lastHitTime[componentInParent] < 1f)
				{
					continue;
				}
				_lastHitTime[componentInParent] = time;
				ClassModNetwork component = ((Component)componentInParent).GetComponent<ClassModNetwork>();
				if ((Object)(object)component != (Object)null && (Object)(object)((MonoBehaviourPun)component).photonView != (Object)null && (Object)(object)((MonoBehaviourPun)componentInParent).photonView != (Object)null && ((MonoBehaviourPun)componentInParent).photonView.Owner != null)
				{
					((MonoBehaviourPun)component).photonView.RPC("RPC_ApplyWolfHeal", ((MonoBehaviourPun)componentInParent).photonView.Owner, new object[1] { 0.025f });
					continue;
				}
				CharacterRefs refs = componentInParent.refs;
				if (refs != null)
				{
					CharacterAfflictions afflictions = refs.afflictions;
					if (afflictions != null)
					{
						afflictions.SubtractStatus((STATUSTYPE)0, 0.025f, false, false);
					}
				}
			}
		}

		public void DamageFriends()
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!_character.refs.view.IsMine)
			{
				return;
			}
			Collider[] array = Physics.OverlapSphere(GetEffectCenterPosition(), 10f);
			HashSet<Character> hashSet = new HashSet<Character>();
			Collider[] array2 = array;
			foreach (Collider val in array2)
			{
				Character componentInParent = ((Component)val).GetComponentInParent<Character>();
				if ((Object)(object)componentInParent == (Object)null || (Object)(object)componentInParent == (Object)(object)_character || hashSet.Contains(componentInParent))
				{
					continue;
				}
				hashSet.Add(componentInParent);
				float time = Time.time;
				if (_lastHitTime.ContainsKey(componentInParent) && time - _lastHitTime[componentInParent] < 1f)
				{
					continue;
				}
				_lastHitTime[componentInParent] = time;
				ClassModNetwork component = ((Component)componentInParent).GetComponent<ClassModNetwork>();
				if ((Object)(object)component != (Object)null && (Object)(object)((MonoBehaviourPun)component).photonView != (Object)null && (Object)(object)((MonoBehaviourPun)componentInParent).photonView != (Object)null && ((MonoBehaviourPun)componentInParent).photonView.Owner != null)
				{
					((MonoBehaviourPun)component).photonView.RPC("RPC_ApplyWolfDamage", ((MonoBehaviourPun)componentInParent).photonView.Owner, new object[1] { 0.05f });
					continue;
				}
				CharacterRefs refs = componentInParent.refs;
				if (refs != null)
				{
					CharacterAfflictions afflictions = refs.afflictions;
					if (afflictions != null)
					{
						afflictions.AddStatus((STATUSTYPE)0, 0.05f, false, true, true);
					}
				}
			}
		}

		private void CreateVisibleCircle()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			GameObject val = new GameObject("WolfRangeCircle");
			_circleRenderer = val.AddComponent<LineRenderer>();
			_circleRenderer.useWorldSpace = false;
			_circleRenderer.loop = true;
			_circleRenderer.positionCount = 100;
			_circleRenderer.startWidth = 0.3f;
			_circleRenderer.endWidth = 0.3f;
			((Renderer)_circleRenderer).material = new Material(Shader.Find("Sprites/Default"));
			((Renderer)_circleRenderer).shadowCastingMode = (ShadowCastingMode)0;
			((Renderer)_circleRenderer).receiveShadows = false;
			DrawCircle(10f);
		}

		private void DrawCircle(float radius)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			int num = 100;
			for (int i = 0; i < num; i++)
			{
				float num2 = (float)i / (float)num * (float)Math.PI * 2f;
				float num3 = Mathf.Cos(num2) * radius;
				float num4 = Mathf.Sin(num2) * radius;
				_circleRenderer.SetPosition(i, new Vector3(num3, 0f, num4));
			}
		}

		private void CreateUI()
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = GameObject.Find("GAME/GUIManager/Canvas_HUD");
			TMP_FontAsset font = null;
			TextMeshProUGUI[] array = Object.FindObjectsOfType<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val2 in array)
			{
				if ((Object)(object)((TMP_Text)val2).font != (Object)null && ((Object)((TMP_Text)val2).font).name == "DarumaDropOne-Regular SDF")
				{
					font = ((TMP_Text)val2).font;
					break;
				}
			}
			GameObject val3 = new GameObject("TimeText");
			val3.transform.SetParent(val.transform, false);
			_timeTextComponent = val3.AddComponent<TextMeshProUGUI>();
			RectTransform component = val3.GetComponent<RectTransform>();
			component.anchoredPosition = new Vector2(930f, 500f);
			((TMP_Text)_timeTextComponent).fontSize = 40f;
			((Graphic)_timeTextComponent).color = Color.white;
			((TMP_Text)_timeTextComponent).font = font;
		}
	}
	public class TechPriestWeightEnforcer : MonoBehaviour
	{
		private Character _character;

		private CharacterAfflictions _afflictions;

		private bool _isActive;

		private int _weightIndex;

		private float _lastCheck = 0f;

		private void Start()
		{
			_character = ((Component)this).GetComponent<Character>();
			_weightIndex = 7;
			RefreshState();
		}

		private void RefreshState()
		{
			_isActive = (Object)(object)_character != (Object)null && ClassCheckUtil.IsTechPriest(_character);
			if (_isActive)
			{
				_afflictions = _character.refs.afflictions;
			}
		}

		private void LateUpdate()
		{
			if (!_isActive || !ClassManager.IsTechPriestActive())
			{
				if (Time.time - _lastCheck > 2f)
				{
					_lastCheck = Time.time;
					RefreshState();
				}
			}
			else if ((Object)(object)_afflictions != (Object)null && _afflictions.currentStatuses[_weightIndex] > 0f)
			{
				_afflictions.currentStatuses[_weightIndex] = 0f;
			}
		}
	}
}
namespace PeakClassMod.Patches
{
	[HarmonyPatch(typeof(Item), "Interact")]
	public class GobelinUniqueWeaponPatch
	{
		private static bool Prefix(Item __instance, Character interactor)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)interactor == (Object)null || !interactor.IsLocal)
			{
				return true;
			}
			if (ClassCheckUtil.IsGobelin(interactor) && ((Object)__instance).name.IndexOf("HealingDart Variant", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				Item[] array = Resources.FindObjectsOfTypeAll<Item>();
				foreach (Item val in array)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)val.holderCharacter == (Object)(object)interactor && (Object)(object)val != (Object)(object)__instance && ((Object)val).name.IndexOf("HealingDart Variant", StringComparison.OrdinalIgnoreCase) >= 0)
					{
						ManualLogSource log = PeakClassModPlugin.Log;
						if (log != null)
						{
							log.LogInfo((object)"[Gobelin] Blocked picking up an extra Blowgun.");
						}
						return false;
					}
				}
			}
			return true;
		}
	}
	[HarmonyPatch]
	public class GobelinSoulboundPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			List<MethodBase> list = new List<MethodBase>();
			MethodInfo methodInfo = AccessTools.Method(typeof(CharacterSpawner), "PushReconnectData", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				list.Add(methodInfo);
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Character), "ApplyPostReviveStatus", (Type[])null, (Type[])null);
			if (methodInfo2 != null)
			{
				list.Add(methodInfo2);
			}
			MethodInfo methodInfo3 = AccessTools.Method(typeof(Character), "CallWakeUp", (Type[])null, (Type[])null);
			if (methodInfo3 != null)
			{
				list.Add(methodInfo3);
			}
			MethodInfo methodInfo4 = AccessTools.Method(typeof(Character), "WakeUp", (Type[])null, (Type[])null);
			if (methodInfo4 != null)
			{
				list.Add(methodInfo4);
			}
			MethodInfo methodInfo5 = AccessTools.Method(typeof(Character), "CallRevive", (Type[])null, (Type[])null);
			if (methodInfo5 != null)
			{
				list.Add(methodInfo5);
			}
			MethodInfo methodInfo6 = AccessTools.Method(typeof(Character), "SetDead", (Type[])null, (Type[])null);
			if (methodInfo6 != null)
			{
				list.Add(methodInfo6);
			}
			return list;
		}

		private static void Postfix(Character __instance)
		{
			Character val = __instance ?? Character.localCharacter;
			if (!((Object)(object)val == (Object)null) && val.IsLocal && (!((Object)(object)val.data != (Object)null) || !val.data.dead) && ClassCheckUtil.IsGobelin(val))
			{
				EnsureBlowpipe(val);
			}
		}

		private static void EnsureBlowpipe(Character character)
		{
			if ((Object)(object)character == (Object)null || (Object)(object)character.player == (Object)null || character.player.itemSlots == null)
			{
				return;
			}
			bool flag = false;
			Item[] array = Resources.FindObjectsOfTypeAll<Item>();
			foreach (Item val in array)
			{
				if ((Object)(object)val != (Object)null && (Object)(object)val.holderCharacter == (Object)(object)character && ((Object)val).name.IndexOf("HealingDart Variant", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					flag = true;
					break;
				}
			}
			if (flag)
			{
				return;
			}
			Item val2 = ItemCache.Get("HealingDart Variant");
			if (!((Object)(object)val2 != (Object)null))
			{
				return;
			}
			ushort itemID = val2.itemID;
			if (character.player.HasEmptySlot(itemID))
			{
				ItemSlot val3 = default(ItemSlot);
				character.player.AddItem(itemID, (ItemInstanceData)null, ref val3);
				ManualLogSource log = PeakClassModPlugin.Log;
				if (log != null)
				{
					log.LogInfo((object)"[Gobelin] Restored Blowpipe on Revive/WakeUp");
				}
			}
		}
	}
	[HarmonyPatch]
	public class MushroomancerVFXPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			List<MethodBase> list = new List<MethodBase>();
			MethodInfo methodInfo = AccessTools.Method(typeof(ScreenVFX), "Play", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				list.Add(methodInfo);
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ScreenVFX), "StartFX", (Type[])null, (Type[])null);
			if (methodInfo2 != null)
			{
				list.Add(methodInfo2);
			}
			return list;
		}

		private static bool Prefix()
		{
			if (ClassManager.IsMushroomancerActive() || ClassManager.IsGobelinActive())
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(BarAffliction), "ChangeAffliction")]
	public class BarAffliction_Patch
	{
		private static void Postfix(BarAffliction __instance)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			if ((Object)(object)Character.localCharacter == (Object)null || (int)__instance.afflictionType != 7)
			{
				return;
			}
			if (ClassManager.IsScoutActive())
			{
				__instance.size *= 0.5f;
			}
			else if (ClassManager.IsGeneralActive())
			{
				__instance.size *= 2f;
			}
			else if (ClassManager.IsTechPriestActive() && ClassCheckUtil.IsTechPriest(Character.localCharacter))
			{
				__instance.size = 0f;
				Image component = ((Component)__instance).GetComponent<Image>();
				if ((Object)(object)component != (Object)null)
				{
					((Behaviour)component).enabled = false;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Character), "Start")]
	public class Character_Start_AddNetComp_Patch
	{
		private static void Postfix(Character __instance)
		{
			if ((Object)(object)__instance != (Object)null)
			{
				PeakClassModPlugin instance = PeakClassModPlugin.Instance;
				instance.EnsureComponent<ClassModNetwork>(((Component)__instance).gameObject);
				instance.EnsureComponent<AstronautStatHandler>(((Component)__instance).gameObject);
				instance.EnsureComponent<MedicStatHandler>(((Component)__instance).gameObject);
				instance.EnsureComponent<TechPriestWeightEnforcer>(((Component)__instance).gameObject);
				instance.EnsureComponent<GobelinSizeHandler>(((Component)__instance).gameObject);
				instance.EnsureComponent<WolfHandler>(((Component)__instance).gameObject);
			}
		}
	}
	[HarmonyPatch(typeof(Character), "UseStamina")]
	public class Character_UseStamina_Patch
	{
		private static void Prefix(Character __instance, ref float usage)
		{
			if (!((Object)(object)__instance == (Object)null) && __instance.IsLocal)
			{
				if (ClassManager.IsScoutActive())
				{
					usage *= 0.8f;
				}
				else if (ClassManager.IsRogueActive())
				{
					usage *= 1.7f;
				}
			}
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
	public class General_AddStatus_Patch
	{
		private static bool Prefix(CharacterAfflictions __instance, STATUSTYPE statusType, ref float amount)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Invalid comparison between Unknown and I4
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Invalid comparison between Unknown and I4
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Invalid comparison between Unknown and I4
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Invalid comparison between Unknown and I4
			Character val = __instance?.character;
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			DaySegmentUtils daySegmentUtils = new DaySegmentUtils();
			if (val.IsLocal && (int)statusType == 1)
			{
				if (ClassManager.IsAstronautActive())
				{
					amount *= 1.3f;
				}
				else if (ClassManager.IsScoutActive())
				{
					amount *= 1.7f;
				}
				else if (ClassManager.IsWolfActive() && !daySegmentUtils.IsDay())
				{
					amount *= 1.3f;
				}
				else if (ClassManager.IsTechPriestActive())
				{
					amount *= 1.5f;
				}
				else if (ClassManager.IsGeneralActive())
				{
					amount *= 2f;
				}
			}
			if (ClassCheckUtil.IsGobelin(val) && (int)statusType == 10)
			{
				amount = 0f;
				return false;
			}
			if (ClassCheckUtil.IsTechPriest(val) && ClassManager.IsTechPriestActive())
			{
				if ((int)statusType == 1)
				{
					amount *= 1.5f;
				}
				else if ((int)statusType == 7)
				{
					amount = 0f;
					return false;
				}
			}
			if ((int)statusType == 3 && ClassCheckUtil.IsMushroom(val))
			{
				amount = 0f;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Item), "StartUseSecondary")]
	public class GobelinAntiFeedPatch
	{
		private static bool Prefix(Item __instance)
		{
			if ((Object)(object)__instance == (Object)null)
			{
				return true;
			}
			if ((Object)(object)((Component)__instance).GetComponent<Action_RestoreHunger>() != (Object)null && GobelinDiet.IsPackagedFood(__instance))
			{
				Interaction instance = Interaction.instance;
				if ((Object)(object)instance == (Object)null)
				{
					return true;
				}
				MonoBehaviour value = Traverse.Create((object)instance).Field("bestCharacter").GetValue<MonoBehaviour>();
				if ((Object)(object)value != (Object)null)
				{
					Character value2 = Traverse.Create((object)value).Field("character").GetValue<Character>();
					if ((Object)(object)value2 != (Object)null && ClassCheckUtil.IsGobelin(value2))
					{
						return false;
					}
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Item), "Update")]
	public class GobelinBlowgunEnforcer
	{
		private static void Postfix(Item __instance)
		{
			if ((Object)(object)__instance == (Object)null || ((Object)__instance).name.IndexOf("HealingDart Variant", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return;
			}
			Character holderCharacter = __instance.holderCharacter;
			if ((Object)(object)holderCharacter != (Object)null && ClassCheckUtil.IsGobelin(holderCharacter))
			{
				if (holderCharacter.IsLocal)
				{
					Traverse val = Traverse.Create((object)__instance);
					Traverse val2 = val.Field("destroyOnUse");
					if (val2.FieldExists() && val2.GetValue<bool>())
					{
						val2.SetValue((object)false);
					}
					try
					{
						if (__instance.data != null && __instance.HasData((DataEntryKey)2))
						{
							OptionableIntItemData data = __instance.GetData<OptionableIntItemData>((DataEntryKey)2);
							if (data != null && data.Value != -1)
							{
								data.Value = -1;
							}
						}
					}
					catch
					{
					}
				}
				if (__instance.UIData != null)
				{
					__instance.UIData.canDrop = false;
					__instance.UIData.canBackpack = false;
					__instance.UIData.canThrow = false;
					__instance.UIData.canPocket = true;
				}
				return;
			}
			if (__instance.UIData != null)
			{
				__instance.UIData.canDrop = true;
				__instance.UIData.canBackpack = true;
				__instance.UIData.canThrow = true;
				__instance.UIData.canPocket = true;
			}
			Traverse val3 = Traverse.Create((object)__instance);
			Traverse val4 = val3.Field("destroyOnUse");
			if (val4.FieldExists())
			{
				val4.SetValue((object)true);
			}
			try
			{
				if (__instance.data != null && __instance.HasData((DataEntryKey)2))
				{
					OptionableIntItemData data2 = __instance.GetData<OptionableIntItemData>((DataEntryKey)2);
					if (data2 != null && data2.Value == -1)
					{
						data2.Value = 1;
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch(typeof(Item), "FinishCastPrimary")]
	public class GobelinCurseOnShootPatch
	{
		private static void Postfix(Item __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.holderCharacter == (Object)null || !__instance.holderCharacter.IsLocal || !ClassCheckUtil.IsGobelin(__instance.holderCharacter) || ((Object)__instance).name.IndexOf("HealingDart Variant", StringComparison.OrdinalIgnoreCase) < 0)
			{
				return;
			}
			CharacterRefs refs = __instance.holderCharacter.refs;
			if (refs != null)
			{
				CharacterAfflictions afflictions = refs.afflictions;
				if (afflictions != null)
				{
					afflictions.AddStatus((STATUSTYPE)5, 0.05f, false, true, true);
				}
			}
		}
	}
	[HarmonyPatch(typeof(Item), "StartUsePrimary")]
	[HarmonyPriority(600)]
	public class GobelinFoodBlockerPrimary
	{
		private static bool Prefix(Item __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.holderCharacter == (Object)null)
			{
				return true;
			}
			if (ClassCheckUtil.IsGobelin(__instance.holderCharacter) && (Object)(object)((Component)__instance).GetComponent<Action_RestoreHunger>() != (Object)null && GobelinDiet.IsPackagedFood(__instance))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Item), "StartUseSecondary")]
	[HarmonyPriority(600)]
	public class GobelinFoodBlockerSecondary
	{
		private static bool Prefix(Item __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.holderCharacter == (Object)null)
			{
				return true;
			}
			if (ClassCheckUtil.IsGobelin(__instance.holderCharacter) && (Object)(object)((Component)__instance).GetComponent<Action_RestoreHunger>() != (Object)null && GobelinDiet.IsPackagedFood(__instance))
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Item), "Consume")]
	public class GobelinInfiniteConsumePatch
	{
		private static bool Prefix(Item __instance)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.holderCharacter == (Object)null)
			{
				return true;
			}
			if (ClassCheckUtil.IsGobelin(__instance.holderCharacter) && ((Object)__instance).name.IndexOf("HealingDart Variant", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				__instance.holderCharacter.data.lastConsumedItem = Time.time;
				if (__instance.holderCharacter.refs != null && (Object)(object)__instance.holderCharacter.refs.animator != (Object)null)
				{
					__instance.holderCharacter.refs.animator.SetBool("Consumed Item", true);
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "AddAffliction")]
	public class GobelinSporeAfflictionPatch
	{
		private static bool Prefix(CharacterAfflictions __instance, Affliction affliction)
		{
			if ((Object)(object)__instance == (Object)null || (Object)(object)__instance.character == (Object)null || affliction == null)
			{
				return true;
			}
			if (ClassCheckUtil.IsGobelin(__instance.character))
			{
				string name = ((object)affliction).GetType().Name;
				if (name.Contains("Confus") || name.Contains("Spore"))
				{
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(Affliction_PoisonOverTime), "OnApplied")]
	public class PoisonPatch
	{
		private static bool Prefix(Affliction_PoisonOverTime __instance)
		{
			return (Object)(object)((Affliction)(__instance?)).character == (Object)null || !ClassCheckUtil.IsMushroom(((Affliction)__instance).character);
		}
	}
	[HarmonyPatch(typeof(CharacterMovement), "EvaluateGroundChecks")]
	public class RogueJumpPatch
	{
		private static void Postfix(CharacterMovement __instance)
		{
			Character val = ((__instance != null) ? ((Component)__instance).GetComponent<Character>() : null);
			if ((Object)(object)val != (Object)null && val.IsLocal && PeakClassModPlugin.rogueActive)
			{
				val.data.jumpsRemaining = 2;
			}
		}
	}
	[HarmonyPatch(typeof(CharacterMovement), "TryToJump")]
	public class RogueJumpRPCPatch
	{
		private static bool Prefix(CharacterMovement __instance)
		{
			Character val = ((__instance != null) ? ((Component)__instance).GetComponent<Character>() : null);
			if ((Object)(object)val != (Object)null && val.IsLocal && PeakClassModPlugin.rogueActive && val.data.currentStamina > 0.005f)
			{
				val.data.jumpsRemaining = 1;
				val.data.chargingJump = true;
				CharacterRefs refs = val.refs;
				if (refs != null)
				{
					PhotonView view = refs.view;
					if (view != null)
					{
						view.RPC("JumpRpc", (RpcTarget)0, new object[1] { false });
					}
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(RunManager), "StartRun")]
	public class RunManager_StartRun_Patch
	{
		[CompilerGenerated]
		private sealed class <AddEffectsDelayed>d__1 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			private Character <lc>5__1;

			private float <c>5__2;

			private float <c>5__3;

			object IEnumerator<object>.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			object IEnumerator.Current
			{
				[DebuggerHidden]
				get
				{
					return <>2__current;
				}
			}

			[DebuggerHidden]
			public <AddEffectsDelayed>d__1(int <>1__state)
			{
				this.<>1__state = <>1__state;
			}

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<lc>5__1 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				//IL_003b: Expected O, but got Unknown
				//IL_006d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0077: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(1.5f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<lc>5__1 = Character.localCharacter;
					if ((Object)(object)<lc>5__1 == (Object)null)
					{
						<>2__current = (object)new WaitForSeconds(1f);
						<>1__state = 2;
						return true;
					}
					break;
				case 2:
					<>1__state = -1;
					<lc>5__1 = Character.localCharacter;
					if ((Object)(object)<lc>5__1 == (Object)null)
					{
						return false;
					}
					break;
				}
				if (ClassCheckUtil.IsMushroom(<lc>5__1))
				{
					ClassManager.ActivateMushroomancerClass();
					ClassManager.StartMushroomancerWatch(<lc>5__1);
				}
				else if (ClassCheckUtil.IsGeneral(<lc>5__1))
				{
					ClassManager.ActivateGeneralClass();
					CharacterRefs refs = <lc>5__1.refs;
					float? obj;
					if (refs == null)
					{
						obj = null;
					}
					else
					{
						CharacterAfflictions afflictions = refs.afflictions;
						obj = ((afflictions != null) ? new float?(afflictions.GetCurrentStatus((STATUSTYPE)5)) : null);
					}
					float? num = obj;
					<c>5__2 = num.GetValueOrDefault();
					if (<c>5__2 < 0.35f)
					{
						CharacterRefs refs2 = <lc>5__1.refs;
						if (refs2 != null)
						{
							CharacterAfflictions afflictions2 = refs2.afflictions;
							if (afflictions2 != null)
							{
								afflictions2.SetStatus((STATUSTYPE)5, 0.35f, true);
							}
						}
					}
				}
				else if (ClassCheckUtil.IsGreatEpeeHat(<lc>5__1))
				{
					ClassManager.ActivateGreatEpeeClass();
					ClassManager.StartGreatEpeeRoutines(<lc>5__1);
				}
				else if (ClassCheckUtil.IsMedicHat(<lc>5__1))
				{
					ClassManager.ActivateMedicClass();
					CharacterRefs refs3 = <lc>5__1.refs;
					float? obj2;
					if (refs3 == null)
					{
						obj2 = null;
					}
					else
					{
						CharacterAfflictions afflictions3 = refs3.afflictions;
						obj2 = ((afflictions3 != null) ? new float?(afflictions3.GetCurrentStatus((STATUSTYPE)5)) : null);
					}
					float? num = obj2;
					<c>5__3 = num.GetValueOrDefault();
					if (<c>5__3 < 0.15f)
					{
						CharacterRefs refs4 = <lc>5__1.refs;
						if (refs4 != null)
						{
							CharacterAfflictions afflictions4 = refs4.afflictions;
							if (afflictions4 != null)
							{
								afflictions4.SetStatus((STATUSTYPE)5, 0.15f, true);
							}
						}
					}
				}
				else if (ClassCheckUtil.IsAstronaut(<lc>5__1))
				{
					ClassManager.ActivateAstronautClass();
				}
				else if (ClassCheckUtil.IsTechPriest(<lc>5__1))
				{
					ClassManager.ActivateTechPriestClass();
				}
				else if (ClassCheckUtil.IsRogueHat(<lc>5__1))
				{
					ClassManager.ActivateRogueClass();
				}
				else if (ClassCheckUtil.IsGobelin(<lc>5__1))
				{
					ClassManager.ActivateGobelinClass();
				}
				else if (ClassCheckUtil.IsScout(<lc>5__1))
				{
					ClassManager.ActivateScoutClass();
				}
				else if (ClassCheckUtil.IsWolf(<lc>5__1))
				{
					ClassManager.ActivateWolfClass();
				}
				return false;
			}

			bool IEnumerator.MoveNext()
			{
				//ILSpy generated this explicit interface implementation from .override directive in MoveNext
				return this.MoveNext();
			}

			[DebuggerHidden]
			void IEnumerator.Reset()
			{
				throw new NotSupportedException();
			}
		}

		private static void Postfix()
		{
			if (PhotonNetwork.IsMasterClient)
			{
				ClassModNetwork.HasReceivedStartItems.Clear();
			}
			PeakClassModPlugin instance = PeakClassModPlugin.Instance;
			if (instance != null)
			{
				((MonoBehaviour)instance).StartCoroutine(AddEffectsDelayed());
			}
		}

		[IteratorStateMachine(typeof(<AddEffectsDelayed>d__1))]
		public static IEnumerator AddEffectsDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <AddEffectsDelayed>d__1(0);
		}
	}
	[HarmonyPatch(typeof(CharacterCustomization), "SetCharacterHat")]
	public class SetHat_Patch
	{
		private static void Postfix(int index)
		{
			CustomizationOption[] array = Singleton<Customization>.Instance?.hats;
			object obj;
			if (array == null || index < 0 || index >= array.Length)
			{
				obj = "Unknown";
			}
			else
			{
				CustomizationOption obj2 = array[index];
				obj = ((obj2 != null) ? ((Object)obj2).name : null);
			}
			string text = (string)obj;
			HatUtils.SetLastLocalHatName(text);
			switch (text)
			{
			case "Hat_Scoutmaster":
				ClassManager.ActivateScoutClass();
				break;
			case "Hat_Medic":
			case "MedicHelmet":
				ClassManager.ActivateMedicClass();
				break;
			case "Hat_Crab":
				ClassManager.ActivateTechPriestClass();
				break;
			case "Hat_Mushroom":
				ClassManager.ActivateMushroomancerClass();
				break;
			case "Hat_Propeller":
				ClassManager.ActivateGreatEpeeClass();
				break;
			case "Hat_NinjaHeadband":
				ClassManager.ActivateRogueClass();
				break;
			case "Hat_Bandana":
			case "Hat_Captain":
				ClassManager.ActivateGeneralClass();
				break;
			case "Hat_Astronaut":
				ClassManager.ActivateAstronautClass();
				break;
			case "Hat_Midsummer":
				ClassManager.ActivateGobelinClass();
				break;
			case "Hat_WolfEars":
				ClassManager.ActivateWolfClass();
				break;
			default:
				ClassManager.DeactivateAllClasses();
				break;
			}
			if ((Object)(object)Character.localCharacter != (Object)null && (Object)(object)GUIManager.instance?.bar != (Object)null)
			{
				GUIManager.instance.bar.ChangeBar();
			}
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "get_statusSum")]
	public class StatusSum_Patch
	{
		private static void Postfix(CharacterAfflictions __instance, ref float __result)
		{
			if (!((Object)(object)__instance?.character == (Object)null) && __instance.character.IsLocal)
			{
				float currentStatus = __instance.GetCurrentStatus((STATUSTYPE)7);
				if (ClassManager.IsScoutActive())
				{
					__result = __result - currentStatus + currentStatus * 0.5f;
				}
				else if (ClassManager.IsGeneralActive())
				{
					__result = __result - currentStatus + currentStatus * 2f;
				}
				else if (ClassManager.IsTechPriestActive() && ClassCheckUtil.IsTechPriest(__instance.character))
				{
					__result -= currentStatus;
				}
			}
		}
	}
	[HarmonyPatch(typeof(Item), "StartUsePrimary")]
	[HarmonyPriority(400)]
	public class TechPriestConsumablePatch1
	{
		private static bool Prefix(Item __instance)
		{
			return !TechPriestItemChecker.ShouldBlockUse(__instance);
		}
	}
	[HarmonyPatch(typeof(Item), "StartUseSecondary")]
	[HarmonyPriority(400)]
	public class TechPriestConsumablePatch2
	{
		private static bool Prefix(Item __instance)
		{
			return !TechPriestItemChecker.ShouldBlockUse(__instance);
		}
	}
	[HarmonyPatch(typeof(Affliction_FasterBoi), "OnApplied")]
	public class TechPriestFasterBoiBlock
	{
		private static bool Prefix(Affliction_FasterBoi __instance)
		{
			return (Object)(object)((Affliction)(__instance?)).character == (Object)null || !ClassCheckUtil.IsTechPriest(((Affliction)__instance).character);
		}
	}
	[HarmonyPatch(typeof(Character), "AddExtraStamina")]
	public class TechPriestStaminaPatch1
	{
		private static bool Prefix(Character __instance)
		{
			return (Object)(object)__instance == (Object)null || !ClassCheckUtil.IsTechPriest(__instance);
		}
	}
	[HarmonyPatch(typeof(Affliction_InfiniteStamina), "OnApplied")]
	public class TechPriestStaminaPatch2
	{
		private static bool Prefix(Affliction_InfiniteStamina __instance)
		{
			return (Object)(object)((Affliction)(__instance?)).character == (Object)null || !ClassCheckUtil.IsTechPriest(((Affliction)__instance).character);
		}
	}
	[HarmonyPatch(typeof(Affliction_InfiniteStamina), "UpdateEffect")]
	public class TechPriestStaminaPatch2_Update
	{
		private static bool Prefix(Affliction_InfiniteStamina __instance)
		{
			return (Object)(object)((Affliction)(__instance?)).character == (Object)null || !ClassCheckUtil.IsTechPriest(((Affliction)__instance).character);
		}
	}
	[HarmonyPatch(typeof(CharacterAfflictions), "UpdateNormalStatuses")]
	public class UpdateStatus_TechPriest_Patch
	{
		private static void Postfix(CharacterAfflictions __instance)
		{
			if ((Object)(object)__instance?.character != (Object)null && ClassCheckUtil.IsTechPriest(__instance.character) && ClassManager.IsTechPriestActive())
			{
				__instance.currentStatuses[7] = 0f;
			}
		}
	}
	[HarmonyPatch]
	public class TechPriestCarryPatch
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			List<MethodBase> list = new List<MethodBase>();
			MethodInfo methodInfo = AccessTools.Method(typeof(CharacterCarrying), "Update", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				list.Add(methodInfo);
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(CharacterCarrying), "RPCA_StartCarry", (Type[])null, (Type[])null);
			if (methodInfo2 != null)
			{
				list.Add(methodInfo2);
			}
			return list;
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CharacterData), "fullyPassedOut");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(CharacterData), "passedOut");
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(CharacterData), "dead");
			MethodInfo methodInfo = AccessTools.Method(typeof(TechPriestCarryPatch), "ShouldBypassPassedOutCheck", (Type[])null, (Type[])null);
			for (int i = 0; i < list.Count; i++)
			{
				if (list[i].opcode == OpCodes.Ldfld && list[i].operand is FieldInfo fieldInfo4 && (fieldInfo4 == fieldInfo || fieldInfo4 == fieldInfo2))
				{
					list.Insert(i, new CodeInstruction(OpCodes.Dup, (object)null));
					list.Insert(i + 2, new CodeInstruction(OpCodes.Call, (object)methodInfo));
					i += 2;
				}
			}
			return list;
		}

		public static bool ShouldBypassPassedOutCheck(CharacterData data, bool originalPassedOut)
		{
			if ((Object)(object)data == (Object)null)
			{
				return originalPassedOut;
			}
			Character localCharacter = Character.localCharacter;
			if ((Object)(object)localCharacter != (Object)null && localCharacter.refs != null && (Object)(object)localCharacter.refs.view != (Object)null && localCharacter.refs.view.IsMine && ClassManager.IsTechPriestActive() && !data.dead)
			{
				return true;
			}
			return originalPassedOut;
		}
	}
}