using System;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using APIPlugin;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using DiskCardGame;
using HarmonyLib;
using InscryptionAPI.Ascension;
using InscryptionAPI.Card;
using InscryptionAPI.Encounters;
using InscryptionAPI.Guid;
using InscryptionAPI.Helpers;
using InscryptionAPI.Localizing;
using InscryptionAPI.Masks;
using InscryptionAPI.Regions;
using InscryptionAPI.Saves;
using InscryptionAPI.Sound;
using InscryptionAPI.TalkingCards;
using InscryptionAPI.TalkingCards.Animation;
using InscryptionAPI.TalkingCards.Create;
using InscryptionAPI.TalkingCards.Helpers;
using InscryptionAPI.Triggers;
using JLPlugin;
using JLPlugin.ConfigilFunctions;
using JLPlugin.Data;
using JLPlugin.Hotkeys;
using JLPlugin.SigilCode;
using JLPlugin.Utils;
using JLPlugin.V2.Data;
using JSONLoader.Data;
using JSONLoader.Data.TalkingCards;
using JSONLoader.V2Code;
using Microsoft.CodeAnalysis;
using MonoMod.Utils;
using NCalc;
using PanoramicData.NCalcExtensions;
using TMPro;
using TinyJson;
using UnityEngine;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.Default | DebuggableAttribute.DebuggingModes.DisableOptimizations | DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints | DebuggableAttribute.DebuggingModes.EnableEditAndContinue)]
[assembly: TargetFramework(".NETStandard,Version=v2.0", FrameworkDisplayName = "")]
[assembly: AssemblyCompany("JSONLoader")]
[assembly: AssemblyConfiguration("Debug")]
[assembly: AssemblyDescription("JSON Loader")]
[assembly: AssemblyFileVersion("2.0.0.0")]
[assembly: AssemblyInformationalVersion("2.0")]
[assembly: AssemblyProduct("JSONLoader")]
[assembly: AssemblyTitle("JSONLoader")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("2.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]
	internal sealed class IsReadOnlyAttribute : Attribute
	{
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class IsUnmanagedAttribute : Attribute
	{
	}
	[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;
		}
	}
}
public static class ImportExportUtils
{
	private static string ID;

	private static string DebugPath;

	private static string LoggingSuffix;

	public static void SetID(string id)
	{
		ID = id;
	}

	public static void SetDebugPath(string path)
	{
		DebugPath = path.Substring(Plugin.BepInExDirectory.Length);
		LoggingSuffix = "";
	}

	public static T ParseEnum<T>(string value) where T : unmanaged, Enum
	{
		if (Enum.TryParse<T>(value, out var result))
		{
			return result;
		}
		int num = Math.Max(value.LastIndexOf('_'), value.LastIndexOf('.'));
		if (num < 0)
		{
			throw new InvalidCastException("Cannot parse " + value + " as " + typeof(T).FullName);
		}
		string text = value.Substring(0, num);
		string text2 = value.Substring(num + 1);
		return GuidManager.GetEnumValue<T>(text, text2);
	}

	public static void ApplyProperty<T, Y>(Func<T> getter, Action<T> setter, ref Y serializeInfoValue, bool toCardInfo, string category, string suffix)
	{
		if (toCardInfo)
		{
			T a = default(T);
			ApplyValue(ref a, ref serializeInfoValue, toA: true, category, suffix);
			setter(a);
		}
		else
		{
			T a2 = getter();
			ApplyValue(ref a2, ref serializeInfoValue, toA: false, category, suffix);
		}
	}

	public static void ApplyProperty<T, Y>(ref T serializeInfoValue, Func<Y> getter, Action<Y> setter, bool toCardInfo, string category, string suffix)
	{
		if (toCardInfo)
		{
			Y b = getter();
			ApplyValue(ref serializeInfoValue, ref b, toA: false, category, suffix);
		}
		else
		{
			Y b2 = default(Y);
			ApplyValue(ref serializeInfoValue, ref b2, toA: true, category, suffix);
			setter(b2);
		}
	}

	public static void ApplyValue<T, Y>(ref T a, ref Y b, bool toA, string category, string suffix)
	{
		if (toA)
		{
			ConvertValue(ref b, ref a, category, suffix);
		}
		else
		{
			ConvertValue(ref a, ref b, category, suffix);
		}
	}

	private static void ConvertValue<FromType, ToType>(ref FromType from, ref ToType to, string category, string suffix)
	{
		//IL_0882: Unknown result type (might be due to invalid IL or missing references)
		//IL_0889: Expected O, but got Unknown
		//IL_099b: Unknown result type (might be due to invalid IL or missing references)
		//IL_09a2: Expected O, but got Unknown
		LoggingSuffix = suffix;
		Type typeFromHandle = typeof(FromType);
		Type typeFromHandle2 = typeof(ToType);
		try
		{
			if (typeFromHandle == typeFromHandle2)
			{
				to = (ToType)(object)from;
				return;
			}
			if (AreNullableTypesEqual(from, to, out var a2, out var _, out var aHasValue, out var _))
			{
				if (aHasValue)
				{
					to = (ToType)a2;
				}
				return;
			}
			if (typeFromHandle.IsGenericType && typeFromHandle.GetGenericTypeDefinition() == typeof(List<>) && typeFromHandle2.IsGenericType && typeFromHandle2.GetGenericTypeDefinition() == typeof(List<>))
			{
				if (from != null)
				{
					IList list = (IList)Activator.CreateInstance(typeFromHandle2);
					to = (ToType)list;
					IList list2 = (IList)(object)from;
					for (int i = 0; i < list2.Count; i++)
					{
						object o = list2[i];
						object @default = GetDefault(typeFromHandle2.GetGenericArguments().Single());
						object value = ConvertType(typeFromHandle, typeFromHandle2, o, @default, category, $"{suffix}_{i + 1}");
						list.Add(value);
					}
				}
				return;
			}
			if (typeFromHandle.IsGenericType && typeFromHandle.GetGenericTypeDefinition() == typeof(List<>) && typeFromHandle2.IsArray)
			{
				if (from != null)
				{
					IList list3 = (IList)(object)from;
					int length = ((from != null) ? list3.Count : 0);
					Array array = Array.CreateInstance(typeFromHandle2.GetElementType(), length);
					to = (ToType)(object)array;
					for (int j = 0; j < list3.Count; j++)
					{
						object obj = list3[j];
						object default2 = GetDefault(typeFromHandle2.GetElementType());
						object[] array2 = new object[4]
						{
							obj,
							default2,
							category,
							$"{suffix}_{j + 1}"
						};
						MethodInfo methodInfo = typeof(ImportExportUtils).GetMethod("ConvertValue", BindingFlags.Static | BindingFlags.NonPublic).MakeGenericMethod(typeFromHandle.GetGenericArguments().Single(), typeFromHandle2.GetElementType());
						methodInfo.Invoke(null, array2);
						array.SetValue(array2[1], j);
					}
				}
				return;
			}
			if (typeFromHandle.IsArray && typeFromHandle2.IsGenericType && typeFromHandle2.GetGenericTypeDefinition() == typeof(List<>))
			{
				if (from != null)
				{
					IList list4 = (IList)Activator.CreateInstance(typeFromHandle2);
					to = (ToType)list4;
					Array array3 = (Array)(object)from;
					for (int k = 0; k < array3.Length; k++)
					{
						object value2 = array3.GetValue(k);
						object default3 = GetDefault(typeFromHandle2.GetGenericArguments().Single());
						object[] array4 = new object[4]
						{
							value2,
							default3,
							category,
							$"{suffix}_{k + 1}"
						};
						MethodInfo methodInfo2 = typeof(ImportExportUtils).GetMethod("ConvertValue", BindingFlags.Static | BindingFlags.NonPublic).MakeGenericMethod(typeFromHandle.GetElementType(), typeFromHandle2.GetGenericArguments().Single());
						methodInfo2.Invoke(null, array4);
						list4.Add(array4[1]);
					}
				}
				return;
			}
			if (typeFromHandle.IsEnum && typeFromHandle2 == typeof(string))
			{
				string text = from.ToString();
				if (int.TryParse(text, out var result))
				{
					object[] array5 = new object[3] { result, "guid", "name" };
					MethodInfo methodInfo3 = typeof(GuidManager).GetMethod("TryGetGuidAndKeyEnumValue", BindingFlags.Static | BindingFlags.Public).MakeGenericMethod(typeFromHandle);
					if ((bool)methodInfo3.Invoke(null, array5))
					{
						string text2 = (string)array5[1];
						string text3 = (string)array5[2];
						to = (ToType)(object)(text2 + "_" + text3);
					}
					else
					{
						Error($"Failed to convert enum to string! '{from}'");
						to = (ToType)(object)text;
					}
				}
				else
				{
					to = (ToType)(object)text;
				}
				return;
			}
			if (typeFromHandle == typeof(string) && typeFromHandle2.IsEnum)
			{
				if (!string.IsNullOrEmpty((string)(object)from))
				{
					object obj2 = typeof(ImportExportUtils).GetMethod("ParseEnum", BindingFlags.Static | BindingFlags.Public).MakeGenericMethod(typeFromHandle2).Invoke(null, new object[1] { from });
					to = (ToType)obj2;
				}
				return;
			}
			if (typeFromHandle == typeof(CardInfo) && typeFromHandle2 == typeof(string))
			{
				if (from != null)
				{
					object obj3 = from;
					to = (ToType)(object)((Object)((obj3 is CardInfo) ? obj3 : null)).name;
				}
				return;
			}
			if (typeFromHandle == typeof(string) && typeFromHandle2 == typeof(CardInfo))
			{
				string text4 = (string)(object)from;
				if (text4 != null)
				{
					text4 = text4.Trim();
				}
				if (string.IsNullOrEmpty(text4))
				{
					return;
				}
				to = (ToType)(object)CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.AllCardsCopy, text4);
				if (to != null)
				{
					return;
				}
				CardInfo[] array6 = FindSimilarCards(text4);
				if (array6.Length == 0)
				{
					string text5 = string.Join(", ", CardManager.AllCardsCopy.Select((CardInfo c) => ((Object)c).name));
					Error("Could not find CardInfo with name '" + text4 + "'!\nAllCards: " + text5);
					return;
				}
				to = (ToType)(object)array6[0];
				string text6 = string.Join(" or ", array6.Select((CardInfo a) => "'" + ((Object)a).name + "'"));
				Warning("Could not find CardInfo with name '" + text4 + "'. Did you mean " + text6 + "?");
				return;
			}
			if (typeFromHandle == typeof(string) && (typeFromHandle2 == typeof(Texture) || typeFromHandle2.IsSubclassOf(typeof(Texture))))
			{
				string text7 = (string)(object)from;
				if (!string.IsNullOrEmpty(text7))
				{
					try
					{
						to = (ToType)(object)TextureHelper.GetImageAsTexture(text7, (FilterMode)0);
						return;
					}
					catch (FileNotFoundException)
					{
						Error("Failed to find texture " + text7 + "!");
						return;
					}
				}
				return;
			}
			if ((typeFromHandle == typeof(Texture) || typeFromHandle.IsSubclassOf(typeof(Texture))) && typeFromHandle2 == typeof(string))
			{
				Texture val = (Texture)(object)from;
				if ((Object)(object)val != (Object)null)
				{
					string path = Path.Combine(Plugin.ExportDirectory, category, "Assets", ID + "_" + suffix + ".png");
					to = (ToType)(object)ExportTexture(val, path);
				}
				return;
			}
			if (typeFromHandle == typeof(string) && typeFromHandle2 == typeof(Sprite))
			{
				string text8 = (string)(object)from;
				if (!string.IsNullOrEmpty(text8))
				{
					Texture2D imageAsTexture = TextureHelper.GetImageAsTexture(text8, (FilterMode)0);
					if ((Object)(object)imageAsTexture != (Object)null)
					{
						to = (ToType)(object)TextureHelper.ConvertTexture(imageAsTexture, (Vector2?)null);
					}
				}
				return;
			}
			if (typeFromHandle == typeof(Sprite) && typeFromHandle2 == typeof(string))
			{
				Sprite val2 = (Sprite)(object)from;
				if ((Object)(object)val2 != (Object)null)
				{
					string path2 = Path.Combine(Plugin.ExportDirectory, category, "Assets", ID + "_" + suffix + ".png");
					to = (ToType)(object)ExportTexture(val2.texture, path2);
				}
				return;
			}
			if (typeFromHandle.GetInterfaces().Contains(typeof(IConvertible)) && typeFromHandle2.GetInterfaces().Contains(typeof(IConvertible)))
			{
				IConvertible convertible = from as IConvertible;
				IConvertible convertible2 = to as IConvertible;
				if (convertible != null && convertible2 != null)
				{
					to = (ToType)Convert.ChangeType(convertible, typeFromHandle2);
				}
				return;
			}
			if (typeFromHandle == typeof(JSONParser.LocalizableField) && typeFromHandle2 == typeof(string))
			{
				Error("Use ApplyLocaleField when converted from LocalizableField to string!");
			}
			else if (typeFromHandle == typeof(string) && typeFromHandle2 == typeof(JSONParser.LocalizableField))
			{
				Error("Use ApplyLocaleField when converted from string to LocalizableField!");
			}
		}
		catch (Exception e)
		{
			Error($"Failed to convert: {typeFromHandle} to {typeFromHandle2}");
			Exception(e);
			return;
		}
		Error($"Unsupported conversion type: {typeFromHandle} to {typeFromHandle2}\n{Environment.StackTrace}");
	}

	private static CardInfo[] FindSimilarCards(string misspelledCardName)
	{
		List<Tuple<int, CardInfo>> list = new List<Tuple<int, CardInfo>>();
		string text = misspelledCardName.ToLower().Replace("-", "").Replace("_", "");
		int num = Mathf.Clamp(text.Length - 1, 1, 4);
		foreach (CardInfo item in CardManager.AllCardsCopy)
		{
			string text2 = ((Object)item).name.ToLower().Replace("-", "").Replace("_", "");
			if (Mathf.Abs(text.Length - text2.Length) > num)
			{
				continue;
			}
			int num2 = 0;
			int num3 = Mathf.Max(0, text.Length - text2.Length);
			int num4 = text2.Length - 1;
			int num5 = text.Length - 1;
			while (num5 >= 0 && num4 >= 0)
			{
				if (text2[num4] == text[num5])
				{
					num2++;
				}
				else
				{
					num3++;
					if (num3 > num)
					{
						break;
					}
					if (num4 > 0 && text2[num4 - 1] == text[num5])
					{
						num4--;
						num2++;
					}
					else if (num5 > 0 && text2[num4] == text[num5 - 1])
					{
						num5--;
						num2++;
					}
				}
				num5--;
				num4--;
			}
			if (num2 > 0 && num3 < num)
			{
				list.Add(new Tuple<int, CardInfo>(num2, item));
			}
		}
		list.Sort((Tuple<int, CardInfo> a, Tuple<int, CardInfo> b) => b.Item1 - a.Item1);
		return list.Select((Tuple<int, CardInfo> a) => a.Item2).ToArray();
	}

	private static object ConvertType(Type fromType, Type toType, object o1, object o2, string category, string suffix)
	{
		object[] array = new object[4] { o1, o2, category, suffix };
		MethodInfo methodInfo = typeof(ImportExportUtils).GetMethod("ConvertValue", BindingFlags.Static | BindingFlags.NonPublic).MakeGenericMethod(fromType.GetGenericArguments().Single(), toType.GetGenericArguments().Single());
		methodInfo.Invoke(null, array);
		return array[1];
	}

	private static bool AreNullableTypesEqual<T, Y>(T t, Y y, out object a, out object b, out bool aHasValue, out bool bHasValue)
	{
		aHasValue = false;
		bHasValue = false;
		a = null;
		b = null;
		bool flag = typeof(T).IsGenericType && typeof(T).GetGenericTypeDefinition() == typeof(Nullable<>);
		bool flag2 = typeof(Y).IsGenericType && typeof(Y).GetGenericTypeDefinition() == typeof(Nullable<>);
		if (!flag && !flag2)
		{
			return false;
		}
		Type type = (flag ? Nullable.GetUnderlyingType(typeof(T)) : typeof(T));
		Type type2 = (flag2 ? Nullable.GetUnderlyingType(typeof(Y)) : typeof(Y));
		if (type == type2)
		{
			if (flag)
			{
				a = GetValueFromNullable(t, out aHasValue);
			}
			else
			{
				a = t;
				aHasValue = true;
			}
			if (flag2)
			{
				b = GetValueFromNullable(y, out bHasValue);
			}
			else
			{
				b = y;
				bHasValue = true;
			}
			return true;
		}
		Error($"Not same types {typeof(T)} {typeof(Y)}");
		return false;
	}

	private static string ExportTexture(Texture texture, string path)
	{
		Texture2D val = (Texture2D)(object)((texture is Texture2D) ? texture : null);
		if (val != null)
		{
			return ExportTexture(val, path);
		}
		Texture2D texture2 = Texture2D.CreateExternalTexture(texture.width, texture.height, (TextureFormat)4, false, false, texture.GetNativeTexturePtr());
		return ExportTexture(texture2, path);
	}

	private static string ExportTexture(Texture2D texture, string path)
	{
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_0050: Expected O, but got Unknown
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		if (!((Texture)texture).isReadable)
		{
			RenderTexture temporary = RenderTexture.GetTemporary(((Texture)texture).width, ((Texture)texture).height, 0, (RenderTextureFormat)7, (RenderTextureReadWrite)1);
			Graphics.Blit((Texture)(object)texture, temporary);
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = temporary;
			Texture2D val = new Texture2D(((Texture)texture).width, ((Texture)texture).height);
			val.ReadPixels(new Rect(0f, 0f, (float)((Texture)temporary).width, (float)((Texture)temporary).height), 0, 0);
			val.Apply();
			RenderTexture.active = active;
			RenderTexture.ReleaseTemporary(temporary);
			texture = val;
		}
		byte[] array = ImageConversion.EncodeToPNG(texture);
		if (array == null)
		{
			Error("Failed to turn into bytes??");
		}
		if (string.IsNullOrEmpty(path))
		{
			Error("path is empty????");
		}
		string directoryName = Path.GetDirectoryName(path);
		if (!Directory.Exists(directoryName))
		{
			Directory.CreateDirectory(directoryName);
		}
		File.WriteAllBytes(path, array);
		return Path.GetFileName(path);
	}

	public static string[] ExportTextures(IEnumerable<Texture2D> texture, string type, string fileName)
	{
		int num = 0;
		List<string> list = new List<string>();
		foreach (Texture2D item in texture)
		{
			num++;
			string path = Path.Combine(Plugin.ExportDirectory, type, "Assets", $"{fileName}_{num}.png");
			list.Add(ExportTexture(item, path));
		}
		return list.ToArray();
	}

	public static void ApplyLocaleField(string field, ref JSONParser.LocalizableField rows, ref string cardInfoEnglishField, bool toCardInfo)
	{
		if (toCardInfo)
		{
			ApplyLocaleField(field, rows, ref cardInfoEnglishField);
			return;
		}
		string text = cardInfoEnglishField;
		cardInfoEnglishField = text;
		ImportLocaleField(rows, cardInfoEnglishField);
	}

	private static void ImportLocaleField(JSONParser.LocalizableField rows, string cardInfoEnglishField)
	{
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
		rows.rows.Clear();
		rows.Initialize(cardInfoEnglishField);
		Translation val = Localization.Translations.Find((Translation a) => a.englishStringFormatted == cardInfoEnglishField);
		if (val != null)
		{
			foreach (KeyValuePair<Language, string> value in val.values)
			{
				string text = LocalizationManager.LanguageToCode(value.Key);
				rows.SetValue(rows.englishFieldName + "_" + text, value.Value);
				VerboseLog($"Loaded {cardInfoEnglishField} translation for {text} => {value.Key}");
			}
			return;
		}
		VerboseLog("ApplyLocaleField could not find any translations from english '" + cardInfoEnglishField + "'");
	}

	private static void ApplyLocaleField(string field, JSONParser.LocalizableField rows, ref string cardInfoEnglishField)
	{
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_012c: Unknown result type (might be due to invalid IL or missing references)
		//IL_012e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Invalid comparison between Unknown and I4
		//IL_014d: Unknown result type (might be due to invalid IL or missing references)
		if (rows.rows.TryGetValue(rows.englishFieldName, out var value))
		{
			cardInfoEnglishField = value;
		}
		else
		{
			if (rows.rows.Count <= 0)
			{
				return;
			}
			cardInfoEnglishField = rows.rows.First().Value;
		}
		VerboseLog("ApplyLocaleField " + field + " english " + cardInfoEnglishField);
		foreach (KeyValuePair<string, string> row in rows.rows)
		{
			if (row.Key == rows.englishFieldName)
			{
				continue;
			}
			int num = row.Key.LastIndexOf("_", StringComparison.Ordinal);
			if (num < 0)
			{
				VerboseError("Could not find _ of key " + row.Key + " in field " + field + "!");
				continue;
			}
			int length = row.Key.Length - num - 1;
			string text = row.Key.Substring(num + 1, length);
			Language val = LocalizationManager.CodeToLanguage(text);
			if ((int)val != 12)
			{
				LocalizationManager.Translate("MADH.inscryption.JSONLoader", (string)null, cardInfoEnglishField, row.Value, val);
				VerboseLog("Translation " + cardInfoEnglishField + " to " + text + " = " + row.Value);
			}
			else
			{
				Error("Unknown language code " + text + " for card " + cardInfoEnglishField + " in field " + field);
			}
		}
	}

	private static object GetValueFromNullable<U>(U u, out bool hasValue)
	{
		Type typeFromHandle = typeof(U);
		if (u != null && (bool)typeFromHandle.GetProperty("HasValue", BindingFlags.Instance | BindingFlags.Public).GetValue(u))
		{
			hasValue = true;
			return typeFromHandle.GetProperty("Value", BindingFlags.Instance | BindingFlags.Public).GetValue(u);
		}
		hasValue = false;
		Type underlyingType = Nullable.GetUnderlyingType(typeFromHandle);
		if (underlyingType.IsValueType)
		{
			return Activator.CreateInstance(underlyingType);
		}
		return null;
	}

	private static object GetDefault(Type type)
	{
		if (type.IsValueType)
		{
			return Activator.CreateInstance(type);
		}
		return null;
	}

	private static void VerboseLog(string message)
	{
		Plugin.VerboseLog("[" + DebugPath + "][" + ID + "][" + LoggingSuffix + "] " + message);
	}

	private static void VerboseWarning(string message)
	{
		if (Configs.VerboseLogging)
		{
			Plugin.VerboseWarning("[" + DebugPath + "][" + ID + "][" + LoggingSuffix + "] " + message);
		}
	}

	private static void VerboseError(string message)
	{
		if (Configs.VerboseLogging)
		{
			Plugin.VerboseError("[" + DebugPath + "][" + ID + "][" + LoggingSuffix + "] " + message);
		}
	}

	private static void Warning(string message)
	{
		if (Configs.VerboseLogging)
		{
			VerboseWarning(message);
			return;
		}
		Plugin.Log.LogWarning((object)("[" + ID + "][" + LoggingSuffix + "] " + message));
	}

	private static void Error(string message)
	{
		if (Configs.VerboseLogging)
		{
			VerboseError(message);
			return;
		}
		Plugin.Log.LogError((object)("[" + ID + "][" + LoggingSuffix + "] " + message));
	}

	private static void Exception(Exception e)
	{
		Plugin.Log.LogError((object)("[" + DebugPath + "][" + ID + "][" + LoggingSuffix + "] " + e.Message + "\n" + e.StackTrace));
	}
}
namespace TinyJson
{
	public static class JSONParser
	{
		public interface IFlexibleField
		{
			bool ContainsKey(string key);

