using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using AddWatermark;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using HarmonyLib;
using LBoL.Base;
using LBoL.ConfigData;
using LBoL.Core;
using LBoL.Core.Adventures;
using LBoL.Core.Battle;
using LBoL.Core.Battle.BattleActions;
using LBoL.Core.Battle.Interactions;
using LBoL.Core.Cards;
using LBoL.Core.Dialogs;
using LBoL.Core.GapOptions;
using LBoL.Core.Intentions;
using LBoL.Core.Randoms;
using LBoL.Core.SaveData;
using LBoL.Core.Stations;
using LBoL.Core.Stats;
using LBoL.Core.StatusEffects;
using LBoL.Core.Units;
using LBoL.EntityLib.Adventures;
using LBoL.EntityLib.Adventures.FirstPlace;
using LBoL.EntityLib.Adventures.Shared12;
using LBoL.EntityLib.Adventures.Shared23;
using LBoL.EntityLib.Adventures.Stage1;
using LBoL.EntityLib.Adventures.Stage2;
using LBoL.EntityLib.Adventures.Stage3;
using LBoL.EntityLib.EnemyUnits.Character;
using LBoL.EntityLib.EnemyUnits.Opponent;
using LBoL.EntityLib.Exhibits.Adventure;
using LBoL.EntityLib.JadeBoxes;
using LBoL.Presentation;
using LBoL.Presentation.UI.Panels;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using RunLogger.Patches;
using RunLogger.Utils;
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: IgnoresAccessChecksTo("LBoL.Base")]
[assembly: IgnoresAccessChecksTo("LBoL.ConfigData")]
[assembly: IgnoresAccessChecksTo("LBoL.Core")]
[assembly: IgnoresAccessChecksTo("LBoL.EntityLib")]
[assembly: IgnoresAccessChecksTo("LBoL.Presentation")]
[assembly: IgnoresAccessChecksTo("Untitled.ConfigDataBuilder.Base")]
[assembly: AssemblyCompany("RunLogger")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyInformationalVersion("1.0.0+149bf0115bf30addcf4b996722f8bd15a4f852aa")]
[assembly: AssemblyProduct("RunLogger")]
[assembly: AssemblyTitle("RunLogger")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("1.0.0.0")]
[module: UnverifiableCode]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

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

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

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
}
namespace RunLogger
{
	[BepInPlugin("ev.lbol.utils.runLogger", "Run Logger", "1.3.6")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInProcess("LBoL.exe")]
	public class BepinexPlugin : BaseUnityPlugin
	{
		private static readonly Harmony harmony = PInfo.harmony;

		internal static ManualLogSource log;

		internal static ConfigEntry<bool> saveProfileName;

		internal static ConfigEntry<bool> saveFailure;

		private void Awake()
		{
			log = ((BaseUnityPlugin)this).Logger;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			saveProfileName = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Save Profile Name", true, "Save and show profile name when uploaded to LBoL Logs.");
			saveFailure = ((BaseUnityPlugin)this).Config.Bind<bool>("General", "Save Failed Run", true, "Save log for the current run even it failed.");
			harmony.PatchAll();
			if (Chainloader.PluginInfos.ContainsKey("neo.lbol.tools.watermark"))
			{
				WatermarkWrapper.ActivateWatermark();
			}
		}

