using System;
using System.Collections;
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.Base.Extensions;
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;
using LBoL.EntityLib.Exhibits.Adventure;
using LBoL.EntityLib.Exhibits.Common;
using LBoL.EntityLib.PlayerUnits;
using LBoL.Presentation;
using LBoL.Presentation.I10N;
using LBoL.Presentation.UI;
using LBoL.Presentation.UI.ExtraWidgets;
using LBoL.Presentation.UI.Panels;
using LBoL.Presentation.UI.Widgets;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using PatchouliCharacterMod.Config;
using RunLogger.Utils;
using RunLogger.Utils.Enums;
using RunLogger.Utils.LogFile;
using RunLogger.Utils.Managers;
using RunLogger.Utils.RunLogLib;
using RunLogger.Utils.RunLogLib.BattleDetails;
using RunLogger.Utils.RunLogLib.Entities;
using RunLogger.Utils.RunLogLib.Nodes;
using RunLogger.Utils.UploadPanelObjects;
using RunLogger.Wrappers;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.Networking;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: 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+58ce987e3dcf0e89cfa7a7e0795d8897cbdadc2d")]
[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", "3.2.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[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> SaveFailure;

		internal static ConfigEntry<bool> SaveAbandoned;

		internal static ConfigEntry<bool> SaveProfileName;

		internal static ConfigEntry<bool> SaveTogether;

		internal static List<ConfigEntry<bool>> AutoUploads = new List<ConfigEntry<bool>>();

		internal static bool HasPatchouliMod;

		private void Awake()
		{
			log = ((BaseUnityPlugin)this).Logger;
			Object.DontDestroyOnLoad((Object)(object)((Component)this).gameObject);
			((Object)((Component)this).gameObject).hideFlags = (HideFlags)61;
			SaveFailure = ((BaseUnityPlugin)this).Config.Bind<bool>("Save", "Save Failed Run", true, "Save log for the current run even it failed.");
			SaveAbandoned = ((BaseUnityPlugin)this).Config.Bind<bool>("Save", "Save Abandoned Run", false, "Save log for the current run even it is abandoned.");
			SaveProfileName = ((BaseUnityPlugin)this).Config.Bind<bool>("Save", "Save Profile Name", true, "Save and show profile name when uploaded to LBoL Logs.");
			SaveTogether = ((BaseUnityPlugin)this).Config.Bind<bool>("Save", "Save Profiles Together", true, "Save the logs of different profiles in the same directory.\nIf set to `false`, they are saved under the corresponding index, i.e. `0`/`1`/`2`.");
			for (int i = 0; i < 3; i++)
			{
				AutoUploads.Add(((BaseUnityPlugin)this).Config.Bind<bool>("Upload", $"Auto Upload Log #{i}", false, $"Auto upload the log of Profile #{i} to LBoL Logs.\nIf set to `false`, you can upload with description at the result screen.\nUploaded log will be deleted from local drive."));
			}
			harmony.PatchAll();
			if (Chainloader.PluginInfos.ContainsKey("neo.lbol.tools.watermark"))
			{
				WatermarkWrapper.ActivateWatermark();
			}
			HasPatchouliMod = Chainloader.PluginInfos.ContainsKey("rmrfmaxx.lbol.PatchouliCharacterMod");
		}

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

		public const string Name = "Run Logger";

		public const string version = "3.2.2";

		public static readonly Harmony harmony = new Harmony("ev.lbol.utils.runLogger");
	}
}
namespace RunLogger.Wrappers
{
	internal class PatchouliModWrapper
	{
		internal static Dictionary<string, dynamic> GetConfigs()
		{
			return new Dictionary<string, object>
			{
				{
					"startingExhibitSign",
					GetStartingExhibitSignWrapper()
				},
				{
					"startingCardSign",
					GetStartingCardSignWrapper()
				}
			};
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static int GetStartingExhibitSignWrapper()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected I4, but got Unknown
			return (int)PatchouliConfigEntry.GetStartingExhibitSign();
		}

		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static int GetStartingCardSignWrapper()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Expected I4, but got Unknown
			return (int)PatchouliConfigEntry.GetStartingCardSign();
		}
	}
	internal class WatermarkWrapper
	{
		[MethodImpl(MethodImplOptions.NoInlining)]
		internal static void ActivateWatermark()
		{
			API.ActivateWatermark();
		}
	}
}
namespace RunLogger.Utils
{
	internal static class Configs
	{
		internal const string RunLoggerDirName = "runLogger";

		internal const string TempDirName = "temp";

		internal const string GasUrl = "https://script.google.com/macros/s/AKfycbxQZf9xkxJX-YNYxXAjssmqT2-HFmH1EPZ6bjbcoz1RxvfWdHoP1eWC8D4XiQkIpmLvbw/exec";

		internal const string RandomMana = "A";

		internal const int Profiles = 3;

		internal static readonly string[] PriorityMods = new string[2] { "ev.lbol.utils.runLogger", "neo.lbol.fix.rngFix" };

		internal static readonly string[] ExcludedMods = new string[2] { "com.bepis.bepinex.scriptengine", "neo.lbol.tools.watermark" };

		internal const string HelpMeEirinMod = "neo.lbol.qol.helpMeEirin";

		internal const string PatchouliMod = "rmrfmaxx.lbol.PatchouliCharacterMod";
	}
	internal static class Controller
	{
		internal static Instance Instance { get; private set; }

		internal static StationObj LastStation
		{
			get
			{
				int num = CurrentStationIndex - 1;
				if (num == -1)
				{
					return null;
				}
				return Instance.RunLog.Stations[num];
			}
		}

		internal static StationObj CurrentStation => Instance.RunLog.Stations.LastOrDefault();

		internal static int CurrentStationIndex => Instance.RunLog.Stations.Count - 1;

		internal static bool ShowRandomResult => Instance.RunLog.Settings.ShowRandomResult;

		internal static void CreateInstance(RunLog runLog)
		{
			Instance = new Instance(runLog);
			Instance.IsInitialized = true;
		}

		internal static void DestroyInstance()
		{
			Instance.IsInitialized = false;
			Instance = null;
		}
	}
	internal class EnumeratorHook : IEnumerable
	{
		[CompilerGenerated]
		private sealed class <GetEnumerator>d__7 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public EnumeratorHook <>4__this;

			private object <item>5__1;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>4__this.prefixAction();
					break;
				case 1:
					<>1__state = -1;
					<>4__this.postItemAction(<item>5__1);
					<item>5__1 = null;
					break;
				}
				if (<>4__this.enumerator.MoveNext())
				{
					<item>5__1 = <>4__this.enumerator.Current;
					<>4__this.preItemAction(<item>5__1);
					<>2__current = <>4__this.itemAction(<item>5__1);
					<>1__state = 1;
					return true;
				}
				<>4__this.postfixAction();
				return false;
			}

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

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

		internal IEnumerator enumerator;

		internal Action prefixAction = delegate
		{
		};

		internal Action<object> preItemAction = delegate
		{
		};

		internal Func<object, object> itemAction = (object item) => item;

		internal Action<object> postItemAction = delegate
		{
		};

		internal Action postfixAction = delegate
		{
		};

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

		[IteratorStateMachine(typeof(<GetEnumerator>d__7))]
		internal IEnumerator GetEnumerator()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <GetEnumerator>d__7(0)
			{
				<>4__this = this
			};
		}
	}
	internal static class Helpers
	{
		internal static Station CurrentStation => Singleton<GameMaster>.Instance.CurrentGameRun.CurrentStation;

		internal static int CurrentSaveIndex => Singleton<GameMaster>.Instance.CurrentSaveIndex.GetValueOrDefault();

		internal static bool AutoUpload
		{
			get
			{
				return BepinexPlugin.AutoUploads[CurrentSaveIndex].Value;
			}
			set
			{
				BepinexPlugin.AutoUploads[CurrentSaveIndex].Value = value;
			}
		}

		internal static void AddStatus(GameRunController gameRun, StationObj stationObj, int? overrideHp)
		{
			PlayerUnit player = gameRun.Player;
			int hp = overrideHp ?? ((Unit)player).Hp;
			Status status = new Status
			{
				Money = gameRun.Money,
				Hp = hp,
				MaxHp = ((Unit)player).MaxHp,
				Power = player.Power,
				MaxPower = player.MaxPower
			};
			if (stationObj == null)
			{
				Controller.Instance.RunLog.Settings.Status = status;
			}
			else
			{
				stationObj.Status = status;
			}
		}

		internal static string GetEnemyGroupId(Station station)
		{
			EnemyGroup val = null;
			BattleAdvTestStation val2 = (BattleAdvTestStation)(object)((station is BattleAdvTestStation) ? station : null);
			if (val2 != null)
			{
				val = val2.EnemyGroup;
			}
			else
			{
				BattleStation val3 = (BattleStation)(object)((station is BattleStation) ? station : null);
				if (val3 != null)
				{
					val = val3.EnemyGroup;
				}
			}
			return (val != null) ? val.Id : null;
		}

		internal static Adventure GetAdventure(Station station)
		{
			if (station == null)
			{
				station = CurrentStation;
			}
			Adventure result = null;
			BattleAdvTestStation val = (BattleAdvTestStation)(object)((station is BattleAdvTestStation) ? station : null);
			if (val != null)
			{
				result = val.Adventure;
			}
			else
			{
				AdventureStation val2 = (AdventureStation)(object)((station is AdventureStation) ? station : null);
				if (val2 != null)
				{
					result = val2.Adventure;
				}
				else
				{
					EntryStation val3 = (EntryStation)(object)((station is EntryStation) ? station : null);
					if (val3 != null)
					{
						result = val3.DebutAdventure;
					}
					else
					{
						TradeStation val4 = (TradeStation)(object)((station is TradeStation) ? station : null);
						if (val4 != null)
						{
							result = val4.Adventure;
						}
					}
				}
			}
			return result;
		}

		internal static string GetAdventureId(Station station)
		{
			Adventure adventure = GetAdventure(station);
			return (adventure != null) ? adventure.Id : null;
		}

		internal static bool IsAdventure<T>() where T : Adventure
		{
			DialogStorage storage;
			return IsAdventure<T>(out storage);
		}

		internal static bool IsAdventure<T>(out DialogStorage storage) where T : Adventure
		{
			Adventure adventure = GetAdventure(null);
			storage = ((adventure != null) ? adventure.Storage : null);
			return adventure is T;
		}

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

		internal static List<CardObj> ParseCards(IEnumerable<Card> cards)
		{
			return cards.Select((Card card) => ParseCard(card)).ToList();
		}

		internal static CardObjWithPrice ParseCardWithPrice(Card card, int? price = null)
		{
			return new CardObjWithPrice
			{
				Id = ((GameEntity)card).Id,
				IsUpgraded = card.IsUpgraded,
				UpgradeCounter = card.UpgradeCounter,
				Price = price
			};
		}

		internal static string GetBaseMana(string oldBaseMana, IEnumerable<string> exhibits)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			string text = oldBaseMana;
			foreach (string exhibit in exhibits)
			{
				ExhibitConfig val = ExhibitConfig.FromId(exhibit);
				if ((int)val.Rarity == 3 && !val.BaseManaColor.HasValue)
				{
					text += "A";
				}
			}
			return text;
		}

		internal static void GetData(out Dictionary<string, object> data)
		{
			StationObj currentStation = Controller.CurrentStation;
			data = currentStation.Data ?? (currentStation.Data = new Dictionary<string, object>());
		}

		internal static void AddDataValue<T>(string key, T value)
		{
			GetData(out var data);
			data.Add(key, value);
		}

		internal static void AddDataListItem<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;
		}

		internal static List<T1> GetStorageList<T1, T2>(DialogStorage storage, T2[] keys, string prefix, string suffix = "")
		{
			List<T1> list = new List<T1>();
			object obj = default(object);
			foreach (T2 val in keys)
			{
				string text = $"{prefix}{val}{suffix}";
				storage.TryGetValue<object>(text, ref obj);
				list.Add((T1)obj);
			}
			return list;
		}
	}
	internal class Instance
	{
		internal string Path;

		internal static bool IsInitialized;

		internal int? PreHealHp;

		internal int? BackgroundDancersIndex;

		internal int? DebutUncommonCardsIndex;

		internal bool DebutUncommonCardsChosen;

		internal bool? IsForced;

		internal List<IEnumerable<StationReward>> RewardsBeforeDebut;

		internal bool IsAbandoned;

		internal RunLog RunLog { get; private set; }

		internal Instance(RunLog runLog)
		{
			RunLog = runLog;
		}
	}
	internal class LBoLLogs : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <Post>d__1 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private UnityWebRequest <request>5__1;

			private byte[] <data>5__2;

			private bool <isNew>5__3;

			private Dictionary<string, object> <result>5__4;

			private object <value>5__5;

			private string <url>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0055: Unknown result type (might be due to invalid IL or missing references)
				//IL_005f: Expected O, but got Unknown
				//IL_008b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0095: Expected O, but got Unknown
				//IL_009c: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a6: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					((Component)ObjectsManager.Clone.Find("Upload")).gameObject.SetActive(false);
					UploadPanel.Log("Uploading...");
					<request>5__1 = new UnityWebRequest("https://script.google.com/macros/s/AKfycbxQZf9xkxJX-YNYxXAjssmqT2-HFmH1EPZ6bjbcoz1RxvfWdHoP1eWC8D4XiQkIpmLvbw/exec", "POST");
					<data>5__2 = Encoding.UTF8.GetBytes(Logger.Encode(Controller.Instance.RunLog, addIndent: false));
					<request>5__1.uploadHandler = (UploadHandler)new UploadHandlerRaw(<data>5__2);
					<request>5__1.downloadHandler = (DownloadHandler)new DownloadHandlerBuffer();
					<request>5__1.SetRequestHeader("Content-Type", "application/json");
					<>2__current = <request>5__1.SendWebRequest();
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<isNew>5__3 = HandleResponse(<request>5__1.downloadHandler.text, out <result>5__4);
					if (<isNew>5__3)
					{
						<result>5__4.TryGetValue("url", out <value>5__5);
						<url>5__6 = (string)<value>5__5;
						BepinexPlugin.log.LogDebug((object)<url>5__6);
						UploadPanel.Log("Uploaded", <url>5__6);
						Logger.DeleteLog(Controller.Instance.Path);
						<value>5__5 = null;
						<url>5__6 = null;
					}
					else
					{
						UploadPanel.Log("Upload failed");
					}
					Controller.DestroyInstance();
					return false;
				}
			}

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

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

		internal static void Upload(string description = null)
		{
			if (!Utility.IsNullOrWhiteSpace(description))
			{
				Controller.Instance.RunLog.Description = description;
			}
			((MonoBehaviour)Singleton<GameMaster>.Instance).StartCoroutine(Post());
		}

		[IteratorStateMachine(typeof(<Post>d__1))]
		private static IEnumerator Post()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <Post>d__1(0);
		}

		private static bool HandleResponse(string response, out Dictionary<string, object> result)
		{
			result = null;
			if (Utility.IsNullOrWhiteSpace(response))
			{
				return false;
			}
			result = JsonConvert.DeserializeObject<Dictionary<string, object>>(response);
			if (!result.TryGetValue("isNew", out var value))
			{
				return false;
			}
			return (bool)value;
		}
	}
}
namespace RunLogger.Utils.UploadPanelObjects
{
	internal static class ObjectsManager
	{
		internal static Transform Panel => GetTransformFromGameRunScene("UploadPanel");