			void SetValue(string key, string value);

			string ToJSON();
		}

		public interface IInitializable
		{
			void Initialize();
		}

		[Serializable]
		public class LocalizableField : IFlexibleField
		{
			public Dictionary<string, string> rows;

			public string englishFieldName;

			public LocalizableField(string EnglishFieldName)
			{
				rows = new Dictionary<string, string>();
				englishFieldName = EnglishFieldName;
			}

			public void Initialize(string englishValue)
			{
				rows[englishFieldName] = englishValue;
			}

			public bool ContainsKey(string key)
			{
				return key.StartsWith(englishFieldName);
			}

			public void SetValue(string key, string value)
			{
				rows[key] = value;
			}

			public string ToJSON()
			{
				string text = "";
				foreach (KeyValuePair<string, string> row in rows)
				{
					text = text + "\t\"" + row.Key + "\": \"" + row.Value + "\",\n";
				}
				return text;
			}

			public override string ToString()
			{
				return rows.ToString();
			}
		}

		[ThreadStatic]
		private static Stack<List<string>> splitArrayPool;

		[ThreadStatic]
		private static StringBuilder stringBuilder;

		[ThreadStatic]
		private static Dictionary<Type, Dictionary<string, FieldInfo>> fieldInfoCache;

		[ThreadStatic]
		private static Dictionary<Type, Dictionary<string, PropertyInfo>> propertyInfoCache;

		[ThreadStatic]
		private static Dictionary<Type, FieldInfo[]> publicFieldInfoCache;

		public static T FromJson<T>(this string json)
		{
			if (propertyInfoCache == null)
			{
				propertyInfoCache = new Dictionary<Type, Dictionary<string, PropertyInfo>>();
			}
			if (fieldInfoCache == null)
			{
				fieldInfoCache = new Dictionary<Type, Dictionary<string, FieldInfo>>();
			}
			if (stringBuilder == null)
			{
				stringBuilder = new StringBuilder();
			}
			if (splitArrayPool == null)
			{
				splitArrayPool = new Stack<List<string>>();
			}
			if (publicFieldInfoCache == null)
			{
				publicFieldInfoCache = new Dictionary<Type, FieldInfo[]>();
			}
			stringBuilder.Length = 0;
			for (int i = 0; i < json.Length; i++)
			{
				char c = json[i];
				switch (c)
				{
				case '"':
					i = AppendUntilStringEnd(appendEscapeCharacter: true, i, json);
					continue;
				case '/':
					if (i + 1 != json.Length && json[i + 1] == '/')
					{
						i = SkipUntilLineEnd(i, json);
						continue;
					}
					break;
				}
				if (!char.IsWhiteSpace(c))
				{
					stringBuilder.Append(c);
				}
			}
			return (T)ParseValue(typeof(T), stringBuilder.ToString());
		}