		private void OnDestroy()
		{
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public static class PInfo
	{
		public const string GUID = "ev.lbol.utils.runLogger";

		public const string Name = "Run Logger";

		public const string version = "1.3.6";

		public static readonly Harmony harmony = new Harmony("ev.lbol.utils.runLogger");
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace RunLogger.Utils
{
	public static class RewardsUtil
	{
		public static void AddReward(StationReward reward)
		{
			AddRewards(new List<StationReward> { reward });
		}

		public static void AddRewards(List<StationReward> rewards)
		{
			//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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Invalid comparison between Unknown and I4
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Invalid comparison between Unknown and I4
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Invalid comparison between Unknown and I4
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Invalid comparison between Unknown and I4
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			if (RunDataController.CurrentStation.Rewards == null)
			{
				RunDataController.CurrentStation.Rewards = new Dictionary<string, object>();
			}
			foreach (StationReward reward in rewards)
			{
				StationRewardType type = reward.Type;
				string key = ((object)(StationRewardType)(ref type)).ToString();
				if ((int)type == 0)
				{
					int money = reward.Money;
					RunDataController.CurrentStation.Rewards[key] = money;
				}
				else if ((int)type == 1 || (int)type == 3)
				{
					List<Card> cards = reward.Cards;
					List<CardObj> cards2 = RunDataController.GetCards(cards);
					StationRewardType val = (StationRewardType)1;
					RunDataController.AddListItem2Obj(((object)(StationRewardType)(ref val)).ToString(), cards2);
				}
				else if ((int)type == 2)
				{
					string id = ((GameEntity)reward.Exhibit).Id;
					RunDataController.AddListItem2Obj(key, id);
				}
			}
		}
	}
	public class RunData
	{
		public string Version { get; set; }

		public string? Name { get; set; }

		public Settings Settings { get; set; }

		public List<StationObj> Stations { get; set; } = new List<StationObj>();


		public List<ActObj> Acts { get; set; } = new List<ActObj>();


		public List<CardChange> Cards { get; set; } = new List<CardChange>();


		public List<ExhibitChange> Exhibits { get; set; } = new List<ExhibitChange>();


		public Result Result { get; set; }
	}
	public class Settings
	{
		public string Character { get; set; }

		public string PlayerType { get; set; }

		public bool HasClearBonus { get; set; }

		public bool ShowRandomResult { get; set; }

		public bool IsAutoSeed { get; set; }

		public string Difficulty { get; set; }

		public List<string> Requests { get; set; }

		public List<string>? JadeBoxes { get; set; }

		public List<Mod> Mods { get; set; }

		public Status Status { get; set; }
	}
	public class Mod
	{
		public string GUID { get; set; }

		public string Name { get; set; }

		public string Version { get; set; }
	}
	public class StationObj
	{
		public string Type { get; set; }

		public NodeObj Node { get; set; }

		public Status Status { get; set; }

		public Dictionary<string, object> Data { get; set; }

		public string? Id { get; set; }

		public Dictionary<string, object>? Rewards { get; set; }
	}
	public class NodeObj
	{
		public int Act { get; set; }

		public int Level { get; set; }

		public int Y { get; set; }
	}
	public class Status
	{
		public int Money { get; set; }

		public int Hp { get; set; }

		public int MaxHp { get; set; }

		public int Power { get; set; }

		public int MaxPower { get; set; }
	}
	public class CardObj
	{
		public string Id { get; set; }

		public bool IsUpgraded { get; set; }

		public int? UpgradeCounter { get; set; }
	}
	public class CardWithPrice : CardObj
	{
		public int? Price { get; set; }

		public bool? IsDiscounted { get; set; }
	}
	public class ActObj
	{
		public int Act { get; set; }

		public List<Node> Nodes { get; set; } = new List<Node>();


		public string Boss { get; set; }
	}
	public class Node
	{
		public int X { get; set; }

		public int Y { get; set; }

		public List<int> Followers { get; set; } = new List<int>();


		public string Type { get; set; }
	}
	public class TurnObj
	{
		public int Round { get; set; }

		public int Turn { get; set; }

		public string Id { get; set; }

		public List<CardObj>? Cards { get; set; }

		public List<IntentionObj>? Intentions { get; set; }

		public BattleStatusObj Status { get; set; }

		public List<StatusEffectObj> StatusEffects { get; set; }
	}
	public class IntentionObj
	{
		public string Type { get; set; }

		public int? Damage { get; set; }

		public int? Times { get; set; }

		public bool? IsAccurate { get; set; }
	}
	public class BattleStatusObj
	{
		public int Hp { get; set; }

		public int Block { get; set; }

		public int Barrier { get; set; }

		public int? Power { get; set; }
	}
	public class StatusEffectObj
	{
		public string Id { get; set; }

		public int? Level { get; set; }

		public int? Duration { get; set; }

		public int? Count { get; set; }

		public int? Limit { get; set; }
	}
	public class CardChange : CardObj
	{
		public string Type { get; set; }

		public int Station { get; set; }
	}
	public class ExhibitChange
	{
		public string Id { get; set; }

		public int? Counter { get; set; }

		public string Type { get; set; }

		public int Station { get; set; }
	}
	public enum ChangeType
	{
		Add,
		Remove,
		Upgrade,
		Use
	}
	public class Result
	{
		public string Type { get; set; }

		public string Timestamp { get; set; }

		public List<CardObj> Cards { get; set; }

		public List<string> Exhibits { get; set; }

		public string BaseMana { get; set; }

		public int ReloadTimes { get; set; }

		public string Seed { get; set; }
	}
	public static class RunDataController
	{
		private const string _dir = "runLogger";

		private static readonly string _path = Path.Join((ReadOnlySpan<char>)"runLogger", (ReadOnlySpan<char>)"temp.txt");

		private static bool _initialized;

		public static RunData RunData;

		public static List<CardObj> Cards;

		public static List<string> Exhibits;

		public static string[] enemiesShowDetails = new string[1] { "Seija" };

		public static StationObj CurrentStation
		{
			get
			{
				if (RunData == null)
				{
					return null;
				}
				return RunData.Stations.LastOrDefault();
			}
		}

		public static int CurrentStationIndex => RunData.Stations.Count - 1;

		public static bool ShowRandom => RunData.Settings.ShowRandomResult;

		public static void GetData(out Dictionary<string, object> Data)
		{
			Data = CurrentStation.Data;
			if (Data == null)
			{
				Dictionary<string, object> dictionary2 = (CurrentStation.Data = new Dictionary<string, object>());
				Data = dictionary2;
			}
		}

		public static void AddData<T>(string key, T value)
		{
			GetData(out var Data);
			Data.Add(key, value);
		}

		public static void AddDataItem<T>(string key, T item)
		{
			GetData(out var Data);
			object value;
			List<T> list = (Data.TryGetValue(key, out value) ? ((List<T>)value) : new List<T>());
			list.Add(item);
			Data[key] = list;
		}

		public static void AddPrice(string key, int price)
		{
			GetData(out var Data);
			Data.TryGetValue("Prices", out var value);
			Dictionary<string, int> dictionary = value as Dictionary<string, int>;
			dictionary.Add(key, price);
		}

		public static void AddListItem2Obj<T>(string key, T listItem)
		{
			key += "s";
			if (!CurrentStation.Rewards.ContainsKey(key))
			{
				CurrentStation.Rewards[key] = new List<T>();
			}
			(CurrentStation.Rewards[key] as List<T>).Add(listItem);
		}

		public static void AddCardChange(IEnumerable<Card> cards, ChangeType Type)
		{
			foreach (Card card in cards)
			{
				CardChange item = new CardChange
				{
					Id = ((GameEntity)card).Id,
					IsUpgraded = card.IsUpgraded,
					UpgradeCounter = card.UpgradeCounter,
					Type = Type.ToString(),
					Station = CurrentStationIndex
				};
				RunData.Cards.Add(item);
			}
		}

		public static void AddExhibitChange(Exhibit exhibit, ChangeType Type, int? Counter = null)
		{
			if (RunData != null)
			{
				ExhibitChange exhibitChange = new ExhibitChange
				{
					Id = ((GameEntity)exhibit).Id,
					Type = Type.ToString(),
					Station = CurrentStationIndex
				};
				if (Counter.HasValue)
				{
					exhibitChange.Counter = Counter;
				}
				RunData.Exhibits.Add(exhibitChange);
			}
		}

		public static CardObj GetCard(Card card)
		{
			return new CardObj
			{
				Id = ((GameEntity)card).Id,
				IsUpgraded = card.IsUpgraded,
				UpgradeCounter = card.UpgradeCounter
			};
		}

		public static List<CardObj> GetCards(IEnumerable<Card> cards)
		{
			return cards.Select((Card card) => GetCard(card)).ToList();
		}

		public static CardWithPrice GetCardWithPrice(Card card, int? price = null)
		{
			return new CardWithPrice
			{
				Id = ((GameEntity)card).Id,
				IsUpgraded = card.IsUpgraded,
				UpgradeCounter = card.UpgradeCounter,
				Price = price
			};
		}

		public static string GetBaseMana(string baseMana, IEnumerable<string> exhibits)
		{
			//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_0023: Invalid comparison between Unknown and I4
			foreach (string exhibit in exhibits)
			{
				ExhibitConfig val = ExhibitConfig.FromId(exhibit);
				Rarity rarity = val.Rarity;
				if ((int)rarity == 3 && !val.BaseManaColor.HasValue)
				{
					baseMana += "A";
				}
			}
			return baseMana;
		}

		public static string GetEnemyGroupId(Station station)
		{
			BattleStation val = (BattleStation)(object)((station is BattleStation) ? station : null);
			if (val != null)
			{
				EnemyGroup enemyGroup = val.EnemyGroup;
				return enemyGroup.Id;
			}
			return null;
		}

		public static string GetAdventureId(Station station)
		{
			AdventureStation val = (AdventureStation)(object)((station is AdventureStation) ? station : null);
			if (val != null)
			{
				Adventure adventure = val.Adventure;
				return adventure.Id;
			}
			EntryStation val2 = (EntryStation)(object)((station is EntryStation) ? station : null);
			if (val2 != null)
			{
				Adventure adventure = val2.DebutAdventure;
				if (adventure == null)
				{
					return null;
				}
				return adventure.Id;
			}
			TradeStation val3 = (TradeStation)(object)((station is TradeStation) ? station : null);
			if (val3 != null)
			{
				Adventure adventure = val3.Adventure;
				return adventure.Id;
			}
			return null;
		}

		public static List<T> GetList<T>(DialogStorage storage, IEnumerable<int> keys, string prefix, string suffix = "")
		{
			List<T> list = new List<T>();
			object obj = default(object);
			foreach (int key in keys)
			{
				string text = $"{prefix}{key}{suffix}";
				storage.TryGetValue<object>(text, ref obj);
				list.Add((T)obj);
			}
			return list;
		}

		public static void Reset()
		{
			InteractionViewerPatch.Listener = null;
			StationPatch.RewardListener = null;
			StationPatch.AddRewardsPatch.isAfterAddRewards = false;
			GameRunControllerPatch.isAfterBossReward = false;
		}

		public static void Create()
		{
			RunData = new RunData();
			_initialized = true;
			Save();
		}

		public static void Save(bool indent = true)
		{
			if (_initialized)
			{
				string line = _Encode(indent);
				_Write(line);
			}
		}

		public static bool Restore()
		{
			_CheckDirectory();
			if (!File.Exists(_path))
			{
				_initialized = false;
				return false;
			}
			using (FileStream stream = File.Open(_path, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
			{
				using StreamReader streamReader = new StreamReader(stream);
				string jsonString = streamReader.ReadToEnd();
				_Decode(jsonString);
			}
			return _initialized;
		}

		public static void Copy(string name)
		{
			if (_initialized)
			{
				Save(indent: false);
				File.Copy(_path, Path.Join((ReadOnlySpan<char>)"runLogger", (ReadOnlySpan<char>)(name + ".json")));
				_initialized = false;
			}
		}

		private static void _Write(string line)
		{
			_CheckDirectory();
			if (!_initialized)
			{
				return;
			}
			using FileStream stream = File.Open(_path, FileMode.Create, FileAccess.Write, FileShare.ReadWrite);
			using StreamWriter streamWriter = new StreamWriter(stream, Encoding.UTF8);
			streamWriter.WriteLine(line);
		}

		private static void _CheckDirectory()
		{
			if (!Directory.Exists("runLogger"))
			{
				Directory.CreateDirectory("runLogger");
			}
		}

		private static string _Encode(bool indent = true)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			return JsonConvert.SerializeObject((object)RunData, (Formatting)(indent ? 1 : 0), new JsonSerializerSettings
			{
				NullValueHandling = (NullValueHandling)1
			});
		}

		private static void _Decode(string jsonString)
		{
			try
			{
				if (!string.IsNullOrEmpty(jsonString))
				{
					RunData = JsonConvert.DeserializeObject<RunData>(jsonString);
					_initialized = true;
					return;
				}
			}
			finally
			{
			}
			_initialized = false;
		}
	}
}
namespace RunLogger.Patches
{
	[HarmonyPatch(typeof(Adventure))]
	public static class AdventurePatch
	{
		[HarmonyPatch(typeof(Debut))]
		public static class DebutPatch
		{
			[HarmonyPatch(typeof(DialogRunner), "SelectOption")]
			public static class SelectOptionPatch
			{
				public static void Prefix(int id)
				{
					if (uncommonCardListener == 1 && id == 0)
					{
						uncommonCardListener = 2;
					}
				}

				public static void Postfix()
				{
					uncommonCardListener = 0;
				}
			}

			public static int uncommonCardListener;

			[HarmonyPatch("RollBonus")]
			public static void Postfix(Exhibit ____exhibit, int[] ____bonusNos, Debut __instance)
			{
				uncommonCardListener = 0;
				if (!RunDataController.RunData.Settings.HasClearBonus)
				{
					return;
				}
				RunDataController.AddData("Options", ____bonusNos);
				if (!RunDataController.ShowRandom)
				{
					return;
				}
				DialogStorage storage = ((Adventure)__instance).Storage;
				RunDataController.AddData("Shining", ((GameEntity)____exhibit).Id);
				int[] array = ____bonusNos;
				string value3 = default(string);
				string value2 = default(string);
				string value = default(string);
				for (int i = 0; i < array.Length; i++)
				{
					switch (array[i])
					{
					case 0:
					{
						List<string> list = RunDataController.GetList<string>(storage, new int[3] { 1, 2, 3 }, "$uncommonCard");
						RunDataController.AddData("UncommonCards", list);
						uncommonCardListener = 1;
						break;
					}
					case 1:
						storage.TryGetValue<string>("$rareCard", ref value3);
						RunDataController.AddData("RareCard", value3);
						break;
					case 2:
						storage.TryGetValue<string>("$rareExhibit", ref value2);
						RunDataController.AddData("RareExhibit", value2);
						break;
					case 5:
						storage.TryGetValue<string>("$transformCard", ref value);
						RunDataController.AddData("TransformCard", value);
						break;
					}
				}
			}
		}

		[HarmonyPatch(typeof(Supply))]
		public static class SupplyPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(Supply __instance)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				string text = default(string);
				storage.TryGetValue<string>("$exhibitA", ref text);
				string text2 = default(string);
				storage.TryGetValue<string>("$exhibitB", ref text2);
				RunDataController.AddData("Exhibits", new string[2] { text, text2 });
				bool value = default(bool);
				storage.TryGetValue<bool>("$bothFlag", ref value);
				RunDataController.AddData("Both", value);
			}
		}

		[HarmonyPatch(typeof(RinnosukeTrade))]
		public static class RinnosukeTradePatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(Supply __instance)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				bool flag = default(bool);
				storage.TryGetValue<bool>("$canSell1", ref flag);
				bool flag2 = default(bool);
				storage.TryGetValue<bool>("$canSell2", ref flag2);
				if (flag)
				{
					Dictionary<string, int> dictionary = new Dictionary<string, int>();
					string key = default(string);
					storage.TryGetValue<string>("$exhibit1", ref key);
					float num = default(float);
					storage.TryGetValue<float>("$exhibit1Price", ref num);
					dictionary.Add(key, (int)num);
					if (flag2)
					{
						string key2 = default(string);
						storage.TryGetValue<string>("$exhibit2", ref key2);
						float num2 = default(float);
						storage.TryGetValue<float>("$exhibit2Price", ref num2);
						dictionary.Add(key2, (int)num2);
					}
					RunDataController.AddData("Prices", dictionary);
				}
			}
		}

		[HarmonyPatch(typeof(DoremyPortal))]
		public static class DoremyPortalPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(DoremyPortal __instance)
			{
				if (RunDataController.ShowRandom)
				{
					string value = default(string);
					((Adventure)__instance).Storage.TryGetValue<string>("$randomExhibit", ref value);
					RunDataController.AddData("Exhibit", value);
				}
			}
		}

		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		public static class SelectBaseManaInteractionPatch
		{
			private static void Prefix(ManaGroup value)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0002: Unknown result type (might be due to invalid IL or missing references)
				//IL_0005: Unknown result type (might be due to invalid IL or missing references)
				ManaGroup val = value;
				string value2 = ManaColorExtensions.ToShortName(((ManaGroup)(ref val)).MaxColor).ToString();
				RunDataController.AddData("Color", value2);
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				return instructions;
			}
		}