		internal static Transform PanelTemp => GetTransformFromGameRunScene("UploadPanelTemp");

		internal static Transform Clone
		{
			get
			{
				UiManager instance = UiManager._instance;
				if ((Object)(object)instance == (Object)null || !Object.op_Implicit((Object)(object)instance))
				{
					return null;
				}
				if (!instance._panelTable.TryGetValue(typeof(GameResultPanel), out var value))
				{
					return null;
				}
				return ((Component)value).transform.Find("UploadPanel(Clone)");
			}
		}

		private static TMP_InputField TmpInput => ((Component)Clone.Find("TextArea/Input/TextFilterInput")).GetComponent<TMP_InputField>();

		internal static string Text
		{
			get
			{
				return TmpInput.text;
			}
			set
			{
				TmpInput.text = value;
			}
		}

		private static Transform GetTransformFromGameRunScene(string name)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			Scene sceneByName = SceneManager.GetSceneByName("GameRun");
			GameObject[] rootGameObjects = ((Scene)(ref sceneByName)).GetRootGameObjects();
			GameObject? obj = Array.Find(rootGameObjects, (GameObject gameObject) => ((Object)gameObject).name == name);
			return (obj != null) ? obj.transform : null;
		}

		internal static Transform GetFromTemp(string path)
		{
			Transform panelTemp = PanelTemp;
			return (panelTemp != null) ? panelTemp.Find(path) : null;
		}

		internal static RectTransform CopyGameObject(Transform transform, string path, Transform parent = null)
		{
			return Object.Instantiate<GameObject>(((Component)transform.Find(path)).gameObject, parent ?? PanelTemp, true).GetComponent<RectTransform>();
		}

		internal static void ChangeText(Transform transform, string text, string color = null)
		{
			LocalizedText component = ((Component)transform).GetComponent<LocalizedText>();
			((Behaviour)component).enabled = false;
			component.key = null;
			((TMP_Text)((Component)transform).GetComponent<TextMeshProUGUI>()).text = ((color == null) ? text : ("<color=#" + color + ">" + text + "</color>"));
		}

		internal static void SetClickEvent(Transform transform, UnityAction call)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Expected O, but got Unknown
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Expected O, but got Unknown
			Button component = ((Component)transform).GetComponent<Button>();
			component.onClick = new ButtonClickedEvent();
			((UnityEvent)component.onClick).AddListener(new UnityAction(call.Invoke));
		}

		internal static void SetTooltip(Transform transform, string title, string description = null)
		{
			SimpleTooltipSource.CreateDirect(((Component)transform).gameObject, title, description).WithPosition((TooltipDirection)1, (TooltipAlignment)0);
		}

		internal static void UpdateStatus(string uploadStatus, string url)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Expected O, but got Unknown
			Transform val = Clone.Find("Status");
			string text = ((url == null) ? uploadStatus : ("<u>" + uploadStatus + "</u>"));
			Transform transform = val.Find("SeedText");
			string color = ((url == null) ? null : ColorUtility.ToHtmlStringRGBA(GlobalConfig.UiBlue));
			ChangeText(transform, text, color);
			if (url != null)
			{
				SetClickEvent(val, (UnityAction)delegate
				{
					Application.OpenURL(url);
				});
			}
		}

		internal static void DestroyClone()
		{
			Transform clone = Clone;
			if ((Object)(object)clone != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)clone).gameObject);
			}
		}
	}
	internal static class PositionsManager
	{
		private const float X = 0f;

		private const float Y = -14.88f;

		private const float BgOffsetX = -3.7f;

		private const float UploadOffsetX = 0.7f;

		private const float StatusOffsetY = 0.06f;

		private const float BoxOffsetY = 5.48f;

		internal const float QuickUploadOffsetX = 0.5f;

		internal const float QuickUploadScale = 0.004f;

		internal const float SwitchOffsetX = -600f;

		internal static Vector3 BgPosition = new Vector3(-3.7f, -14.88f, 10f);

		internal static Vector3 AutoUploadPosition = new Vector3(0f, -14.88f, 10f);

		internal static Vector3 UploadPosition = new Vector3(0.7f, -14.88f, 10f);

		internal static Vector3 StatusPosition = new Vector3(0.7f, -14.82f, 10f);

		internal static Vector3 InputLocalPosition = new Vector3(0f, 100f, 0f);

		internal static Vector3 InputSizeDelta = Vector2.op_Implicit(new Vector2(2000f, 700f));

		internal static Vector3 BoxPosition = new Vector3(0f, -9.4f, 10f);

		internal static Vector3 CountLocalPosition = new Vector3(150f, -340f, 0f);
	}
	internal static class UploadPanel
	{
		internal static bool HasPanel
		{
			get
			{
				//IL_0041: Unknown result type (might be due to invalid IL or missing references)
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				Transform panel = ObjectsManager.Panel;
				if ((Object)(object)panel != (Object)null)
				{
					return true;
				}
				if ((Object)(object)ObjectsManager.PanelTemp == (Object)null)
				{
					panel = new GameObject("UploadPanelTemp", new Type[1] { typeof(RectTransform) }).transform;
					Transform transform = new GameObject("Upload", new Type[1] { typeof(RectTransform) }).transform;
					transform.SetParent(panel, true);
					transform.position = PositionsManager.UploadPosition;
					((Component)transform).gameObject.SetActive(false);
				}
				return false;
			}
		}

		internal static void AdjustPanel()
		{
			if ((Object)(object)ObjectsManager.PanelTemp == (Object)null)
			{
				return;
			}
			Transform fromTemp = ObjectsManager.GetFromTemp("Bg");
			Transform fromTemp2 = ObjectsManager.GetFromTemp("Status");
			Transform fromTemp3 = ObjectsManager.GetFromTemp("AutoUpload");
			Transform fromTemp4 = ObjectsManager.GetFromTemp("Upload");
			Transform fromTemp5 = ObjectsManager.GetFromTemp("TextArea");
			Transform fromTemp6 = ObjectsManager.GetFromTemp("QuickUpload");
			Transform fromTemp7 = ObjectsManager.GetFromTemp("Input");
			if (!((Object)(object)fromTemp == (Object)null) && !((Object)(object)fromTemp2 == (Object)null) && !((Object)(object)fromTemp3 == (Object)null) && !((Object)(object)fromTemp4 == (Object)null) && !((Object)(object)fromTemp5 == (Object)null) && !((Object)(object)fromTemp6 == (Object)null) && !((Object)(object)fromTemp7 == (Object)null))
			{
				Transform val = fromTemp4.Find("Edit");
				fromTemp6.SetParent(fromTemp4, false);
				fromTemp7.SetParent(fromTemp5, true);
				Image component = ((Component)fromTemp7.Find("TextFilterInput")).GetComponent<Image>();
				component.sprite = ((Component)fromTemp).GetComponent<Image>().sprite;
				component.type = (Type)1;
				Transform[] array = (Transform[])(object)new Transform[5] { fromTemp, fromTemp2, fromTemp3, fromTemp4, fromTemp5 };
				for (int i = 0; i < array.Length; i++)
				{
					array[i].SetSiblingIndex(i);
				}
				val.SetAsLastSibling();
				((Object)ObjectsManager.PanelTemp).name = "UploadPanel";
			}
		}

		internal static void Log(string uploadStatus, string url = null)
		{
			ObjectsManager.UpdateStatus(uploadStatus, url);
			BepinexPlugin.log.LogDebug((object)uploadStatus);
		}
	}
}
namespace RunLogger.Utils.RunLogLib
{
	public class ActObj
	{
		public int Act { get; set; }

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


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