		private static int SkipUntilLineEnd(int startIdx, string json)
		{
			for (int i = startIdx + 2; i < json.Length; i++)
			{
				if (json[i] == '\n')
				{
					return i + 1;
				}
			}
			return json.Length - 1;
		}

		private static int AppendUntilStringEnd(bool appendEscapeCharacter, int startIdx, string json)
		{
			stringBuilder.Append(json[startIdx]);
			for (int i = startIdx + 1; i < json.Length; i++)
			{
				if (json[i] == '\\')
				{
					if (appendEscapeCharacter)
					{
						stringBuilder.Append(json[i]);
					}
					stringBuilder.Append(json[i + 1]);
					i++;
				}
				else
				{
					if (json[i] == '"')
					{
						stringBuilder.Append(json[i]);
						return i;
					}
					stringBuilder.Append(json[i]);
				}
			}
			return json.Length - 1;
		}

		private static List<string> Split(string json)
		{
			List<string> list = ((splitArrayPool.Count > 0) ? splitArrayPool.Pop() : new List<string>());
			list.Clear();
			if (json.Length == 2)
			{
				return list;
			}
			int num = 0;
			stringBuilder.Length = 0;
			for (int i = 1; i < json.Length - 1; i++)
			{
				switch (json[i])
				{
				case '[':
				case '{':
					num++;
					break;
				case ']':
				case '}':
					num--;
					break;
				case '"':
					i = AppendUntilStringEnd(appendEscapeCharacter: true, i, json);
					continue;
				case ',':
				case ':':
					if (num == 0)
					{
						list.Add(stringBuilder.ToString());
						stringBuilder.Length = 0;
						continue;
					}
					break;
				}
				stringBuilder.Append(json[i]);
			}
			list.Add(stringBuilder.ToString());
			return list;
		}

		internal static object ParseValue(Type type, string json)
		{
			if (type == typeof(string))
			{
				if (json.Length <= 2)
				{
					return string.Empty;
				}
				StringBuilder stringBuilder = new StringBuilder(json.Length);
				for (int i = 1; i < json.Length - 1; i++)
				{
					if (json[i] == '\\' && i + 1 < json.Length - 1)
					{
						int num = "\"\\nrtbf/".IndexOf(json[i + 1]);
						if (num >= 0)
						{
							stringBuilder.Append("\"\\\n\r\t\b\f/"[num]);
							i++;
							continue;
						}
						if (json[i + 1] == 'u' && i + 5 < json.Length - 1)
						{
							uint result = 0u;
							if (uint.TryParse(json.Substring(i + 2, 4), NumberStyles.AllowHexSpecifier, null, out result))
							{
								stringBuilder.Append((char)result);
								i += 5;
								continue;
							}
						}
					}
					stringBuilder.Append(json[i]);
				}
				return stringBuilder.ToString();
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Nullable<>))
			{
				return Convert.ChangeType(json, type.GetGenericArguments().First(), CultureInfo.InvariantCulture);
			}
			if (type.IsPrimitive)
			{
				return Convert.ChangeType(json, type, CultureInfo.InvariantCulture);
			}
			if (type == typeof(decimal))
			{
				decimal.TryParse(json, NumberStyles.Float, CultureInfo.InvariantCulture, out var result2);
				return result2;
			}
			if (type == typeof(DateTime))
			{
				DateTime.TryParse(json.Replace("\"", ""), CultureInfo.InvariantCulture, DateTimeStyles.None, out var result3);
				return result3;
			}
			if (json == "null")
			{
				return null;
			}
			if (type.IsEnum)
			{
				if (json[0] == '"')
				{
					json = json.Substring(1, json.Length - 2);
				}
				try
				{
					return Enum.Parse(type, json, ignoreCase: false);
				}
				catch
				{
					return 0;
				}
			}
			if (type.IsArray)
			{
				Type elementType = type.GetElementType();
				if (json[0] != '[' || json[json.Length - 1] != ']')
				{
					return null;
				}
				List<string> list = Split(json);
				Array array = Array.CreateInstance(elementType, list.Count);
				for (int j = 0; j < list.Count; j++)
				{
					array.SetValue(ParseValue(elementType, list[j]), j);
				}
				splitArrayPool.Push(list);
				return array;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
			{
				Type type2 = type.GetGenericArguments()[0];
				if (json[0] != '[' || json[json.Length - 1] != ']')
				{
					return null;
				}
				List<string> list2 = Split(json);
				IList list3 = (IList)type.GetConstructor(new Type[1] { typeof(int) }).Invoke(new object[1] { list2.Count });
				for (int k = 0; k < list2.Count; k++)
				{
					list3.Add(ParseValue(type2, list2[k]));
				}
				splitArrayPool.Push(list2);
				return list3;
			}
			if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Dictionary<, >))
			{
				Type[] genericArguments = type.GetGenericArguments();
				Type type3 = genericArguments[0];
				Type type4 = genericArguments[1];
				if (type3 != typeof(string))
				{
					return null;
				}
				if (json[0] != '{' || json[json.Length - 1] != '}')
				{
					return null;
				}
				List<string> list4 = Split(json);
				if (list4.Count % 2 != 0)
				{
					return null;
				}
				IDictionary dictionary = (IDictionary)type.GetConstructor(new Type[1] { typeof(int) }).Invoke(new object[1] { list4.Count / 2 });
				for (int l = 0; l < list4.Count; l += 2)
				{
					if (list4[l].Length > 2)
					{
						string key = list4[l].Substring(1, list4[l].Length - 2);
						object value = ParseValue(type4, list4[l + 1]);
						dictionary[key] = value;
					}
				}
				return dictionary;
			}
			if (type == typeof(object))
			{
				return ParseAnonymousValue(json);
			}
			if (json[0] == '{' && json[json.Length - 1] == '}')
			{
				return ParseObject(type, json);
			}
			return null;
		}

		private static object ParseAnonymousValue(string json)
		{
			if (json.Length == 0)
			{
				return null;
			}
			if (json[0] == '{' && json[json.Length - 1] == '}')
			{
				List<string> list = Split(json);
				if (list.Count % 2 != 0)
				{
					return null;
				}
				Dictionary<string, object> dictionary = new Dictionary<string, object>(list.Count / 2);
				for (int i = 0; i < list.Count; i += 2)
				{
					dictionary[list[i].Substring(1, list[i].Length - 2)] = ParseAnonymousValue(list[i + 1]);
				}
				return dictionary;
			}
			if (json[0] == '[' && json[json.Length - 1] == ']')
			{
				List<string> list2 = Split(json);
				List<object> list3 = new List<object>(list2.Count);
				for (int j = 0; j < list2.Count; j++)
				{
					list3.Add(ParseAnonymousValue(list2[j]));
				}
				return list3;
			}
			if (json[0] == '"' && json[json.Length - 1] == '"')
			{
				string text = json.Substring(1, json.Length - 2);
				return text.Replace("\\", string.Empty);
			}
			if (char.IsDigit(json[0]) || json[0] == '-')
			{
				if (json.Contains("."))
				{
					double.TryParse(json, NumberStyles.Float, CultureInfo.InvariantCulture, out var result);
					return result;
				}
				int.TryParse(json, out var result2);
				return result2;
			}
			if (json == "true")
			{
				return true;
			}
			if (json == "false")
			{
				return false;
			}
			return null;
		}

		private static Dictionary<string, T> CreateMemberNameDictionary<T>(T[] members) where T : MemberInfo
		{
			Dictionary<string, T> dictionary = new Dictionary<string, T>(StringComparer.OrdinalIgnoreCase);
			foreach (T val in members)
			{
				if (val.IsDefined(typeof(IgnoreDataMemberAttribute), inherit: true))
				{
					continue;
				}
				string name = val.Name;
				if (val.IsDefined(typeof(DataMemberAttribute), inherit: true))
				{
					DataMemberAttribute dataMemberAttribute = (DataMemberAttribute)Attribute.GetCustomAttribute(val, typeof(DataMemberAttribute), inherit: true);
					if (!string.IsNullOrEmpty(dataMemberAttribute.Name))
					{
						name = dataMemberAttribute.Name;
					}
				}
				dictionary.Add(name.ToLower(), val);
			}
			return dictionary;
		}

		private static object ParseObject(Type type, string json)
		{
			object uninitializedObject = FormatterServices.GetUninitializedObject(type);
			if (uninitializedObject is IInitializable initializable)
			{
				initializable.Initialize();
			}
			List<string> list = Split(json);
			if (list.Count % 2 != 0)
			{
				return uninitializedObject;
			}
			if (!fieldInfoCache.TryGetValue(type, out var value))
			{
				value = CreateMemberNameDictionary(type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy));
				fieldInfoCache.Add(type, value);
			}
			if (!propertyInfoCache.TryGetValue(type, out var value2))
			{
				value2 = CreateMemberNameDictionary(type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.FlattenHierarchy));
				propertyInfoCache.Add(type, value2);
			}
			for (int i = 0; i < list.Count; i += 2)
			{
				if (list[i].Length <= 2)
				{
					continue;
				}
				string text = list[i].Substring(1, list[i].Length - 2).ToLower();
				string text2 = list[i + 1];
				if (value.TryGetValue(text, out var value3))
				{
					SetField(value3, uninitializedObject, text2);
					continue;
				}
				if (value2.TryGetValue(text, out var value4))
				{
					SetProperty(value4, uninitializedObject, text2);
					continue;
				}
				bool flag = false;
				foreach (KeyValuePair<string, FieldInfo> item in value)
				{
					FieldInfo value5 = item.Value;
					if (value5.FieldType.GetInterfaces().Contains(typeof(IFlexibleField)))
					{
						object value6 = value5.GetValue(uninitializedObject);
						if (value6 is IFlexibleField flexibleField && flexibleField.ContainsKey(text))
						{
							flexibleField.SetValue(text, (string)ParseValue(typeof(string), text2));
							flag = true;
							break;
						}
					}
				}
				if (!flag)
				{
					Plugin.VerboseWarning($"{text} field not found for {type}");
				}
			}
			return uninitializedObject;
		}

		private static void SetField(FieldInfo info, object o, string v)
		{
			if (info.FieldType.GetInterfaces().Contains(typeof(IFlexibleField)))
			{
				object value = info.GetValue(o);
				if (value == null)
				{
					Debug.LogError((object)$"{info.Name} field is null! {info.FieldType} o:{o} instance:{o}");
				}
				else if (value is IFlexibleField flexibleField)
				{
					flexibleField.SetValue(info.Name, (string)ParseValue(typeof(string), v));
				}
			}
			else
			{
				info.SetValue(o, ParseValue(info.FieldType, v));
			}
		}

		private static void SetProperty(PropertyInfo info, object o, string v)
		{
			info.SetValue(o, ParseValue(info.PropertyType, v), null);
		}

		public static string ToJSON<T>(T t)
		{
			return ToJSONInternal(typeof(T), t, "");
		}

		private static string ToJSONInternal(Type type, object t, string prefix)
		{
			try
			{
				if (type == typeof(string))
				{
					string text = (string)t;
					if (text != null)
					{
						return "\"" + text + "\"";
					}
					return "\"\"";
				}
				if (type == typeof(string[]))
				{
					string[] array = (string[])t;
					if (array != null && array.Length != 0)
					{
						string text2 = "[";
						for (int i = 0; i < array.Length; i++)
						{
							string text3 = array[i];
							text2 = text2 + "\"" + text3 + "\"";
							if (i < array.Length - 1)
							{
								text2 += ",";
							}
						}
						return text2 + "]";
					}
					return "[]";
				}
				if (type == typeof(int?))
				{
					int? num = (int?)t;
					if (num.HasValue)
					{
						return num.Value.ToString();
					}
					return "0";
				}
				if (type == typeof(bool?))
				{
					bool? flag = (bool?)t;
					if (flag.HasValue)
					{
						return flag.Value ? "true" : "false";
					}
					return "false";
				}
				if (type == typeof(bool))
				{
					return ((bool)t) ? "true" : "false";
				}
				if (type == typeof(int) || type == typeof(long))
				{
					return t.ToString();
				}
				if (type == typeof(Dictionary<string, string>))
				{
					Dictionary<string, string> dictionary = (Dictionary<string, string>)t;
					if (dictionary != null && dictionary.Count > 0)
					{
						string text4 = "{";
						int num2 = 0;
						foreach (KeyValuePair<string, string> item in dictionary)
						{
							text4 = ((num2++ <= 0) ? (text4 + "\n\t" + prefix + "\"" + item.Key + "\": \"" + item.Value + "\"") : (text4 + ",\n\t" + prefix + "\"" + item.Key + "\": \"" + item.Value + "\""));
						}
						if (num2 > 0)
						{
							return text4 + "\n" + prefix + "}";
						}
						return text4 + "}";
					}
					return "{}";
				}
				if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(List<>))
				{
					IList list = (IList)t;
					if (list != null && list.Count > 0)
					{
						Type type2 = list.GetType().GetGenericArguments().Single();
						string text5 = "";
						string text6 = prefix + "\t";
						for (int j = 0; j < list.Count; j++)
						{
							object t2 = list[j];
							text5 = text5 + "\n" + text6 + ToJSONInternal(type2, t2, text6);
							if (j < list.Count - 1)
							{
								text5 += ",";
							}
						}
						return "[" + text5 + "\n" + prefix + "]";
					}
					return "[]";
				}
				if (type.IsAssignableFrom(typeof(IFlexibleField)))
				{
					if (t != null)
					{
						return ((IFlexibleField)t).ToJSON();
					}
					Dictionary<string, string> rows = ((LocalizableField)t).rows;
					return ToJSONInternal(rows.GetType(), rows, prefix);
				}
				if (!type.IsValueType)
				{
					if (!publicFieldInfoCache.TryGetValue(type, out var value))
					{
						value = type.GetFields(BindingFlags.Instance | BindingFlags.Public);
						publicFieldInfoCache[type] = value;
					}
					string text7 = "{";
					int num3 = 0;
					string text8 = prefix + "\t";
					FieldInfo[] array2 = value;
					foreach (FieldInfo fieldInfo in array2)
					{
						string text9 = ToJSONInternal(fieldInfo.FieldType, fieldInfo.GetValue(t), text8);
						if (num3++ > 0)
						{
							text7 += ",";
						}
						text7 = text7 + "\n" + text8 + "\"" + fieldInfo.Name + "\": " + text9;
					}
					if (num3 > 0)
					{
						return text7 + "\n" + prefix + "}";
					}
					return text7 + prefix + "}";
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogError((object)$"Something went wrong while serializing JSON type: {type} value: {t}");
				Plugin.Log.LogError((object)ex);
				throw;
			}
			throw new NotImplementedException($"Type not supported for JSON serialization {type}");
		}
	}
}
namespace JLPlugin
{
	public static class Extensions
	{
		public static void Append<K, V>(this Dictionary<K, V> first, Dictionary<K, V> second)
		{
			second.ToList().ForEach(delegate(KeyValuePair<K, V> pair)
			{
				first[pair.Key] = pair.Value;
			});
		}
	}
	internal static class Interpreter
	{
		public static class RegexStrings
		{
			public static string Function = "([a-zA-Z]+)(?<!if|in)(\\(((?>\\((?<c>)|[^()]+|\\)(?<-c>))*(?(c)(?!)))\\))";