		[HarmonyPatch(typeof(MiyoiBartender))]
		public static class MiyoiBartenderPatch
		{
			private static string exhibit;

			[HarmonyPatch("InitVariables")]
			public static void Prefix(MiyoiBartender __instance)
			{
				UniqueRandomPool<string> enemyPoolAct = ((Adventure)__instance).Stage.EnemyPoolAct3;
				List<string> value = ((IEnumerable<RandomPoolEntry<string>>)enemyPoolAct).Select((RandomPoolEntry<string> e) => e.Elem).ToList();
				RunDataController.AddData("Ids", value);
			}

			[HarmonyPatch("InitVariables")]
			public static void Postfix(MiyoiBartender __instance)
			{
				string value = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$randomExhibit", ref value);
				if (RunDataController.ShowRandom)
				{
					RunDataController.AddData("Exhibit", value);
				}
				else
				{
					exhibit = value;
				}
			}

			public static void HandleBattle()
			{
				if (exhibit != null)
				{
					RunDataController.AddData("Exhibit", exhibit);
					exhibit = null;
				}
			}
		}

		[HarmonyPatch(typeof(SumirekoGathering))]
		public static class SumirekoGatheringPatch
		{
			private static List<string> rareCards;

			[HarmonyPatch("InitVariables")]
			public static void Postfix(SumirekoGathering __instance)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				rareCards = RunDataController.GetList<string>(storage, new int[3] { 1, 2, 3 }, "$rareTrade");
				string text = default(string);
				storage.TryGetValue<string>("$rareCard1", ref text);
				if (text != null)
				{
					bool isUpgraded = default(bool);
					storage.TryGetValue<bool>("$isUpgraded", ref isUpgraded);
					CardObj value = new CardObj
					{
						Id = text,
						IsUpgraded = isUpgraded
					};
					RunDataController.AddData("Card", value);
					RunDataController.AddData("Cards", rareCards);
					InteractionViewerPatch.Listener = "SumirekoGathering";
				}
			}