		public string Name { get; set; }

		public string Version { get; set; }

		public Dictionary<string, dynamic> Configs { get; set; }
	}
	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 class RunLog
	{
		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 string? Description { 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 StationObj
	{
		public string Type { get; set; }

		public StationNode 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 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; }
	}
}
namespace RunLogger.Utils.RunLogLib.Nodes
{
	public class ActNode
	{
		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 StationNode
	{
		public int Act { get; set; }

		public int Level { get; set; }

		public int Y { get; set; }
	}
}
namespace RunLogger.Utils.RunLogLib.Entities
{
	public class CardChange : CardObj
	{
		public string Type { get; set; }

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

		public bool IsUpgraded { get; set; }

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

		public bool? IsDiscounted { get; set; }
	}
	public enum ChangeType
	{
		Add,
		Remove,
		Upgrade,
		Use
	}
	public class ExhibitChange
	{
		public string Id { get; set; }

		public int? Counter { get; set; }

		public string Type { get; set; }

		public int Station { get; set; }
	}
}
namespace RunLogger.Utils.RunLogLib.BattleDetails
{
	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 IntentionObj
	{
		public string Type { get; set; }

		public int? Damage { get; set; }

		public int? Times { get; set; }

		public bool? IsAccurate { 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 TurnObj
	{
		public int Round { get; set; }

		public int Turn { get; set; }

		public string Id { get; set; }

		public string? Mana { 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; }
	}
}
namespace RunLogger.Utils.Managers
{
	internal static class EntitiesManager
	{
		internal static void AddCardChange(IEnumerable<Card> cards, ChangeType changeType)
		{
			foreach (Card card in cards)
			{
				CardChange item = new CardChange
				{
					Id = ((GameEntity)card).Id,
					IsUpgraded = card.IsUpgraded,
					UpgradeCounter = card.UpgradeCounter,
					Type = changeType.ToString(),
					Station = Controller.CurrentStationIndex
				};
				Controller.Instance.RunLog.Cards.Add(item);
			}
		}

		internal static void AddExhibitChange(Exhibit exhibit, ChangeType changeType, int? counter = null, int offset = 0)
		{
			ExhibitChange item = new ExhibitChange
			{
				Id = ((GameEntity)exhibit).Id,
				Counter = counter,
				Type = changeType.ToString(),
				Station = Controller.CurrentStationIndex + offset
			};
			Controller.Instance.RunLog.Exhibits.Add(item);
		}
	}
	internal static class RewardsManager
	{
		internal static void GetRewards(out Dictionary<string, object> rewards)
		{
			StationObj currentStation = Controller.CurrentStation;
			rewards = currentStation.Rewards ?? (currentStation.Rewards = new Dictionary<string, object>());
		}

		internal static void AddCardsRewards(Interaction interaction)
		{
			MiniSelectCardInteraction val = (MiniSelectCardInteraction)(object)((interaction is MiniSelectCardInteraction) ? interaction : null);
			IReadOnlyList<Card> cards = ((val == null) ? ((SelectCardInteraction)((interaction is SelectCardInteraction) ? interaction : null)).PendingCards : val.PendingCards);
			List<CardObj> item = Helpers.ParseCards(cards);
			GetRewards(out var rewards);
			rewards.Add("Cards", new List<List<CardObj>> { item });
		}

		internal static void AddExhibitRewards(Exhibit exhibit)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Expected O, but got Unknown
			StationReward reward = new StationReward
			{
				Type = (StationRewardType)2,
				Exhibit = exhibit
			};
			AddReward(reward);
		}

		private static void AddEntitiesRewardsListItem<T>(string type, T listItem)
		{
			string key = type + "s";
			GetRewards(out var rewards);
			if (!rewards.TryGetValue(key, out var value))
			{
				rewards[key] = new List<T>();
			}
			List<T> list = (value ?? rewards[key]) as List<T>;
			list.Add(listItem);
		}

		internal static void AddReward(StationReward reward)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: 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_001f: 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: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Expected I4, but got Unknown
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			GetRewards(out var rewards);
			StationRewardType type = reward.Type;
			string text = ((object)(StationRewardType)(ref type)).ToString();
			StationRewardType val = type;
			StationRewardType val2 = val;
			switch ((int)val2)
			{
			case 0:
				rewards[text] = reward.Money;
				break;
			case 1:
			case 3:
			{
				List<CardObj> listItem = Helpers.ParseCards(reward.Cards);
				StationRewardType val3 = (StationRewardType)1;
				AddEntitiesRewardsListItem(((object)(StationRewardType)(ref val3)).ToString(), listItem);
				break;
			}
			case 2:
			{
				string id = ((GameEntity)reward.Exhibit).Id;
				AddEntitiesRewardsListItem(text, id);
				break;
			}
			default:
				BepinexPlugin.log.LogDebug((object)("Reward of type `" + text + "` is ignored"));
				break;
			}
		}

		internal static void AddRewards(IEnumerable<StationReward> rewards)
		{
			foreach (StationReward reward in rewards)
			{
				AddReward(reward);
			}
		}
	}
	internal static class TurnObjManager
	{
		internal static void GetLastTurnObj(out TurnObj turnObj)
		{
			List<TurnObj> list = Controller.CurrentStation.Data["Details"] as List<TurnObj>;
			turnObj = list[list.Count - 1];
		}

		internal static void AppendTurnObj(int round, int turn, string id, string mana = null, List<CardObj> cards = null)
		{
			TurnObj item = new TurnObj
			{
				Round = round,
				Turn = turn,
				Id = id,
				Mana = mana,
				Cards = cards
			};
			Helpers.AddDataListItem("Details", item);
		}

		internal static void UpdateTurnObj(Unit unit)
		{
			GetLastTurnObj(out var turnObj);
			turnObj.Status = GetStatus(unit);
			turnObj.StatusEffects = GetStatusEffects(unit);
		}

		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();
		}
	}
}
namespace RunLogger.Utils.LogFile
{
	internal static class FileManager
	{
		private static string GetDirectory(string subDir)
		{
			List<string> list = new List<string> { "runLogger" };
			if (!BasicTypeExtensions.IsNullOrEmpty(subDir))
			{
				list.Add(subDir);
			}
			string[] paths = list.ToArray();
			string text = Path.Combine(paths);
			if (!Directory.Exists(text))
			{
				Directory.CreateDirectory(text);
			}
			return text;
		}

		internal static string GetFilePath(string name, string extension, string subDir)
		{
			string directory = GetDirectory(subDir);
			string path = name + "." + extension;
			return Path.Combine(directory, path);
		}

		internal static string ReadFile(string path)
		{
			if (!File.Exists(path))
			{
				return null;
			}
			return File.ReadAllText(path);
		}

		internal static void WriteFile(string path, string text)
		{
			File.WriteAllText(path, text);
		}
	}
	internal static class Logger
	{
		private static string ProfileName => Helpers.CurrentSaveIndex.ToString();

		internal static string Encode(RunLog runLog, bool addIndent)
		{
			//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_001b: Expected O, but got Unknown
			return JsonConvert.SerializeObject((object)runLog, (Formatting)(addIndent ? 1 : 0), new JsonSerializerSettings
			{
				NullValueHandling = (NullValueHandling)1
			});
		}

		private static RunLog Decode(string jsonString)
		{
			try
			{
				if (!string.IsNullOrEmpty(jsonString))
				{
					return JsonConvert.DeserializeObject<RunLog>(jsonString);
				}
			}
			catch (Exception ex)
			{
				BepinexPlugin.log.LogDebug((object)ex);
				DeleteTemp();
			}
			return null;
		}

		private static RunLog Read(string path)
		{
			string jsonString = FileManager.ReadFile(path);
			return Decode(jsonString);
		}

		private static void Write(string path, bool addIndent)
		{
			RunLog runLog = Controller.Instance.RunLog;
			if (runLog != null)
			{
				string text = Encode(runLog, addIndent);
				FileManager.WriteFile(path, text);
			}
		}

		private static string GetTempPath()
		{
			string profileName = ProfileName;
			string subDir = "temp";
			return FileManager.GetFilePath(profileName, "txt", subDir);
		}

		private static string GetLogPath(string name)
		{
			string subDir = (BepinexPlugin.SaveTogether.Value ? null : ProfileName);
			string filePath = FileManager.GetFilePath(name, "json", subDir);
			BepinexPlugin.log.LogDebug((object)("Log saved: " + filePath));
			return filePath;
		}

		internal static void SaveTemp(TempSaveTiming tempSaveTiming)
		{
			string tempPath = GetTempPath();
			Write(tempPath, addIndent: true);
			BepinexPlugin.log.LogDebug((object)$"Temp save timing: {tempSaveTiming}");
		}

		internal static RunLog LoadTemp()
		{
			string tempPath = GetTempPath();
			return Read(tempPath);
		}

		internal static void DeleteTemp()
		{
			string tempPath = GetTempPath();
			File.Delete(tempPath);
		}

		internal static void SaveLog(string name)
		{
			string logPath = GetLogPath(name);
			Write(logPath, addIndent: false);
			Controller.Instance.Path = logPath;
		}

		internal static void DeleteLog(string path)
		{
			File.Delete(path);
		}
	}
}
namespace RunLogger.Utils.Enums
{
	internal static class FilenameExtension
	{
		internal const string Temp = "txt";

		internal const string Log = "json";
	}
	internal enum TempSaveTiming
	{
		EnterStage,
		EnterMapNode,
		BattleFinish,
		Adventure
	}
	internal static class UploadStatus
	{
		internal const string Uploading = "Uploading...";

		internal const string Uploaded = "Uploaded";

		internal const string Failed = "Upload failed";

		internal const string NotSaved = "Log not saved";
	}
}
namespace RunLogger.Patches.SaveData
{
	internal static class CreateTemp
	{
		[HarmonyPatch(typeof(GameRunController), "Create")]
		private static class StartRun
		{
			private static void Prefix()
			{
				BepinexPlugin.log.LogDebug((object)"Start run");
				Controller.CreateInstance(new RunLog());
			}