			public static string Variable = "\\[((?>\\[(?<c>)|[^\\[\\]]+|\\](?<-c>))*(?(c)(?!)))\\]";

			public static string GeneratedVariable = "\\[([^]]*?\\.[^[]*?)\\]";

			public static string Expression = "\\(((?>\\((?<c>)|[^()]+|\\)(?<-c>))*(?(c)(?!)))\\)";
		}

		public static Random random = new Random();

		public static object Process(in string input, AbilityBehaviourData abilityData, Type type = null, bool sendDebug = true, Dictionary<string, object?> additionalParameters = null)
		{
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Expected O, but got Unknown
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00bf: Expected O, but got Unknown
			object obj = input;
			MatchCollection matchCollection = Regex.Matches(input, RegexStrings.Expression);
			if (matchCollection.Cast<Match>().Any((Match expressions) => expressions.Success))
			{
				EvaluateFunctionHandler val2 = default(EvaluateFunctionHandler);
				foreach (Match item in matchCollection)
				{
					string value = item.Groups[0].Value;
					string value2 = item.Groups[1].Value;
					ExtendedExpression val = new ExtendedExpression(value2);
					EvaluateFunctionHandler obj2 = val2;
					if (obj2 == null)
					{
						EvaluateFunctionHandler val3 = delegate(string functionName, FunctionArgs functionArgs)
						{
							ConfigilExtensions.Extend(functionName, functionArgs, abilityData);
						};
						EvaluateFunctionHandler val4 = val3;
						val2 = val3;
						obj2 = val4;
					}
					((Expression)val).EvaluateFunction += obj2;
					if (additionalParameters != null)
					{
						Extensions.AddRange<string, object>(((Expression)val).Parameters, additionalParameters);
					}
					foreach (KeyValuePair<string, string> variable in abilityData.variables)
					{
						((Expression)val).Parameters[variable.Key] = variable.Value;
					}
					foreach (KeyValuePair<string, object> generatedVariable in abilityData.generatedVariables)
					{
						((Expression)val).Parameters[generatedVariable.Key] = generatedVariable.Value;
					}
					MatchCollection matchCollection2 = Regex.Matches(value2, RegexStrings.GeneratedVariable);
					if (matchCollection2.Cast<Match>().Any((Match variables) => variables.Success))
					{
						foreach (Match item2 in matchCollection2)
						{
							string value3 = item2.Groups[1].Value;
							((Expression)val).Parameters[value3] = ProcessGeneratedVariable(value3, abilityData);
						}
					}
					if (sendDebug)
					{
						Plugin.Log.LogDebug((object)("input: " + value));
					}
					object obj3 = ((Expression)val).Evaluate();
					if (type == null || matchCollection.Count > 1)
					{
						if (obj3.GetType() == typeof(bool))
						{
							obj3 = obj3.ToString().ToLower();
						}
						obj = obj.ToString().Replace(value, obj3.ToString());
					}
					else
					{
						obj = obj3;
					}
					if (sendDebug)
					{
						Plugin.Log.LogDebug((object)$"output: {obj3}");
					}
				}
			}
			return obj;
		}

		public static object ProcessGeneratedVariable(string contents, AbilityBehaviourData abilityData = null, object variable = null)
		{
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			List<string> list = contents.Split(new char[1] { '.' }).ToList();
			object value = variable;
			if (variable == null && abilityData != null && !abilityData.generatedVariables.TryGetValue(list[0], out value))
			{
				throw new Exception(list[0] + " is an invalid generated variable");
			}
			for (int i = 1; i < list.Count; i++)
			{
				if (value == null)
				{
					return null;
				}
				if (value.GetType() == typeof(PlayableCard))
				{
					if (list[i] == "TemporaryAbilities")
					{
						List<Ability> list2 = new List<Ability>();
						foreach (List<Ability> item in ((PlayableCard)value).TemporaryMods.Select((CardModificationInfo x) => x.abilities).ToList())
						{
							list2.AddRange(item);
						}
						value = list2;
						break;
					}
					if (list[i] == "AllAbilities")
					{
						List<Ability> list3 = new List<Ability>();
						foreach (List<Ability> item2 in ((PlayableCard)value).TemporaryMods.Select((CardModificationInfo x) => x.abilities).ToList())
						{
							list3.AddRange(item2);
						}
						list3.AddRange(((Card)(PlayableCard)value).Info.Abilities);
						value = list3;
						break;
					}
				}
				PropertyInfo property = value.GetType().GetProperty(list[i]);
				if ((object)property == null)
				{
					FieldInfo field = value.GetType().GetField(list[i]);
					if ((object)field == null)
					{
						return null;
					}
					value = field.GetValue(value);
				}
				else
				{
					if (property.GetIndexParameters().Length >= 1)
					{
						break;
					}
					value = property.GetValue(value);
				}
			}
			return value;
		}
	}
	internal static class Configs
	{
		private static ConfigEntry<bool> betaCompatibility;

		private static ConfigEntry<bool> verboseLogging;

		private static ConfigEntry<string> reloadHotkey;

		private static ConfigEntry<string> exportHotkey;

		private static ConfigFile configFile;

		private static Version oldConfigVersion;

		private static Version currentVersion;

		internal static bool BetaCompatibility => betaCompatibility.Value;

		internal static bool VerboseLogging => verboseLogging.Value;

		internal static string ReloadHotkey => reloadHotkey.Value;

		internal static string ExportHotkey => exportHotkey.Value;

		public static void InitializeConfigs(ConfigFile config)
		{
			configFile = config;
			currentVersion = new Version("2.5.3");
			oldConfigVersion = GetOldConfigVersion();
			betaCompatibility = config.Bind<bool>("JSONLoader", "JDLR Backwards Compatibility", true, "Set to true to enable old-style JSON files (JLDR) to be read and converted to new-style files (JLDR2)");
			verboseLogging = config.Bind<bool>("JSONLoader", "Verbose Logging", false, "Set to true to see more logs on what JSONLoader is doing and what isn't working.");
			reloadHotkey = config.Bind<string>("Hotkeys", "Reload JLDR2 and game", "LeftShift+R", "Restarts the game and reloads all JLDR2 files.");
			exportHotkey = config.Bind<string>("Hotkeys", "Export all to JLDR2", "LeftControl+RightControl+X", "Exports all data in the game back to .JLDR2 files.");
			MigrateConfigs();
			ModdedSaveManager.SaveData.SetValue("MADH.inscryption.JSONLoader", "LastLoadedVersion", (object)currentVersion.ToString());
		}

		private static Version GetOldConfigVersion()
		{
			string value = ModdedSaveManager.SaveData.GetValue("MADH.inscryption.JSONLoader", "LastLoadedVersion");
			if (string.IsNullOrEmpty(value))
			{
				return new Version("2.5.2");
			}
			return new Version(value);
		}

		private static void MigrateConfigs()
		{
			if (!(oldConfigVersion == currentVersion) && oldConfigVersion <= new Version("2.5.3"))
			{
				Plugin.Log.LogInfo((object)$"Migrating from {oldConfigVersion} to {currentVersion}!");
				if (ReloadHotkey == (string)((ConfigEntryBase)exportHotkey).DefaultValue && ExportHotkey == (string)((ConfigEntryBase)reloadHotkey).DefaultValue)
				{
					Plugin.Log.LogInfo((object)"\tMigrating hotkeys to new defaults!");
					exportHotkey.Value = (string)((ConfigEntryBase)exportHotkey).DefaultValue;
					reloadHotkey.Value = (string)((ConfigEntryBase)reloadHotkey).DefaultValue;
					configFile.Save();
				}
			}
		}
	}
	[BepInPlugin("MADH.inscryption.JSONLoader", "JSONLoader", "2.5.3")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class Plugin : BaseUnityPlugin
	{
		public static Plugin Instance;

		public const string PluginGuid = "MADH.inscryption.JSONLoader";

		public const string PluginName = "JSONLoader";

		public const string PluginVersion = "2.5.3";

		public static string JSONLoaderDirectory = "";

		public static string BepInExDirectory = "";

		internal static ManualLogSource Log;

		private HotkeyController hotkeyController;

		public static string ExportDirectory => Path.Combine(JSONLoaderDirectory, "Exported");

		private static List<string> GetAllJLDRFiles()
		{
			return (from a in Directory.GetFiles(Paths.PluginPath, "*.jldr*", SearchOption.AllDirectories)
				where (a.EndsWith(".jldr") || a.EndsWith(".jldr2")) && !a.Contains(Path.Combine(JSONLoaderDirectory, "Examples"))
				select a).ToList();
		}

		private void Awake()
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Expected O, but got Unknown
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loading JSONLoader!");
			Instance = this;
			Log = ((BaseUnityPlugin)this).Logger;
			JSONLoaderDirectory = Path.GetDirectoryName(((BaseUnityPlugin)this).Info.Location);
			int num = ((BaseUnityPlugin)this).Info.Location.LastIndexOf("BepInEx");
			if (num > 0)
			{
				BepInExDirectory = ((BaseUnityPlugin)this).Info.Location.Substring(0, num);
			}
			else
			{
				BepInExDirectory = Directory.GetParent(JSONLoaderDirectory)?.FullName ?? "";
			}
			Harmony val = new Harmony("MADH.inscryption.JSONLoader");
			val.PatchAll();
			Configs.InitializeConfigs(((BaseUnityPlugin)this).Config);
			Log.LogWarning((object)"Note: JSONLoader now uses .jldr2 files, not .json files.");
			List<string> allJLDRFiles = GetAllJLDRFiles();
			if (Configs.BetaCompatibility)
			{
				Log.LogWarning((object)"Note: Backwards compatibility has been enabled. Old *.jldr files will be converted to *.jldr2 automatically. This will slow down your game loading!");
				JLUtils.LoadCardsFromFiles(allJLDRFiles);
			}
			LoadAll(allJLDRFiles);
			hotkeyController = new HotkeyController();
			hotkeyController.AddHotkey(Configs.ReloadHotkey, ReloadGame);
			hotkeyController.AddHotkey(Configs.ExportHotkey, ExportAllToJLDR2);
			((BaseUnityPlugin)this).Logger.LogInfo((object)"Loaded JSONLoader!");
		}

		public static void LogFields()
		{
			string text = "\n";
			List<Type> list = new List<Type>();
			list.Add(typeof(PlayableCard));
			list.Add(typeof(CardInfo));
			list.Add(typeof(CardSlot));
			List<Type> list2 = list;
			foreach (Type item in list2)
			{
				FieldInfo[] fields = item.GetFields();
				if (fields.Length != 0)
				{
					string text2 = item.Name + " fields:\n";
					text += text2;
					text = text + new string('-', text2.Length - 1) + "\n";
					FieldInfo[] array = fields;
					foreach (FieldInfo fieldInfo in array)
					{
						text = text + fieldInfo.Name + " (" + fieldInfo.FieldType.Name + ")\n";
					}
					text = text + new string('-', text2.Length - 1) + "\n\n";
				}
				PropertyInfo[] properties = item.GetProperties();
				if (properties.Length != 0)
				{
					string text3 = item.Name + " properties:\n";
					text += text3;
					text = text + new string('-', text3.Length - 1) + "\n";
					PropertyInfo[] array2 = properties;
					foreach (PropertyInfo propertyInfo in array2)
					{
						text = text + propertyInfo.Name + " (" + propertyInfo.PropertyType.Name + ")\n";
					}
					text = text + new string('-', text3.Length - 1) + "\n\n";
				}
			}
			Log.LogInfo((object)text);
		}

		public void LoadAll(List<string> files)
		{
			TribeList.LoadAllTribes(files);
			SigilData.LoadAllSigils(files);
			CardSerializeInfo.LoadAllJLDR2(files);
			EncounterData.LoadAllEncounters(files);
			StarterDeckList.LoadAllStarterDecks(files);
			GramophoneData.LoadAllGramophone(files);
			LanguageData.LoadAllLanguages(files);
			MaskData.LoadAllMasks(files);
			LoadTalkingCards.InitAndLoad(files);
		}

		public void Update()
		{
			hotkeyController.Update();
		}

		private void ReloadGame()
		{
			List<string> allJLDRFiles = GetAllJLDRFiles();
			LoadAll(allJLDRFiles);
			CachedCardData.Flush();
			if (SaveFile.IsAscension)
			{
				ReloadKaycees();
			}
			if (SaveManager.SaveFile.IsPart1)
			{
				ReloadVanilla();
			}
		}

		public void ExportAllToJLDR2()
		{
			TribeList.ExportAllTribes();
			EncounterData.ExportAllEncounters();
			StarterDeckList.ExportAllStarterDecks();
			LanguageData.ExportAllLanguages();
			CardSerializeInfo.ExportAllCards();
		}

		public static void ReloadVanilla()
		{
			FrameLoopManager.Instance.SetIterationDisabled(false);
			MenuController.ReturnToStartScreen();
			MenuController.LoadGameFromMenu(false);
		}

		public static void ReloadKaycees()
		{
			FrameLoopManager.Instance.SetIterationDisabled(false);
			SceneLoader.Load("Ascension_Configure");
			FrameLoopManager.Instance.SetIterationDisabled(false);
			SaveManager.savingDisabled = false;
			MenuController.LoadGameFromMenu(false);
		}

		internal static void VerboseLog(string s)
		{
			if (Configs.VerboseLogging)
			{
				Log.LogInfo((object)s);
			}
		}

		internal static void VerboseWarning(string s)
		{
			if (Configs.VerboseLogging)
			{
				Log.LogWarning((object)s);
			}
		}

		internal static void VerboseError(string s)
		{
			if (Configs.VerboseLogging)
			{
				Log.LogError((object)s);
			}
		}
	}
}
namespace JLPlugin.Hotkeys
{
	internal class HotkeyController
	{
		public class Hotkey
		{
			public KeyCode[] KeyCodes;