			[HarmonyPatch(typeof(DialogFunctions), "HasMoney")]
			[HarmonyPostfix]
			public static void HasMoneyPatch(bool __result, GameRunController ____gameRun)
			{
				Station currentStation = ____gameRun.CurrentStation;
				string adventureId = RunDataController.GetAdventureId(currentStation);
				if (adventureId != null && !(adventureId != "SumirekoGathering"))
				{
					RunDataController.AddData("HasMoney", __result);
					if (__result && !RunDataController.CurrentStation.Data.TryGetValue("Cards", out var _))
					{
						RunDataController.AddData("Cards", rareCards);
						InteractionViewerPatch.Listener = "SumirekoGathering";
					}
				}
			}
		}

		[HarmonyPatch(typeof(ShinmyoumaruForge))]
		public static class ShinmyoumaruForgePatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(ShinmyoumaruForge __instance)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				bool value = default(bool);
				storage.TryGetValue<bool>("$hasUpgradableBasics", ref value);
				RunDataController.AddData("HasUpgradableBasics", value);
				bool value2 = default(bool);
				storage.TryGetValue<bool>("$hasNonBasics", ref value2);
				RunDataController.AddData("HasNonBasics", value2);
				float num = default(float);
				storage.TryGetValue<float>("$loseMax", ref num);
				RunDataController.AddData("LoseMax", (int)num);
			}
		}

		[HarmonyPatch(typeof(WatatsukiPurify))]
		public static class WatatsukiPurifyPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(WatatsukiPurify __instance)
			{
				float num = default(float);
				((Adventure)__instance).Storage.TryGetValue<float>("$loseMax", ref num);
				RunDataController.AddData("LoseMax", (int)num);
			}
		}

		[HarmonyPatch(typeof(HinaCollect))]
		public static class HinaCollectPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(HinaCollect __instance)
			{
				if (RunDataController.ShowRandom)
				{
					string value = default(string);
					((Adventure)__instance).Storage.TryGetValue<string>("$card", ref value);
					RunDataController.AddData("Card", value);
				}
			}
		}

		[HarmonyPatch(typeof(KosuzuBookstore))]
		public static class KosuzuBookstorePatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(KosuzuBookstore __instance)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				bool flag = default(bool);
				storage.TryGetValue<bool>("$thirdBook", ref flag);
				string item = default(string);
				storage.TryGetValue<string>("$book0", ref item);
				string item2 = default(string);
				storage.TryGetValue<string>("$book1", ref item2);
				List<string> list = new List<string> { item, item2 };
				if (flag)
				{
					string item3 = default(string);
					storage.TryGetValue<string>("$book2", ref item3);
					list.Add(item3);
				}
				RunDataController.AddData("Exhibits", list);
				float num = default(float);
				storage.TryGetValue<float>("$returnBookCount", ref num);
				int num2 = (int)num;
				if (num2 > 0)
				{
					List<string> list2 = RunDataController.GetList<string>(storage, Enumerable.Range(0, num2), "$returnBook");
					RunDataController.AddData("Returns", list2);
				}
			}
		}

		[HarmonyPatch(typeof(NarumiOfferCard))]
		public static class NarumiOfferCardPatch
		{
			public static bool isNarumi;

			[HarmonyPatch("OfferDeckCard")]
			public static void Prefix()
			{
				isNarumi = true;
			}

			[HarmonyPatch(typeof(GameRunController), "RemoveDeckCards")]
			[HarmonyPostfix]
			public static void RemoveDeckCardsPatch(IEnumerable<Card> cards)
			{
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Invalid comparison between Unknown and I4
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				if (isNarumi)
				{
					Card val = cards.First();
					string value;
					if ((int)val.CardType == 8)
					{
						CardType val2 = (CardType)8;
						value = ((object)(CardType)(ref val2)).ToString();
					}
					else
					{
						Rarity rarity = val.Config.Rarity;
						value = ((object)(Rarity)(ref rarity)).ToString();
					}
					RunDataController.AddData("Type", value);
					isNarumi = false;
				}
			}
		}

		[HarmonyPatch]
		public static class NazrinDetectPatch
		{
			[HarmonyPatch(typeof(NazrinDetectPanel), "Roll")]
			[HarmonyPostfix]
			public static void RollPatch(int resultIndex)
			{
				RunDataController.AddData("Result", resultIndex);
			}
		}

		[HarmonyPatch]
		public static class HecatiaTshirtPatch
		{
			[HarmonyPatch(typeof(GameRunController), "GainExhibitRunner")]
			[HarmonyPostfix]
			[HarmonyPriority(1)]
			private static void GainExhibitRunnerPatch(Exhibit exhibit)
			{
				if (exhibit is IdolTshirt)
				{
					int counter = exhibit.Counter;
					if (counter > 2)
					{
						RunDataController.AddExhibitChange(exhibit, ChangeType.Upgrade, counter);
					}
				}
			}
		}

		[HarmonyPatch(typeof(KeineSales))]
		public static class KeineSalesPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(KeineSales __instance)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				float num = default(float);
				storage.TryGetValue<float>("$stageNo", ref num);
				List<int> list = new List<int> { 1 };
				if (num > 1f)
				{
					list.Add(2);
				}
				List<int> value = (from question in RunDataController.GetList<float>(storage, list, "$question", "No")
					select (int)question).ToList();
				RunDataController.AddData("Questions", value);
			}
		}

		[HarmonyPatch(typeof(MikeInvest))]
		public static class MikeInvestPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(MikeInvest __instance)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				float num = default(float);
				storage.TryGetValue<float>("$longMoney", ref num);
				RunDataController.AddData("Money", (int)num);
				if (RunDataController.ShowRandom)
				{
					string value = default(string);
					storage.TryGetValue<string>("$cardReward", ref value);
					RunDataController.AddData("Card", value);
				}
			}
		}

		[HarmonyPatch(typeof(YoumuDelivery))]
		public static class YoumuDeliveryPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(YoumuDelivery __instance)
			{
				if (RunDataController.ShowRandom)
				{
					string value = default(string);
					((Adventure)__instance).Storage.TryGetValue<string>("$transformCard", ref value);
					RunDataController.AddData("Card", value);
				}
			}
		}

		[HarmonyPatch(typeof(RemiliaMeet))]
		public static class RemiliaMeetPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(RemiliaMeet __instance)
			{
				bool value = default(bool);
				((Adventure)__instance).Storage.TryGetValue<bool>("$hasExhibit", ref value);
				RunDataController.AddData("HasExhibit", value);
			}
		}

		[HarmonyPatch(typeof(RingoEmp))]
		public static class RingoEmpPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(RingoEmp __instance)
			{
				if (RunDataController.ShowRandom)
				{
					DialogStorage storage = ((Adventure)__instance).Storage;
					List<string> list = RunDataController.GetList<string>(storage, new int[3] { 1, 2, 3 }, "$tool");
					RunDataController.AddData("Cards", list);
				}
			}
		}

		[HarmonyPatch(typeof(YachieOppression))]
		public static class YachieOppressionPatch
		{
			private static string exhibit;

			[HarmonyPatch("InitVariables")]
			public static void Postfix(YachieOppression __instance)
			{
				string value = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$enemyExhibit", ref value);
				if (RunDataController.ShowRandom)
				{
					RunDataController.AddData("Exhibit", value);
				}
				else
				{
					exhibit = value;
				}
			}

			public static void HandleBattle()
			{
				if (exhibit != null)
				{
					RunDataController.AddData("Exhibit", exhibit);
					exhibit = null;
				}
			}
		}

		[HarmonyPatch(typeof(AssistKagerou))]
		public static class AssistKagerouPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(AssistKagerou __instance)
			{
				if (RunDataController.ShowRandom)
				{
					string value = default(string);
					((Adventure)__instance).Storage.TryGetValue<string>("$exhibitReward", ref value);
					RunDataController.AddData("Exhibit", value);
				}
			}
		}

		[HarmonyPatch(typeof(EternityAscension))]
		public static class EternityAscensionPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(EternityAscension __instance)
			{
				if (RunDataController.ShowRandom)
				{
					string value = default(string);
					((Adventure)__instance).Storage.TryGetValue<string>("$transformCard", ref value);
					RunDataController.AddData("Card", value);
				}
			}
		}

		[HarmonyPatch(typeof(KaguyaVersusMokou))]
		public static class KaguyaVersusMokouPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(KaguyaVersusMokou __instance)
			{
				float num = default(float);
				((Adventure)__instance).Storage.TryGetValue<float>("$hpLose", ref num);
				float num2 = default(float);
				((Adventure)__instance).Storage.TryGetValue<float>("$hpLoseLow", ref num2);
				RunDataController.AddData("Hps", new int[2]
				{
					(int)num,
					(int)num2
				});
			}
		}

		[HarmonyPatch(typeof(ParseeJealousy))]
		public static class ParseeJealousyPatch
		{
			[HarmonyPatch("InitVariables")]
			public static void Postfix(ParseeJealousy __instance)
			{
				if (RunDataController.ShowRandom)
				{
					string value = default(string);
					((Adventure)__instance).Storage.TryGetValue<string>("$exhibitPassBy", ref value);
					RunDataController.AddData("Exhibit", value);
				}
			}

			[HarmonyPatch("GetExhibit")]
			[HarmonyPostfix]
			public static void GetExhibitPatch(ParseeJealousy __instance)
			{
				string text = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$exhibit", ref text);
				string text2 = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$exhibit2", ref text2);
				RunDataController.AddData("Exhibits", new string[2] { text, text2 });
			}
		}

		[HarmonyPatch(typeof(BackgroundDancers))]
		public static class BackgroundDancersPatch
		{
			public const string line = "line:033d1fd";

			private static BackgroundDancers instance;

			private static int i;

			[HarmonyPatch("InitVariables")]
			public static void Postfix(BackgroundDancers __instance)
			{
				i = -1;
				float num = default(float);
				((Adventure)__instance).Storage.TryGetValue<float>("$hpLose", ref num);
				RunDataController.AddData("Hp", (int)num);
			}

			[HarmonyPatch("RollOptions")]
			[HarmonyPostfix]
			public static void RollOptionsPatch(BackgroundDancers __instance, int[] ____optionIndices)
			{
				RunDataController.AddData("Options", ____optionIndices.ToList());
				foreach (int option in ____optionIndices)
				{
					HandleRandom(__instance, option);
				}
			}

			[HarmonyPatch("SelectOption")]
			[HarmonyPostfix]
			public static void SelectOptionPatch(BackgroundDancers __instance, int index)
			{
				i = index - 1;
				instance = __instance;
			}

			public static void HandleOptions()
			{
				if (i != -1)
				{
					int num = instance._optionIndices[i];
					RunDataController.AddDataItem("Options", num);
					HandleRandom(instance, num);
					i = -1;
				}
			}

			private static void HandleRandom(BackgroundDancers __instance, int option)
			{
				if (RunDataController.ShowRandom)
				{
					DialogStorage storage = ((Adventure)__instance).Storage;
					switch (option)
					{
					case 0:
					case 2:
					case 3:
						break;
					case 1:
					{
						string text = default(string);
						storage.TryGetValue<string>("$reward2Rare", ref text);
						string text2 = default(string);
						storage.TryGetValue<string>("$reward2Rare2", ref text2);
						RunDataController.AddDataItem("Tools", new string[2] { text, text2 });
						break;
					}
					case 4:
					{
						string item2 = default(string);
						storage.TryGetValue<string>("$reward5Exhibit", ref item2);
						RunDataController.AddDataItem("Exhibits", item2);
						break;
					}
					case 5:
					{
						string item = default(string);
						storage.TryGetValue<string>("$reward6Ability", ref item);
						RunDataController.AddDataItem("Abilities", item);
						break;
					}
					}
				}
			}
		}

		[HarmonyPatch(typeof(SatoriCounseling))]
		public static class SatoriCounselingPatch
		{
			public const string lineValid = "line:0f753ad";

			public const string lineInvalid = "line:02f3a36";

			public static bool isMini;

			[HarmonyPatch("Library")]
			[HarmonyPostfix]
			public static void LibraryPatch()
			{
				InteractionViewerPatch.Listener = "SatoriCounseling";
				isMini = false;
			}

			[HarmonyPatch("Analyse")]
			[HarmonyPostfix]
			public static void AnalysePatch()
			{
				InteractionViewerPatch.Listener = "SatoriCounseling";
				isMini = true;
			}
		}

		[HarmonyPatch(typeof(BuduSuanming))]
		public static class BuduSuanmingPatch
		{
			public const string lineBoss = "line:0b5f8ae";

			public const string lineEvent = "line:0607cc8";

			public const string lineExhibit = "line:02c2c1f";

			public static string boss;

			public static string host;

			public static string exhibit;

			[HarmonyPatch("InitVariables")]
			public static void Postfix(BuduSuanming __instance)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				storage.TryGetValue<string>("$bossId", ref boss);
				storage.TryGetValue<string>("$hostId", ref host);
				storage.TryGetValue<string>("$seijaItem", ref exhibit);
			}
		}

		[HarmonyPatch("InitVariables")]
		public static void Postfix(Adventure __instance)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			string id = __instance.Id;
			string[] source = new string[2] { "JunkoColorless", "PatchouliPhilosophy" };
			if (source.Contains(id))
			{
				GameRunController gameRun = __instance.GameRun;
				string[] exhibits = gameRun.ExhibitRecord.ToArray();
				ManaGroup baseMana = gameRun.BaseMana;
				string baseMana2 = RunDataController.GetBaseMana(((object)(ManaGroup)(ref baseMana)).ToString(), exhibits);
				RunDataController.AddData("BaseMana", baseMana2);
			}
		}
	}
	[HarmonyPatch(typeof(Cirno))]
	public static class CirnoPatch
	{
		[HarmonyPatch("SetNextBuff")]
		[HarmonyPrefix]
		private static void SetNextBuffPatch(Cirno __instance)
		{
			Type nextBuff = __instance.NextBuff;
			if (!(nextBuff == null))
			{
				string name = nextBuff.Name;
				int nextLevel = __instance.NextLevel;
				StatusEffectObj item = new StatusEffectObj
				{
					Id = name,
					Level = nextLevel
				};
				RunDataController.AddDataItem("Teammates", item);
			}
		}
	}
	internal class DialogPatch
	{
		[HarmonyPatch(typeof(DialogRunner))]
		private class DialogRunnerPatch
		{
			[HarmonyPatch("SelectOption")]
			[HarmonyPostfix]
			private static void SelectOptionPatch(int id)
			{
				RunDataController.AddDataItem("Choices", id);
			}
		}

		[HarmonyPatch(typeof(DialogFunctions))]
		private class DialogFunctionsPatch
		{
			[HarmonyPatch("AdventureRand")]
			[HarmonyPostfix]
			private static void AdventureRandPatch(int __result)
			{
				RunDataController.AddDataItem("Values", __result);
			}
		}

		[HarmonyPatch(typeof(DialogLinePhase))]
		private class DialogLinePhasePatch
		{
			[HarmonyPatch("GetLocalizedText")]
			[HarmonyPostfix]
			private static void GetLocalizedTextPatch(string ____lineId)
			{
				switch (____lineId)
				{
				case "line:0f753ad":
					RunDataController.AddData("HasMoney", value: true);
					break;
				case "line:02f3a36":
					RunDataController.AddData("HasMoney", value: false);
					break;
				case "line:0b5f8ae":
					RunDataController.AddData("Boss", AdventurePatch.BuduSuanmingPatch.boss);
					break;
				case "line:0607cc8":
					RunDataController.AddData("Host", AdventurePatch.BuduSuanmingPatch.host);
					break;
				case "line:02c2c1f":
					RunDataController.AddData("Exhibit", AdventurePatch.BuduSuanmingPatch.exhibit);
					break;
				}
			}
		}

		[HarmonyPatch(typeof(DialogOption))]
		private class DialogOptionPatch
		{
			[HarmonyPatch("GetLocalizedText")]
			[HarmonyPostfix]
			private static void GetLocalizedTextPatch(string ____lineId)
			{
				if (____lineId == "line:033d1fd")
				{
					AdventurePatch.BackgroundDancersPatch.HandleOptions();
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameMaster))]
	internal class GameMasterPatch
	{
		[HarmonyPatch("AppendGameRunHistory")]
		[HarmonyPostfix]
		private static void AppendGameRunHistoryPatch(GameRunRecordSaveData record)
		{
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			if (RunDataController.Restore())
			{
				string text = ((object)(GameResultType)(ref record.ResultType)).ToString();
				string saveTimestamp = record.SaveTimestamp;
				List<CardObj> cards = record.Cards.Select((CardRecordSaveData card) => new CardObj
				{
					Id = card.Id,
					IsUpgraded = card.Upgraded,
					UpgradeCounter = card.UpgradeCounter
				}).ToList();
				List<string> list = record.Exhibits.ToList();
				string baseMana = RunDataController.GetBaseMana(record.BaseMana, list);
				int reloadTimes = record.ReloadTimes;
				string seed = RandomGen.SeedToString(record.Seed);
				Result result = new Result
				{
					Type = text,
					Timestamp = saveTimestamp,
					Cards = cards,
					Exhibits = list,
					BaseMana = baseMana,
					ReloadTimes = reloadTimes,
					Seed = seed
				};
				RunDataController.RunData.Result = result;
				RunDataController.Save();
				string text2 = saveTimestamp.Replace(":", "-");
				string player = record.Player;
				string text3 = record.PlayerType.ToString().Replace("Type", "");
				string text4 = list[0];
				Settings settings = RunDataController.RunData.Settings;
				char c = settings.Difficulty[0];
				int count = settings.Requests.Count;
				string name = string.Join("_", text2, player, text3, text4, $"{c}{count}", text);
				bool value = BepinexPlugin.saveFailure.Value;
				GameResultType val = (GameResultType)0;
				bool flag = text == ((object)(GameResultType)(ref val)).ToString();
				if (value || !flag)
				{
					RunDataController.Copy(name);
				}
			}
		}
	}
	[HarmonyPatch(typeof(GameRunController))]
	internal static class GameRunControllerPatch
	{
		public static bool isAfterBossReward;

		public static bool isOverridingStartingDeck;

		public static IEnumerable<Card> startingDeckOverride;

		public static IEnumerable<Card> startingCards;

		public static List<Exhibit> startingExhibits = new List<Exhibit>();

		private static void ResetStartingDeckOverride()
		{
			isOverridingStartingDeck = false;
			startingDeckOverride = null;
		}

		[HarmonyPatch("Create")]
		[HarmonyPrefix]
		private static void PreCreatePatch()
		{
			ResetStartingDeckOverride();
		}

		[HarmonyPatch("Create")]
		[HarmonyPostfix]
		private static void CreatePatch(GameRunStartupParameters parameters, GameRunController __result)
		{
			//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_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			RunDataController.Reset();
			string id = ((GameEntity)parameters.Player).Id;
			PlayerType playerType = parameters.PlayerType;
			string playerType2 = ((object)(PlayerType)(ref playerType)).ToString().Replace("Type", "");
			bool hasClearBonus = __result.HasClearBonus;
			bool showRandomResult = parameters.ShowRandomResult;
			bool isAutoSeed = __result.IsAutoSeed;
			GameDifficulty difficulty = parameters.Difficulty;
			string difficulty2 = ((object)(GameDifficulty)(ref difficulty)).ToString();
			IEnumerable<PuzzleFlag> source = PuzzleFlags.EnumerateComponents(parameters.Puzzles);
			List<string> requests = source.Select((PuzzleFlag puzzleFlag) => ((object)(PuzzleFlag)(ref puzzleFlag)).ToString()).ToList();
			List<string> list = parameters.JadeBoxes.Select((JadeBox JadeBox) => ((GameEntity)JadeBox).Id).ToList();
			Dictionary<string, PluginInfo> pluginInfos = Chainloader.PluginInfos;
			List<Mod> list2 = new List<Mod>();
			string[] array = new string[2] { "ev.lbol.utils.runLogger", "neo.lbol.fix.rngFix" };
			string[] source2 = new string[2] { "com.bepis.bepinex.scriptengine", "neo.lbol.tools.watermark" };
			string[] array2 = array;
			foreach (string key in array2)
			{
				if (pluginInfos.TryGetValue(key, out var value))
				{
					list2.Add(HandleMod(value));
				}
			}
			foreach (var (text2, pluginInfo) in pluginInfos)
			{
				if (!array.Contains(text2) && !source2.Contains(text2))
				{
					if (text2 == "neo.lbol.qol.helpMeEirin")
					{
						hasClearBonus = true;
					}
					Mod item = HandleMod(pluginInfo);
					list2.Add(item);
				}
			}
			RunDataController.Create();
			RunDataController.RunData.Version = VersionInfo.Current.Version;
			if (BepinexPlugin.saveProfileName.Value)
			{
				RunDataController.RunData.Name = parameters.UserProfile.Name;
			}
			Settings settings = new Settings
			{
				Character = id,
				PlayerType = playerType2,
				HasClearBonus = hasClearBonus,
				ShowRandomResult = showRandomResult,
				IsAutoSeed = isAutoSeed,
				Difficulty = difficulty2,
				Requests = requests,
				Mods = list2
			};
			if (list.Count > 0)
			{
				settings.JadeBoxes = list;
			}
			RunDataController.RunData.Settings = settings;
			RunDataController.Save();
		}

		private static Mod HandleMod(PluginInfo PluginInfo)
		{
			string gUID = PluginInfo.Metadata.GUID;
			string name = PluginInfo.Metadata.Name;
			string version = PluginInfo.Metadata.Version.ToString();
			return new Mod
			{
				GUID = gUID,
				Name = name,
				Version = version
			};
		}

		[HarmonyPatch("Save")]
		[HarmonyPostfix]
		private static void SavePatch(GameRunController __instance)
		{
			StationObj currentStation = RunDataController.CurrentStation;
			Station currentStation2 = __instance.CurrentStation;
			int hp = ((Unit)__instance.Player).Hp;
			if (currentStation2 != null)
			{
				if (currentStation2.IsStageEnd)
				{
					isAfterBossReward = true;
				}
			}
			else if (isAfterBossReward)
			{
				hp = currentStation.Status.Hp;
				isAfterBossReward = false;
			}
			Status status = new Status
			{
				Money = __instance.Money,
				Hp = hp,
				MaxHp = ((Unit)__instance.Player).MaxHp,
				Power = __instance.Player.Power,
				MaxPower = __instance.Player.MaxPower
			};
			if (currentStation == null)
			{
				RunDataController.RunData.Settings.Status = status;
			}
			else
			{
				currentStation.Status = status;
			}
			RunDataController.Save();
		}

		[HarmonyPatch("Restore")]
		[HarmonyPostfix]
		private static void RestorePatch()
		{
			RunDataController.Restore();
		}

		[HarmonyPatch("EnterStage")]
		[HarmonyPostfix]
		private static void EnterStagePatch(GameRunController __instance)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (RunDataController.CurrentStation != null)
			{
				isAfterBossReward = true;
			}
			int level = __instance.CurrentStage.Level;
			GameMap currentMap = __instance.CurrentMap;
			string bossId = currentMap.BossId;
			List<Node> list = new List<Node>();
			for (int i = 0; i < currentMap.Nodes.GetLength(0); i++)
			{
				for (int j = 0; j < currentMap.Nodes.GetLength(1); j++)
				{
					MapNode val = currentMap.Nodes[i, j];
					if (val != null)
					{
						Node obj = new Node
						{
							X = val.X,
							Y = val.Y,
							Followers = val.FollowerList
						};
						StationType stationType = val.StationType;
						obj.Type = ((object)(StationType)(ref stationType)).ToString();
						Node item = obj;
						list.Add(item);
					}
				}
			}
			ActObj item2 = new ActObj
			{
				Act = level,
				Nodes = list,
				Boss = bossId
			};
			RunDataController.RunData.Acts.Add(item2);
			RunDataController.Save();
		}

		[HarmonyPatch("EnterMapNode")]
		[HarmonyPostfix]
		[HarmonyPriority(2)]
		private static void EnterMapNodePatch(MapNode node, GameRunController __instance)
		{
			//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)
			InteractionViewerPatch.Listener = null;
			StationPatch.RewardListener = null;
			StationPatch.AddRewardsPatch.isAfterAddRewards = false;
			SeijaPatch.BattleActionPatch.isPlayerTrunStarted = false;
			AdventurePatch.NarumiOfferCardPatch.isNarumi = false;
			int level = __instance.CurrentStage.Level;
			Station currentStation = __instance.CurrentStation;
			int level2 = currentStation.Level;
			int y = node.Y;
			StationType stationType = node.StationType;
			string type = ((object)(StationType)(ref stationType)).ToString();
			StationObj stationObj = new StationObj
			{
				Type = type,
				Node = new NodeObj
				{
					Act = level,
					Level = level2,
					Y = y
				}
			};
			string adventureId = RunDataController.GetAdventureId(currentStation);
			if (adventureId != null)
			{
				stationObj.Id = adventureId;
			}
			else
			{
				adventureId = RunDataController.GetEnemyGroupId(currentStation);
				if (adventureId != null)
				{
					stationObj.Id = adventureId;
				}
			}
			RunDataController.RunData.Stations.Add(stationObj);
			if (isOverridingStartingDeck)
			{
				RunDataController.AddCardChange(startingDeckOverride, ChangeType.Add);
				ResetStartingDeckOverride();
			}
			if (startingCards != null)
			{
				RunDataController.AddCardChange(startingCards, ChangeType.Add);
				startingCards = null;
			}
			if (startingExhibits.Any())
			{
				return;
			}
			foreach (Exhibit startingExhibit in startingExhibits)
			{
				RunDataController.AddExhibitChange(startingExhibit, ChangeType.Upgrade);
			}
			startingExhibits.Clear();
		}

		[HarmonyPatch("InternalAddDeckCards")]
		[HarmonyPostfix]
		private static void InternalAddDeckCardsPatch(Card[] cards)
		{
			if (!isOverridingStartingDeck)
			{
				if (RunDataController.RunData == null)
				{
					startingCards = cards;
				}
				else
				{
					RunDataController.AddCardChange(cards, ChangeType.Add);
				}
			}
		}

		[HarmonyPatch("RemoveDeckCards")]
		[HarmonyPrefix]
		private static void RemoveDeckCardsPatch(IEnumerable<Card> cards)
		{
			if (!isOverridingStartingDeck)
			{
				RunDataController.AddCardChange(cards, ChangeType.Remove);
			}
		}

		[HarmonyPatch("UpgradeDeckCards")]
		[HarmonyPostfix]
		private static void UpgradeDeckCardsPatch(IEnumerable<Card> cards)
		{
			RunDataController.AddCardChange(cards, ChangeType.Upgrade);
		}

		[HarmonyPatch("GainExhibitRunner")]
		[HarmonyPostfix]
		[HarmonyPriority(2)]
		private static void GainExhibitRunnerPatch(Exhibit exhibit)
		{
			if (RunDataController.RunData == null)
			{
				startingExhibits.Add(exhibit);
			}
			else
			{
				RunDataController.AddExhibitChange(exhibit, ChangeType.Add);
			}
		}

		[HarmonyPatch("LoseExhibit")]
		[HarmonyPostfix]
		private static void LoseExhibitPatch(Exhibit exhibit)
		{
			RunDataController.AddExhibitChange(exhibit, ChangeType.Remove);
		}

		[HarmonyPatch("LeaveBattle")]
		[HarmonyPostfix]
		private static void LeaveBattlePatch(EnemyGroup enemyGroup, BattleStats __result, GameRunController __instance)
		{
			int totalRounds = __result.TotalRounds;
			RunDataController.AddData("Rounds", totalRounds);
			string adventureId = RunDataController.GetAdventureId(__instance.CurrentStation);
			if (adventureId != null)
			{
				RunDataController.AddData("Id", enemyGroup.Id);
				string text = adventureId;
				string text2 = text;
				if (!(text2 == "YachieOppression"))
				{
					if (text2 == "MiyoiBartender")
					{
						AdventurePatch.MiyoiBartenderPatch.HandleBattle();
					}
				}
				else
				{
					AdventurePatch.YachieOppressionPatch.HandleBattle();
				}
			}
			RunDataController.Save();
		}

		[HarmonyPatch("RollNormalExhibit")]
		[HarmonyPostfix]
		private static void RollNormalExhibitPatch(Exhibit __result)
		{
			string rewardListener = StationPatch.RewardListener;
			BepinexPlugin.log.LogDebug((object)("RewardListener in " + MethodBase.GetCurrentMethod().Name + ": " + rewardListener));
			if (!(rewardListener != "AddReward"))
			{
				string id = ((GameEntity)__result).Id;
				RunDataController.Exhibits.Add(id);
				StationPatch.RewardListener = null;
			}
		}
	}
	[HarmonyPatch(typeof(InteractionViewer))]
	public static class InteractionViewerPatch
	{
		public static string Listener;

		[HarmonyPatch("View")]
		[HarmonyPrefix]
		public static void ViewPatch(Interaction interaction)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (Listener != null)
			{
				BepinexPlugin.log.LogDebug((object)("InteractionViewerPatch.Listener: " + Listener));
			}
			if (interaction is MiniSelectCardInteraction)
			{
				string type = RunDataController.CurrentStation.Type;
				StationType val = (StationType)7;
				if (type == ((object)(StationType)(ref val)).ToString() && AdventurePatch.DebutPatch.uncommonCardListener == 2)
				{
					AddMiniSelectCardInteractionRewards(interaction);
					return;
				}
			}
			string listener = Listener;
			string text = listener;
			if (!(text == "SumirekoGathering"))
			{
				if (text == "SatoriCounseling")
				{
					if (AdventurePatch.SatoriCounselingPatch.isMini)
					{
						AddMiniSelectCardInteractionRewards(interaction);
					}
					else
					{
						AddSelectCardInteractionRewards(interaction);
					}
				}
			}
			else
			{
				AddMiniSelectCardInteractionRewards(interaction);
			}
			Listener = null;
			if (interaction.Source == null)
			{
				return;
			}
			string id = interaction.Source.Id;
			RewardInteraction val2 = (RewardInteraction)(object)((interaction is RewardInteraction) ? interaction : null);
			if (val2 != null)
			{
				if (!(id == "HuiyeBaoxiang"))
				{
					return;
				}
				IReadOnlyList<Exhibit> pendingExhibits = val2.PendingExhibits;
				if (RunDataController.CurrentStation.Rewards == null)
				{
					RunDataController.CurrentStation.Rewards = new Dictionary<string, object>();
				}
				if (!RunDataController.CurrentStation.Rewards.TryGetValue("Exhibits", out object value))
				{
					RunDataController.CurrentStation.Rewards["Exhibits"] = new List<string>();
				}
				RunDataController.CurrentStation.Rewards.TryGetValue("Exhibits", out value);
				List<string> list = value as List<string>;
				{
					foreach (Exhibit item in pendingExhibits)
					{
						list.Add(((GameEntity)item).Id);
					}
					return;
				}
			}
			MiniSelectCardInteraction val3 = (MiniSelectCardInteraction)(object)((interaction is MiniSelectCardInteraction) ? interaction : null);
			if (val3 == null)
			{
				return;
			}
			if (id == "Modaoshu")
			{
				IReadOnlyList<Card> pendingCards = val3.PendingCards;
				if (RunDataController.CurrentStation.Rewards == null)
				{
					RunDataController.CurrentStation.Rewards = new Dictionary<string, object>();
				}
				if (!RunDataController.CurrentStation.Rewards.TryGetValue("Cards", out object _))
				{
					RunDataController.CurrentStation.Rewards["Cards"] = new List<List<CardObj>>();
				}
				object obj = RunDataController.CurrentStation.Rewards["Cards"];
				if (obj is List<List<CardObj>> list2)
				{
					list2.Add(new List<CardObj>());
					list2[list2.Count - 1] = RunDataController.GetCards(pendingCards);
				}
				else if (obj is List<List<CardWithPrice>> list3)
				{
					list3.Add(new List<CardWithPrice>());
					list3[list3.Count - 1] = pendingCards.Select((Card card) => RunDataController.GetCardWithPrice(card)).ToList();
				}
			}
			else if (id == "FixBook")
			{
				IReadOnlyList<Card> pendingCards2 = val3.PendingCards;
				List<List<CardObj>> value3 = new List<List<CardObj>> { RunDataController.GetCards(pendingCards2) };
				Dictionary<string, object> rewards = new Dictionary<string, object> { { "Cards", value3 } };
				RunDataController.CurrentStation.Rewards = rewards;
			}
		}

		private static void AddMiniSelectCardInteractionRewards(Interaction interaction)
		{
			MiniSelectCardInteraction val = (MiniSelectCardInteraction)(object)((interaction is MiniSelectCardInteraction) ? interaction : null);
			IReadOnlyList<Card> pendingCards = val.PendingCards;
			HandleCardRewards(pendingCards);
		}

		private static void AddSelectCardInteractionRewards(Interaction interaction)
		{
			SelectCardInteraction val = (SelectCardInteraction)(object)((interaction is SelectCardInteraction) ? interaction : null);
			IReadOnlyList<Card> pendingCards = val.PendingCards;
			HandleCardRewards(pendingCards);
		}

		private static void HandleCardRewards(IReadOnlyList<Card> pendingCards)
		{
			List<CardObj> cards = RunDataController.GetCards(pendingCards);
			Dictionary<string, object> rewards = new Dictionary<string, object> { 
			{
				"Cards",
				new List<List<CardObj>> { cards }
			} };
			RunDataController.CurrentStation.Rewards = rewards;
		}
	}
	[HarmonyPatch]
	public static class JadeBoxPatch
	{
		[HarmonyPatch(typeof(Start50), "OnGain")]
		public static class Start50OnGainPatch
		{
			private static void Prefix()
			{
				GameRunControllerPatch.isOverridingStartingDeck = true;
			}

			private static void Postfix(GameRunController gameRun)
			{
				GameRunControllerPatch.startingDeckOverride = gameRun._baseDeck;
			}
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	internal class ExihibitCounterSetterPatch
	{
		public static bool isInitialize;

		private static void Prefix(int value, Exhibit __instance)
		{
			if (isInitialize)
			{
				return;
			}
			string[] source = new string[5] { "GanzhuYao", "ChuRenou", "TiangouYuyi", "Moping", "Baota" };
			string id = ((GameEntity)__instance).Id;
			if (!source.Contains(id))
			{
				return;
			}
			int counter = __instance.Counter;
			if (counter > value)
			{
				RunDataController.AddExhibitChange(__instance, ChangeType.Use, value);
			}
			else if (counter < value)
			{
				if (id == "Moping")
				{
					GapStationPatch.UpgradeMoping = fn;
				}
				else
				{
					fn();
				}
			}
			void fn()
			{
				RunDataController.AddExhibitChange(__instance, ChangeType.Upgrade, value);
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			return instructions;
		}
	}
	[HarmonyPatch(typeof(Exhibit), "Initialize")]
	internal class ExihibitInitializePatch
	{
		private static void Prefix()
		{
			ExihibitCounterSetterPatch.isInitialize = true;
		}

		private static void Postfix()
		{
			ExihibitCounterSetterPatch.isInitialize = false;
		}
	}
	[HarmonyPatch(typeof(Stage))]
	public static class StagePatch
	{
		[HarmonyPatch("SetBoss")]
		[HarmonyPostfix]
		private static void SetBossPatch(string enemyGroupName)
		{
			if (RunDataController.RunData != null)
			{
				RunDataController.RunData.Acts[0].Boss = enemyGroupName;
			}
		}

		[HarmonyPatch("GetEnemyCardReward")]
		[HarmonyPostfix]
		private static void GetEnemyCardRewardPatch(StationReward __result)
		{
			bool isAfterAddRewards = StationPatch.AddRewardsPatch.isAfterAddRewards;
			BepinexPlugin.log.LogDebug((object)$"isAfterAddRewards: {isAfterAddRewards}");
			if (isAfterAddRewards)
			{
				RewardsUtil.AddReward(__result);
			}
		}

		[HarmonyPatch("GetEliteEnemyExhibit")]
		[HarmonyPostfix]
		private static void GetEliteEnemyExhibitPatch(Exhibit __result)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: 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_0042: Expected O, but got Unknown
			bool isAfterAddRewards = StationPatch.AddRewardsPatch.isAfterAddRewards;
			BepinexPlugin.log.LogDebug((object)$"isAfterAddRewards: {isAfterAddRewards}");
			if (isAfterAddRewards)
			{
				StationReward reward = new StationReward
				{
					Type = (StationRewardType)2,
					Exhibit = __result
				};
				RewardsUtil.AddReward(reward);
			}
		}

		[HarmonyPatch(typeof(StationReward), "CreateToolCard")]
		[HarmonyPostfix]
		private static void GetShopToolCardsPatch(StationReward __result)
		{
			string rewardListener = StationPatch.RewardListener;
			BepinexPlugin.log.LogDebug((object)("RewardListener in " + MethodBase.GetCurrentMethod().Name + ": " + rewardListener));
			if (rewardListener == null)
			{
				RewardsUtil.AddReward(__result);
			}
		}
	}
	[HarmonyPatch(typeof(Seija))]
	public static class SeijaPatch
	{
		[HarmonyPatch(typeof(BattleAction))]
		public static class BattleActionPatch
		{
			[HarmonyPatch]
			private class CreateEventPhasePatch
			{
				private static MethodBase TargetMethod()
				{
					return AccessTools.Method(typeof(BattleAction), "CreateEventPhase", (Type[])null, (Type[])null).MakeGenericMethod(typeof(UnitEventArgs));
				}

				private static void Prefix(BattleAction __instance, string name, UnitEventArgs args)
				{
					BattleController battle = __instance.Battle;
					string id = battle.EnemyGroup.Id;
					if (!RunDataController.enemiesShowDetails.Contains(id))
					{
						return;
					}
					if (name == "TurnStarted")
					{
						if (__instance is StartPlayerTurnAction)
						{
							isPlayerTrunStarted = true;
						}
					}
					else
					{
						if (!(name == "TurnEnded"))
						{
							return;
						}
						if (__instance is EndPlayerTurnAction)
						{
							Unit unit = args.Unit;
							PlayerUnit unit2 = (PlayerUnit)(object)((unit is PlayerUnit) ? unit : null);
							AddDetails((Unit)(object)unit2);
						}
						else if (__instance is EndEnemyTurnAction)
						{
							Unit unit3 = args.Unit;
							EnemyUnit val = (EnemyUnit)(object)((unit3 is EnemyUnit) ? unit3 : null);
							string id2 = ((GameEntity)val).Id;
							if (RunDataController.enemiesShowDetails.Contains(id2))
							{
								int roundCounter = battle.RoundCounter;
								int turnCounter = ((Unit)val).TurnCounter;
								TurnObj item = new TurnObj
								{
									Round = roundCounter,
									Turn = turnCounter,
									Id = id2
								};
								RunDataController.AddDataItem("Details", item);
								AddDetails((Unit)(object)val);
							}
						}
					}
				}
			}

			public static bool isPlayerTrunStarted;

			[HarmonyPatch("CreatePhase", new Type[]
			{
				typeof(string),
				typeof(Action),
				typeof(bool)
			})]
			[HarmonyPrefix]
			private static void CreatePhasePatch(BattleAction __instance, string name)
			{
				if (isPlayerTrunStarted && !(name != "InTurn"))
				{
					BattleController battle = __instance.Battle;
					int roundCounter = battle.RoundCounter;
					int turnCounter = ((Unit)battle.Player).TurnCounter;
					IReadOnlyList<Card> handZone = battle.HandZone;
					List<CardObj> cards = RunDataController.GetCards(handZone);
					TurnObj item = new TurnObj
					{
						Round = roundCounter,
						Turn = turnCounter,
						Id = "Player",
						Cards = cards
					};
					RunDataController.AddDataItem("Details", item);
					isPlayerTrunStarted = false;
				}
			}
		}

		private static bool isBattleStart;

		[HarmonyPatch("OnEnterBattle")]
		[HarmonyPostfix]
		private static void OnEnterBattlePatch(Seija __instance)
		{
			int round = 0;
			int turn = 0;
			string id = ((GameEntity)__instance).Id;
			TurnObj item = new TurnObj
			{
				Round = round,
				Turn = turn,
				Id = id
			};
			RunDataController.AddDataItem("Details", item);
			isBattleStart = true;
		}

		[HarmonyPatch("GetTurnMoves")]
		[HarmonyPostfix]
		private static void GetTurnMovesPatch(Seija __instance, IEnumerable<IEnemyMove> __result)
		{
			if (isBattleStart)
			{
				AddDetails((Unit)(object)__instance);
				isBattleStart = false;
			}
			AddIntentions(__result, __instance);
		}

		private static void AddDetails(Unit unit)
		{
			GetDetails(out var details);
			BattleStatusObj status = GetStatus(unit);
			details.Status = status;
			List<StatusEffectObj> statusEffects = GetStatusEffects(unit);
			details.StatusEffects = statusEffects;
		}

		private static void GetDetails(out TurnObj details)
		{
			List<TurnObj> list = RunDataController.CurrentStation.Data["Details"] as List<TurnObj>;
			details = list[list.Count - 1];
		}

		private static BattleStatusObj GetStatus(Unit unit)
		{
			int hp = unit.Hp;
			int block = unit.Block;
			int shield = unit.Shield;
			BattleStatusObj battleStatusObj = new BattleStatusObj
			{
				Hp = hp,
				Block = block,
				Barrier = shield
			};
			PlayerUnit val = (PlayerUnit)(object)((unit is PlayerUnit) ? unit : null);
			if (val != null)
			{
				battleStatusObj.Power = val.Power;
			}
			return battleStatusObj;
		}

		private static List<StatusEffectObj> GetStatusEffects(Unit unit)
		{
			return unit.StatusEffects.Select(delegate(StatusEffect se)
			{
				StatusEffectObj statusEffectObj = new StatusEffectObj
				{
					Id = ((GameEntity)se).Id
				};
				if (se.HasLevel)
				{
					statusEffectObj.Level = se.Level;
				}
				if (se.HasDuration)
				{
					statusEffectObj.Duration = se.Duration;
				}
				if (se.HasCount)
				{
					statusEffectObj.Count = se.Count;
				}
				int? num = se.Limit;
				if (num.HasValue && num != 0)
				{
					statusEffectObj.Limit = se.Limit;
				}
				return statusEffectObj;
			}).ToList();
		}

		private static void AddIntentions(IEnumerable<IEnemyMove> moves, Seija enemy)
		{
			GetDetails(out var details);
			List<IntentionObj> intentions = moves.Select(delegate(IEnemyMove m)
			{
				//IL_0009: Unknown result type (might be due to invalid IL or missing references)
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: 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_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0024: Unknown result type (might be due to invalid IL or missing references)
				//IL_0027: Invalid comparison between Unknown and I4
				//IL_004f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Unknown result type (might be due to invalid IL or missing references)
				//IL_007d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002b: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Invalid comparison between Unknown and I4
				//IL_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_003a: Invalid comparison between Unknown and I4
				Intention intention = m.Intention;
				IntentionType type = intention.Type;
				string type2 = ((object)(IntentionType)(ref type)).ToString();
				IntentionType val = type;
				IntentionType val2 = val;
				if ((int)val2 == 1)
				{
					AttackIntention val3 = (AttackIntention)(object)((intention is AttackIntention) ? intention : null);
					DamageInfo damage = val3.Damage;
					int value = ((Unit)enemy).Battle.CalculateDamage((GameEntity)(object)enemy, (Unit)(object)enemy, (Unit)(object)((Unit)enemy).Battle.Player, damage);
					return new IntentionObj
					{
						Type = type2,
						Damage = value,
						Times = val3.Times,
						IsAccurate = val3.IsAccuracy
					};
				}
				if ((int)val2 == 10)
				{
					ClearIntention val4 = (ClearIntention)(object)((intention is ClearIntention) ? intention : null);
					return new IntentionObj
					{
						Type = type2
					};
				}
				if ((int)val2 == 12)
				{
					SpellCardIntention val5 = (SpellCardIntention)(object)((intention is SpellCardIntention) ? intention : null);
					return new IntentionObj
					{
						Type = type2
					};
				}
				return new IntentionObj();
			}).ToList();
			details.Intentions = intentions;
		}
	}
	[HarmonyPatch(typeof(Station))]
	public static class StationPatch
	{
		[HarmonyPatch(typeof(Station))]
		public static class AddRewardsPatch
		{
			[HarmonyPatch]
			public static class GenerateRewardsPatch
			{
				private static void Reset()
				{
					isAfterAddRewards = false;
				}

				[HarmonyPatch(typeof(EnemyStation), "GenerateRewards")]
				[HarmonyPrefix]
				private static void EnemyStationPatch()
				{
					Reset();
				}

				[HarmonyPatch(typeof(EliteEnemyStation), "GenerateRewards")]
				[HarmonyPrefix]
				private static void EliteEnemyStationPatch()
				{
					Reset();
				}

				[HarmonyPatch(typeof(BossStation), "GenerateRewards")]
				[HarmonyPrefix]
				private static void BossStationPatch()
				{
					Reset();
				}
			}

			public static bool isAfterAddRewards;

			[HarmonyPatch("AddRewards", new Type[] { typeof(IEnumerable<StationReward>) })]
			private static void Prefix(IEnumerable<StationReward> rewards)
			{
				RewardListener = "AddReward";
				RewardsUtil.AddRewards(rewards.ToList());
			}

			[HarmonyPatch("AddRewards", new Type[] { typeof(IEnumerable<StationReward>) })]
			private static void Postfix()
			{
				RewardListener = null;
				isAfterAddRewards = true;
			}
		}

		public static string RewardListener;

		public const string Listener = "AddReward";

		[HarmonyPatch("AddReward")]
		[HarmonyPrefix]
		private static void AddRewardPatch(StationReward reward)
		{
			BepinexPlugin.log.LogDebug((object)("RewardListener in " + MethodBase.GetCurrentMethod().Name + ": " + RewardListener));
			if (RewardListener == null)
			{
				RewardListener = "AddReward";
				RewardsUtil.AddReward(reward);
			}
		}
	}
	[HarmonyPatch(typeof(BossStation))]
	internal class BossStationPatch
	{
		[HarmonyPatch("GenerateBossRewards")]
		[HarmonyPostfix]
		private static void GenerateBossRewardsPatch(BossStation __instance)
		{
			Exhibit[] bossRewards = __instance.BossRewards;
			List<string> value = bossRewards.Select((Exhibit exhibit) => ((GameEntity)exhibit).Id).ToList();
			Dictionary<string, object> rewards = new Dictionary<string, object> { { "Exhibits", value } };
			RunDataController.CurrentStation.Rewards = rewards;
		}
	}
	[HarmonyPatch(typeof(GapStation))]
	public static class GapStationPatch
	{
		private const string Listener = "InternalGerRareCard";

		public static Action UpgradeMoping;

		[HarmonyPatch(typeof(GapOptionsPanel), "OnShowing")]
		[HarmonyPostfix]
		private static void OnShowingPatch(GapStation gapStation)
		{
			List<string> value = gapStation.GapOptions.Select(delegate(GapOption gapOption)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				GapOptionType type = gapOption.Type;
				return ((object)(GapOptionType)(ref type)).ToString();
			}).ToList();
			RunDataController.AddData("Options", value);
			if (UpgradeMoping != null)
			{
				UpgradeMoping();
				UpgradeMoping = null;
			}
		}

		[HarmonyPatch(typeof(GapOptionsPanel), "OptionClicked")]
		[HarmonyPostfix]
		private static void OptionClickedPatch(GapOption option)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			GapOptionType type = option.Type;
			string value = ((object)(GapOptionType)(ref type)).ToString();
			RunDataController.CurrentStation.Data["Choice"] = value;
		}

		[HarmonyPatch(typeof(GapOptionsPanel), "InternalGerRareCard")]
		[HarmonyPrefix]
		private static void InternalGerRareCardPatch()
		{
			StationPatch.RewardListener = "InternalGerRareCard";
		}

		[HarmonyPatch(typeof(SelectCardPanel), "ShowMiniSelect")]
		[HarmonyPrefix]
		private static void ShowMiniSelectPatch(SelectCardPayload payload)
		{
			string rewardListener = StationPatch.RewardListener;
			BepinexPlugin.log.LogDebug((object)("RewardListener in " + MethodBase.GetCurrentMethod().Name + ": " + rewardListener));
			string text = rewardListener;
			string text2 = text;
			if (text2 == "InternalGerRareCard")
			{
				List<CardObj> cards = RunDataController.GetCards(payload.Cards);
				RunDataController.AddData("ShanliangDengpao", cards);
			}
			StationPatch.RewardListener = null;
		}
	}
	[HarmonyPatch(typeof(SelectStation))]
	internal class SelectStationPatch
	{
		[HarmonyPatch("GenerateRecord")]
		[HarmonyPostfix]
		private static void GenerateRecordPatch(SelectStation __instance)
		{
			List<string> value = __instance.Opponents.Select((EnemyUnit opponent) => ((GameEntity)opponent).Id).ToList();
			RunDataController.AddData("Opponents", value);
		}
	}
	[HarmonyPatch(typeof(ShopStation))]
	internal class ShopStationPatch
	{
		[HarmonyPatch(typeof(ShopStation))]
		private class BuyCardPatch
		{
			private const string BuyCard = "BuyCard";

			[HarmonyPatch("BuyCard")]
			private static void Prefix()
			{
				Listener = "BuyCard";
			}

			[HarmonyPatch("GetPrice", new Type[]
			{
				typeof(Card),
				typeof(bool)
			})]
			[HarmonyPostfix]
			private static void GetPricePatch(Card card, int __result, ShopStation __instance)
			{
				if (!(Listener != "BuyCard"))
				{
					RunDataController.CurrentStation.Rewards.TryGetValue("Cards", out object value);
					List<List<CardWithPrice>> list = value as List<List<CardWithPrice>>;
					if (index == -1)
					{
						index = list.Count;
						list.Add(new List<CardWithPrice>());
					}
					int value2 = (int)(((Station)__instance).GameRun.FinalShopPriceMultiplier * (float)__result);
					list[index].Add(RunDataController.GetCardWithPrice(card, value2));
					Listener = null;
				}
			}
		}

		[HarmonyPatch(typeof(ShopStation))]
		private class BuyExhibitRunnerPatch
		{
			private const string BuyExhibit = "BuyExhibitRunner";

			[HarmonyPatch("BuyExhibitRunner")]
			private static void Prefix()
			{
				Listener = "BuyExhibitRunner";
			}

			[HarmonyPatch("GetPrice", new Type[] { typeof(Exhibit) })]
			[HarmonyPostfix]
			private static void GetPricePatch(Exhibit exhibit, int __result, ShopStation __instance)
			{
				if (!(Listener != "BuyExhibitRunner"))
				{
					RunDataController.CurrentStation.Rewards.TryGetValue("Exhibits", out object value);
					int price = (int)(((Station)__instance).GameRun.FinalShopPriceMultiplier * (float)__result);
					RunDataController.AddPrice(((GameEntity)exhibit).Id, price);
					(value as List<string>).Add(((GameEntity)exhibit).Id);
					Listener = null;
				}
			}
		}

		private static string Listener;

		private static int index;

		[HarmonyPatch("OnEnter")]
		[HarmonyPrefix]
		private static void OnEnterPatch()
		{
			Listener = null;
			index = -1;
		}

		[HarmonyPatch(typeof(GameRunController), "EnterMapNode")]
		[HarmonyPostfix]
		[HarmonyPriority(1)]
		private static void EnterMapNodePatch(GameRunController __instance)
		{
			Station currentStation = __instance.CurrentStation;
			ShopStation val = (ShopStation)(object)((currentStation is ShopStation) ? currentStation : null);
			if (val == null)
			{
				return;
			}
			List<ShopItem<Card>> shopCards = val.ShopCards;
			List<CardWithPrice> list = shopCards.Select(delegate(ShopItem<Card> item)
			{
				int price = item.Price;
				return RunDataController.GetCardWithPrice(item.Content, price);
			}).ToList();
			list[val.DiscountCardNo].IsDiscounted = true;
			List<ShopItem<Exhibit>> shopExhibits = val.ShopExhibits;
			List<string> value = shopExhibits.Select((ShopItem<Exhibit> item) => ((GameEntity)item.Content).Id).ToList();
			Dictionary<string, int> dictionary = new Dictionary<string, int>
			{
				{ "Remove", val.RemoveDeckCardPrice },
				{ "Upgrade", val.UpgradeDeckCardPrice }
			};
			foreach (ShopItem<Exhibit> item in shopExhibits)
			{
				dictionary[((GameEntity)item.Content).Id] = item.Price;
			}
			Dictionary<string, object> rewards = new Dictionary<string, object>
			{
				{
					"Cards",
					new List<List<CardWithPrice>> { list }
				},
				{ "Exhibits", value }
			};
			RunDataController.CurrentStation.Rewards = rewards;
			RunDataController.AddData("Prices", dictionary);
		}

		[HarmonyPatch("RemoveDeckCard")]
		[HarmonyPrefix]
		private static void RemoveDeckCardPatch(Card card)
		{
			RunDataController.AddData("Choice", 0);
			RunDataController.AddData("Remove", RunDataController.GetCard(card));
		}

		[HarmonyPatch("UpgradeDeckCard")]
		[HarmonyPrefix]
		private static void UpgradeDeckCardPatch(Card card)
		{
			RunDataController.AddData("Choice", 1);
			RunDataController.AddData("Upgrade", RunDataController.GetCard(card));
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}