			private static void Postfix(GameRunStartupParameters parameters, GameRunController __result)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0060: Unknown result type (might be due to invalid IL or missing references)
				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[] priorityMods = Configs.PriorityMods;
				foreach (string key in priorityMods)
				{
					if (pluginInfos.TryGetValue(key, out var value))
					{
						list2.Add(ParseMod(value));
					}
				}
				foreach (var (text2, pluginInfo) in pluginInfos)
				{
					if (!Configs.PriorityMods.Contains(text2) && !Configs.ExcludedMods.Contains(text2))
					{
						if (text2 == "neo.lbol.qol.helpMeEirin")
						{
							hasClearBonus = true;
						}
						Mod mod = ParseMod(pluginInfo);
						if (text2 == "rmrfmaxx.lbol.PatchouliCharacterMod")
						{
							mod.Configs = PatchouliModWrapper.GetConfigs();
						}
						list2.Add(mod);
					}
				}
				Controller.Instance.RunLog.Version = VersionInfo.Current.Version;
				if (BepinexPlugin.SaveProfileName.Value)
				{
					Controller.Instance.RunLog.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;
				}
				Controller.Instance.RunLog.Settings = settings;
			}

			private static Mod ParseMod(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]
	internal static class LoadTemp
	{
		[HarmonyPatch(typeof(GameRunController), "Restore")]
		[HarmonyPrefix]
		private static void RestoreRun()
		{
			BepinexPlugin.log.LogDebug((object)"Trying to restore run...");
			RunLog runLog = Logger.LoadTemp();
			if (runLog == null)
			{
				BepinexPlugin.log.LogDebug((object)"Run restore failed");
				return;
			}
			Controller.CreateInstance(runLog);
			BepinexPlugin.log.LogDebug((object)"Run restored");
		}
	}
	[HarmonyPatch]
	internal static class SaveLog
	{
		[HarmonyPatch(typeof(GameRunController), "AbandonGameRun")]
		[HarmonyPostfix]
		private static void SetIsAbandoned()
		{
			if (Instance.IsInitialized)
			{
				Controller.Instance.IsAbandoned = true;
			}
		}

		[HarmonyPatch(typeof(GameMaster), "SaveProfileWithEndingGameRun")]
		[HarmonyPostfix]
		private static void EndRun(GameRunController gameRun, GameRunRecordSaveData gameRunRecord)
		{
			if (Instance.IsInitialized)
			{
				BepinexPlugin.log.LogDebug((object)"End run");
				EndRunInternal(gameRun, gameRunRecord);
				Logger.DeleteTemp();
			}
		}

		private static void EndRunInternal(GameRunController gameRun, GameRunRecordSaveData gameRunRecord)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (Controller.Instance.IsAbandoned && !BepinexPlugin.SaveAbandoned.Value)
			{
				return;
			}
			Helpers.AddStatus(gameRun, Controller.CurrentStation, null);
			string text = ((object)(GameResultType)(ref gameRunRecord.ResultType)).ToString();
			bool value = BepinexPlugin.SaveFailure.Value;
			GameResultType val = (GameResultType)0;
			bool flag = text == ((object)(GameResultType)(ref val)).ToString();
			if (value || !flag)
			{
				string saveTimestamp = gameRunRecord.SaveTimestamp;
				List<CardObj> cards = gameRunRecord.Cards.Select((CardRecordSaveData card) => new CardObj
				{
					Id = card.Id,
					IsUpgraded = card.Upgraded,
					UpgradeCounter = card.UpgradeCounter
				}).ToList();
				List<string> list = gameRunRecord.Exhibits.ToList();
				string baseMana = Helpers.GetBaseMana(gameRunRecord.BaseMana, list);
				int reloadTimes = gameRunRecord.ReloadTimes;
				string seed = RandomGen.SeedToString(gameRunRecord.Seed);
				Result result = new Result
				{
					Type = text,
					Timestamp = saveTimestamp,
					Cards = cards,
					Exhibits = list,
					BaseMana = baseMana,
					ReloadTimes = reloadTimes,
					Seed = seed
				};
				Controller.Instance.RunLog.Result = result;
				string text2 = saveTimestamp.Replace(":", "-");
				string player = gameRunRecord.Player;
				string text3 = gameRunRecord.PlayerType.ToString().Replace("Type", "");
				string text4 = list[0];
				Settings settings = Controller.Instance.RunLog.Settings;
				char c = settings.Difficulty[0];
				int count = settings.Requests.Count;
				string name = string.Join("_", text2, player, text3, text4, $"{c}{count}", text);
				Logger.SaveLog(name);
			}
		}
	}
	[HarmonyPatch]
	internal static class SaveTemp
	{
		[HarmonyPatch(typeof(GameMaster), "SaveGameRun")]
		[HarmonyPrefix]
		private static void SaveTempInAdventure(GameRunSaveData data, bool normalSave)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			if (Instance.IsInitialized && (int)data.Timing == 4 && normalSave)
			{
				Logger.SaveTemp(TempSaveTiming.Adventure);
			}
		}
	}
	[HarmonyPatch]
	internal static class SelectProfile
	{
		[HarmonyPatch(typeof(GameMaster), "SelectProfile")]
		[HarmonyPostfix]
		private static void DestroyInstance()
		{
			BepinexPlugin.log.LogDebug((object)$"Profile #{Helpers.CurrentSaveIndex} selected");
			Controller.DestroyInstance();
		}
	}
}
namespace RunLogger.Patches.RunLogPatches
{
	[HarmonyPatch]
	internal static class ActObjPatch
	{
		[HarmonyPatch(typeof(GameRunController), "EnterStage")]
		[HarmonyPostfix]
		private static void NewAct(GameRunController __instance)
		{
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			if (!Instance.IsInitialized)
			{
				return;
			}
			int level = __instance.CurrentStage.Level;
			GameMap currentMap = __instance.CurrentMap;
			string bossId = currentMap.BossId;
			List<ActNode> list = new List<ActNode>();
			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)
					{
						ActNode obj = new ActNode
						{
							X = val.X,
							Y = val.Y,
							Followers = val.FollowerList
						};
						StationType stationType = val.StationType;
						obj.Type = ((object)(StationType)(ref stationType)).ToString();
						ActNode item = obj;
						list.Add(item);
					}
				}
			}
			ActObj item2 = new ActObj
			{
				Act = level,
				Nodes = list,
				Boss = bossId
			};
			Controller.Instance.RunLog.Acts.Add(item2);
			Logger.SaveTemp(TempSaveTiming.EnterStage);
		}

		[HarmonyPatch(typeof(GameMaster), "SelectStationFlow")]
		[HarmonyPostfix]
		private static void AddBoss(ref IEnumerator __result)
		{
			if (Instance.IsInitialized)
			{
				EnumeratorHook enumeratorHook = new EnumeratorHook();
				enumeratorHook.enumerator = __result;
				enumeratorHook.postfixAction = postfixAction;
				EnumeratorHook enumeratorHook2 = enumeratorHook;
				__result = enumeratorHook2.GetEnumerator();
			}
			static void postfixAction()
			{
				Station currentStation = Helpers.CurrentStation;
				SelectStation val = (SelectStation)(object)((currentStation is SelectStation) ? currentStation : null);
				string selectedBoss = ((Station)val).Stage.SelectedBoss;
				Controller.Instance.RunLog.Acts[0].Boss = selectedBoss;
			}
		}
	}
	[HarmonyPatch]
	internal static class CardChangePatch
	{
		[HarmonyPatch(typeof(GameRunController), "InternalAddDeckCards")]
		[HarmonyPostfix]
		private static void AddCardsPatch(Card[] cards)
		{
			if (Instance.IsInitialized)
			{
				EntitiesManager.AddCardChange(cards, ChangeType.Add);
			}
		}

		[HarmonyPatch(typeof(GameRunController), "RemoveDeckCards")]
		[HarmonyPrefix]
		private static void RemoveCardsPatch(IEnumerable<Card> cards)
		{
			if (Instance.IsInitialized)
			{
				EntitiesManager.AddCardChange(cards, ChangeType.Remove);
			}
		}

		[HarmonyPatch(typeof(GameRunController), "UpgradeDeckCards")]
		[HarmonyPostfix]
		private static void UpgradeCardsPatch(IEnumerable<Card> cards)
		{
			if (Instance.IsInitialized)
			{
				EntitiesManager.AddCardChange(cards, ChangeType.Upgrade);
			}
		}
	}
	[HarmonyPatch]
	internal static class ExhibitChangePatch
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static class UseAndUpgrade
		{
			private static readonly string[] Exhibits = new string[5] { "GanzhuYao", "ChuRenou", "TiangouYuyi", "Moping", "Baota" };

			private static void Prefix(int value, Exhibit __instance)
			{
				//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
				if (!Instance.IsInitialized)
				{
					return;
				}
				if (!Exhibits.Contains(((GameEntity)__instance).Id) || ((GameEntity)__instance).GameRun == null)
				{
					return;
				}
				int num = value - __instance.Counter;
				if (num < 0)
				{
					if (!(__instance is TiangouYuyi) || Controller.CurrentStation.Type == ((object)(StationType)(ref ((GameEntity)__instance).GameRun.StageRecords.LastOrDefault().Stations.LastOrDefault().Type)).ToString())
					{
						EntitiesManager.AddExhibitChange(__instance, ChangeType.Use, value);
					}
				}
				else
				{
					if (num <= 0)
					{
						return;
					}
					int offset = 0;
					if (__instance is Moping)
					{
						string type = Controller.CurrentStation.Type;
						StationType type2 = ((GameEntity)__instance).GameRun.CurrentStation.Type;
						if (!(type != ((object)(StationType)(ref type2)).ToString()))
						{
							return;
						}
						offset = 1;
					}
					EntitiesManager.AddExhibitChange(__instance, ChangeType.Upgrade, value, offset);
				}
			}

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

		[HarmonyPatch(typeof(GameRunController), "GainExhibitRunner")]
		[HarmonyPostfix]
		[HarmonyPriority(400)]
		private static void Add(Exhibit exhibit)
		{
			if (Instance.IsInitialized)
			{
				EntitiesManager.AddExhibitChange(exhibit, ChangeType.Add);
			}
		}

		[HarmonyPatch(typeof(GameRunController), "LoseExhibit")]
		[HarmonyPostfix]
		private static void Remove(Exhibit exhibit)
		{
			if (Instance.IsInitialized)
			{
				EntitiesManager.AddExhibitChange(exhibit, ChangeType.Remove);
			}
		}
	}
}
namespace RunLogger.Patches.RunLogPatches.StationObjPatches
{
	[HarmonyPatch]
	internal static class EnemyGroupIdPatch
	{
		[HarmonyPatch(typeof(GameRunController), "LeaveBattle")]
		[HarmonyPostfix]
		private static void AddEnemyGroupId(EnemyGroup enemyGroup, GameRunController __instance)
		{
			if (Instance.IsInitialized)
			{
				string adventureId = Helpers.GetAdventureId(__instance.CurrentStation);
				if (adventureId != null)
				{
					Helpers.AddDataValue("Id", enemyGroup.Id);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class StationObjPatch
	{
		[HarmonyPatch(typeof(GameRunController), "EnterMapNode")]
		[HarmonyPrefix]
		private static void GetForced(bool forced)
		{
			if (Instance.IsInitialized)
			{
				Controller.Instance.IsForced = forced;
			}
		}

		[HarmonyPatch(typeof(GameRunController), "EnterStation")]
		[HarmonyPostfix]
		private static void NewStation(Station station, GameRunController __instance)
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			if (!Instance.IsInitialized)
			{
				return;
			}
			bool? isForced = Controller.Instance.IsForced;
			Controller.Instance.IsForced = null;
			if (isForced.GetValueOrDefault())
			{
				return;
			}
			int level = station.Stage.Level;
			int level2 = station.Level;
			MapNode visitingNode = __instance.CurrentMap.VisitingNode;
			int y = visitingNode.Y;
			StationType stationType = visitingNode.StationType;
			string type = ((object)(StationType)(ref stationType)).ToString();
			StationNode node = new StationNode
			{
				Act = level,
				Level = level2,
				Y = y
			};
			StationObj stationObj = new StationObj
			{
				Type = type,
				Node = node
			};
			string adventureId = Helpers.GetAdventureId(station);
			if (adventureId != null)
			{
				stationObj.Id = adventureId;
			}
			else
			{
				adventureId = Helpers.GetEnemyGroupId(station);
				stationObj.Id = adventureId;
			}
			Controller.Instance.RunLog.Stations.Add(stationObj);
			List<IEnumerable<StationReward>> rewardsBeforeDebut = Controller.Instance.RewardsBeforeDebut;
			if (rewardsBeforeDebut == null)
			{
				return;
			}
			foreach (IEnumerable<StationReward> item in rewardsBeforeDebut)
			{
				RewardsManager.AddRewards(item);
			}
			Controller.Instance.RewardsBeforeDebut = null;
		}

		[HarmonyPatch(typeof(BattleAdvTestStation), "SetEnemy")]
		[HarmonyPostfix]
		private static void AddEnemyGroupId(EnemyGroupEntry entry)
		{
			if (Instance.IsInitialized)
			{
				Controller.CurrentStation.Id = entry.Id;
			}
		}

		[HarmonyPatch(typeof(BattleAdvTestStation), "SetAdventure")]
		[HarmonyPostfix]
		private static void AddAdventureId(Adventure adventure)
		{
			if (Instance.IsInitialized)
			{
				Controller.CurrentStation.Id = adventure.Id;
			}
		}
	}
	[HarmonyPatch]
	internal static class StatusPatch
	{
		[HarmonyPatch(typeof(GameMaster), "SaveGameRun")]
		[HarmonyPrefix]
		private static void AddStatus(GameRunSaveData data, bool normalSave, GameMaster __instance)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			if (Instance.IsInitialized && (int)data.Timing == 1 && normalSave)
			{
				BepinexPlugin.log.LogDebug((object)"Add `Status`");
				GameRunController currentGameRun = __instance.CurrentGameRun;
				Helpers.AddStatus(currentGameRun, Controller.LastStation, Controller.Instance.PreHealHp);
				Controller.Instance.PreHealHp = null;
				Logger.SaveTemp(TempSaveTiming.EnterMapNode);
			}
		}

		[HarmonyPatch(typeof(GameRunController), "EnterNextStage")]
		[HarmonyPrefix]
		private static void AddStatusFix(GameRunController __instance)
		{
			if (Instance.IsInitialized)
			{
				PlayerUnit player = __instance.Player;
				Controller.Instance.PreHealHp = ((Unit)player).Hp;
			}
		}
	}
}
namespace RunLogger.Patches.RunLogPatches.StationObjPatches.DataPatches
{
	[HarmonyPatch]
	internal static class ChoicesPatch
	{
		[HarmonyPatch(typeof(DialogRunner), "SelectOption")]
		[HarmonyPostfix]
		private static void AddChoices(int id)
		{
			if (Instance.IsInitialized)
			{
				Helpers.AddDataListItem("Choices", id);
			}
		}
	}
	[HarmonyPatch]
	internal static class ExhibitsRewardsPatch
	{
		[HarmonyPatch(typeof(InteractionViewer), "View")]
		[HarmonyPrefix]
		private static void AddRewards(Interaction interaction)
		{
			if (!Instance.IsInitialized)
			{
				return;
			}
			GameEntity source = interaction.Source;
			string text = ((source != null) ? source.Id : null);
			if (text == null)
			{
				return;
			}
			RewardInteraction val = (RewardInteraction)(object)((interaction is RewardInteraction) ? interaction : null);
			if (val != null)
			{
				if (!(text == "HuiyeBaoxiang"))
				{
					return;
				}
				IReadOnlyList<Exhibit> pendingExhibits = val.PendingExhibits;
				RewardsManager.GetRewards(out var rewards);
				if (!rewards.TryGetValue("Exhibits", out var value))
				{
					rewards["Exhibits"] = new List<string>();
				}
				List<string> list = (value ?? rewards["Exhibits"]) as List<string>;
				{
					foreach (Exhibit item in pendingExhibits)
					{
						list.Add(((GameEntity)item).Id);
					}
					return;
				}
			}
			MiniSelectCardInteraction val2 = (MiniSelectCardInteraction)(object)((interaction is MiniSelectCardInteraction) ? interaction : null);
			if (val2 == null)
			{
				return;
			}
			if (text == "Modaoshu")
			{
				IReadOnlyList<Card> pendingCards = val2.PendingCards;
				RewardsManager.GetRewards(out var rewards2);
				if (!rewards2.TryGetValue("Cards", out var value2))
				{
					rewards2["Cards"] = new List<List<CardObj>>();
				}
				object obj = value2 ?? rewards2["Cards"];
				if (obj is List<List<CardObj>> list2)
				{
					list2.Add(new List<CardObj>());
					list2[list2.Count - 1] = Helpers.ParseCards(pendingCards);
				}
				else if (obj is List<List<CardObjWithPrice>> list3)
				{
					list3.Add(new List<CardObjWithPrice>());
					list3[list3.Count - 1] = pendingCards.Select((Card card) => Helpers.ParseCardWithPrice(card)).ToList();
				}
			}
			else if (text == "FixBook")
			{
				IReadOnlyList<Card> pendingCards2 = val2.PendingCards;
				List<List<CardObj>> value3 = new List<List<CardObj>> { Helpers.ParseCards(pendingCards2) };
				RewardsManager.GetRewards(out var rewards3);
				rewards3["Cards"] = value3;
			}
		}
	}
	[HarmonyPatch]
	internal static class GapPatch
	{
		[HarmonyPatch(typeof(GapOptionsPanel), "OnShowing")]
		[HarmonyPostfix]
		private static void AddOptions(GapStation gapStation)
		{
			if (Instance.IsInitialized)
			{
				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();
				Helpers.AddDataValue("Options", value);
			}
		}

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