			public Action Function;
		}

		private static Action<List<KeyCode>, KeyCode> OnHotkeyPressed = delegate
		{
		};

		private static KeyCode[] AllCodes = Enum.GetValues(typeof(KeyCode)).Cast<KeyCode>().ToArray();

		private List<Hotkey> Hotkeys = new List<Hotkey>();

		private List<KeyCode> m_pressedKeys = new List<KeyCode>();

		private bool m_hotkeyActivated = false;

		private static KeyCode[] DeserializeKeyCodes(string hotkey)
		{
			return hotkey.Trim().Split(new char[1] { '+' }).Select(delegate(string a)
			{
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_002e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				if (!Enum.TryParse<KeyCode>(a, out KeyCode result))
				{
					Plugin.Log.LogError((object)("Unknown hotkey: '" + a + "'. See possible hotkeys here separated by +. https://docs.unity3d.com/ScriptReference/KeyCode.html"));
				}
				return result;
			})
				.ToArray();
		}

		public void Update()
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: 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_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			KeyCode[] allCodes = AllCodes;
			foreach (KeyCode val in allCodes)
			{
				if (Input.GetKeyDown(val) && !m_pressedKeys.Contains(val))
				{
					m_pressedKeys.Add(val);
					HotkeysChanged(val, triggerHotkey: true);
				}
			}
			for (int j = 0; j < m_pressedKeys.Count; j++)
			{
				KeyCode val2 = m_pressedKeys[j];
				if (!Input.GetKey(val2))
				{
					m_pressedKeys.Remove(val2);
					HotkeysChanged((KeyCode)0, triggerHotkey: false);
					m_hotkeyActivated = false;
				}
			}
		}

		private void HotkeysChanged(KeyCode pressedButton, bool triggerHotkey)
		{
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Invalid comparison between Unknown and I4
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (triggerHotkey)
			{
				Hotkey hotkey = null;
				foreach (Hotkey hotkey2 in Hotkeys)
				{
					if (!m_hotkeyActivated && hotkey2.KeyCodes.Length != 0 && m_pressedKeys.Intersect(hotkey2.KeyCodes).Count() == hotkey2.KeyCodes.Length && (hotkey == null || hotkey.KeyCodes.Length < hotkey2.KeyCodes.Length))
					{
						hotkey = hotkey2;
					}
				}
				hotkey?.Function?.Invoke();
			}
			if ((int)pressedButton > 0)
			{
				OnHotkeyPressed?.Invoke(m_pressedKeys, pressedButton);
			}
		}

		public void AddHotkey(string hotkeys, Action callback)
		{
			Hotkeys.Add(new Hotkey
			{
				KeyCodes = DeserializeKeyCodes(hotkeys),
				Function = callback
			});
		}
	}
}
namespace JLPlugin.V2.Data
{
	public class CardSerializeInfo : JSONParser.IInitializable
	{
		public const string DEFAULT_MOD_PREFIX = "JSON";

		private static FieldInfo[] PUBLIC_FIELD_INFOS = typeof(CardSerializeInfo).GetFields(BindingFlags.Instance | BindingFlags.Public);

		public string name;

		public string modPrefix;

		public string[] decals;

		public JSONParser.LocalizableField displayedName;

		public JSONParser.LocalizableField description;

		public int? baseAttack;

		public int? baseHealth;

		public int? bloodCost;

		public int? bonesCost;

		public int? energyCost;

		public string[] gemsCost;

		public string[] abilities;

		public string[] specialAbilities;

		public string specialStatIcon;

		public string[] metaCategories;

		public string cardComplexity;

		public bool? onePerDeck;

		public string temple;

		public string titleGraphic;

		public bool? hideAttackAndHealth;

		public string[] appearanceBehaviour;

		public string texture;

		public string emissionTexture;

		public string holoPortraitPrefab;

		public string animatedPortrait;

		public string altTexture;

		public string altEmissionTexture;

		public string pixelTexture;

		public string[] tribes;

		public string[] traits;

		public string evolveIntoName;

		public int? evolveTurns;

		public string defaultEvolutionName;

		public string tailName;

		public string tailLostPortrait;

		public string iceCubeName;

		public bool? flipPortraitForStrafe;

		public Dictionary<string, string> extensionProperties;

		public string filePath;

		public CardSerializeInfo()
		{
			Initialize();
		}

		public void Initialize()
		{
			displayedName = new JSONParser.LocalizableField("displayedName");
			description = new JSONParser.LocalizableField("description");
		}

		public static void Apply(CardInfo cardInfo, CardSerializeInfo serializeInfo, bool toCardInfo, string cardName)
		{
			ImportExportUtils.SetID(cardName);
			ImportExportUtils.ApplyLocaleField("displayedName", ref serializeInfo.displayedName, ref cardInfo.displayedName, toCardInfo);
			ImportExportUtils.ApplyLocaleField("description", ref serializeInfo.description, ref cardInfo.description, toCardInfo);
			ImportExportUtils.ApplyProperty(() => ((Object)cardInfo).name, delegate(string a)
			{
				((Object)cardInfo).name = a;
			}, ref serializeInfo.name, toCardInfo, "Cards", "name");
			ImportExportUtils.ApplyValue(ref cardInfo.baseAttack, ref serializeInfo.baseAttack, toCardInfo, "Cards", "baseAttack");
			ImportExportUtils.ApplyValue(ref cardInfo.baseHealth, ref serializeInfo.baseHealth, toCardInfo, "Cards", "baseHealth");
			ImportExportUtils.ApplyValue(ref cardInfo.cost, ref serializeInfo.bloodCost, toCardInfo, "Cards", "cost");
			ImportExportUtils.ApplyValue(ref cardInfo.bonesCost, ref serializeInfo.bonesCost, toCardInfo, "Cards", "bonesCost");
			ImportExportUtils.ApplyValue(ref cardInfo.energyCost, ref serializeInfo.energyCost, toCardInfo, "Cards", "energyCost");
			ImportExportUtils.ApplyValue(ref cardInfo.gemsCost, ref serializeInfo.gemsCost, toCardInfo, "Cards", "gemsCost");
			ImportExportUtils.ApplyValue(ref cardInfo.abilities, ref serializeInfo.abilities, toCardInfo, "Cards", "abilities");
			ImportExportUtils.ApplyValue(ref cardInfo.specialAbilities, ref serializeInfo.specialAbilities, toCardInfo, "Cards", "specialAbilities");
			ImportExportUtils.ApplyValue(ref cardInfo.specialStatIcon, ref serializeInfo.specialStatIcon, toCardInfo, "Cards", "specialStatIcon");
			ImportExportUtils.ApplyValue(ref cardInfo.metaCategories, ref serializeInfo.metaCategories, toCardInfo, "Cards", "metaCategories");
			ImportExportUtils.ApplyValue(ref cardInfo.cardComplexity, ref serializeInfo.cardComplexity, toCardInfo, "Cards", "cardComplexity");
			ImportExportUtils.ApplyValue(ref cardInfo.onePerDeck, ref serializeInfo.onePerDeck, toCardInfo, "Cards", "onePerDeck");
			ImportExportUtils.ApplyValue(ref cardInfo.temple, ref serializeInfo.temple, toCardInfo, "Cards", "temple");
			ImportExportUtils.ApplyValue(ref cardInfo.titleGraphic, ref serializeInfo.titleGraphic, toCardInfo, "Cards", "titleGraphic");
			ImportExportUtils.ApplyValue(ref cardInfo.hideAttackAndHealth, ref serializeInfo.hideAttackAndHealth, toCardInfo, "Cards", "hideAttackAndHealth");
			ImportExportUtils.ApplyValue(ref cardInfo.appearanceBehaviour, ref serializeInfo.appearanceBehaviour, toCardInfo, "Cards", "appearanceBehaviour");
			ImportExportUtils.ApplyValue(ref cardInfo.tribes, ref serializeInfo.tribes, toCardInfo, "Cards", "tribes");
			ImportExportUtils.ApplyValue(ref cardInfo.traits, ref serializeInfo.traits, toCardInfo, "Cards", "traits");
			ImportExportUtils.ApplyValue(ref cardInfo.defaultEvolutionName, ref serializeInfo.defaultEvolutionName, toCardInfo, "Cards", "defaultEvolutionName");
			ImportExportUtils.ApplyValue(ref cardInfo.flipPortraitForStrafe, ref serializeInfo.flipPortraitForStrafe, toCardInfo, "Cards", "flipPortraitForStrafe");
			ImportExportUtils.ApplyValue(ref cardInfo.decals, ref serializeInfo.decals, toCardInfo, "Cards", "decals");
			ImportExportUtils.ApplyValue(ref cardInfo.portraitTex, ref serializeInfo.texture, toCardInfo, "Cards", "texture");
			ImportExportUtils.ApplyValue(ref cardInfo.alternatePortrait, ref serializeInfo.altTexture, toCardInfo, "Cards", "altTexture");
			ImportExportUtils.ApplyValue(ref cardInfo.pixelPortrait, ref serializeInfo.pixelTexture, toCardInfo, "Cards", "pixelTexture");
			Sprite a2 = CardExtensions.GetEmissivePortrait(cardInfo);
			Sprite a3 = CardExtensions.GetEmissiveAltPortrait(cardInfo);
			ImportExportUtils.ApplyValue(ref a2, ref serializeInfo.emissionTexture, toCardInfo, "Cards", "emissionTexture");
			ImportExportUtils.ApplyValue(ref a3, ref serializeInfo.altEmissionTexture, toCardInfo, "Cards", "altEmissionTexture");
			if ((Object)(object)cardInfo.portraitTex != (Object)null && (Object)(object)a2 != (Object)null)
			{
				CardExtensions.SetEmissivePortrait(cardInfo, a2);
			}
			if ((Object)(object)cardInfo.alternatePortrait != (Object)null && (Object)(object)a3 != (Object)null)
			{
				CardExtensions.SetEmissiveAltPortrait(cardInfo, a3);
			}
			if (toCardInfo)
			{
				if (!string.IsNullOrEmpty(serializeInfo.evolveIntoName))
				{
					CardExtensions.SetEvolve(cardInfo, serializeInfo.evolveIntoName, (!serializeInfo.evolveTurns.HasValue) ? 1 : serializeInfo.evolveTurns.Value, (IEnumerable<CardModificationInfo>)null);
				}
			}
			else if (cardInfo.evolveParams != null)
			{
				CardInfo evolution = cardInfo.evolveParams.evolution;
				serializeInfo.evolveIntoName = ((evolution != null) ? ((Object)evolution).name : null);
				serializeInfo.evolveTurns = cardInfo.evolveParams.turnsToEvolve;
			}
			if (toCardInfo)
			{
				if (!string.IsNullOrEmpty(serializeInfo.tailName))
				{
					CardExtensions.SetTail(cardInfo, serializeInfo.tailName, serializeInfo.tailLostPortrait, (IEnumerable<CardModificationInfo>)null);
				}
			}
			else if (cardInfo.tailParams != null)
			{
				CardInfo tail = cardInfo.tailParams.tail;
				serializeInfo.tailName = ((tail != null) ? ((Object)tail).name : null);
				ImportExportUtils.ApplyValue(ref cardInfo.tailParams.tailLostPortrait, ref serializeInfo.tailLostPortrait, toCardInfo, "Cards", "tailLostPortrait");
			}
			if (toCardInfo)
			{
				if (!string.IsNullOrEmpty(serializeInfo.iceCubeName))
				{
					CardExtensions.SetIceCube(cardInfo, serializeInfo.iceCubeName, (IEnumerable<CardModificationInfo>)null);
				}
			}
			else if (cardInfo.iceCubeParams != null)
			{
				serializeInfo.iceCubeName = ((Object)cardInfo.iceCubeParams.creatureWithin).name;
			}
			if (toCardInfo)
			{
				if (serializeInfo.extensionProperties != null)
				{
					foreach (KeyValuePair<string, string> extensionProperty in serializeInfo.extensionProperties)
					{
						CardExtensions.SetExtendedProperty(cardInfo, extensionProperty.Key, (object)extensionProperty.Value);
					}
				}
				CardExtensions.SetExtendedProperty(cardInfo, "JSONFilePath", (object)serializeInfo.filePath);
			}
			else
			{
				Dictionary<string, string> cardExtensionTable = CardManager.GetCardExtensionTable(cardInfo);
				if (cardExtensionTable != null && cardExtensionTable.Count > 0)
				{
					foreach (KeyValuePair<string, string> item in cardExtensionTable)
					{
						if (item.Key == "ModPrefix")
						{
							serializeInfo.modPrefix = item.Value;
						}
					}
					serializeInfo.extensionProperties = cardExtensionTable;
				}
			}
			if (toCardInfo)
			{
				if (!string.IsNullOrEmpty(serializeInfo.holoPortraitPrefab))
				{
					cardInfo.holoPortraitPrefab = Resources.Load<GameObject>(serializeInfo.holoPortraitPrefab);
				}
			}
			else if ((Object)(object)cardInfo.holoPortraitPrefab != (Object)null)
			{
				serializeInfo.holoPortraitPrefab = ((object)cardInfo.holoPortraitPrefab).ToString();
			}
			if (toCardInfo)
			{
				if (!string.IsNullOrEmpty(serializeInfo.animatedPortrait))
				{
					cardInfo.animatedPortrait = Resources.Load<GameObject>(serializeInfo.animatedPortrait);
				}
			}
			else if ((Object)(object)cardInfo.animatedPortrait != (Object)null)
			{
				serializeInfo.holoPortraitPrefab = ((object)cardInfo.animatedPortrait).ToString();
			}
		}

