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.Logging;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("com.corgan.AtOEndless")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0")]
[assembly: AssemblyProduct("AtOEndless")]
[assembly: AssemblyTitle("com.corgan.AtOEndless")]
[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 AtOEndless
{
	[HarmonyPatch]
	public class AtOEndless
	{
		public static bool refreshed = false;

		public static Dictionary<Zone, List<string>> RemoveRequirementsByZone = new Dictionary<Zone, List<string>>
		{
			{
				(Zone)0,
				new List<string>(1) { "treasurehuntii" }
			},
			{
				(Zone)3,
				new List<string>(1) { "darkdeal" }
			},
			{
				(Zone)1,
				new List<string>(5) { "armblowtorch", "armchargedrod", "armcoolingengine", "armdisclauncher", "armsmallcannon" }
			},
			{
				(Zone)2,
				new List<string>()
			},
			{
				(Zone)12,
				new List<string>(3) { "ulmininportal", "ulminindown", "riftulmi61" }
			},
			{
				(Zone)14,
				new List<string>(5) { "sahtidown", "sahtipolizonevent", "dreadroom", "dreadup", "dreadmastcannon" }
			},
			{
				(Zone)4,
				new List<string>()
			}
		};

		public static Dictionary<Zone, List<string>> AddRequirementsByZone = new Dictionary<Zone, List<string>>
		{
			{
				(Zone)0,
				new List<string>(6) { "crossroadnorth", "crossroadsouth", "caravannopay", "fungamemill", "riftsen47", "riftsen48" }
			},
			{
				(Zone)3,
				new List<string>(3) { "boatfaenlor", "riftfaen42", "riftfaen43" }
			},
			{
				(Zone)1,
				new List<string>(4) { "lavacascade", "goblinnorth", "riftvelka39", "riftvelka40" }
			},
			{
				(Zone)2,
				new List<string>(5) { "boatup", "boatcenter", "boatdown", "riftaqua46", "riftaqua47" }
			},
			{
				(Zone)12,
				new List<string>(3) { "ulmininup", "riftulmi60", "riftulmi61" }
			},
			{
				(Zone)14,
				new List<string>(5) { "sahtiup", "dreaddown", "sahtipolizon", "riftsahti67", "riftsahti68" }
			},
			{
				(Zone)4,
				new List<string>(4) { "voidnorth", "voidnorthpass", "voidsouth", "voidsouthpass" }
			}
		};

		public static string[] zoneStartNodes = new string[7] { "sen_0", "faen_0", "aqua_0", "velka_0", "ulmin_0", "sahti_0", "voidlow_0" };

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Node), "OnMouseUp")]
		public static void OnMouseUp(ref Node __instance)
		{
			if (Functions.ClickedThisTransform(((Component)__instance).transform) && !AlertManager.Instance.IsActive() && !GameManager.Instance.IsTutorialActive() && !SettingsManager.Instance.IsActive() && !DamageMeterManager.Instance.IsActive() && (!Object.op_Implicit((Object)(object)MapManager.Instance) || !MapManager.Instance.IsCharacterUnlock()) && (!Object.op_Implicit((Object)(object)MapManager.Instance) || (!MapManager.Instance.IsCorruptionOver() && !MapManager.Instance.IsConflictOver())) && (!Object.op_Implicit((Object)(object)MapManager.Instance) || !MapManager.Instance.selectedNode) && !Object.op_Implicit((Object)(object)EventManager.Instance))
			{
				GameManager.Instance.SetCursorPlain();
				MapManager.Instance.HidePopup();
				MapManager.Instance.PlayerSelectedNode(__instance, false);
				GameManager.Instance.PlayAudio(AudioManager.Instance.soundButtonClick, 0f, 0f);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(Node), "AssignNode")]
		public static void AssignNodePre(ref AtOManager __instance, out string[][] __state)
		{
			__state = new string[2][]
			{
				AtOManager.Instance.mapVisitedNodes.ToArray(),
				AtOManager.Instance.mapVisitedNodesAction.ToArray()
			};
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.Clear();
				AtOManager.Instance.mapVisitedNodesAction.Clear();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Node), "AssignNode")]
		public static void AssignNodePost(ref Node __instance, string[][] __state)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[0]).ToArray()));
				AtOManager.Instance.mapVisitedNodesAction.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[1]).ToArray()));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "GetTownTier")]
		public static void GetTownTier(ref AtOManager __instance, ref int ___townTier, ref int __result)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				__result = Math.Min(___townTier, 3);
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "GetActNumberForText")]
		public static void GetActNumberForText(ref AtOManager __instance, ref int ___townTier, ref int __result)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				__result = ___townTier + 1;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MapManager), "Awake")]
		public static void Awake(ref MapManager __instance)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			if (refreshed)
			{
				return;
			}
			foreach (GameObject map in __instance.mapList)
			{
				foreach (Transform item in map.transform)
				{
					Transform val = item;
					if (!(((Object)((Component)val).gameObject).name == "Nodes"))
					{
						continue;
					}
					foreach (Transform item2 in val)
					{
						Transform val2 = item2;
						GameObject gameObject = ((Component)val2).gameObject;
						Node component = gameObject.GetComponent<Node>();
						((Component)component).GetComponent<Node>().nodeData = Globals.Instance.GetNodeData(component.nodeData.NodeId);
					}
				}
			}
			refreshed = true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Globals), "CreateGameContent")]
		public static void CreateGameContent(ref Globals __instance, ref Dictionary<string, EventData> ____Events, ref Dictionary<string, NodeData> ____NodeDataSource, ref Dictionary<string, CombatData> ____CombatDataSource, ref Dictionary<string, CinematicData> ____Cinematics)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge() && ____Events.TryGetValue("e_sen34_a", out var value))
			{
				EventReplyData val = value.Replys.First();
				EventReplyData val2 = val.ShallowCopy();
				EventReplyData val3 = val.ShallowCopy();
				EventReplyData val4 = val.ShallowCopy();
				EventReplyData val5 = val.ShallowCopy();
				EventReplyData val6 = val.ShallowCopy();
				EventReplyData val7 = val.ShallowCopy();
				EventReplyData val8 = val.ShallowCopy();
				val2.ReplyActionText = (EventAction)0;
				val2.ReplyText = "You are thrust into a portal of unknown color";
				val2.SsRequirementUnlock = null;
				val2.SsNodeTravel = __instance.GetNodeData("sen_0");
				val3.ReplyActionText = (EventAction)0;
				val3.ReplyText = "You are thrust into a portal of unknown color";
				val3.SsRequirementUnlock = null;
				val3.SsNodeTravel = __instance.GetNodeData("faen_0");
				val4.ReplyActionText = (EventAction)0;
				val4.ReplyText = "You are thrust into a portal of unknown color";
				val4.SsRequirementUnlock = null;
				val4.SsNodeTravel = __instance.GetNodeData("aqua_0");
				val6.ReplyActionText = (EventAction)0;
				val6.ReplyText = "You are thrust into a portal of unknown color";
				val6.SsRequirementUnlock = null;
				val6.SsNodeTravel = __instance.GetNodeData("velka_0");
				val5.ReplyActionText = (EventAction)0;
				val5.ReplyText = "You are thrust into a portal of unknown color";
				val5.SsRequirementUnlock = null;
				val5.SsNodeTravel = __instance.GetNodeData("ulmin_0");
				val7.RequirementSku = "2511580";
				val7.ReplyActionText = (EventAction)0;
				val7.ReplyText = "You are thrust into a portal of unknown color";
				val7.SsRequirementUnlock = null;
				val7.SsNodeTravel = __instance.GetNodeData("sahti_0");
				val7.RequirementSku = "3185630";
				val8.ReplyActionText = (EventAction)0;
				val8.ReplyText = "You are thrust into a portal of unknown color";
				val8.SsRequirementUnlock = null;
				val8.SsNodeTravel = __instance.GetNodeData("voidlow_0");
				EventData val9 = Object.Instantiate<EventData>(value);
				EventData val10 = Object.Instantiate<EventData>(value);
				EventData val11 = Object.Instantiate<EventData>(value);
				EventData val12 = Object.Instantiate<EventData>(value);
				EventData val13 = Object.Instantiate<EventData>(value);
				EventData val14 = Object.Instantiate<EventData>(value);
				EventData val15 = Object.Instantiate<EventData>(value);
				val9.EventName = "Endless Obelisk";
				val9.Description = "Ahhhhhhhhhhhhhhhhhhhh!";
				val9.DescriptionAction = "AHHHHHHHHHHHHHHHH!";
				val9.EventId = "e_endless_sen";
				val9.Replys = (EventReplyData[])(object)new EventReplyData[6] { val3, val4, val6, val5, val7, val8 };
				val9.ReplyRandom = 1;
				val9.Init();
				val10.EventName = "Endless Obelisk";
				val10.Description = "Ahhhhhhhhhhhhhhhhhhhh!";
				val10.DescriptionAction = "AHHHHHHHHHHHHHHHH!";
				val10.EventId = "e_endless_faen";
				val10.Replys = (EventReplyData[])(object)new EventReplyData[6] { val2, val4, val6, val5, val7, val8 };
				val10.ReplyRandom = 1;
				val10.Init();
				val11.EventName = "Endless Obelisk";
				val11.Description = "Ahhhhhhhhhhhhhhhhhhhh!";
				val11.DescriptionAction = "AHHHHHHHHHHHHHHHH!";
				val11.EventId = "e_endless_aqua";
				val11.Replys = (EventReplyData[])(object)new EventReplyData[6] { val2, val3, val6, val5, val7, val8 };
				val11.ReplyRandom = 1;
				val11.Init();
				val12.EventName = "Endless Obelisk";
				val12.Description = "Ahhhhhhhhhhhhhhhhhhhh!";
				val12.DescriptionAction = "AHHHHHHHHHHHHHHHH!";
				val12.EventId = "e_endless_velka";
				val12.Replys = (EventReplyData[])(object)new EventReplyData[6] { val2, val3, val4, val5, val7, val8 };
				val12.ReplyRandom = 1;
				val12.Init();
				val13.EventName = "Endless Obelisk";
				val13.Description = "Ahhhhhhhhhhhhhhhhhhhh!";
				val13.DescriptionAction = "AHHHHHHHHHHHHHHHH!";
				val13.EventId = "e_endless_ulmin";
				val13.Replys = (EventReplyData[])(object)new EventReplyData[6] { val2, val3, val4, val6, val7, val8 };
				val13.ReplyRandom = 1;
				val13.Init();
				val14.EventName = "Endless Obelisk";
				val14.Description = "Ahhhhhhhhhhhhhhhhhhhh!";
				val14.DescriptionAction = "AHHHHHHHHHHHHHHHH!";
				val14.EventId = "e_endless_sahti";
				val14.Replys = (EventReplyData[])(object)new EventReplyData[6] { val2, val3, val4, val6, val5, val8 };
				val14.ReplyRandom = 1;
				val14.Init();
				val15.EventName = "Endless Obelisk";
				val15.Description = "Ahhhhhhhhhhhhhhhhhhhh!";
				val15.DescriptionAction = "AHHHHHHHHHHHHHHHH!";
				val15.EventId = "e_endless_void";
				val15.Replys = (EventReplyData[])(object)new EventReplyData[6] { val2, val3, val4, val6, val5, val7 };
				val15.ReplyRandom = 1;
				val15.Init();
				____Events.Add(val9.EventId.ToLower(), val9);
				____Events.Add(val10.EventId.ToLower(), val10);
				____Events.Add(val11.EventId.ToLower(), val11);
				____Events.Add(val13.EventId.ToLower(), val13);
				____Events.Add(val12.EventId.ToLower(), val12);
				____Events.Add(val14.EventId.ToLower(), val14);
				____Events.Add(val15.EventId.ToLower(), val15);
				if (____NodeDataSource.TryGetValue("sen_34", out var value2))
				{
					value2.NodeEvent = (EventData[])(object)new EventData[1] { val9 };
					____NodeDataSource["sen_34"] = value2;
				}
				if (____NodeDataSource.TryGetValue("faen_39", out var value3))
				{
					value3.NodeEvent = (EventData[])(object)new EventData[1] { val9 };
					____NodeDataSource["faen_39"] = value3;
				}
				if (____NodeDataSource.TryGetValue("aqua_36", out var value4))
				{
					value4.NodeEvent = (EventData[])(object)new EventData[1] { val11 };
					____NodeDataSource["aqua_36"] = value4;
				}
				if (____NodeDataSource.TryGetValue("velka_33", out var value5))
				{
					value5.NodeEvent = (EventData[])(object)new EventData[1] { val12 };
					____NodeDataSource["velka_33"] = value5;
				}
				if (____NodeDataSource.TryGetValue("ulmin_40", out var value6))
				{
					value6.NodeEvent = (EventData[])(object)new EventData[1] { val13 };
					____NodeDataSource["ulmin_40"] = value6;
				}
				if (____NodeDataSource.TryGetValue("sahti_63", out var value7))
				{
					value7.NodeEvent = (EventData[])(object)new EventData[1] { val14 };
					____NodeDataSource["sahti_63"] = value7;
				}
				if (____CombatDataSource.TryGetValue("evoidhigh_13b", out var value8))
				{
					value8.EventData = val15;
					____CombatDataSource["evoidhigh_13b"] = value8;
				}
				if (____Cinematics.TryGetValue("endgame", out var value9))
				{
					value9.CinematicEndAdventure = false;
					____Cinematics["endgame"] = value9;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(EventManager), "CloseEvent")]
		public static void CloseEvent(ref EventManager __instance, ref NodeData ___destinationNode, ref EventData ___currentEvent)
		{
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			if (GameManager.Instance.IsObeliskChallenge() || GameManager.Instance.IsWeeklyChallenge() || !((Object)(object)___destinationNode != (Object)null) || (!(___currentEvent.EventId == "e_endless_sen") && !(___currentEvent.EventId == "e_endless_faen") && !(___currentEvent.EventId == "e_endless_aqua") && !(___currentEvent.EventId == "e_endless_ulmin") && !(___currentEvent.EventId == "e_endless_velka") && !(___currentEvent.EventId == "e_endless_sahti") && !(___currentEvent.EventId == "e_endless_void")))
			{
				return;
			}
			AtOManager.Instance.SetTownTier(AtOManager.Instance.GetActNumberForText(""));
			AtOManager.Instance.SetGameId(string.Format("{0}+{1}", AtOManager.Instance.GetGameId().Split("+", StringSplitOptions.RemoveEmptyEntries).First(), AtOManager.Instance.GetActNumberForText("")));
			AtOManager.Instance.gameNodeAssigned.Clear();
			if (RemoveRequirementsByZone.TryGetValue(AtOManager.Instance.GetMapZone(___destinationNode.NodeId), out var value))
			{
				foreach (string item in value)
				{
					AtOManager.Instance.RemovePlayerRequirement(Globals.Instance.GetRequirementData(item), "");
				}
			}
			if (!AddRequirementsByZone.TryGetValue(AtOManager.Instance.GetMapZone(___destinationNode.NodeId), out var value2))
			{
				return;
			}
			foreach (string item2 in value2)
			{
				AtOManager.Instance.AddPlayerRequirement(Globals.Instance.GetRequirementData(item2), true);
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AtOManager), "UpgradeTownTier")]
		public static bool UpgradeTownTier(ref AtOManager __instance, ref int ___townTier)
		{
			if (GameManager.Instance.IsObeliskChallenge() || GameManager.Instance.IsWeeklyChallenge())
			{
				return true;
			}
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(NPC), "InitData")]
		public static void InitDataPre(ref NPC __instance)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge() && (Object)(object)((Character)__instance).NpcData != (Object)null && AtOManager.Instance.GetActNumberForText("") >= 3 && (Object)(object)((Character)__instance).NpcData.UpgradedMob != (Object)null)
			{
				((Character)__instance).NpcData = ((Character)__instance).NpcData.UpgradedMob;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(NPC), "InitData")]
		public static void InitDataPost(ref NPC __instance)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Invalid comparison between Unknown and I4
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Invalid comparison between Unknown and I4
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Invalid comparison between Unknown and I4
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				int num = AtOManager.Instance.GetActNumberForText("") - 1;
				if (num >= 1 && (int)AtOManager.Instance.GetMapZone(AtOManager.Instance.currentMapNode) == 0)
				{
					NPC obj = __instance;
					int hp = (((Character)__instance).HpCurrent = Functions.FuncRoundToInt((float)((Character)__instance).Hp + (float)((Character)__instance).Hp * 3f));
					((Character)obj).Hp = hp;
					NPC obj2 = __instance;
					((Character)obj2).Speed = ((Character)obj2).Speed + 2;
				}
				if (num >= 4 && (int)AtOManager.Instance.GetMapZone(AtOManager.Instance.currentMapNode) != 4 && (int)AtOManager.Instance.GetMapZone(AtOManager.Instance.currentMapNode) != 5)
				{
					NPC obj3 = __instance;
					int hp = (((Character)__instance).HpCurrent = Functions.FuncRoundToInt((float)((Character)__instance).Hp + (float)((Character)__instance).Hp * 0.5f));
					((Character)obj3).Hp = hp;
					NPC obj4 = __instance;
					((Character)obj4).Speed = ((Character)obj4).Speed + 1;
				}
				if (num >= 4)
				{
					NPC obj5 = __instance;
					int hp = (((Character)__instance).HpCurrent = Functions.FuncRoundToInt((float)((Character)__instance).Hp + (float)((Character)__instance).Hp * (0.5f * (float)(num - 3))));
					((Character)obj5).Hp = hp;
					NPC obj6 = __instance;
					((Character)obj6).Speed = ((Character)obj6).Speed + (num - 3);
				}
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(Character), "GetAuraCurseQuantityModification")]
		public static void GetAuraCurseQuantityModification(ref Character __instance, ref int __result, string id, CardClass CC, ref bool ___isHero)
		{
			if (GameManager.Instance.IsObeliskChallenge() || GameManager.Instance.IsWeeklyChallenge() || ___isHero)
			{
				return;
			}
			switch (id)
			{
			default:
				if (!(id == "fatigue"))
				{
					break;
				}
				goto case "doom";
			case "doom":
			case "paralyze":
			case "invulnerable":
			case "stress":
				__result = 0;
				break;
			}
			int num = AtOManager.Instance.GetActNumberForText("") - 1;
			if (num >= 4)
			{
				__result = Mathf.FloorToInt((float)__result * (1f + 0.25f * (float)(num - 3)));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(GameData), "FillData")]
		public static void FillData(ref GameData __instance, ref int ___townTier)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				___townTier = AtOManager.Instance.GetActNumberForText("") - 1;
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AtOManager), "SetCurrentNode")]
		public static void SetCurrentNodePre(ref AtOManager __instance, out string[][] __state)
		{
			__state = new string[2][]
			{
				AtOManager.Instance.mapVisitedNodes.ToArray(),
				AtOManager.Instance.mapVisitedNodesAction.ToArray()
			};
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.Clear();
				AtOManager.Instance.mapVisitedNodesAction.Clear();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "SetCurrentNode")]
		public static void SetCurrentNodePost(ref AtOManager __instance, string[][] __state)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[0]).ToArray()));
				AtOManager.Instance.mapVisitedNodesAction.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[1]).ToArray()));
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AtOManager), "ReAssignNodeByRequeriment")]
		public static void ReAssignNodeByRequerimentPre(ref AtOManager __instance, out string[][] __state)
		{
			__state = new string[2][]
			{
				AtOManager.Instance.mapVisitedNodes.ToArray(),
				AtOManager.Instance.mapVisitedNodesAction.ToArray()
			};
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.Clear();
				AtOManager.Instance.mapVisitedNodesAction.Clear();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(AtOManager), "ReAssignNodeByRequeriment")]
		public static void ReAssignNodeByRequerimentPost(ref AtOManager __instance, string[][] __state)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[0]).ToArray()));
				AtOManager.Instance.mapVisitedNodesAction.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[1]).ToArray()));
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MapManager), "DrawNodes")]
		public static void DrawNodesPre(ref MapManager __instance, out string[][] __state)
		{
			__state = new string[2][]
			{
				AtOManager.Instance.mapVisitedNodes.ToArray(),
				AtOManager.Instance.mapVisitedNodesAction.ToArray()
			};
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.Clear();
				AtOManager.Instance.mapVisitedNodesAction.Clear();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MapManager), "DrawNodes")]
		public static void DrawNodesPost(ref MapManager __instance, string[][] __state, ref Dictionary<string, Node> ___mapNode)
		{
			if (GameManager.Instance.IsObeliskChallenge() || GameManager.Instance.IsWeeklyChallenge())
			{
				return;
			}
			AtOManager.Instance.mapVisitedNodes.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[0]).ToArray()));
			AtOManager.Instance.mapVisitedNodesAction.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[1]).ToArray()));
			for (int i = 0; i < AtOManager.Instance.mapVisitedNodes.Count; i++)
			{
				if (AtOManager.Instance.mapVisitedNodes[i] != "" && ___mapNode.ContainsKey(AtOManager.Instance.mapVisitedNodes[i]))
				{
					___mapNode[AtOManager.Instance.mapVisitedNodes[i]].SetVisited();
				}
				if (zoneStartNodes.Contains(AtOManager.Instance.mapVisitedNodes[i]))
				{
					break;
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MapManager), "GetMapNodesCo")]
		public static void GetMapNodesCoPre(ref MapManager __instance, out string[][] __state)
		{
			__state = new string[2][]
			{
				AtOManager.Instance.mapVisitedNodes.ToArray(),
				AtOManager.Instance.mapVisitedNodesAction.ToArray()
			};
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.Clear();
				AtOManager.Instance.mapVisitedNodesAction.Clear();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MapManager), "GetMapNodesCo")]
		public static void GetMapNodesCoPost(ref MapManager __instance, string[][] __state)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[0]).ToArray()));
				AtOManager.Instance.mapVisitedNodesAction.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[1]).ToArray()));
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MapManager), "AssignGameNodes")]
		public static void AssignGameNodesPre(ref MapManager __instance, out string[][] __state)
		{
			__state = new string[2][]
			{
				AtOManager.Instance.mapVisitedNodes.ToArray(),
				AtOManager.Instance.mapVisitedNodesAction.ToArray()
			};
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.Clear();
				AtOManager.Instance.mapVisitedNodesAction.Clear();
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MapManager), "AssignGameNodes")]
		public static void AssignGameNodesPost(ref MapManager __instance, string[][] __state)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				AtOManager.Instance.mapVisitedNodes.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[0]).ToArray()));
				AtOManager.Instance.mapVisitedNodesAction.AddRange(new <>z__ReadOnlyArray<string>(new ReadOnlySpan<string>(__state[1]).ToArray()));
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(CinematicManager), "DoCinematic")]
		public static bool DoCinematicPre(ref CinematicManager __instance, ref CinematicData ___cinematicData)
		{
			if (GameManager.Instance.IsObeliskChallenge() || GameManager.Instance.IsWeeklyChallenge())
			{
				return true;
			}
			if (AtOManager.Instance.CinematicId == "intro" && AtOManager.Instance.GetActNumberForText("") > 1)
			{
				GameManager.Instance.ChangeScene("Map");
				return false;
			}
			return true;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(AtOManager), "FinishGame")]
		public static bool FinishGame(ref AtOManager __instance, ref CombatData ___currentCombatData)
		{
			if (GameManager.Instance.IsObeliskChallenge() || GameManager.Instance.IsWeeklyChallenge())
			{
				return true;
			}
			if (___currentCombatData.CombatId == "evoidhigh_13b")
			{
				return false;
			}
			return true;
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MapManager), "SetPositionInCurrentNode")]
		public static void SetPositionInCurrentNode(ref MapManager __instance, ref bool __result)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge() && !__result && AtOManager.Instance.currentMapNode == "voidhigh_13" && AtOManager.Instance.bossesKilledName.Any((string s) => s.StartsWith("archonnihr", StringComparison.OrdinalIgnoreCase)))
			{
				CombatData currentCombatData = AtOManager.Instance.GetCurrentCombatData();
				CombatData combatData = Globals.Instance.GetCombatData((currentCombatData != null) ? currentCombatData.CombatId : null);
				if ((Object)(object)currentCombatData != (Object)(object)combatData)
				{
					AtOManager.Instance.SetCombatData(combatData);
				}
				__result = true;
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(IntroNewGameManager), "DoIntro")]
		public static void DoIntro(ref IntroNewGameManager __instance)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				__instance.title.text = __instance.title.text.Replace(string.Format(Texts.Instance.GetText("actNumber", ""), AtOManager.Instance.GetTownTier() + 2), string.Format(Texts.Instance.GetText("actNumber", ""), AtOManager.Instance.GetActNumberForText("")));
			}
		}

		[HarmonyPostfix]
		[HarmonyPatch(typeof(MenuSaveButton), "SetGameData")]
		public static void SetGameData(ref MenuSaveButton __instance, GameData _gameData)
		{
			if (!GameManager.Instance.IsObeliskChallenge() && !GameManager.Instance.IsWeeklyChallenge())
			{
				__instance.descriptionText.text = __instance.descriptionText.text.Replace(string.Format(Texts.Instance.GetText("actNumber", ""), Math.Min(4, _gameData.TownTier + 1)), string.Format(Texts.Instance.GetText("actNumber", ""), _gameData.TownTier + 1));
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SteamManager), "SetScore")]
		public static bool SetScore()
		{
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SteamManager), "SetObeliskScore")]
		public static bool SetObeliskScore()
		{
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SteamManager), "SetSingularityScore")]
		public static bool SetSingularityScore()
		{
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SteamManager), "SetWeeklyScore")]
		public static bool SetWeeklyScore()
		{
			return false;
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(MatchManager), "CastCardAction")]
		public static void CastCardAction(MatchManager __instance, ref CardData _cardActive, Transform targetTransformCast, ref CardItem theCardItem, string _uniqueCastId, bool _automatic, ref CardData _card, int _cardIterationTotal, int _cardSpecialValueGlobal)
		{
			if (!_automatic)
			{
				if (theCardItem.CardData.KillPet)
				{
					theCardItem.CardData.KillPet = false;
				}
			}
			else if ((Object)(object)_cardActive == (Object)null && (Object)(object)_card != (Object)null)
			{
				if (_card.KillPet)
				{
					_card.KillPet = false;
				}
			}
			else if (_cardActive.KillPet)
			{
				_cardActive.KillPet = false;
			}
		}
	}
	[BepInPlugin("com.corgan.AtOEndless", "AtOEndless", "1.0.0")]
	[BepInProcess("AcrossTheObelisk.exe")]
	public class Plugin : BaseUnityPlugin
	{
		internal int ModDate = int.Parse(DateTime.Today.ToString("yyyyMMdd"));

		private readonly Harmony harmony = new Harmony("com.corgan.AtOEndless");

		internal static ManualLogSource Log;

		public static string debugBase = "com.corgan.AtOEndless ";

		private void Awake()
		{
			Log = ((BaseUnityPlugin)this).Logger;
			Log.LogInfo((object)"com.corgan.AtOEndless 1.0.0 has loaded!");
			LogDebug("Excuting Patches");
			harmony.PatchAll();
		}

		internal static void LogDebug(string msg)
		{
			Log.LogDebug((object)(debugBase + msg));
		}

		internal static void LogInfo(string msg)
		{
			Log.LogInfo((object)(debugBase + msg));
		}

		internal static void LogError(string msg)
		{
			Log.LogError((object)(debugBase + msg));
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "com.corgan.AtOEndless";

		public const string PLUGIN_NAME = "AtOEndless";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => _items.Length;

	T IReadOnlyList<T>.this[int index] => _items[index];

	int ICollection<T>.Count => _items.Length;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			return _items[index];
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlyArray(T[] items)
	{
		_items = items;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return ((IEnumerable)_items).GetEnumerator();
	}

	void ICollection.CopyTo(Array array, int index)
	{
		((ICollection)_items).CopyTo(array, index);
	}

	int IList.Add(object value)
	{
		throw new NotSupportedException();
	}

	void IList.Clear()
	{
		throw new NotSupportedException();
	}

	bool IList.Contains(object value)
	{
		return ((IList)_items).Contains(value);
	}

	int IList.IndexOf(object value)
	{
		return ((IList)_items).IndexOf(value);
	}

	void IList.Insert(int index, object value)
	{
		throw new NotSupportedException();
	}

	void IList.Remove(object value)
	{
		throw new NotSupportedException();
	}

	void IList.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return ((IEnumerable<T>)_items).GetEnumerator();
	}

	void ICollection<T>.Add(T item)
	{
		throw new NotSupportedException();
	}

	void ICollection<T>.Clear()
	{
		throw new NotSupportedException();
	}

	bool ICollection<T>.Contains(T item)
	{
		return ((ICollection<T>)_items).Contains(item);
	}

	void ICollection<T>.CopyTo(T[] array, int arrayIndex)
	{
		((ICollection<T>)_items).CopyTo(array, arrayIndex);
	}

	bool ICollection<T>.Remove(T item)
	{
		throw new NotSupportedException();
	}

	int IList<T>.IndexOf(T item)
	{
		return ((IList<T>)_items).IndexOf(item);
	}

	void IList<T>.Insert(int index, T item)
	{
		throw new NotSupportedException();
	}

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}