using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using MoreAscents.API;
using MoreAscents.Patches;
using UnityEngine;
using Zorro.Core;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETFramework,Version=v4.7.1", FrameworkDisplayName = ".NET Framework 4.7.1")]
[assembly: AssemblyCompany("MoreAscents")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+fd4fc9f93d2dbc82bcd4486a197ec15629076d03")]
[assembly: AssemblyProduct("MoreAscents")]
[assembly: AssemblyTitle("MoreAscents")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace MoreAscents
{
	public class AscentGimmick
	{
		public AscentStruct _ascentData;

		public bool active;

		public virtual string GetTitle()
		{
			return "";
		}

		public virtual string GetDescription()
		{
			return "";
		}

		public virtual Color GetColor()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			return Color.red;
		}

		public virtual string GetTitleReward()
		{
			return "";
		}

		public virtual void CharacterPassedOut(Character character)
		{
		}

		public virtual void OnLavaExisted(Lava lava)
		{
		}

		public virtual void OnFogInitNewSphere(OrbFogHandler __instance)
		{
		}

		public virtual void OnCharacterFall(Character character)
		{
		}

		public virtual void RespawnChestExisted(Spawner chest)
		{
		}

		public virtual void OnFinishCooking(ItemCooking itemCooking)
		{
		}

		public virtual void SpawnerSpawnItems(Spawner spawner, ref List<Transform> spawnSpots)
		{
		}

		public virtual void OnGrabbedCharacter(Character thisCharacter)
		{
		}

		public virtual void OnUpdateNormalStatuses(Character character)
		{
		}

		public virtual void Update()
		{
		}

		public virtual float AfflictionMultiplier(CharacterAfflictions afflictions, STATUSTYPE statusType, float amount)
		{
			return 0f;
		}
	}
	public static class AscentGimmickHandler
	{
		internal static readonly List<AscentGimmick> gimmicks = new List<AscentGimmick>();

		private static readonly List<AscentInstanceData> pendingDatas = new List<AscentInstanceData>();

		private static bool HasInitialized = false;

		internal static int BaseAscents { get; private set; } = -1;


		internal static void MarkGimmicksAsActive(int ascentIndex)
		{
			int num = 0;
			foreach (AscentInstanceData ascent in SingletonAsset<AscentData>.Instance.ascents)
			{
				AscentGimmick gimmickByData = GetGimmickByData(ascent);
				if (num <= ascentIndex && gimmickByData != null)
				{
					gimmickByData.active = true;
					Plugin.Logger.LogWarning((object)("enabled gimmick " + gimmickByData.GetType().Name + " [" + gimmickByData.GetTitle() + "]!"));
				}
				num++;
			}
		}

		public static AscentGimmick GetGimmickByData(AscentInstanceData data)
		{
			foreach (AscentGimmick gimmick in gimmicks)
			{
				if (gimmick._ascentData.data == data)
				{
					return gimmick;
				}
			}
			return null;
		}

		internal static void DisableGimmicks()
		{
			foreach (AscentGimmick gimmick in gimmicks)
			{
				gimmick.active = false;
			}
		}

		internal static int GetBaseAscentCount()
		{
			if (BaseAscents == -1)
			{
				BaseAscents = SingletonAsset<AscentData>.Instance.ascents.Count;
			}
			return BaseAscents;
		}

		internal static void Initialize()
		{
			if (HasInitialized)
			{
				Plugin.Logger.LogError((object)"already initialized");
				return;
			}
			HasInitialized = true;
			AscentData instance = SingletonAsset<AscentData>.Instance;
			List<AscentInstanceData> ascents = instance.ascents;
			List<AscentInstanceData> list = new List<AscentInstanceData>();
			Plugin.Logger.LogInfo((object)$"initializing with ({pendingDatas.Count} custom) and ({ascents.Count} base)");
			foreach (AscentInstanceData item in ascents)
			{
				HotLoadAscentInstanceData(list, item);
			}
			foreach (AscentInstanceData pendingData in pendingDatas)
			{
				HotLoadAscentInstanceData(list, pendingData);
			}
			instance.ascents = list;
		}

		private static void HotLoadAscentInstanceData(List<AscentInstanceData> targetList, AscentInstanceData data)
		{
			if (data.titleReward == "")
			{
				data.titleReward = data.title + " Conqueror";
			}
			targetList.Add(data);
		}

		public static void RegisterAscent<T>() where T : AscentGimmick
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: 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_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			AscentGimmick ascentGimmick = Activator.CreateInstance<T>();
			AscentInstanceData val2 = new AscentInstanceData
			{
				title = ascentGimmick.GetTitle(),
				description = ascentGimmick.GetDescription(),
				titleReward = ascentGimmick.GetTitleReward(),
				color = ascentGimmick.GetColor(),
				sashSprite = SingletonAsset<AscentData>.Instance.ascents[0].sashSprite
			};
			ascentGimmick._ascentData = new AscentStruct
			{
				data = val2,
				order = 9 + (gimmicks.Count + 1)
			};
			gimmicks.Add(ascentGimmick);
			if (HasInitialized)
			{
				HotLoadAscentInstanceData(SingletonAsset<AscentData>.Instance.ascents, val2);
				Plugin.Logger.LogInfo((object)("Hot loaded " + val2.title + "!"));
				return;
			}
			pendingDatas.Add(val2);
			Plugin.Logger.LogInfo((object)("Queued " + val2.title));
			AddIdentityTranslation(ascentGimmick.GetTitle(), ascentGimmick.GetTitle());
			AddIdentityTranslation("desc_" + ascentGimmick.GetTitle(), ascentGimmick.GetDescription());
			static void AddIdentityTranslation(string key, string val)
			{
				if (string.IsNullOrWhiteSpace(key))
				{
					throw new NotImplementedException($"translation was empty?? {typeof(T)}");
				}
				LocalizedText.mainTable.Add(key.ToUpperInvariant(), Enumerable.Repeat(val.ToUpperInvariant(), 14).ToList());
			}
		}
	}
	public struct AscentStruct
	{
		public AscentInstanceData data;

		public int order;
	}
	public class AfflictionGimmick : AscentGimmick
	{
		public override string GetTitle()
		{
			return "Ascent 9";
		}

		public override string GetDescription()
		{
			return "You're more vulnerable to everything but Injuries, Hunger and Weight.";
		}

		public override float AfflictionMultiplier(CharacterAfflictions affliction, STATUSTYPE statusType, float amount)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			if ((int)statusType == 0 || (int)statusType == 1 || (int)statusType == 7 || !affliction.character.IsLocal || (CharacterPatches.UpdateNormalStatuses.InUpdateNormalStatuses && (int)statusType == 2))
			{
				return 0f;
			}
			return 2f;
		}
	}
	public class BingBongGimmick : AscentGimmick
	{
		private static float SinceLastShake;

		public override string GetDescription()
		{
			return "Bing Bong calls upon an evil force if not given attention.";
		}

		public override string GetTitle()
		{
			return "Chaos 4";
		}

		public override void Update()
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			float deltaTime = Time.deltaTime;
			SinceLastShake += deltaTime;
			Item heldBingBongItem = BingBongPatches.heldBingBongItem;
			if ((Object)(object)heldBingBongItem != (Object)null && (int)heldBingBongItem.itemState == 1)
			{
				BingBongMechanics.BingBongUnheldFor = 0f;
			}
			else
			{
				BingBongMechanics.BingBongUnheldFor += deltaTime;
			}
			foreach (Character allCharacter in Character.AllCharacters)
			{
				if (allCharacter.IsLocal)
				{
					if (allCharacter.data.passedOutOnTheBeach > 0f)
					{
						BingBongMechanics.BingBongUnheldFor = 0f;
						break;
					}
					if (BingBongMechanics.BingBongUnheldFor > 10f && BingBongMechanics.BingBongUnheldFor <= 15f && SinceLastShake > 0f)
					{
						SinceLastShake = 0f;
						GamefeelHandler.instance.AddPerlinShake(0.7f, 0.15f, 15f);
					}
					if (BingBongMechanics.BingBongUnheldFor >= 15f)
					{
						allCharacter.refs.afflictions.AddStatus((STATUSTYPE)4, 0.05f * Time.deltaTime, false, true, true);
						break;
					}
				}
			}
		}
	}
	public class CampfireGimmick : AscentGimmick
	{
		public override string GetDescription()
		{
			return "Campfires are extremely hot.";
		}

		public override string GetTitle()
		{
			return "Chaos 2";
		}

		public override void OnFinishCooking(ItemCooking itemCooking)
		{
			itemCooking.wreckWhenCooked = true;
		}
	}
	public class SkeletonGimmick : AscentGimmick
	{
		public override string GetDescription()
		{
			return "Passing out instantly turns you into a skeleton.";
		}

		public override string GetTitle()
		{
			return "Chaos 1";
		}

		public override void CharacterPassedOut(Character character)
		{
			if (character.IsLocal)
			{
				((object)character).GetType().GetMethod("DieInstantly", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(character, Array.Empty<object>());
			}
		}
	}
	public class SunHotGimmick : AscentGimmick
	{
		public override string GetDescription()
		{
			return "The sun is very hot, don't get heatstroke.";
		}

		public override string GetTitle()
		{
			return "Chaos 3";
		}

		public override void OnUpdateNormalStatuses(Character character)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			if (!character.IsLocal || DayNightManager.instance.isDay < 0.5f)
			{
				return;
			}
			MountainProgressHandler instance = Singleton<MountainProgressHandler>.Instance;
			if (!((Object)(object)instance == (Object)null) && instance.maxProgressPointReached < 3)
			{
				Vector3 val = -((Component)RenderSettings.sun).transform.forward;
				RaycastHit val2 = HelperFunctions.LineCheck(character.Center, character.Center + val * 1000f, (LayerType)5, 0f, (QueryTriggerInteraction)1);
				if (!Object.op_Implicit((Object)(object)((RaycastHit)(ref val2)).transform) || !(((Object)((Component)((RaycastHit)(ref val2)).transform).gameObject).name != "EdgeWall"))
				{
					character.refs.afflictions.AddStatus((STATUSTYPE)8, 0.0025f * Time.deltaTime, false, true, true);
				}
			}
		}
	}
	public class FallDamageGimmick : AscentGimmick
	{
		public override string GetTitle()
		{
			return "Ascent 8";
		}

		public override string GetDescription()
		{
			return "Butter Fingers.";
		}

		public override void OnCharacterFall(Character character)
		{
			if (character.IsLocal)
			{
				((object)Character.localCharacter.refs.items).GetType().GetMethod("DropAllItems", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(Character.localCharacter.refs.items, new object[1] { true });
			}
		}
	}
	public class HelpingIsBadGimmick : AscentGimmick
	{
		public override string GetTitle()
		{
			return "Ascent 11";
		}

		public override string GetDescription()
		{
			return "Helping makes you drowsy.";
		}

		public override void OnGrabbedCharacter(Character character)
		{
			character.refs.afflictions.AddStatus((STATUSTYPE)6, 0.05f, false, true, true);
		}
	}
	public class LuggageGimmick : AscentGimmick
	{
		public override string GetTitle()
		{
			return "Ascent 10";
		}

		public override string GetDescription()
		{
			return "Big Luggage's have a chance to only contain one item.";
		}

		public override void SpawnerSpawnItems(Spawner spawner, ref List<Transform> spawnSpots)
		{
			if (((Object)((Component)spawner).gameObject).name == "LuggageBig" && Random.Range(0, 2) == 0)
			{
				List<Transform> list = new List<Transform>();
				list.Add(spawnSpots[0]);
				spawnSpots = list;
			}
		}
	}
	public class OccultStatueGimmick : AscentGimmick
	{
		[CompilerGenerated]
		private sealed class <DespawnStatusDelayed>d__5 : IEnumerator<object>, IDisposable, IEnumerator
		{
			private int <>1__state;

			private object <>2__current;

			public OccultStatueGimmick <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Expected O, but got Unknown
				int num = <>1__state;
				OccultStatueGimmick occultStatueGimmick = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(45f);
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					lock (occultStatueGimmick.despawnQueue_lockObj)
					{
						if (occultStatueGimmick.despawnQueue != null)
						{
							foreach (Spawner item in occultStatueGimmick.despawnQueue)
							{
								((Component)item).gameObject.SetActive(false);
							}
							occultStatueGimmick.despawnQueue = null;
						}
					}
					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 List<Spawner> despawnQueue;

		private readonly object despawnQueue_lockObj = new object();

		public override string GetTitle()
		{
			return "Ascent 12";
		}

		public override string GetDescription()
		{
			return "No more Revive Statues.";
		}

		public override void RespawnChestExisted(Spawner chest)
		{
			if (Plugin.ascent7Disabler.Value)
			{
				return;
			}
			lock (despawnQueue_lockObj)
			{
				if (despawnQueue == null)
				{
					despawnQueue = new List<Spawner>();
					((MonoBehaviour)Plugin.Instance).StartCoroutine(DespawnStatusDelayed());
				}
				despawnQueue.Add(chest);
			}
		}

		[IteratorStateMachine(typeof(<DespawnStatusDelayed>d__5))]
		private IEnumerator DespawnStatusDelayed()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DespawnStatusDelayed>d__5(0)
			{
				<>4__this = this
			};
		}
	}
	public class FogGimmick : AscentGimmick
	{
		public override string GetDescription()
		{
			return "The fog starts earlier and moves faster.";
		}

		public override string GetTitle()
		{
			return "Chaos 2";
		}

		public override void OnFogInitNewSphere(OrbFogHandler fog)
		{
			fog.currentStartForward = 0f;
			fog.currentStartHeight = 0f;
			fog.speed *= 2f;
			fog.maxWaitTime /= 10f;
			Plugin.Logger.LogWarning((object)"patched fog AGAIN");
		}
	}
	[BepInPlugin("MoreAscents", "MoreAscents", "1.0.0")]
	internal class Plugin : BaseUnityPlugin
	{
		internal static ManualLogSource Logger;

		internal static Plugin Instance;

		internal static ConfigEntry<int> ascentsUnlocked;

		internal static ConfigEntry<bool> ascent7Disabler;

		private static bool Initted;

		private void Awake()
		{
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			Logger = ((BaseUnityPlugin)this).Logger;
			Instance = this;
			ascentsUnlocked = ((BaseUnityPlugin)this).Config.Bind<int>("General", "MaxAscent", 0, "");
			ascent7Disabler = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Ascent 7/12 Disabler", false, "Disables ascent 7 and 12.");
			AscentGimmickHandler.GetBaseAscentCount();
			AscentGimmickHandler.RegisterAscent<FallDamageGimmick>();
			AscentGimmickHandler.RegisterAscent<AfflictionGimmick>();
			AscentGimmickHandler.RegisterAscent<LuggageGimmick>();
			AscentGimmickHandler.RegisterAscent<HelpingIsBadGimmick>();
			AscentGimmickHandler.RegisterAscent<OccultStatueGimmick>();
			AscentGimmickHandler.RegisterAscent<SkeletonGimmick>();
			AscentGimmickHandler.RegisterAscent<CampfireGimmick>();
			AscentGimmickHandler.RegisterAscent<SunHotGimmick>();
			AscentGimmickHandler.RegisterAscent<BingBongGimmick>();
			AscentGimmickHandler.Initialize();
			Logger.LogInfo((object)"Plugin MoreAscents is loaded!");
			new Harmony("MoreAscents").PatchAll();
		}

		internal static void Init()
		{
			if (Initted)
			{
				return;
			}
			Initted = true;
			int num = default(int);
			if (Singleton<AchievementManager>.Instance.GetSteamStatInt((STEAMSTATTYPE)13, ref num))
			{
				if (num > AscentGimmickHandler.BaseAscents)
				{
					Singleton<AchievementManager>.Instance.SetSteamStat((STEAMSTATTYPE)13, AscentGimmickHandler.BaseAscents);
				}
				ascentsUnlocked.Value = ((ascentsUnlocked.Value < num) ? num : ascentsUnlocked.Value);
			}
			Logger.LogInfo((object)"Initted");
		}

		private void Update()
		{
			GUIManagerPatches.Grasp.SinceLastGrab += Time.deltaTime;
			foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
			{
				if (gimmick.active)
				{
					gimmick.Update();
				}
			}
		}
	}
	[HarmonyPatch(typeof(BoardingPass), "UpdateAscent")]
	internal static class boarding_initilize_patch
	{
		internal static void Prefix(BoardingPass __instance)
		{
			if (Input.GetKey((KeyCode)108))
			{
				Singleton<AchievementManager>.Instance.SetSteamStat((STEAMSTATTYPE)13, 155);
			}
			FieldInfo field = ((object)__instance).GetType().GetField("maxAscent", BindingFlags.Instance | BindingFlags.NonPublic);
			field.SetValue(__instance, SingletonAsset<AscentData>.Instance.ascents.Count - 3);
			Plugin.Logger.LogInfo((object)$"Ascents capped {field.GetValue(__instance)}");
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "MoreAscents";

		public const string PLUGIN_NAME = "MoreAscents";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace MoreAscents.Patches
{
	public class AirportCheckInKioskPatches
	{
		[HarmonyPatch(typeof(AirportCheckInKiosk), "BeginIslandLoadRPC")]
		public static class LoadIslandMaster
		{
			[HarmonyPrefix]
			public static void Prefix(int ascent)
			{
				AscentGimmickHandler.DisableGimmicks();
				AscentGimmickHandler.MarkGimmicksAsActive(ascent + 2);
			}
		}
	}
	internal class BingBongPatches
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		internal static class Patch
		{
			[HarmonyPrefix]
			internal static void Prefix(Item value)
			{
				if ((Object)(object)value != (Object)null && value != null && (value.UIData?.itemName?.ToLowerInvariant()?.Equals("bing bong")).GetValueOrDefault())
				{
					heldBingBongItem = value;
				}
				else
				{
					heldBingBongItem = null;
				}
			}
		}

		internal static Item heldBingBongItem;
	}
	public class CharacterPatches
	{
		[HarmonyPatch(typeof(CharacterMovement), "CheckFallDamage")]
		public static class CheckFallDamage
		{
			public static bool InFallDamage;

			[HarmonyPrefix]
			public static void Prefix(CharacterMovement __instance)
			{
				InFallDamage = true;
			}

			[HarmonyPostfix]
			public static void Postfix(CharacterMovement __instance)
			{
				InFallDamage = false;
			}
		}

		[HarmonyPatch(typeof(CharacterGrabbing), "Reach")]
		public static class Reach
		{
			public static Character character;

			[HarmonyPrefix]
			public static void Prefix(CharacterGrabbing __instance)
			{
				character = ((Component)__instance).GetComponent<Character>();
			}

			[HarmonyPostfix]
			public static void Postfix()
			{
				character = null;
			}
		}

		[HarmonyPatch(typeof(Character), "RPCA_PassOut")]
		public static class RPCA_PassOut
		{
			[HarmonyPostfix]
			public static void Prefix(Character __instance)
			{
				foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
				{
					if (gimmick.active)
					{
						gimmick.CharacterPassedOut(__instance);
					}
				}
			}
		}

		[HarmonyPatch(typeof(CharacterAfflictions), "UpdateNormalStatuses")]
		public static class UpdateNormalStatuses
		{
			public static bool InUpdateNormalStatuses;

			[HarmonyPrefix]
			public static void Prefix(CharacterAfflictions __instance)
			{
				foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
				{
					if (gimmick.active)
					{
						gimmick.OnUpdateNormalStatuses(__instance.character);
					}
				}
				InUpdateNormalStatuses = true;
			}

			[HarmonyPostfix]
			public static void Postfix()
			{
				InUpdateNormalStatuses = false;
			}
		}

		[HarmonyPatch(typeof(CharacterAfflictions), "AddStatus")]
		public static class AddStatus
		{
			[HarmonyPrefix]
			public static void Prefix(CharacterAfflictions __instance, ref float amount, STATUSTYPE statusType)
			{
				//IL_0026: Unknown result type (might be due to invalid IL or missing references)
				float num = 1f;
				foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
				{
					if (gimmick.active)
					{
						num += gimmick.AfflictionMultiplier(__instance, statusType, amount);
					}
				}
				amount *= num;
			}

			[HarmonyPostfix]
			public static void Postfix(CharacterAfflictions __instance, bool __result, float amount, STATUSTYPE statusType)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				if (!__result || !CheckFallDamage.InFallDamage || (int)statusType != 0)
				{
					return;
				}
				foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
				{
					if (gimmick.active)
					{
						gimmick.OnCharacterFall(__instance.character);
					}
				}
			}
		}
	}
	internal class DisableAscent7
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static class Patch
		{
			[HarmonyPostfix]
			public static void Postfix(ref bool __result)
			{
				if (Plugin.ascent7Disabler.Value)
				{
					__result = true;
				}
			}
		}
	}
	internal static class AchievementManagerPatches
	{
		[HarmonyPatch(typeof(AchievementManager), "GetMaxAscent")]
		internal static class GetMaxAscent
		{
			[HarmonyPostfix]
			internal static void Postfix(ref int __result)
			{
				__result = Plugin.ascentsUnlocked.Value;
				if (__result > SingletonAsset<AscentData>.Instance.ascents.Count - 1)
				{
					__result = SingletonAsset<AscentData>.Instance.ascents.Count - 1;
				}
			}
		}

		[HarmonyPatch(typeof(AchievementManager), "Start")]
		internal static class Start
		{
			[HarmonyPrefix]
			internal static void Prefix()
			{
				Plugin.Init();
			}
		}

		[HarmonyPatch(typeof(AchievementManager), "SetSteamStat", new Type[]
		{
			typeof(STEAMSTATTYPE),
			typeof(int)
		})]
		internal static class SetSteamStat
		{
			[HarmonyPrefix]
			internal static void Prefix(STEAMSTATTYPE steamStatType, ref int value)
			{
				//IL_0000: Unknown result type (might be due to invalid IL or missing references)
				//IL_0003: Invalid comparison between Unknown and I4
				if ((int)steamStatType == 13)
				{
					Plugin.ascentsUnlocked.Value = value;
					if (value > AscentGimmickHandler.BaseAscents - 1)
					{
						value = AscentGimmickHandler.BaseAscents - 1;
					}
				}
			}
		}
	}
	internal static class CharacterCustomizationPatches
	{
		[HarmonyPatch(typeof(CharacterCustomization), "SetCharacterSash")]
		internal static class SetCharacterSash
		{
			[HarmonyPrefix]
			internal static void Prefix(ref int index)
			{
				if (index > AscentGimmickHandler.BaseAscents - 2)
				{
					index = AscentGimmickHandler.BaseAscents - 2;
				}
			}
		}
	}
	public class FogPatches
	{
		[HarmonyPatch(typeof(OrbFogHandler), "InitNewSphere")]
		public static class Start
		{
			[HarmonyPostfix]
			public static void Postfix(OrbFogHandler __instance)
			{
				foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
				{
					if (gimmick.active)
					{
						gimmick.OnFogInitNewSphere(__instance);
					}
				}
			}
		}
	}
	public class GUIManagerPatches
	{
		[HarmonyPatch(typeof(GUIManager), "Grasp")]
		public static class Grasp
		{
			public static float SinceLastGrab;

			[HarmonyPrefix]
			public static void Prefix()
			{
				if (!CharacterPatches.Reach.character.IsLocal)
				{
					Plugin.Logger.LogWarning((object)"not local, not firing OnGrabbedCharacter to gimmicks.");
				}
				else
				{
					if (SinceLastGrab <= 1f)
					{
						return;
					}
					SinceLastGrab = 0f;
					Plugin.Logger.LogInfo((object)"success");
					foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
					{
						if (gimmick.active)
						{
							gimmick.OnGrabbedCharacter(Character.localCharacter);
						}
					}
				}
			}
		}
	}
	public class ItemCookingPatches
	{
		[HarmonyPatch(typeof(ItemCooking), "FinishCookingRPC")]
		public static class FinishCookingRPC
		{
			[HarmonyPrefix]
			public static void Prefix(ItemCooking __instance)
			{
				foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
				{
					if (gimmick.active)
					{
						gimmick.OnFinishCooking(__instance);
					}
				}
			}
		}
	}
	public class LavaRiverPatches
	{
		[HarmonyPatch(typeof(Lava), "Start")]
		public static class Start
		{
			[HarmonyPrefix]
			public static void Prefix(Lava __instance)
			{
				foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
				{
					if (gimmick.active)
					{
						gimmick.OnLavaExisted(__instance);
					}
				}
			}
		}
	}
	public class RopeSpoolPatches
	{
		[HarmonyPatch(typeof(RopeSpool), "OnInstanceDataSet")]
		public static class OnInstanceDataSet
		{
			[HarmonyPrefix]
			public static void Prefix(RopeSpool __instance)
			{
			}
		}
	}
	public class SpawnerPatches
	{
		[HarmonyPatch(typeof(Spawner), "SpawnItems")]
		public static class GetSpawnSpots
		{
			[HarmonyPrefix]
			public static void Prefix(Spawner __instance, ref List<Transform> spawnSpots)
			{
				foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
				{
					if (gimmick.active)
					{
						gimmick.SpawnerSpawnItems(__instance, ref spawnSpots);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Luggage), "Awake")]
		public static class Awake
		{
			[HarmonyPostfix]
			public static void Postfix(Luggage __instance)
			{
				if (((object)__instance).GetType() != typeof(RespawnChest))
				{
					return;
				}
				foreach (AscentGimmick gimmick in AscentGimmickHandler.gimmicks)
				{
					if (gimmick.active)
					{
						gimmick.RespawnChestExisted((Spawner)(object)__instance);
					}
				}
			}
		}
	}
}
namespace MoreAscents.API
{
	internal class BingBongMechanics
	{
		internal static float BingBongUnheldFor;
	}
}