		private void ApplyLocaleField(string field, JSONParser.LocalizableField rows, out string cardInfoEnglishField)
		{
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Invalid comparison between Unknown and I4
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			if (rows.rows.TryGetValue(rows.englishFieldName, out var value))
			{
				cardInfoEnglishField = value;
			}
			else
			{
				if (rows.rows.Count <= 0)
				{
					cardInfoEnglishField = null;
					return;
				}
				cardInfoEnglishField = rows.rows.First().Value;
			}
			foreach (KeyValuePair<string, string> row in rows.rows)
			{
				if (row.Key == rows.englishFieldName)
				{
					continue;
				}
				int num = row.Key.LastIndexOf("_", StringComparison.Ordinal);
				if (num >= 0)
				{
					int length = row.Key.Length - num - 1;
					string text = row.Key.Substring(num + 1, length);
					Language val = LocalizationManager.CodeToLanguage(text);
					if ((int)val != 12)
					{
						LocalizationManager.Translate("MADH.inscryption.JSONLoader", (string)null, cardInfoEnglishField, row.Value, val);
					}
					else
					{
						Plugin.Log.LogDebug((object)$"Unknown language code {text} for card {displayedName} in field {field}");
					}
				}
			}
		}

		internal void Apply(bool UpdateCard = false)
		{
			if (string.IsNullOrEmpty(name))
			{
				throw new InvalidOperationException("Card cannot have an empty name!");
			}
			CardInfo val = (CardInfo)(UpdateCard ? ((object)ScriptableObjectLoader<CardInfo>.AllData.Find((CardInfo x) => ((Object)x).name == name)) : ((object)CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, name)));
			if ((Object)(object)val != (Object)null)
			{
				Plugin.VerboseLog("Modifying " + name + " using " + ToJSON());
				Apply(val, this, toCardInfo: true, ((Object)val).name);
				return;
			}
			Plugin.VerboseLog("New Card " + name + " using " + ToJSON());
			string text = modPrefix ?? "JSON";
			CardInfo val2 = ScriptableObject.CreateInstance<CardInfo>();
			((Object)val2).name = (name.StartsWith(text + "_") ? name : (text + "_" + name));
			Apply(val2, this, toCardInfo: true, ((Object)val2).name);
			CardManager.Add(text, val2);
		}

		internal void Remove()
		{
			if (string.IsNullOrEmpty(name))
			{
				throw new InvalidOperationException("Card cannot have an empty name!");
			}
			CardInfo val = CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, name);
			if ((Object)(object)val != (Object)null)
			{
				throw new InvalidOperationException("Base game cards cannot be removed!");
			}
			ObservableCollection<CardInfo> source = (ObservableCollection<CardInfo>)typeof(CardManager).GetField("NewCards", BindingFlags.Static | BindingFlags.NonPublic).GetValue(null);
			CardInfo val2 = ((IEnumerable<CardInfo>)source).FirstOrDefault((Func<CardInfo, bool>)((CardInfo x) => ((Object)x).name == name));
			if ((Object)(object)val2 != (Object)null)
			{
				CardManager.Remove(val2);
			}
			else
			{
				Plugin.Log.LogWarning((object)("Cannot remove " + name));
			}
		}

		internal CardInfo ToCardInfo()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			if (string.IsNullOrEmpty(name))
			{
				throw new InvalidOperationException("Card cannot have an empty name!");
			}
			CardInfo val = (CardInfo)CardExtensions.CardByName((IEnumerable<CardInfo>)CardManager.BaseGameCards, name).Clone();
			if ((Object)(object)val != (Object)null)
			{
				Plugin.Log.LogDebug((object)("Modifying " + name + " using " + ToJSON()));
				Apply(val, this, toCardInfo: true, name);
				return val;
			}
			string text = modPrefix ?? "JSON";
			CardInfo val2 = ScriptableObject.CreateInstance<CardInfo>();
			((Object)val2).name = (name.StartsWith(text + "_") ? name : (text + "_" + name));
			Apply(val2, this, toCardInfo: true, name);
			return val2;
		}

		public string WriteToFile(string filename, bool overwrite = true)
		{
			Plugin.Log.LogDebug((object)("Writing card " + (name ?? "Unnamed") + " to " + filename));
			if (!filename.EndsWith("2"))
			{
				filename += "2";
			}
			if (overwrite || !File.Exists(filename))
			{
				File.WriteAllText(filename, ToJSON());
			}
			return filename;
		}

		private string ToJSON()
		{
			string text = "{\n";
			FieldInfo[] pUBLIC_FIELD_INFOS = PUBLIC_FIELD_INFOS;
			foreach (FieldInfo fieldInfo in pUBLIC_FIELD_INFOS)
			{
				if (fieldInfo.FieldType == typeof(string))
				{
					string text2 = (string)fieldInfo.GetValue(this);
					if (!string.IsNullOrEmpty(text2))
					{
						text = text + "\t\"" + fieldInfo.Name + "\": \"" + text2 + "\",\n";
					}
				}
				else if (fieldInfo.FieldType == typeof(string[]))
				{
					string[] array = (string[])fieldInfo.GetValue(this);
					if (array != null && array.Length != 0)
					{
						text = text + "\t\"" + fieldInfo.Name + "\": [" + string.Join(",", array.Select((string v) => "\"" + v + "\"")) + "],\n";
					}
				}
				else if (fieldInfo.FieldType == typeof(int?))
				{
					int? num = (int?)fieldInfo.GetValue(this);
					if (num.HasValue)
					{
						text += $"\t\"{fieldInfo.Name}\": {num.Value},\n";
					}
				}
				else if (fieldInfo.FieldType == typeof(bool?))
				{
					bool? flag = (bool?)fieldInfo.GetValue(this);
					if (flag.HasValue)
					{
						text = text + "\t\"" + fieldInfo.Name + "\": " + (flag.Value ? "true" : "false") + ",\n";
					}
				}
				else if (fieldInfo.FieldType == typeof(Dictionary<string, string>))
				{
					Dictionary<string, string> dictionary = (Dictionary<string, string>)fieldInfo.GetValue(this);
					if (dictionary == null || dictionary.Count <= 0)
					{
						continue;
					}
					text = text + "\t\"" + fieldInfo.Name + "\": {\n";
					foreach (KeyValuePair<string, string> item in dictionary.Where((KeyValuePair<string, string> kvp) => !string.IsNullOrEmpty(kvp.Key) && !string.IsNullOrEmpty(kvp.Value)))
					{
						text = text + "\t\t\"" + item.Key + "\": \"" + item.Value + "\",\n";
					}
					text += "\t},\n";
				}
				else
				{
					if (!fieldInfo.FieldType.IsAssignableFrom(typeof(JSONParser.IFlexibleField)))
					{
						continue;
					}
					object value = fieldInfo.GetValue(this);
					if (value != null)
					{
						text += ((JSONParser.IFlexibleField)value).ToJSON();
					}
					Dictionary<string, string> rows = ((JSONParser.LocalizableField)fieldInfo.GetValue(this)).rows;
					foreach (KeyValuePair<string, string> item2 in rows)
					{
						text = text + "\t\"" + item2.Key + "\": " + item2.Value + ",\n";
					}
				}
			}
			return text.TrimEnd('\n', ',') + "\n}";
		}

		public static void LoadAllJLDR2(List<string> files)
		{
			for (int i = 0; i < files.Count; i++)
			{
				string text = files[i];
				string text2 = text.Substring(text.LastIndexOf(Path.DirectorySeparatorChar) + 1);
				if (!text2.EndsWith("_encounter.jldr2") && !text2.EndsWith("_tribe.jldr2") && !text2.EndsWith("_tribes.jldr2") && !text2.EndsWith("_sigil.jldr2") && !text2.EndsWith("_deck.jldr2") && !text2.EndsWith("_gram.jldr2") && !text2.EndsWith("_language.jldr2") && !text2.EndsWith("_mask.jldr2") && !text2.EndsWith("_talk.jldr2"))
				{
					files.RemoveAt(i--);
					Plugin.VerboseLog("Loading JLDR2 Card " + text2);
					ImportExportUtils.SetDebugPath(text);
					try
					{
						CardSerializeInfo cardSerializeInfo = File.ReadAllText(text).FromJson<CardSerializeInfo>();
						cardSerializeInfo.filePath = text;
						cardSerializeInfo.Apply();
						Plugin.VerboseLog("Loaded JSON card " + cardSerializeInfo.name);
					}
					catch (Exception ex)
					{
						Plugin.Log.LogError((object)("Failed to load " + text2 + ": " + ex.Message));
						Plugin.Log.LogError((object)ex);
					}
				}
			}
		}

		public static void ExportAllCards()
		{
			Plugin.Log.LogInfo((object)$"Exporting {CardManager.AllCardsCopy.Count} cards.");
			foreach (CardInfo item in CardManager.AllCardsCopy)
			{
				string text = Path.Combine(Plugin.ExportDirectory, "Cards", ((Object)item).name + ".jldr2");
				ImportExportUtils.SetDebugPath(text);
				CardSerializeInfo cardSerializeInfo = new CardSerializeInfo();
				Apply(item, cardSerializeInfo, toCardInfo: false, ((Object)item).name);
				string directoryName = Path.GetDirectoryName(text);
				if (!Directory.Exists(directoryName))
				{
					Directory.CreateDirectory(directoryName);
				}
				cardSerializeInfo.WriteToFile(text);
			}
		}
	}
}
namespace JLPlugin.Utils
{
	public static class CDUtils
	{
		public static void CheckValidFields(List<string> fields)
		{
			foreach (string field in fields)
			{
				if (string.IsNullOrEmpty(field))
				{
					Plugin.Log.LogError((object)(ErrorUtil.Card + " - fieldsToEdit cannot contain an empty string"));
				}
				else if (!Dicts.CardDataFields.Contains(field))
				{
					Plugin.Log.LogError((object)(ErrorUtil.Card + " - \"" + field + "\" is an invalid field name"));
				}
			}
		}