		[HarmonyPatch(typeof(SelectCardPanel), "ShowMiniSelect")]
		[HarmonyPrefix]
		private static void AddShanliangDengpao(SelectCardPayload payload)
		{
			if (Instance.IsInitialized && ((GapOption)Library.CreateGapOption<GetRareCard>()).Name == payload.Name)
			{
				List<CardObj> value = Helpers.ParseCards(payload.Cards);
				Helpers.AddDataValue("ShanliangDengpao", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class OpponentsPatch
	{
		[HarmonyPatch(typeof(SelectStation), "GenerateRecord")]
		[HarmonyPostfix]
		private static void AddOpponents(SelectStation __instance)
		{
			if (Instance.IsInitialized)
			{
				List<string> value = __instance.Opponents.Select((EnemyUnit opponent) => ((GameEntity)opponent).Id).ToList();
				Helpers.AddDataValue("Opponents", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class RewardsPatch
	{
		[HarmonyPatch(typeof(Station), "AddRewards", new Type[] { typeof(IEnumerable<StationReward>) })]
		[HarmonyPrefix]
		private static void AddRewards(IEnumerable<StationReward> rewards)
		{
			if (!Instance.IsInitialized)
			{
				return;
			}
			if (Helpers.IsAdventure<Debut>())
			{
				if (Controller.CurrentStation == null)
				{
					Instance instance = Controller.Instance;
					List<IEnumerable<StationReward>> list = instance.RewardsBeforeDebut ?? (instance.RewardsBeforeDebut = new List<IEnumerable<StationReward>>());
					list.Add(rewards);
				}
			}
			else
			{
				RewardsManager.AddRewards(rewards);
			}
		}

		[HarmonyPatch(typeof(BossStation), "GenerateBossRewards")]
		[HarmonyPostfix]
		private static void AddBossExhibits(BossStation __instance)
		{
			if (Instance.IsInitialized)
			{
				Exhibit[] bossRewards = __instance.BossRewards;
				foreach (Exhibit exhibit in bossRewards)
				{
					RewardsManager.AddExhibitRewards(exhibit);
				}
			}
		}

		[HarmonyPatch(typeof(Stage), "GetEnemyCardReward")]
		[HarmonyPostfix]
		private static void AddExtraCardsReward(StationReward __result)
		{
			if (Instance.IsInitialized)
			{
				Station currentStation = Helpers.CurrentStation;
				if (currentStation is EnemyStation && currentStation.Rewards.Count != 0)
				{
					RewardsManager.AddReward(__result);
				}
			}
		}

		[HarmonyPatch(typeof(Stage), "GetEliteEnemyExhibit")]
		[HarmonyPostfix]
		private static void AddExtraExhibitReward(Exhibit __result)
		{
			if (Instance.IsInitialized)
			{
				Station currentStation = Helpers.CurrentStation;
				if (currentStation is EliteEnemyStation && currentStation.Rewards.Count != 0)
				{
					RewardsManager.AddExhibitRewards(__result);
				}
			}
		}

		[HarmonyPatch(typeof(StationReward), "CreateToolCard")]
		[HarmonyPostfix]
		private static void GetShopToolCardsPatch(StationReward __result)
		{
			if (Instance.IsInitialized)
			{
				Station currentStation = Helpers.CurrentStation;
				if (currentStation is BattleStation)
				{
					RewardsManager.AddReward(__result);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class RoundsPatch
	{
		[HarmonyPatch(typeof(GameRunController), "LeaveBattle")]
		[HarmonyPostfix]
		private static void AddRounds(BattleStats __result)
		{
			if (Instance.IsInitialized)
			{
				int totalRounds = __result.TotalRounds;
				Helpers.AddDataValue("Rounds", totalRounds);
			}
		}

		[HarmonyPatch(typeof(GameMaster), "SaveGameRun")]
		[HarmonyPrefix]
		private static void SaveTemp(GameRunSaveData data, bool normalSave)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			if (Instance.IsInitialized && (int)data.Timing == 2 && normalSave)
			{
				Logger.SaveTemp(TempSaveTiming.BattleFinish);
			}
		}
	}
	[HarmonyPatch]
	internal static class ShopPatch
	{
		[HarmonyPatch(typeof(GameRunController), "EnterMapNode")]
		[HarmonyPostfix]
		private static void AddData(bool forced, GameRunController __instance)
		{
			if (!Instance.IsInitialized)
			{
				return;
			}
			Station currentStation = __instance.CurrentStation;
			ShopStation val = (ShopStation)(object)((currentStation is ShopStation) ? currentStation : null);
			if (val == null)
			{
				return;
			}
			List<CardObjWithPrice> list = val.ShopCards.Select((ShopItem<Card> item) => Helpers.ParseCardWithPrice(item.Content, item.Price)).ToList();
			list[val.DiscountCardNo].IsDiscounted = true;
			Dictionary<string, int> dictionary = new Dictionary<string, int>
			{
				{ "Remove", val.RemoveDeckCardPrice },
				{ "Upgrade", val.UpgradeDeckCardPrice }
			};
			List<ShopItem<Exhibit>> shopExhibits = val.ShopExhibits;
			List<string> list2 = new List<string>();
			foreach (ShopItem<Exhibit> item in shopExhibits)
			{
				string id = ((GameEntity)item.Content).Id;
				dictionary[id] = item.Price;
				list2.Add(id);
			}
			Dictionary<string, object> rewards = new Dictionary<string, object>
			{
				{
					"Cards",
					new List<List<CardObjWithPrice>> { list }
				},
				{ "Exhibits", list2 }
			};
			Controller.CurrentStation.Rewards = rewards;
			if (forced)
			{
				Helpers.GetData(out var data);
				data["Prices"] = dictionary;
			}
			else
			{
				Helpers.AddDataValue("Prices", dictionary);
			}
		}

		[HarmonyPatch(typeof(ShopStation), "RemoveDeckCard")]
		[HarmonyPrefix]
		private static void AddRemove(Card card)
		{
			if (Instance.IsInitialized)
			{
				Helpers.AddDataValue("Choice", 0);
				Helpers.AddDataValue("Remove", Helpers.ParseCard(card));
			}
		}

		[HarmonyPatch(typeof(ShopStation), "UpgradeDeckCard")]
		[HarmonyPrefix]
		private static void AddUpgrade(Card card)
		{
			if (Instance.IsInitialized)
			{
				Helpers.AddDataValue("Choice", 1);
				Helpers.AddDataValue("Upgrade", Helpers.ParseCard(card));
			}
		}

		[HarmonyPatch(typeof(ShopStation), "GetPrice", new Type[]
		{
			typeof(Card),
			typeof(bool)
		})]
		[HarmonyPostfix]
		private static void AddExtraCard(Card card, int __result, ShopStation __instance)
		{
			if (!Instance.IsInitialized)
			{
				return;
			}
			if (!IsOnEnter(__instance))
			{
				Controller.CurrentStation.Rewards.TryGetValue("Cards", out object value);
				List<List<CardObjWithPrice>> list = value as List<List<CardObjWithPrice>>;
				if (list.Count <= 1 || !list[1][0].Price.HasValue)
				{
					list.Insert(1, new List<CardObjWithPrice>());
				}
				List<CardObjWithPrice> list2 = list[1];
				int price = GetPrice(__instance, __result);
				list2.Add(Helpers.ParseCardWithPrice(card, price));
			}
		}

		[HarmonyPatch(typeof(ShopStation), "GetPrice", new Type[] { typeof(Exhibit) })]
		[HarmonyPostfix]
		private static void AddExtraExhibit(Exhibit exhibit, int __result, ShopStation __instance)
		{
			if (Instance.IsInitialized && !(exhibit is KongZhanpinhe))
			{
				if (!IsOnEnter(__instance))
				{
					Controller.CurrentStation.Rewards.TryGetValue("Exhibits", out object value);
					List<string> list = value as List<string>;
					int price = GetPrice(__instance, __result);
					string id = ((GameEntity)exhibit).Id;
					list.Add(id);
					Helpers.GetData(out var data);
					data.TryGetValue("Prices", out var value2);
					Dictionary<string, int> dictionary = value2 as Dictionary<string, int>;
					dictionary.Add(id, price);
				}
			}
		}

		private static bool IsOnEnter(ShopStation shopStation)
		{
			return shopStation.ShopExhibits == null;
		}

		private static int GetPrice(ShopStation shopStation, int basePrice)
		{
			return (int)(((Station)shopStation).GameRun.FinalShopPriceMultiplier * (float)basePrice);
		}
	}
	[HarmonyPatch]
	internal static class TeammatesPatch
	{
		[HarmonyPatch(typeof(Cirno), "SetNextBuff")]
		[HarmonyPrefix]
		private static void AddTeammates(Cirno __instance)
		{
			if (Instance.IsInitialized)
			{
				Type nextBuff = __instance.NextBuff;
				if (!(nextBuff == null))
				{
					string name = nextBuff.Name;
					int nextLevel = __instance.NextLevel;
					StatusEffectObj item = new StatusEffectObj
					{
						Id = name,
						Level = nextLevel
					};
					Helpers.AddDataListItem("Teammates", item);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class ValuesPatch
	{
		[HarmonyPatch(typeof(DialogFunctions), "AdventureRand")]
		[HarmonyPostfix]
		private static void AddValues(int __result)
		{
			if (Instance.IsInitialized)
			{
				Helpers.AddDataListItem("Values", __result);
			}
		}
	}
}
namespace RunLogger.Patches.RunLogPatches.StationObjPatches.DataPatches.EventPatches
{
	[HarmonyPatch]
	internal static class AssistKagerouPatch
	{
		[HarmonyPatch(typeof(AssistKagerou), "InitVariables")]
		[HarmonyPostfix]
		private static void AddExhibit(AssistKagerou __instance)
		{
			if (Instance.IsInitialized && Controller.ShowRandomResult)
			{
				string value = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$exhibitReward", ref value);
				Helpers.AddDataValue("Exhibit", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class BackgroundDancersPatch
	{
		[HarmonyPatch(typeof(BackgroundDancers), "InitVariables")]
		[HarmonyPostfix]
		private static void AddHp(BackgroundDancers __instance)
		{
			if (Instance.IsInitialized)
			{
				float num = default(float);
				((Adventure)__instance).Storage.TryGetValue<float>("$hpLose", ref num);
				Helpers.AddDataValue("Hp", (int)num);
			}
		}

		[HarmonyPatch(typeof(BackgroundDancers), "RollOptions")]
		[HarmonyPostfix]
		private static void AddOptionsAndData(BackgroundDancers __instance, int[] ____optionIndices)
		{
			if (Instance.IsInitialized)
			{
				Helpers.AddDataValue("Options", ____optionIndices.ToList());
				foreach (int option in ____optionIndices)
				{
					HandleRandom(__instance, option);
				}
			}
		}

		[HarmonyPatch(typeof(BackgroundDancers), "SelectOption")]
		[HarmonyPostfix]
		private static void AddData(int index, ref IEnumerator __result)
		{
			if (Instance.IsInitialized)
			{
				EnumeratorHook enumeratorHook = new EnumeratorHook();
				enumeratorHook.enumerator = __result;
				enumeratorHook.postfixAction = postfixAction;
				EnumeratorHook enumeratorHook2 = enumeratorHook;
				Controller.Instance.BackgroundDancersIndex = index - 1;
				__result = enumeratorHook2.GetEnumerator();
			}
			static void postfixAction()
			{
				Adventure adventure = Helpers.GetAdventure(null);
				BackgroundDancers val = (BackgroundDancers)(object)((adventure is BackgroundDancers) ? adventure : null);
				int num = val._optionIndices[Controller.Instance.BackgroundDancersIndex.Value];
				Controller.Instance.BackgroundDancersIndex = null;
				Helpers.AddDataListItem("Options", num);
				HandleRandom(val, num);
			}
		}

		private static void HandleRandom(BackgroundDancers __instance, int option)
		{
			if (Controller.ShowRandomResult)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				switch (option)
				{
				case 0:
				case 2:
				case 3:
					break;
				case 1:
				{
					List<string> storageList = Helpers.GetStorageList<string, string>(storage, new string[2] { "", "2" }, "$reward2Rare");
					Helpers.AddDataListItem("Tools", storageList);
					break;
				}
				case 4:
				{
					string item2 = default(string);
					storage.TryGetValue<string>("$reward5Exhibit", ref item2);
					Helpers.AddDataListItem("Exhibits", item2);
					break;
				}
				case 5:
				{
					string item = default(string);
					storage.TryGetValue<string>("$reward6Ability", ref item);
					Helpers.AddDataListItem("Abilities", item);
					break;
				}
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class BaseManaPatch
	{
		[HarmonyPatch(/*Could not decode attribute arguments.*/)]
		private static class AddColor
		{
			private static void Prefix(ManaGroup value)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				if (Instance.IsInitialized)
				{
					ManaGroup val = value;
					string value2 = ManaColorExtensions.ToShortName(((ManaGroup)(ref val)).MaxColor).ToString();
					Helpers.AddDataValue("Color", value2);
				}
			}

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

		private static readonly string[] Adventures = new string[2] { "JunkoColorless", "PatchouliPhilosophy" };

		[HarmonyPatch(typeof(Adventure), "InitVariables")]
		[HarmonyPostfix]
		private static void AddBaseMana(Adventure __instance)
		{
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (Instance.IsInitialized && Adventures.Contains(__instance.Id))
			{
				GameRunController gameRun = __instance.GameRun;
				string[] exhibits = gameRun.ExhibitRecord.ToArray();
				ManaGroup baseMana = gameRun.BaseMana;
				string baseMana2 = Helpers.GetBaseMana(((object)(ManaGroup)(ref baseMana)).ToString(), exhibits);
				Helpers.AddDataValue("BaseMana", baseMana2);
			}
		}
	}
	[HarmonyPatch]
	internal static class BuduSuanmingPatch
	{
		[HarmonyPatch(typeof(DialogRunner), "SelectOption")]
		[HarmonyPostfix]
		private static void AddData(int id)
		{
			if (Instance.IsInitialized && Helpers.IsAdventure<BuduSuanming>(out DialogStorage storage))
			{
				switch (id)
				{
				case 0:
				{
					string value3 = default(string);
					storage.TryGetValue<string>("$bossId", ref value3);
					Helpers.AddDataValue("Boss", value3);
					break;
				}
				case 1:
				{
					string value2 = default(string);
					storage.TryGetValue<string>("$hostId", ref value2);
					Helpers.AddDataValue("Host", value2);
					break;
				}
				case 2:
				{
					string value = default(string);
					storage.TryGetValue<string>("$seijaItem", ref value);
					Helpers.AddDataValue("Exhibit", value);
					break;
				}
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class DebutPatch
	{
		[HarmonyPatch(typeof(Debut), "RollBonus")]
		[HarmonyPostfix]
		private static void AddData(Exhibit ____exhibit, int[] ____bonusNos, Debut __instance)
		{
			if (!Instance.IsInitialized || !Controller.Instance.RunLog.Settings.HasClearBonus)
			{
				return;
			}
			Helpers.AddDataValue("Options", ____bonusNos);
			int num = Array.IndexOf(____bonusNos, 0);
			if (num != -1)
			{
				Controller.Instance.DebutUncommonCardsIndex = num + 2;
			}
			if (!Controller.ShowRandomResult)
			{
				return;
			}
			Helpers.AddDataValue("Shining", ((GameEntity)____exhibit).Id);
			DialogStorage storage = ((Adventure)__instance).Storage;
			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> storageList = Helpers.GetStorageList<string, int>(storage, new int[3] { 1, 2, 3 }, "$uncommonCard");
					Helpers.AddDataValue("UncommonCards", storageList);
					break;
				}
				case 1:
					storage.TryGetValue<string>("$rareCard", ref value3);
					Helpers.AddDataValue("RareCard", value3);
					break;
				case 2:
					storage.TryGetValue<string>("$rareExhibit", ref value2);
					Helpers.AddDataValue("RareExhibit", value2);
					break;
				case 5:
					storage.TryGetValue<string>("$transformCard", ref value);
					Helpers.AddDataValue("TransformCard", value);
					break;
				}
			}
		}

		[HarmonyPatch(typeof(DialogRunner), "SelectOption")]
		[HarmonyPostfix]
		private static void Prefix(int id)
		{
			if (Instance.IsInitialized && id == Controller.Instance.DebutUncommonCardsIndex)
			{
				Controller.Instance.DebutUncommonCardsChosen = true;
			}
		}

		[HarmonyPatch(typeof(InteractionViewer), "View")]
		[HarmonyPrefix]
		private static void AddCardsRewards(Interaction interaction)
		{
			if (Instance.IsInitialized && Controller.Instance.DebutUncommonCardsChosen && Helpers.IsAdventure<Debut>())
			{
				RewardsManager.AddCardsRewards(interaction);
				Controller.Instance.DebutUncommonCardsIndex = null;
				Controller.Instance.DebutUncommonCardsChosen = false;
			}
		}
	}
	[HarmonyPatch]
	internal static class DoremyPortalPatch
	{
		[HarmonyPatch(typeof(DoremyPortal), "InitVariables")]
		[HarmonyPostfix]
		private static void AddExhibit(DoremyPortal __instance)
		{
			if (Instance.IsInitialized && Controller.ShowRandomResult)
			{
				string value = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$randomExhibit", ref value);
				Helpers.AddDataValue("Exhibit", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class EternityAscensionPatch
	{
		[HarmonyPatch(typeof(EternityAscension), "InitVariables")]
		[HarmonyPostfix]
		private static void AddCard(EternityAscension __instance)
		{
			if (Instance.IsInitialized && Controller.ShowRandomResult)
			{
				string value = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$transformCard", ref value);
				Helpers.AddDataValue("Card", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class HecatiaTshirtPatch
	{
		[HarmonyPatch(typeof(GameRunController), "GainExhibitRunner")]
		[HarmonyPostfix]
		[HarmonyPriority(200)]
		private static void UpgradeExhibit(Exhibit exhibit)
		{
			if (Instance.IsInitialized && exhibit is IdolTshirt)
			{
				int counter = exhibit.Counter;
				if (counter > exhibit.Config.InitialCounter)
				{
					EntitiesManager.AddExhibitChange(exhibit, ChangeType.Upgrade, counter);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class HinaCollectPatch
	{
		[HarmonyPatch(typeof(HinaCollect), "InitVariables")]
		[HarmonyPostfix]
		private static void AddCard(HinaCollect __instance)
		{
			if (Instance.IsInitialized && Controller.ShowRandomResult)
			{
				string value = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$card", ref value);
				Helpers.AddDataValue("Card", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class KaguyaVersusMokouPatch
	{
		[HarmonyPatch(typeof(KaguyaVersusMokou), "InitVariables")]
		[HarmonyPostfix]
		private static void AddHps(KaguyaVersusMokou __instance)
		{
			if (Instance.IsInitialized)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				List<int> value = (from hp in Helpers.GetStorageList<float, string>(storage, new string[2] { "", "Low" }, "$hpLose")
					select (int)hp).ToList();
				Helpers.AddDataValue("Hps", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class KeineSalesPatch
	{
		[HarmonyPatch(typeof(KeineSales), "InitVariables")]
		[HarmonyPostfix]
		private static void AddQuestions(KeineSales __instance)
		{
			if (Instance.IsInitialized)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				float num = default(float);
				storage.TryGetValue<float>("$stageNo", ref num);
				int[] keys = Enumerable.Range(1, (int)num).ToArray();
				List<int> value = (from question in Helpers.GetStorageList<float, int>(storage, keys, "$question", "No")
					select (int)question).ToList();
				Helpers.AddDataValue("Questions", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class KosuzuBookstorePatch
	{
		[HarmonyPatch(typeof(KosuzuBookstore), "InitVariables")]
		[HarmonyPostfix]
		private static void AddData(KosuzuBookstore __instance)
		{
			if (Instance.IsInitialized)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				bool flag = default(bool);
				storage.TryGetValue<bool>("$thirdBook", ref flag);
				int count = (flag ? 3 : 2);
				int[] keys = Enumerable.Range(0, count).ToArray();
				List<string> storageList = Helpers.GetStorageList<string, int>(storage, keys, "$book");
				Helpers.AddDataValue("Exhibits", storageList);
				float num = default(float);
				storage.TryGetValue<float>("$returnBookCount", ref num);
				int num2 = (int)num;
				if (num2 != 0)
				{
					int[] keys2 = Enumerable.Range(0, num2).ToArray();
					List<string> storageList2 = Helpers.GetStorageList<string, int>(storage, keys2, "$returnBook");
					Helpers.AddDataValue("Returns", storageList2);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class MikeInvestPatch
	{
		[HarmonyPatch(typeof(MikeInvest), "InitVariables")]
		[HarmonyPostfix]
		private static void AddData(MikeInvest __instance)
		{
			if (Instance.IsInitialized)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				float num = default(float);
				storage.TryGetValue<float>("$longMoney", ref num);
				Helpers.AddDataValue("Money", (int)num);
				if (Controller.ShowRandomResult)
				{
					string value = default(string);
					storage.TryGetValue<string>("$cardReward", ref value);
					Helpers.AddDataValue("Card", value);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class MiyoiBartenderPatch
	{
		[HarmonyPatch(typeof(MiyoiBartender), "InitVariables")]
		[HarmonyPrefix]
		private static void AddIds(MiyoiBartender __instance)
		{
			if (Instance.IsInitialized)
			{
				UniqueRandomPool<string> enemyPoolAct = ((Adventure)__instance).Stage.EnemyPoolAct3;
				List<string> value = ((IEnumerable<RandomPoolEntry<string>>)enemyPoolAct).Select((RandomPoolEntry<string> e) => e.Elem).ToList();
				Helpers.AddDataValue("Ids", value);
			}
		}

		[HarmonyPatch(typeof(MiyoiBartender), "InitVariables")]
		[HarmonyPostfix]
		private static void AddExhibitBeforeBattle(MiyoiBartender __instance)
		{
			if (Instance.IsInitialized && Controller.ShowRandomResult)
			{
				AddExhibit(((Adventure)__instance).Storage);
			}
		}

		[HarmonyPatch(typeof(GameRunController), "LeaveBattle")]
		[HarmonyPostfix]
		private static void AddExhibitAfterBattle()
		{
			if (Instance.IsInitialized && !Controller.ShowRandomResult && Helpers.IsAdventure<MiyoiBartender>(out DialogStorage storage))
			{
				AddExhibit(storage);
			}
		}

		private static void AddExhibit(DialogStorage storage)
		{
			string value = default(string);
			storage.TryGetValue<string>("$randomExhibit", ref value);
			Helpers.AddDataValue("Exhibit", value);
		}
	}
	[HarmonyPatch]
	internal static class NarumiOfferCardPatch
	{
		[HarmonyPatch(typeof(GameRunController), "RemoveDeckCards")]
		[HarmonyPostfix]
		private static void AddType(IEnumerable<Card> cards)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (Instance.IsInitialized && Helpers.IsAdventure<NarumiOfferCard>())
			{
				Card val = cards.First();
				string? text;
				if ((int)val.CardType != 8)
				{
					Rarity rarity = val.Config.Rarity;
					text = ((object)(Rarity)(ref rarity)).ToString();
				}
				else
				{
					CardType val2 = (CardType)8;
					text = ((object)(CardType)(ref val2)).ToString();
				}
				string value = text;
				Helpers.AddDataValue("Type", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class NazrinDetectPatch
	{
		[HarmonyPatch(typeof(NazrinDetectPanel), "Roll")]
		[HarmonyPostfix]
		private static void AddResult(int resultIndex)
		{
			if (Instance.IsInitialized)
			{
				Helpers.AddDataValue("Result", resultIndex);
			}
		}
	}
	[HarmonyPatch]
	internal static class ParseeJealousyPatch
	{
		[HarmonyPatch(typeof(ParseeJealousy), "InitVariables")]
		[HarmonyPostfix]
		private static void AddExhibit(ParseeJealousy __instance)
		{
			if (Instance.IsInitialized && Controller.ShowRandomResult)
			{
				string value = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$exhibitPassBy", ref value);
				Helpers.AddDataValue("Exhibit", value);
			}
		}

		[HarmonyPatch(typeof(ParseeJealousy), "GetExhibit")]
		[HarmonyPostfix]
		private static void AddExhibits(ParseeJealousy __instance)
		{
			if (Instance.IsInitialized)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				List<string> storageList = Helpers.GetStorageList<string, string>(storage, new string[2] { "", "2" }, "$exhibit");
				Helpers.AddDataValue("Exhibits", storageList);
			}
		}
	}
	[HarmonyPatch]
	internal static class RemiliaMeetPatch
	{
		[HarmonyPatch(typeof(RemiliaMeet), "InitVariables")]
		[HarmonyPostfix]
		private static void AddHasExhibit(RemiliaMeet __instance)
		{
			if (Instance.IsInitialized)
			{
				bool value = default(bool);
				((Adventure)__instance).Storage.TryGetValue<bool>("$hasExhibit", ref value);
				Helpers.AddDataValue("HasExhibit", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class RingoEmpPatch
	{
		[HarmonyPatch(typeof(RingoEmp), "InitVariables")]
		[HarmonyPostfix]
		private static void AddCards(RingoEmp __instance)
		{
			if (Instance.IsInitialized && Controller.ShowRandomResult)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				List<string> storageList = Helpers.GetStorageList<string, int>(storage, new int[3] { 1, 2, 3 }, "$tool");
				Helpers.AddDataValue("Cards", storageList);
			}
		}
	}
	[HarmonyPatch]
	internal static class RinnosukeTradePatch
	{
		[HarmonyPatch(typeof(RinnosukeTrade), "InitVariables")]
		[HarmonyPostfix]
		private static void AddPrices(RinnosukeTrade __instance)
		{
			if (!Instance.IsInitialized)
			{
				return;
			}
			DialogStorage storage = ((Adventure)__instance).Storage;
			List<int> list = new List<int>();
			bool flag = default(bool);
			for (int i = 1; i <= 2; i++)
			{
				storage.TryGetValue<bool>($"$canSell{i}", ref flag);
				if (flag)
				{
					list.Add(i);
				}
			}
			if (list.Count == 0)
			{
				return;
			}
			int[] keys = list.ToArray();
			List<string> storageList = Helpers.GetStorageList<string, int>(storage, keys, "$exhibit");
			List<float> storageList2 = Helpers.GetStorageList<float, int>(storage, keys, "$exhibit", "Price");
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			for (int j = 0; j < storageList.Count; j++)
			{
				if (storageList[j] != null)
				{
					dictionary.Add(storageList[j], (int)storageList2[j]);
				}
			}
			Helpers.AddDataValue("Prices", dictionary);
		}
	}
	[HarmonyPatch]
	internal static class SatoriCounselingPatch
	{
		[HarmonyPatch(typeof(DialogFunctions), "AdventureRand")]
		[HarmonyPostfix]
		private static void AddHasMoney(int a, int __result, GameRunController ____gameRun)
		{
			if (Instance.IsInitialized && a == 50)
			{
				if (!(____gameRun.Player is Koishi) && !(Helpers.GetAdventureId(____gameRun.CurrentStation) != "SatoriCounseling"))
				{
					int money = ____gameRun.Money;
					bool value = money >= __result;
					Helpers.AddDataValue("HasMoney", value);
				}
			}
		}

		[HarmonyPatch(typeof(InteractionViewer), "View")]
		[HarmonyPrefix]
		private static void AddCardsRewards(Interaction interaction)
		{
			if (Instance.IsInitialized && Helpers.IsAdventure<SatoriCounseling>())
			{
				RewardsManager.AddCardsRewards(interaction);
			}
		}
	}
	[HarmonyPatch]
	internal static class ShinmyoumaruForgePatch
	{
		[HarmonyPatch(typeof(ShinmyoumaruForge), "InitVariables")]
		[HarmonyPostfix]
		private static void AddData(ShinmyoumaruForge __instance)
		{
			if (Instance.IsInitialized)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				bool value = default(bool);
				storage.TryGetValue<bool>("$hasUpgradableBasics", ref value);
				bool value2 = default(bool);
				storage.TryGetValue<bool>("$hasNonBasics", ref value2);
				float num = default(float);
				storage.TryGetValue<float>("$loseMax", ref num);
				Helpers.AddDataValue("HasUpgradableBasics", value);
				Helpers.AddDataValue("HasNonBasics", value2);
				Helpers.AddDataValue("LoseMax", (int)num);
			}
		}
	}
	[HarmonyPatch]
	internal static class SumirekoGatheringPatch
	{
		[HarmonyPatch(typeof(SumirekoGathering), "InitVariables")]
		[HarmonyPostfix]
		private static void AddData(SumirekoGathering __instance)
		{
			if (Instance.IsInitialized)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				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
					};
					Helpers.AddDataValue("Card", value);
					AddCards(storage);
				}
			}
		}

		[HarmonyPatch(typeof(DialogFunctions), "HasMoney")]
		[HarmonyPostfix]
		private static void AddHasMoney(bool __result)
		{
			if (!Instance.IsInitialized || !Helpers.IsAdventure<SumirekoGathering>(out DialogStorage storage))
			{
				return;
			}
			bool flag = __result;
			Helpers.AddDataValue("HasMoney", flag);
			if (flag)
			{
				Helpers.GetData(out var data);
				if (!data.ContainsKey("Cards"))
				{
					AddCards(storage);
				}
			}
		}

		[HarmonyPatch(typeof(InteractionViewer), "View")]
		[HarmonyPrefix]
		private static void AddCardsRewards(Interaction interaction)
		{
			if (Instance.IsInitialized && Helpers.IsAdventure<SumirekoGathering>())
			{
				RewardsManager.AddCardsRewards(interaction);
			}
		}

		private static void AddCards(DialogStorage storage)
		{
			List<string> storageList = Helpers.GetStorageList<string, int>(storage, new int[3] { 1, 2, 3 }, "$rareTrade");
			Helpers.AddDataValue("Cards", storageList);
		}
	}
	[HarmonyPatch]
	internal static class SupplyPatch
	{
		[HarmonyPatch(typeof(Supply), "InitVariables")]
		[HarmonyPostfix]
		private static void AddData(Supply __instance)
		{
			if (Instance.IsInitialized)
			{
				DialogStorage storage = ((Adventure)__instance).Storage;
				List<string> storageList = Helpers.GetStorageList<string, string>(storage, new string[2] { "A", "B" }, "$exhibit");
				Helpers.AddDataValue("Exhibits", storageList);
				bool value = default(bool);
				storage.TryGetValue<bool>("$bothFlag", ref value);
				Helpers.AddDataValue("Both", value);
			}
		}
	}
	[HarmonyPatch]
	internal static class WatatsukiPurifyPatch
	{
		[HarmonyPatch(typeof(WatatsukiPurify), "InitVariables")]
		[HarmonyPostfix]
		private static void AddLoseMax(WatatsukiPurify __instance)
		{
			if (Instance.IsInitialized)
			{
				float num = default(float);
				((Adventure)__instance).Storage.TryGetValue<float>("$loseMax", ref num);
				Helpers.AddDataValue("LoseMax", (int)num);
			}
		}
	}
	[HarmonyPatch]
	internal static class YachieOppressionPatch
	{
		[HarmonyPatch(typeof(YachieOppression), "InitVariables")]
		[HarmonyPostfix]
		private static void AddExhibitBeforeBattle(YachieOppression __instance)
		{
			if (Instance.IsInitialized && Controller.ShowRandomResult)
			{
				AddExhibit(((Adventure)__instance).Storage);
			}
		}

		[HarmonyPatch(typeof(GameRunController), "LeaveBattle")]
		[HarmonyPostfix]
		private static void AddExhibitAfterBattle()
		{
			if (Instance.IsInitialized && !Controller.ShowRandomResult && Helpers.IsAdventure<YachieOppression>(out DialogStorage storage))
			{
				AddExhibit(storage);
			}
		}

		private static void AddExhibit(DialogStorage storage)
		{
			string value = default(string);
			storage.TryGetValue<string>("$enemyExhibit", ref value);
			Helpers.AddDataValue("Exhibit", value);
		}
	}
	[HarmonyPatch]
	internal static class YoumuDeliveryPatch
	{
		[HarmonyPatch(typeof(YoumuDelivery), "InitVariables")]
		[HarmonyPostfix]
		private static void AddCard(YoumuDelivery __instance)
		{
			if (Instance.IsInitialized && Controller.ShowRandomResult)
			{
				string value = default(string);
				((Adventure)__instance).Storage.TryGetValue<string>("$transformCard", ref value);
				Helpers.AddDataValue("Card", value);
			}
		}
	}
}
namespace RunLogger.Patches.RunLogPatches.StationObjPatches.DataPatches.BattleDetailsPatches
{
	[HarmonyPatch]
	internal static class IntentionsPatch
	{
		[HarmonyPatch(typeof(Seija), "GetTurnMoves")]
		[HarmonyPostfix]
		private static void AddIntentions(Seija __instance, IEnumerable<IEnemyMove> __result)
		{
			if (Instance.IsInitialized)
			{
				if (((Unit)__instance).TurnCounter == 0)
				{
					TurnObjManager.UpdateTurnObj((Unit)(object)__instance);
				}
				AddIntentionsInternal(__instance, __result);
			}
		}

		private static void AddIntentionsInternal(Seija enemy, IEnumerable<IEnemyMove> moves)
		{
			TurnObjManager.GetLastTurnObj(out var turnObj);
			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();
			turnObj.Intentions = intentions;
		}
	}
	[HarmonyPatch]
	internal static class TurnObjPatch
	{
		[HarmonyPatch]
		private static class UpsertOnPlayerAndEnemyEndTurn
		{
			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(typeof(BattleAction), "CreateEventPhase", (Type[])null, (Type[])null).MakeGenericMethod(typeof(UnitEventArgs));
			}

			private static void Prefix(string name, UnitEventArgs args, BattleAction __instance)
			{
				if (!Instance.IsInitialized || name != "TurnEnded")
				{
					return;
				}
				BattleController battle = __instance.Battle;
				if (battle.EnemyGroup.Id != "Seija")
				{
					return;
				}
				if (__instance is EndPlayerTurnAction)
				{
					Unit unit = args.Unit;
					PlayerUnit unit2 = (PlayerUnit)(object)((unit is PlayerUnit) ? unit : null);
					TurnObjManager.UpdateTurnObj((Unit)(object)unit2);
				}
				else if (__instance is EndEnemyTurnAction)
				{
					Unit unit3 = args.Unit;
					EnemyUnit val = (EnemyUnit)(object)((unit3 is EnemyUnit) ? unit3 : null);
					string id = ((GameEntity)val).Id;
					if (!(id != "Seija"))
					{
						int roundCounter = battle.RoundCounter;
						int turnCounter = ((Unit)val).TurnCounter;
						TurnObjManager.AppendTurnObj(roundCounter, turnCounter, id);
						TurnObjManager.UpdateTurnObj((Unit)(object)val);
					}
				}
			}
		}

		[HarmonyPatch(typeof(Seija), "OnEnterBattle")]
		[HarmonyPostfix]
		private static void AppendOnEnemyEnterBattle(Seija __instance)
		{
			if (Instance.IsInitialized)
			{
				TurnObjManager.AppendTurnObj(0, 0, ((GameEntity)__instance).Id);
			}
		}

		[HarmonyPatch(typeof(BattleAction), "CreatePhase", new Type[]
		{
			typeof(string),
			typeof(Action),
			typeof(bool)
		})]
		[HarmonyPrefix]
		private static void AppendOnPlayerStartTurn(string name, BattleAction __instance)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			if (Instance.IsInitialized && !(name != "InTurn"))
			{
				BattleController battle = __instance.Battle;
				if (!(battle.EnemyGroup.Id != "Seija") && !battle.PlayerTurnShouldEnd)
				{
					int roundCounter = battle.RoundCounter;
					int turnCounter = ((Unit)battle.Player).TurnCounter;
					ManaGroup battleMana = battle.BattleMana;
					string mana = ((object)(ManaGroup)(ref battleMana)).ToString();
					List<CardObj> cards = Helpers.ParseCards(battle.HandZone);
					TurnObjManager.AppendTurnObj(roundCounter, turnCounter, "Player", mana, cards);
				}
			}
		}
	}
}
namespace RunLogger.Patches.PanelPatches
{
	[HarmonyPatch]
	internal static class CardDetailPanelPatch
	{
		[HarmonyPatch(typeof(CardDetailPanel), "Awake")]
		[HarmonyPostfix]
		private static void CreateBg(CardDetailPanel __instance)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			if (!UploadPanel.HasPanel && !((Object)(object)ObjectsManager.GetFromTemp("Bg") != (Object)null))
			{
				RectTransform val = ObjectsManager.CopyGameObject(((Component)__instance).transform, "SubWidgetGroup/TooltipParent/TooltipTemplate/Root/ExtraText");
				((Object)val).name = "Bg";
				val.pivot = new Vector2(0f, 0.5f);
				val.anchorMin = new Vector2(0f, 1f);
				val.anchorMax = new Vector2(0f, 1f);
				val.sizeDelta = new Vector2(700f, 100f);
				((Transform)val).position = PositionsManager.BgPosition;
				Object.Destroy((Object)(object)((Component)((Transform)val).Find("UpgradeText")).gameObject);
				Object.Destroy((Object)(object)((Component)val).GetComponent<ContentSizeFitter>());
				ObjectsManager.ChangeText(((Transform)val).Find("PoolText"), null);
				UploadPanel.AdjustPanel();
			}
		}
	}
	[HarmonyPatch]
	internal static class GameResultPanelPatch
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction<bool> <>9__1_0;

			public static UnityAction <>9__1_3;

			internal void <DisplayPanel>b__1_0(bool isOn)
			{
				Helpers.AutoUpload = isOn;
			}

			internal void <DisplayPanel>b__1_3()
			{
				LBoLLogs.Upload();
			}
		}

		[HarmonyPatch(typeof(GameResultPanel), "Awake")]
		[HarmonyPostfix]
		private static void CreateQuickUpload(GameResultPanel __instance)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to inva