		public static T Assign<T>(string data, string field, Dictionary<string, T> dict)
		{
			ErrorUtil.Field = field;
			if (string.IsNullOrEmpty(data))
			{
				return default(T);
			}
			if (!dict.ContainsKey(data))
			{
				ErrorUtil.Log(data);
				return default(T);
			}
			return dict[data];
		}

		public static List<T> Assign<T>(List<string> list, string field, Dictionary<string, T> dict)
		{
			ErrorUtil.Field = field;
			if (list == null || list.Count == 0)
			{
				return null;
			}
			List<T> list2 = new List<T>();
			foreach (string item in list)
			{
				if (!dict.ContainsKey(item))
				{
					ErrorUtil.Log(item);
				}
				else
				{
					list2.Add(dict[item]);
				}
			}
			if (list2.Count == 0)
			{
				return null;
			}
			return list2;
		}

		public static Texture2D Assign(string image, string field)
		{
			ErrorUtil.Field = field;
			if (string.IsNullOrEmpty(image))
			{
				return null;
			}
			if (!image.EndsWith(".png"))
			{
				ErrorUtil.Log(image, ", it must be a .png");
				return null;
			}
			return JLUtils.LoadTexture2D(image);
		}

		public static List<Texture> Assign(List<string> list, string field)
		{
			ErrorUtil.Field = field;
			if (list == null || list.Count == 0)
			{
				return null;
			}
			List<Texture> list2 = new List<Texture>();
			foreach (string item in list)
			{
				if (!string.IsNullOrEmpty(item))
				{
					if (!item.EndsWith(".png"))
					{
						ErrorUtil.Log(item, ", it must be a .png");
					}
					else
					{
						list2.Add((Texture)(object)JLUtils.LoadTexture2D(item));
					}
				}
			}
			if (list2.Count == 0)
			{
				return null;
			}
			return list2;
		}
	}
	public static class Dicts
	{
		public static readonly Dictionary<string, CardMetaCategory> MetaCategory = Enum.GetValues(typeof(CardMetaCategory)).Cast<CardMetaCategory>().ToDictionary((CardMetaCategory t) => ((object)(CardMetaCategory)(ref t)).ToString(), (CardMetaCategory t) => t);

		public static readonly Dictionary<string, CardComplexity> Complexity = Enum.GetValues(typeof(CardComplexity)).Cast<CardComplexity>().ToDictionary((CardComplexity t) => ((object)(CardComplexity)(ref t)).ToString(), (CardComplexity t) => t);

		public static readonly Dictionary<string, CardTemple> Temple = Enum.GetValues(typeof(CardTemple)).Cast<CardTemple>().ToDictionary((CardTemple t) => ((object)(CardTemple)(ref t)).ToString(), (CardTemple t) => t);

		public static readonly Dictionary<string, GemType> GemColour = Enum.GetValues(typeof(GemType)).Cast<GemType>().ToDictionary((GemType t) => ((object)(GemType)(ref t)).ToString(), (GemType t) => t);

		public static readonly Dictionary<string, SpecialStatIcon> StatIcon = Enum.GetValues(typeof(SpecialStatIcon)).Cast<SpecialStatIcon>().ToDictionary((SpecialStatIcon t) => ((object)(SpecialStatIcon)(ref t)).ToString(), (SpecialStatIcon t) => t);

		public static readonly Dictionary<string, Tribe> Tribes = Enum.GetValues(typeof(Tribe)).Cast<Tribe>().ToDictionary((Tribe t) => ((object)(Tribe)(ref t)).ToString(), (Tribe t) => t);

		public static readonly Dictionary<string, Trait> Traits = Enum.GetValues(typeof(Trait)).Cast<Trait>().ToDictionary((Trait t) => ((object)(Trait)(ref t)).ToString(), (Trait t) => t);

		public static readonly Dictionary<string, SpecialTriggeredAbility> SpecialAbilities = Enum.GetValues(typeof(SpecialTriggeredAbility)).Cast<SpecialTriggeredAbility>().ToDictionary((SpecialTriggeredAbility t) => ((object)(SpecialTriggeredAbility)(ref t)).ToString(), (SpecialTriggeredAbility t) => t);

		public static readonly Dictionary<string, Ability> Abilities = Enum.GetValues(typeof(Ability)).Cast<Ability>().ToDictionary((Ability t) => ((object)(Ability)(ref t)).ToString(), (Ability t) => t);

		public static readonly Dictionary<string, Appearance> AppearanceBehaviour = Enum.GetValues(typeof(Appearance)).Cast<Appearance>().ToDictionary((Appearance t) => ((object)(Appearance)(ref t)).ToString(), (Appearance t) => t);

		public static readonly List<string> CardDataFields = (from elem in typeof(CardData).GetFields()
			select elem.Name).ToList();
	}
	[StructLayout(LayoutKind.Sequential, Size = 1)]
	public struct ErrorUtil
	{
		public static string Card { get; set; }

		public static string Field { get; set; }

		public static string Message { get; set; }

		public static void Log(string Data, string addition = "")
		{
			Plugin.Log.LogError((object)string.Format(Message + addition, Card, Field, Data));
		}

		public static void Clear()
		{
			Card = null;
			Field = null;
			Message = null;
		}
	}
	[Obsolete]
	public static class IDUtils
	{
		public static EvolveIdentifier GenerateEvolveIdentifier(CardData card)
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Expected O, but got Unknown
			if (card.evolution == null)
			{
				return null;
			}
			if (string.IsNullOrEmpty(card.evolution.name))
			{
				Plugin.Log.LogError((object)(card.name + " - evolution must have a name"));
				return null;
			}
			return new EvolveIdentifier(card.evolution.name, (card.evolution.turnsToEvolve == 0) ? 1 : card.evolution.turnsToEvolve, (CardModificationInfo)null);
		}

		public static TailIdentifier GenerateTailIdentifier(CardData card)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Expected O, but got Unknown
			if (card.tail == null)
			{
				return null;
			}
			if (string.IsNullOrEmpty(card.tail.name))
			{
				Plugin.Log.LogError((object)(card.name + " - tail must have a name"));
				return null;
			}
			return new TailIdentifier(card.tail.name, CDUtils.Assign(card.tail.tailLostPortrait, "tailLostPortrait"), (CardModificationInfo)null);
		}

		public static IceCubeIdentifier GenerateIceCubeIdentifier(CardData card)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Expected O, but got Unknown
			if (card.iceCube == null)
			{
				return null;
			}
			if (string.IsNullOrEmpty(card.iceCube.creatureWithin))
			{
				Plugin.Log.LogError((object)(card.name + " - iceCube must have a creatureWithin"));
				return null;
			}
			return new IceCubeIdentifier(card.iceCube.creatureWithin, (CardModificationInfo)null);
		}

		public static List<AbilityIdentifier> GenerateAbilityIdentifiers(List<AbilityData> list)
		{
			return list?.Select((AbilityData elem) => AbilityIdentifier.GetAbilityIdentifier(elem.GUID, elem.name)).ToList();
		}

		public static List<SpecialAbilityIdentifier> GenerateSpecialAbilityIdentifiers(List<SpecialAbilityData> list)
		{
			return list?.Select((SpecialAbilityData elem) => SpecialAbilityIdentifier.GetID(elem.GUID, elem.name)).ToList();
		}
	}
	[Obsolete]
	public static class JLUtils
	{
		public static void LoadCardsFromFiles(List<string> files)
		{
			Dictionary<string, CardData> dictionary = new Dictionary<string, CardData>();
			for (int num = files.Count - 1; num >= 0; num--)
			{
				string text = files[num];
				string text2 = text.Substring(text.LastIndexOf(Path.DirectorySeparatorChar) + 1);
				if (text.EndsWith(".jldr"))
				{
					files.RemoveAt(num);
					CardData cardData = File.ReadAllText(text).FromJson<CardData>();
					if (cardData == null)
					{
						Plugin.Log.LogWarning((object)("Failed to load " + text2));
					}
					else
					{
						dictionary.Add(text, cardData);
					}
				}
			}
			List<CardData> allKnownCards = dictionary.Values.ToList();
			foreach (KeyValuePair<string, CardData> item2 in dictionary)
			{
				string key = item2.Key;
				CardData value = item2.Value;
				CardSerializeInfo cardSerializeInfo = value.ConvertToV2(allKnownCards);
				if (cardSerializeInfo != null)
				{
					string item = cardSerializeInfo.WriteToFile(key, overwrite: false);
					files.Add(item);
				}
				else
				{
					Plugin.Log.LogError((object)(key + " is a JLDR without a valid name"));
				}
			}
		}

		public static Texture2D LoadTexture2D(string image)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Expected O, but got Unknown
			string[] files = Directory.GetFiles(Paths.PluginPath, image, SearchOption.AllDirectories);
			if (files.Length == 0)
			{
				Plugin.Log.LogError((object)(ErrorUtil.Card + " - Couldn't find texture \"" + image + "\" to load into " + ErrorUtil.Field));
				return null;
			}
			if (files.Length > 1)
			{
				Plugin.Log.LogError((object)(ErrorUtil.Card + " - Couldn't load \"" + image + "\" into " + ErrorUtil.Field + ", more than one file with that name found in the plugins folder"));
				return null;
			}
			byte[] array = File.ReadAllBytes(files[0]);
			Texture2D val = new Texture2D(2, 2);
			if (!ImageConversion.LoadImage(val, array))
			{
				Plugin.Log.LogError((object)(ErrorUtil.Card + " - Couldn't load \"" + image + "\" into " + ErrorUtil.Field));
				return null;
			}
			return val;
		}
	}
}
namespace JLPlugin.SigilCode
{
	public abstract class ConfigurableBase : ActivatedAbilityBehaviour
	{
		public SigilData abilityData = new SigilData();

		public Ability ability = (Ability)0;

		public override Ability Ability => ability;

		public PlayableCard PlayableCard => ((Component)this).GetComponent<PlayableCard>();
	}
	public abstract class ConfigurableSpecialBase : SpecialCardBehaviour
	{
		public SigilData abilityData = new SigilData();

		public SpecialTriggeredAbility specialAbility = (SpecialTriggeredAbility)0;
	}
	[HarmonyPatch(typeof(CardTriggerHandler), "AddAbility", new Type[] { typeof(Ability) })]
	public class Add_Ability_patch
	{
		[HarmonyPrefix]
		public static bool Prefix(Ability ability, CardTriggerHandler __instance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: 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_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			if (!SigilDicts.ArgumentList.ContainsKey(ability))
			{
				return true;
			}
			Type item = SigilDicts.ArgumentList[ability].Item1;
			if ((!__instance.triggeredAbilities.Exists((Tuple<Ability, AbilityBehaviour> x) => x.Item1 == ability) || AbilitiesUtil.GetInfo(ability).canStack) && !AbilitiesUtil.GetInfo(ability).passive)
			{
				ConfigurableBase configurableBase = ((Component)__instance).gameObject.AddComponent(item) as ConfigurableBase;
				configurableBase.abilityData = SigilData.GetAbilityArguments(ability);
				configurableBase.ability = ability;
				__instance.triggeredAbilities.Add(new Tuple<Ability, AbilityBehaviour>(ability, (AbilityBehaviour)(object)configurableBase));
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CardTriggerHandler), "AddAbility", new Type[] { typeof(SpecialTriggeredAbility) })]
	public class Add__Special_Ability_patch
	{
		[HarmonyPrefix]
		public static bool Prefix(SpecialTriggeredAbility ability, CardTriggerHandler __instance)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			if (!SigilDicts.SpecialArgumentList.ContainsKey(ability))
			{
				return true;
			}
			Type item = SigilDicts.SpecialArgumentList[ability].Item1;
			if (!__instance.specialAbilities.Exists((Tuple<SpecialTriggeredAbility, SpecialCardBehaviour> x) => x.Item1 == ability))
			{
				ConfigurableSpecialBase configurableSpecialBase = ((Component)__instance).gameObject.AddComponent(item) as ConfigurableSpecialBase;
				configurableSpecialBase.abilityData = SigilData.GetAbilityArguments(ability);
				__instance.specialAbilities.Add(new Tuple<SpecialTriggeredAbility, SpecialCardBehaviour>(ability, (SpecialCardBehaviour)(object)configurableSpecialBase));
			}
			return false;
		}
	}
	[HarmonyPatch(/*Could not decode attribute arguments.*/)]
	public class GetOpposingSlots_patch
	{
		[HarmonyPostfix]
		public static void Postfix(PlayableCard __instance, ref List<CardSlot> __result)
		{
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.OnBoard)
			{
				return;
			}
			foreach (CardSlot item in Singleton<BoardManager>.Instance.AllSlotsCopy)
			{
				if ((Object)(object)item.Card == (Object)null)
				{
					continue;
				}
				foreach (Ability triggeredAbility in item.Card.GetTriggeredAbilities())
				{
					if (!SigilDicts.ArgumentList.ContainsKey(triggeredAbility) || !item.Card.HasAbility(triggeredAbility))
					{
						continue;
					}
					foreach (AbilityBehaviourData item2 in SigilData.GetAbilityArguments(triggeredAbility).abilityBehaviour.Where((AbilityBehaviourData x) => x?.extraAttacks != null))
					{
						foreach (extraAttacks extraAttack in item2.extraAttacks)
						{
							SigilData.UpdateVariables(item2, item.Card);
							item2.generatedVariables["TriggerCard"] = __instance;
							if (SigilData.ConvertArgument(extraAttack.runOnCondition, item2) == "false")
							{
								continue;
							}
							CardSlot val = slotData.GetSlot(extraAttack.attackingSlot, item2);
							if (extraAttack.attackingSlot == null)
							{
								val = item;
							}
							if (!((Object)(object)val == (Object)(object)__instance.slot))
							{
								continue;
							}
							__result.Remove(__instance.Slot.opposingSlot);
							foreach (slotData item3 in extraAttack.slotsToAttack)
							{
								CardSlot slot = slotData.GetSlot(item3, item2);
								if ((Object)(object)slot != (Object)null)
								{
									__result.Add(slot);
								}
							}
						}
					}
				}
			}
		}
	}
	[HarmonyPatch]
	public class OnBoardCleanup_patch
	{
		[HarmonyPrefix]
		[HarmonyPatch(typeof(TurnManager), "CleanupPhase")]
		public static void CleanupPhase()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			foreach (CardSlot item in Singleton<BoardManager>.Instance.AllSlotsCopy)
			{
				if ((Object)(object)item.Card == (Object)null)
				{
					continue;
				}
				foreach (Ability triggeredAbility in item.Card.GetTriggeredAbilities())
				{
					if (SigilDicts.ArgumentList.ContainsKey(triggeredAbility))
					{
						((Card)item.Card).Info.temporaryDecals.Clear();
						((Card)item.Card).RenderCard();
					}
				}
				foreach (SpecialTriggeredAbility specialAbility in ((Card)item.Card).Info.SpecialAbilities)
				{
					if (SigilDicts.SpecialArgumentList.ContainsKey(specialAbility))
					{
						((Card)item.Card).Info.temporaryDecals.Clear();
						((Card)item.Card).RenderCard();
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayableCard), "GetPassiveAttackBuffs")]
	public class PassiveAttackBuffs_patch
	{
		[HarmonyPostfix]
		public static void Postfix(ref int __result, ref PlayableCard __instance)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.OnBoard)
			{
				return;
			}
			foreach (CardSlot item in Singleton<BoardManager>.Instance.AllSlotsCopy)
			{
				if ((Object)(object)item.Card == (Object)null)
				{
					continue;
				}
				foreach (Ability triggeredAbility in item.Card.GetTriggeredAbilities())
				{
					if (SigilDicts.ArgumentList.ContainsKey(triggeredAbility))
					{
						ApplyBuffs(SigilData.GetAbilityArguments(triggeredAbility).abilityBehaviour, item, ref __result, ref __instance);
					}
				}
				foreach (SpecialTriggeredAbility specialAbility in ((Card)item.Card).Info.SpecialAbilities)
				{
					if (SigilDicts.SpecialArgumentList.ContainsKey(specialAbility))
					{
						ApplyBuffs(SigilData.GetAbilityArguments(specialAbility).abilityBehaviour, item, ref __result, ref __instance);
					}
				}
			}
		}

		public static void ApplyBuffs(List<AbilityBehaviourData> AbilityBehaviourList, CardSlot slot, ref int __result, ref PlayableCard __instance)
		{
			foreach (AbilityBehaviourData item in AbilityBehaviourList.Where((AbilityBehaviourData x) => x.trigger?.triggerType == "Passive"))
			{
				if (item.buffCards == null)
				{
					continue;
				}
				foreach (buffCards buffCard in item.buffCards)
				{
					SigilData.UpdateVariables(item, slot.Card);
					if (SigilData.ConvertArgument(buffCard.runOnCondition, item, sendDebug: false) == "false")
					{
						continue;
					}
					CardSlot val = slotData.GetSlot(buffCard.slot, item, sendDebug: false);
					if (buffCard.slot == null)
					{
						val = slot;
					}
					if (!((Object)(object)val == (Object)(object)__instance.slot))
					{
						continue;
					}
					if (!string.IsNullOrEmpty(buffCard.addStats))
					{
						string text = SigilData.ConvertArgument(buffCard.addStats.Split(new char[1] { '/' })[0], item, sendDebug: false);
						if (text != "?")
						{
							__result += int.Parse(text);
						}
					}
					if (!string.IsNullOrEmpty(buffCard.setStats))
					{
						string text2 = SigilData.ConvertArgument(buffCard.setStats.Split(new char[1] { '/' })[0], item, sendDebug: false);
						if (text2 != "?")
						{
							__result = int.Parse(text2) - ((Card)slot.Card).Info.Attack;
						}
					}
				}
			}
		}
	}
	[HarmonyPatch(typeof(PlayableCard), "GetPassiveHealthBuffs")]
	public class PassiveHealthBuffs_patch
	{
		[HarmonyPostfix]
		public static void Postfix(ref int __result, ref PlayableCard __instance)
		{
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			if (!__instance.OnBoard)
			{
				return;
			}
			foreach (CardSlot item in Singleton<BoardManager>.Instance.AllSlotsCopy)
			{
				if ((Object)(object)item.Card == (Object)null)
				{
					continue;
				}
				foreach (Ability triggeredAbility in item.Card.GetTriggeredAbilities())
				{
					if (SigilDicts.ArgumentList.ContainsKey(triggeredAbility))
					{
						ApplyBuffs(SigilData.GetAbilityArguments(triggeredAbility).abilityBehaviour, item, ref __result, ref __instance);
					}
				}
				foreach (SpecialTriggeredAbility specialAbility in ((Card)item.Card).Info.SpecialAbilities)
				{
					if (SigilDicts.SpecialArgumentList.ContainsKey(specialAbility))
					{
						ApplyBuffs(SigilData.GetAbilityArguments(specialAbility).abilityBehaviour, item, ref __result, ref __instance);
					}
				}
			}
		}

		public static void ApplyBuffs(List<AbilityBehaviourData> AbilityBehaviourList, CardSlot slot, ref int __result, ref PlayableCard __instance)
		{
			foreach (AbilityBehaviourData item in AbilityBehaviourList.Where((AbilityBehaviourData x) => x.trigger?.triggerType == "Passive"))
			{
				if (item.buffCards == null)
				{
					continue;
				}
				foreach (buffCards buffCard in item.buffCards)
				{
					SigilData.UpdateVariables(item, slot.Card);
					if (SigilData.ConvertArgument(buffCard.runOnCondition, item, sendDebug: false) == "false")
					{
						continue;
					}
					CardSlot val = slotData.GetSlot(buffCard.slot, item, sendDebug: false);
					if (buffCard.slot == null)
					{
						val = slot;
					}
					if (!((Object)(object)val == (Object)(object)__instance.slot))
					{
						continue;
					}
					if (!string.IsNullOrEmpty(buffCard.addStats))
					{
						string text = SigilData.ConvertArgument(buffCard.addStats.Split(new char[1] { '/' })[1], item, sendDebug: false);
						if (text != "?")
						{
							__result += int.Parse(text);
						}
					}
					if (!string.IsNullOrEmpty(buffCard.setStats))
					{
						string text2 = SigilData.ConvertArgument(buffCard.setStats.Split(new char[1] { '/' })[1], item, sendDebug: false);
						if (text2 != "?")
						{
							__result = int.Parse(text2) - ((Card)slot.Card).Info.Health;
						}
					}
					if (((Card)__instance).Info.Health + __result <= 0)
					{
						((MonoBehaviour)Singleton<BoardManager>.Instance).StartCoroutine(__instance.Die(false, (PlayableCard)null, true));
					}
				}
			}
		}
	}
	public static class CachedCardData
	{
		private static Dictionary<string, CardSerializeInfo> CardDataCache = new Dictionary<string, CardSerializeInfo>();

		public static CardSerializeInfo? Get(string filePath)
		{
			if (filePath == null)
			{
				return null;
			}
			if (!CardDataCache.ContainsKey(filePath))
			{
				return null;
			}
			return CardDataCache[filePath];
		}

		public static void Add(string filePath, CardSerializeInfo data)
		{
			CardDataCache[filePath] = data;
		}

		public static bool Contains(string? filePath)
		{
			return filePath != null && CardDataCache.ContainsKey(filePath);
		}

		public static void Flush()
		{
			CardDataCache.Clear();
		}
	}
	public class ConfigurableMain : ConfigurableBase, IOnBellRung, IOnOtherCardAddedToHand, IOnCardAssignedToSlotContext, IOnCardDealtDamageDirectly
	{
		public override int BonesCost => (abilityData.activationCost?.bonesCost).GetValueOrDefault();

		public override int EnergyCost => (abilityData.activationCost?.energyCost).GetValueOrDefault();

		public override int Priority => abilityData.priority.GetValueOrDefault();

		public override bool CanActivate()
		{
			AbilityBehaviourData abilityBehaviourData = abilityData.abilityBehaviour.Where((AbilityBehaviourData x) => x.trigger?.triggerType == "OnActivate").ToList()[0];
			if (abilityBehaviourData == null)
			{
				return false;
			}
			SigilData.UpdateVariables(abilityBehaviourData, base.PlayableCard);
			return (SigilData.ConvertArgument(abilityBehaviourData.trigger?.activatesForCardsWithCondition, abilityBehaviourData) ?? "true") == "true";
		}

		public override IEnumerator Activate()
		{
			int BloodCost = (abilityData.activationCost?.bloodCost).GetValueOrDefault();
			if (BloodCost > 0)
			{
				List<CardSlot> occupiedSlots = Singleton<BoardManager>.Instance.PlayerSlotsCopy.FindAll((CardSlot x) => (Object)(object)x.Card != (Object)null && (Object)(object)x.Card != (Object)(object)((AbilityBehaviour)this).Card);
				if (!((Object)(object)Singleton<BoardManager>.Instance != (Object)null) || Singleton<BoardManager>.Instance.AvailableSacrificeValueInSlots(occupiedSlots) < BloodCost)
				{
					((Card)base.PlayableCard).Anim.LightNegationEffect();
					AudioController.Instance.PlaySound2D("toneless_negate", (MixerGroup)10, 0.2f, 0f, (Pitch)null, (Repetition)null, (Randomization)null, (Distortion)null, false);
					yield return (object)new WaitForSeconds(0.25f);
					yield break;
				}
				Singleton<BoardManager>.Instance.CancelledSacrifice = false;
				yield return Singleton<BoardManager>.Instance.ChooseSacrificesForCard(occupiedSlots, ((AbilityBehaviour)this).Card, BloodCost);
				if (Singleton<BoardManager>.Instance.CancelledSacrifice)
				{
					yield break;
				}
			}
			List<GemType> GemCost = abilityData.activationCost?.gemsCost?.Select((string s) => ImportExportUtils.ParseEnum<GemType>(s)).ToList() ?? new List<GemType>();
			foreach (GemType Gem in GemCost)
			{
				if (!Singleton<ResourcesManager>.Instance.HasGem(Gem))
				{
					((Card)base.PlayableCard).Anim.LightNegationEffect();
					AudioController.Instance.PlaySound2D("toneless_negate", (MixerGroup)10, 0.2f, 0f, (Pitch)null, (Repetition)null, (Randomization)null, (Distortion)null, false);
					yield return (object)new WaitForSeconds(0.25f);
					yield break;
				}
			}
			yield return TriggerSigil("OnActivate");
		}

		public void Start()
		{
			if (abilityData?.abilityBehaviour == null)
			{
				return;
			}
			foreach (AbilityBehaviourData item in abilityData.abilityBehaviour)
			{
				item.TurnsInPlay = 0;
				string extendedProperty = CardExtensions.GetExtendedProperty(((Card)base.PlayableCard).Info, "JSONFilePath");
				if (extendedProperty != null)
				{
					if (!CachedCardData.Contains(extendedProperty))
					{
						CachedCardData.Add(extendedProperty, File.ReadAllText(extendedProperty).FromJson<CardSerializeInfo>());
					}
					CardSerializeInfo cardSerializeInfo = CachedCardData.Get(extendedProperty);
					if (cardSerializeInfo.extensionProperties != null)
					{
						foreach (KeyValuePair<string, string> extensionProperty in cardSerializeI