using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Permissions;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using CollectionWeaver.Core;
using EnhancedPrefabLoader.API;
using EnhancedPrefabLoader.API.Assets;
using EnhancedPrefabLoader.API.Behaviors;
using EnhancedPrefabLoader.API.Events;
using EnhancedPrefabLoader.API.Extensions;
using EnhancedPrefabLoader.API.InternalBridges;
using EnhancedPrefabLoader.API.Models;
using EnhancedPrefabLoader.API.Registry;
using EnhancedPrefabLoader.API.Services;
using EnhancedPrefabLoader.API.UI;
using EnhancedPrefabLoader.Core;
using EnhancedPrefabLoader.Core.Assets;
using EnhancedPrefabLoader.Core.Cards;
using EnhancedPrefabLoader.Core.Cards.ExpGenerators;
using EnhancedPrefabLoader.Core.Cards.PriceGenerators;
using EnhancedPrefabLoader.Core.Components;
using EnhancedPrefabLoader.Core.Events;
using EnhancedPrefabLoader.Core.Extensions;
using EnhancedPrefabLoader.Core.ExternalBridges;
using EnhancedPrefabLoader.Core.LoadingPipeline;
using EnhancedPrefabLoader.Core.LoadingPipeline.Processors;
using EnhancedPrefabLoader.Core.LoadingPipeline.Validators;
using EnhancedPrefabLoader.Core.Models.Runtime;
using EnhancedPrefabLoader.Core.Models.SaveData;
using EnhancedPrefabLoader.Core.Packs.PackGenerators;
using EnhancedPrefabLoader.Core.Patches;
using EnhancedPrefabLoader.Core.Properties;
using EnhancedPrefabLoader.Core.Registry;
using EnhancedPrefabLoader.Core.Saves;
using EnhancedPrefabLoader.Core.Services;
using EnhancedPrefabLoader.Core.Services.Internal;
using EnhancedPrefabLoader.Core.Settings;
using EnhancedPrefabLoader.Core.Shops;
using EnhancedPrefabLoader.Core.Trading;
using EnhancedPrefabLoader.Core.Uninstall;
using EnhancedPrefabLoader.Core.Utils;
using EnhancedPrefabLoader.Shared.Enums;
using EnhancedPrefabLoader.Shared.Extensions;
using EnhancedPrefabLoader.Shared.Helpers;
using EnhancedPrefabLoader.Shared.Models;
using HarmonyLib;
using I2.Loc;
using Microsoft.CodeAnalysis;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Newtonsoft.Json.Serialization;
using TMPro;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.Experimental.Rendering;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using UnityEngine.Video;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: IgnoresAccessChecksTo("Assembly-CSharp")]
[assembly: AssemblyCompany("EnhancedPrefabLoader")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("6.2.3.0")]
[assembly: AssemblyInformationalVersion("6.2.3+35f34656f829a028d941f0dc922be3d2b18bf963")]
[assembly: AssemblyProduct("Enhanced Prefab Loader")]
[assembly: AssemblyTitle("EnhancedPrefabLoader")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("6.2.3.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[CompilerGenerated]
internal sealed class <>z__ReadOnlyArray<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Length;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

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

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

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

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

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

	bool ICollection<T>.IsReadOnly => true;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlyList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	int ICollection.Count => _items.Count;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

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

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

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

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

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

	bool ICollection<T>.IsReadOnly => true;

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

	public <>z__ReadOnlyList(List<T> items)
	{
		_items = items;
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
[CompilerGenerated]
internal sealed class <>z__ReadOnlySingleElementList<T> : IEnumerable, ICollection, IList, IEnumerable<T>, IReadOnlyCollection<T>, IReadOnlyList<T>, ICollection<T>, IList<T>
{
	private sealed class Enumerator : IDisposable, IEnumerator, IEnumerator<T>
	{
		object IEnumerator.Current => _item;

		T IEnumerator<T>.Current => _item;

		public Enumerator(T item)
		{
			_item = item;
		}

		bool IEnumerator.MoveNext()
		{
			if (!_moveNextCalled)
			{
				return _moveNextCalled = true;
			}
			return false;
		}

		void IEnumerator.Reset()
		{
			_moveNextCalled = false;
		}

		void IDisposable.Dispose()
		{
		}
	}

	int ICollection.Count => 1;

	bool ICollection.IsSynchronized => false;

	object ICollection.SyncRoot => this;

	object IList.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	bool IList.IsFixedSize => true;

	bool IList.IsReadOnly => true;

	int IReadOnlyCollection<T>.Count => 1;

	T IReadOnlyList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
	}

	int ICollection<T>.Count => 1;

	bool ICollection<T>.IsReadOnly => true;

	T IList<T>.this[int index]
	{
		get
		{
			if (index != 0)
			{
				throw new IndexOutOfRangeException();
			}
			return _item;
		}
		set
		{
			throw new NotSupportedException();
		}
	}

	public <>z__ReadOnlySingleElementList(T item)
	{
		_item = item;
	}

	IEnumerator IEnumerable.GetEnumerator()
	{
		return new Enumerator(_item);
	}

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

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

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

	bool IList.Contains(object value)
	{
		return EqualityComparer<T>.Default.Equals(_item, (T)value);
	}

	int IList.IndexOf(object value)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, (T)value))
		{
			return -1;
		}
		return 0;
	}

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

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

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

	IEnumerator<T> IEnumerable<T>.GetEnumerator()
	{
		return new Enumerator(_item);
	}

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

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

	bool ICollection<T>.Contains(T item)
	{
		return EqualityComparer<T>.Default.Equals(_item, item);
	}

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

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

	int IList<T>.IndexOf(T item)
	{
		if (!EqualityComparer<T>.Default.Equals(_item, item))
		{
			return -1;
		}
		return 0;
	}

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

	void IList<T>.RemoveAt(int index)
	{
		throw new NotSupportedException();
	}
}
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[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]
	[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;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
public sealed class ConfigurationManagerAttributes
{
	public delegate void CustomHotkeyDrawerFunc(ConfigEntryBase setting, ref bool isCurrentlyAcceptingInput);

	public bool? ShowRangeAsPercent;

	public Action<ConfigEntryBase> CustomDrawer;

	public CustomHotkeyDrawerFunc CustomHotkeyDrawer;

	public bool? Browsable;

	public string Category;

	public object DefaultValue;

	public bool? HideDefaultButton;

	public bool? HideSettingName;

	public string Description;

	public string DispName;

	public int? Order;

	public bool? ReadOnly;

	public bool? IsAdvanced;

	public Func<object, string> ObjToStr;

	public Func<string, object> StrToObj;
}
namespace EnhancedPrefabLoader
{
	[BepInDependency("EnhancedPrefabLoader.API", "6.1.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInPlugin("EnhancedPrefabLoader", "Enhanced Prefab Loader", "6.2.3")]
	public class Plugin : BaseUnityPlugin
	{
		private readonly Harmony harmony = new Harmony("EnhancedPrefabLoader");

		private bool legacyPlayTablesChecked;

		internal static Plugin Instance { get; private set; }

		public Plugin()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			Instance = this;
		}

		private void Awake()
		{
			EplRuntimeData.Config.Initialize(((BaseUnityPlugin)this).Config);
			ModLogger.Initialize(((BaseUnityPlugin)this).Logger);
			ValidateApiAssembly();
			Epl.RegisterApi((IEplApi)(object)new EplApi());
			InterceptorRegistry.RegisterFromAssembly(Assembly.GetExecutingAssembly());
			StreamingAssetsBridge.AssetLoadBridge = (IAssetLoadBridge)(object)EplRuntimeData.Services.StreamingAssetService;
			StreamingAssetsBridge.AssetRefTracker = (IAssetRefTracker)(object)EplRuntimeData.Services.StreamingAssetService;
			EplRuntimeData.Events.OnInventoryBaseAwake += delegate
			{
				EplRuntimeData.Services.ShopInventoryManager.PopulateAllShopInventories();
			};
			SceneManager.sceneLoaded += OnSceneLoad;
			harmony.PatchAll();
			ModLogger.Info("Plugin Enhanced Prefab Loader v:6.2.3 by GhostNarwhal is loaded!", "Awake", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Plugin.cs");
		}

		private void OnDestroy()
		{
			harmony.UnpatchSelf();
			ModLogger.Info("Plugin Enhanced Prefab Loader is unloaded!", "OnDestroy", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Plugin.cs");
		}

		private static void ValidateApiAssembly()
		{
			Assembly assembly = typeof(Epl).Assembly;
			AssemblyName loadedName = assembly.GetName();
			AssemblyName assemblyName = typeof(Plugin).Assembly.GetReferencedAssemblies().FirstOrDefault((AssemblyName a) => a.Name == loadedName.Name);
			if (assemblyName != null && loadedName.Version < assemblyName.Version)
			{
				ModLogger.Error($"Loaded {loadedName.Name} {loadedName.Version} is older than the {assemblyName.Version} this EnhancedPrefabLoader build was compiled against — another mod is likely shipping an outdated copy at '{assembly.Location}'. Remove duplicate EnhancedPrefabLoader.API.dll files; only the standalone API mod should provide it.", "ValidateApiAssembly", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Plugin.cs");
			}
		}

		private void NeutralizeLegacyEnhancedPlayTables()
		{
			if (!Chainloader.PluginInfos.ContainsKey("EnhancedPlayTables"))
			{
				return;
			}
			ModLogger.Error("EnhancedPlayTables is installed alongside EnhancedPrefabLoader, which now includes its play-table card features — uninstall EnhancedPlayTables. Its patches have been disabled for this session.", "NeutralizeLegacyEnhancedPlayTables", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Plugin.cs");
			foreach (MethodBase item in Harmony.GetAllPatchedMethods().ToList())
			{
				harmony.Unpatch(item, (HarmonyPatchType)0, "EnhancedPlayTables");
			}
		}

		private void OnSceneLoad(Scene scene, LoadSceneMode _)
		{
			if (!legacyPlayTablesChecked)
			{
				legacyPlayTablesChecked = true;
				NeutralizeLegacyEnhancedPlayTables();
			}
			if (((Scene)(ref scene)).name == "Title")
			{
				EplRuntimeData.Services.SaveDataManager.ResetAllSaveData();
				EplRuntimeData.Services.ShopService.ResetUIState();
				EplRuntimeData.Services.PlayTableService.Reset();
				EplRuntimeData.Services.CardExpansionSelectService.IsLoaded = false;
				EplRuntimeData.Services.CardRaritySelectService.IsLoaded = false;
				EplRuntimeData.Services.CollectionBinderService.IsLoaded = false;
				EplRuntimeData.Services.SettingsScreenService.IsLoaded = false;
				EplRuntimeData.Services.ScriptHookService.Reset();
			}
			else
			{
				EplRuntimeData.Services.ShopService.CreateAndRegisterCustomShops();
				EplRuntimeData.Services.StreamingAssetService.StartCleanupCoroutine();
				EplRuntimeData.Services.ScriptHookService.SubscribeGameEvents();
			}
		}
	}
}
namespace EnhancedPrefabLoader.Shared.Models
{
	public class BundleDescriptor
	{
		private List<string> assemblies = new List<string>();

		private List<CustomShopInfo> customShops = new List<CustomShopInfo>();

		private List<ItemInfo> items = new List<ItemInfo>();

		private List<PrefabInfo> prefabs = new List<PrefabInfo>();

		private List<CardExpansionInfo> cardExpansions = new List<CardExpansionInfo>();

		public string BundleId { get; set; } = string.Empty;

		public string Name { get; set; } = string.Empty;

		public bool ItemPricesSuppliedByApi { get; set; }

		public List<string> Assemblies
		{
			get
			{
				return assemblies;
			}
			set
			{
				assemblies = value ?? new List<string>();
			}
		}

		public List<CustomShopInfo> CustomShops
		{
			get
			{
				return customShops;
			}
			set
			{
				customShops = value ?? new List<CustomShopInfo>();
			}
		}

		public List<ItemInfo> Items
		{
			get
			{
				return items;
			}
			set
			{
				items = value ?? new List<ItemInfo>();
			}
		}

		public List<PrefabInfo> Prefabs
		{
			get
			{
				return prefabs;
			}
			set
			{
				prefabs = value ?? new List<PrefabInfo>();
			}
		}

		public List<CardExpansionInfo> CardExpansions
		{
			get
			{
				return cardExpansions;
			}
			set
			{
				cardExpansions = value ?? new List<CardExpansionInfo>();
			}
		}

		public List<PrefabInfo> Furniture => Prefabs.Where((PrefabInfo p) => p.AddItemToFurnitureShop).ToList();

		public List<PrefabInfo> Deco => Prefabs.Where((PrefabInfo p) => p.IsDecoObject || p.IsDecoFloorTexture || p.IsDecoCeilingTexture || p.IsDecoWallTexture).ToList();

		public HashSet<string> MeshNames
		{
			get
			{
				HashSet<string> hashSet = new HashSet<string>();
				foreach (string item in from i in Items
					where !string.IsNullOrWhiteSpace(i.Mesh)
					select i.Mesh)
				{
					hashSet.Add(item);
				}
				return hashSet;
			}
		}
	}
	public class CardExpansionInfo
	{
		public string Name { get; set; } = string.Empty;

		public string MenuCategory { get; set; } = string.Empty;

		public string CardExpansion { get; set; } = string.Empty;

		[JsonProperty("CardbackSprite")]
		public string Cardback { get; set; } = string.Empty;

		public string FoilMask { get; set; } = string.Empty;

		public bool HasRandomFoils { get; set; }

		public float FoilChance { get; set; }

		public List<string> Rarities { get; set; } = new List<string>();

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

		public string CardPriceStrategy { get; set; } = string.Empty;

		public bool CardPriceStrategySuppliedByApi { get; set; }

		public float DefaultBorderMultiplierBase { get; set; } = 3.15f;

		public float DefaultFoilMultiplier { get; set; } = 2.9f;

		public float RarityDrivenFloor { get; set; } = 4f;

		public float RarityDrivenStepSize { get; set; } = 1026f;

		public float RarityDrivenBorderMultiplierBase { get; set; } = 1.15f;

		public float RarityDrivenFoilMultiplier { get; set; } = 1.4f;

		public int TradeUnlockLevel { get; set; }

		public List<string> PlayCardMaterials { get; set; } = new List<string>();

		public bool IsValid { get; set; } = true;
	}
	public class CardExpansionMetadata
	{
		public string ExpansionName { get; set; } = string.Empty;

		public int CardCount { get; set; }
	}
	public class CardInfo
	{
		public string Name { get; set; } = string.Empty;

		public string ElementType { get; set; } = string.Empty;

		public string Rarity { get; set; } = string.Empty;

		public int CardNumber { get; set; }

		public string Sprite { get; set; } = string.Empty;

		public string BorderType { get; set; } = string.Empty;

		public bool IsFoil { get; set; }

		public string FoilMask { get; set; } = string.Empty;

		public string Cardback { get; set; } = string.Empty;
	}
	public struct ColorData
	{
		public float R { get; set; }

		public float G { get; set; }

		public float B { get; set; }

		public float A { get; set; }
	}
	public class CustomShopInfo
	{
		public string PhoneAppId { get; set; } = string.Empty;

		public string AppDisplayName { get; set; } = string.Empty;

		public string AppIcon { get; set; } = string.Empty;

		public string AppInnerBGImage { get; set; } = string.Empty;

		public string AppOuterBGImage { get; set; } = string.Empty;

		public string SiteLogo { get; set; } = string.Empty;

		public string SiteHeader { get; set; } = string.Empty;

		public string SiteBackground { get; set; } = string.Empty;

		public bool IsValid { get; internal set; } = true;
	}
	public class ItemInfo
	{
		public string Name { get; set; } = string.Empty;

		public string ItemCategory { get; set; } = string.Empty;

		public string SpriteName { get; set; } = string.Empty;

		public float BaseCost { get; set; }

		public bool AddItemAsAccessory { get; set; }

		public bool AddItemAsFigurine { get; set; }

		public bool AddItemAsBoardGame { get; set; }

		public string PhoneAppId { get; set; } = string.Empty;

		public string ItemType { get; set; } = string.Empty;

		public bool UsesBaseGameMesh { get; set; }

		public string MeshToUse { get; set; } = string.Empty;

		public string Mesh { get; set; } = string.Empty;

		public string MeshSecondary { get; set; } = string.Empty;

		public string Material { get; set; } = string.Empty;

		public string MaterialSecondary { get; set; } = string.Empty;

		public List<string> MaterialList { get; set; } = new List<string>();

		[JsonProperty("IsBigBox")]
		public bool HasBigBox { get; set; }

		public bool HasSmallBox { get; set; }

		[JsonProperty("HideTillUnlocked")]
		public bool BigBoxHideTillUnlocked { get; set; }

		public bool SmallBoxHideTillUnlocked { get; set; }

		[JsonProperty("LicensePrice")]
		public float BigBoxLicensePrice { get; set; }

		public float SmallBoxLicensePrice { get; set; }

		[JsonProperty("LicenseLevelRequirement")]
		public int BigBoxLicenseLevelRequirement { get; set; }

		public int SmallBoxLicenseLevelRequirement { get; set; }

		[JsonProperty("IgnoreDoubleImage")]
		public bool BigBoxIgnoreDoubleImage { get; set; }

		public bool SmallBoxIgnoreDoubleImage { get; set; }

		[JsonProperty("HasBigBox")]
		private bool HasBigBoxAlias
		{
			set
			{
				HasBigBox = value;
			}
		}

		[JsonProperty("BigBoxHideTillUnlocked")]
		private bool BigBoxHideTillUnlockedAlias
		{
			set
			{
				BigBoxHideTillUnlocked = value;
			}
		}

		[JsonProperty("BigBoxLicensePrice")]
		private float BigBoxLicensePriceAlias
		{
			set
			{
				BigBoxLicensePrice = value;
			}
		}

		[JsonProperty("BigBoxLicenseLevelRequirement")]
		private int BigBoxLicenseLevelRequirementAlias
		{
			set
			{
				BigBoxLicenseLevelRequirement = value;
			}
		}

		[JsonProperty("BigBoxIgnoreDoubleImage")]
		private bool BigBoxIgnoreDoubleImageAlias
		{
			set
			{
				BigBoxIgnoreDoubleImage = value;
			}
		}

		public float MinMarketPricePercent { get; set; }

		public float MaxMarketPricePercent { get; set; }

		public string FollowItemPrice { get; set; } = string.Empty;

		public bool AutoSetBoxPrice { get; set; }

		public bool MarketPricePercentSuppliedByApi { get; set; }

		public bool FollowItemPriceSuppliedByApi { get; set; }

		public bool AutoBoxPriceSuppliedByApi { get; set; }

		public bool LicensePriceSuppliedByApi { get; set; }

		public bool LicenseLevelSuppliedByApi { get; set; }

		public bool IsTallItem { get; set; }

		public float InBoxOffsetY { get; set; }

		public float InBoxOffsetScale { get; set; }

		public Vector3Data ItemDeminsion { get; set; }

		public Vector3Data CollidorPosOffset { get; set; }

		public Vector3Data ColliderScale { get; set; }

		public List<string> PriceAffectedBy { get; set; } = new List<string>();

		public bool IsSprayCan { get; set; }

		public bool IsCardPack { get; set; }

		public bool ApiManaged { get; set; }

		public bool IsCardBox { get; set; }

		public bool IsBulkBox { get; set; }

		public int MinValue { get; set; }

		public string CardExpansion { get; set; } = string.Empty;

		public bool CanHaveDuplicates { get; set; }

		public bool CanHaveGodPacks { get; set; }

		public string PackGenerationStrategy { get; set; } = string.Empty;

		public Dictionary<string, float> NormalWeights { get; set; } = new Dictionary<string, float>();

		public Dictionary<string, float> GodWeights { get; set; } = new Dictionary<string, float>();

		public Dictionary<string, Dictionary<string, float>> SlotWeights { get; set; } = new Dictionary<string, Dictionary<string, float>>();

		public bool NormalWeightsSuppliedByApi { get; set; }

		public bool GodWeightsSuppliedByApi { get; set; }

		public bool SlotWeightsSuppliedByApi { get; set; }

		public bool CanHaveGodPacksSuppliedByApi { get; set; }

		public bool GodPackPercentageSuppliedByApi { get; set; }

		[Obsolete("Use NormalWeights, GodWeights, and SlotWeights instead. This field exists for backwards compatibility with older descriptors.")]
		public List<RarityWeightInfo> GenerationWeights { get; set; } = new List<RarityWeightInfo>();

		public string SpawnsPackType { get; set; } = string.Empty;

		public string PackType { get; set; } = string.Empty;

		public float GodPackPercentage { get; set; }

		public bool IsValid { get; set; } = true;
	}
	public class ModManifest
	{
		public string ModId { get; set; } = string.Empty;

		public string Name { get; set; } = string.Empty;

		public string Directory { get; set; } = string.Empty;

		public string BundlePath { get; set; } = string.Empty;

		public string JsonPath { get; set; } = string.Empty;

		public bool IsValid { get; set; } = true;

		public bool IsLoaded { get; set; } = true;

		public List<string> Errors { get; set; } = new List<string>();

		public int ItemCount { get; set; }

		public int FurnitureCount { get; set; }

		public int CustomShopCount { get; set; }

		public int DecoCount { get; set; }

		public List<CardExpansionMetadata> CardExpansions { get; set; } = new List<CardExpansionMetadata>();
	}
	public class PrefabInfo
	{
		public string Name { get; set; } = string.Empty;

		public string PrefabName { get; set; } = string.Empty;

		public string SpriteName { get; set; } = string.Empty;

		public float Price { get; set; }

		public int LevelRequirement { get; set; }

		public bool LevelRequirementSuppliedByApi { get; set; }

		public bool AddItemToFurnitureShop { get; set; }

		public string Description { get; set; } = string.Empty;

		public string ObjectType { get; set; }

		public List<VideoClipInfo> VideoClips { get; set; } = new List<VideoClipInfo>();

		public float DecoBonus { get; set; }

		public bool IsDecoWallTexture { get; set; }

		public bool IsDecoFloorTexture { get; set; }

		public bool IsDecoCeilingTexture { get; set; }

		public bool IsDecoObject { get; set; }

		public string DecoObject { get; set; } = string.Empty;

		public string DecoType { get; set; } = string.Empty;

		public string Texture { get; set; } = string.Empty;

		public string RoughnessMap { get; set; } = string.Empty;

		public string NormalMap { get; set; } = string.Empty;

		public float Smoothness { get; set; }

		public ColorData Color { get; set; }

		public bool IsValid { get; set; } = true;
	}
	public class RarityWeightInfo
	{
		public string Rarity { get; set; } = string.Empty;

		[Obsolete("Use SlotWeights instead. This field exists for backwards compatibility with older descriptors.")]
		public string GuaranteedSlots { get; set; } = string.Empty;

		public float NormalWeight { get; set; }

		public float GodPackWeight { get; set; }
	}
	public struct Vector3Data
	{
		public float X { get; set; }

		public float Y { get; set; }

		public float Z { get; set; }
	}
	public class VideoClipInfo
	{
		public string Name { get; set; } = string.Empty;

		public string VideoPlayerName { get; set; } = string.Empty;
	}
}
namespace EnhancedPrefabLoader.Shared.Helpers
{
	public static class FileHelper
	{
		public const string BundleDirectoryPattern = "*_prefabloader";

		public static List<string> GetAllBundleDescriptorsIn(string basePath)
		{
			return Directory.EnumerateDirectories(basePath, "*_prefabloader", new EnumerationOptions
			{
				RecurseSubdirectories = true,
				MatchCasing = MatchCasing.CaseInsensitive
			}).SelectMany((string d) => Directory.GetFiles(d, "*.json", SearchOption.AllDirectories)).ToList();
		}
	}
	public static class ModIdGenerator
	{
		public static string GenerateFromDirectory(string directory)
		{
			string directoryName = Path.GetDirectoryName(directory);
			DirectoryInfo directoryInfo = new DirectoryInfo(string.IsNullOrEmpty(directoryName) ? directory : directoryName);
			string fullName = directoryInfo.FullName;
			string name = directoryInfo.Name;
			using SHA1 sHA = SHA1.Create();
			string text = BitConverter.ToString(sHA.ComputeHash(Encoding.UTF8.GetBytes(fullName.ToLowerInvariant()))).Replace("-", "").Substring(0, 8);
			return name + "_" + text;
		}
	}
}
namespace EnhancedPrefabLoader.Shared.Extensions
{
	public static class DictionaryExtensions
	{
		public static TValue GetOrDefault<TKey, TValue>(this Dictionary<TKey, TValue> dict, TKey key)
		{
			if (!dict.TryGetValue(key, out TValue value))
			{
				return default(TValue);
			}
			return value;
		}

		public static TValue GetOrAdd<TKey, TValue>(this Dictionary<TKey, TValue> dict, TKey key, Func<TKey, TValue> factory)
		{
			if (!dict.TryGetValue(key, out TValue value))
			{
				value = (dict[key] = factory(key));
			}
			return value;
		}

		public static void MergeAdd<TKey>(this Dictionary<TKey, int> dict, IEnumerable<(TKey key, int amount)> items)
		{
			foreach (var item3 in items)
			{
				TKey item = item3.key;
				int item2 = item3.amount;
				dict[item] = dict.GetOrAdd(item, (TKey _) => 0) + item2;
			}
		}

		public static void AddRange<TKey, TValue>(this Dictionary<TKey, TValue> dict, IEnumerable<KeyValuePair<TKey, TValue>> items)
		{
			foreach (KeyValuePair<TKey, TValue> item in items)
			{
				dict[item.Key] = item.Value;
			}
		}
	}
	public static class ListExtensions
	{
		public static List<T> Shuffle<T>(this List<T> list) where T : class
		{
			for (int num = list.Count - 1; num > 0; num--)
			{
				int num2 = Random.Range(0, num + 1);
				int index = num;
				int index2 = num2;
				T value = list[num2];
				T value2 = list[num];
				list[index] = value;
				list[index2] = value2;
			}
			return list;
		}

		public static List<T> SwapAndRemove<T>(this List<T> list, int index)
		{
			int num = list.Count - 1;
			if (index != num)
			{
				int index2 = num;
				T value = list[num];
				T value2 = list[index];
				list[index] = value;
				list[index2] = value2;
			}
			list.RemoveAt(num);
			return list;
		}
	}
}
namespace EnhancedPrefabLoader.Shared.Enums
{
	[Flags]
	public enum ItemFlags : byte
	{
		None = 0,
		BoardGame = 1,
		Accessory = 2,
		Figurine = 4,
		TCG = 8
	}
}
namespace EnhancedPrefabLoader.Core
{
	internal class BundleManager
	{
		internal class BundleHandle
		{
			private AssetBundle? assetBundle;

			private AssetBundleCreateRequest? loadRequest;

			private bool isLoading;

			public bool HasError { get; private set; }

			public bool IsLoaded { get; private set; }

			public static BundleHandle Create(string bundlePath)
			{
				string bundleName = Path.GetFileNameWithoutExtension(bundlePath);
				AssetBundle val = AssetBundle.GetAllLoadedAssetBundles().FirstOrDefault((Func<AssetBundle, bool>)((AssetBundle b) => ((Object)b).name == bundleName));
				if (val != null)
				{
					ModLogger.Debug("Bundle '" + bundleName + "' already loaded externally, reusing.", "Create", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\BundleManager.cs");
					return new BundleHandle
					{
						assetBundle = val,
						IsLoaded = true
					};
				}
				return new BundleHandle
				{
					loadRequest = AssetBundle.LoadFromFileAsync(bundlePath)
				};
			}

			internal IEnumerator WaitForLoadAsync()
			{
				if (IsLoaded)
				{
					yield break;
				}
				if (!isLoading)
				{
					isLoading = true;
					if (loadRequest != null)
					{
						yield return loadRequest;
						assetBundle = loadRequest.assetBundle;
						loadRequest = null;
						IsLoaded = assetBundle != null;
						HasError = assetBundle == null;
					}
					isLoading = false;
				}
				while (isLoading)
				{
					ModLogger.Debug("Waiting for another coroutine to finish loading bundle.", "WaitForLoadAsync", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\BundleManager.cs");
					yield return null;
				}
			}

			internal AssetBundleRequest? LoadAssetAsync<T>(string assetName) where T : Object
			{
				if (!string.IsNullOrEmpty(assetName))
				{
					AssetBundle? obj = assetBundle;
					if (obj == null)
					{
						return null;
					}
					return obj.LoadAssetAsync<T>(assetName);
				}
				return null;
			}

			internal AssetBundleRequest? LoadAssetAsync(string assetName, Type type)
			{
				if (!string.IsNullOrEmpty(assetName))
				{
					AssetBundle? obj = assetBundle;
					if (obj == null)
					{
						return null;
					}
					return obj.LoadAssetAsync(assetName, type);
				}
				return null;
			}

			internal AssetBundleRequest? LoadAllAsync<T>() where T : Object
			{
				AssetBundle? obj = assetBundle;
				if (obj == null)
				{
					return null;
				}
				return obj.LoadAllAssetsAsync<T>();
			}
		}

		private readonly Dictionary<string, BundleHandle> bundleHandles = new Dictionary<string, BundleHandle>();

		internal BundleHandle GetOrOpen(string bundlePath)
		{
			if (bundleHandles.TryGetValue(bundlePath, out BundleHandle value))
			{
				if (!value.HasError)
				{
					return value;
				}
				bundleHandles.Remove(bundlePath);
			}
			value = BundleHandle.Create(bundlePath);
			bundleHandles[bundlePath] = value;
			return value;
		}
	}
	internal class EplApi : IEplApi
	{
		public bool IsBundleLoadingComplete => EplRuntimeData.IsBundleLoadingComplete;

		public IBundleRegistry BundleRegistry => (IBundleRegistry)(object)EplRuntimeData.Assets.BundleRegistry;

		public IEplAssets Assets => (IEplAssets)(object)EplRuntimeData.Assets;

		public IEplServices Services => (IEplServices)(object)EplRuntimeData.Services;

		public IEplEvents Events => (IEplEvents)(object)EplRuntimeData.Events;
	}
	internal class EplCaches
	{
		internal Dictionary<string, Material> CardBackMaterials { get; } = new Dictionary<string, Material>();

		internal Material? OriginalCardBackMaterial { get; set; }

		internal List<(Material Material, Color OriginalColor)> LightingAwareMaterials { get; } = new List<(Material, Color)>();
	}
	internal class EplConfig
	{
		internal bool ExcludeBaseGameCardsFromTrade { get; private set; }

		internal bool SparkleFoilEnabled { get; private set; }

		internal bool UseCustomExpForBase { get; private set; }

		internal bool DisableBaseGamePlayCards { get; private set; }

		internal int PreferEplTableItemsChance { get; private set; }

		internal bool FlipTableCards { get; private set; }

		internal int FacedownCardChance { get; private set; }

		internal int TappedCardChance { get; private set; }

		internal float TappedCardAngle { get; private set; }

		internal bool OptimizeShelfVisibilityUpdates { get; private set; }

		internal bool OptimizeMonsterDataLookups { get; private set; }

		internal bool OptimizeCardSaveIndexLookups { get; private set; }

		internal bool ReduceStreamedTextureMemory { get; private set; }

		internal bool OptimizeRestockDataLookups { get; private set; }

		internal bool OptimizeClockUpdates { get; private set; }

		internal bool OptimizeCardBorderTypeLookups { get; private set; }

		internal ConfigEntry<LogLevel> MinimumLogLevelEntry { get; private set; }

		internal ConfigEntry<float> CollectionBinderSpacingXEntry { get; private set; }

		internal ConfigEntry<float> CollectionBinderSpacingYEntry { get; private set; }

		internal ConfigEntry<Vector2> CollectionBinderButtonSizeEntry { get; private set; }

		internal ConfigEntry<float> CardExpansionSelectSpacingXEntry { get; private set; }

		internal ConfigEntry<float> CardExpansionSelectSpacingYEntry { get; private set; }

		internal ConfigEntry<Vector2> CardExpansionSelectButtonSizeEntry { get; private set; }

		internal ConfigEntry<float> RaritySelectSpacingXEntry { get; private set; }

		internal ConfigEntry<float> RaritySelectSpacingYEntry { get; private set; }

		internal ConfigEntry<Vector2> RaritySelectButtonSizeEntry { get; private set; }

		internal void Initialize(ConfigFile config)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_044b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Expected O, but got Unknown
			//IL_04e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_04f0: Expected O, but got Unknown
			//IL_053d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0547: Expected O, but got Unknown
			//IL_059e: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a8: Expected O, but got Unknown
			ConfigEntry<bool> excludeBaseGame = config.Bind<bool>("Trading", "ExcludeBaseGameCardsFromTrade", false, "When enabled, base-game expansions (Tetramon, Destiny, Ghost) will not appear in customer card trade/sell selection.");
			ExcludeBaseGameCardsFromTrade = excludeBaseGame.Value;
			excludeBaseGame.SettingChanged += delegate
			{
				ExcludeBaseGameCardsFromTrade = excludeBaseGame.Value;
			};
			ConfigEntry<bool> sparkleFoil = config.Bind<bool>("CardUI", "Sparkle Foil Enabled", true, "When enabled, foil cards display the sparkle glitter effect.");
			SparkleFoilEnabled = sparkleFoil.Value;
			sparkleFoil.SettingChanged += delegate
			{
				SparkleFoilEnabled = sparkleFoil.Value;
			};
			CollectionBinderSpacingXEntry = config.Bind<float>("CollectionBinderUI", "ExpansionSpacingX", 30f, (ConfigDescription)null);
			CollectionBinderSpacingYEntry = config.Bind<float>("CollectionBinderUI", "ExpansionSpacingY", -45f, (ConfigDescription)null);
			CollectionBinderButtonSizeEntry = config.Bind<Vector2>("CollectionBinderUI", "ExpansionButtonSize", new Vector2(325f, 184.5f), (ConfigDescription)null);
			CardExpansionSelectSpacingXEntry = config.Bind<float>("UI", "ExpansionSpacingX", 30f, (ConfigDescription)null);
			CardExpansionSelectSpacingYEntry = config.Bind<float>("UI", "ExpansionSpacingY", -45f, (ConfigDescription)null);
			CardExpansionSelectButtonSizeEntry = config.Bind<Vector2>("UI", "ExpansionButtonSize", new Vector2(325f, 184.5f), (ConfigDescription)null);
			RaritySelectSpacingXEntry = config.Bind<float>("UI", "RaritySpacingX", 30f, (ConfigDescription)null);
			RaritySelectSpacingYEntry = config.Bind<float>("UI", "RaritySpacingY", -45f, (ConfigDescription)null);
			RaritySelectButtonSizeEntry = config.Bind<Vector2>("UI", "RarityButtonSize", new Vector2(325f, 184.5f), (ConfigDescription)null);
			ConfigEntry<bool> useCustomExp = config.Bind<bool>("GamePlay", "UseCustomExpForBase", false, "When enabled, base-game card expansions will use the EPL experience formula instead of the vanilla formula.");
			UseCustomExpForBase = useCustomExp.Value;
			useCustomExp.SettingChanged += delegate
			{
				UseCustomExpForBase = useCustomExp.Value;
			};
			MinimumLogLevelEntry = config.Bind<LogLevel>("Logging", "Minimum log level to log", LogLevel.Warning, (ConfigDescription)null);
			ConfigEntry<bool> optimizeShelfVisibility = config.Bind<bool>("Performance", "OptimizeShelfVisibilityUpdates", false, "When enabled, replaces the base game's per-frame shelf item visibility pass with change detection — item meshes are only toggled when a shelf crosses the distance/angle threshold, plus a periodic 0.5s refresh. Greatly reduces per-frame overhead in large stocked shops. Disable if another mod patches ShelfManager.Update.");
			OptimizeShelfVisibilityUpdates = optimizeShelfVisibility.Value;
			optimizeShelfVisibility.SettingChanged += delegate
			{
				OptimizeShelfVisibilityUpdates = optimizeShelfVisibility.Value;
			};
			ConfigEntry<bool> optimizeMonsterData = config.Bind<bool>("Performance", "OptimizeMonsterDataLookups", false, "When enabled, base-game monster data lookups use a cached dictionary instead of scanning the data lists on every call (card prices, pack opening, card rendering). Lookups that miss the cache fall back to the vanilla scan. Disable if another mod patches InventoryBase.GetMonsterData.");
			OptimizeMonsterDataLookups = optimizeMonsterData.Value;
			optimizeMonsterData.SettingChanged += delegate
			{
				OptimizeMonsterDataLookups = optimizeMonsterData.Value;
			};
			ConfigEntry<bool> optimizeCardSaveIndex = config.Bind<bool>("Performance", "OptimizeCardSaveIndexLookups", false, "When enabled, base-game card save index lookups use a cached index dictionary instead of rescanning the shown monster list on every call (the hottest card path: add/remove card, prices, binder, bulk donation). EPL expansions are unaffected — they already use their own cached path. Disable if another mod patches CPlayerData.GetCardSaveIndex.");
			OptimizeCardSaveIndexLookups = optimizeCardSaveIndex.Value;
			optimizeCardSaveIndex.SettingChanged += delegate
			{
				OptimizeCardSaveIndexLookups = optimizeCardSaveIndex.Value;
			};
			ConfigEntry<bool> reduceStreamedTextures = config.Bind<bool>("Performance", "ReduceStreamedTextureMemory", false, "When enabled, the base game's web-streamed textures (downloaded card art) release their CPU-side pixel copies after loading, halving their memory for the session. Disable if another mod reads pixels from these cached textures.");
			ReduceStreamedTextureMemory = reduceStreamedTextures.Value;
			reduceStreamedTextures.SettingChanged += delegate
			{
				ReduceStreamedTextureMemory = reduceStreamedTextures.Value;
			};
			ConfigEntry<bool> optimizeRestockData = config.Bind<bool>("Performance", "OptimizeRestockDataLookups", false, "When enabled, restock data lookups (check price screens, barcode scanner, customer purchasing, trades) use a cached index dictionary over the combined base+EPL entry list instead of rescanning it per call. Disable if another mod patches InventoryBase.GetRestockData* methods.");
			OptimizeRestockDataLookups = optimizeRestockData.Value;
			optimizeRestockData.SettingChanged += delegate
			{
				OptimizeRestockDataLookups = optimizeRestockData.Value;
			};
			ConfigEntry<bool> optimizeClock = config.Bind<bool>("Performance", "OptimizeClockUpdates", false, "When enabled, the in-game clock string is only rebuilt when the displayed time actually changes instead of every frame, removing constant string allocation garbage. Disable if another mod patches LightManager.EvaluateTimeClock.");
			OptimizeClockUpdates = optimizeClock.Value;
			optimizeClock.SettingChanged += delegate
			{
				OptimizeClockUpdates = optimizeClock.Value;
			};
			ConfigEntry<bool> optimizeCardBorders = config.Bind<bool>("Performance", "OptimizeCardBorderTypeLookups", false, "When enabled, base-game card border type lookups use fixed tables instead of building a new list on every call (several call sites run per card in loops). EPL expansions are unaffected. Disable if another mod patches CPlayerData.GetCardBorderType.");
			OptimizeCardBorderTypeLookups = optimizeCardBorders.Value;
			optimizeCardBorders.SettingChanged += delegate
			{
				OptimizeCardBorderTypeLookups = optimizeCardBorders.Value;
			};
			ConfigEntry<bool> disableBaseCards = config.Bind<bool>("PlayTable", "DisableBaseGamePlayCards", false, "When enabled, base game card textures will not appear on play tables. If no mod expansion textures are available, this setting is ignored.");
			DisableBaseGamePlayCards = disableBaseCards.Value;
			disableBaseCards.SettingChanged += delegate
			{
				DisableBaseGamePlayCards = disableBaseCards.Value;
			};
			ConfigEntry<int> preferEplTableItems = config.Bind<int>("PlayTable", "PreferEplTableItemsChance", 50, new ConfigDescription("Chance (%) that a play table's decorations (playmat, deck box, comic book) are picked from EPL-added items when any are unlocked. At 0 every unlocked item has equal odds, so large base-game pools drown out EPL items; at 100 EPL items are always picked when available.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			PreferEplTableItemsChance = preferEplTableItems.Value;
			preferEplTableItems.SettingChanged += delegate
			{
				PreferEplTableItemsChance = preferEplTableItems.Value;
			};
			ConfigEntry<bool> flipTableCards = config.Bind<bool>("PlayTable", "FlipTableCards", true, "When enabled, the cards laid out on play tables become individual face-up cards instead of the vanilla facedown rows, with configurable facedown/tapped rolls per card. Card faces always come from the expansion the table picked.");
			FlipTableCards = flipTableCards.Value;
			flipTableCards.SettingChanged += delegate
			{
				FlipTableCards = flipTableCards.Value;
			};
			ConfigEntry<int> facedownChance = config.Bind<int>("PlayTable", "FacedownCardChance", 10, new ConfigDescription("Chance (%) for each flipped table card to be placed facedown. Only used when FlipTableCards is enabled.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			FacedownCardChance = facedownChance.Value;
			facedownChance.SettingChanged += delegate
			{
				FacedownCardChance = facedownChance.Value;
			};
			ConfigEntry<int> tappedChance = config.Bind<int>("PlayTable", "TappedCardChance", 10, new ConfigDescription("Chance (%) for each flipped table card to be \"tapped\" (rotated sideways). Only used when FlipTableCards is enabled.", (AcceptableValueBase)(object)new AcceptableValueRange<int>(0, 100), Array.Empty<object>()));
			TappedCardChance = tappedChance.Value;
			tappedChance.SettingChanged += delegate
			{
				TappedCardChance = tappedChance.Value;
			};
			ConfigEntry<float> tappedAngle = config.Bind<float>("PlayTable", "TappedCardAngle", 75f, new ConfigDescription("Angle in degrees a \"tapped\" table card is rotated. Only used when FlipTableCards is enabled.", (AcceptableValueBase)(object)new AcceptableValueRange<float>(0f, 90f), Array.Empty<object>()));
			TappedCardAngle = tappedAngle.Value;
			tappedAngle.SettingChanged += delegate
			{
				TappedCardAngle = tappedAngle.Value;
			};
		}
	}
	internal static class EplRuntimeData
	{
		internal static bool IsBundleLoadingComplete { get; set; }

		internal static BundleAssetTracker BundleAssetTracker { get; set; } = new BundleAssetTracker();

		internal static List<Assembly> Assemblies { get; private set; } = new List<Assembly>();

		internal static EplCaches Caches { get; private set; } = new EplCaches();

		internal static EplConfig Config { get; private set; } = new EplConfig();

		internal static EplEvents Events { get; private set; } = new EplEvents();

		internal static EplAssets Assets { get; private set; } = new EplAssets(new BundleRegistry(BundleAssetTracker));

		internal static EplServices Services { get; private set; } = new EplServices(new SaveDataService(BundleAssetTracker));
	}
	public enum LogLevel
	{
		Debug,
		Info,
		Warning,
		Error,
		None
	}
	public static class ModLogger
	{
		private static ManualLogSource logger;

		private static LogLevel logLevel;

		public static void Initialize(ManualLogSource logger)
		{
			ModLogger.logger = logger;
			logLevel = EplRuntimeData.Config.MinimumLogLevelEntry.Value;
			EplRuntimeData.Config.MinimumLogLevelEntry.SettingChanged += delegate
			{
				logLevel = EplRuntimeData.Config.MinimumLogLevelEntry.Value;
			};
		}

		public static void Debug(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "")
		{
			if (logLevel <= LogLevel.Debug)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
				logger.LogDebug((object)("[" + fileNameWithoutExtension + "." + memberName + "]: " + message));
			}
		}

		public static void Info(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "")
		{
			if (logLevel <= LogLevel.Info)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
				logger.LogInfo((object)("[" + fileNameWithoutExtension + "." + memberName + "]: " + message));
			}
		}

		public static void Warning(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "")
		{
			if (logLevel <= LogLevel.Warning)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
				logger.LogWarning((object)("[" + fileNameWithoutExtension + "." + memberName + "]: " + message));
			}
		}

		public static void Error(string message, [CallerMemberName] string memberName = "", [CallerFilePath] string filePath = "")
		{
			if (logLevel <= LogLevel.Error)
			{
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(filePath);
				logger.LogError((object)("[" + fileNameWithoutExtension + "." + memberName + "]: " + message));
			}
		}
	}
	public static class MyPluginInfo
	{
		public const string PLUGIN_GUID = "EnhancedPrefabLoader";

		public const string PLUGIN_NAME = "Enhanced Prefab Loader";

		public const string PLUGIN_VERSION = "6.2.3";
	}
}
namespace EnhancedPrefabLoader.Core.Utils
{
	internal static class CardExpansionTypeResolver
	{
		private static ECardExpansionType[]? sortedModKeys;

		internal static ECardExpansionType Resolve(int index)
		{
			if (index >= 8 && index < 200000)
			{
				ECardExpansionType[] array = GetSortedModKeys();
				int num = index - 8;
				if (num < array.Length)
				{
					return array[num];
				}
				return (ECardExpansionType)0;
			}
			return (ECardExpansionType)index;
		}

		internal static void InvalidateCache()
		{
			sortedModKeys = null;
		}

		private static ECardExpansionType[] GetSortedModKeys()
		{
			return sortedModKeys ?? (sortedModKeys = EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys.OrderBy((ECardExpansionType k) => (int)k).ToArray());
		}
	}
	internal static class DecoObjectResolver
	{
		private static EDecoObject[]? sortedModKeys;

		internal static EDecoObject Resolve(int index)
		{
			if (index >= 184 && index < 200000)
			{
				EDecoObject[] array = GetSortedModKeys();
				int num = index - 184;
				if (num < array.Length)
				{
					return array[num];
				}
				return (EDecoObject)0;
			}
			return (EDecoObject)index;
		}

		internal static void InvalidateCache()
		{
			sortedModKeys = null;
		}

		private static EDecoObject[] GetSortedModKeys()
		{
			return sortedModKeys ?? (sortedModKeys = EplRuntimeData.Assets.DecoLibrary.DecoObjectData.Keys.OrderBy((EDecoObject k) => (int)k).ToArray());
		}
	}
	internal static class GameBuild
	{
		internal static Type? PriceTagAtlasMapType { get; } = AccessTools.TypeByName("PriceTagAtlasMap");

		internal static Type? StoredBoxRecordType { get; } = AccessTools.TypeByName("StoredBoxRecord");

		internal static bool HasPriceTagAtlas { get; } = (object)PriceTagAtlasMapType != null && (object)AccessTools.Field(typeof(UI_PriceTag), "m_AtlasMap") != null && (object)AccessTools.Field(typeof(UI_PriceTag), "m_InstancedRenderer") != null;

		internal static bool HasLegacyPriceTagIcon { get; } = (object)AccessTools.Field(typeof(UI_PriceTag), "m_Icon") != null;

		internal static bool HasItemMaterialPropertyBlocks { get; } = (object)AccessTools.Property(typeof(Item), "m_MaterialPropertyBlock") != null;

		internal static bool HasItemSharedMaterialSlots { get; } = (object)AccessTools.Method(typeof(Item), "SetSharedMaterialForFirstSlot", (Type[])null, (Type[])null) != null;

		internal static bool HasStoredBoxRecords { get; } = (object)StoredBoxRecordType != null && (object)AccessTools.Method(typeof(RestockManager), "GetWarehouseCompartmentList", (Type[])null, (Type[])null) != null && (object)AccessTools.Method(typeof(ShelfCompartment), "TryPopLastStoredBoxRecord", (Type[])null, (Type[])null) != null;
	}
	internal static class ItemTypeResolver
	{
		private static EItemType[]? sortedModKeys;

		internal static EItemType Resolve(int index)
		{
			if (index >= 130 && index < 200000)
			{
				EItemType[] array = GetSortedModKeys();
				int num = index - 130;
				if (num < array.Length)
				{
					return array[num];
				}
				return (EItemType)0;
			}
			return (EItemType)index;
		}

		internal static void InvalidateCache()
		{
			sortedModKeys = null;
		}

		private static EItemType[] GetSortedModKeys()
		{
			return sortedModKeys ?? (sortedModKeys = EplRuntimeData.Assets.ItemLibrary.ItemData.Keys.OrderBy((EItemType k) => (int)k).ToArray());
		}
	}
}
namespace EnhancedPrefabLoader.Core.Uninstall
{
	internal class CardRemovalStrategy(HashSet<ECardExpansionType> cardExpansions) : IAssetRemovalStrategy
	{
		private Dictionary<CardData, int> removedCards = new Dictionary<CardData, int>();

		public RemovalResult RemoveAssets()
		{
			removedCards = new Dictionary<CardData, int>();
			RemoveFromCardShelves();
			RemoveFromBinder();
			RemoveFromBulkDonationBoxes();
			RemoveFromCardStorageShelves();
			RemoveFromCardPackageBoxes();
			RemoveFromCardGrading();
			RemoveFromDecks();
			RemoveFromAutoPackOpeners();
			RemoveFromHeldCards();
			return RemovalResult.Success(removedCards.Values.Sum(), removedCards.Sum<KeyValuePair<CardData, int>>((KeyValuePair<CardData, int> kvp) => CPlayerData.GetCardMarketPrice(kvp.Key) * (float)kvp.Value));
		}

		private void RemoveFromCardShelves()
		{
			RemoveFromShelfCardCompartments(CSingleton<ShelfManager>.Instance.m_CardShelfList);
			RemoveFromShelfCardCompartments((IEnumerable<CardShelf>)CSingleton<ShelfManager>.Instance.m_CardItemCombiShelfList);
		}

		private void RemoveFromShelfCardCompartments(IEnumerable<CardShelf> cardShelves)
		{
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			foreach (InteractableCardCompartment item in cardShelves.SelectMany((CardShelf cs) => cs.m_CardCompartmentList))
			{
				if (item.m_StoredCardList.Count == 0)
				{
					continue;
				}
				CardData cardData = item.m_StoredCardList[0].m_Card3dUI.m_CardUI.m_CardData;
				if (!cardExpansions.Contains(cardData.expansionType))
				{
					continue;
				}
				foreach (InteractableCardPriceTag interactablePriceTag in item.m_InteractablePriceTagList)
				{
					interactablePriceTag.SetPriceChecked(false);
				}
				item.m_StoredCardList[0].SetIsDisplayedOnShelf(false);
				item.m_StoredCardList[0].SetTargetRotation(Quaternion.identity);
				item.m_StoredCardList.RemoveAt(0);
				item.SetPriceTagCardData((CardData)null);
				item.SetPriceTagVisibility(false);
				if (item.m_CardShelf?.m_ElectronicCardListener != null)
				{
					item.m_CardShelf.m_ElectronicCardListener.UpdateCardUI((CardData)null);
				}
				removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + 1;
			}
		}

		private void RemoveFromBinder()
		{
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			foreach (CardData item in CPlayerData.m_GradedCardInventoryList.Where((CompactCardDataAmount c) => cardExpansions.Contains(c.expansionType)).Select((Func<CompactCardDataAmount, CardData>)CPlayerData.GetGradedCardData).ToList())
			{
				CPlayerData.RemoveGradedCard(item, false);
				removedCards[item] = removedCards.GetValueOrDefault(item) + 1;
			}
			CardExpansionLibrary cardExpansionLibrary = EplRuntimeData.Assets.CardExpansionLibrary;
			foreach (ECardExpansionType item2 in cardExpansions)
			{
				if (!cardExpansionLibrary.CardExpansionData.TryGetValue(item2, out ModCardExpansionData value))
				{
					continue;
				}
				foreach (KeyValuePair<EMonsterType, ModCardData> card in value.Cards)
				{
					card.Deconstruct(out var _, out var value2);
					CardData val = value2.ToCardData();
					int cardAmount = CPlayerData.GetCardAmount(val);
					if (cardAmount > 0)
					{
						CPlayerData.ReduceCard(val, cardAmount);
						removedCards[val] = removedCards.GetValueOrDefault(val) + cardAmount;
					}
				}
			}
		}

		private void RemoveFromBulkDonationBoxes()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			foreach (List<CompactCardDataAmount> item in CSingleton<ShelfManager>.Instance.m_BulkDonationBoxList.Select((InteractableBulkDonationBox b) => b.m_CompactCardDataAmountList))
			{
				foreach (CompactCardDataAmount item2 in item.Where((CompactCardDataAmount c) => cardExpansions.Contains(c.expansionType)))
				{
					CardData cardData = CPlayerData.GetCardData(item2.cardSaveIndex, item2.expansionType, item2.isDestiny);
					removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + item2.amount;
				}
				item.RemoveAll((CompactCardDataAmount c) => cardExpansions.Contains(c.expansionType));
			}
		}

		private void RemoveFromCardStorageShelves()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			foreach (List<CompactCardDataAmount> item in CSingleton<ShelfManager>.Instance.m_CardStorageShelfList.Select((InteractableCardStorageShelf b) => b.m_CompactCardDataAmountList))
			{
				foreach (CompactCardDataAmount item2 in item.Where((CompactCardDataAmount c) => cardExpansions.Contains(c.expansionType)))
				{
					CardData cardData = CPlayerData.GetCardData(item2.cardSaveIndex, item2.expansionType, item2.isDestiny);
					removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + item2.amount;
				}
				item.RemoveAll((CompactCardDataAmount c) => cardExpansions.Contains(c.expansionType));
			}
		}

		private void RemoveFromCardPackageBoxes()
		{
			foreach (InteractablePackagingBox_Card packageBox in RestockManager.GetCardPackagingBoxList().ToList())
			{
				packageBox.m_StoredCardList.RemoveAll(delegate(InteractableCard3d i)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					CardData cardData = i.m_Card3dUI.m_CardUI.m_CardData;
					if (cardExpansions.Contains(cardData.expansionType))
					{
						removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + 1;
						packageBox.m_StoredCardDataList.Remove(cardData);
						((InteractableObject)i).OnDestroyed();
						return true;
					}
					return false;
				});
				if (packageBox.m_StoredCardList.Count == 0)
				{
					CSingleton<ShelfManager>.Instance.m_SpawnedPackageBoxCardList.Remove(packageBox);
					((InteractableObject)packageBox).OnDestroyed();
				}
			}
		}

		private void RemoveFromCardGrading()
		{
			//IL_008e: 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_00ab: Expected O, but got Unknown
			foreach (GradeCardSubmitSet item in CPlayerData.m_GradeCardInProgressList.ToList())
			{
				item.m_CardDataList.RemoveAll(delegate(CardData cardData)
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					if (!cardExpansions.Contains(cardData.expansionType))
					{
						return false;
					}
					removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + 1;
					return true;
				});
				if (item.m_CardDataList.Count == 0)
				{
					CPlayerData.m_GradeCardInProgressList.Remove(item);
				}
			}
			GradeCardSubmitSet currentGradeCardSubmitSet = CPlayerData.m_CurrentGradeCardSubmitSet;
			if (currentGradeCardSubmitSet?.m_CardDataList == null)
			{
				return;
			}
			for (int num = 0; num < currentGradeCardSubmitSet.m_CardDataList.Count; num++)
			{
				if (cardExpansions.Contains(currentGradeCardSubmitSet.m_CardDataList[num].expansionType))
				{
					currentGradeCardSubmitSet.m_CardDataList[num] = new CardData();
				}
			}
		}

		private void RemoveFromDecks()
		{
			foreach (DeckCompactCardDataList deckCompactCardData in CPlayerData.m_DeckCompactCardDataList)
			{
				deckCompactCardData.compactCardDataAmountList.RemoveAll((CompactCardDataAmount c) => cardExpansions.Contains(c.expansionType));
			}
		}

		private void RemoveFromAutoPackOpeners()
		{
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			foreach (List<CompactCardDataAmount> item in CSingleton<ShelfManager>.Instance.m_AutoPackOpenerList.Select((InteractableAutoPackOpener p) => p.m_CompactCardDataAmountList))
			{
				foreach (CompactCardDataAmount item2 in item.Where((CompactCardDataAmount c) => cardExpansions.Contains(c.expansionType)))
				{
					CardData cardData = CPlayerData.GetCardData(item2.cardSaveIndex, item2.expansionType, item2.isDestiny);
					removedCards[cardData] = removedCards.GetValueOrDefault(cardData) + item2.amount;
				}
				item.RemoveAll((CompactCardDataAmount c) => cardExpansions.Contains(c.expansionType));
			}
		}

		private void RemoveFromHeldCards()
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			InteractionPlayerController instance = CSingleton<InteractionPlayerController>.Instance;
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			List<InteractableCard3d> currentHoldingCard3dList = instance.m_CurrentHoldingCard3dList;
			bool flag = false;
			for (int num = Math.Min(currentHoldingCard3dList.Count, CPlayerData.m_HoldCardDataList.Count) - 1; num >= 0; num--)
			{
				CardData val = CPlayerData.m_HoldCardDataList[num];
				if (cardExpansions.Contains(val.expansionType))
				{
					removedCards[val] = removedCards.GetValueOrDefault(val) + 1;
					((InteractableObject)currentHoldingCard3dList[num]).OnDestroyed();
					currentHoldingCard3dList.RemoveAt(num);
					CPlayerData.m_HoldCardDataList.RemoveAt(num);
					flag = true;
				}
			}
			if (!flag)
			{
				return;
			}
			if (currentHoldingCard3dList.Count == 0)
			{
				instance.ExitHoldCardMode();
				return;
			}
			for (int i = 0; i < currentHoldingCard3dList.Count; i++)
			{
				((InteractableObject)currentHoldingCard3dList[i]).LerpToTransform(instance.m_HoldCardPosList[i], instance.m_HoldCardPosList[i], 3f);
			}
		}
	}
	internal class CustomerRemovalStrategy(HashSet<ECardExpansionType> cardExpansions, HashSet<EItemType> items) : IAssetRemovalStrategy
	{
		public RemovalResult RemoveAssets()
		{
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			float num2 = 0f;
			foreach (Customer customer in CSingleton<CustomerManager>.Instance.m_CustomerList)
			{
				if (!customer.IsActive() || !IsCarryingBundleContent(customer))
				{
					continue;
				}
				foreach (Item item in from i in customer.m_ItemInBagList.Concat(customer.m_ItemInHandList)
					where items.Contains(i.m_ItemType)
					select i)
				{
					num++;
					num2 += RestockManager.GetItemMarketPrice(item.m_ItemType);
				}
				foreach (CardData item2 in from c in customer.m_CardInBagList
					select c.m_Card3dUI.m_CardUI.m_CardData into c
					where cardExpansions.Contains(c.expansionType)
					select c)
				{
					num++;
					num2 += CPlayerData.GetCardMarketPrice(item2);
				}
				customer.DeactivateCustomer();
			}
			return RemovalResult.Success(num, num2);
		}

		private bool IsCarryingBundleContent(Customer customer)
		{
			if (!customer.m_ItemInBagList.Concat(customer.m_ItemInHandList).Any((Item i) => items.Contains(i.m_ItemType)) && !customer.m_CardInBagList.Any((InteractableCard3d c) => cardExpansions.Contains(c.m_Card3dUI.m_CardUI.m_CardData.expansionType)))
			{
				return HasBundleTournamentPrize(customer);
			}
			return true;
		}

		private bool HasBundleTournamentPrize(Customer customer)
		{
			CustomerTournamentData customerTournamentData = customer.GetCustomerTournamentData();
			if (customerTournamentData == null)
			{
				return false;
			}
			if (customerTournamentData.m_TargetPrizeData == null || !customerTournamentData.m_TargetPrizeData.IsBundleContent(cardExpansions, items))
			{
				return customerTournamentData.m_PrizeDataList.Any((TournamentPrizeData p) => p.IsBundleContent(cardExpansions, items));
			}
			return true;
		}
	}
	internal class DecoRemovalStrategy(HashSet<EDecoObject> decoTypes, string bundleId) : IAssetRemovalStrategy
	{
		public RemovalResult RemoveAssets()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			float totalValue = 0f;
			int totalDecoCount = 0;
			foreach (EDecoObject item in decoTypes)
			{
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EDecoObject, DecoSaveData>(item, out DecoSaveData data))
				{
					totalDecoCount += data.ItemCount;
					totalValue += InventoryBase.GetItemDecoPurchaseData(item).price * (float)data.ItemCount;
					data.Reset();
				}
			}
			ResetTextureSaveData((DecoFlags)3, EplRuntimeData.Assets.DecoLibrary.firstInsertedCeilingTexture, CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_CeilingDecoDataList, ref totalDecoCount, ref totalValue);
			ResetTextureSaveData((DecoFlags)1, EplRuntimeData.Assets.DecoLibrary.firstInsertedFloorTexture, CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FloorDecoDataList, ref totalDecoCount, ref totalValue);
			ResetTextureSaveData((DecoFlags)2, EplRuntimeData.Assets.DecoLibrary.firstInsertedWallTexture, CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_WallDecoDataList, ref totalDecoCount, ref totalValue);
			return RemovalResult.Success(totalDecoCount, totalValue);
		}

		private unsafe void ResetTextureSaveData(DecoFlags category, int? firstInsertedIndex, List<ShopDecoData> decoDataList, ref int totalDecoCount, ref float totalValue)
		{
			if (!firstInsertedIndex.HasValue)
			{
				return;
			}
			string category2 = ((object)(*(DecoFlags*)(&category))/*cast due to .constrained prefix*/).ToString();
			BundleAssetTracker bundleAssetTracker = EplRuntimeData.BundleAssetTracker;
			SaveDataService saveDataManager = EplRuntimeData.Services.SaveDataManager;
			for (int i = firstInsertedIndex.Value; i < decoDataList.Count; i++)
			{
				string name = decoDataList[i].name;
				if (!(bundleAssetTracker.GetBundleIdFor(category2, name) != bundleId) && saveDataManager.TryGetSaveData<DecoSaveData>(category2, name, out DecoSaveData data))
				{
					totalDecoCount += data.ItemCount;
					totalValue += decoDataList[i].price * (float)data.ItemCount;
					data.Reset();
				}
			}
		}
	}
	internal interface IAssetRemovalStrategy
	{
		RemovalResult RemoveAssets();
	}
	internal class InteractableObjectRemovalStrategy(HashSet<EObjectType> furnitures, HashSet<EDecoObject> decos) : IAssetRemovalStrategy
	{
		private readonly Dictionary<EItemType, int> itemsToRestock = new Dictionary<EItemType, int>();

		public RemovalResult RemoveAssets()
		{
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_026d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027c: Unknown result type (might be due to invalid IL or missing references)
			itemsToRestock.Clear();
			int num = 0;
			float num2 = 0f;
			List<InteractableObject> list = (from Transform t in (IEnumerable)CSingleton<ShelfManager>.Instance.m_ShelfParentGrp
				select ((Component)t).GetComponent<InteractableObject>() into i
				where i != null && (furnitures.Contains(i.m_ObjectType) || decos.Contains(i.m_DecoObjectType))
				select i).ToList();
			FurnitureLibrary furnitureLibrary = EplRuntimeData.Assets.FurnitureLibrary;
			foreach (InteractableObject item in list)
			{
				InteractableDecoration val = (InteractableDecoration)(object)((item is InteractableDecoration) ? item : null);
				if (val == null)
				{
					InteractableBulkDonationBox val2 = (InteractableBulkDonationBox)(object)((item is InteractableBulkDonationBox) ? item : null);
					if (val2 == null)
					{
						InteractableCardStorageShelf val3 = (InteractableCardStorageShelf)(object)((item is InteractableCardStorageShelf) ? item : null);
						if (val3 == null)
						{
							CardItemCombiShelf val4 = (CardItemCombiShelf)(object)((item is CardItemCombiShelf) ? item : null);
							if (val4 == null)
							{
								CardShelf val5 = (CardShelf)(object)((item is CardShelf) ? item : null);
								if (val5 == null)
								{
									InteractableWorkbench val6 = (InteractableWorkbench)(object)((item is InteractableWorkbench) ? item : null);
									if (val6 == null)
									{
										Shelf val7 = (Shelf)(object)((item is Shelf) ? item : null);
										if (val7 == null)
										{
											WarehouseShelf val8 = (WarehouseShelf)(object)((item is WarehouseShelf) ? item : null);
											ModFurniturePurchaseData value;
											if (val8 != null)
											{
												EmptyWarehouseShelf(val8);
												num2 += furnitureLibrary.FurnitureData[((InteractableObject)val8).m_ObjectType].BaseFurniturePurchaseData.price;
											}
											else if (furnitureLibrary.FurnitureData.TryGetValue(item.m_ObjectType, out value))
											{
												num2 += value.BaseFurniturePurchaseData.price;
											}
											else if (decos.Contains(item.m_DecoObjectType))
											{
												num2 += InventoryBase.GetItemDecoPurchaseData(item.m_DecoObjectType).price;
											}
										}
										else
										{
											EmptyShelf(val7);
											num2 += furnitureLibrary.FurnitureData[((InteractableObject)val7).m_ObjectType].BaseFurniturePurchaseData.price;
										}
									}
									else
									{
										EmptyWorkbench(val6);
										num2 += furnitureLibrary.FurnitureData[((InteractableObject)val6).m_ObjectType].BaseFurniturePurchaseData.price;
									}
								}
								else
								{
									EmptyCardShelf(val5);
									num2 += furnitureLibrary.FurnitureData[((InteractableObject)val5).m_ObjectType].BaseFurniturePurchaseData.price;
								}
							}
							else
							{
								EmptyCombiShelf(val4);
								num2 += furnitureLibrary.FurnitureData[((InteractableObject)val4).m_ObjectType].BaseFurniturePurchaseData.price;
							}
						}
						else
						{
							EmptyCardStorageShelf(val3);
							num2 += furnitureLibrary.FurnitureData[((InteractableObject)val3).m_ObjectType].BaseFurniturePurchaseData.price;
						}
					}
					else
					{
						EmptyBulkDonationBox(val2);
						num2 += furnitureLibrary.FurnitureData[((InteractableObject)val2).m_ObjectType].BaseFurniturePurchaseData.price;
					}
				}
				else
				{
					num2 += InventoryBase.GetItemDecoPurchaseData(((InteractableObject)val).m_DecoObjectType).price;
				}
				if (item.m_IsBoxedUp)
				{
					((InteractableObject)item.m_InteractablePackagingBox_Shelf).OnDestroyed();
				}
				else
				{
					item.OnDestroyed();
				}
				num++;
			}
			RestockItems();
			return RemovalResult.Success(num, num2);
		}

		private void EmptyWarehouseShelf(WarehouseShelf warehouseShelf)
		{
			//IL_0064: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			foreach (ShelfCompartment item in from p in warehouseShelf.m_StorageCompartmentList.SelectMany((InteractableStorageCompartment s) => s.m_ShelfCompartment.m_InteractablePackagingBoxList)
				select p.m_ItemCompartment)
			{
				itemsToRestock[item.m_ItemType] = itemsToRestock.GetValueOrDefault(item.m_ItemType) + item.m_StoredItemList.Count;
			}
			if (!StoredBoxRecordAccess.IsAvailable)
			{
				return;
			}
			foreach (ShelfCompartment item2 in warehouseShelf.m_StorageCompartmentList.Select((InteractableStorageCompartment s) => s.m_ShelfCompartment))
			{
				int num = StoredBoxRecordAccess.RecordCount(item2);
				for (int num2 = 0; num2 < num; num2++)
				{
					object record = StoredBoxRecordAccess.Peek(item2, num2);
					EItemType key = StoredBoxRecordAccess.ItemTypeOf(record);
					itemsToRestock[key] = itemsToRestock.GetValueOrDefault(key) + StoredBoxRecordAccess.AmountOf(record);
				}
			}
		}

		private void EmptyCombiShelf(CardItemCombiShelf combiShelf)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			EmptyCardShelf((CardShelf)(object)combiShelf);
			foreach (ShelfCompartment shelfItemCompartment in combiShelf.GetShelfItemCompartmentList())
			{
				itemsToRestock[shelfItemCompartment.m_ItemType] = itemsToRestock.GetValueOrDefault(shelfItemCompartment.m_ItemType) + shelfItemCompartment.m_StoredItemList.Count;
			}
		}

		private void EmptyShelf(Shelf shelf)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			foreach (ShelfCompartment itemCompartment in ((InteractableObject)shelf).m_ItemCompartmentList)
			{
				itemsToRestock[itemCompartment.m_ItemType] = itemsToRestock.GetValueOrDefault(itemCompartment.m_ItemType) + itemCompartment.m_StoredItemList.Count;
			}
		}

		private void EmptyWorkbench(InteractableWorkbench interactableWorkbench)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			foreach (Item storedItem in interactableWorkbench.m_StoredItemList)
			{
				itemsToRestock[storedItem.m_ItemType] = itemsToRestock.GetValueOrDefault(storedItem.m_ItemType) + 1;
			}
		}

		private static void EmptyCardShelf(CardShelf cardShelf)
		{
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			foreach (InteractableCardCompartment item in cardShelf.m_CardCompartmentList.Where((InteractableCardCompartment c) => c.m_StoredCardList.Count > 0))
			{
				foreach (InteractableCardPriceTag interactablePriceTag in item.m_InteractablePriceTagList)
				{
					interactablePriceTag.SetPriceChecked(false);
				}
				CardData cardData = item.m_StoredCardList[0].m_Card3dUI.m_CardUI.m_CardData;
				item.m_StoredCardList[0].SetIsDisplayedOnShelf(false);
				item.m_StoredCardList[0].SetTargetRotation(Quaternion.identity);
				item.m_StoredCardList.RemoveAt(0);
				item.SetPriceTagCardData((CardData)null);
				item.SetPriceTagVisibility(false);
				if (item.m_CardShelf?.m_ElectronicCardListener != null)
				{
					item.m_CardShelf.m_ElectronicCardListener.UpdateCardUI((CardData)null);
				}
				CPlayerData.AddCard(cardData, 1);
			}
		}

		private static void EmptyCardStorageShelf(InteractableCardStorageShelf interactableCardStorageShelf)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			foreach (CompactCardDataAmount compactCardDataAmount in interactableCardStorageShelf.m_CompactCardDataAmountList)
			{
				CPlayerData.AddCard(CPlayerData.GetCardData(compactCardDataAmount.cardSaveIndex, compactCardDataAmount.expansionType, compactCardDataAmount.isDestiny), compactCardDataAmount.amount);
			}
			interactableCardStorageShelf.m_CompactCardDataAmountList.Clear();
		}

		private static void EmptyBulkDonationBox(InteractableBulkDonationBox interactableBulkDonationBox)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			foreach (CompactCardDataAmount compactCardDataAmount in interactableBulkDonationBox.m_CompactCardDataAmountList)
			{
				CPlayerData.AddCard(CPlayerData.GetCardData(compactCardDataAmount.cardSaveIndex, compactCardDataAmount.expansionType, compactCardDataAmount.isDestiny), compactCardDataAmount.amount);
			}
			interactableBulkDonationBox.m_CompactCardDataAmountList.Clear();
		}

		private void RestockItems()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			foreach (KeyValuePair<EItemType, int> item in itemsToRestock)
			{
				item.Deconstruct(out var key, out var value);
				EItemType val = key;
				int num2;
				int num = (num2 = value);
				int maxItemCountInBox = RestockManager.GetMaxItemCountInBox(val, true);
				int num3 = Mathf.CeilToInt((float)num / (float)maxItemCountInBox);
				for (int i = 0; i < num3; i++)
				{
					int num4 = ((num2 >= maxItemCountInBox) ? maxItemCountInBox : num2);
					RestockManager.SpawnPackageBoxItem(val, num4, true);
					num2 -= num4;
				}
			}
		}
	}
	internal class ItemRemovalStrategy(HashSet<EItemType> items) : IAssetRemovalStrategy
	{
		private List<Item> removedItems = new List<Item>();

		public RemovalResult RemoveAssets()
		{
			removedItems = new List<Item>();
			RemoveFromShelves();
			RemoveFromPackagingBoxes();
			RemoveFromWorkbenches();
			RemoveFromAutoPackOpeners();
			RemoveFromPlayTables();
			RemoveFromHeldItems();
			float num = RemoveFromRestockQueue();
			(int Count, float Value) tuple = RemoveFromStoredBoxRecords();
			int item = tuple.Count;
			float item2 = tuple.Value;
			float totalValue = removedItems.Select((Item i) => RestockManager.GetItemMarketPrice(i.m_ItemType)).Sum() + num + item2;
			foreach (Item removedItem in removedItems)
			{
				ItemSpawnManager.DisableItem(removedItem);
			}
			return RemovalResult.Success(removedItems.Count + item, totalValue);
		}

		private (int Count, float Value) RemoveFromStoredBoxRecords()
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			if (!StoredBoxRecordAccess.IsAvailable)
			{
				return (Count: 0, Value: 0f);
			}
			int num = 0;
			float num2 = 0f;
			foreach (ShelfCompartment warehouseCompartment in StoredBoxRecordAccess.GetWarehouseCompartments())
			{
				if (!Object.op_Implicit((Object)(object)warehouseCompartment) || !HasMatchingRecord(warehouseCompartment))
				{
					continue;
				}
				List<object> list = new List<object>();
				object record;
				while (StoredBoxRecordAccess.TryPop(warehouseCompartment, out record))
				{
					EItemType val = StoredBoxRecordAccess.ItemTypeOf(record);
					if (!items.Contains(val))
					{
						list.Add(record);
						continue;
					}
					num++;
					num2 += RestockManager.GetItemMarketPrice(val) * (float)StoredBoxRecordAccess.AmountOf(record);
				}
				for (int num3 = list.Count - 1; num3 >= 0; num3--)
				{
					StoredBoxRecordAccess.Add(warehouseCompartment, list[num3]);
				}
				if (warehouseCompartment.m_ItemAmount == 0)
				{
					warehouseCompartment.RemoveLabel(false);
				}
			}
			return (Count: num, Value: num2);
		}

		private bool HasMatchingRecord(ShelfCompartment compartment)
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			int num = StoredBoxRecordAccess.RecordCount(compartment);
			for (int i = 0; i < num; i++)
			{
				if (items.Contains(StoredBoxRecordAccess.ItemTypeOf(StoredBoxRecordAccess.Peek(compartment, i))))
				{
					return true;
				}
			}
			return false;
		}

		private void RemoveFromPackagingBoxes()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			foreach (InteractablePackagingBox_Item item in RestockManager.GetItemPackagingBoxList().ToList())
			{
				if (!items.Contains(item.m_ItemType) && !items.Contains(item.m_ItemCompartment.m_ItemType))
				{
					continue;
				}
				if (item.m_IsStored)
				{
					item.m_BoxStoredCompartment.RemoveBox(item);
					if (item.m_BoxStoredCompartment.m_ItemAmount == 0)
					{
						item.m_BoxStoredCompartment.RemoveLabel(false);
					}
				}
				removedItems.AddRange(item.m_ItemCompartment.m_StoredItemList);
				EmptyItemCompartment(item.m_ItemCompartment);
				((InteractableObject)item).OnDestroyed();
			}
		}

		private void RemoveFromShelves()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			ShelfManager instance = CSingleton<ShelfManager>.Instance;
			foreach (ShelfCompartment item in instance.m_ShelfList.SelectMany((Shelf s) => ((InteractableObject)s).m_ItemCompartmentList).Concat(instance.m_CardItemCombiShelfList.SelectMany((CardItemCombiShelf s) => s.GetShelfItemCompartmentList())))
			{
				if (items.Contains(item.m_ItemType) && item.m_ItemAmount != 0)
				{
					removedItems.AddRange(item.m_StoredItemList);
					EmptyItemCompartment(item);
				}
			}
		}

		private void RemoveFromWorkbenches()
		{
			foreach (InteractableWorkbench workbench in CSingleton<ShelfManager>.Instance.m_WorkbenchList)
			{
				foreach (Item item in workbench.m_StoredItemList.Where((Item i) => items.Contains(i.m_ItemType)).ToList())
				{
					removedItems.Add(item);
					workbench.RemoveItem(item);
				}
			}
		}

		private void RemoveFromAutoPackOpeners()
		{
			foreach (InteractableAutoPackOpener autoPackOpener in CSingleton<ShelfManager>.Instance.m_AutoPackOpenerList)
			{
				List<Item> list = autoPackOpener.m_StoredItemList.Where((Item i) => items.Contains(i.m_ItemType)).ToList();
				if (list.Count == 0)
				{
					continue;
				}
				foreach (Item item in list)
				{
					removedItems.Add(item);
					autoPackOpener.RemoveItem(item);
				}
				if (Object.op_Implicit((Object)(object)autoPackOpener.m_AutoCardOpenerUI))
				{
					autoPackOpener.m_AutoCardOpenerUI.UpdatePackCountText(autoPackOpener.m_StoredItemList.Count, autoPackOpener.m_MaxPackCount);
				}
			}
		}

		private void RemoveFromPlayTables()
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			foreach (InteractablePlayTable playTable in CSingleton<ShelfManager>.Instance.m_PlayTableList)
			{
				for (int i = 0; i < playTable.m_TableGameItemSetDataList.Count; i++)
				{
					TableGameItemSetData val = playTable.m_TableGameItemSetDataList[i];
					if (val != null && (items.Contains(val.playMatType) || items.Contains(val.deckBoxType) || items.Contains(val.comicBookType)))
					{
						playTable.m_TableGameItemSetDataList[i] = null;
					}
				}
			}
		}

		private void RemoveFromHeldItems()
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			InteractionPlayerController instance = CSingleton<InteractionPlayerController>.Instance;
			if (!Object.op_Implicit((Object)(object)instance))
			{
				return;
			}
			List<Item> holdItemList = instance.m_HoldItemList;
			bool flag = false;
			for (int num = holdItemList.Count - 1; num >= 0; num--)
			{
				if (items.Contains(holdItemList[num].m_ItemType))
				{
					removedItems.Add(holdItemList[num]);
					holdItemList.RemoveAt(num);
					flag = true;
				}
			}
			if (!flag)
			{
				return;
			}
			CPlayerData.m_HoldItemTypeList.RemoveAll((EItemType t) => items.Contains(t));
			if (holdItemList.Count == 0)
			{
				instance.SetCurrentGameState((EGameState)0);
				instance.m_IsHoldItemMode = false;
				return;
			}
			for (int num2 = 0; num2 < holdItemList.Count; num2++)
			{
				holdItemList[num2].SmoothLerpToTransform(instance.m_HoldCardPackPosList[num2], instance.m_HoldCardPackPosList[num2], true);
			}
		}

		private float RemoveFromRestockQueue()
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			RestockManager instance = CSingleton<RestockManager>.Instance;
			float num = 0f;
			for (int num2 = CPlayerData.m_SpawnBoxRestockIndexWaitingList.Count - 1; num2 >= 0; num2--)
			{
				RestockData restockData = InventoryBase.GetRestockData(CPlayerData.m_SpawnBoxRestockIndexWaitingList[num2]);
				if (restockData != null && items.Contains(restockData.itemType))
				{
					int maxItemCountInBox = RestockManager.GetMaxItemCountInBox(restockData.itemType, restockData.isBigBox);
					num += RestockManager.GetItemMarketPrice(restockData.itemType) * (float)maxItemCountInBox * (float)CPlayerData.m_SpawnBoxItemCountWaitingList[num2];
					CPlayerData.m_SpawnBoxRestockIndexWaitingList.RemoveAt(num2);
					CPlayerData.m_SpawnBoxItemCountWaitingList.RemoveAt(num2);
					if (num2 < instance.m_SpawnBoxItemWaitingList.Count)
					{
						instance.m_SpawnBoxItemWaitingList.RemoveAt(num2);
					}
				}
			}
			return num;
		}

		private static void EmptyItemCompartment(ShelfCompartment itemCompartment)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			itemCompartment.m_StoredItemList.Clear();
			itemCompartment.m_ItemAmount = 0;
			itemCompartment.m_ItemType = (EItemType)(-1);
			itemCompartment.RemoveLabel(false);
		}
	}
	internal class RemovalResult
	{
		internal bool IsSuccess { get; private set; }

		internal int AssetsRemoved { get; private set; }

		internal float TotalValue { get; private set; }

		internal string ErrorMessage { get; private set; } = string.Empty;

		private RemovalResult()
		{
		}

		internal static RemovalResult Success(int assetsRemoved, float totalValue)
		{
			return new RemovalResult
			{
				IsSuccess = true,
				AssetsRemoved = assetsRemoved,
				TotalValue = totalValue
			};
		}

		internal static RemovalResult Failure(string msg)
		{
			return new RemovalResult
			{
				IsSuccess = false,
				ErrorMessage = msg
			};
		}

		internal static RemovalResult Empty()
		{
			return new RemovalResult
			{
				IsSuccess = true
			};
		}

		internal void Merge(RemovalResult other)
		{
			IsSuccess = IsSuccess && other.IsSuccess;
			AssetsRemoved += other.AssetsRemoved;
			TotalValue += other.TotalValue;
			if (!string.IsNullOrWhiteSpace(other.ErrorMessage))
			{
				ErrorMessage = (string.IsNullOrWhiteSpace(ErrorMessage) ? other.ErrorMessage : (ErrorMessage + "\n" + other.ErrorMessage));
			}
		}
	}
	internal static class StoredBoxRecordAccess
	{
		private static readonly MethodInfo? getWarehouseCompartmentList = AccessTools.Method(typeof(RestockManager), "GetWarehouseCompartmentList", (Type[])null, (Type[])null);

		private static readonly MethodInfo? getRecordCount = AccessTools.Method(typeof(ShelfCompartment), "GetStoredBoxRecordCount", (Type[])null, (Type[])null);

		private static readonly MethodInfo? peekRecord = AccessTools.Method(typeof(ShelfCompartment), "PeekStoredBoxRecord", (Type[])null, (Type[])null);

		private static readonly MethodInfo? tryPopRecord = AccessTools.Method(typeof(ShelfCompartment), "TryPopLastStoredBoxRecord", (Type[])null, (Type[])null);

		private static readonly MethodInfo? addRecord = AccessTools.Method(typeof(ShelfCompartment), "AddStoredBoxRecord", (Type[])null, (Type[])null);

		private static readonly FieldInfo? itemTypeField = AccessTools.Field(GameBuild.StoredBoxRecordType, "itemType");

		private static readonly FieldInfo? amountField = AccessTools.Field(GameBuild.StoredBoxRecordType, "amount");

		internal static bool IsAvailable
		{
			get
			{
				if (GameBuild.HasStoredBoxRecords && (object)getWarehouseCompartmentList != null && (object)getRecordCount != null && (object)peekRecord != null && (object)tryPopRecord != null && (object)addRecord != null && (object)itemTypeField != null)
				{
					return (object)amountField != null;
				}
				return false;
			}
		}

		internal static List<ShelfCompartment> GetWarehouseCompartments()
		{
			return (getWarehouseCompartmentList.Invoke(null, null) as List<ShelfCompartment>) ?? new List<ShelfCompartment>();
		}

		internal static int RecordCount(ShelfCompartment compartment)
		{
			return (int)getRecordCount.Invoke(compartment, null);
		}

		internal static object Peek(ShelfCompartment compartment, int index)
		{
			return peekRecord.Invoke(compartment, new object[1] { index });
		}

		internal static bool TryPop(ShelfCompartment compartment, out object? record)
		{
			object[] array = new object[1];
			bool flag = (bool)tryPopRecord.Invoke(compartment, array);
			record = (flag ? array[0] : null);
			return flag;
		}

		internal static void Add(ShelfCompartment compartment, object record)
		{
			addRecord.Invoke(compartment, new object[1] { record });
		}

		internal static EItemType ItemTypeOf(object record)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return (EItemType)itemTypeField.GetValue(record);
		}

		internal static int AmountOf(object record)
		{
			return (int)amountField.GetValue(record);
		}
	}
	internal static class TournamentPrizeDataExtensions
	{
		internal static bool IsBundleContent(this TournamentPrizeData prize, HashSet<ECardExpansionType> cardExpansions, HashSet<EItemType> items)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!prize.IsCard() || !cardExpansions.Contains(prize.m_CardData.expansionType))
			{
				if (prize.IsItem())
				{
					return items.Contains(prize.m_ItemType);
				}
				return false;
			}
			return true;
		}
	}
	internal class TournamentRemovalStrategy(HashSet<ECardExpansionType> cardExpansions, HashSet<EItemType> items) : IAssetRemovalStrategy
	{
		public RemovalResult RemoveAssets()
		{
			int num = 0;
			float num2 = 0f;
			TournamentData tournamentData = CPlayerData.m_TournamentData;
			if (tournamentData != null)
			{
				foreach (TournamentPrizeDataList prizeData in tournamentData.m_PrizeDataList)
				{
					foreach (TournamentPrizeData item in prizeData.m_PrizeDataList.Where((TournamentPrizeData p) => p.IsBundleContent(cardExpansions, items)))
					{
						num += item.m_Count;
						num2 += GetPrizeValue(item);
					}
					prizeData.m_PrizeDataList.RemoveAll((TournamentPrizeData p) => p.IsBundleContent(cardExpansions, items));
				}
			}
			foreach (CustomerTournamentData item2 in from d in CSingleton<ShelfManager>.Instance.m_PlayTableList.SelectMany((InteractablePlayTable t) => t.m_CustomerTournamentDataList).Append(CPlayerData.m_PlayerTournamentData)
				where d != null
				select d)
			{
				item2.m_PrizeDataList.RemoveAll((TournamentPrizeData p) => p.IsBundleContent(cardExpansions, items));
				if (item2.m_TargetPrizeData != null && item2.m_TargetPrizeData.IsBundleContent(cardExpansions, items))
				{
					item2.m_TargetPrizeData = null;
				}
			}
			return RemovalResult.Success(num, num2);
		}

		private static float GetPrizeValue(TournamentPrizeData prize)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!prize.IsCard())
			{
				return RestockManager.GetItemMarketPrice(prize.m_ItemType) * (float)prize.m_Count;
			}
			return CPlayerData.GetCardMarketPrice(prize.m_CardData) * (float)prize.m_Count;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Trading
{
	internal class CardTradeManager
	{
		private readonly CardSelectionService cardSelectionService = new CardSelectionService();

		private readonly CardTradePricingService cardTradePricingService = new CardTradePricingService();

		private readonly CardTradeUIManager cardTradeUIManager = new CardTradeUIManager();

		public void SetCustomer(CustomerTradeCardScreen screen, Customer customer, CustomerTradeData customerTradeData)
		{
			CSingleton<CustomerManager>.Instance.m_IsPlayerTrading = true;
			screen.m_CurrentCustomer = customer;
			screen.m_HasAccepted = false;
			screen.m_IsTrading = customerTradeData?.m_IsTrading ?? (Random.Range(0, 100) < Math.Min(40, CPlayerData.m_ShopLevel));
			screen.m_CardData_L = (CardData)((customerTradeData != null) ? ((object)customerTradeData.m_CardData_L) : ((object)cardSelectionService.SelectRandomCard()));
			if (screen.m_IsTrading)
			{
				SetupTradeMode(screen, customerTradeData);
			}
			else
			{
				SetupSellMode(screen, customerTradeData);
			}
			cardTradeUIManager.UpdateUI(screen);
		}

		private void SetupTradeMode(CustomerTradeCardScreen screen, CustomerTradeData customerTradeData)
		{
			screen.m_CardData_R = (CardData)((customerTradeData != null) ? ((object)customerTradeData.m_CardData_R) : ((object)cardSelectionService.SelectPlayerCard(screen.m_CardData_L, customerTradeData)));
			if (screen.m_CardData_R == null)
			{
				screen.m_IsTrading = false;
				SetupSellMode(screen, customerTradeData);
			}
		}

		private void SetupSellMode(CustomerTradeCardScreen screen, CustomerTradeData customerTradeData)
		{
			cardTradePricingService.CalculateAskingPrice(screen, screen.m_CardData_L, customerTradeData);
			if (customerTradeData != null)
			{
				screen.m_PriceSet = customerTradeData.m_PriceSet;
				screen.m_LastPriceSet = customerTradeData.m_LastPriceSet;
			}
			else
			{
				screen.OnInputTextUpdated("0");
			}
		}
	}
	internal class CardTradePricingService
	{
		private static readonly (float threshold, float minBonus, float maxBonus)[] PriceTiers = new(float, float, float)[9]
		{
			(10f, 0f, 0.03f),
			(20f, 0f, 0.04f),
			(100f, 0.01f, 0.05f),
			(300f, 0.01f, 0.06f),
			(500f, 0.01f, 0.08f),
			(1000f, 0.01f, 0.1f),
			(2000f, 0.02f, 0.11f),
			(5000f, 0.03f, 0.12f),
			(8000f, 0.03f, 0.12f)
		};

		public void CalculateAskingPrice(CustomerTradeCardScreen screen, CardData customerCard, CustomerTradeData customerTradeData)
		{
			screen.m_SellCardMarketPrice = CPlayerData.GetCardMarketPrice(customerCard);
			if (customerTradeData != null)
			{
				screen.m_SellCardAskPrice = customerTradeData.m_SellCardAskPrice;
				screen.m_MaxDeclineCount = customerTradeData.m_MaxDeclineCount;
				screen.m_DeclineCount = customerTradeData.m_DeclineCount;
			}
			else
			{
				screen.m_SellCardAskPrice = CalculateInitialAskingPrice(screen.m_SellCardMarketPrice);
				screen.m_MaxDeclineCount = Random.Range(0, 5);
				screen.m_DeclineCount = 0;
			}
		}

		private float CalculateInitialAskingPrice(float marketPrice)
		{
			float num = Random.Range(0.7f, 1.2f);
			(float, float, float)[] priceTiers = PriceTiers;
			for (int i = 0; i < priceTiers.Length; i++)
			{
				(float, float, float) tuple = priceTiers[i];
				if (marketPrice > tuple.Item1)
				{
					num += Random.Range(tuple.Item2, tuple.Item3);
				}
			}
			return num * marketPrice;
		}
	}
	internal class CardTradeUIManager
	{
		public void UpdateUI(CustomerTradeCardScreen screen)
		{
			SetTradingScreenText(screen);
			UpdateScreenGrpVisibility(screen);
			SetPriceTexts(screen);
			UpdateCardDisplays(screen);
			UpdateButtonVisibility(screen);
		}

		private void SetTradingScreenText(CustomerTradeCardScreen screen)
		{
			List<string> list = (screen.m_IsTrading ? screen.m_CustomerTradeCardTextList : screen.m_CustomerSellCardTextList);
			((TMP_Text)screen.m_CustomerTopText).text = LocalizationManager.GetTranslation("CustomerTrade/" + list[Random.Range(0, list.Count)], true, 0, true, false, (GameObject)null, (string)null, true);
			screen.m_CustomerTopTextAnim.Rewind();
			screen.m_CustomerTopTextAnim.Play();
		}

		private void UpdateScreenGrpVisibility(CustomerTradeCardScreen screen)
		{
			screen.m_CustomerTradingText.SetActive(screen.m_IsTrading);
			screen.m_CustomerSellingText.SetActive(!screen.m_IsTrading);
			screen.m_TradeGrp_R.SetActive(screen.m_IsTrading);
			screen.m_SellGrp_R.SetActive(!screen.m_IsTrading);
		}

		private void SetPriceTexts(CustomerTradeCardScreen screen)
		{
			string translation = LocalizationManager.GetTranslation("Market Price", true, 0, true, false, (GameObject)null, (string)null, true);
			string priceString = GameInstance.GetPriceString(CPlayerData.GetCardMarketPrice(screen.m_CardData_L), false, true, false, "F2");
			string translation2 = LocalizationManager.GetTranslation("Ask Price", true, 0, true, false, (GameObject)null, (string)null, true);
			string priceString2 = GameInstance.GetPriceString(screen.m_SellCardAskPrice, false, true, false, "F2");
			if (screen.m_IsTrading)
			{
				((TMP_Text)screen.m_MarketPrice_L).text = translation + " : " + priceString;
				return;
			}
			((TMP_Text)screen.m_MarketPrice_L).text = translation2 + " : " + priceString2 + "\n" + translation + " : " + priceString;
			screen.m_CardUI_Buying.SetCardUI(screen.m_CardData_L);
		}

		private void UpdateButtonVisibility(CustomerTradeCardScreen screen)
		{
			screen.m_AcceptBtn.SetActive(true);
			screen.m_CancelBtn.SetActive(true);
			screen.m_LetMeThinkBtn.SetActive(true);
			screen.m_DoneBtn.SetActive(false);
		}

		private void UpdateCardDisplays(CustomerTradeCardScreen screen)
		{
			screen.m_IsNewUI.SetActive(CPlayerData.GetCardAmount(screen.m_CardData_L) == 0);
			screen.m_CardUI_L.SetCardUI(screen.m_CardData_L);
			screen.m_CardUI_Album_L.SetCardUI(screen.m_CardData_L);
			((TMP_Text)screen.m_AlbumCardCount_L).text = GetCardCountText(screen.m_CardData_L);
			if (screen.m_IsTrading && screen.m_CardData_R != null)
			{
				screen.m_CardUI_R.SetCardUI(screen.m_CardData_R);
				screen.m_CardUI_Album.SetCardUI(screen.m_CardData_R);
				((TMP_Text)screen.m_AlbumCardCount).text = GetCardCountText(screen.m_CardData_R);
				float cardMarketPrice = CPlayerData.GetCardMarketPrice(screen.m_CardData_R);
				string translation = LocalizationManager.GetTranslation("Market Price", true, 0, true, false, (GameObject)null, (string)null, true);
				((TMP_Text)screen.m_MarketPrice_R).text = translation + " : " + GameInstance.GetPriceString(cardMarketPrice, false, true, false, "F2");
			}
		}

		private string GetCardCountText(CardData card)
		{
			if (card.cardGrade <= 0)
			{
				return "X" + CPlayerData.GetCardAmount(card);
			}
			if (!CPlayerData.HasGradedCardInAlbum(card))
			{
				return "X0";
			}
			return "X1";
		}
	}
}
namespace EnhancedPrefabLoader.Core.Shops
{
	internal class CustomShopScreen : RestockItemScreen, ICustomShopScreen
	{
		private TextMeshProUGUI? pageUrl;

		private Image? pageLogo;

		private Image? pageHeader;

		private Image? pageBackground;

		private Color originalHeaderColor;

		private Color originalBackgroundColor;

		private string displayName = string.Empty;

		private readonly List<string> pageUrls = new List<string>(4) { "cards", "accessories", "figurines", "all" };

		private List<List<RestockData>> pageItems = new List<List<RestockData>>();

		private int currentPageIndex;

		internal bool IsOpen => ((UIScreenBase)this).m_ScreenGroup.activeSelf;

		public override void Awake()
		{
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			//IL_0270: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Expected O, but got Unknown
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0295: Expected O, but got Unknown
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Expected O, but got Unknown
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Expected O, but got Unknown
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Expected O, but got Unknown
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Expected O, but got Unknown
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_030d: Expected O, but got Unknown
			//IL_031e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Expected O, but got Unknown
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_033e: Expected O, but got Unknown
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_035e: Expected O, but got Unknown
			//IL_036a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Expected O, but got Unknown
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_038f: Expected O, but got Unknown
			//IL_039b: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Expected O, but got Unknown
			//IL_03c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ca: Expected O, but got Unknown
			//IL_03d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e0: Expected O, but got Unknown
			//IL_044d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0457: Expected O, but got Unknown
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Expected O, but got Unknown
			((UIScreenBase)this).m_ScreenGroup = ((Component)((Component)this).transform.Find("ScreenGrp")).gameObject;
			ref RectTransform animGrp = ref ((GenericSliderScreen)this).m_AnimGrp;
			Transform obj = ((UIScreenBase)this).m_ScreenGroup.transform.Find("AnimGrp");
			animGrp = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			((GenericSliderScreen)this).m_VerticalLayoutGrp = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteContent_Grp/ScrollerGrp");
			((GenericSliderScreen)this).m_VerticalLayout = ((Component)((GenericSliderScreen)this).m_VerticalLayoutGrp).GetComponent<VerticalLayoutGroup>();
			((GenericSliderScreen)this).m_SliderGrp = ((Component)((GenericSliderScreen)this).m_VerticalLayoutGrp).gameObject;
			((GenericSliderScreen)this).m_ScrollEndComparer = ((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("ScrollEndComparer")).gameObject;
			((GenericSliderScreen)this).m_ScrollEndPos = ((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("ScrollEnd")).gameObject;
			Transform obj2 = ((Component)this).transform.parent.Find("RestockItemAddToCartScreen");
			base.m_RestockItemAddToCartScreen = ((obj2 != null) ? ((Component)obj2).GetComponent<RestockItemAddToCartScreen>() : null);
			Transform obj3 = ((Component)this).transform.parent.Find("RestockItemCheckoutScreen");
			base.m_RestockItemCheckoutScreen = ((obj3 != null) ? ((Component)obj3).GetComponent<RestockItemCheckoutScreen>() : null);
			base.m_SortUIScreen = ((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("SortingUIScreen")).GetComponent<UIScreenBase>();
			base.m_RestockItemPanelUIList = new List<RestockItemPanelUI>();
			base.m_PageButtonHighlightList = new List<GameObject>(4)
			{
				((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/PackBtn/AnimGrp/BGBarGrp/BGBlack")).gameObject,
				((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/AccessoriesBtn/AnimGrp/BGBarGrp/BGBlack")).gameObject,
				((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/FigurineBtn/AnimGrp/BGBarGrp/BGBlack")).gameObject,
				((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/AllBtn/AnimGrp/BGBarGrp/BGBlack")).gameObject
			};
			base.m_SortBtnList = (from Transform t in (IEnumerable)((Component)base.m_SortUIScreen).transform.Find("Screen_Grp/AnimGrp/Mask/UIGroup")
				select ((Component)t).GetComponent<ControllerButton>()).ToList();
			Transform val = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar");
			Transform obj4 = val.Find("TotalPriceBG/TotalPrice");
			base.m_TotalCostText = ((obj4 != null) ? ((Component)obj4).GetComponent<TextMeshProUGUI>() : null);
			base.m_CartNotification = ((Component)val.Find("NotificationGrp")).gameObject;
			Transform obj5 = base.m_CartNotification.transform.Find("NotificationText");
			base.m_TotalCartItemCountText = ((obj5 != null) ? ((Component)obj5).GetComponent<TextMeshProUGUI>() : null);
			Button component = ((Component)val.Find("CheckoutBtn/BtnRaycast")).GetComponent<Button>();
			component.onClick = new ButtonClickedEvent();
			((UnityEvent)component.onClick).AddListener(new UnityAction(base.OnPressCheckoutButton));
			Button component2 = ((Component)val.Find("PackBtn/AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>();
			component2.onClick = new ButtonClickedEvent();
			((UnityEvent)component2.onClick).AddListener((UnityAction)delegate
			{
				OnScreenSelection(0);
			});
			Button component3 = ((Component)val.Find("AccessoriesBtn/AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>();
			component3.onClick = new ButtonClickedEvent();
			((UnityEvent)component3.onClick).AddListener((UnityAction)delegate
			{
				OnScreenSelection(1);
			});
			Button component4 = ((Component)val.Find("FigurineBtn/AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>();
			component4.onClick = new ButtonClickedEvent();
			((UnityEvent)component4.onClick).AddListener((UnityAction)delegate
			{
				OnScreenSelection(2);
			});
			Button component5 = ((Component)val.Find("AllBtn/AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>();
			component5.onClick = new ButtonClickedEvent();
			((UnityEvent)component5.onClick).AddListener((UnityAction)delegate
			{
				OnScreenSelection(3);
			});
			Button component6 = ((Component)((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("TopWebBar/AddressBar/CloseBtn")).GetComponent<Button>();
			component6.onClick = new ButtonClickedEvent();
			((UnityEvent)component6.onClick).AddListener(new UnityAction(((UIScreenBase)this).CloseScreen));
			Button component7 = ((Component)val.Find("SortBtn/AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>();
			component7.onClick = new ButtonClickedEvent();
			((UnityEvent)component7.onClick).AddListener(new UnityAction(base.OpenSortScreen));
			Button component8 = ((Component)((Component)base.m_SortUIScreen).transform.Find("Screen_Grp/AnimGrp/CloseButton/ButtonArea")).GetComponent<Button>();
			component8.onClick = new ButtonClickedEvent();
			((UnityEvent)component8.onClick).AddListener(new UnityAction(base.CloseSortScreen));
			foreach (var item in ((IEnumerable)((Component)base.m_SortUIScreen).transform.Find("Screen_Grp/AnimGrp/Mask/UIGroup")).Cast<Transform>().Select((Transform t, int item) => (((Component)t.Find("AnimGrp/BGBarGrp/BtnRaycast")).GetComponent<Button>(), index: item)))
			{
				var (val2, index) = item;
				val2.onClick = new ButtonClickedEvent();
				((UnityEvent)val2.onClick).AddListener((UnityAction)delegate
				{
					OnPressSortButton(index);
				});
			}
			for (int num = 1; num < ((GenericSliderScreen)this).m_VerticalLayoutGrp.childCount; num++)
			{
				Object.Destroy((Object)(object)((Component)((GenericSliderScreen)this).m_VerticalLayoutGrp.GetChild(num)).gameObject);
			}
			base.m_RestockItemPanelUIList.AddRange(from Transform t in (IEnumerable)((GenericSliderScreen)this).m_VerticalLayoutGrp.GetChild(0)
				select ((Component)t).GetComponent<RestockItemPanelUI>());
			((GenericSliderScreen)this).m_ScrollEndPosOffsetYAmount = 0f;
			((GenericSliderScreen)this).m_MaximizePosY = -100f;
			((GenericSliderScreen)this).m_ScrollSpeedMultiplier = 1f;
			((GenericSliderScreen)this).m_GamepadJoystickSpeedMultiplier = 1f;
			((GenericSliderScreen)this).m_MaxPosXClamp = 100000f;
			((GenericSliderScreen)this).m_EvalSliderMaxOnOpen = true;
			((GenericSliderScreen)this).m_ResetScrollPosOnOpen = true;
			((UIScreenBase)this).m_CloseIfScreenOpened = true;
			((RestockItemScreen)this).Awake();
		}

		internal void SwapTo(CustomShopData shopData)
		{
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			displayName = shopData.AppDisplayName;
			List<RestockData> item = shopData.TCG.Concat(shopData.Accessories).Concat(shopData.Figurines).Distinct()
				.ToList();
			pageItems = new List<List<RestockData>>(4) { shopData.TCG, shopData.Accessories, shopData.Figurines, item };
			currentPageIndex = 0;
			UpdatePageButtonHighlights();
			Transform val = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar");
			if (val != null)
			{
				if (pageLogo == null)
				{
					Transform obj = val.Find("Logo");
					pageLogo = ((obj != null) ? ((Component)obj).GetComponent<Image>() : null);
				}
				Image? obj2 = pageLogo;
				if (obj2 != null)
				{
					StreamingAssetExtensions.SetSpriteAsync(obj2, shopData.SiteLogo);
				}
				if (!Object.op_Implicit((Object)(object)pageHeader))
				{
					pageHeader = ((Component)val).GetComponent<Image>();
					if (Object.op_Implicit((Object)(object)pageHeader))
					{
						originalHeaderColor = ((Graphic)pageHeader).color;
					}
				}
				Image? obj3 = pageHeader;
				if (obj3 != null)
				{
					StreamingAssetExtensions.SetSpriteAsync(obj3, shopData.SiteHeader);
				}
				if (Object.op_Implicit((Object)(object)pageHeader))
				{
					((Graphic)pageHeader).color = ((shopData.SiteHeader != null) ? Color.white : originalHeaderColor);
				}
			}
			if (!Object.op_Implicit((Object)(object)pageBackground))
			{
				Transform obj4 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("BG");
				pageBackground = ((obj4 != null) ? ((Component)obj4).GetComponent<Image>() : null);
				if (Object.op_Implicit((Object)(object)pageBackground))
				{
					originalBackgroundColor = ((Graphic)pageBackground).color;
				}
			}
			Image? obj5 = pageBackground;
			if (obj5 != null)
			{
				StreamingAssetExtensions.SetSpriteAsync(obj5, shopData.SiteBackground);
			}
			if (Object.op_Implicit((Object)(object)pageBackground))
			{
				((Graphic)pageBackground).color = ((shopData.SiteBackground != null) ? Color.white : originalBackgroundColor);
			}
			if (pageUrl == null)
			{
				Transform obj6 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("TopWebBar/AddressBar/AddressBarWhite/Text");
				pageUrl = ((obj6 != null) ? ((Component)obj6).GetComponent<TextMeshProUGUI>() : null);
			}
			TextMeshProUGUI? obj7 = pageUrl;
			if (obj7 != null)
			{
				((TMP_Text)obj7).text = "www." + displayName.ToLower().Replace(" ", "-") + ".com/shop/" + pageUrls[0];
			}
			((RestockItemScreen)this).EvaluateRestockItemPanelUI(0);
			((GenericSliderScreen)this).m_PosX = 0f;
			((GenericSliderScreen)this).m_LerpPosX = 0f;
		}

		public override void EvaluateRestockItemPanelUI(int _)
		{
			if (pageItems.Count == 0)
			{
				return;
			}
			List<int> sortedItems = GetSortedItems();
			for (int i = 0; i < base.m_RestockItemPanelUIList.Count; i++)
			{
				if (i < sortedItems.Count)
				{
					base.m_RestockItemPanelUIList[i].Init((RestockItemScreen)(object)this, sortedItems[i]);
					((UIElementBase)base.m_RestockItemPanelUIList[i]).SetActive(true);
					((GenericSliderScreen)this).m_ScrollEndPosParent = ((Component)base.m_RestockItemPanelUIList[i]).gameObject;
				}
				else
				{
					((UIElementBase)base.m_RestockItemPanelUIList[i]).SetActive(false);
				}
			}
		}

		internal void InitializeControllerExtension()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			ControllerScreenUIExtension component = ((Component)this).GetComponent<ControllerScreenUIExtension>();
			if (component == null)
			{
				ModLogger.Warning("Unable to find the Controller script on custom shop. Likely broken due to a base game update.", "InitializeControllerExtension", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Shops\\CustomShopScreen.cs");
				return;
			}
			component.m_ControllerBtnColumnList.Clear();
			component.m_CtrlBtnXChangeMethodList.Clear();
			List<ControllerBtnList> controllerBtnColumnList = component.m_ControllerBtnColumnList;
			ControllerBtnList item = default(ControllerBtnList);
			List<ControllerButton> list = new List<ControllerButton>(1);
			Transform obj = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("TopWebBar");
			list.Add((obj != null) ? ((Component)obj).GetComponent<ControllerButton>() : null);
			item.rowList = list;
			controllerBtnColumnList.Add(item);
			component.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
			List<ControllerBtnList> controllerBtnColumnList2 = component.m_ControllerBtnColumnList;
			item = default(ControllerBtnList);
			List<ControllerButton> list2 = new List<ControllerButton>(6);
			Transform obj2 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/SortBtn");
			list2.Add((obj2 != null) ? ((Component)obj2).GetComponent<ControllerButton>() : null);
			Transform obj3 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/PackBtn");
			list2.Add((obj3 != null) ? ((Component)obj3).GetComponent<ControllerButton>() : null);
			Transform obj4 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/AccessoriesBtn");
			list2.Add((obj4 != null) ? ((Component)obj4).GetComponent<ControllerButton>() : null);
			Transform obj5 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/FigurineBtn");
			list2.Add((obj5 != null) ? ((Component)obj5).GetComponent<ControllerButton>() : null);
			Transform obj6 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/AllBtn");
			list2.Add((obj6 != null) ? ((Component)obj6).GetComponent<ControllerButton>() : null);
			Transform obj7 = ((Transform)((GenericSliderScreen)this).m_AnimGrp).Find("WebsiteTopBar/CheckoutBtn");
			list2.Add((obj7 != null) ? ((Component)obj7).GetComponent<ControllerButton>() : null);
			item.rowList = list2;
			controllerBtnColumnList2.Add(item);
			component.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
			for (int i = 0; i < base.m_RestockItemPanelUIList.Count; i += 4)
			{
				ControllerBtnList val = new ControllerBtnList
				{
					rowList = new List<ControllerButton>()
				};
				int num = Mathf.Min(4, base.m_RestockItemPanelUIList.Count - i);
				for (int j = 0; j < num; j++)
				{
					val.rowList.Add(((Component)base.m_RestockItemPanelUIList[i + j]).GetComponent<ControllerButton>());
				}
				component.m_ControllerBtnColumnList.Add(val);
				component.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
			}
		}

		private void OnScreenSelection(int pageIndex)
		{
			if (pageIndex != currentPageIndex)
			{
				currentPageIndex = pageIndex;
				UpdatePageButtonHighlights();
				TextMeshProUGUI? obj = pageUrl;
				if (obj != null)
				{
					((TMP_Text)obj).text = "www." + displayName.ToLower().Replace(" ", "-") + ".com/shop/" + pageUrls[pageIndex];
				}
				((RestockItemScreen)this).EvaluateRestockItemPanelUI(pageIndex);
				((MonoBehaviour)this).StartCoroutine(((GenericSliderScreen)this).EvaluateActiveRestockUIScroller());
				((GenericSliderScreen)this).m_PosX = 0f;
				((GenericSliderScreen)this).m_LerpPosX = 0f;
			}
		}

		private void UpdatePageButtonHighlights()
		{
			for (int i = 0; i < base.m_PageButtonHighlightList.Count; i++)
			{
				base.m_PageButtonHighlightList[i].SetActive(i == currentPageIndex);
			}
		}

		private void OnPressSortButton(int index)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			CPlayerData.m_RestockSortingType = (ERestockSortingType)index;
			((RestockItemScreen)this).EvaluateRestockItemPanelUI(index);
			((MonoBehaviour)this).StartCoroutine(((GenericSliderScreen)this).EvaluateActiveRestockUIScroller());
			((GenericSliderScreen)this).m_PosX = 0f;
			((GenericSliderScreen)this).m_LerpPosX = 0f;
			((RestockItemScreen)this).CloseSortScreen();
		}

		private List<int> GetSortedItems()
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Expected I4, but got Unknown
			int baseItemsCount = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList.Count;
			List<RestockData> currentPageItems = pageItems[currentPageIndex];
			IEnumerable<(ModRestockData, int)> source = from x in EplRuntimeData.Assets.ItemLibrary.RestockEntries.Select((ModRestockData entry, int index) => (entry: entry, index: index + baseItemsCount))
				where currentPageItems.Contains(x.entry.RestockData)
				select x;
			ERestockSortingType restockSortingType = CPlayerData.m_RestockSortingType;
			return (restockSortingType - 1) switch
			{
				1 => (from x in source
					orderby x.entry.RestockData.licenseShopLevelRequired descending, x.entry.RestockData.name
					select x.index).ToList(), 
				0 => (from x in source
					orderby x.entry.RestockData.licenseShopLevelRequired, x.entry.RestockData.name
					select x.index).ToList(), 
				3 => (from x in source
					orderby GetItemCost(x.entry, x.index) descending, x.entry.RestockData.name
					select x.index).ToList(), 
				2 => (from x in source
					orderby GetItemCost(x.entry, x.index), x.entry.RestockData.name
					select x.index).ToList(), 
				_ => (from x in source
					orderby x.entry.RestockData.licenseShopLevelRequired, x.entry.RestockData.name
					select x.index).ToList(), 
			};
		}

		private float GetItemCost(ModRestockData entry, int index)
		{
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!CPlayerData.GetIsItemLicenseUnlocked(index))
			{
				return entry.RestockData.licensePrice;
			}
			return CPlayerData.GetItemCost(entry.RestockData.itemType) * (float)RestockManager.GetMaxItemCountInBox(entry.RestockData.itemType, entry.RestockData.isBigBox);
		}
	}
	internal class ShopInventoryManager
	{
		private bool IsFurnitureLoaded { get; set; }

		private bool IsItemsLoaded { get; set; }

		private bool IsDecoLoaded { get; set; }

		internal List<EItemType> CustomShopTcgItems { get; } = new List<EItemType>();

		internal List<EItemType> CustomShopAccessoryItems { get; } = new List<EItemType>();

		internal List<EItemType> CustomShopFigurineItems { get; } = new List<EItemType>();

		internal void PopulateAllShopInventories()
		{
			AddFurnitureToInventory();
			AddItemsToInventory();
			AddDecoToInventory();
		}

		private void AddFurnitureToInventory()
		{
			if (IsFurnitureLoaded)
			{
				return;
			}
			if (EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.Count == 0)
			{
				ModLogger.Debug("No furniture to add to shop", "AddFurnitureToInventory", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
				IsFurnitureLoaded = true;
				return;
			}
			foreach (ModFurniturePurchaseData value in EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.Values)
			{
				List<FurniturePurchaseData> furniturePurchaseDataList = CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FurniturePurchaseDataList;
				List<ObjectData> objectDataList = CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_ObjectDataList;
				bool flag = false;
				for (int i = 0; i < furniturePurchaseDataList.Count; i++)
				{
					if (furniturePurchaseDataList[i].levelRequirement > value.BaseFurniturePurchaseData.levelRequirement)
					{
						furniturePurchaseDataList.Insert(i, value.BaseFurniturePurchaseData);
						objectDataList.Insert(i, value.BaseObjectData);
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					furniturePurchaseDataList.Add(value.BaseFurniturePurchaseData);
					objectDataList.Add(value.BaseObjectData);
				}
			}
			IsFurnitureLoaded = true;
		}

		internal void AddItemsToInventory()
		{
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: 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_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			if (IsItemsLoaded)
			{
				return;
			}
			if (EplRuntimeData.Assets.ItemLibrary.ItemData.Count == 0)
			{
				ModLogger.Debug("No items to add to shop", "AddItemsToInventory", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
				IsItemsLoaded = true;
				return;
			}
			foreach (ModRestockData restockEntry in EplRuntimeData.Assets.ItemLibrary.RestockEntries)
			{
				StockItemData_ScriptableObject stockItemData_SO = CSingleton<InventoryBase>.Instance.m_StockItemData_SO;
				EItemType itemType = restockEntry.RestockData.itemType;
				if ((restockEntry.ItemFlags & ItemFlags.BoardGame) != ItemFlags.None)
				{
					stockItemData_SO.m_ShownBoardGameItemType.AddIfMissing(itemType);
				}
				if (PhoneOverhaulBridge.Instance.IsLoaded && !string.IsNullOrWhiteSpace(restockEntry.PhoneAppId) && EplRuntimeData.Assets.ShopLibrary.CustomShops.ContainsKey(restockEntry.PhoneAppId))
				{
					if ((restockEntry.ItemFlags & ItemFlags.Accessory) != ItemFlags.None)
					{
						CustomShopAccessoryItems.AddIfMissing(itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.Figurine) != ItemFlags.None)
					{
						CustomShopFigurineItems.AddIfMissing(itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.TCG) != ItemFlags.None)
					{
						CustomShopTcgItems.AddIfMissing(itemType);
					}
				}
				else
				{
					if ((restockEntry.ItemFlags & ItemFlags.Accessory) != ItemFlags.None)
					{
						stockItemData_SO.m_ShownAccessoryItemType.AddIfMissing(itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.Figurine) != ItemFlags.None)
					{
						stockItemData_SO.m_ShownFigurineItemType.AddIfMissing(itemType);
					}
					if ((restockEntry.ItemFlags & ItemFlags.TCG) != ItemFlags.None)
					{
						stockItemData_SO.m_ShownItemType.AddIfMissing(itemType);
					}
				}
			}
			IsItemsLoaded = true;
		}

		private void AddDecoToInventory()
		{
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Invalid comparison between Unknown and I4
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Invalid comparison between Unknown and I4
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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 (IsDecoLoaded)
			{
				return;
			}
			if (EplRuntimeData.Assets.DecoLibrary.DecoObjectData.Count == 0)
			{
				ModLogger.Debug("No deco objects to add to shop", "AddDecoToInventory", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
			}
			else
			{
				foreach (KeyValuePair<EDecoObject, ModDecoData> decoObjectDatum in EplRuntimeData.Assets.DecoLibrary.DecoObjectData)
				{
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_DecoPurchaseDataList.Add(decoObjectDatum.Value.BasePurchaseData);
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_DecoDataList.Add(decoObjectDatum.Value.BaseDecoData);
					EDecoType decoType = decoObjectDatum.Value.BaseDecoData.decoType;
					if ((int)decoType != 1 && (int)decoType != 0)
					{
						CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_OtherDecoList.Add(decoObjectDatum.Key);
					}
					if ((int)decoObjectDatum.Value.BaseDecoData.decoType == 1)
					{
						CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_PosterDecoList.Add(decoObjectDatum.Key);
					}
				}
			}
			if (EplRuntimeData.Assets.DecoLibrary.DecoWallTextureData.Count == 0)
			{
				ModLogger.Debug("No wall textures to add to shop", "AddDecoToInventory", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
			}
			else
			{
				foreach (ModShopDecoData decoWallTextureDatum in EplRuntimeData.Assets.DecoLibrary.DecoWallTextureData)
				{
					DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
					int valueOrDefault = decoLibrary.firstInsertedWallTexture.GetValueOrDefault();
					if (!decoLibrary.firstInsertedWallTexture.HasValue)
					{
						valueOrDefault = CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_WallDecoDataList.Count;
						decoLibrary.firstInsertedWallTexture = valueOrDefault;
					}
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_WallDecoDataList.Add(decoWallTextureDatum.ShopDecoData);
				}
			}
			if (EplRuntimeData.Assets.DecoLibrary.DecoFloorTextureData.Count == 0)
			{
				ModLogger.Debug("No floor textures to add to shop", "AddDecoToInventory", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
			}
			else
			{
				foreach (ModShopDecoData decoFloorTextureDatum in EplRuntimeData.Assets.DecoLibrary.DecoFloorTextureData)
				{
					DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
					int valueOrDefault = decoLibrary.firstInsertedFloorTexture.GetValueOrDefault();
					if (!decoLibrary.firstInsertedFloorTexture.HasValue)
					{
						valueOrDefault = CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FloorDecoDataList.Count;
						decoLibrary.firstInsertedFloorTexture = valueOrDefault;
					}
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_FloorDecoDataList.Add(decoFloorTextureDatum.ShopDecoData);
				}
			}
			if (EplRuntimeData.Assets.DecoLibrary.DecoCeilingTextureData.Count == 0)
			{
				ModLogger.Debug("No ceiling textures to add to shop", "AddDecoToInventory", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Shops\\ShopInventoryManager.cs");
			}
			else
			{
				foreach (ModShopDecoData decoCeilingTextureDatum in EplRuntimeData.Assets.DecoLibrary.DecoCeilingTextureData)
				{
					DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
					int valueOrDefault = decoLibrary.firstInsertedCeilingTexture.GetValueOrDefault();
					if (!decoLibrary.firstInsertedCeilingTexture.HasValue)
					{
						valueOrDefault = CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_CeilingDecoDataList.Count;
						decoLibrary.firstInsertedCeilingTexture = valueOrDefault;
					}
					CSingleton<InventoryBase>.Instance.m_ObjectData_SO.m_CeilingDecoDataList.Add(decoCeilingTextureDatum.ShopDecoData);
				}
			}
			IsDecoLoaded = true;
		}

		internal List<EItemType> GetCustomShopItemsForCheckPricePage(int pageIndex)
		{
			switch (pageIndex)
			{
			case 0:
				return CustomShopTcgItems;
			case 1:
				return CustomShopAccessoryItems;
			case 2:
				return CustomShopFigurineItems;
			case 3:
			{
				List<EItemType> customShopTcgItems = CustomShopTcgItems;
				List<EItemType> customShopAccessoryItems = CustomShopAccessoryItems;
				List<EItemType> customShopFigurineItems = CustomShopFigurineItems;
				List<EItemType> list = new List<EItemType>(customShopTcgItems.Count + customShopAccessoryItems.Count + customShopFigurineItems.Count);
				list.AddRange(customShopTcgItems);
				list.AddRange(customShopAccessoryItems);
				list.AddRange(customShopFigurineItems);
				return list;
			}
			default:
				return new List<EItemType>();
			}
		}

		internal int GetBaseGameItemCountForCheckPricePage(int pageIndex)
		{
			StockItemData_ScriptableObject stockItemData_SO = CSingleton<InventoryBase>.Instance.m_StockItemData_SO;
			return pageIndex switch
			{
				0 => stockItemData_SO.m_ShownItemType.Count, 
				1 => stockItemData_SO.m_ShownAccessoryItemType.Count, 
				2 => stockItemData_SO.m_ShownFigurineItemType.Count, 
				4 => stockItemData_SO.m_ShownBoardGameItemType.Count((EItemType t) => (int)t != -1), 
				3 => stockItemData_SO.m_ShownItemType.Count + stockItemData_SO.m_ShownAccessoryItemType.Count + stockItemData_SO.m_ShownFigurineItemType.Count + stockItemData_SO.m_ShownBoardGameItemType.Count((EItemType t) => (int)t != -1), 
				_ => 0, 
			};
		}
	}
}
namespace EnhancedPrefabLoader.Core.Settings
{
	internal class BundleInfoPanel
	{
		private static readonly Color ErrorColor = new Color(1f, 0.42f, 0.42f);

		private static readonly Color WarningColor = new Color(1f, 0.79f, 0.3f);

		private readonly List<string> dropdownBundleIds = new List<string>();

		private Transform? parent;

		private GameObject? labelTemplate;

		private TMP_Dropdown? bundleDropdown;

		private TextMeshProUGUI? statusValue;

		private TextMeshProUGUI? bundleIdValue;

		private TextMeshProUGUI? itemCountValue;

		private TextMeshProUGUI? furnitureCountValue;

		private TextMeshProUGUI? decoCountValue;

		private TextMeshProUGUI? textureCountValue;

		private TextMeshProUGUI? expansionCountValue;

		private TextMeshProUGUI? cardCountValue;

		private GameObject? expansionDropdownRow;

		private TMP_Dropdown? expansionDropdown;

		private GameObject? issuesPanel;

		private FlowLayoutGroup? issuesFlow;

		private Color defaultValueColor = Color.white;

		internal void Build(Transform screenParent, Transform? bundleDropdownRow, GameObject? rowTemplate, GameObject? dropdownRowTemplate)
		{
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			parent = screenParent;
			labelTemplate = rowTemplate;
			SetupBundleDropdown(bundleDropdownRow);
			if (Object.op_Implicit((Object)(object)rowTemplate))
			{
				statusValue = CreateLabelRow("Status:");
				if (Object.op_Implicit((Object)(object)statusValue))
				{
					defaultValueColor = ((Graphic)statusValue).color;
				}
				bundleIdValue = CreateLabelRow("Bundle ID:");
				itemCountValue = CreateLabelRow("Items:");
				furnitureCountValue = CreateLabelRow("Furniture:");
				decoCountValue = CreateLabelRow("Deco Objects:");
				textureCountValue = CreateLabelRow("Textures:");
				expansionCountValue = CreateLabelRow("Card Expansions:");
				CreateExpansionDropdown(dropdownRowTemplate);
				cardCountValue = CreateLabelRow("Cards:");
				CreateIssuesPanel();
				UpdateBundleInfo();
			}
		}

		internal void RefreshDropdownOptions()
		{
			if (Object.op_Implicit((Object)(object)bundleDropdown))
			{
				BundleRegistry registry = EplRuntimeData.Assets.BundleRegistry;
				BundleMaintenanceService maintenanceService = EplRuntimeData.Services.BundleMaintenanceService;
				dropdownBundleIds.Clear();
				dropdownBundleIds.AddRange(registry.BundleInfo.Keys);
				bundleDropdown.ClearOptions();
				bundleDropdown.AddOptions(((IEnumerable<string>)dropdownBundleIds).Select((Func<string, OptionData>)delegate(string id)
				{
					//IL_0033: Unknown result type (might be due to invalid IL or missing references)
					//IL_0039: Expected O, but got Unknown
					string name = registry.BundleInfo[id].Name;
					return new OptionData(maintenanceService.IsUninstalled(id) ? (name + " (uninstalled)") : name);
				}).ToList());
			}
		}

		internal void UpdateBundleInfo()
		{
			string selectedBundleId = GetSelectedBundleId();
			if (selectedBundleId != null && EplRuntimeData.Assets.BundleRegistry.BundleInfo.TryGetValue(selectedBundleId, out BundleInfo value))
			{
				UpdateStatusRow(selectedBundleId, value);
				SetValue(bundleIdValue, value.BundleId);
				SetValue(itemCountValue, value.ItemTypes.Count.ToString());
				SetValue(furnitureCountValue, value.FurnitureTypes.Count.ToString());
				SetValue(decoCountValue, value.DecoObjects.Count.ToString());
				int num = value.WallTextures.Count + value.FloorTextures.Count + value.CeilingTextures.Count;
				SetValue(textureCountValue, $"{num} (Wall: {value.WallTextures.Count}, Floor: {value.FloorTextures.Count}, Ceiling: {value.CeilingTextures.Count})");
				PopulateExpansionDropdown(value);
				UpdateIssuesList(value);
			}
		}

		internal string? GetSelectedBundleId()
		{
			if (!Object.op_Implicit((Object)(object)bundleDropdown))
			{
				return null;
			}
			int value = bundleDropdown.value;
			if (value >= 0 && value < dropdownBundleIds.Count)
			{
				return dropdownBundleIds[value];
			}
			return null;
		}

		private void SetupBundleDropdown(Transform? bundleDropdownRow)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)bundleDropdownRow))
			{
				return;
			}
			Transform obj = bundleDropdownRow.Find("Currency Dropdown");
			TMP_Dropdown val = ((obj != null) ? ((Component)obj).GetComponent<TMP_Dropdown>() : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				bundleDropdown = val;
				bundleDropdown.onValueChanged = new DropdownEvent();
				RefreshDropdownOptions();
				((UnityEvent<int>)(object)bundleDropdown.onValueChanged).AddListener((UnityAction<int>)delegate
				{
					UpdateBundleInfo();
				});
			}
		}

		private TextMeshProUGUI CreateLabelRow(string labelText)
		{
			GameObject obj = Object.Instantiate<GameObject>(labelTemplate, parent);
			((Object)obj).name = labelText;
			obj.SetActive(true);
			TextMeshProUGUI component = obj.GetComponent<TextMeshProUGUI>();
			((TMP_Text)component).text = labelText;
			Transform obj2 = obj.transform.Find("ValueText");
			TextMeshProUGUI val = ((obj2 != null) ? ((Component)obj2).GetComponent<TextMeshProUGUI>() : null);
			if (Object.op_Implicit((Object)(object)val))
			{
				((TMP_Text)val).text = string.Empty;
			}
			return val ?? component;
		}

		private void CreateExpansionDropdown(GameObject? dropdownRowTemplate)
		{
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			if (!Object.op_Implicit((Object)(object)parent) || !Object.op_Implicit((Object)(object)dropdownRowTemplate))
			{
				return;
			}
			expansionDropdownRow = Object.Instantiate<GameObject>(dropdownRowTemplate, parent);
			((Object)expansionDropdownRow).name = "ExpansionDropdown";
			expansionDropdownRow.SetActive(false);
			GameObject? obj = expansionDropdownRow;
			Localize component = obj.GetComponent<Localize>();
			if (Object.op_Implicit((Object)(object)component))
			{
				component.Term = "Card Expansion";
			}
			Transform val = obj.transform.Find("Currency Dropdown");
			if (Object.op_Implicit((Object)(object)val))
			{
				((Object)val).name = "Expansion Dropdown";
				expansionDropdown = ((Component)val).GetComponent<TMP_Dropdown>();
				Transform obj2 = val.Find("Label");
				TextMeshProUGUI val2 = ((obj2 != null) ? ((Component)obj2).GetComponent<TextMeshProUGUI>() : null);
				if (Object.op_Implicit((Object)(object)val2))
				{
					expansionDropdown.captionText = (TMP_Text)(object)val2;
				}
				expansionDropdown.onValueChanged = new DropdownEvent();
				expansionDropdown.ClearOptions();
				((UnityEvent<int>)(object)expansionDropdown.onValueChanged).AddListener((UnityAction<int>)delegate
				{
					UpdateCardCount();
				});
			}
		}

		private void CreateIssuesPanel()
		{
			if (Object.op_Implicit((Object)(object)parent))
			{
				issuesPanel = FlowLayoutGroup.Create(parent, isScrollable: true);
				((Object)issuesPanel).name = "BundleIssuesPanel";
				LayoutElement obj = issuesPanel.AddComponent<LayoutElement>();
				obj.preferredHeight = 180f;
				obj.flexibleWidth = 1f;
				issuesFlow = issuesPanel.GetComponentInChildren<FlowLayoutGroup>();
				if (Object.op_Implicit((Object)(object)issuesFlow))
				{
					issuesFlow.ChildWidth = 1150f;
					issuesFlow.ChildHeight = 32f;
					issuesFlow.UseChildHeights = true;
					issuesFlow.StretchChildWidth = true;
					issuesFlow.SpacingX = 0f;
					issuesFlow.SpacingY = 4f;
					issuesFlow.CenterContent = false;
				}
				issuesPanel.SetActive(false);
			}
		}

		private void UpdateStatusRow(string bundleId, BundleInfo info)
		{
			//IL_00be: 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_00b0: Unknown result type (might be due to invalid IL or missing references)
			string text = ((!info.IsValid) ? "Skipped (invalid)" : ((!info.IsLoaded) ? "Not loaded" : ((info.Errors.Count > 0) ? "Loaded with errors" : ((info.Warnings.Count > 0) ? "Loaded with warnings" : "Loaded"))));
			if (EplRuntimeData.Services.BundleMaintenanceService.IsUninstalled(bundleId))
			{
				text += " (uninstalled)";
			}
			SetValue(statusValue, text);
			if (Object.op_Implicit((Object)(object)statusValue))
			{
				((Graphic)statusValue).color = ((!info.IsValid || info.Errors.Count > 0) ? ErrorColor : ((info.Warnings.Count > 0) ? WarningColor : defaultValueColor));
			}
		}

		private void UpdateIssuesList(BundleInfo info)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)issuesPanel) || !Object.op_Implicit((Object)(object)issuesFlow))
			{
				return;
			}
			issuesFlow.ClearChildren();
			if (info.Errors.Count == 0 && info.Warnings.Count == 0)
			{
				issuesPanel.SetActive(false);
				return;
			}
			issuesPanel.SetActive(true);
			foreach (string error in info.Errors)
			{
				AddIssueRow("[Error] " + error, ErrorColor);
			}
			foreach (string warning in info.Warnings)
			{
				AddIssueRow("[Warning] " + warning, WarningColor);
			}
		}

		private void AddIssueRow(string message, Color color)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			if (Object.op_Implicit((Object)(object)labelTemplate))
			{
				Transform obj = issuesFlow.AddFromTemplate(labelTemplate.transform);
				Transform val = obj.Find("ValueText");
				if (Object.op_Implicit((Object)(object)val))
				{
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
				TextMeshProUGUI component = ((Component)obj).GetComponent<TextMeshProUGUI>();
				if (Object.op_Implicit((Object)(object)component))
				{
					((TMP_Text)component).text = message;
					((Graphic)component).color = color;
					((TMP_Text)component).fontSize = 14f;
					((TMP_Text)component).enableAutoSizing = false;
					((TMP_Text)component).enableWordWrapping = true;
					((TMP_Text)component).overflowMode = (TextOverflowModes)0;
					((TMP_Text)component).alignment = (TextAlignmentOptions)257;
				}
				LayoutElement component2 = ((Component)obj).GetComponent<LayoutElement>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					component2.minHeight = -1f;
					component2.preferredHeight = -1f;
					component2.flexibleHeight = -1f;
				}
			}
		}

		private unsafe void PopulateExpansionDropdown(BundleInfo info)
		{
			if (info.ExpansionTypes.Count == 0)
			{
				if (Object.op_Implicit((Object)(object)expansionDropdownRow))
				{
					expansionDropdownRow.SetActive(false);
				}
				if (Object.op_Implicit((Object)(object)expansionCountValue))
				{
					((Component)((TMP_Text)expansionCountValue).transform.parent).gameObject.SetActive(true);
				}
				SetValue(expansionCountValue, "0");
				if (Object.op_Implicit((Object)(object)cardCountValue))
				{
					((Component)((TMP_Text)cardCountValue).transform.parent).gameObject.SetActive(false);
				}
				return;
			}
			if (Object.op_Implicit((Object)(object)expansionCountValue))
			{
				((Component)((TMP_Text)expansionCountValue).transform.parent).gameObject.SetActive(false);
			}
			if (Object.op_Implicit((Object)(object)expansionDropdownRow))
			{
				expansionDropdownRow.SetActive(true);
			}
			if (Object.op_Implicit((Object)(object)cardCountValue))
			{
				((Component)((TMP_Text)cardCountValue).transform.parent).gameObject.SetActive(true);
			}
			if (!Object.op_Implicit((Object)(object)expansionDropdown))
			{
				return;
			}
			expansionDropdown.ClearOptions();
			CardExpansionLibrary expansionLibrary = EplRuntimeData.Assets.CardExpansionLibrary;
			List<OptionData> list = ((IEnumerable<ECardExpansionType>)info.ExpansionTypes).Select((Func<ECardExpansionType, OptionData>)delegate(ECardExpansionType e)
			{
				//IL_0019: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Expected O, but got Unknown
				string text = ((object)(*(ECardExpansionType*)(&e))/*cast due to .constrained prefix*/).ToString();
				if (expansionLibrary.CardExpansionData.TryGetValue(e, out ModCardExpansionData value) && !string.IsNullOrWhiteSpace(value.Name))
				{
					text = value.Name;
				}
				return new OptionData(text);
			}).ToList();
			expansionDropdown.AddOptions(list);
			expansionDropdown.value = 0;
			UpdateCardCount();
		}

		private void UpdateCardCount()
		{
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			string selectedBundleId = GetSelectedBundleId();
			if (selectedBundleId == null || !EplRuntimeData.Assets.BundleRegistry.BundleInfo.TryGetValue(selectedBundleId, out BundleInfo value))
			{
				return;
			}
			if (!Object.op_Implicit((Object)(object)expansionDropdown) || value.ExpansionTypes.Count == 0)
			{
				SetValue(cardCountValue, "0");
				return;
			}
			int value2 = expansionDropdown.value;
			if (value2 < 0 || value2 >= value.ExpansionTypes.Count)
			{
				SetValue(cardCountValue, "0");
				return;
			}
			ECardExpansionType key = value.ExpansionTypes[value2];
			int num = 0;
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(key, out ModCardExpansionData value3))
			{
				num = value3.Cards.Count;
			}
			SetValue(cardCountValue, num.ToString());
		}

		private static void SetValue(TextMeshProUGUI? valueTmp, string value)
		{
			if (Object.op_Implicit((Object)(object)valueTmp))
			{
				((TMP_Text)valueTmp).text = value;
			}
		}
	}
	internal class SettingsDialog
	{
		private GameObject? dialogRoot;

		private Button? confirmButton;

		private Button? cancelButton;

		private GameObject? cancelButtonGroup;

		private TextMeshProUGUI? confirmLabel;

		private TextMeshProUGUI? messageText;

		private Action? onConfirm;

		internal void Build(SettingScreen settingsScreen)
		{
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e6: Expected O, but got Unknown
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Expected O, but got Unknown
			GameObject keybindChangesConfirmScreen = settingsScreen.m_KeybindChangesConfirmScreen;
			if (!Object.op_Implicit((Object)(object)keybindChangesConfirmScreen))
			{
				ModLogger.Warning("Keybind confirm screen not found on SettingScreen; EPL settings dialogs are unavailable", "Build", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Settings\\SettingsDialog.cs");
				return;
			}
			dialogRoot = Object.Instantiate<GameObject>(keybindChangesConfirmScreen, settingsScreen.m_ScreenGrp.transform);
			((Object)dialogRoot).name = "EplSettingsDialog";
			dialogRoot.SetActive(false);
			Localize[] componentsInChildren = dialogRoot.GetComponentsInChildren<Localize>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren[i]);
			}
			Button[] componentsInChildren2 = dialogRoot.GetComponentsInChildren<Button>(true);
			Button[] array = componentsInChildren2;
			foreach (Button button in array)
			{
				if (confirmButton == null && HasPersistentCall(button, "OnPressConfirmKeybindChange"))
				{
					confirmButton = button;
				}
				else if (cancelButton == null && HasPersistentCall(button, "OnPressCancelKeybindChange"))
				{
					cancelButton = button;
				}
			}
			if (confirmButton == null)
			{
				confirmButton = componentsInChildren2.FirstOrDefault();
			}
			if (cancelButton == null)
			{
				cancelButton = ((IEnumerable<Button>)componentsInChildren2).FirstOrDefault((Func<Button, bool>)((Button b) => (Object)(object)b != (Object)(object)confirmButton));
			}
			Transform confirmGroup = (Object.op_Implicit((Object)(object)confirmButton) ? ((Component)confirmButton).transform.parent : null);
			Transform cancelGroup = (Object.op_Implicit((Object)(object)cancelButton) ? ((Component)cancelButton).transform.parent : null);
			if (Object.op_Implicit((Object)(object)confirmButton))
			{
				confirmButton.onClick = new ButtonClickedEvent();
				((UnityEvent)confirmButton.onClick).AddListener(new UnityAction(OnConfirmPressed));
				confirmLabel = FindGroupLabel(confirmGroup);
				StripNonGraphicBehaviours(confirmLabel);
			}
			if (Object.op_Implicit((Object)(object)cancelButton))
			{
				cancelButton.onClick = new ButtonClickedEvent();
				((UnityEvent)cancelButton.onClick).AddListener(new UnityAction(OnCancelPressed));
				cancelButtonGroup = (Object.op_Implicit((Object)(object)cancelGroup) ? ((Component)cancelGroup).gameObject : null);
				TextMeshProUGUI? obj = FindGroupLabel(cancelGroup);
				StripNonGraphicBehaviours(obj);
				SetText(obj, "Cancel");
			}
			messageText = ((IEnumerable<TextMeshProUGUI>)dialogRoot.GetComponentsInChildren<TextMeshProUGUI>(true)).FirstOrDefault((Func<TextMeshProUGUI, bool>)((TextMeshProUGUI t) => ((Component)t).gameObject.activeSelf && (!Object.op_Implicit((Object)(object)confirmGroup) || !((TMP_Text)t).transform.IsChildOf(confirmGroup)) && (!Object.op_Implicit((Object)(object)cancelGroup) || !((TMP_Text)t).transform.IsChildOf(cancelGroup))));
			if (Object.op_Implicit((Object)(object)messageText))
			{
				StripNonGraphicBehaviours(messageText);
				((TMP_Text)messageText).enableWordWrapping = true;
				((TMP_Text)messageText).overflowMode = (TextOverflowModes)0;
			}
			if (!CanShow())
			{
				ModLogger.Warning("EPL settings dialog could not resolve its buttons or message text from the cloned confirm screen", "Build", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Settings\\SettingsDialog.cs");
			}
		}

		internal void ShowConfirm(string message, Action confirmAction)
		{
			if (!CanShow())
			{
				ModLogger.Error("EPL settings dialog unavailable; cannot confirm action. Message was: " + message, "ShowConfirm", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Settings\\SettingsDialog.cs");
				return;
			}
			onConfirm = confirmAction;
			SetText(messageText, message);
			SetText(confirmLabel, "Confirm");
			if (Object.op_Implicit((Object)(object)cancelButtonGroup))
			{
				cancelButtonGroup.SetActive(true);
			}
			dialogRoot.SetActive(true);
		}

		internal void ShowInfo(string message)
		{
			if (!CanShow())
			{
				ModLogger.Warning("EPL settings dialog unavailable; message was: " + message, "ShowInfo", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Settings\\SettingsDialog.cs");
				return;
			}
			onConfirm = null;
			SetText(messageText, message);
			SetText(confirmLabel, "OK");
			if (Object.op_Implicit((Object)(object)cancelButtonGroup))
			{
				cancelButtonGroup.SetActive(false);
			}
			dialogRoot.SetActive(true);
		}

		internal void Hide()
		{
			onConfirm = null;
			if (Object.op_Implicit((Object)(object)dialogRoot))
			{
				dialogRoot.SetActive(false);
			}
		}

		private void OnConfirmPressed()
		{
			SoundManager.GenericConfirm(1f, 1f);
			Action? action = onConfirm;
			Hide();
			action?.Invoke();
		}

		private void OnCancelPressed()
		{
			SoundManager.GenericConfirm(1f, 1f);
			Hide();
		}

		private bool CanShow()
		{
			if (Object.op_Implicit((Object)(object)dialogRoot) && Object.op_Implicit((Object)(object)confirmButton))
			{
				return Object.op_Implicit((Object)(object)messageText);
			}
			return false;
		}

		private static TextMeshProUGUI? FindGroupLabel(Transform? buttonGroup)
		{
			if (!Object.op_Implicit((Object)(object)buttonGroup))
			{
				return null;
			}
			return ((Component)buttonGroup).GetComponentInChildren<TextMeshProUGUI>(true);
		}

		private static void StripNonGraphicBehaviours(TextMeshProUGUI? label)
		{
			if (!Object.op_Implicit((Object)(object)label))
			{
				return;
			}
			MonoBehaviour[] components = ((Component)label).GetComponents<MonoBehaviour>();
			foreach (MonoBehaviour val in components)
			{
				if (!(val is Graphic))
				{
					Object.Destroy((Object)(object)val);
				}
			}
		}

		private static bool HasPersistentCall(Button button, string methodName)
		{
			for (int i = 0; i < ((UnityEventBase)button.onClick).GetPersistentEventCount(); i++)
			{
				if (((UnityEventBase)button.onClick).GetPersistentMethodName(i) == methodName)
				{
					return true;
				}
			}
			return false;
		}

		private static void SetText(TextMeshProUGUI? tmp, string text)
		{
			if (Object.op_Implicit((Object)(object)tmp))
			{
				((TMP_Text)tmp).text = text;
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Services
{
	internal class CardExpansionService : ICardExpansionService
	{
		public void SetCardPriceGenerator(ECardExpansionType expansionType, ICardPriceGenerator generator)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{expansionType} is not a registered card expansion.");
			}
			value.CardPriceGenerator = generator;
		}

		public void SetCardExpGenerator(ECardExpansionType expansionType, ICardExpGenerator generator)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{expansionType} is not a registered card expansion.");
			}
			value.CardExpGenerator = generator;
		}

		public void SetFoilChance(ECardExpansionType expansionType, float foilChance)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{expansionType} is not a registered card expansion.");
			}
			value.FoilChance = foilChance;
		}

		public float GenerateCardMarketPrice(ECardExpansionType cardExpansionType, EMonsterType monsterType, bool isFoil)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{cardExpansionType} is not a registered card expansion.");
			}
			if (!value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				throw new ArgumentException($"{monsterType} is not a registered card in expansion {cardExpansionType}.");
			}
			return value.CardPriceGenerator.GenerateCardMarketPrice(cardExpansionType, monsterType, value2.BorderType, value2.MonsterData.Rarity, value.Rarities, isFoil);
		}

		public float GenerateCardMarketPrice(CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{cardData.expansionType} is not a registered card expansion.");
			}
			if (!value.Cards.TryGetValue(cardData.monsterType, out ModCardData value2))
			{
				throw new ArgumentException($"{cardData.monsterType} is not a registered card in expansion {cardData.expansionType}.");
			}
			return value.CardPriceGenerator.GenerateCardMarketPrice(cardData.expansionType, cardData.monsterType, value2.BorderType, value2.MonsterData.Rarity, value.Rarities, cardData.isFoil);
		}

		public float GenerateCardExp(CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{cardData.expansionType} is not a registered card expansion.");
			}
			return value.CardExpGenerator.CalculateExp(cardData);
		}
	}
	internal class CardUIService : ICardUIService
	{
		private const string CardMaskTextureName = "CardMask";

		private readonly ConditionalWeakTable<CardUI, ModdedCardUI> moddedCardUIs = new ConditionalWeakTable<CardUI, ModdedCardUI>();

		private readonly Sprite? cardMask;

		internal CardUIService()
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			byte[] array = Resources.CardMask;
			if (array != null && array.Length != 0)
			{
				Texture2D val = new Texture2D(2, 2);
				ImageConversion.LoadImage(val, array);
				((Object)val).name = "CardMask";
				val.Apply(false, true);
				cardMask = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			}
		}

		internal void SetDirty(CardUI cardUI)
		{
			if (moddedCardUIs.TryGetValue(cardUI, out ModdedCardUI value))
			{
				value.IsDirty = true;
			}
		}

		internal void SetModdedCardUI(CardUI cardUI)
		{
			if (!moddedCardUIs.TryGetValue(cardUI, out ModdedCardUI _))
			{
				ModdedCardUI moddedCardUI = ((Component)cardUI).gameObject.AddComponent<ModdedCardUI>();
				moddedCardUI.Initialize(cardUI);
				moddedCardUIs.Add(cardUI, moddedCardUI);
			}
		}

		internal void ApplyCardUIChanges(CardUI cardUI, CardData cardData, ModCardExpansionData expansion)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			SetCardBack(cardUI, cardData, expansion);
			if (moddedCardUIs.TryGetValue(cardUI, out ModdedCardUI value))
			{
				StreamingAsset<Sprite> cardFoilMask = expansion.Cards[cardData.monsterType].FoilMask ?? expansion.FoilMask;
				value.ApplyModdedCardSpecs(cardMask, cardFoilMask);
				((Component)value).gameObject.SetActive(false);
				((Component)value).gameObject.SetActive(true);
			}
		}

		internal void RestoreOriginalState(CardUI cardUI, CardData cardData)
		{
			RestoreCardBack(cardUI);
			if (moddedCardUIs.TryGetValue(cardUI, out ModdedCardUI value))
			{
				value.RestoreDefaults(cardData);
			}
		}

		public void ApplyEplCardUI(CardUI cardUI, CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				throw new ArgumentException($"{cardData.expansionType} is not a registered EPL expansion.");
			}
			SetModdedCardUI(cardUI);
			ApplyCardUIChanges(cardUI, cardData, value);
		}

		public void RestoreOriginalCardUI(CardUI cardUI, CardData cardData)
		{
			RestoreOriginalState(cardUI, cardData);
		}

		private void SetCardBack(CardUI cardUI, CardData cardData, ModCardExpansionData expansion)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			Card3dUIGroup card3dUIGroup = cardUI.m_Card3dUIGroup;
			Renderer val = ((card3dUIGroup != null) ? card3dUIGroup.m_CardBackMesh.GetComponent<Renderer>() : null);
			if (val != null)
			{
				EplCaches caches = EplRuntimeData.Caches;
				Material originalMaterial = caches.OriginalCardBackMaterial ?? (caches.OriginalCardBackMaterial = val.sharedMaterial);
				ModCardData modCardData = expansion.Cards[cardData.monsterType];
				StreamingAsset<Texture> cardback = modCardData.Cardback ?? expansion.CardBack;
				string key = ((modCardData.Cardback == null) ? expansion.Name : $"{expansion.Name}_{modCardData.MonsterData.MonsterType}");
				Material orAdd = EplRuntimeData.Caches.CardBackMaterials.GetOrAdd<string, Material>(key, delegate
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					//IL_001c: Expected O, but got Unknown
					//IL_001c: Unknown result type (might be due to invalid IL or missing references)
					//IL_002d: Expected O, but got Unknown
					//IL_002e: Expected O, but got Unknown
					Material val2 = new Material(originalMaterial);
					StreamingAssetExtensions.SetTextureAsync(val2, "_BaseMap", cardback);
					StreamingAssetExtensions.SetTextureAsync(val2, "_EmissionMap", cardback);
					return val2;
				});
				val.material = orAdd;
			}
		}

		private void RestoreCardBack(CardUI cardUI)
		{
			Card3dUIGroup card3dUIGroup = cardUI.m_Card3dUIGroup;
			object obj;
			if (card3dUIGroup == null)
			{
				obj = null;
			}
			else
			{
				GameObject cardBackMesh = card3dUIGroup.m_CardBackMesh;
				obj = ((cardBackMesh != null) ? cardBackMesh.GetComponent<Renderer>() : null);
			}
			Renderer val = (Renderer)obj;
			if (val != null && EplRuntimeData.Caches.OriginalCardBackMaterial != null)
			{
				val.material = EplRuntimeData.Caches.OriginalCardBackMaterial;
			}
		}
	}
	internal class DecoService : IDecoService
	{
		public void SetLevelRequirement(EDecoObject decoObject, int level)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				throw new ArgumentException($"{decoObject} is not a registered decoration object.");
			}
			value.BasePurchaseData.levelRequirement = level;
		}

		public void SetPrice(EDecoObject decoObject, float price)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				throw new ArgumentException($"{decoObject} is not a registered decoration object.");
			}
			value.BasePurchaseData.price = price;
		}
	}
	internal class EplServices : IEplServices
	{
		IItemService IEplServices.ItemService => (IItemService)(object)ItemService;

		ICardExpansionService IEplServices.CardExpansionService => (ICardExpansionService)(object)CardExpansionService;

		ICardUIService IEplServices.CardUIService => (ICardUIService)(object)CardUIService;

		IMenuService IEplServices.MenuService => (IMenuService)(object)MenuService;

		IFurnitureService IEplServices.FurnitureService => (IFurnitureService)(object)FurnitureService;

		IDecoService IEplServices.DecoService => (IDecoService)(object)DecoService;

		IBundleMaintenanceService IEplServices.BundleMaintenanceService => (IBundleMaintenanceService)(object)BundleMaintenanceService;

		internal MenuService MenuService { get; private set; } = new MenuService();

		internal CardExpansionService CardExpansionService { get; private set; } = new CardExpansionService();

		internal ItemService ItemService { get; private set; } = new ItemService();

		internal SaveDataService SaveDataManager { get; private set; }

		internal BundleManager BundleManager { get; private set; }

		internal StreamingAssetService StreamingAssetService { get; private set; }

		internal ShopService ShopService { get; private set; }

		internal ShopInventoryManager ShopInventoryManager { get; private set; }

		internal CardUIService CardUIService { get; private set; }

		internal FurnitureService FurnitureService { get; private set; }

		internal DecoService DecoService { get; private set; }

		internal CollectionBinderService CollectionBinderService { get; private set; }

		internal CardExpansionSelectService CardExpansionSelectService { get; private set; }

		internal CardRaritySelectService CardRaritySelectService { get; private set; }

		internal WorkerPackOpenerScreenService WorkerPackOpenerScreenService { get; private set; }

		internal CardTradeManager CardTradeManager { get; private set; }

		internal PlayTableService PlayTableService { get; private set; }

		internal SettingsScreenService SettingsScreenService { get; private set; }

		internal BundleMaintenanceService BundleMaintenanceService { get; private set; }

		internal ScriptHookService ScriptHookService { get; private set; }

		internal PriceTagAtlasService PriceTagAtlasService { get; private set; }

		public EplServices(SaveDataService saveDataManager)
		{
			SaveDataManager = saveDataManager;
			BundleManager = new BundleManager();
			StreamingAssetService = new StreamingAssetService();
			ShopService = new ShopService();
			ShopInventoryManager = new ShopInventoryManager();
			CardUIService = new CardUIService();
			FurnitureService = new FurnitureService();
			DecoService = new DecoService();
			CollectionBinderService = new CollectionBinderService();
			CardExpansionSelectService = new CardExpansionSelectService();
			CardRaritySelectService = new CardRaritySelectService();
			WorkerPackOpenerScreenService = new WorkerPackOpenerScreenService();
			CardTradeManager = new CardTradeManager();
			PlayTableService = new PlayTableService();
			SettingsScreenService = new SettingsScreenService();
			BundleMaintenanceService = new BundleMaintenanceService();
			ScriptHookService = new ScriptHookService();
			PriceTagAtlasService = new PriceTagAtlasService();
			base..ctor();
		}
	}
	internal class FurnitureService : IFurnitureService
	{
		public void SetLevelRequirement(EObjectType objectType, int level)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value))
			{
				throw new ArgumentException($"{objectType} is not a registered furniture object.");
			}
			value.BaseFurniturePurchaseData.levelRequirement = level;
		}

		public void SetPrice(EObjectType objectType, float price)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value))
			{
				throw new ArgumentException($"{objectType} is not a registered furniture object.");
			}
			value.BaseFurniturePurchaseData.price = price;
		}
	}
	internal class ItemService : IItemService
	{
		public void SetPackGenerator(EItemType pack, IPackGenerator generator)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			value.PackGenerator = generator;
		}

		public void SetNormalGenerationWeight(EItemType pack, ERarity rarity, float weight)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			if (value.NormalGenerationWeights.Count != 0)
			{
				value.NormalGenerationWeights[rarity] = weight;
			}
		}

		public void SetGodGenerationWeight(EItemType pack, ERarity rarity, float weight)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			if (value.GodGenerationWeights.Count != 0)
			{
				value.GodGenerationWeights[rarity] = weight;
			}
		}

		public void SetSlotWeight(EItemType pack, PackSlot slot, ERarity rarity, float weight)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			if (value.PackSlotWeights.TryGetValue(slot, out Dictionary<ERarity, float> value2))
			{
				value2[rarity] = weight;
			}
		}

		public void SetItemPriceGenerator(string bundleId, IItemPriceGenerator generator)
		{
			EplRuntimeData.Assets.ItemLibrary.ItemPriceGenerators[bundleId] = generator;
		}

		public List<CardData> GeneratePackContent(EItemType pack)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: 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_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0255: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"Type {pack} is not a valid pack.");
			}
			bool flag = value.CanHaveGodPack && Random.value < value.GodPackPercentage;
			EplRuntimeData.Events.ItemEvents.FireBeforePackGenerated(new PackGenerationEventArgs
			{
				Pack = pack,
				IsGodPack = flag,
				NormalWeights = ((value.NormalGenerationWeights.Count > 0) ? value.NormalGenerationWeights : null),
				GodWeights = ((value.GodGenerationWeights.Count > 0) ? value.GodGenerationWeights : null),
				SlotWeights = ((value.PackSlotWeights.Count > 0) ? value.PackSlotWeights : null)
			});
			IPackGenerator val = (flag ? value.GodPackGenerator : value.PackGenerator);
			if (val == null)
			{
				ModLogger.Error($"Pack {pack} has no pack generator assigned. API managed packs need a generator set via SetPackGenerator. Falling back to all random generation.", "GeneratePackContent", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\ItemService.cs");
				val = PackGeneratorFactory.For(PackGenerationStrategy.AllRandom, value);
			}
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(value.Expansion, out ModCardExpansionData value2))
			{
				throw new InvalidOperationException($"Unable to find expansion data for {value.Expansion}");
			}
			List<MonsterData> list = value2.MonsterDataList.ToList();
			List<MonsterData> list2 = val.GeneratePack(value.Expansion, list, value2.HasRandomFoils);
			EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(value.Expansion, out CardExpansionSaveData data);
			List<CardData> list3 = new List<CardData>();
			foreach (MonsterData item in list2)
			{
				CardData val2 = value2.Cards[item.MonsterType].ToCardData();
				if (value2.HasRandomFoils)
				{
					val2.isFoil = flag || Random.value < value2.FoilChance;
				}
				if (data != null)
				{
					int num = item.MonsterType - 1;
					if (value2.HasRandomFoils)
					{
						num = num * 2 + (val2.isFoil ? 1 : 0);
					}
					val2.isNew = data.CardCountList[num] == 0;
				}
				list3.Add(val2);
			}
			EplRuntimeData.Events.ItemEvents.FireAfterPackGenerated(new PackGeneratedEventArgs
			{
				Pack = pack,
				IsGodPack = flag,
				Cards = list3
			});
			return list3;
		}

		public float GenerateItemCost(EItemType itemType)
		{
			//IL_0000: 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_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			ItemData itemData = InventoryBase.GetItemData(itemType);
			string bundleIdFor = EplRuntimeData.Assets.BundleRegistry.GetBundleIdFor<EItemType>(itemType);
			if (bundleIdFor != null && EplRuntimeData.Assets.ItemLibrary.ItemPriceGenerators.TryGetValue(bundleIdFor, out IItemPriceGenerator value))
			{
				return value.GenerateItemCost(itemType, itemData.baseCost);
			}
			if ((int)itemData.boxFollowItemPrice == -1)
			{
				return itemData.baseCost * Mathf.Clamp(Random.Range(0.9f, 1.3f), 1f, 1.3f);
			}
			return CPlayerData.GetItemCost(itemData.boxFollowItemPrice) * 8f * Mathf.Clamp(Random.Range(0.9f, 1.2f), 1f, 1.15f);
		}

		public float GenerateItemMarketPrice(EItemType itemType, float costPrice, float minMarkup, float maxMarkup)
		{
			//IL_0000: 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_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Invalid comparison between Unknown and I4
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			ItemData itemData = InventoryBase.GetItemData(itemType);
			string bundleIdFor = EplRuntimeData.Assets.BundleRegistry.GetBundleIdFor<EItemType>(itemType);
			if (bundleIdFor != null && EplRuntimeData.Assets.ItemLibrary.ItemPriceGenerators.TryGetValue(bundleIdFor, out IItemPriceGenerator value))
			{
				return value.GenerateItemMarketPrice(itemType, itemData.baseCost, minMarkup, maxMarkup);
			}
			if ((int)itemData.boxFollowItemPrice == -1)
			{
				return costPrice * Random.Range(minMarkup, maxMarkup);
			}
			return CPlayerData.GetItemMarketPrice(itemData.boxFollowItemPrice) * 8f * Random.Range(minMarkup, maxMarkup);
		}

		internal float GenerateItemMarketPrice(int index, float costPrice)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			EItemType val = ItemTypeResolver.Resolve(index);
			ItemData itemData = InventoryBase.GetItemData(val);
			float num = itemData.marketPriceMinPercent;
			float maxMarkup = itemData.marketPriceMaxPercent;
			if (num == 0f)
			{
				num = 1.5f;
				maxMarkup = 3f;
			}
			return GenerateItemMarketPrice(val, costPrice, num, maxMarkup);
		}

		public void SetGodPackPercentage(EItemType pack, float percentage)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			value.GodPackPercentage = percentage;
		}

		public void SetGodPack(EItemType pack, bool enabled, float percentage)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			value.CanHaveGodPack = enabled;
			value.GodPackPercentage = percentage;
		}

		public void SetCanHaveGodPacks(EItemType pack, bool enabled)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			value.CanHaveGodPack = enabled;
		}

		public void SetFollowItemPrice(EItemType itemType, EItemType sourceItemType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			ItemData itemData = InventoryBase.GetItemData(itemType);
			ItemData itemData2 = InventoryBase.GetItemData(sourceItemType);
			itemData.baseCost = itemData2.baseCost;
			itemData.marketPriceMinPercent = itemData2.marketPriceMinPercent;
			itemData.marketPriceMaxPercent = itemData2.marketPriceMaxPercent;
		}

		public void SetMarketPricePercent(EItemType itemType, float min, float max)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			ItemData itemData = InventoryBase.GetItemData(itemType);
			itemData.marketPriceMinPercent = min;
			itemData.marketPriceMaxPercent = max;
		}

		public void SetAutoBoxPrice(EItemType itemType, EItemType followItemType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			InventoryBase.GetItemData(itemType).boxFollowItemPrice = followItemType;
		}

		public void SetLicensePrice(EItemType itemType, bool isBigBox, float price)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			foreach (ModRestockData restockEntry in EplRuntimeData.Assets.ItemLibrary.RestockEntries)
			{
				if (restockEntry.RestockData.itemType == itemType && restockEntry.RestockData.isBigBox == isBigBox)
				{
					restockEntry.RestockData.licensePrice = price;
					break;
				}
			}
		}

		public void SetLicenseLevel(EItemType itemType, bool isBigBox, int level)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			foreach (ModRestockData restockEntry in EplRuntimeData.Assets.ItemLibrary.RestockEntries)
			{
				if (restockEntry.RestockData.itemType == itemType && restockEntry.RestockData.isBigBox == isBigBox)
				{
					restockEntry.RestockData.licenseShopLevelRequired = level;
					break;
				}
			}
		}

		internal float GenerateItemCost(int index)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			EItemType itemType = ItemTypeResolver.Resolve(index);
			return GenerateItemCost(itemType);
		}
	}
	internal class MenuService : IMenuService
	{
		internal List<NestedMenu.MenuEntry> GenericExpansionEntries { get; } = new List<NestedMenu.MenuEntry>();

		internal List<NestedMenu.MenuEntry> BinderExpansionEntries { get; } = new List<NestedMenu.MenuEntry>();

		public void AddGenericExpansionButton(string label, Action onClick)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			GenericExpansionEntries.Add(new NestedMenu.MenuEntry
			{
				Label = label,
				OnClick = (UnityAction)delegate
				{
					onClick();
				}
			});
		}

		public void AddBinderExpansionButton(string label, Action onClick)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Expected O, but got Unknown
			BinderExpansionEntries.Add(new NestedMenu.MenuEntry
			{
				Label = label,
				OnClick = (UnityAction)delegate
				{
					onClick();
				}
			});
		}
	}
}
namespace EnhancedPrefabLoader.Core.Services.Internal
{
	internal class BundleMaintenanceService : IBundleMaintenanceService
	{
		private const string UninstalledToastText = "Uninstalled - restart the game to remove it from the shop";

		private const float ToastCooldownSeconds = 2f;

		private readonly HashSet<string> uninstalledBundleIds = new HashSet<string>();

		private float lastToastTime = float.NegativeInfinity;

		public bool IsUninstalled(string bundleId)
		{
			return uninstalledBundleIds.Contains(bundleId);
		}

		internal bool TryBlockPurchase(EItemType itemType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return TryBlockPurchaseFor(EplRuntimeData.BundleAssetTracker.GetBundleIdFor<EItemType>(itemType));
		}

		internal bool TryBlockPurchase(EObjectType objectType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return TryBlockPurchaseFor(EplRuntimeData.BundleAssetTracker.GetBundleIdFor<EObjectType>(objectType));
		}

		internal bool TryBlockPurchase(EDecoObject decoObject)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			return TryBlockPurchaseFor(EplRuntimeData.BundleAssetTracker.GetBundleIdFor<EDecoObject>(decoObject));
		}

		internal bool TryBlockPurchase(string category, string assetName)
		{
			return TryBlockPurchaseFor(EplRuntimeData.BundleAssetTracker.GetBundleIdFor(category, assetName));
		}

		internal unsafe bool TryBlockTexturePurchase(int categoryIndex, int shopDecoIndex)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
			ShelfData_ScriptableObject objectData_SO = CSingleton<InventoryBase>.Instance.m_ObjectData_SO;
			int? num;
			List<ShopDecoData> list;
			DecoFlags val;
			switch (categoryIndex)
			{
			case 0:
				num = decoLibrary.firstInsertedWallTexture;
				list = objectData_SO.m_WallDecoDataList;
				val = (DecoFlags)2;
				break;
			case 1:
				num = decoLibrary.firstInsertedFloorTexture;
				list = objectData_SO.m_FloorDecoDataList;
				val = (DecoFlags)1;
				break;
			case 2:
				num = decoLibrary.firstInsertedCeilingTexture;
				list = objectData_SO.m_CeilingDecoDataList;
				val = (DecoFlags)3;
				break;
			default:
				return false;
			}
			if (!num.HasValue || shopDecoIndex < num.Value || shopDecoIndex >= list.Count)
			{
				return false;
			}
			return TryBlockPurchase(((object)(*(DecoFlags*)(&val))/*cast due to .constrained prefix*/).ToString(), list[shopDecoIndex].name);
		}

		public bool ResetPrices(string bundleId)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			BundleAssetTracker bundleAssetTracker = EplRuntimeData.BundleAssetTracker;
			SaveDataService saveDataManager = EplRuntimeData.Services.SaveDataManager;
			int num = 0;
			foreach (EItemType item in bundleAssetTracker.GetEnumValuesForBundle<EItemType>(bundleId))
			{
				if (saveDataManager.TryGetSaveData<EItemType, ItemSaveData>(item, out ItemSaveData data))
				{
					IPriceResettable priceResettable = data;
					if (priceResettable != null)
					{
						priceResettable.ResetPrices();
						num++;
					}
				}
			}
			foreach (ECardExpansionType item2 in bundleAssetTracker.GetEnumValuesForBundle<ECardExpansionType>(bundleId))
			{
				if (saveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(item2, out CardExpansionSaveData data2))
				{
					IPriceResettable priceResettable2 = data2;
					if (priceResettable2 != null)
					{
						priceResettable2.ResetPrices();
						num++;
					}
				}
			}
			if (num > 0)
			{
				RestockManager instance = CSingleton<RestockManager>.Instance;
				if (Object.op_Implicit((Object)(object)instance))
				{
					instance.Init();
					ModLogger.Info($"Reset prices for {num} assets in bundle '{bundleId}'", "ResetPrices", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\BundleMaintenanceService.cs");
				}
				else
				{
					ModLogger.Info($"Reset prices for {num} assets in bundle '{bundleId}' — new prices will generate on next game load", "ResetPrices", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\BundleMaintenanceService.cs");
				}
			}
			return num > 0;
		}

		internal RemovalResult UninstallBundle(string bundleId)
		{
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Expected O, but got Unknown
			if (!CanCurrentlyUninstall())
			{
				return RemovalResult.Failure("Cannot uninstall until end of day or while pack openers are running.");
			}
			BundleAssetTracker bundleAssetTracker = EplRuntimeData.BundleAssetTracker;
			HashSet<ECardExpansionType> enumValuesForBundle = bundleAssetTracker.GetEnumValuesForBundle<ECardExpansionType>(bundleId);
			HashSet<EItemType> enumValuesForBundle2 = bundleAssetTracker.GetEnumValuesForBundle<EItemType>(bundleId);
			HashSet<EObjectType> enumValuesForBundle3 = bundleAssetTracker.GetEnumValuesForBundle<EObjectType>(bundleId);
			HashSet<EDecoObject> enumValuesForBundle4 = bundleAssetTracker.GetEnumValuesForBundle<EDecoObject>(bundleId);
			List<IAssetRemovalStrategy> obj = new List<IAssetRemovalStrategy>(6)
			{
				new CardRemovalStrategy(enumValuesForBundle),
				new ItemRemovalStrategy(enumValuesForBundle2),
				new TournamentRemovalStrategy(enumValuesForBundle, enumValuesForBundle2),
				new CustomerRemovalStrategy(enumValuesForBundle, enumValuesForBundle2),
				new DecoRemovalStrategy(enumValuesForBundle4, bundleId),
				new InteractableObjectRemovalStrategy(enumValuesForBundle3, enumValuesForBundle4)
			};
			RemovalResult removalResult = RemovalResult.Empty();
			foreach (IAssetRemovalStrategy item in obj)
			{
				try
				{
					removalResult.Merge(item.RemoveAssets());
				}
				catch (Exception ex)
				{
					ModLogger.Error("Error during uninstall strategy " + item.GetType().Name + ": " + ex.Message, "UninstallBundle", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\BundleMaintenanceService.cs");
					removalResult.Merge(RemovalResult.Failure(ex.Message));
				}
			}
			CleanupPackageBoxSaveData(enumValuesForBundle2);
			ResetExpansionSelections(enumValuesForBundle);
			if (removalResult.IsSuccess)
			{
				EplRuntimeData.Services.SaveDataManager.PurgeBundleSaveData(bundleId);
				uninstalledBundleIds.Add(bundleId);
				CEventManager.QueueEvent((CEvent)new CEventPlayer_AddCoin(removalResult.TotalValue / 2f, false));
				ModLogger.Info($"Uninstalled bundle '{bundleId}': removed {removalResult.AssetsRemoved} assets, refunded {removalResult.TotalValue / 2f:F2} coins", "UninstallBundle", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\BundleMaintenanceService.cs");
				EplRuntimeData.Events.BundleEvents.FireBundleUninstalled(bundleId);
			}
			return removalResult;
		}

		private bool TryBlockPurchaseFor(string? bundleId)
		{
			if (bundleId == null || !uninstalledBundleIds.Contains(bundleId))
			{
				return false;
			}
			ShowUninstalledToast();
			return true;
		}

		private void ShowUninstalledToast()
		{
			NotEnoughResourceTextPopup instance = CSingleton<NotEnoughResourceTextPopup>.Instance;
			if (Object.op_Implicit((Object)(object)instance) && !(Time.time - lastToastTime < 2f))
			{
				lastToastTime = Time.time;
				instance.ShowRawText("Uninstalled - restart the game to remove it from the shop");
			}
		}

		private static void CleanupPackageBoxSaveData(HashSet<EItemType> itemTypes)
		{
			CPlayerData.m_PackageBoxItemSaveDataList.RemoveAll((PackageBoxItemaveData box) => itemTypes.Contains(box.itemTypeAmount.itemType));
		}

		private static void ResetExpansionSelections(HashSet<ECardExpansionType> expansions)
		{
			//IL_0001: 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_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			if (expansions.Contains(CPlayerData.m_QuickFillCardExpansionType))
			{
				CPlayerData.m_QuickFillCardExpansionType = (ECardExpansionType)0;
			}
			if (expansions.Contains(CPlayerData.m_DonationQuickFillCardExpansionType))
			{
				CPlayerData.m_DonationQuickFillCardExpansionType = (ECardExpansionType)0;
			}
			if (expansions.Contains(CPlayerData.m_WorkbenchCardExpansionType))
			{
				CPlayerData.m_WorkbenchCardExpansionType = (ECardExpansionType)0;
			}
		}

		private bool CanCurrentlyUninstall()
		{
			bool num = CSingleton<ShelfManager>.Instance.m_AutoPackOpenerList.Any((InteractableAutoPackOpener p) => p.m_IsProcessing);
			bool flag = CSingleton<LightManager>.Instance.m_TimeHour >= 21;
			return !num && flag;
		}
	}
	internal class CardExpansionSelectService
	{
		private CardExpansionSelectScreen? screen;

		private FlowLayoutGroup? flowLayoutGroup;

		private NestedMenu? nestedMenuController;

		private Transform? cloneableButton;

		private bool isLoaded;

		private bool hasSubscribedToSettings;

		internal bool IsLoaded
		{
			get
			{
				return isLoaded;
			}
			set
			{
				isLoaded = value;
				if (!value)
				{
					screen = null;
					flowLayoutGroup = null;
					nestedMenuController = null;
				}
			}
		}

		internal void OpenScreen()
		{
			if (!Object.op_Implicit((Object)(object)screen))
			{
				screen = CSingleton<CardExpansionSelectScreen>.Instance;
			}
			if (!Object.op_Implicit((Object)(object)flowLayoutGroup))
			{
				flowLayoutGroup = InitFlowLayoutGroup();
			}
			if (!Object.op_Implicit((Object)(object)nestedMenuController))
			{
				nestedMenuController = ((Component)flowLayoutGroup).gameObject.AddComponent<NestedMenu>()?.Setup(flowLayoutGroup, cloneableButton);
			}
			ControllerScreenUIExtension component = ((Component)screen).GetComponent<ControllerScreenUIExtension>();
			if (Object.op_Implicit((Object)(object)nestedMenuController))
			{
				nestedMenuController.OnOpen(PopulateMainMenu(), component);
			}
		}

		private FlowLayoutGroup InitFlowLayoutGroup()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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)
			//IL_00ac: 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)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_013f: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = screen.m_ScreenGrp.transform.Find("AnimGrp/Mask/UIGroup");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			Transform val2 = ((Transform)val).Find("Tetramon_Button");
			if (val2 != null)
			{
				((Component)val2).transform.SetParent((Transform)null);
				((Component)val2).gameObject.SetActive(false);
				cloneableButton = val2;
			}
			GameObject val3 = FlowLayoutGroup.Create(((Transform)val).parent, isScrollable: true);
			flowLayoutGroup = val3.GetComponentInChildren<FlowLayoutGroup>(true);
			RectTransform component = val3.GetComponent<RectTransform>();
			((Transform)component).SetSiblingIndex(((Transform)val).GetSiblingIndex());
			component.anchorMin = val.anchorMin;
			component.anchorMax = val.anchorMax;
			component.pivot = val.pivot;
			component.anchoredPosition = val.anchoredPosition;
			component.sizeDelta = val.sizeDelta;
			((Transform)component).localScale = ((Transform)val).localScale;
			component.offsetMin = val.offsetMin;
			component.offsetMax = val.offsetMax;
			Object.Destroy((Object)(object)((Component)val).gameObject);
			Vector2 value = EplRuntimeData.Config.CardExpansionSelectButtonSizeEntry.Value;
			flowLayoutGroup.SpacingX = EplRuntimeData.Config.CardExpansionSelectSpacingXEntry.Value;
			flowLayoutGroup.SpacingY = EplRuntimeData.Config.CardExpansionSelectSpacingYEntry.Value;
			flowLayoutGroup.ChildWidth = value.x;
			flowLayoutGroup.ChildHeight = value.y;
			if (hasSubscribedToSettings)
			{
				return flowLayoutGroup;
			}
			hasSubscribedToSettings = true;
			EplRuntimeData.Config.CardExpansionSelectSpacingXEntry.SettingChanged += delegate
			{
				if (flowLayoutGroup != null)
				{
					flowLayoutGroup.SpacingX = EplRuntimeData.Config.CardExpansionSelectSpacingXEntry.Value;
				}
			};
			EplRuntimeData.Config.CardExpansionSelectSpacingYEntry.SettingChanged += delegate
			{
				if (flowLayoutGroup != null)
				{
					flowLayoutGroup.SpacingY = EplRuntimeData.Config.CardExpansionSelectSpacingYEntry.Value;
				}
			};
			EplRuntimeData.Config.CardExpansionSelectButtonSizeEntry.SettingChanged += delegate
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if (flowLayoutGroup != null)
				{
					Vector2 value2 = EplRuntimeData.Config.CardExpansionSelectButtonSizeEntry.Value;
					flowLayoutGroup.ChildWidth = value2.x;
					flowLayoutGroup.ChildHeight = value2.y;
				}
			};
			return flowLayoutGroup;
		}

		private List<NestedMenu.MenuEntry> PopulateMainMenu()
		{
			List<NestedMenu.MenuEntry> list = CardExpansionLibrary.BaseExpansionTypes.Select((ECardExpansionType expansion) => new NestedMenu.MenuEntry
			{
				Label = InventoryBase.GetCardExpansionName(expansion),
				OnClick = (UnityAction)delegate
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Expected I4, but got Unknown
					CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)expansion);
				}
			}).ToList();
			IEnumerable<NestedMenu.MenuEntry> collection = (from kvp in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData
				group kvp by kvp.Value.MenuCategory into @group
				select (!string.IsNullOrWhiteSpace(@group.Key)) ? new <>z__ReadOnlySingleElementList<NestedMenu.MenuEntry>(new NestedMenu.MenuEntry
				{
					Label = @group.Key,
					SubMenu = @group.Select((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => new NestedMenu.MenuEntry
					{
						Label = kvp.Value.Name,
						OnClick = (UnityAction)delegate
						{
							//IL_000b: Unknown result type (might be due to invalid IL or missing references)
							//IL_0015: Expected I4, but got Unknown
							CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)kvp.Key);
						}
					}).ToList()
				}) : @group.Select((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => new NestedMenu.MenuEntry
				{
					Label = kvp.Value.Name,
					OnClick = (UnityAction)delegate
					{
						//IL_000b: Unknown result type (might be due to invalid IL or missing references)
						//IL_0015: Expected I4, but got Unknown
						CSingleton<CardExpansionSelectScreen>.Instance.OnPressButton((int)kvp.Key);
					}
				})).SelectMany((IEnumerable<NestedMenu.MenuEntry> x) => x);
			list.AddRange(collection);
			list.AddRange(EplRuntimeData.Services.MenuService.GenericExpansionEntries);
			return list;
		}
	}
	internal class CardRaritySelectService
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static UnityAction <>9__11_1;

			public static UnityAction <>9__11_2;

			public static UnityAction <>9__11_3;

			public static UnityAction <>9__11_4;

			public static UnityAction <>9__11_5;

			public static Func<ERarity, NestedMenu.MenuEntry> <>9__11_0;

			internal void <PopulateMainMenu>b__11_1()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(-1);
			}

			internal void <PopulateMainMenu>b__11_2()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(0);
			}

			internal void <PopulateMainMenu>b__11_3()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(1);
			}

			internal void <PopulateMainMenu>b__11_4()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(2);
			}

			internal void <PopulateMainMenu>b__11_5()
			{
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(3);
			}

			internal NestedMenu.MenuEntry <PopulateMainMenu>b__11_0(ERarity r)
			{
				//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_0036: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				<>c__DisplayClass11_0 CS$<>8__locals2 = new <>c__DisplayClass11_0
				{
					r = r
				};
				return new NestedMenu.MenuEntry
				{
					Label = StringExtensions.Prettierize(((object)Unsafe.As<ERarity, ERarity>(ref CS$<>8__locals2.r)/*cast due to .constrained prefix*/).ToString()),
					OnClick = (UnityAction)delegate
					{
						//IL_0006: Unknown result type (might be due to invalid IL or missing references)
						//IL_0010: Expected I4, but got Unknown
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton((int)CS$<>8__locals2.r);
					}
				};
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass11_0
		{
			public ERarity r;

			internal void <PopulateMainMenu>b__6()
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_0010: Expected I4, but got Unknown
				CSingleton<CardRaritySelectScreen>.Instance.OnPressButton((int)r);
			}
		}

		private CardRaritySelectScreen? screen;

		private FlowLayoutGroup? flowLayoutGroup;

		private NestedMenu? nestedMenuController;

		private Transform? cloneableButton;

		private bool isLoaded;

		private bool hasSubscribedToSettings;

		internal bool IsLoaded
		{
			get
			{
				return isLoaded;
			}
			set
			{
				isLoaded = value;
				if (!value)
				{
					screen = null;
					flowLayoutGroup = null;
					nestedMenuController = null;
				}
			}
		}

		internal void OpenScreen(ECardExpansionType expansionType)
		{
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			if (!Object.op_Implicit((Object)(object)screen))
			{
				screen = CSingleton<CardRaritySelectScreen>.Instance;
			}
			if (!Object.op_Implicit((Object)(object)flowLayoutGroup))
			{
				flowLayoutGroup = InitFlowLayoutGroup();
			}
			if (!Object.op_Implicit((Object)(object)nestedMenuController))
			{
				nestedMenuController = ((Component)flowLayoutGroup).gameObject.AddComponent<NestedMenu>()?.Setup(flowLayoutGroup, cloneableButton);
			}
			ControllerScreenUIExtension component = ((Component)screen).GetComponent<ControllerScreenUIExtension>();
			if (Object.op_Implicit((Object)(object)nestedMenuController))
			{
				nestedMenuController.OnOpen(PopulateMainMenu(expansionType), component);
			}
		}

		private FlowLayoutGroup InitFlowLayoutGroup()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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)
			//IL_00ac: 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)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_013f: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = screen.m_ScreenGrp.transform.Find("AnimGrp/Mask/UIGroup");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			Transform val2 = ((Transform)val).Find("AnyRarity_Button");
			if (val2 != null)
			{
				((Component)val2).transform.SetParent((Transform)null);
				((Component)val2).gameObject.SetActive(false);
				cloneableButton = val2;
			}
			GameObject val3 = FlowLayoutGroup.Create(((Transform)val).parent, isScrollable: true);
			flowLayoutGroup = val3.GetComponentInChildren<FlowLayoutGroup>(true);
			RectTransform component = val3.GetComponent<RectTransform>();
			((Transform)component).SetSiblingIndex(((Transform)val).GetSiblingIndex());
			component.anchorMin = val.anchorMin;
			component.anchorMax = val.anchorMax;
			component.pivot = val.pivot;
			component.anchoredPosition = val.anchoredPosition;
			component.sizeDelta = val.sizeDelta;
			((Transform)component).localScale = ((Transform)val).localScale;
			component.offsetMin = val.offsetMin;
			component.offsetMax = val.offsetMax;
			Object.Destroy((Object)(object)((Component)val).gameObject);
			Vector2 value = EplRuntimeData.Config.RaritySelectButtonSizeEntry.Value;
			flowLayoutGroup.SpacingX = EplRuntimeData.Config.RaritySelectSpacingXEntry.Value;
			flowLayoutGroup.SpacingY = EplRuntimeData.Config.RaritySelectSpacingYEntry.Value;
			flowLayoutGroup.ChildWidth = value.x;
			flowLayoutGroup.ChildHeight = value.y;
			if (hasSubscribedToSettings)
			{
				return flowLayoutGroup;
			}
			hasSubscribedToSettings = true;
			EplRuntimeData.Config.RaritySelectSpacingXEntry.SettingChanged += delegate
			{
				FlowLayoutGroup? obj2 = flowLayoutGroup;
				if (obj2 != null)
				{
					obj2.SpacingX = EplRuntimeData.Config.RaritySelectSpacingXEntry.Value;
				}
			};
			EplRuntimeData.Config.RaritySelectSpacingYEntry.SettingChanged += delegate
			{
				FlowLayoutGroup? obj2 = flowLayoutGroup;
				if (obj2 != null)
				{
					obj2.SpacingY = EplRuntimeData.Config.RaritySelectSpacingYEntry.Value;
				}
			};
			EplRuntimeData.Config.RaritySelectButtonSizeEntry.SettingChanged += delegate
			{
				//IL_0012: Unknown result type (might be due to invalid IL or missing references)
				//IL_0017: Unknown result type (might be due to invalid IL or missing references)
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_002f: Unknown result type (might be due to invalid IL or missing references)
				if (flowLayoutGroup != null)
				{
					Vector2 value2 = EplRuntimeData.Config.RaritySelectButtonSizeEntry.Value;
					flowLayoutGroup.ChildWidth = value2.x;
					flowLayoutGroup.ChildHeight = value2.y;
				}
			};
			return flowLayoutGroup;
		}

		private unsafe List<NestedMenu.MenuEntry> PopulateMainMenu(ECardExpansionType expansionType)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			List<NestedMenu.MenuEntry> list = new List<NestedMenu.MenuEntry>();
			NestedMenu.MenuEntry obj = new NestedMenu.MenuEntry
			{
				Label = "Any Rarity"
			};
			object obj2 = <>c.<>9__11_1;
			if (obj2 == null)
			{
				UnityAction val = delegate
				{
					CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(-1);
				};
				<>c.<>9__11_1 = val;
				obj2 = (object)val;
			}
			obj.OnClick = (UnityAction)obj2;
			list.Add(obj);
			List<NestedMenu.MenuEntry> list2 = list;
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				NestedMenu.MenuEntry[] array = new NestedMenu.MenuEntry[4];
				NestedMenu.MenuEntry obj3 = new NestedMenu.MenuEntry
				{
					Label = "Common"
				};
				object obj4 = <>c.<>9__11_2;
				if (obj4 == null)
				{
					UnityAction val2 = delegate
					{
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(0);
					};
					<>c.<>9__11_2 = val2;
					obj4 = (object)val2;
				}
				obj3.OnClick = (UnityAction)obj4;
				array[0] = obj3;
				NestedMenu.MenuEntry obj5 = new NestedMenu.MenuEntry
				{
					Label = "Rare"
				};
				object obj6 = <>c.<>9__11_3;
				if (obj6 == null)
				{
					UnityAction val3 = delegate
					{
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(1);
					};
					<>c.<>9__11_3 = val3;
					obj6 = (object)val3;
				}
				obj5.OnClick = (UnityAction)obj6;
				array[1] = obj5;
				NestedMenu.MenuEntry obj7 = new NestedMenu.MenuEntry
				{
					Label = "Epic"
				};
				object obj8 = <>c.<>9__11_4;
				if (obj8 == null)
				{
					UnityAction val4 = delegate
					{
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(2);
					};
					<>c.<>9__11_4 = val4;
					obj8 = (object)val4;
				}
				obj7.OnClick = (UnityAction)obj8;
				array[2] = obj7;
				NestedMenu.MenuEntry obj9 = new NestedMenu.MenuEntry
				{
					Label = "Legendary"
				};
				object obj10 = <>c.<>9__11_5;
				if (obj10 == null)
				{
					UnityAction val5 = delegate
					{
						CSingleton<CardRaritySelectScreen>.Instance.OnPressButton(3);
					};
					<>c.<>9__11_5 = val5;
					obj10 = (object)val5;
				}
				obj9.OnClick = (UnityAction)obj10;
				array[3] = obj9;
				list2.AddRange(new <>z__ReadOnlyArray<NestedMenu.MenuEntry>(array));
				return list2;
			}
			list2.AddRange(value.Rarities.Select((ERarity r) => new NestedMenu.MenuEntry
			{
				Label = StringExtensions.Prettierize(((object)(*(ERarity*)(&r))/*cast due to .constrained prefix*/).ToString()),
				OnClick = (UnityAction)delegate
				{
					//IL_0006: Unknown result type (might be due to invalid IL or missing references)
					//IL_0010: Expected I4, but got Unknown
					CSingleton<CardRaritySelectScreen>.Instance.OnPressButton((int)r);
				}
			}));
			return list2;
		}
	}
	internal class CardSelectionService
	{
		private static readonly (EItemType pack, int foil, int grade)[] PackBonuses = new(EItemType, int, int)[7]
		{
			((EItemType)2, 0, 2),
			((EItemType)4, 0, 2),
			((EItemType)6, 1, 2),
			((EItemType)8, 1, 2),
			((EItemType)10, 1, 2),
			((EItemType)12, 1, 2),
			((EItemType)14, 1, 3)
		};

		public CardData SelectRandomCard()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Invalid comparison between Unknown and I4
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: 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)
			//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)
			//IL_00e5: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Invalid comparison between Unknown and I4
			ECardExpansionType weightedRandom = CalculateExpansionWeights().GetWeightedRandom();
			(int foil, int grade) tuple = PackBonuses.Where(((EItemType pack, int foil, int grade) b) => CPlayerData.m_ShopLevel >= InventoryBase.GetUnlockItemLevelRequired(b.pack)).Aggregate((0, 0), ((int foil, int grade) acc, (EItemType pack, int foil, int grade) b) => (foil: acc.foil + b.foil, grade: acc.grade + b.grade));
			int item = tuple.foil;
			int item2 = tuple.grade;
			int num = InventoryBase.GetShownMonsterList(weightedRandom).Count * CPlayerData.GetCardAmountPerMonsterType(weightedRandom, true);
			int num2 = Random.Range(0, num);
			bool flag = (int)weightedRandom == 2 && Random.Range(0, 100) < 50;
			CardData val = ((Random.Range(0, 100) < item2) ? CPlayerData.GetGradedCardData(new CompactCardDataAmount
			{
				cardSaveIndex = num2,
				expansionType = weightedRandom,
				isDestiny = flag,
				amount = Random.Range(1, 11)
			}) : CPlayerData.GetCardData(num2, weightedRandom, flag));
			if ((int)weightedRandom == 2)
			{
				val.isFoil = Random.Range(0, 100) < item;
			}
			return val;
		}

		public CardData? SelectPlayerCard(CardData targetCard, CustomerTradeData customerTradeData)
		{
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			int num = 4;
			float cardMarketPrice = CPlayerData.GetCardMarketPrice(targetCard);
			Dictionary<ECardExpansionType, float> dictionary = CalculateExpansionWeights();
			if (dictionary.ContainsKey(targetCard.expansionType))
			{
				dictionary[targetCard.expansionType] *= 3f;
				if ((int)targetCard.expansionType == 2)
				{
					dictionary[targetCard.expansionType] *= 4f;
				}
			}
			for (int i = 0; i < num; i++)
			{
				if (dictionary.Count <= 0)
				{
					break;
				}
				ECardExpansionType weightedRandom = dictionary.GetWeightedRandom();
				CardData val = TryFindInExpansion(weightedRandom, targetCard, cardMarketPrice);
				if (val != null)
				{
					return val;
				}
				dictionary.Remove(weightedRandom);
			}
			return null;
		}

		private CardData? TryFindInExpansion(ECardExpansionType expansion, CardData targetCard, float targetPrice)
		{
			//IL_0000: 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_005b: Invalid comparison between Unknown and I4
			//IL_0020: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: 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_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			List<int> cardCollectedList = CPlayerData.GetCardCollectedList(expansion, false);
			List<CardData> list = new List<CardData>();
			for (int i = 0; i < cardCollectedList.Count; i++)
			{
				if (cardCollectedList[i] > 0)
				{
					float cardMarketPrice = CPlayerData.GetCardMarketPrice(i, expansion, false, 0);
					if (cardMarketPrice >= targetPrice * 0.75f && cardMarketPrice < targetPrice * 1.5f)
					{
						CardData cardData = CPlayerData.GetCardData(i, expansion, false);
						if (!cardData.IsEqual(targetCard))
						{
							list.Add(cardData);
						}
					}
				}
				if ((int)expansion != 2 || CPlayerData.GetCardCollectedList(expansion, true)[i] <= 0)
				{
					continue;
				}
				float cardMarketPrice2 = CPlayerData.GetCardMarketPrice(i, expansion, true, 0);
				if (cardMarketPrice2 >= targetPrice * 0.75f && cardMarketPrice2 < targetPrice * 1.5f)
				{
					CardData cardData2 = CPlayerData.GetCardData(i, expansion, true);
					if (!cardData2.IsEqual(targetCard))
					{
						list.Add(cardData2);
					}
				}
			}
			for (int j = 0; j < CPlayerData.m_GradedCardInventoryList.Count; j++)
			{
				CompactCardDataAmount val = CPlayerData.m_GradedCardInventoryList[j];
				if (val.expansionType != expansion)
				{
					continue;
				}
				float cardMarketPrice3 = CPlayerData.GetCardMarketPrice(val.cardSaveIndex, val.expansionType, val.isDestiny, val.amount);
				if (cardMarketPrice3 >= targetPrice * 0.75f && cardMarketPrice3 < targetPrice * 1.5f)
				{
					CardData gradedCardData = CPlayerData.GetGradedCardData(val);
					if (!gradedCardData.IsEqual(targetCard))
					{
						list.Add(gradedCardData);
					}
				}
			}
			if (list.Count != 0)
			{
				return list[Random.Range(0, list.Count)];
			}
			return null;
		}

		private Dictionary<ECardExpansionType, float> CalculateExpansionWeights()
		{
			Dictionary<ECardExpansionType, float> dictionary = CalculateExpansionWeights(EplRuntimeData.Config.ExcludeBaseGameCardsFromTrade);
			if (dictionary.Count == 0)
			{
				ModLogger.Debug("No unlocked EPL expansions available for trading, falling back to base game expansions", "CalculateExpansionWeights", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\CardSelectionService.cs");
				dictionary = CalculateExpansionWeights(excludeBaseGame: false);
			}
			return dictionary;
		}

		private Dictionary<ECardExpansionType, float> CalculateExpansionWeights(bool excludeBaseGame)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ECardExpansionType, float> dictionary = new Dictionary<ECardExpansionType, float>();
			if (!excludeBaseGame)
			{
				dictionary[(ECardExpansionType)0] = 48f;
				dictionary[(ECardExpansionType)1] = CalculateExpansionWeight((ECardExpansionType)1, InventoryBase.GetUnlockItemLevelRequired((EItemType)8), 15, 48);
				dictionary[(ECardExpansionType)7] = CalculateExpansionWeight((ECardExpansionType)7, InventoryBase.GetUnlockItemLevelRequired((EItemType)129), 15, 48);
			}
			foreach (KeyValuePair<ECardExpansionType, ModCardExpansionData> cardExpansionDatum in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData)
			{
				dictionary[cardExpansionDatum.Key] = CalculateExpansionWeight(cardExpansionDatum.Key, cardExpansionDatum.Value.TradeUnlockLevel, 15, 48);
			}
			if (!excludeBaseGame)
			{
				dictionary[(ECardExpansionType)2] = CalculateDynamicExpansionWeight((ECardExpansionType)2, InventoryBase.GetUnlockItemLevelRequired((EItemType)2), 0.04f, dictionary);
			}
			foreach (ECardExpansionType item in (from kvp in dictionary
				where kvp.Value <= 0f
				select kvp.Key).ToList())
			{
				dictionary.Remove(item);
			}
			return dictionary;
		}

		private float CalculateExpansionWeight(ECardExpansionType expansionType, int unlockLevel, int minWeight, int maxWeight)
		{
			if (CPlayerData.m_ShopLevel < unlockLevel)
			{
				return 0f;
			}
			if (CPlayerData.m_ShopLevel >= 50)
			{
				return maxWeight;
			}
			int num = CPlayerData.m_ShopLevel - unlockLevel;
			int num2 = 50 - unlockLevel;
			float num3 = (float)num / (float)num2;
			int num4 = maxWeight - minWeight;
			return (float)minWeight + (float)num4 * num3;
		}

		private float CalculateDynamicExpansionWeight(ECardExpansionType expansionType, int unlockLevel, float targetPercentage, Dictionary<ECardExpansionType, float> allWeights)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (CPlayerData.m_ShopLevel < unlockLevel)
			{
				return 0f;
			}
			int maxWeight = Mathf.RoundToInt(allWeights.Values.Sum() * targetPercentage / (1f - targetPercentage));
			return CalculateExpansionWeight(expansionType, unlockLevel, 1, maxWeight);
		}
	}
	internal class CollectionBinderService
	{
		private CollectionBinderUI? collectionBinderUI;

		private FlowLayoutGroup? flowLayoutGroup;

		private NestedMenu? nestedMenuController;

		private Transform? cloneableButton;

		private bool isLoaded;

		private bool hasSubscribedToSettings;

		internal List<ECardExpansionType> Buttons { get; set; } = new List<ECardExpansionType>();

		internal bool IsLoaded
		{
			get
			{
				return isLoaded;
			}
			set
			{
				isLoaded = value;
				if (!value)
				{
					collectionBinderUI = null;
					flowLayoutGroup = null;
					nestedMenuController = null;
				}
			}
		}

		internal void OpenScreen(CollectionBinderUI collectionBinderUI)
		{
			if (!Object.op_Implicit((Object)(object)this.collectionBinderUI))
			{
				this.collectionBinderUI = collectionBinderUI;
			}
			if (!Object.op_Implicit((Object)(object)flowLayoutGroup))
			{
				flowLayoutGroup = InitFlowLayoutGroup();
			}
			if (!Object.op_Implicit((Object)(object)nestedMenuController))
			{
				nestedMenuController = ((Component)flowLayoutGroup).gameObject.AddComponent<NestedMenu>()?.Setup(flowLayoutGroup, cloneableButton);
			}
			ControllerScreenUIExtension component = ((Component)collectionBinderUI).GetComponent<ControllerScreenUIExtension>();
			if (Object.op_Implicit((Object)(object)nestedMenuController))
			{
				nestedMenuController.OnOpen(PopulateMainMenu(), component, saveLastEntry: true);
			}
		}

		private FlowLayoutGroup InitFlowLayoutGroup()
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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)
			//IL_00ac: 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)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: 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_013f: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = collectionBinderUI.m_ExpansionSelectScreen.transform.Find("Mask/UIGroup");
			RectTransform val = (RectTransform)(object)((obj is RectTransform) ? obj : null);
			Transform val2 = ((Transform)val).Find("Tetramon_Button");
			if (val2 != null)
			{
				((Component)val2).transform.SetParent((Transform)null);
				((Component)val2).gameObject.SetActive(false);
				cloneableButton = val2;
			}
			GameObject val3 = FlowLayoutGroup.Create(((Transform)val).parent, isScrollable: true);
			flowLayoutGroup = val3.GetComponentInChildren<FlowLayoutGroup>(true);
			RectTransform component = val3.GetComponent<RectTransform>();
			((Transform)component).SetSiblingIndex(((Transform)val).GetSiblingIndex());
			component.anchorMin = val.anchorMin;
			component.anchorMax = val.anchorMax;
			component.pivot = val.pivot;
			component.anchoredPosition = val.anchoredPosition;
			component.sizeDelta = val.sizeDelta;
			((Transform)component).localScale = ((Transform)val).localScale;
			component.offsetMin = val.offsetMin;
			component.offsetMax = val.offsetMax;
			Object.Destroy((Object)(object)((Component)val).gameObject);
			Vector2 value = EplRuntimeData.Config.CollectionBinderButtonSizeEntry.Value;
			flowLayoutGroup.SpacingX = EplRuntimeData.Config.CollectionBinderSpacingXEntry.Value;
			flowLayoutGroup.SpacingY = EplRuntimeData.Config.CollectionBinderSpacingYEntry.Value;
			flowLayoutGroup.ChildWidth = value.x;
			flowLayoutGroup.ChildHeight = value.y;
			if (hasSubscribedToSettings)
			{
				return flowLayoutGroup;
			}
			hasSubscribedToSettings = true;
			EplRuntimeData.Config.CollectionBinderSpacingXEntry.SettingChanged += delegate
			{
				FlowLayoutGroup? obj2 = flowLayoutGroup;
				if (obj2 != null)
				{
					obj2.SpacingX = EplRuntimeData.Config.CollectionBinderSpacingXEntry.Value;
				}
			};
			EplRuntimeData.Config.CollectionBinderSpacingYEntry.SettingChanged += delegate
			{
				FlowLayoutGroup? obj2 = flowLayoutGroup;
				if (obj2 != null)
				{
					obj2.SpacingY = EplRuntimeData.Config.CollectionBinderSpacingYEntry.Value;
				}
			};
			EplRuntimeData.Config.CollectionBinderButtonSizeEntry.SettingChanged += delegate
			{
				//IL_000a: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_003c: Unknown result type (might be due to invalid IL or missing references)
				Vector2 value2 = EplRuntimeData.Config.CollectionBinderButtonSizeEntry.Value;
				if (collectionBinderUI != null)
				{
					foreach (Transform expansionBtn in collectionBinderUI.m_ExpansionBtnList)
					{
						RectTransform val4 = (RectTransform)(object)((expansionBtn is RectTransform) ? expansionBtn : null);
						if (val4 != null)
						{
							val4.sizeDelta = value2;
						}
					}
				}
			};
			return flowLayoutGroup;
		}

		private List<NestedMenu.MenuEntry> PopulateMainMenu()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Expected O, but got Unknown
			List<NestedMenu.MenuEntry> list = CardExpansionLibrary.BaseExpansionTypes.Select((ECardExpansionType expansion) => new NestedMenu.MenuEntry
			{
				Label = InventoryBase.GetCardExpansionName(expansion),
				OnClick = (UnityAction)delegate
				{
					//IL_000c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0016: Expected I4, but got Unknown
					collectionBinderUI.OnPressSwitchExpansion((int)expansion);
				}
			}).ToList();
			list.Add(new NestedMenu.MenuEntry
			{
				Label = "Graded Cards",
				OnClick = (UnityAction)delegate
				{
					collectionBinderUI.OnPressSwitchToGradedAlbum();
				}
			});
			IEnumerable<NestedMenu.MenuEntry> collection = (from kvp in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData
				group kvp by kvp.Value.MenuCategory into @group
				select (!string.IsNullOrWhiteSpace(@group.Key)) ? new <>z__ReadOnlySingleElementList<NestedMenu.MenuEntry>(new NestedMenu.MenuEntry
				{
					Label = @group.Key,
					SubMenu = @group.Select((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => new NestedMenu.MenuEntry
					{
						Label = kvp.Value.Name,
						OnClick = (UnityAction)delegate
						{
							//IL_0011: Unknown result type (might be due to invalid IL or missing references)
							//IL_001b: Expected I4, but got Unknown
							collectionBinderUI.OnPressSwitchExpansion((int)kvp.Key);
						}
					}).ToList()
				}) : @group.Select((KeyValuePair<ECardExpansionType, ModCardExpansionData> kvp) => new NestedMenu.MenuEntry
				{
					Label = kvp.Value.Name,
					OnClick = (UnityAction)delegate
					{
						//IL_0011: Unknown result type (might be due to invalid IL or missing references)
						//IL_001b: Expected I4, but got Unknown
						collectionBinderUI.OnPressSwitchExpansion((int)kvp.Key);
					}
				})).SelectMany((IEnumerable<NestedMenu.MenuEntry> x) => x);
			list.AddRange(collection);
			list.AddRange(EplRuntimeData.Services.MenuService.BinderExpansionEntries);
			return list;
		}
	}
	internal class PlayTableService
	{
		private readonly Dictionary<InteractablePlayTable, (ECardExpansionType? Expansion, List<Material> Materials)> tablePicks = new Dictionary<InteractablePlayTable, (ECardExpansionType?, List<Material>)>();

		private readonly Dictionary<MeshRenderer, Material> originalTableCardMaterials = new Dictionary<MeshRenderer, Material>();

		private readonly Dictionary<MeshFilter, (Mesh Mesh, Quaternion Rotation)> originalTableCardMeshes = new Dictionary<MeshFilter, (Mesh, Quaternion)>();

		private readonly List<Mesh> singleCardMeshes = new List<Mesh>();

		private readonly List<Material> vanillaPlayCardMaterials = new List<Material>();

		internal void CacheFanAssets(CardFanRandomizer fan)
		{
			if (vanillaPlayCardMaterials.Count == 0)
			{
				vanillaPlayCardMaterials.AddRange(fan.m_PlayCardMatList);
			}
			if (singleCardMeshes.Count != 0)
			{
				return;
			}
			foreach (GameObject cardFanGrp in fan.m_CardFanGrpList)
			{
				MeshFilter[] componentsInChildren = cardFanGrp.GetComponentsInChildren<MeshFilter>(true);
				foreach (MeshFilter val in componentsInChildren)
				{
					if (Object.op_Implicit((Object)(object)val.sharedMesh))
					{
						singleCardMeshes.Add(val.sharedMesh);
					}
				}
			}
		}

		internal void RollExpansionFor(InteractablePlayTable table)
		{
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			List<(ECardExpansionType, List<Material>)> playCardMaterialSets = EplRuntimeData.Assets.CardExpansionLibrary.PlayCardMaterialSets;
			if (playCardMaterialSets.Count != 0)
			{
				bool flag = !EplRuntimeData.Config.DisableBaseGamePlayCards;
				int num = Random.Range(0, playCardMaterialSets.Count + (flag ? 1 : 0));
				tablePicks[table] = ((num < playCardMaterialSets.Count) ? (playCardMaterialSets[num].Item1, playCardMaterialSets[num].Item2) : ((ECardExpansionType)null, new List<Material>()));
			}
		}

		internal List<Material> ResolvePlayCardMaterials(CardFanRandomizer fan)
		{
			Customer componentInParent = ((Component)fan).GetComponentInParent<Customer>();
			InteractablePlayTable val = (Object.op_Implicit((Object)(object)componentInParent) ? componentInParent.m_CurrentPlayTable : ((Component)fan).GetComponentInParent<InteractablePlayTable>());
			if (Object.op_Implicit((Object)(object)val))
			{
				List<Material> item = GetOrRollPickFor(val).Materials;
				if (item == null || item.Count <= 0)
				{
					return fan.m_PlayCardMatList;
				}
				return item;
			}
			List<(ECardExpansionType, List<Material>)> playCardMaterialSets = EplRuntimeData.Assets.CardExpansionLibrary.PlayCardMaterialSets;
			bool flag = playCardMaterialSets.Count == 0 || !EplRuntimeData.Config.DisableBaseGamePlayCards;
			int num = Random.Range(0, playCardMaterialSets.Count + (flag ? 1 : 0));
			if (num >= playCardMaterialSets.Count)
			{
				return fan.m_PlayCardMatList;
			}
			return playCardMaterialSets[num].Item2;
		}

		internal void ApplyTableCardMaterials(TableGameItemSet itemSet)
		{
			InteractablePlayTable componentInParent = ((Component)itemSet).GetComponentInParent<InteractablePlayTable>();
			if (!Object.op_Implicit((Object)(object)componentInParent))
			{
				return;
			}
			List<Material> item = GetOrRollPickFor(componentInParent).Materials;
			if (item == null)
			{
				return;
			}
			MeshRenderer[] componentsInChildren = ((Component)itemSet).GetComponentsInChildren<MeshRenderer>(true);
			foreach (MeshRenderer val in componentsInChildren)
			{
				if (IsTableCardMesh(((Object)val).name))
				{
					if (!originalTableCardMaterials.TryGetValue(val, out Material value))
					{
						value = ((Renderer)val).sharedMaterial;
						originalTableCardMaterials[val] = value;
					}
					((Renderer)val).sharedMaterial = ((item.Count > 0) ? item[Random.Range(0, item.Count)] : value);
				}
			}
		}

		internal void ApplyDecorationMaterials(TableGameItemSet itemSet)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			ApplyDecorationMaterial(itemSet.m_PlayMatMesh, itemSet.m_TableGameItemSetData.playMatType);
			ApplyDecorationMaterial(itemSet.m_DeckBoxMesh, itemSet.m_TableGameItemSetData.deckBoxType);
			ApplyDecorationMaterial(itemSet.m_ComicBookMesh, itemSet.m_TableGameItemSetData.comicBookType);
		}

		internal void ApplyCardFlipping(TableGameItemSet itemSet)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: 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)
			bool flag = EplRuntimeData.Config.FlipTableCards && singleCardMeshes.Count > 0;
			InteractablePlayTable componentInParent = ((Component)itemSet).GetComponentInParent<InteractablePlayTable>();
			List<Material> list = (Object.op_Implicit((Object)(object)componentInParent) ? GetOrRollPickFor(componentInParent).Materials : null);
			bool flag2 = (list == null || list.Count <= 0) && vanillaPlayCardMaterials.Count > 0;
			MeshFilter[] componentsInChildren = ((Component)itemSet).GetComponentsInChildren<MeshFilter>(true);
			MeshRenderer val4 = default(MeshRenderer);
			foreach (MeshFilter val in componentsInChildren)
			{
				if (!((Object)val).name.StartsWith("CardSingle", StringComparison.Ordinal))
				{
					continue;
				}
				if (!originalTableCardMeshes.TryGetValue(val, out (Mesh, Quaternion) value))
				{
					value = (val.sharedMesh, ((Component)val).transform.localRotation);
					originalTableCardMeshes[val] = value;
				}
				if (!flag)
				{
					val.sharedMesh = value.Item1;
					((Component)val).transform.localRotation = value.Item2;
					continue;
				}
				Mesh val2 = (val.sharedMesh = singleCardMeshes[Random.Range(0, singleCardMeshes.Count)]);
				((Component)val).transform.localRotation = Quaternion.identity;
				((Component)val).transform.Rotate(GetFanNormalizationAngles(((Object)val2).name), (Space)1);
				if (Random.Range(0, 100) < EplRuntimeData.Config.FacedownCardChance)
				{
					((Component)val).transform.Rotate(0f, 180f, 0f, (Space)1);
				}
				if (Random.Range(0, 100) < EplRuntimeData.Config.TappedCardChance)
				{
					((Component)val).transform.Rotate(0f, 0f, 0f - EplRuntimeData.Config.TappedCardAngle, (Space)1);
				}
				if (flag2 && ((Component)val).TryGetComponent<MeshRenderer>(ref val4))
				{
					((Renderer)val4).sharedMaterial = vanillaPlayCardMaterials[Random.Range(0, vanillaPlayCardMaterials.Count)];
				}
			}
		}

		internal void ClearTableGame(InteractablePlayTable table)
		{
			tablePicks.Remove(table);
		}

		internal void Reset()
		{
			tablePicks.Clear();
			originalTableCardMaterials.Clear();
			originalTableCardMeshes.Clear();
			singleCardMeshes.Clear();
			vanillaPlayCardMaterials.Clear();
		}

		private (ECardExpansionType? Expansion, List<Material>? Materials) GetOrRollPickFor(InteractablePlayTable table)
		{
			if (tablePicks.TryGetValue(table, out (ECardExpansionType?, List<Material>) value))
			{
				return value;
			}
			RollExpansionFor(table);
			if (!tablePicks.TryGetValue(table, out value))
			{
				return (Expansion: null, Materials: null);
			}
			return value;
		}

		private static void ApplyDecorationMaterial(MeshRenderer meshRenderer, EItemType itemType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if ((int)itemType != -1 && Object.op_Implicit((Object)(object)meshRenderer) && EplRuntimeData.BundleAssetTracker.GetBundleIdFor<EItemType>(itemType) != null)
			{
				List<Material> list = InventoryBase.GetItemMeshData(itemType)?.materialList;
				if (list != null && list.Count > 0)
				{
					((Renderer)meshRenderer).sharedMaterial = list[Random.Range(0, list.Count)];
				}
			}
		}

		private static Vector3 GetFanNormalizationAngles(string meshName)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (meshName.StartsWith("Card5", StringComparison.Ordinal))
			{
				return new Vector3(90f, 0f, 22f);
			}
			if (meshName.StartsWith("Card4", StringComparison.Ordinal))
			{
				return new Vector3(90f, 0f, 10f);
			}
			if (meshName.StartsWith("Card3", StringComparison.Ordinal))
			{
				return new Vector3(90f, 0f, -22f);
			}
			if (meshName.StartsWith("Card2", StringComparison.Ordinal))
			{
				return new Vector3(90f, 0f, -10f);
			}
			return new Vector3(90f, 0f, 0f);
		}

		private static bool IsTableCardMesh(string meshName)
		{
			if (!meshName.StartsWith("CardSingle", StringComparison.Ordinal))
			{
				return meshName.StartsWith("CardDeck", StringComparison.Ordinal);
			}
			return true;
		}
	}
	internal class PriceTagAtlasService
	{
		private class AtlasMapSnapshot
		{
			private static readonly string[] NamedIndexFields = new string[17]
			{
				"periodIndex", "commaIndex", "minusIndex", "spaceIndex", "dollarIndex", "euroIndex", "yenIndex", "poundIndex", "centIndex", "pIndex",
				"rIndex", "mIndex", "sIndex", "eIndex", "nIndex", "barcodeIndex", "priceZeroIndex"
			};

			public int[] DigitIndex = Array.Empty<int>();

			public List<(string Name, int Value)> NamedIndices = new List<(string, int)>();

			public float[] CellAdvance = Array.Empty<float>();

			public int[] ItemTypeValues = Array.Empty<int>();

			public int[] ItemCellIndices = Array.Empty<int>();

			public int[] ObjectTypeValues = Array.Empty<int>();

			public int[] ObjectCellIndices = Array.Empty<int>();

			public static AtlasMapSnapshot Capture(ScriptableObject map)
			{
				return new AtlasMapSnapshot
				{
					DigitIndex = (int[])(GetMapValue<int[]>(map, "digitIndex") ?? Array.Empty<int>()).Clone(),
					NamedIndices = NamedIndexFields.Select((string name) => (name: name, GetMapInt(map, name))).ToList(),
					CellAdvance = (float[])(GetMapValue<float[]>(map, "cellAdvance") ?? Array.Empty<float>()).Clone(),
					ItemTypeValues = (int[])(GetMapValue<int[]>(map, "itemTypeValues") ?? Array.Empty<int>()).Clone(),
					ItemCellIndices = (int[])(GetMapValue<int[]>(map, "itemCellIndices") ?? Array.Empty<int>()).Clone(),
					ObjectTypeValues = (int[])(GetMapValue<int[]>(map, "objectTypeValues") ?? Array.Empty<int>()).Clone(),
					ObjectCellIndices = (int[])(GetMapValue<int[]>(map, "objectCellIndices") ?? Array.Empty<int>()).Clone()
				};
			}

			public HashSet<int> UsedCells()
			{
				return new HashSet<int>(from x in DigitIndex.Concat(NamedIndices.Select<(string, int), int>(((string Name, int Value) x) => x.Value)).Concat(ItemCellIndices).Concat(ObjectCellIndices)
					where x >= 0
					select x);
			}
		}

		private const int MaxGridSize = 32;

		private static readonly FieldInfo? atlasMapField = AccessTools.Field(typeof(UI_PriceTag), "m_AtlasMap");

		private static readonly FieldInfo? instancedRendererField = AccessTools.Field(typeof(UI_PriceTag), "m_InstancedRenderer");

		private static readonly Dictionary<string, FieldInfo> mapFields = new Dictionary<string, FieldInfo>();

		private readonly Dictionary<EItemType, int> itemCells = new Dictionary<EItemType, int>();

		private readonly Dictionary<EObjectType, int> objectCells = new Dictionary<EObjectType, int>();

		private readonly HashSet<int> filledCells = new HashSet<int>();

		private readonly HashSet<int> pendingCells = new HashSet<int>();

		private Texture2D? atlas;

		private Texture2D? sourceAtlas;

		private ScriptableObject? map;

		private Material? material;

		private AtlasMapSnapshot? pristine;

		private int sourceGridSize;

		private int gridSize;

		private int cellSize;

		private bool capacityWarned;

		internal void EnsureIcon(UI_PriceTag priceTag, EItemType itemType)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (GameBuild.HasPriceTagAtlas && EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(itemType, out ModItemData value) && value.Icon != null && EnsureBuilt(priceTag) && itemCells.TryGetValue(itemType, out var value2))
			{
				RequestFill(value2, value.Icon);
			}
		}

		internal void EnsureIcon(UI_PriceTag priceTag, EObjectType objectType)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (GameBuild.HasPriceTagAtlas && EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value) && value.Icon != null && EnsureBuilt(priceTag) && objectCells.TryGetValue(objectType, out var value2))
			{
				RequestFill(value2, value.Icon);
			}
		}

		private bool EnsureBuilt(UI_PriceTag priceTag)
		{
			object? obj = atlasMapField?.GetValue(priceTag);
			ScriptableObject val = (ScriptableObject)((obj is ScriptableObject) ? obj : null);
			object? obj2 = instancedRendererField?.GetValue(priceTag);
			Renderer val2 = (Renderer)((obj2 is Renderer) ? obj2 : null);
			Material val3 = (Object.op_Implicit((Object)(object)val2) ? val2.sharedMaterial : null);
			if (!Object.op_Implicit((Object)(object)val) || !Object.op_Implicit((Object)(object)val3))
			{
				return false;
			}
			if (Object.op_Implicit((Object)(object)atlas) && (Object)(object)map == (Object)(object)val && (Object)(object)material == (Object)(object)val3)
			{
				return true;
			}
			return Build(val, val3);
		}

		private bool Build(ScriptableObject tagMap, Material tagMaterial)
		{
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)map != (Object)(object)tagMap || pristine == null)
			{
				pristine = AtlasMapSnapshot.Capture(tagMap);
			}
			if ((Object)(object)material != (Object)(object)tagMaterial || !Object.op_Implicit((Object)(object)sourceAtlas))
			{
				ref Texture2D? reference = ref sourceAtlas;
				Texture texture = tagMaterial.GetTexture("_MainTex");
				reference = (Texture2D?)(object)((texture is Texture2D) ? texture : null);
				sourceGridSize = Mathf.RoundToInt(tagMaterial.GetFloat("_AtlasGridSize"));
			}
			if (!Object.op_Implicit((Object)(object)sourceAtlas) || sourceGridSize <= 0)
			{
				ModLogger.Error("Price tag atlas or grid size unavailable; EPL price tag icons disabled.", "Build", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\PriceTagAtlasService.cs");
				return false;
			}
			map = tagMap;
			material = tagMaterial;
			cellSize = ((Texture)sourceAtlas).width / sourceGridSize;
			HashSet<int> hashSet = pristine.UsedCells();
			List<EItemType> list = (from kvp in EplRuntimeData.Assets.ItemLibrary.ItemData
				where kvp.Value.Icon != null
				select kvp.Key into x
				orderby (int)x
				select x).ToList();
			List<EObjectType> list2 = (from kvp in EplRuntimeData.Assets.FurnitureLibrary.FurnitureData
				where kvp.Value.Icon != null
				select kvp.Key into x
				orderby (int)x
				select x).ToList();
			int num = list.Count + list2.Count;
			gridSize = sourceGridSize;
			while (gridSize * gridSize - hashSet.Count < num && gridSize < 32)
			{
				gridSize *= 2;
			}
			List<int> list3 = CollectFreeCells(hashSet);
			if (list3.Count < num && !capacityWarned)
			{
				capacityWarned = true;
				ModLogger.Warning($"Price tag atlas has room for {list3.Count} mod icons but {num} are registered; the remainder will show no icon.", "Build", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\PriceTagAtlasService.cs");
			}
			if (!CreateAtlasTexture())
			{
				return false;
			}
			itemCells.Clear();
			objectCells.Clear();
			filledCells.Clear();
			pendingCells.Clear();
			int num2 = 0;
			foreach (EItemType item in list)
			{
				if (num2 >= list3.Count)
				{
					break;
				}
				itemCells[item] = list3[num2++];
			}
			foreach (EObjectType item2 in list2)
			{
				if (num2 >= list3.Count)
				{
					break;
				}
				objectCells[item2] = list3[num2++];
			}
			ApplyMap();
			material.SetTexture("_MainTex", (Texture)(object)atlas);
			material.SetFloat("_AtlasGridSize", (float)gridSize);
			ModLogger.Info($"Price tag atlas extended to a {gridSize}x{gridSize} grid with {itemCells.Count} item and {objectCells.Count} furniture icon cells.", "Build", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\PriceTagAtlasService.cs");
			return true;
		}

		private List<int> CollectFreeCells(HashSet<int> usedCells)
		{
			HashSet<int> hashSet = new HashSet<int>(usedCells.Select(Remap));
			int num = ((usedCells.Count > 0) ? Remap(usedCells.Max()) : (-1));
			int num2 = gridSize * gridSize;
			List<int> list = new List<int>();
			for (int i = 0; i < num2; i++)
			{
				if (!hashSet.Contains(i) && (i > num || i % gridSize >= sourceGridSize))
				{
					list.Add(i);
				}
			}
			return list;
		}

		private bool CreateAtlasTexture()
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: 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_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)atlas))
			{
				Object.Destroy((Object)(object)atlas);
			}
			int num = gridSize * cellSize;
			Texture2D val = sourceAtlas;
			atlas = new Texture2D(num, num, (TextureFormat)4, true, false)
			{
				name = "EPL_PriceTagAtlas",
				filterMode = ((Texture)val).filterMode,
				wrapMode = ((Texture)val).wrapMode,
				anisoLevel = ((Texture)val).anisoLevel
			};
			atlas.Apply(false, true);
			int width = ((Texture)val).width;
			for (int i = 0; i < ((Texture)atlas).mipmapCount && width >> i > 0; i++)
			{
				int num2 = width >> i;
				RenderTexture temporary = GetTemporary(num2, num2);
				Graphics.Blit((Texture)(object)val, temporary);
				Graphics.CopyTexture((Texture)(object)temporary, 0, 0, 0, 0, num2, num2, (Texture)(object)atlas, 0, i, 0, (num >> i) - num2);
				RenderTexture.ReleaseTemporary(temporary);
			}
			return true;
		}

		private void ApplyMap()
		{
			AtlasMapSnapshot atlasMapSnapshot = pristine;
			ScriptableObject val = map;
			SetMapValue(val, "digitIndex", atlasMapSnapshot.DigitIndex.Select(RemapOrNone).ToArray());
			foreach (var (name, index) in atlasMapSnapshot.NamedIndices)
			{
				SetMapValue(val, name, RemapOrNone(index));
			}
			float[] array = Enumerable.Repeat(1f, gridSize * gridSize).ToArray();
			for (int i = 0; i < atlasMapSnapshot.CellAdvance.Length; i++)
			{
				int num = Remap(i);
				if (num < array.Length)
				{
					array[num] = atlasMapSnapshot.CellAdvance[i];
				}
			}
			SetMapValue(val, "cellAdvance", array);
			List<int> list = new List<int>();
			list.AddRange(atlasMapSnapshot.ItemTypeValues);
			list.AddRange(itemCells.Keys.Select((EItemType x) => (int)x));
			SetMapValue(val, "itemTypeValues", list.ToArray());
			List<int> list2 = new List<int>();
			list2.AddRange(atlasMapSnapshot.ItemCellIndices.Select(RemapOrNone));
			list2.AddRange(itemCells.Values);
			SetMapValue(val, "itemCellIndices", list2.ToArray());
			List<int> list3 = new List<int>();
			list3.AddRange(atlasMapSnapshot.ObjectTypeValues);
			list3.AddRange(objectCells.Keys.Select((EObjectType x) => (int)x));
			SetMapValue(val, "objectTypeValues", list3.ToArray());
			List<int> list4 = new List<int>();
			list4.AddRange(atlasMapSnapshot.ObjectCellIndices.Select(RemapOrNone));
			list4.AddRange(objectCells.Values);
			SetMapValue(val, "objectCellIndices", list4.ToArray());
			SetMapValue(val, "m_ItemCache", null);
			SetMapValue(val, "m_ObjectCache", null);
		}

		private void RequestFill(int cell, StreamingAsset<Sprite> icon)
		{
			if (filledCells.Contains(cell) || !pendingCells.Add(cell))
			{
				return;
			}
			Texture2D atlas = this.atlas;
			icon.GetAsync((Action<Object>)delegate(Object? obj)
			{
				pendingCells.Remove(cell);
				Sprite val = (Sprite)(object)((obj is Sprite) ? obj : null);
				if (val != null && Object.op_Implicit((Object)(object)val) && Object.op_Implicit((Object)(object)atlas) && !((Object)(object)atlas != (Object)(object)this.atlas))
				{
					BlitIntoCell(val, cell);
					filledCells.Add(cell);
				}
			});
		}

		private void BlitIntoCell(Sprite sprite, int cell)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			Texture2D texture = sprite.texture;
			Rect textureRect = sprite.textureRect;
			if (!Object.op_Implicit((Object)(object)texture) || ((Rect)(ref textureRect)).width <= 0f || ((Rect)(ref textureRect)).height <= 0f)
			{
				return;
			}
			Vector2 val = default(Vector2);
			((Vector2)(ref val))..ctor(((Rect)(ref textureRect)).width / (float)((Texture)texture).width, ((Rect)(ref textureRect)).height / (float)((Texture)texture).height);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(((Rect)(ref textureRect)).x / (float)((Texture)texture).width, ((Rect)(ref textureRect)).y / (float)((Texture)texture).height);
			int num = ((((Rect)(ref textureRect)).width >= ((Rect)(ref textureRect)).height) ? cellSize : Mathf.Max(1, Mathf.RoundToInt((float)cellSize * ((Rect)(ref textureRect)).width / ((Rect)(ref textureRect)).height)));
			int num2 = ((((Rect)(ref textureRect)).height >= ((Rect)(ref textureRect)).width) ? cellSize : Mathf.Max(1, Mathf.RoundToInt((float)cellSize * ((Rect)(ref textureRect)).height / ((Rect)(ref textureRect)).width)));
			RenderTexture temporary = GetTemporary(num, num2);
			Graphics.Blit((Texture)(object)texture, temporary, val, val2);
			RenderTexture temporary2 = GetTemporary(cellSize, cellSize);
			RenderTexture active = RenderTexture.active;
			RenderTexture.active = temporary2;
			GL.Clear(true, true, Color.clear);
			RenderTexture.active = active;
			Graphics.CopyTexture((Texture)(object)temporary, 0, 0, 0, 0, num, num2, (Texture)(object)temporary2, 0, 0, (cellSize - num) / 2, (cellSize - num2) / 2);
			RenderTexture.ReleaseTemporary(temporary);
			int num3 = gridSize * cellSize;
			int num4 = cell % gridSize * cellSize;
			int num5 = num3 - (cell / gridSize + 1) * cellSize;
			RenderTexture val3 = temporary2;
			for (int i = 0; i < ((Texture)atlas).mipmapCount && cellSize >> i > 0; i++)
			{
				int num6 = cellSize >> i;
				if (i > 0)
				{
					RenderTexture temporary3 = GetTemporary(num6, num6);
					Graphics.Blit((Texture)(object)val3, temporary3);
					RenderTexture.ReleaseTemporary(val3);
					val3 = temporary3;
				}
				Graphics.CopyTexture((Texture)(object)val3, 0, 0, 0, 0, num6, num6, (Texture)(object)atlas, 0, i, num4 >> i, num5 >> i);
			}
			RenderTexture.ReleaseTemporary(val3);
		}

		private RenderTexture GetTemporary(int width, int height)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			RenderTextureDescriptor val = default(RenderTextureDescriptor);
			((RenderTextureDescriptor)(ref val))..ctor(width, height, ((Texture)atlas).graphicsFormat, 0);
			((RenderTextureDescriptor)(ref val)).useMipMap = false;
			((RenderTextureDescriptor)(ref val)).sRGB = GraphicsFormatUtility.IsSRGBFormat(((Texture)atlas).graphicsFormat);
			RenderTexture temporary = RenderTexture.GetTemporary(val);
			((Texture)temporary).filterMode = (FilterMode)1;
			return temporary;
		}

		private int Remap(int index)
		{
			return index / sourceGridSize * gridSize + index % sourceGridSize;
		}

		private int RemapOrNone(int index)
		{
			if (index >= 0)
			{
				return Remap(index);
			}
			return index;
		}

		private static FieldInfo? MapField(string name)
		{
			if (!mapFields.TryGetValue(name, out FieldInfo value))
			{
				value = AccessTools.Field(GameBuild.PriceTagAtlasMapType, name);
				if ((object)value != null)
				{
					mapFields[name] = value;
				}
			}
			return value;
		}

		private static T? GetMapValue<T>(ScriptableObject map, string name) where T : class
		{
			return MapField(name)?.GetValue(map) as T;
		}

		private static int GetMapInt(ScriptableObject map, string name)
		{
			object obj = MapField(name)?.GetValue(map);
			if (obj is int)
			{
				return (int)obj;
			}
			return -1;
		}

		private static void SetMapValue(ScriptableObject map, string name, object? value)
		{
			MapField(name)?.SetValue(map, value);
		}
	}
	internal class SaveDataService(BundleAssetTracker assetTracker)
	{
		private readonly SaveDataReconciler saveDataReconciler = new SaveDataReconciler();

		private readonly SaveDataSerialization saveDataSerializationService = new SaveDataSerialization();

		private readonly Dictionary<string, SaveData> saveData = new Dictionary<string, SaveData>();

		private Dictionary<string, SaveData> orphanedSaveData = new Dictionary<string, SaveData>();

		internal void RegisterSaveData<TEnum, TData>(string bundleId, TEnum enumValue, TData data) where TEnum : Enum where TData : EplBaseSaveData
		{
			SetSaveData(bundleId, enumValue, data);
		}

		internal void RegisterSaveData<TData>(string bundleId, string category, string assetName, TData data) where TData : EplBaseSaveData
		{
			SetSaveData(bundleId, category, assetName, data);
		}

		internal bool TryGetSaveData<TEnum, TData>(TEnum enumValue, [NotNullWhen(true)] out TData? data) where TEnum : Enum where TData : EplBaseSaveData
		{
			string bundleIdFor = assetTracker.GetBundleIdFor(enumValue);
			if (string.IsNullOrWhiteSpace(bundleIdFor))
			{
				data = null;
				return false;
			}
			string key = GenerateKey(enumValue);
			data = (saveData.TryGetValue(bundleIdFor, out SaveData value) ? value.GetData<TData>(key) : null);
			return data != null;
		}

		internal bool TryGetSaveData<TData>(string category, string assetName, [NotNullWhen(true)] out TData? data) where TData : EplBaseSaveData
		{
			string bundleIdFor = assetTracker.GetBundleIdFor(category, assetName);
			if (string.IsNullOrWhiteSpace(bundleIdFor))
			{
				data = null;
				return false;
			}
			string key = GenerateKey(category, assetName);
			data = (saveData.TryGetValue(bundleIdFor, out SaveData value) ? value.GetData<TData>(key) : null);
			return data != null;
		}

		private void SetSaveData<TEnum, TData>(string bundleId, TEnum enumValue, TData data) where TEnum : Enum where TData : EplBaseSaveData
		{
			if (string.IsNullOrWhiteSpace(bundleId))
			{
				ModLogger.Warning($"Registration of save data for item {enumValue} failed. Mod id is not defined", "SetSaveData", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\SaveDataService.cs");
				return;
			}
			string key = GenerateKey(enumValue);
			saveData.GetOrAdd(bundleId, (string _) => new SaveData()).SetData(key, data);
		}

		private void SetSaveData<TData>(string bundleId, string category, string assetName, TData data) where TData : EplBaseSaveData
		{
			if (string.IsNullOrWhiteSpace(bundleId))
			{
				ModLogger.Warning("Registration of save data for item " + assetName + " failed. Mod id is not defined", "SetSaveData", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\SaveDataService.cs");
				return;
			}
			string key = GenerateKey(category, assetName);
			saveData.GetOrAdd(bundleId, (string _) => new SaveData()).SetData(key, data);
		}

		internal void LoadFromFile(string filePath)
		{
			Dictionary<string, SaveData> dictionary = saveDataSerializationService.LoadFromFile(filePath);
			if (dictionary == null)
			{
				return;
			}
			orphanedSaveData = saveDataReconciler.Reconcile(dictionary, saveData);
			foreach (SaveData value in saveData.Values)
			{
				foreach (string key in value.GetKeys())
				{
					if (value.GetData<EplBaseSaveData>(key) is IPostLoadNormalizer postLoadNormalizer)
					{
						postLoadNormalizer.NormalizeAfterLoad(key);
					}
				}
			}
		}

		internal void PurgeBundleSaveData(string bundleId)
		{
			HashSet<string> hashSet = new HashSet<string>();
			if (saveData.Remove(bundleId, out SaveData value))
			{
				hashSet.UnionWith(value.GetKeys());
			}
			hashSet.UnionWith(from v in assetTracker.GetEnumValuesForBundle<EItemType>(bundleId)
				select GenerateKey<EItemType>(v));
			hashSet.UnionWith(from v in assetTracker.GetEnumValuesForBundle<EObjectType>(bundleId)
				select GenerateKey<EObjectType>(v));
			hashSet.UnionWith(from v in assetTracker.GetEnumValuesForBundle<EDecoObject>(bundleId)
				select GenerateKey<EDecoObject>(v));
			hashSet.UnionWith(from v in assetTracker.GetEnumValuesForBundle<ECardExpansionType>(bundleId)
				select GenerateKey<ECardExpansionType>(v));
			hashSet.UnionWith(GetTextureKeys(bundleId, (DecoFlags)2));
			hashSet.UnionWith(GetTextureKeys(bundleId, (DecoFlags)1));
			hashSet.UnionWith(GetTextureKeys(bundleId, (DecoFlags)3));
			orphanedSaveData.Remove(bundleId);
			foreach (string item in orphanedSaveData.Keys.ToList())
			{
				SaveData obj = orphanedSaveData[item];
				obj.RemoveKeys(hashSet);
				if (obj.IsEmpty)
				{
					orphanedSaveData.Remove(item);
				}
			}
			ModLogger.Info($"Purged save data for bundle '{bundleId}' ({hashSet.Count} keys)", "PurgeBundleSaveData", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\SaveDataService.cs");
		}

		internal void ResetAllSaveData()
		{
			orphanedSaveData.Clear();
			foreach (SaveData value in saveData.Values)
			{
				value.ResetData();
			}
		}

		internal void SaveToFile(string filePath)
		{
			Dictionary<string, SaveData> dict = new Dictionary<string, SaveData>();
			string key;
			SaveData value;
			foreach (KeyValuePair<string, SaveData> orphanedSaveDatum in orphanedSaveData)
			{
				orphanedSaveDatum.Deconstruct(out key, out value);
				string key2 = key;
				SaveData other = value;
				dict.GetOrAdd(key2, (string _) => new SaveData()).MergeFrom(other);
			}
			foreach (KeyValuePair<string, SaveData> saveDatum in saveData)
			{
				saveDatum.Deconstruct(out key, out value);
				string key3 = key;
				SaveData other2 = value;
				dict.GetOrAdd(key3, (string _) => new SaveData()).MergeFrom(other2);
			}
			saveDataSerializationService.SaveToFile(dict, filePath);
		}

		private unsafe IEnumerable<string> GetTextureKeys(string bundleId, DecoFlags category)
		{
			string categoryName = ((object)(*(DecoFlags*)(&category))/*cast due to .constrained prefix*/).ToString();
			return from assetName in assetTracker.GetNamedAssetsForBundle(bundleId, categoryName)
				select GenerateKey(categoryName, assetName);
		}

		private string GenerateKey<TEnum>(TEnum enumValue) where TEnum : Enum
		{
			return $"{typeof(TEnum).Name}:{enumValue}";
		}

		private string GenerateKey(string category, string assetName)
		{
			return category + ":" + assetName;
		}
	}
	internal class ScriptHookService
	{
		private enum Hook
		{
			LightsChanged,
			ShopOpenChanged,
			TimeOfDayChanged,
			DayStarted,
			DayEnded,
			ShopLevelChanged,
			RoomUnlocked,
			MoneyChanged
		}

		private class HookDefinition(Hook hook, string methodName, Type[] parameterTypes, string expectedSignature)
		{
			internal Hook Hook => hook;

			internal string MethodName => methodName;

			internal Type[] ParameterTypes => parameterTypes;

			internal string ExpectedSignature => expectedSignature;
		}

		private class Registration(MonoBehaviour component, MethodInfo method, ScriptHookTracker owner)
		{
			internal MonoBehaviour Component => component;

			internal MethodInfo Method => method;

			internal ScriptHookTracker Owner => owner;
		}

		private static readonly HookDefinition[] hookDefinitions = new HookDefinition[8]
		{
			new HookDefinition(Hook.LightsChanged, "OnLightsChanged", new Type[1] { typeof(bool) }, "bool lightsOn"),
			new HookDefinition(Hook.ShopOpenChanged, "OnShopOpenChanged", new Type[1] { typeof(bool) }, "bool isOpen"),
			new HookDefinition(Hook.TimeOfDayChanged, "OnTimeOfDayChanged", new Type[1] { typeof(int) }, "int timeOfDayIndex"),
			new HookDefinition(Hook.DayStarted, "OnDayStarted", new Type[1] { typeof(int) }, "int day"),
			new HookDefinition(Hook.DayEnded, "OnDayEnded", new Type[1] { typeof(int) }, "int day"),
			new HookDefinition(Hook.ShopLevelChanged, "OnShopLevelChanged", new Type[1] { typeof(int) }, "int shopLevel"),
			new HookDefinition(Hook.RoomUnlocked, "OnRoomUnlocked", new Type[2]
			{
				typeof(int),
				typeof(int)
			}, "int roomCount, int warehouseRoomCount"),
			new HookDefinition(Hook.MoneyChanged, "OnMoneyChanged", new Type[1] { typeof(double) }, "double amount")
		};

		private readonly Dictionary<Type, Dictionary<Hook, MethodInfo>> hookCache = new Dictionary<Type, Dictionary<Hook, MethodInfo>>();

		private readonly Dictionary<Hook, List<Registration>> registrations = Enum.GetValues(typeof(Hook)).Cast<Hook>().ToDictionary((Hook hook) => hook, (Hook _) => new List<Registration>());

		private LightManager? lightManager;

		private bool? lastLightsOn;

		private bool? lastShopOpen;

		private int? lastTimeOfDayIndex;

		internal void ScanPrefab(GameObject prefab, BundleInfo bundleInfo)
		{
			bool flag = false;
			MonoBehaviour[] componentsInChildren = prefab.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (Object.op_Implicit((Object)(object)val))
				{
					Type type = ((object)val).GetType();
					if (IsCustomScriptType(type))
					{
						flag |= GetHooksFor(type, bundleInfo, ((Object)prefab).name).Count > 0;
					}
				}
			}
			if (flag && !Object.op_Implicit((Object)(object)prefab.GetComponent<ScriptHookTracker>()))
			{
				prefab.AddComponent<ScriptHookTracker>();
			}
		}

		internal void Register(ScriptHookTracker tracker)
		{
			List<(Hook, Registration)> list = new List<(Hook, Registration)>();
			MonoBehaviour[] componentsInChildren = ((Component)tracker).GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren)
			{
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				Type type = ((object)val).GetType();
				if (!IsCustomScriptType(type))
				{
					continue;
				}
				foreach (KeyValuePair<Hook, MethodInfo> item in GetHooksFor(type, null, ((Object)((Component)tracker).gameObject).name))
				{
					item.Deconstruct(out var key, out var value);
					Hook hook = key;
					MethodInfo method = value;
					Registration registration = new Registration(val, method, tracker);
					registrations[hook].Add(registration);
					list.Add((hook, registration));
				}
			}
			ReplayStateHooks(list);
		}

		internal void Unregister(ScriptHookTracker tracker)
		{
			foreach (List<Registration> value in registrations.Values)
			{
				value.RemoveAll((Registration registration) => (Object)(object)registration.Owner == (Object)(object)tracker);
			}
		}

		internal void PollStateHooks(LightManager instance)
		{
			lightManager = instance;
			bool activeSelf = instance.m_ShoplightGrp.activeSelf;
			if (lastLightsOn != activeSelf)
			{
				lastLightsOn = activeSelf;
				Dispatch(Hook.LightsChanged, activeSelf);
			}
			bool isShopOpen = CPlayerData.m_IsShopOpen;
			if (lastShopOpen != isShopOpen)
			{
				lastShopOpen = isShopOpen;
				Dispatch(Hook.ShopOpenChanged, isShopOpen);
			}
			int tImeOfDayIndex = instance.m_TImeOfDayIndex;
			if (lastTimeOfDayIndex != tImeOfDayIndex)
			{
				lastTimeOfDayIndex = tImeOfDayIndex;
				Dispatch(Hook.TimeOfDayChanged, tImeOfDayIndex);
			}
		}

		internal void SubscribeGameEvents()
		{
			CEventManager.AddListener<CEventPlayer_OnDayStarted>((EventDelegate<CEventPlayer_OnDayStarted>)OnGameDayStarted);
			CEventManager.AddListener<CEventPlayer_OnDayEnded>((EventDelegate<CEventPlayer_OnDayEnded>)OnGameDayEnded);
			CEventManager.AddListener<CEventPlayer_ShopLeveledUp>((EventDelegate<CEventPlayer_ShopLeveledUp>)OnGameShopLeveledUp);
			CEventManager.AddListener<CEventPlayer_NewRoomUnlocked>((EventDelegate<CEventPlayer_NewRoomUnlocked>)OnGameRoomUnlocked);
			CEventManager.AddListener<CEventPlayer_AddCoin>((EventDelegate<CEventPlayer_AddCoin>)OnGameCoinChanged);
			CEventManager.AddListener<CEventPlayer_ReduceCoin>((EventDelegate<CEventPlayer_ReduceCoin>)OnGameCoinChanged);
			CEventManager.AddListener<CEventPlayer_SetCoin>((EventDelegate<CEventPlayer_SetCoin>)OnGameCoinChanged);
		}

		internal void Reset()
		{
			foreach (List<Registration> value in registrations.Values)
			{
				value.Clear();
			}
			lightManager = null;
			lastLightsOn = null;
			lastShopOpen = null;
			lastTimeOfDayIndex = null;
		}

		private void OnGameDayStarted(CEventPlayer_OnDayStarted _)
		{
			Dispatch(Hook.DayStarted, CPlayerData.m_CurrentDay);
		}

		private void OnGameDayEnded(CEventPlayer_OnDayEnded _)
		{
			Dispatch(Hook.DayEnded, CPlayerData.m_CurrentDay);
		}

		private void OnGameShopLeveledUp(CEventPlayer_ShopLeveledUp evt)
		{
			Dispatch(Hook.ShopLevelChanged, evt.m_ShopLevel);
		}

		private void OnGameRoomUnlocked(CEventPlayer_NewRoomUnlocked _)
		{
			Dispatch(Hook.RoomUnlocked, CPlayerData.m_UnlockRoomCount, CPlayerData.m_UnlockWarehouseRoomCount);
		}

		private void OnGameCoinChanged(CEvent _)
		{
			Dispatch(Hook.MoneyChanged, CPlayerData.m_CoinAmountDouble);
		}

		private void ReplayStateHooks(List<(Hook hook, Registration registration)> added)
		{
			if (added.Count == 0)
			{
				return;
			}
			LightManager val = lightManager;
			bool? flag = lastLightsOn ?? (Object.op_Implicit((Object)(object)val) ? new bool?(val.m_ShoplightGrp.activeSelf) : ((bool?)null));
			bool flag2 = lastShopOpen ?? CPlayerData.m_IsShopOpen;
			int? num = lastTimeOfDayIndex ?? (Object.op_Implicit((Object)(object)val) ? new int?(val.m_TImeOfDayIndex) : ((int?)null));
			foreach (var (hook, registration) in added)
			{
				switch (hook)
				{
				case Hook.LightsChanged:
					if (flag.HasValue)
					{
						Invoke(registration, flag.Value);
					}
					break;
				case Hook.ShopOpenChanged:
					Invoke(registration, flag2);
					break;
				case Hook.TimeOfDayChanged:
					if (num.HasValue)
					{
						Invoke(registration, num.Value);
					}
					break;
				case Hook.ShopLevelChanged:
					Invoke(registration, CPlayerData.m_ShopLevel);
					break;
				case Hook.MoneyChanged:
					Invoke(registration, CPlayerData.m_CoinAmountDouble);
					break;
				}
			}
		}

		private void Dispatch(Hook hook, params object[] arguments)
		{
			List<Registration> list = registrations[hook];
			if (list.Count != 0)
			{
				Registration[] array = list.ToArray();
				for (int i = 0; i < array.Length; i++)
				{
					Invoke(array[i], arguments);
				}
			}
		}

		private Dictionary<Hook, MethodInfo> GetHooksFor(Type type, BundleInfo? bundleInfo, string prefabName)
		{
			if (hookCache.TryGetValue(type, out Dictionary<Hook, MethodInfo> value))
			{
				return value;
			}
			Dictionary<Hook, MethodInfo> dictionary = new Dictionary<Hook, MethodInfo>();
			HookDefinition[] array = hookDefinitions;
			foreach (HookDefinition definition in array)
			{
				List<MethodInfo> candidateMethods = GetCandidateMethods(type, definition.MethodName);
				MethodInfo methodInfo = candidateMethods.FirstOrDefault((MethodInfo candidate) => (from parameter in candidate.GetParameters()
					select parameter.ParameterType).SequenceEqual(definition.ParameterTypes));
				if ((object)methodInfo != null)
				{
					dictionary[definition.Hook] = methodInfo;
				}
				else if (candidateMethods.Count > 0)
				{
					string text = "Script " + type.Name + " on prefab '" + prefabName + "' declares " + definition.MethodName + " with an unexpected signature — expected " + definition.MethodName + "(" + definition.ExpectedSignature + "), the hook will not be called";
					bundleInfo?.warnings.Add(text);
					ModLogger.Warning(text, "GetHooksFor", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\ScriptHookService.cs");
				}
			}
			hookCache[type] = dictionary;
			return dictionary;
		}

		private static void Invoke(Registration registration, params object[] arguments)
		{
			if (!Object.op_Implicit((Object)(object)registration.Component))
			{
				return;
			}
			try
			{
				registration.Method.Invoke(registration.Component, arguments);
			}
			catch (Exception ex)
			{
				Exception arg = ((ex is TargetInvocationException ex2 && ex.InnerException != null) ? ex2.InnerException : ex);
				ModLogger.Error($"Script hook {registration.Method.Name} on {((object)registration.Component).GetType().Name} threw: {arg}", "Invoke", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\ScriptHookService.cs");
			}
		}

		private static List<MethodInfo> GetCandidateMethods(Type type, string methodName)
		{
			List<MethodInfo> list = new List<MethodInfo>();
			Type type2 = type;
			while ((object)type2 != null && type2 != typeof(MonoBehaviour))
			{
				list.AddRange(from method in type2.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
					where method.Name == methodName
					select method);
				type2 = type2.BaseType;
			}
			return list;
		}

		private static bool IsCustomScriptType(Type type)
		{
			Assembly assembly = type.Assembly;
			if (assembly == typeof(InteractableObject).Assembly || assembly == typeof(ScriptHookService).Assembly || assembly == typeof(Epl).Assembly)
			{
				return false;
			}
			string name = assembly.GetName().Name;
			if (!name.StartsWith("Unity") && !name.StartsWith("System") && name != "mscorlib")
			{
				return name != "netstandard";
			}
			return false;
		}
	}
	internal class SettingsScreenService
	{
		private GameObject? modSettingScreen;

		private GameObject? labelTemplate;

		private GameObject? dropdownTemplate;

		private GameObject? resetButton;

		private GameObject? uninstallButton;

		private BundleInfoPanel? infoPanel;

		private SettingsDialog? dialog;

		internal bool IsLoaded { get; set; }

		internal void Initialize(SettingScreen settingsScreen, bool isTitleScreen)
		{
			if (IsLoaded && Object.op_Implicit((Object)(object)modSettingScreen))
			{
				SetTitleMode(isTitleScreen);
				return;
			}
			CreateTabButton(settingsScreen);
			CreateContentScreen(settingsScreen);
			IsLoaded = true;
			SetTitleMode(isTitleScreen);
		}

		internal void HideModScreen()
		{
			if (Object.op_Implicit((Object)(object)modSettingScreen))
			{
				modSettingScreen.SetActive(false);
			}
			dialog?.Hide();
		}

		private void CreateTabButton(SettingScreen settingsScreen)
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			GameObject gameObject = ((Component)settingsScreen.m_ScreenGrp.transform.Find("KeybindSettingBtn")).gameObject;
			GameObject val = Object.Instantiate<GameObject>(gameObject, gameObject.transform.parent);
			settingsScreen.m_SubSettingBtnHighlight.Add(((Component)val.transform.Find("AnimGrp/BGHighlight")).gameObject);
			Transform transform = val.transform;
			Transform obj = ((transform is RectTransform) ? transform : null);
			obj.localPosition = new Vector3(-588f, 73f, 0f);
			obj.SetSiblingIndex(gameObject.transform.GetSiblingIndex() + 1);
			((Component)obj).GetComponentInChildren<Localize>(true).Term = "EPL";
			Button componentInChildren = val.GetComponentInChildren<Button>();
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				componentInChildren.onClick = new ButtonClickedEvent();
				((UnityEvent)componentInChildren.onClick).AddListener((UnityAction)delegate
				{
					OnPressModSettings(settingsScreen);
				});
			}
		}

		private void CreateContentScreen(SettingScreen settingsScreen)
		{
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			GameObject gameObject = ((Component)settingsScreen.m_ScreenGrp.transform.Find("Settings Content")).gameObject;
			modSettingScreen = Object.Instantiate<GameObject>(gameObject, settingsScreen.m_ScreenGrp.transform);
			modSettingScreen.transform.SetSiblingIndex(gameObject.transform.GetSiblingIndex() + 1);
			modSettingScreen.SetActive(false);
			VerticalLayoutGroup component = modSettingScreen.GetComponent<VerticalLayoutGroup>();
			if (Object.op_Implicit((Object)(object)component))
			{
				((HorizontalOrVerticalLayoutGroup)component).spacing = 8f;
			}
			Transform val = modSettingScreen.transform.Find("CurrencyType (Custom)");
			((Component)val).GetComponent<Localize>().Term = "Bundle";
			Transform val2 = modSettingScreen.transform.Find("Separator");
			Transform val3 = modSettingScreen.transform.Find("Music (Custom)");
			if (Object.op_Implicit((Object)(object)val3))
			{
				labelTemplate = Object.Instantiate<GameObject>(((Component)val3).gameObject);
				labelTemplate.SetActive(false);
				Localize component2 = labelTemplate.GetComponent<Localize>();
				if (Object.op_Implicit((Object)(object)component2))
				{
					Object.Destroy((Object)(object)component2);
				}
				Transform val4 = labelTemplate.transform.Find("Music Slider");
				if (Object.op_Implicit((Object)(object)val4))
				{
					TextMeshProUGUI component3 = labelTemplate.GetComponent<TextMeshProUGUI>();
					GameObject val5 = new GameObject("ValueText");
					val5.transform.SetParent(labelTemplate.transform, false);
					TextMeshProUGUI obj = val5.AddComponent<TextMeshProUGUI>();
					((TMP_Text)obj).font = ((TMP_Text)component3).font;
					((TMP_Text)obj).fontSize = ((TMP_Text)component3).fontSize;
					((Graphic)obj).color = ((Graphic)component3).color;
					((TMP_Text)obj).alignment = (TextAlignmentOptions)513;
					((TMP_Text)obj).enableWordWrapping = false;
					((TMP_Text)obj).overflowMode = (TextOverflowModes)1;
					RectTransform component4 = val5.GetComponent<RectTransform>();
					component4.anchorMin = new Vector2(0.25f, 0f);
					component4.anchorMax = new Vector2(1f, 1f);
					component4.offsetMin = Vector2.zero;
					component4.offsetMax = Vector2.zero;
					Object.DestroyImmediate((Object)(object)((Component)val4).gameObject);
				}
			}
			if (Object.op_Implicit((Object)(object)val))
			{
				dropdownTemplate = Object.Instantiate<GameObject>(((Component)val).gameObject);
				dropdownTemplate.SetActive(false);
			}
			if (val != null)
			{
				val.SetParent((Transform)null);
			}
			if (val2 != null)
			{
				val2.SetParent((Transform)null);
			}
			foreach (Transform item in modSettingScreen.transform)
			{
				Object.Destroy((Object)(object)((Component)item).gameObject);
			}
			if (val2 != null)
			{
				val2.SetParent(modSettingScreen.transform);
			}
			if (val != null)
			{
				val.SetParent(modSettingScreen.transform);
			}
			infoPanel = new BundleInfoPanel();
			infoPanel.Build(modSettingScreen.transform, val, labelTemplate, dropdownTemplate);
			CreateActionButtons(settingsScreen);
			dialog = new SettingsDialog();
			dialog.Build(settingsScreen);
		}

		private void CreateActionButtons(SettingScreen settingsScreen)
		{
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			if (Object.op_Implicit((Object)(object)modSettingScreen))
			{
				Transform obj = settingsScreen.m_ScreenGrp.transform.Find("Settings Content");
				Button val = ((obj != null) ? ((Component)obj).GetComponentInChildren<Button>(true) : null);
				if (!Object.op_Implicit((Object)(object)val))
				{
					ModLogger.Warning("Could not find a button to clone for mod settings screen", "CreateActionButtons", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Services\\Internal\\SettingsScreenService.cs");
					return;
				}
				resetButton = CreateActionButton(((Component)val).gameObject, "ResetPricesBtn", "Force Price Reset", new UnityAction(OnPressResetPrices));
				uninstallButton = CreateActionButton(((Component)val).gameObject, "UninstallBtn", "Uninstall", new UnityAction(OnPressUninstall));
			}
		}

		private GameObject CreateActionButton(GameObject sourceButton, string name, string label, UnityAction onPress)
		{
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Expected O, but got Unknown
			GameObject val = Object.Instantiate<GameObject>(sourceButton, modSettingScreen.transform);
			((Object)val).name = name;
			MonoBehaviour[] componentsInChildren = val.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val2 in componentsInChildren)
			{
				if (!(val2 is Button) && !(val2 is Graphic) && !(val2 is LayoutElement))
				{
					Object.Destroy((Object)(object)val2);
				}
			}
			TextMeshProUGUI componentInChildren = val.GetComponentInChildren<TextMeshProUGUI>(true);
			if (Object.op_Implicit((Object)(object)componentInChildren))
			{
				((TMP_Text)componentInChildren).text = label;
			}
			Button component = val.GetComponent<Button>();
			if (Object.op_Implicit((Object)(object)component))
			{
				((Selectable)component).interactable = true;
				component.onClick = new ButtonClickedEvent();
				((UnityEvent)component.onClick).AddListener(onPress);
			}
			val.SetActive(true);
			return val;
		}

		private void SetTitleMode(bool isTitleScreen)
		{
			if (Object.op_Implicit((Object)(object)resetButton))
			{
				resetButton.SetActive(!isTitleScreen);
			}
			if (Object.op_Implicit((Object)(object)uninstallButton))
			{
				uninstallButton.SetActive(!isTitleScreen);
			}
		}

		private void OnPressModSettings(SettingScreen settingsScreen)
		{
			SoundManager.GenericConfirm(1f, 1f);
			settingsScreen.m_GameSettingScreen.SetActive(false);
			settingsScreen.m_DisplaySettingScreen.SetActive(false);
			settingsScreen.m_LanguageScreen.SetActive(false);
			settingsScreen.m_KeybindScreen.SetActive(false);
			if (Object.op_Implicit((Object)(object)modSettingScreen))
			{
				modSettingScreen.SetActive(true);
			}
			infoPanel?.RefreshDropdownOptions();
			infoPanel?.UpdateBundleInfo();
			int num = settingsScreen.m_SubSettingBtnHighlight.Count - 1;
			for (int i = 0; i < settingsScreen.m_SubSettingBtnHighlight.Count; i++)
			{
				settingsScreen.m_SubSettingBtnHighlight[i].SetActive(i == num);
			}
		}

		private void OnPressResetPrices()
		{
			string text = infoPanel?.GetSelectedBundleId();
			if (text != null)
			{
				SoundManager.GenericConfirm(1f, 1f);
				bool flag = EplRuntimeData.Services.BundleMaintenanceService.ResetPrices(text);
				dialog?.ShowInfo(flag ? "Prices have been reset. New prices will be generated for this bundle's content." : "No price data was found to reset for this bundle.");
			}
		}

		private void OnPressUninstall()
		{
			string bundleId = infoPanel?.GetSelectedBundleId();
			if (bundleId != null)
			{
				SoundManager.GenericConfirm(1f, 1f);
				BundleInfo value;
				string text = (EplRuntimeData.Assets.BundleRegistry.BundleInfo.TryGetValue(bundleId, out value) ? value.Name : bundleId);
				string text2 = "Uninstall '" + text + "'?\n\nAll of its cards, items, furniture and deco will be removed from this save and 50% of their value refunded.";
				if (EplRuntimeData.Services.BundleMaintenanceService.IsUninstalled(bundleId))
				{
					text2 += "\n\nThis bundle was already uninstalled this session; confirming will sweep the current save again.";
				}
				dialog?.ShowConfirm(text2, delegate
				{
					RunUninstall(bundleId);
				});
			}
		}

		private void RunUninstall(string bundleId)
		{
			RemovalResult removalResult = EplRuntimeData.Services.BundleMaintenanceService.UninstallBundle(bundleId);
			if (!removalResult.IsSuccess)
			{
				string text = (string.IsNullOrWhiteSpace(removalResult.ErrorMessage) ? "See the log for details." : removalResult.ErrorMessage);
				dialog?.ShowInfo("Uninstall failed.\n\n" + text);
			}
			else
			{
				dialog?.ShowInfo($"Uninstall complete - removed {removalResult.AssetsRemoved} assets and refunded ${removalResult.TotalValue / 2f:F2}." + "\n\nSave and reload before continuing to play. Remove the bundle's folder before the next launch to finish uninstalling.");
				infoPanel?.RefreshDropdownOptions();
				infoPanel?.UpdateBundleInfo();
			}
		}
	}
	internal class ShopService
	{
		private bool IsFurnitureUILoaded { get; set; }

		private bool IsItemUILoaded { get; set; }

		private bool IsBoardGameUILoaded { get; set; }

		private bool IsCheckPriceUILoaded { get; set; }

		internal void CreateAndRegisterCustomShops()
		{
			if (!PhoneOverhaulBridge.Instance.IsLoaded || EplRuntimeData.Assets.ShopLibrary.CustomShops.Count == 0)
			{
				return;
			}
			ClearShopItemLists();
			int num = 0;
			string key;
			CustomShopData value;
			foreach (KeyValuePair<string, CustomShopData> customShop in EplRuntimeData.Assets.ShopLibrary.CustomShops)
			{
				customShop.Deconstruct(out key, out value);
				CustomShopData shopData = value;
				foreach (ModRestockData item in EplRuntimeData.Assets.ItemLibrary.RestockEntries.Where((ModRestockData m) => m.PhoneAppId == shopData.PhoneAppId))
				{
					if ((item.ItemFlags & ItemFlags.TCG) != ItemFlags.None)
					{
						shopData.TCG.Add(item.RestockData);
					}
					if ((item.ItemFlags & ItemFlags.Accessory) != ItemFlags.None)
					{
						shopData.Accessories.Add(item.RestockData);
					}
					if ((item.ItemFlags & ItemFlags.Figurine) != ItemFlags.None)
					{
						shopData.Figurines.Add(item.RestockData);
					}
				}
				int num2 = Mathf.Max(shopData.TCG.Count, Mathf.Max(shopData.Accessories.Count, shopData.Figurines.Count));
				if (num2 > num)
				{
					num = num2;
				}
			}
			GameObject val = GameObject.Find("Canvas/RestockItemScreen_Grp");
			GameObject val2 = Object.Instantiate<GameObject>(val, val.transform.parent);
			Object.Destroy((Object)(object)val2.GetComponent<RestockItemScreen>());
			CustomShopScreen sharedScreen = val2.AddComponent<CustomShopScreen>();
			((Object)sharedScreen).name = "CustomShop_SharedScreen_Grp";
			((Component)sharedScreen).transform.SetSiblingIndex(val.transform.GetSiblingIndex());
			ShopService.SetupShopPanels<CustomShopScreen>(sharedScreen, num, 4, (Action<CustomShopScreen, Transform>)delegate(CustomShopScreen s, Transform panel)
			{
				((RestockItemScreen)s).m_RestockItemPanelUIList.Add(((Component)panel).GetComponent<RestockItemPanelUI>());
			});
			sharedScreen.InitializeControllerExtension();
			foreach (KeyValuePair<string, CustomShopData> customShop2 in EplRuntimeData.Assets.ShopLibrary.CustomShops)
			{
				customShop2.Deconstruct(out key, out value);
				CustomShopData customShopData = value;
				CustomShopData capturedData = customShopData;
				PhoneOverhaulBridge.Instance.RegisterApp(customShopData.PhoneAppId, customShopData.AppDisplayName, customShopData.AppIcon, customShopData.AppInnerBGImage, customShopData.AppOuterBGImage, delegate
				{
					if (!sharedScreen.IsOpen)
					{
						sharedScreen.SwapTo(capturedData);
						UI_PhoneScreen component = GameObject.Find("CanvasWorldspaceFixedFOV/CanvasGrp/UI_PhoneScreen_Grp").GetComponent<UI_PhoneScreen>();
						SoundManager.PlayAudio("SFX_ButtonLightTap", 0.15f, 1f);
						((UIScreenBase)component).OpenChildScreen((UIScreenBase)(object)sharedScreen);
						PhoneManager.SetCanClosePhone(false);
						component.SetPhoneButtonRaycastEnable(false);
					}
				});
			}
			EplRuntimeData.Events.ShopEvents.FireShopsReady();
		}

		internal void ClearShopItemLists()
		{
			foreach (var (_, customShopData2) in EplRuntimeData.Assets.ShopLibrary.CustomShops)
			{
				customShopData2.TCG.Clear();
				customShopData2.Accessories.Clear();
				customShopData2.Figurines.Clear();
			}
		}

		internal void ResetUIState()
		{
			ClearShopItemLists();
			IsFurnitureUILoaded = false;
			IsItemUILoaded = false;
			IsBoardGameUILoaded = false;
			IsCheckPriceUILoaded = false;
		}

		internal void SetupFurnitureShopUI(FurnitureShopUIScreen furnitureItemScreen)
		{
			if (!IsFurnitureUILoaded)
			{
				ShopService.SetupShopPanels<FurnitureShopUIScreen>(furnitureItemScreen, EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.Count, 3, (Action<FurnitureShopUIScreen, Transform>)delegate(FurnitureShopUIScreen s, Transform panel)
				{
					s.m_FurnitureShopPanelUIList.Add(((Component)panel).GetComponent<FurnitureShopPanelUI>());
				});
				IsFurnitureUILoaded = true;
			}
		}

		internal void SetupItemShopUI(RestockItemScreen restockItemScreen)
		{
			if (!IsItemUILoaded)
			{
				ShopService.SetupShopPanels<RestockItemScreen>(restockItemScreen, EplRuntimeData.Assets.ItemLibrary.ItemData.Count, 4, (Action<RestockItemScreen, Transform>)delegate(RestockItemScreen s, Transform panel)
				{
					s.m_RestockItemPanelUIList.Add(((Component)panel).GetComponent<RestockItemPanelUI>());
				});
				IsItemUILoaded = true;
			}
		}

		internal void SetupCheckPriceScreenUI(CheckPriceScreen checkPriceScreen)
		{
			if (IsCheckPriceUILoaded)
			{
				return;
			}
			ShopInventoryManager shopInventoryManager = EplRuntimeData.Services.ShopInventoryManager;
			int num = shopInventoryManager.GetBaseGameItemCountForCheckPricePage(3) + shopInventoryManager.GetCustomShopItemsForCheckPricePage(3).Count - checkPriceScreen.m_CheckPricePanelUIList.Count;
			if (num > 0)
			{
				ShopService.SetupShopPanels<CheckPriceScreen>(checkPriceScreen, num, 4, (Action<CheckPriceScreen, Transform>)delegate(CheckPriceScreen s, Transform panel)
				{
					s.m_CheckPricePanelUIList.Add(((Component)panel).GetComponent<CheckPricePanelUI>());
				});
			}
			IsCheckPriceUILoaded = true;
		}

		internal void SetupBoardgameShopUI(RestockItemBoardGameScreen boardgameItemScreen)
		{
			if (!IsBoardGameUILoaded)
			{
				ShopService.SetupShopPanels<RestockItemBoardGameScreen>(boardgameItemScreen, EplRuntimeData.Assets.ItemLibrary.ItemData.Count, 4, (Action<RestockItemBoardGameScreen, Transform>)delegate(RestockItemBoardGameScreen s, Transform panel)
				{
					((RestockItemScreen)s).m_RestockItemPanelUIList.Add(((Component)panel).GetComponent<RestockItemPanelUI>());
				});
				IsBoardGameUILoaded = true;
			}
		}

		internal static void SetupShopPanels<T>(T shopUI, int itemCount, int itemsPerRow, Action<T, Transform> addPanel) where T : GenericSliderScreen
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: 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_007e: Expected O, but got Unknown
			//IL_0087: 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)
			Transform val = ((Component)(object)shopUI).transform.Find("ScreenGrp/AnimGrp/WebsiteContent_Grp/ScrollerGrp");
			Transform val2 = val.Find("HorizontalLayout");
			int result;
			int num = Math.DivRem(itemCount, itemsPerRow, out result);
			if (result != 0)
			{
				num++;
			}
			ControllerScreenUIExtension component = ((Component)(object)shopUI).GetComponent<ControllerScreenUIExtension>();
			for (int i = 0; i < num; i++)
			{
				Transform obj = Object.Instantiate<Transform>(val2, val);
				ControllerBtnList val3 = new ControllerBtnList
				{
					rowList = new List<ControllerButton>()
				};
				foreach (Transform item in obj)
				{
					Transform val4 = item;
					addPanel(shopUI, val4);
					val3.rowList.Add(((Component)val4).GetComponent<ControllerButton>());
				}
				if (component != null)
				{
					component.m_ControllerBtnColumnList.Add(val3);
					component.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
				}
			}
		}
	}
	internal class WorkerPackOpenerScreenService
	{
		internal void ApplyEplPackIcons(WorkerSetPackOpenerTypeOptionScreen screen, int pageIndex)
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			List<WorkerPackTypeOptionPanelUI> workerPackTypeOptionPanelUIList = screen.m_WorkerPackTypeOptionPanelUIList;
			List<EItemType> cardPackItemTypeList = screen.m_CardPackItemTypeList;
			for (int i = 0; i < workerPackTypeOptionPanelUIList.Count; i++)
			{
				int num = i + pageIndex * screen.m_PackPerPage;
				Image image = workerPackTypeOptionPanelUIList[i].m_Image;
				if (Object.op_Implicit((Object)(object)image))
				{
					if (num < cardPackItemTypeList.Count && EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(cardPackItemTypeList[num], out ModItemData value))
					{
						StreamingAssetExtensions.SetSpriteAsync(image, value.Icon);
					}
					else
					{
						StreamingAssetExtensions.CancelPendingSpriteAsync(image);
					}
				}
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Saves
{
	internal class EplSerializationBinder : ISerializationBinder
	{
		private readonly Dictionary<string, Type> typeToName = new Dictionary<string, Type>
		{
			{
				"item",
				typeof(ItemSaveData)
			},
			{
				"deco",
				typeof(DecoSaveData)
			},
			{
				"cardExpansion",
				typeof(CardExpansionSaveData)
			},
			{
				"savedata",
				typeof(SaveData)
			}
		};

		private readonly Dictionary<Type, string> nameToType = new Dictionary<Type, string>
		{
			{
				typeof(ItemSaveData),
				"item"
			},
			{
				typeof(DecoSaveData),
				"deco"
			},
			{
				typeof(CardExpansionSaveData),
				"cardExpansion"
			},
			{
				typeof(SaveData),
				"savedata"
			}
		};

		public Type BindToType(string? assemblyName, string typeName)
		{
			if (!typeToName.TryGetValue(typeName, out Type value))
			{
				throw new InvalidOperationException("Unauthorized type resolution attempted for '" + typeName + "'.");
			}
			return value;
		}

		public void BindToName(Type serializedType, out string? assemblyName, out string? typeName)
		{
			assemblyName = null;
			if (!nameToType.TryGetValue(serializedType, out typeName))
			{
				throw new InvalidOperationException("Cannot serialize unmapped type: " + serializedType.Name);
			}
		}
	}
	internal class SaveData
	{
		[JsonProperty("Data")]
		private Dictionary<string, EplBaseSaveData?> data = new Dictionary<string, EplBaseSaveData>();

		internal bool IsEmpty => data.Count == 0;

		internal T? GetData<T>(string key) where T : EplBaseSaveData
		{
			if (!data.TryGetValue(key, out EplBaseSaveData value))
			{
				return null;
			}
			return value as T;
		}

		internal void SetData<T>(string key, T? value) where T : EplBaseSaveData
		{
			data[key] = value;
		}

		internal IEnumerable<string> GetKeys()
		{
			return data.Keys;
		}

		internal bool ContainsKey(string key)
		{
			return data.ContainsKey(key);
		}

		internal void RemoveKeys(IEnumerable<string> keys)
		{
			foreach (string key in keys)
			{
				data.Remove(key);
			}
		}

		internal void MergeFrom(SaveData other)
		{
			foreach (KeyValuePair<string, EplBaseSaveData> datum in other.data)
			{
				data[datum.Key] = datum.Value;
			}
		}

		internal void ResetData()
		{
			foreach (KeyValuePair<string, EplBaseSaveData> datum in data)
			{
				if (datum.Value is IResettable resettable)
				{
					resettable.Reset();
				}
			}
		}
	}
	internal class SaveDataReconciler
	{
		internal Dictionary<string, SaveData> Reconcile(Dictionary<string, SaveData> loadedData, Dictionary<string, SaveData> currentBundleData)
		{
			Dictionary<string, SaveData> dictionary = new Dictionary<string, SaveData>();
			string key;
			SaveData value;
			foreach (KeyValuePair<string, SaveData> loadedDatum in loadedData)
			{
				loadedDatum.Deconstruct(out key, out value);
				string text = key;
				SaveData saveData = value;
				foreach (string key2 in saveData.GetKeys())
				{
					EplBaseSaveData data = saveData.GetData<EplBaseSaveData>(key2);
					if (data == null || data.GetType() == typeof(EplBaseSaveData))
					{
						ModLogger.Warning("Discarding save entry '" + key2 + "' under bundle id '" + text + "' — it carries no usable data (missing or unrecognized type annotation).", "Reconcile", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataReconciler.cs");
						continue;
					}
					string text2 = FindTargetModId(key2, currentBundleData);
					if (text2 == null)
					{
						dictionary.GetOrAdd(text, (string _) => new SaveData()).SetData(key2, data);
						continue;
					}
					EplBaseSaveData data2 = currentBundleData[text2].GetData<EplBaseSaveData>(key2);
					if (data2 != null && data2.GetType() != data.GetType())
					{
						ModLogger.Warning("Preserving save entry '" + key2 + "' under bundle id '" + text + "' as orphaned — loaded type " + data.GetType().Name + " does not match registered type " + data2.GetType().Name + ".", "Reconcile", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataReconciler.cs");
						dictionary.GetOrAdd(text, (string _) => new SaveData()).SetData(key2, data);
					}
					else
					{
						currentBundleData[text2].SetData(key2, data);
					}
				}
			}
			foreach (KeyValuePair<string, SaveData> item in dictionary)
			{
				item.Deconstruct(out key, out value);
				string arg = key;
				SaveData saveData2 = value;
				ModLogger.Warning($"Preserving {saveData2.GetKeys().Count()} save entries under bundle id '{arg}' that match no loaded content — they will be written back to the save file untouched.", "Reconcile", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataReconciler.cs");
			}
			return dictionary;
		}

		private string? FindTargetModId(string key, Dictionary<string, SaveData> currentBundleData)
		{
			foreach (var (result, saveData2) in currentBundleData)
			{
				if (saveData2.ContainsKey(key))
				{
					return result;
				}
			}
			return null;
		}
	}
	internal class SaveDataSerialization
	{
		private readonly JsonSerializerSettings serializerSettings = new JsonSerializerSettings
		{
			TypeNameHandling = (TypeNameHandling)4,
			Formatting = (Formatting)1,
			SerializationBinder = (ISerializationBinder)(object)new EplSerializationBinder()
		};

		private static readonly Dictionary<string, string> LegacyTypeRewrites = new Dictionary<string, string>
		{
			{ "EnhancedPrefabLoader.Models.SaveData.ItemSaveData", "item" },
			{ "EnhancedPrefabLoader.Models.SaveData.DecoSaveData", "deco" },
			{ "EnhancedPrefabLoader.Models.SaveData.CardExpansionSaveData", "cardExpansion" },
			{ "EnhancedPrefabLoader.Saves.ModSaveData", "savedata" }
		};

		internal Dictionary<string, SaveData>? LoadFromFile(string filePath)
		{
			if (!File.Exists(filePath))
			{
				ModLogger.Warning("No save file found at path " + filePath, "LoadFromFile", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataSerialization.cs");
				return null;
			}
			try
			{
				JToken obj = JToken.Parse(File.ReadAllText(filePath));
				NormalizeTypeAnnotations(obj);
				return obj.ToObject<Dictionary<string, SaveData>>(JsonSerializer.Create(serializerSettings));
			}
			catch (Exception ex)
			{
				ModLogger.Error("Failed to load save file " + filePath + ": " + ex.Message, "LoadFromFile", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataSerialization.cs");
				BackupUnreadableFile(filePath);
				return null;
			}
		}

		private static void BackupUnreadableFile(string filePath)
		{
			try
			{
				string text = $"{filePath}.{DateTime.Now:yyyyMMdd_HHmmss}.bak";
				File.Copy(filePath, text, overwrite: true);
				ModLogger.Error("The unreadable save file was backed up to " + text + " — the next in-game save will overwrite the original.", "BackupUnreadableFile", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataSerialization.cs");
			}
			catch (Exception ex)
			{
				ModLogger.Error("Failed to back up unreadable save file " + filePath + ": " + ex.Message, "BackupUnreadableFile", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataSerialization.cs");
			}
		}

		private static void NormalizeTypeAnnotations(JToken token)
		{
			JObject val = (JObject)(object)((token is JObject) ? token : null);
			if (val != null)
			{
				JProperty val2 = val.Property("$type");
				if (val2 != null)
				{
					string text = ((object)val2.Value).ToString();
					string key = text.Split(',')[0].Trim();
					if (LegacyTypeRewrites.TryGetValue(key, out string value))
					{
						val2.Value = JToken.op_Implicit(value);
					}
					else if (text.Contains('.') || text.Contains(','))
					{
						((JToken)val2).Remove();
					}
				}
				{
					foreach (JProperty item in val.Properties())
					{
						NormalizeTypeAnnotations(item.Value);
					}
					return;
				}
			}
			JArray val3 = (JArray)(object)((token is JArray) ? token : null);
			if (val3 == null)
			{
				return;
			}
			foreach (JToken item2 in val3)
			{
				NormalizeTypeAnnotations(item2);
			}
		}

		internal void SaveToFile(Dictionary<string, SaveData> saveData, string filePath)
		{
			try
			{
				string contents = JsonConvert.SerializeObject((object)saveData, serializerSettings);
				File.WriteAllText(filePath, contents);
			}
			catch (Exception ex)
			{
				ModLogger.Error("Failed to save file " + filePath + ": " + ex.Message, "SaveToFile", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Saves\\SaveDataSerialization.cs");
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Registry
{
	internal class BundleAssetTracker
	{
		private readonly Dictionary<Type, Dictionary<object, string>> enumTrackers = new Dictionary<Type, Dictionary<object, string>>();

		private readonly Dictionary<string, Dictionary<string, string>> nameTrackers = new Dictionary<string, Dictionary<string, string>>();

		internal void Register<TEnum>(string modId, TEnum enumValue) where TEnum : Enum
		{
			Type typeFromHandle = typeof(TEnum);
			enumTrackers.GetOrAdd(typeFromHandle, (Type _) => new Dictionary<object, string>())[enumValue] = modId;
		}

		internal void Register(string modId, string category, string assetName)
		{
			nameTrackers.GetOrAdd(category, (string _) => new Dictionary<string, string>())[assetName] = modId;
		}

		internal string? GetBundleIdFor<TEnum>(TEnum enumValue) where TEnum : Enum
		{
			if (!enumTrackers.TryGetValue(typeof(TEnum), out Dictionary<object, string> value) || !value.TryGetValue(enumValue, out var value2))
			{
				return null;
			}
			return value2;
		}

		internal string? GetBundleIdFor(string category, string assetName)
		{
			if (!nameTrackers.TryGetValue(category, out Dictionary<string, string> value) || !value.TryGetValue(assetName, out var value2))
			{
				return null;
			}
			return value2;
		}

		internal HashSet<T> GetEnumValuesForBundle<T>(string bundleId) where T : Enum
		{
			if (!enumTrackers.TryGetValue(typeof(T), out Dictionary<object, string> value))
			{
				return new HashSet<T>();
			}
			HashSet<T> hashSet = new HashSet<T>();
			foreach (var (obj2, text2) in value)
			{
				if (text2 == bundleId)
				{
					hashSet.Add((T)obj2);
				}
			}
			return hashSet;
		}

		internal HashSet<string> GetNamedAssetsForBundle(string bundleId, string category)
		{
			if (!nameTrackers.TryGetValue(category, out Dictionary<string, string> value))
			{
				return new HashSet<string>();
			}
			HashSet<string> hashSet = new HashSet<string>();
			foreach (var (item, text3) in value)
			{
				if (text3 == bundleId)
				{
					hashSet.Add(item);
				}
			}
			return hashSet;
		}
	}
	internal class BundleRegistry(BundleAssetTracker assetTracker) : IBundleRegistry
	{
		private readonly Dictionary<string, BundleInfo> bundleInfo = new Dictionary<string, BundleInfo>();

		public IReadOnlyDictionary<string, BundleInfo> BundleInfo => bundleInfo;

		internal void RegisterBundle(BundleInfo bundleInfo)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: 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_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: 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_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			foreach (EItemType itemType in bundleInfo.itemTypes)
			{
				assetTracker.Register<EItemType>(bundleInfo.BundleId, itemType);
			}
			foreach (EObjectType furnitureType in bundleInfo.furnitureTypes)
			{
				assetTracker.Register<EObjectType>(bundleInfo.BundleId, furnitureType);
			}
			foreach (EDecoObject decoObject in bundleInfo.decoObjects)
			{
				assetTracker.Register<EDecoObject>(bundleInfo.BundleId, decoObject);
			}
			foreach (ECardExpansionType expansionType in bundleInfo.expansionTypes)
			{
				assetTracker.Register<ECardExpansionType>(bundleInfo.BundleId, expansionType);
			}
			foreach (string wallTexture in bundleInfo.wallTextures)
			{
				assetTracker.Register(bundleInfo.BundleId, ((object)(DecoFlags)2/*cast due to .constrained prefix*/).ToString(), wallTexture);
			}
			foreach (string ceilingTexture in bundleInfo.ceilingTextures)
			{
				assetTracker.Register(bundleInfo.BundleId, ((object)(DecoFlags)3/*cast due to .constrained prefix*/).ToString(), ceilingTexture);
			}
			foreach (string floorTexture in bundleInfo.floorTextures)
			{
				assetTracker.Register(bundleInfo.BundleId, ((object)(DecoFlags)1/*cast due to .constrained prefix*/).ToString(), floorTexture);
			}
			if (this.bundleInfo.TryGetValue(bundleInfo.BundleId, out BundleInfo value))
			{
				MergeBundleInfo(value, bundleInfo);
			}
			else
			{
				this.bundleInfo[bundleInfo.BundleId] = bundleInfo;
			}
		}

		public string? GetBundleIdFor<TEnum>(TEnum enumValue) where TEnum : Enum
		{
			return assetTracker.GetBundleIdFor(enumValue);
		}

		public unsafe string? GetBundleIdFor(DecoFlags category, string assetName)
		{
			return assetTracker.GetBundleIdFor(((object)(*(DecoFlags*)(&category))/*cast due to .constrained prefix*/).ToString(), assetName);
		}

		public bool IsEplAsset<TEnum>(TEnum enumValue) where TEnum : Enum
		{
			return assetTracker.GetBundleIdFor(enumValue) != null;
		}

		public bool IsEplAsset(string category, string assetName)
		{
			return assetTracker.GetBundleIdFor(category, assetName) != null;
		}

		public bool HasRegisteredRestockData(EItemType itemType)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.LookupLibrary.RestockDataLookup.TryGetValue(itemType, out List<RestockData> value))
			{
				return value.Count > 0;
			}
			return false;
		}

		public IReadOnlyCollection<TEnum> GetEnumValuesForBundle<TEnum>(string bundleId) where TEnum : Enum
		{
			return assetTracker.GetEnumValuesForBundle<TEnum>(bundleId);
		}

		public unsafe IReadOnlyCollection<string> GetNamedAssetsForBundle(string bundleId, DecoFlags category)
		{
			return assetTracker.GetNamedAssetsForBundle(bundleId, ((object)(*(DecoFlags*)(&category))/*cast due to .constrained prefix*/).ToString());
		}

		private static void MergeBundleInfo(BundleInfo existing, BundleInfo incoming)
		{
			existing.IsLoaded |= incoming.IsLoaded;
			existing.IsValid |= incoming.IsValid;
			MergeUnique(existing.itemTypes, incoming.itemTypes);
			MergeUnique(existing.furnitureTypes, incoming.furnitureTypes);
			MergeUnique(existing.decoObjects, incoming.decoObjects);
			MergeUnique(existing.expansionTypes, incoming.expansionTypes);
			MergeUnique(existing.wallTextures, incoming.wallTextures);
			MergeUnique(existing.ceilingTextures, incoming.ceilingTextures);
			MergeUnique(existing.floorTextures, incoming.floorTextures);
			existing.errors.AddRange(incoming.errors);
			existing.warnings.AddRange(incoming.warnings);
		}

		private static void MergeUnique<T>(List<T> target, List<T> source)
		{
			foreach (T item in source)
			{
				if (!target.Contains(item))
				{
					target.Add(item);
				}
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Properties
{
	[GeneratedCode("System.Resources.Tools.StronglyTypedResourceBuilder", "18.0.0.0")]
	[DebuggerNonUserCode]
	[CompilerGenerated]
	internal class Resources
	{
		private static ResourceManager resourceMan;

		private static CultureInfo resourceCulture;

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static ResourceManager ResourceManager
		{
			get
			{
				if (resourceMan == null)
				{
					resourceMan = new ResourceManager("EnhancedPrefabLoader.Core.Properties.Resources", typeof(Resources).Assembly);
				}
				return resourceMan;
			}
		}

		[EditorBrowsable(EditorBrowsableState.Advanced)]
		internal static CultureInfo Culture
		{
			get
			{
				return resourceCulture;
			}
			set
			{
				resourceCulture = value;
			}
		}

		internal static byte[] CardMask => (byte[])ResourceManager.GetObject("CardMask", resourceCulture);

		internal Resources()
		{
		}
	}
}
namespace EnhancedPrefabLoader.Core.Patches
{
	[HarmonyPatch(typeof(BulkDonationBoxQuickFillScreen))]
	internal class BulkDonationBoxQuickFillScreenPatches
	{
		[HarmonyPatch("RunBundleCardBulkFunction")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> RunBundleCardBulkFunctionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[2]
			{
				typeof(ECardExpansionType),
				typeof(EMonsterType)
			}, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(EMonsterType));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				}).RemoveInstruction();
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("OnPressChangeRarityButton")]
		[HarmonyPostfix]
		private static void OnPressChangeRarityButtonPostfix(BulkDonationBoxQuickFillScreen __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			EplRuntimeData.Services.CardRaritySelectService.OpenScreen(__instance.m_CurrentCardExpansionType);
		}

		[HarmonyPatch("OnCardExpansionUpdated")]
		[HarmonyPostfix]
		private static void OnCardExpansionUpdatedPostfix(BulkDonationBoxQuickFillScreen __instance, CEventPlayer_OnCardExpansionSelectScreenUpdated evt)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			__instance.OnRarityLimitUpdated(new CEventPlayer_OnCardRaritySelectScreenUpdated(-1));
		}
	}
	[HarmonyPatch(typeof(Card3dUIGroup))]
	internal class Card3dUIGroupPatches
	{
		[HarmonyPatch("EvaluateCardGrade")]
		[HarmonyPostfix]
		private static void EvaluateCardGradePostfix(Card3dUIGroup __instance, CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				((TMP_Text)__instance.m_GradeExpansionRarityText).text = value.Name + " " + CPlayerData.GetFullCardTypeName(cardData, false);
			}
		}
	}
	[HarmonyPatch(typeof(CardExpansionSelectScreen))]
	internal class CardExpansionSelectScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyPrefix]
		private static bool OpenScreenPrefix(ECardExpansionType initCardExpansion)
		{
			EplRuntimeData.Services.CardExpansionSelectService.OpenScreen();
			SoundManager.GenericMenuOpen(1f, 1f);
			CSingleton<CardExpansionSelectScreen>.Instance.m_ScreenGrp.SetActive(true);
			ControllerScreenUIExtManager.OnOpenScreen(CSingleton<CardExpansionSelectScreen>.Instance.m_ControllerScreenUIExtension);
			return false;
		}

		[HarmonyPatch("OpenScreen")]
		[HarmonyPostfix]
		private static void OpenScreenPostfix(ECardExpansionType initCardExpansion)
		{
			Canvas.ForceUpdateCanvases();
		}
	}
	[HarmonyPatch(typeof(CardFanRandomizer))]
	internal class CardFanRandomizerPatches
	{
		[HarmonyPatch("RandomizePlayCard")]
		[HarmonyPrefix]
		private static bool RandomizePlayCardPrefix(CardFanRandomizer __instance)
		{
			EplRuntimeData.Services.PlayTableService.CacheFanAssets(__instance);
			foreach (GameObject cardFanGrp in __instance.m_CardFanGrpList)
			{
				cardFanGrp.SetActive(false);
			}
			__instance.m_CardFanGrpList[Random.Range(0, __instance.m_CardFanGrpList.Count)].SetActive(true);
			List<Material> list = EplRuntimeData.Services.PlayTableService.ResolvePlayCardMaterials(__instance);
			Material material = list[Random.Range(0, list.Count)];
			Material material2 = list[Random.Range(0, list.Count)];
			foreach (MeshRenderer meshRenderer in __instance.m_MeshRendererList)
			{
				((Renderer)meshRenderer).material = material;
			}
			((Renderer)__instance.m_MeshRendererList[0]).material = material2;
			return false;
		}
	}
	[HarmonyPatch(typeof(CardOpeningSequence))]
	internal class CardOpeningSequencePatches
	{
		private static Material? vanillaPackMaterial;

		[HarmonyPatch("ReadyingCardPack")]
		[HarmonyPostfix]
		private static void ReadyingCardPackPostfix(CardOpeningSequence __instance, Item item)
		{
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			SkinnedMeshRenderer cardPackMesh = __instance.m_CardPackMesh;
			if (GameBuild.HasItemMaterialPropertyBlocks && Object.op_Implicit((Object)(object)cardPackMesh) && Object.op_Implicit((Object)(object)item))
			{
				if (!Object.op_Implicit((Object)(object)vanillaPackMaterial))
				{
					vanillaPackMaterial = ((Renderer)cardPackMesh).sharedMaterial;
				}
				bool flag = EplRuntimeData.Assets.ItemLibrary.ItemMeshData.ContainsKey(item.GetItemType()) && Object.op_Implicit((Object)(object)item.m_Mesh);
				((Renderer)cardPackMesh).sharedMaterial = (Material)(flag ? ((object)((Renderer)item.m_Mesh).sharedMaterial) : ((object)vanillaPackMaterial));
			}
		}

		[HarmonyPatch("OpenScreen")]
		[HarmonyPrefix]
		private static bool OpenScreenPrefix(CardOpeningSequence __instance, ECollectionPackType collectionPackType, bool isMultiPack, bool isPremiumPack)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.ExpansionLookup.ContainsKey(collectionPackType))
			{
				return true;
			}
			if (!Object.op_Implicit((Object)(object)__instance.m_CurrentItem) || !EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.ContainsKey(__instance.m_CurrentItem.GetItemType()))
			{
				ModLogger.Error($"[CardOpeningSequencePatches.OpenScreenPrefix]: {collectionPackType} is an EPL pack type but the current item has no registered generation data, falling back to the base game", "OpenScreenPrefix", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\CardOpeningSequencePatches.cs");
				return true;
			}
			__instance.m_IsScreenActive = true;
			__instance.m_CollectionPackType = collectionPackType;
			__instance.m_IsNewlList.Clear();
			__instance.m_TotalExpGained = 0;
			__instance.m_TotalCardValue = 0f;
			__instance.m_HasFoilCard = false;
			__instance.m_StateIndex = 0;
			__instance.m_ManualOpenCardDataList.Clear();
			__instance.m_CardValueList.Clear();
			__instance.m_CurrentOpenedCardIndex = 0;
			foreach (Card3dUIGroup card3dUI in __instance.m_Card3dUIList)
			{
				((Component)card3dUI).gameObject.SetActive(false);
			}
			EItemType itemType = __instance.m_CurrentItem.GetItemType();
			int count = __instance.m_Card3dUIList.Count;
			int num = 0;
			foreach (CardData item in EplRuntimeData.Services.ItemService.GeneratePackContent(itemType))
			{
				if (num >= count)
				{
					ModLogger.Error($"[CardOpeningSequencePatches.OpenScreenPrefix]: Pack {itemType} generated more cards than the {count} available card slots, skipping the remaining cards", "OpenScreenPrefix", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\CardOpeningSequencePatches.cs");
					break;
				}
				__instance.m_HasFoilCard = __instance.m_HasFoilCard || item.isFoil;
				__instance.m_ManualOpenCardDataList.Add(item);
				__instance.m_CardValueList.Add(CPlayerData.GetCardMarketPrice(item));
				__instance.m_Card3dUIList[num].m_CardUI.SetCardUI(item);
				__instance.m_IsNewlList.Add(CSingleton<CGameManager>.Instance.m_OpenPackShowNewCard && item.isNew);
				CPlayerData.AddCard(item, 1);
				num++;
			}
			CSingleton<InteractionPlayerController>.Instance.m_CollectionBinderFlipAnimCtrl.SetCanUpdateSort(true);
			return false;
		}

		[HarmonyPatch("Update")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Expected O, but got Unknown
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_018d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e9: Expected O, but got Unknown
			List<CodeInstruction> list = instructions.ToList();
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardOpeningSequence), "m_ManualOpenCardDataList");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(CardOpeningSequence), "m_TotalExpGained");
			MethodInfo methodInfo = AccessTools.Method(typeof(List<CardData>), "get_Item", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(CardOpeningSequencePatches), "ProcessCardExp", (Type[])null, (Type[])null);
			CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[CardOpeningSequencePatches.UpdateTranspiler]: Failed to find card list anchor, leaving Update unpatched", "UpdateTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\CardOpeningSequencePatches.cs");
				return list;
			}
			int num = val.Pos + 1;
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[CardOpeningSequencePatches.UpdateTranspiler]: Failed to find m_TotalExpGained anchor, leaving Update unpatched", "UpdateTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\CardOpeningSequencePatches.cs");
				return list;
			}
			int pos = val.Pos;
			List<CodeInstruction> list2 = val.Instructions();
			CodeInstruction val2 = null;
			for (int i = num; i < pos; i++)
			{
				if (list2[i].opcode == OpCodes.Stloc_S)
				{
					val2 = new CodeInstruction(OpCodes.Stloc_S, list2[i].operand);
					break;
				}
			}
			if (val2 == null)
			{
				ModLogger.Error("[CardOpeningSequencePatches.UpdateTranspiler]: Failed to find exp local between anchors, leaving Update unpatched", "UpdateTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\CardOpeningSequencePatches.cs");
				return list;
			}
			val.Start().Advance(num).RemoveInstructions(pos - num)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					val2
				});
			return val.InstructionEnumeration();
		}

		internal static int ProcessCardExp(CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Expected I4, but got Unknown
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
			{
				return (int)EplRuntimeData.Services.CardExpansionService.GenerateCardExp(cardData);
			}
			if (EplRuntimeData.Config.UseCustomExpForBase)
			{
				return (int)new CardExpGenerator().CalculateExp(cardData);
			}
			? val = cardData.GetCardBorderType() + 1;
			return val * Mathf.CeilToInt((float)val / 2f) * ((!cardData.isFoil) ? 1 : 8);
		}
	}
	[HarmonyPatch(typeof(CardRaritySelectScreen))]
	internal class CardRaritySelectScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OpenScreenTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Expected O, but got Unknown
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(List<GameObject>), "get_Item", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(GameObject), "SetActive", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardRaritySelectScreen), "m_CurrentIndex");
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldc_I4_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Stloc_0, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Br || i.opcode == OpCodes.Br_S), (string)null)
			});
			if (val.IsValid)
			{
				int pos = val.Pos;
				val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldc_I4_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
				});
				if (val.IsValid)
				{
					int num = val.Pos + 1;
					val.Start().Advance(pos).RemoveInstructions(num - pos);
				}
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(CardShelf))]
	internal class CardShelfPatches
	{
		[HarmonyPatch("LoadCardCompartment")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> LoadCardCompartmentTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0043: 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_0063: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Expected O, but got Unknown
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Expected O, but got Unknown
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(List<CardData>), "Item");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(CardShelfPatches), "ShouldProcessCard", (Type[])null, (Type[])null);
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(CSingleton<Card3dUISpawner>), "Instance");
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo3, (string)null)
			});
			if (val.IsValid)
			{
				Label label = il.DefineLabel();
				val.AddLabels((IEnumerable<Label>)new <>z__ReadOnlySingleElementList<Label>(label)).Start().MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
				})
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
					{
						new CodeInstruction(OpCodes.Ldarg_1, (object)null),
						new CodeInstruction(OpCodes.Ldloc_1, (object)null),
						new CodeInstruction(OpCodes.Callvirt, (object)methodInfo),
						new CodeInstruction(OpCodes.Call, (object)methodInfo2),
						new CodeInstruction(OpCodes.Brtrue, (object)label)
					});
			}
			return val.InstructionEnumeration();
		}

		private static bool ShouldProcessCard(CardData cardData)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (cardData != null)
			{
				return EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType);
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(CardUI))]
	internal class CardUIPatches
	{
		[HarmonyPatch("SetCardUI")]
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(CardData));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(1).RemoveInstruction().InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				})
					.RemoveInstruction();
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("SetCardUI")]
		[HarmonyPriority(800)]
		[HarmonyPrefix]
		private static void SetCardUIPrefix(CardUI __instance, CardData cardData)
		{
			//IL_0010: 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)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
			{
				EplRuntimeData.Services.CardUIService.RestoreOriginalCardUI(__instance, cardData);
			}
			else
			{
				cardData.borderType = (ECardBorderType)5;
			}
		}

		[HarmonyPatch("SetCardUI")]
		[HarmonyPriority(800)]
		[HarmonyPostfix]
		private static void SetCardUIPostfix(CardUI __instance, CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				StreamingAssetExtensions.SetSpriteAsync(__instance.m_CenterFrameImage, value.Cards[cardData.monsterType].Icon);
				EplRuntimeData.Services.CardUIService.ApplyEplCardUI(__instance, cardData);
			}
		}
	}
	[HarmonyPatch(typeof(CGameData))]
	internal class CGameDataPatches
	{
		private const int BaseGameItemListSize = 500;

		[HarmonyPatch("PropagateLoadData")]
		[HarmonyPostfix]
		private static void PropagateLoadDataPostfix()
		{
			int num = TrimToBaseGameSize(CPlayerData.m_CurrentTotalItemCountList) + TrimToBaseGameSize(CPlayerData.m_SetItemPriceList) + TrimToBaseGameSize(CPlayerData.m_AverageItemCostList) + TrimToBaseGameSize(CPlayerData.m_GeneratedCostPriceList) + TrimToBaseGameSize(CPlayerData.m_GeneratedMarketPriceList) + TrimToBaseGameSize(CPlayerData.m_ItemPricePercentChangeList) + TrimToBaseGameSize(CPlayerData.m_ItemPricePercentPastChangeList) + TrimToBaseGameSize(CPlayerData.m_StockSoldList);
			if (num > 0)
			{
				ModLogger.Info($"Removed {num} redundant pad entries from base game item lists", "PropagateLoadDataPostfix", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\CGameDataPatches.cs");
			}
		}

		private static int TrimToBaseGameSize<T>(List<T> list)
		{
			if (list == null || list.Count <= 500)
			{
				return 0;
			}
			int num = list.Count - 500;
			list.RemoveRange(500, num);
			return num;
		}
	}
	[HarmonyPatch(typeof(CGameManager))]
	internal class CGameManagerPatches
	{
		[HarmonyPatch("LoadLobbySceneAsync")]
		[HarmonyPostfix]
		private static IEnumerator LoadLobbySceneAsyncPostfix(IEnumerator __result, string sceneName, CGameManager __instance)
		{
			__result.MoveNext();
			yield return __result.Current;
			LoadingScreenMessageService loadingScreenMessages = new LoadingScreenMessageService();
			loadingScreenMessages.Initialize();
			loadingScreenMessages.Start((MonoBehaviour)(object)__instance);
			BundleLoadingManager loadManager = new BundleLoadingManager();
			((MonoBehaviour)__instance).StartCoroutine(loadManager.LoadBundlesAsync(Paths.PluginPath));
			float displayedProgress = 0f;
			while (!loadManager.isLoadingComplete)
			{
				displayedProgress = Mathf.MoveTowards(displayedProgress, loadManager.LoadingProgress, Time.deltaTime * 0.4f);
				LoadingScreen.SetPercentDone((int)(displayedProgress * 50f));
				yield return null;
			}
			LoadingScreen.SetPercentDone(50);
			AsyncOperation asyncLoad = SceneManager.LoadSceneAsync(sceneName);
			while (!asyncLoad.isDone)
			{
				float num = asyncLoad.progress / 0.9f;
				LoadingScreen.SetPercentDone(50 + (int)(num * 50f));
				yield return null;
			}
			loadingScreenMessages.Stop((MonoBehaviour)(object)__instance);
		}
	}
	[HarmonyPatch(typeof(CheckPricePanelUI))]
	internal class CheckPricePanelUIPatches
	{
		[HarmonyPatch("InitCard")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitCardTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Expected O, but got Unknown
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Expected O, but got Unknown
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Expected O, but got Unknown
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01af: Expected O, but got Unknown
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c2: Expected O, but got Unknown
			//IL_01cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Expected O, but got Unknown
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Expected O, but got Unknown
			//IL_0227: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Expected O, but got Unknown
			ConstructorInfo constructorInfo = AccessTools.Constructor(typeof(CardData), (Type[])null, false);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "expansionType");
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo eplRuntimeServiceGet = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo cardExpansionServiceGet = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo getMonsterDataMethod = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(CardDataFactory), "Create", (Type[])null, (Type[])null);
			LocalBuilder localCardData = il.DeclareLocal(typeof(CardData));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Newobj, (object)constructorInfo, (string)null)
			});
			if (val.IsValid)
			{
				int pos = val.Pos;
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
				{
					new CodeMatch((OpCode?)OpCodes.Stfld, (object)fieldInfo, (string)null)
				});
				if (val.IsValid)
				{
					int pos2 = val.Pos;
					val.Start().Advance(pos).RemoveInstructions(pos2 - pos + 1)
						.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
						{
							new CodeInstruction(OpCodes.Ldarg_2, (object)null),
							new CodeInstruction(OpCodes.Ldarg_3, (object)null),
							new CodeInstruction(OpCodes.Ldarg, (object)4),
							new CodeInstruction(OpCodes.Ldarg, (object)5),
							new CodeInstruction(OpCodes.Call, (object)methodInfo2),
							new CodeInstruction(OpCodes.Stloc_0, (object)null)
						})
						.Start()
						.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
						{
							new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
							new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
							new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
						})
						.Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
						{
							//IL_0020: Unknown result type (might be due to invalid IL or missing references)
							//IL_0026: Expected O, but got Unknown
							//IL_0033: Unknown result type (might be due to invalid IL or missing references)
							//IL_0039: Expected O, but got Unknown
							//IL_0046: Unknown result type (might be due to invalid IL or missing references)
							//IL_004c: Expected O, but got Unknown
							//IL_0059: Unknown result type (might be due to invalid IL or missing references)
							//IL_005f: Expected O, but got Unknown
							//IL_006c: Unknown result type (might be due to invalid IL or missing references)
							//IL_0072: Expected O, but got Unknown
							matcher.Advance(1).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
							{
								new CodeInstruction(OpCodes.Stloc_S, (object)localCardData),
								new CodeInstruction(OpCodes.Call, (object)eplRuntimeServiceGet),
								new CodeInstruction(OpCodes.Callvirt, (object)cardExpansionServiceGet),
								new CodeInstruction(OpCodes.Ldloc_S, (object)localCardData),
								new CodeInstruction(OpCodes.Callvirt, (object)getMonsterDataMethod)
							});
						}, (Action<string>)null);
				}
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("InitItem")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitItemTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0086: 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)
			//IL_00a6: Expected O, but got Unknown
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Expected O, but got Unknown
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Expected O, but got Unknown
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(CheckPricePanelUI), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(CheckPricePanelUI), "m_ItemType");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[3]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(CheckPriceScreen))]
	internal class CheckPriceScreenPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyPrefix]
		private static void InitPrefix(CheckPriceScreen __instance)
		{
			EplRuntimeData.Services.ShopService.SetupCheckPriceScreenUI(__instance);
		}

		[HarmonyPatch("EvaluateItemPanelUI")]
		[HarmonyPostfix]
		private static void EvaluateItemPanelUIPostfix(CheckPriceScreen __instance, int pageIndex)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			ShopInventoryManager shopInventoryManager = EplRuntimeData.Services.ShopInventoryManager;
			List<EItemType> customShopItemsForCheckPricePage = shopInventoryManager.GetCustomShopItemsForCheckPricePage(pageIndex);
			if (customShopItemsForCheckPricePage.Count == 0)
			{
				return;
			}
			int baseGameItemCountForCheckPricePage = shopInventoryManager.GetBaseGameItemCountForCheckPricePage(pageIndex);
			for (int i = 0; i < customShopItemsForCheckPricePage.Count; i++)
			{
				int num = baseGameItemCountForCheckPricePage + i;
				if (num < __instance.m_CheckPricePanelUIList.Count)
				{
					CheckPricePanelUI val = __instance.m_CheckPricePanelUIList[num];
					val.InitItem(__instance, customShopItemsForCheckPricePage[i]);
					((UIElementBase)val).SetActive(true);
					__instance.m_ScrollEndParent.transform.parent = ((Component)val).transform;
					__instance.m_ScrollEndParent.transform.position = ((Component)val).transform.position;
					((GenericSliderScreen)__instance).m_ScrollEndPosParent = __instance.m_ScrollEndParent;
					continue;
				}
				break;
			}
		}
	}
	[HarmonyPatch(typeof(CollectionBinderFlipAnimCtrl))]
	internal class CollectionBinderFlipAnimCtrlPatches
	{
		[HarmonyPatch("UpdateBinderAllCardUI")]
		[HarmonyPrefix]
		private static bool UpdateBinderAllCardUIPrefix(CollectionBinderFlipAnimCtrl __instance, int binderIndex, int pageIndex)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(__instance.m_ExpansionType, out ModCardExpansionData value))
			{
				return true;
			}
			if (pageIndex <= 0 || pageIndex > __instance.m_MaxIndex)
			{
				return false;
			}
			for (int i = 0; i < __instance.m_BinderPageGrpList[binderIndex].m_CardList.Count; i++)
			{
				__instance.m_BinderPageGrpList[binderIndex].SetSingleCard(i, (CardData)null, 0, __instance.m_SortingType);
				int num = (pageIndex - 1) * 12 + i;
				if (num < __instance.m_SortedIndexList.Count)
				{
					int num2 = __instance.m_SortedIndexList[num];
					EMonsterType key = value.SortedMonsterTypes[value.HasRandomFoils ? (num2 >> 1) : num2];
					CardData val = value.Cards[key].ToCardData();
					if (value.HasRandomFoils)
					{
						val.isFoil = (num2 & 1) == 1;
					}
					int cardAmountByIndex = CPlayerData.GetCardAmountByIndex(num2, val.expansionType, false);
					__instance.m_BinderPageGrpList[binderIndex].SetSingleCard(i, val, cardAmountByIndex, __instance.m_SortingType);
				}
			}
			return false;
		}

		[HarmonyPatch("EnterViewUpCloseState")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> EnterViewUpCloseStateTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Expected O, but got Unknown
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(CardData));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(1).RemoveInstruction().InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				})
					.RemoveInstruction();
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("SortByCardRarity")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> SortByCardRarityTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo expansionTypeField = AccessTools.Field(typeof(CollectionBinderFlipAnimCtrl), "m_ExpansionType");
			MethodInfo eplRuntimeServiceGet = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo cardExpansionServiceGet = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo getMonsterDataMethod = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[2]
			{
				typeof(ECardExpansionType),
				typeof(EMonsterType)
			}, (Type[])null);
			LocalBuilder localMonsterType = il.DeclareLocal(typeof(EMonsterType));
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				//IL_001a: Expected O, but got Unknown
				//IL_0027: Unknown result type (might be due to invalid IL or missing references)
				//IL_002d: Expected O, but got Unknown
				//IL_003a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Expected O, but got Unknown
				//IL_0048: Unknown result type (might be due to invalid IL or missing references)
				//IL_004e: Expected O, but got Unknown
				//IL_005b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0061: Expected O, but got Unknown
				//IL_006e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0074: Expected O, but got Unknown
				//IL_0081: Unknown result type (might be due to invalid IL or missing references)
				//IL_0087: Expected O, but got Unknown
				matcher.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[7]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localMonsterType),
					new CodeInstruction(OpCodes.Call, (object)eplRuntimeServiceGet),
					new CodeInstruction(OpCodes.Callvirt, (object)cardExpansionServiceGet),
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)expansionTypeField),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localMonsterType),
					new CodeInstruction(OpCodes.Callvirt, (object)getMonsterDataMethod)
				}).RemoveInstruction();
			}, (Action<string>)null).InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(CollectionBinderUI))]
	internal class CollectionBinderUIPatches
	{
		[HarmonyPatch("OpenSortAlbumScreen")]
		[HarmonyPrefix]
		private static void OpenSortAlbumScreenPrefix(CollectionBinderUI __instance, int sortingMethodIndex, int currentExpansionIndex, bool isGradedCardAlbum)
		{
			EplRuntimeData.Services.CollectionBinderService.OpenScreen(__instance);
		}

		[HarmonyPatch("OpenSortAlbumScreen")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OpenSortAlbumScreenTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Expected O, but got Unknown
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Expected O, but got Unknown
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Expected O, but got Unknown
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_3, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction op) => op.opcode == OpCodes.Brfalse || op.opcode == OpCodes.Brfalse_S), (string)null)
			});
			if (val.IsValid)
			{
				int pos = val.Pos;
				val.MatchForward(true, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)null, (string)null)
				});
				if (val.IsValid)
				{
					int num = val.Pos + 1;
					val.Start().Advance(pos).RemoveInstructions(num - pos);
				}
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("OpenSortAlbumScreen")]
		[HarmonyPostfix]
		private static void OpenSortAlbumScreenPostfix(int sortingMethodIndex, int currentExpansionIndex, bool isGradedCardAlbum)
		{
			Canvas.ForceUpdateCanvases();
		}
	}
	[HarmonyPatch(typeof(CPlayerData))]
	internal class CPlayerDataPatches
	{
		private class ShownMonsterIndexLookup
		{
			public Dictionary<EMonsterType, int> IndexByType = new Dictionary<EMonsterType, int>();

			public int SourceCount = -1;
		}

		private static readonly ConditionalWeakTable<List<EMonsterType>, ShownMonsterIndexLookup> shownMonsterIndexLookups = new ConditionalWeakTable<List<EMonsterType>, ShownMonsterIndexLookup>();

		private static readonly ECardBorderType[] standardBorderTypes;

		private static readonly ECardBorderType[] ghostBorderTypes;

		[HarmonyPatch("GetCardCollectedList")]
		[HarmonyPrefix]
		private static bool GetCardCollectedListPrefix(ECardExpansionType expansionType, bool isDimension, ref List<int>? __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data.CardCountList;
			return false;
		}

		[HarmonyPatch("GetIsCardCollectedList")]
		[HarmonyPrefix]
		private static bool GetIsCardCollectedListPrefix(ECardExpansionType expansionType, bool isDimension, ref List<bool>? __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data.IsCardCollectedList;
			return false;
		}

		[HarmonyPatch("GetCardMarketPrice", new Type[]
		{
			typeof(int),
			typeof(ECardExpansionType),
			typeof(bool),
			typeof(int)
		})]
		[HarmonyPrefix]
		private static bool GetCardMarketPricePrefix(int index, ECardExpansionType expansionType, bool isDestiny, int cardGrade, ref float __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data.CardMarketPriceList[index].GetMarketPrice(index, cardGrade);
			return false;
		}

		[HarmonyPatch("GetCardMarketPrice", new Type[] { typeof(CardData) })]
		[HarmonyPrefix]
		private static bool GetCardMarketPricePrefix(CardData cardData, ref float __result)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			__result = data.CardMarketPriceList[cardSaveIndex].GetMarketPrice(cardSaveIndex, cardData.cardGrade);
			return false;
		}

		[HarmonyPatch("GetCardAmountPerMonsterType")]
		[HarmonyPrefix]
		private static bool GetCardAmountPerMonsterTypePrefix(ECardExpansionType expansionType, bool includeFoilCount, ref int __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			__result = ((!(value.HasRandomFoils && includeFoilCount)) ? 1 : 2);
			return false;
		}

		[HarmonyPatch("GetCardBorderType")]
		[HarmonyPrefix]
		private static bool GetCardBorderTypePrefix(int borderTypeIndex, ECardExpansionType expansionType, ref ECardBorderType __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(expansionType))
			{
				return true;
			}
			__result = (ECardBorderType)borderTypeIndex;
			return false;
		}

		[HarmonyPatch("GetCardBorderType")]
		[HarmonyPrefix]
		private static bool GetCardBorderTypeBaseGamePrefix(int borderTypeIndex, ECardExpansionType expansionType, ref ECardBorderType __result)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Invalid comparison between Unknown and I4
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Config.OptimizeCardBorderTypeLookups || EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(expansionType))
			{
				return true;
			}
			ECardBorderType[] array = (((int)expansionType == 2) ? ghostBorderTypes : standardBorderTypes);
			__result = array[borderTypeIndex % CPlayerData.GetCardAmountPerMonsterType(expansionType, false)];
			return false;
		}

		[HarmonyPatch("GetCardSaveIndex")]
		[HarmonyPrefix]
		private static bool GetCardSaveIndex(CardData cardData, ref int __result)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			__result = (value.MonsterTypeIndexLookup.TryGetValue(cardData.monsterType, out var value2) ? value2 : (-1));
			if (value.HasRandomFoils)
			{
				__result = __result * 2 + (cardData.isFoil ? 1 : 0);
			}
			return false;
		}

		[HarmonyPatch("GetCardSaveIndex")]
		[HarmonyPrefix]
		private static bool GetCardSaveIndexBaseGamePrefix(CardData cardData, ref int __result)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: 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_00c7: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Config.OptimizeCardSaveIndexLookups || EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
			{
				return true;
			}
			List<EMonsterType> shownMonsterList = InventoryBase.GetShownMonsterList(cardData.expansionType);
			ShownMonsterIndexLookup orCreateValue = shownMonsterIndexLookups.GetOrCreateValue(shownMonsterList);
			if (orCreateValue.SourceCount != shownMonsterList.Count)
			{
				orCreateValue.IndexByType.Clear();
				for (int i = 0; i < shownMonsterList.Count; i++)
				{
					orCreateValue.IndexByType.TryAdd(shownMonsterList[i], i);
				}
				orCreateValue.SourceCount = shownMonsterList.Count;
			}
			__result = (orCreateValue.IndexByType.TryGetValue(cardData.monsterType, out var value) ? (value * CPlayerData.GetCardAmountPerMonsterType(cardData.expansionType, true) + cardData.borderType) : 0);
			if (cardData.isFoil)
			{
				__result += CPlayerData.GetCardAmountPerMonsterType(cardData.expansionType, false);
			}
			return false;
		}

		[HarmonyPatch("GetCardPrice")]
		[HarmonyPrefix]
		private static bool GetCardPricePrefix(CardData cardData, ref float __result)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			if (cardData.cardGrade > data.GradedCardPriceList[cardSaveIndex].Count)
			{
				return true;
			}
			double value = ((cardData.cardGrade > 0) ? ((double)data.GradedCardPriceList[cardSaveIndex][cardData.cardGrade - 1]) : ((double)data.CardPriceList[cardSaveIndex]));
			value = ((GameInstance.GetCurrencyConversionRate() > 1f) ? Math.Round(value, 3, MidpointRounding.AwayFromZero) : Math.Round(value, 2, MidpointRounding.AwayFromZero));
			__result = (float)value;
			return false;
		}

		[HarmonyPatch("GetCardPriceUsingIndex")]
		[HarmonyPrefix]
		private static bool GetCardPriceUsingIndexPrefix(int index, ECardExpansionType expansionType, bool isDestiny, int cardGrade, ref float __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			if (cardGrade > data.GradedCardPriceList[index].Count)
			{
				return true;
			}
			double value = ((cardGrade > 0) ? ((double)data.GradedCardPriceList[index][cardGrade - 1]) : ((double)data.CardPriceList[index]));
			value = ((GameInstance.GetCurrencyConversionRate() > 1f) ? Math.Round(value, 3, MidpointRounding.AwayFromZero) : Math.Round(value, 2, MidpointRounding.AwayFromZero));
			__result = (float)value;
			return false;
		}

		[HarmonyPatch("SetCardPrice")]
		[HarmonyPrefix]
		private static bool SetCardPricePrefix(CardData cardData, float priceSet)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Expected O, but got Unknown
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			if (cardData.cardGrade > data.GradedCardPriceList[cardSaveIndex].Count)
			{
				return true;
			}
			if (cardData.cardGrade > 0)
			{
				data.GradedCardPriceList[cardSaveIndex][cardData.cardGrade - 1] = priceSet;
			}
			else
			{
				data.CardPriceList[cardSaveIndex] = priceSet;
			}
			CEventManager.QueueEvent((CEvent)new CEventPlayer_CardPriceChanged(cardData, priceSet));
			return false;
		}

		[HarmonyPatch("SetCardGeneratedMarketPrice")]
		[HarmonyPrefix]
		private static bool SetCardGeneratedMarketPricePrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, float price)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			data.CardMarketPriceList[cardIndex].generatedMarketPrice = price;
			return false;
		}

		[HarmonyPatch("AddCardPricePercentChange")]
		[HarmonyPrefix]
		private static bool AddCardPricePercentChangePrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, float percentChange)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			MarketPrice obj = data.CardMarketPriceList[cardIndex];
			float num = (obj.pricePercentChangeList += percentChange);
			if (num < -80f)
			{
				data.CardMarketPriceList[cardIndex].pricePercentChangeList = -80f;
			}
			if (num > 200f)
			{
				data.CardMarketPriceList[cardIndex].pricePercentChangeList = 200f;
			}
			return false;
		}

		[HarmonyPatch("GetCardPricePercentChange")]
		[HarmonyPrefix]
		private static bool GetCardPricePercentChangePrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, ref float __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data.CardMarketPriceList[cardIndex].pricePercentChangeList;
			return false;
		}

		[HarmonyPatch("UpdatePastCardPricePercentChange")]
		[HarmonyPostfix]
		private static void UpdatePastCardPricePercentChangePostfix()
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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)
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(key, out CardExpansionSaveData data))
				{
					continue;
				}
				foreach (MarketPrice cardMarketPrice in data.CardMarketPriceList)
				{
					MarketPrice val = cardMarketPrice;
					if (val.pastPricePercentChangeList == null)
					{
						val.pastPricePercentChangeList = new List<float>();
					}
					cardMarketPrice.pastPricePercentChangeList.Add(cardMarketPrice.pricePercentChangeList);
					if (cardMarketPrice.pastPricePercentChangeList.Count > 30)
					{
						cardMarketPrice.pastPricePercentChangeList.RemoveRange(0, cardMarketPrice.pastPricePercentChangeList.Count - 30);
					}
				}
			}
		}

		[HarmonyPatch("GetPastCardPricePercentChange")]
		[HarmonyPrefix]
		private static bool GetPastCardPricePercentChangePrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, ref List<float> __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			MarketPrice val = data.CardMarketPriceList[cardIndex];
			MarketPrice val2 = val;
			if (val2.pastPricePercentChangeList == null)
			{
				val2.pastPricePercentChangeList = new List<float>();
			}
			if (val.pastPricePercentChangeList.Count == 0)
			{
				val.pastPricePercentChangeList.Add(val.pricePercentChangeList);
			}
			__result = val.pastPricePercentChangeList;
			if (__result.Count > 30)
			{
				__result.RemoveRange(0, __result.Count - 30);
			}
			return false;
		}

		[HarmonyPatch("GetCardMarketPriceCustomPercent")]
		[HarmonyPrefix]
		private static bool GetCardMarketPriceCustomPercentPrefix(int index, ECardExpansionType expansionType, bool isDestiny, float percent, int cardGrade, ref float __result)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			__result = data.CardMarketPriceList[index].GetMarketPriceCustomPercent(percent, index, cardGrade);
			return false;
		}

		[HarmonyPatch("AddCard")]
		[HarmonyPrefix]
		private static bool AddCardPrefix(CardData cardData, int addAmount)
		{
			//IL_000b: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			if (cardData.cardGrade > 0)
			{
				CPlayerData.m_GradedCardInventoryList.Add(new CompactCardDataAmount
				{
					cardSaveIndex = cardSaveIndex,
					amount = cardData.cardGrade,
					expansionType = cardData.expansionType,
					isDestiny = cardData.isDestiny,
					gradedCardIndex = CPlayerData.m_GradedCardInventoryList.Count + 1
				});
				return false;
			}
			data.CardCountList[cardSaveIndex] += addAmount;
			data.IsCardCollectedList[cardSaveIndex] = true;
			return false;
		}

		[HarmonyPatch("ReduceCard")]
		[HarmonyPrefix]
		private static bool ReduceCardPrefix(CardData cardData, int reduceAmount)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			data.CardCountList[cardSaveIndex] -= reduceAmount;
			return false;
		}

		[HarmonyPatch("ReduceCardUsingIndex")]
		[HarmonyPrefix]
		private static bool ReduceCardUsingIndexPrefix(int index, ECardExpansionType expansionType, bool isDestiny, int reduceAmount)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			data.CardCountList[index] -= reduceAmount;
			return false;
		}

		[HarmonyPatch("SetCard")]
		[HarmonyPrefix]
		private static bool SetCardPrefix(CardData cardData, int amount)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(cardData.expansionType, out CardExpansionSaveData data))
			{
				return true;
			}
			int cardSaveIndex = CPlayerData.GetCardSaveIndex(cardData);
			data.CardCountList[cardSaveIndex] = amount;
			return false;
		}

		[HarmonyPatch("GetCardData")]
		[HarmonyPrefix]
		private static bool GetCardDataPrefix(int cardIndex, ECardExpansionType expansionType, bool isDestiny, ref CardData __result)
		{
			//IL_000f: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			int num = cardIndex;
			if (value.HasRandomFoils)
			{
				num >>= 1;
			}
			EMonsterType key = value.SortedMonsterTypes[num];
			ModCardData modCardData = value.Cards[key];
			__result = modCardData.ToCardData();
			if (value.HasRandomFoils)
			{
				__result.isFoil = (cardIndex & 1) == 1;
			}
			return false;
		}

		[HarmonyPatch("GetGradedCardData")]
		[HarmonyPrefix]
		private static bool GetGradedCardDataPrefix(CompactCardDataAmount compactCardData, ref CardData __result)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(compactCardData.expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			EMonsterType monsterTypeFromCardSaveIndex = CPlayerData.GetMonsterTypeFromCardSaveIndex(compactCardData.cardSaveIndex, compactCardData.expansionType);
			CardData val = value.Cards[monsterTypeFromCardSaveIndex].ToCardData();
			val.gradedCardIndex = compactCardData.gradedCardIndex;
			val.cardGrade = compactCardData.amount;
			if (value.HasRandomFoils)
			{
				val.isFoil = (compactCardData.cardSaveIndex & 1) == 1;
			}
			__result = val;
			return false;
		}

		[HarmonyPatch("GetTotalCardCollectedAmount")]
		[HarmonyPostfix]
		private static int GetTotalCardCollectedAmountPostfix(int __result)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			int num = 0;
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				if (!EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(key, out CardExpansionSaveData data))
				{
					continue;
				}
				foreach (int cardCount in data.CardCountList)
				{
					num += cardCount;
				}
			}
			return __result + num;
		}

		[HarmonyPatch("GetFullCardTypeName")]
		[HarmonyPrefix]
		private static bool GetFullCardTypeNamePrefix(CardData cardData, bool ignoreRarity, ref string __result)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			ModCardData value2;
			string text = ((!ignoreRarity && value.Cards.TryGetValue(cardData.monsterType, out value2)) ? StringExtensions.Prettierize(((object)Unsafe.As<ERarity, ERarity>(ref value2.MonsterData.Rarity)/*cast due to .constrained prefix*/).ToString().Split("_").Last()) : string.Empty);
			string text2 = (cardData.isFoil ? LocalizationManager.GetTranslation("Foil", true, 0, true, false, (GameObject)null, (string)null, true) : string.Empty);
			__result = (text + " " + text2).Trim();
			return false;
		}

		static CPlayerDataPatches()
		{
			ECardBorderType[] array = new ECardBorderType[6];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			standardBorderTypes = (ECardBorderType[])(object)array;
			ghostBorderTypes = (ECardBorderType[])(object)new ECardBorderType[1] { (ECardBorderType)5 };
		}
	}
	[HarmonyPatch(typeof(CSaveLoad))]
	internal class CSaveLoadPatches
	{
		[HarmonyPatch("Save")]
		[HarmonyPrefix]
		private static void SavePrefix(int saveSlotIndex, bool skipJSONSave)
		{
			if (!Directory.Exists(Application.persistentDataPath + "/PrefabLoader"))
			{
				Directory.CreateDirectory(Application.persistentDataPath + "/PrefabLoader");
			}
			EplRuntimeData.Services.SaveDataManager.SaveToFile(string.Format("{0}/PrefabLoader/{1}_{2}", Application.persistentDataPath, "EnhancedPrefabLoader", saveSlotIndex));
		}

		[HarmonyPatch("Load")]
		[HarmonyPrefix]
		private static void LoadPrefix(int slotIndex)
		{
			SaveDataService saveDataManager = EplRuntimeData.Services.SaveDataManager;
			if (File.Exists(string.Format("{0}/PrefabLoader/{1}_{2}", Application.persistentDataPath, "EnhancedPrefabLoader", slotIndex)))
			{
				saveDataManager.LoadFromFile(string.Format("{0}/PrefabLoader/{1}_{2}", Application.persistentDataPath, "EnhancedPrefabLoader", slotIndex));
			}
		}
	}
	[HarmonyPatch(typeof(CustomerManager))]
	internal class CustomerManagerPatches
	{
		internal class HiddenItemsState
		{
			public List<InteractableObject> DecoObjects = new List<InteractableObject>();

			public List<InteractableObject> Interactables = new List<InteractableObject>();

			public List<Shelf> Shelves = new List<Shelf>();

			public List<InteractablePlayTable> PlayTables = new List<InteractablePlayTable>();

			public bool HasData
			{
				get
				{
					if (DecoObjects.Count <= 0 && Interactables.Count <= 0 && Shelves.Count <= 0)
					{
						return PlayTables.Count > 0;
					}
					return true;
				}
			}
		}

		[HarmonyPatch("EvaluateMaxCustomerCount")]
		[HarmonyPrefix]
		private static void EvaluateMaxCustomerCountPrefix(ref HiddenItemsState __state)
		{
			HiddenItemsState state = new HiddenItemsState();
			__state = state;
			ShelfManager instance = CSingleton<ShelfManager>.Instance;
			instance.m_DecoObjectList.RemoveAll(delegate(InteractableObject x)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				if ((int)x.m_DecoObjectType >= 200000)
				{
					state.DecoObjects.Add(x);
					return true;
				}
				return false;
			});
			instance.m_InteractableObjectList.RemoveAll(delegate(InteractableObject x)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				if ((int)x.m_ObjectType >= 200000)
				{
					state.Interactables.Add(x);
					return true;
				}
				return false;
			});
			instance.m_ShelfList.RemoveAll(delegate(Shelf x)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				if ((int)((InteractableObject)x).m_ObjectType >= 200000)
				{
					state.Shelves.Add(x);
					return true;
				}
				return false;
			});
			instance.m_PlayTableList.RemoveAll(delegate(InteractablePlayTable x)
			{
				//IL_0001: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Invalid comparison between Unknown and I4
				if ((int)((InteractableObject)x).m_ObjectType >= 200000)
				{
					state.PlayTables.Add(x);
					return true;
				}
				return false;
			});
		}

		[HarmonyPatch("EvaluateMaxCustomerCount")]
		[HarmonyPostfix]
		private static void EvaluateMaxCustomerCountPostfix(CustomerManager __instance, HiddenItemsState __state)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			if (!__state.HasData || __instance.m_CustomerCountMax >= 20)
			{
				return;
			}
			float extraBonus = 0f;
			foreach (InteractableObject decoObject in __state.DecoObjects)
			{
				DecoPurchaseData itemDecoPurchaseData = InventoryBase.GetItemDecoPurchaseData(decoObject.m_DecoObjectType);
				if (itemDecoPurchaseData != null)
				{
					extraBonus += itemDecoPurchaseData.price / 20000f;
				}
			}
			ProcessList<InteractableObject>(__state.Interactables);
			ProcessList<Shelf>(__state.Shelves);
			ProcessList<InteractablePlayTable>(__state.PlayTables);
			__instance.m_CustomerCountMax = Mathf.Clamp(__instance.m_CustomerCountMax + Mathf.RoundToInt(extraBonus), 0, 25);
			void ProcessList<T>(List<T> items) where T : notnull, InteractableObject
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				foreach (T item in items)
				{
					ObjectData objectData = InventoryBase.GetObjectData(((InteractableObject)item).m_ObjectType);
					if (objectData != null)
					{
						extraBonus += objectData.decoBonus;
					}
				}
			}
		}

		[HarmonyPatch("EvaluateMaxCustomerCount")]
		[HarmonyFinalizer]
		private static void EvaluateMaxCustomerCountFinalizer(HiddenItemsState __state)
		{
			if (__state != null && __state.HasData)
			{
				ShelfManager instance = CSingleton<ShelfManager>.Instance;
				if (__state.DecoObjects.Count > 0)
				{
					instance.m_DecoObjectList.AddRange(__state.DecoObjects);
				}
				if (__state.Interactables.Count > 0)
				{
					instance.m_InteractableObjectList.AddRange(__state.Interactables);
				}
				if (__state.Shelves.Count > 0)
				{
					instance.m_ShelfList.AddRange(__state.Shelves);
				}
				if (__state.PlayTables.Count > 0)
				{
					instance.m_PlayTableList.AddRange(__state.PlayTables);
				}
			}
		}
	}
	[HarmonyPatch(typeof(CustomerTradeCardScreen))]
	internal class CustomerTradeCardScreenPatches
	{
		[HarmonyPatch("SetCustomer")]
		[HarmonyPrefix]
		private static bool SetCustomerPrefix(CustomerTradeCardScreen __instance, Customer customer, CustomerTradeData customerTradeData)
		{
			EplRuntimeData.Services.CardTradeManager.SetCustomer(__instance, customer, customerTradeData);
			return false;
		}
	}
	[HarmonyPatch(typeof(DeckEditScreen))]
	internal class DeckEditScreenPatches
	{
		private const string UnsupportedCardText = "Cards from custom expansions can't be used in decks";

		[HarmonyPatch("UpdateSelectedCardData")]
		[HarmonyPrefix]
		private static bool UpdateSelectedCardDataPrefix(DeckEditScreen __instance, CardData cardData)
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			if (cardData == null || !EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
			{
				return true;
			}
			CPlayerData.AddCard(cardData, 1);
			NotEnoughResourceTextPopup instance = CSingleton<NotEnoughResourceTextPopup>.Instance;
			if (Object.op_Implicit((Object)(object)instance))
			{
				instance.ShowRawText("Cards from custom expansions can't be used in decks");
			}
			((UIScreenBase)__instance).m_ControllerScreenUIExtension.SetControllerUIActive(true);
			return false;
		}
	}
	internal static class FastPackOpeningCompatibilityPatches
	{
		[HarmonyPatch]
		internal class SetMeshMaterialListPatch
		{
			private static readonly List<MethodBase> targetMethods = new List<MethodBase>();

			private static bool Prepare()
			{
				if (!IsFastPackOpeningLoaded())
				{
					return false;
				}
				targetMethods.Clear();
				Type type = AccessTools.TypeByName("FastPackOpening.Patches");
				string[] array = new string[2] { "InteractionPlayerController_EvaluateOpenCardPack_Prefix", "InteractionPlayerController_OnGameDataFinishLoaded_Postfix" };
				foreach (string text in array)
				{
					MethodInfo methodInfo = AccessTools.Method(type, text, (Type[])null, (Type[])null);
					if ((object)methodInfo == null)
					{
						ModLogger.Error("[FastPackOpeningCompatibilityPatches]: Could not resolve FastPackOpening.Patches." + text + ", skipping it", "Prepare", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\FastPackOpeningCompatibilityPatches.cs");
					}
					else
					{
						targetMethods.Add(methodInfo);
					}
				}
				return targetMethods.Count > 0;
			}

			private static IEnumerable<MethodBase> TargetMethods()
			{
				return targetMethods;
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase original)
			{
				//IL_0043: Unknown result type (might be due to invalid IL or missing references)
				//IL_0049: Expected O, but got Unknown
				//IL_005f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0065: Expected O, but got Unknown
				//IL_0073: Unknown result type (might be due to invalid IL or missing references)
				//IL_0079: Expected O, but got Unknown
				//IL_0087: Unknown result type (might be due to invalid IL or missing references)
				//IL_008d: Expected O, but got Unknown
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Expected O, but got Unknown
				//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
				//IL_00d8: Expected O, but got Unknown
				//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e6: Expected O, but got Unknown
				MethodInfo methodInfo = AccessTools.Method(typeof(Item), "SetMesh", (Type[])null, (Type[])null);
				FieldInfo fieldInfo = AccessTools.Field(typeof(ItemMeshData), "materialList");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(ItemMeshData), "materialSecondary");
				CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldnull, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
				});
				if (val.IsValid)
				{
					object operand = val.Instruction.operand;
					val.Advance(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
					{
						new CodeInstruction(OpCodes.Ldloc_S, operand),
						new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo)
					}).RemoveInstructions(1);
				}
				else
				{
					ModLogger.Error("[FastPackOpeningCompatibilityPatches]: Failed to find the SetMesh call in " + original.Name + ", EPL items spawned by FastPackOpening will not get random materials", "Transpiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\FastPackOpeningCompatibilityPatches.cs");
				}
				return val.InstructionEnumeration();
			}
		}

		[HarmonyPatch]
		internal class UpdateExpPatch
		{
			private static bool Prepare()
			{
				if (!IsFastPackOpeningLoaded())
				{
					return false;
				}
				if ((object)ResolveTarget() == null)
				{
					ModLogger.Error("[FastPackOpeningCompatibilityPatches]: Could not resolve FastPackOpening.Patches.CardOpeningSequence_Update_Prefix, card exp will use FastPackOpening's vanilla formula", "Prepare", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\FastPackOpeningCompatibilityPatches.cs");
					return false;
				}
				return true;
			}

			private static MethodBase TargetMethod()
			{
				return ResolveTarget();
			}

			private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
			{
				//IL_0062: Unknown result type (might be due to invalid IL or missing references)
				//IL_007c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0082: Expected O, but got Unknown
				//IL_0090: Unknown result type (might be due to invalid IL or missing references)
				//IL_0096: Expected O, but got Unknown
				//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
				//IL_00aa: Expected O, but got Unknown
				//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00be: Expected O, but got Unknown
				//IL_0104: Unknown result type (might be due to invalid IL or missing references)
				//IL_010a: Expected O, but got Unknown
				//IL_0118: Unknown result type (might be due to invalid IL or missing references)
				//IL_011e: Expected O, but got Unknown
				//IL_012c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0132: Expected O, but got Unknown
				//IL_018e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0194: Expected O, but got Unknown
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a2: Expected O, but got Unknown
				//IL_01aa: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b0: Expected O, but got Unknown
				//IL_01b9: Unknown result type (might be due to invalid IL or missing references)
				//IL_01bf: Expected O, but got Unknown
				//IL_01c7: Unknown result type (might be due to invalid IL or missing references)
				//IL_01cd: Expected O, but got Unknown
				//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dc: Expected O, but got Unknown
				List<CodeInstruction> list = instructions.ToList();
				FieldInfo fieldInfo = AccessTools.Field(typeof(CardOpeningSequence), "m_TotalExpGained");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(CardOpeningSequence), "m_ManualOpenCardDataList");
				MethodInfo methodInfo = AccessTools.Method(typeof(List<CardData>), "get_Item", (Type[])null, (Type[])null);
				MethodInfo methodInfo2 = AccessTools.Method(typeof(CardOpeningSequencePatches), "ProcessCardExp", (Type[])null, (Type[])null);
				CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Add, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Stfld, (object)fieldInfo, (string)null)
				});
				if (!val.IsValid)
				{
					ModLogger.Error("[FastPackOpeningCompatibilityPatches.UpdateExpPatch]: Failed to find the exp accumulation, card exp will use FastPackOpening's vanilla formula", "Transpiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\FastPackOpeningCompatibilityPatches.cs");
					return list;
				}
				int pos = val.Pos;
				val.MatchBack(false, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
				});
				if (!val.IsValid)
				{
					ModLogger.Error("[FastPackOpeningCompatibilityPatches.UpdateExpPatch]: Failed to find the card list access, card exp will use FastPackOpening's vanilla formula", "Transpiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\FastPackOpeningCompatibilityPatches.cs");
					return list;
				}
				object operand = val.Advance(1).Instruction.operand;
				val.Start().Advance(pos + 1).RemoveInstruction()
					.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
					{
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Ldind_Ref, (object)null),
						new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
						new CodeInstruction(OpCodes.Ldloc_S, operand),
						new CodeInstruction(OpCodes.Callvirt, (object)methodInfo),
						new CodeInstruction(OpCodes.Call, (object)methodInfo2)
					});
				return val.InstructionEnumeration();
			}

			private static MethodBase ResolveTarget()
			{
				return AccessTools.Method(AccessTools.TypeByName("FastPackOpening.Patches"), "CardOpeningSequence_Update_Prefix", (Type[])null, (Type[])null);
			}
		}

		private static bool IsFastPackOpeningLoaded()
		{
			return Chainloader.PluginInfos.ContainsKey("FastPackOpening");
		}
	}
	[HarmonyPatch(typeof(FurnitureShopConfirmPurchaseScreen))]
	internal class FurnitureShopConfirmPurchaseScreenPatches
	{
		[HarmonyPatch("UpdateData")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateDataTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(FurnitureShopConfirmPurchaseScreen), "m_Image");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(FurniturePurchaseData), "icon");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[2]
			{
				typeof(Image),
				typeof(FurniturePurchaseData)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(FurnitureShopPanelUI))]
	internal class FurnitureShopPanelUIPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Expected O, but got Unknown
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(FurnitureShopPanelUI), "m_Image");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(FurniturePurchaseData), "icon");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[2]
			{
				typeof(Image),
				typeof(FurniturePurchaseData)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(FurnitureShopUIScreen))]
	internal class FurnitureShopUIScreenPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyPrefix]
		private static void InitPrefix(FurnitureShopUIScreen __instance)
		{
			EplRuntimeData.Services.ShopService.SetupFurnitureShopUI(__instance);
		}

		[HarmonyPatch("OnPressPanelUIButton")]
		[HarmonyPrefix]
		private static bool OnPressPanelUIButtonPrefix(int index)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			FurniturePurchaseData furniturePurchaseData = InventoryBase.GetFurniturePurchaseData(index);
			if (furniturePurchaseData != null)
			{
				return !EplRuntimeData.Services.BundleMaintenanceService.TryBlockPurchase(furniturePurchaseData.objectType);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(HostTournamentScreen))]
	internal class HostTournamentScreenPatches
	{
		[HarmonyPatch("EvaluateSideRewardImage")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> EvaluateSideRewardImageTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected O, but got Unknown
			//IL_0119: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Expected O, but got Unknown
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(HostTournamentScreen), "m_RewardSideItemImageList");
			MethodInfo methodInfo = AccessTools.Method(typeof(List<Image>), "get_Item", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo listGetItemTypeMethod = AccessTools.Method(typeof(List<EItemType>), "get_Item", (Type[])null, (Type[])null);
			MethodInfo replacementSetSpriteMethod = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			return new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[6]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction i) => i.opcode == OpCodes.Ldloc_S || i.opcode == OpCodes.Ldc_I4_2 || i.opcode == OpCodes.Ldc_I4_1), (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				//IL_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_007a: Expected O, but got Unknown
				//IL_0088: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Expected O, but got Unknown
				//IL_009b: Unknown result type (might be due to invalid IL or missing references)
				//IL_00a1: Expected O, but got Unknown
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b4: Expected O, but got Unknown
				int num = -1;
				while (matcher.Pos + num >= 0 && !CodeInstructionExtensions.Calls(matcher.InstructionAt(num), listGetItemTypeMethod))
				{
					num--;
				}
				if (matcher.Pos + num < 0)
				{
					ModLogger.Error("EvaluateSideRewardImage transpiler could not locate the item index feeding a reward image, leaving this site unpatched", "EvaluateSideRewardImageTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\HostTournamentScreenPatches.cs");
					matcher.Advance(6);
				}
				else
				{
					CodeInstruction val = matcher.InstructionAt(num - 1);
					matcher.Advance(4).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
					{
						new CodeInstruction(OpCodes.Ldloc_1, (object)null),
						new CodeInstruction(val.opcode, val.operand),
						new CodeInstruction(OpCodes.Callvirt, (object)listGetItemTypeMethod),
						new CodeInstruction(OpCodes.Call, (object)replacementSetSpriteMethod)
					});
				}
			}, (Action<string>)null).InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(InteractableAutoPackOpener))]
	internal class InteractableAutoPackOpenerPatches
	{
		[HarmonyPatch("OpenPack")]
		[HarmonyPrefix]
		private static bool OpenPackPrefix(InteractableAutoPackOpener __instance)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(__instance.m_StoredItemList[0].GetItemType(), out CardGenerationData _))
			{
				return true;
			}
			__instance.m_PackOpenedCount++;
			foreach (CardData item2 in EplRuntimeData.Services.ItemService.GeneratePackContent(__instance.m_StoredItemList[0].GetItemType()))
			{
				int cardSaveIndex = CPlayerData.GetCardSaveIndex(item2);
				bool flag = false;
				for (int i = 0; i < __instance.m_CompactCardDataAmountList.Count; i++)
				{
					if (__instance.m_CompactCardDataAmountList[i].cardSaveIndex == cardSaveIndex && __instance.m_CompactCardDataAmountList[i].expansionType == item2.expansionType)
					{
						flag = true;
						CompactCardDataAmount obj = __instance.m_CompactCardDataAmountList[i];
						obj.amount++;
						break;
					}
				}
				if (!flag)
				{
					CompactCardDataAmount item = new CompactCardDataAmount
					{
						expansionType = item2.expansionType,
						isDestiny = false,
						cardSaveIndex = cardSaveIndex,
						amount = 1
					};
					__instance.m_CompactCardDataAmountList.Add(item);
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(InteractablePlayTable))]
	internal class InteractablePlayTablePatches
	{
		[HarmonyPatch("CustomerHasReached")]
		[HarmonyPrefix]
		private static void CustomerHasReachedPrefix(InteractablePlayTable __instance)
		{
			if (__instance.m_CurrentPlayerCount + 1 >= __instance.m_MaxSeatCount)
			{
				EplRuntimeData.Services.PlayTableService.RollExpansionFor(__instance);
			}
		}

		[HarmonyPatch("StopTableGame")]
		[HarmonyPostfix]
		private static void StopTableGamePostfix(InteractablePlayTable __instance)
		{
			EplRuntimeData.Services.PlayTableService.ClearTableGame(__instance);
		}
	}
	[HarmonyPatch(typeof(InteractableWorkbench))]
	internal class InteractableWorkbenchPatches
	{
		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix(InteractableWorkbench __instance)
		{
			foreach (var (_, list2) in EplRuntimeData.Assets.ItemLibrary.BulkBoxes)
			{
				if (list2.Count > 0)
				{
					__instance.m_ValidStoreItemTypeList.AddRange(list2.Select<(int, EItemType), EItemType>(((int MinPrice, EItemType ItemType) b) => b.ItemType));
				}
			}
		}

		[HarmonyPatch("GetBulkBoxItemType")]
		[HarmonyPrefix]
		private static bool GetBulkBoxItemTypePrefix(ECardExpansionType cardExpansionType, float totalPrice, ref EItemType __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.ItemLibrary.BulkBoxes.TryGetValue(cardExpansionType, out List<(int, EItemType)> value) || value.Count == 0)
			{
				return true;
			}
			foreach (var (num, val) in value)
			{
				if (totalPrice > (float)num)
				{
					__result = (EItemType)(int)val;
					return false;
				}
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(InteractionPlayerController))]
	internal class InteractionPlayerControllerPatches
	{
		private static Mesh? vanillaOpenBoxMesh;

		private static Material? vanillaOpenBoxMaterial;

		[HarmonyPatch("EvaluateOpenCardPack")]
		[HarmonyPrefix]
		private static void EvaluateOpenCardPackPrefix(InteractionPlayerController __instance, out EItemType __state)
		{
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected I4, but got Unknown
			__state = (EItemType)(-1);
			if (GameBuild.HasItemMaterialPropertyBlocks && __instance.m_HoldItemList.Count > 0 && !__instance.CanOpenPack() && __instance.CanOpenCardBox())
			{
				__state = (EItemType)(int)__instance.m_HoldItemList[0].GetItemType();
			}
		}

		[HarmonyPatch("EvaluateOpenCardPack")]
		[HarmonyPostfix]
		private static void EvaluateOpenCardPackPostfix(InteractionPlayerController __instance, EItemType __state)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			MeshRenderer openCardBoxMesh = __instance.m_OpenCardBoxMesh;
			MeshFilter openCardBoxMeshFilter = __instance.m_OpenCardBoxMeshFilter;
			if ((int)__state != -1 && Object.op_Implicit((Object)(object)openCardBoxMesh) && Object.op_Implicit((Object)(object)openCardBoxMeshFilter))
			{
				if (!Object.op_Implicit((Object)(object)vanillaOpenBoxMesh))
				{
					vanillaOpenBoxMesh = openCardBoxMeshFilter.sharedMesh;
					vanillaOpenBoxMaterial = ((Renderer)openCardBoxMesh).sharedMaterial;
				}
				if (EplRuntimeData.Assets.ItemLibrary.ItemMeshData.TryGetValue(__state, out ItemMeshData value))
				{
					openCardBoxMeshFilter.sharedMesh = value.mesh;
					((Renderer)openCardBoxMesh).sharedMaterial = value.material;
				}
				else
				{
					openCardBoxMeshFilter.sharedMesh = vanillaOpenBoxMesh;
					((Renderer)openCardBoxMesh).sharedMaterial = vanillaOpenBoxMaterial;
				}
			}
		}

		[HarmonyPatch("IsHoldingSpray")]
		[HarmonyPrefix]
		private static bool IsHoldingSprayPrefix(InteractionPlayerController __instance, ref bool __result)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.m_HoldItemList.Count <= 0 || !EplRuntimeData.Assets.ItemLibrary.ItemData.ContainsKey(__instance.m_HoldItemList[0].GetItemType()))
			{
				return true;
			}
			__result = EplRuntimeData.Assets.ItemLibrary.SprayCanList.Contains(__instance.m_HoldItemList[0].GetItemType());
			return false;
		}

		[HarmonyPatch("IsCardPackType")]
		[HarmonyPrefix]
		private static bool IsCardPackTypePrefix(EItemType itemType, ref bool __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(itemType, out ModItemData value))
			{
				return true;
			}
			__result = !value.BaseItemData.isNotBoosterPack;
			return false;
		}

		[HarmonyPatch("CanOpenCardBox")]
		[HarmonyPrefix]
		private static bool CanOpenCardBoxPrefix(InteractionPlayerController __instance, ref bool __result)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (__instance.m_HoldItemList.Count == 0)
			{
				return true;
			}
			if (!EplRuntimeData.Assets.LookupLibrary.SpawnPackLookup.ContainsKey(__instance.m_HoldItemList[0].GetItemType()))
			{
				return true;
			}
			__result = true;
			return false;
		}

		[HarmonyPatch("CardBoxToCardPack")]
		[HarmonyPrefix]
		private static bool CardBoxToCardPackPrefix(EItemType cardBoxItemType, ref EItemType __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.SpawnPackLookup.TryGetValue(cardBoxItemType, out var value))
			{
				return true;
			}
			__result = (EItemType)(int)value;
			return false;
		}
	}
	[HarmonyPatch(typeof(InventoryBase))]
	internal class InventoryBasePatches
	{
		private class MonsterDataLookup
		{
			public Dictionary<EMonsterType, MonsterData> ByType = new Dictionary<EMonsterType, MonsterData>();

			public int SourceCount = -1;
		}

		private static readonly ConditionalWeakTable<List<MonsterData>, MonsterDataLookup> monsterDataLookups = new ConditionalWeakTable<List<MonsterData>, MonsterDataLookup>();

		private static readonly Dictionary<EItemType, List<int>> restockIndexLookup = new Dictionary<EItemType, List<int>>();

		private static int restockBaseCount = -1;

		private static int restockModCount = -1;

		internal static void InvalidateRestockDataLookup()
		{
			restockBaseCount = -1;
			restockModCount = -1;
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix()
		{
			EplRuntimeData.Events.FireOnInventoryBaseAwake();
		}

		[HarmonyPatch("GetItemData")]
		[HarmonyPrefix]
		private static bool GetItemDataPrefix(EItemType itemType, ref ItemData __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(itemType, out ModItemData value))
			{
				return true;
			}
			__result = value.BaseItemData;
			return false;
		}

		[HarmonyPatch("GetItemMeshData")]
		[HarmonyPrefix]
		private static bool GetItemMeshDataPrefix(EItemType itemType, ref ItemMeshData __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.ItemLibrary.ItemMeshData.TryGetValue(itemType, out ItemMeshData value))
			{
				return true;
			}
			__result = value;
			return false;
		}

		[HarmonyPatch("GetCardUISetting")]
		[HarmonyPrefix]
		private static bool GetCardUISettingsPrefix(ECardExpansionType expansionType, ref CardUISetting __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(expansionType))
			{
				return true;
			}
			__result = CSingleton<InventoryBase>.Instance.m_MonsterData_SO.m_CardUISettingList[0];
			return false;
		}

		[HarmonyPatch("GetCardUISettingWithBorder")]
		[HarmonyPrefix]
		private static bool GetCardUISettingsWithBorderPrefix(ECardExpansionType expansionType, ref CardUISetting __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(expansionType))
			{
				return true;
			}
			__result = CSingleton<InventoryBase>.Instance.m_MonsterData_SO.m_CardUISettingList[0];
			return false;
		}

		[HarmonyPatch("GetCardExpansionType")]
		[HarmonyPrefix]
		private static bool GetCardExpansionTypePrefix(ECollectionPackType collectionPackType, ref ECardExpansionType __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.ExpansionLookup.TryGetValue(collectionPackType, out var value))
			{
				return true;
			}
			__result = (ECardExpansionType)(int)value;
			return false;
		}

		[HarmonyPatch("ItemTypeToCollectionPackType")]
		[HarmonyPrefix]
		private static bool ItemTypeToCollectionPackTypePrefix(EItemType itemType, ref ECollectionPackType __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected I4, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(itemType, out CardGenerationData value))
			{
				return true;
			}
			__result = (ECollectionPackType)(int)value.PackType;
			return false;
		}

		[HarmonyPatch("GetRandomItemTypeFromCategory")]
		[HarmonyPrefix]
		private static bool GetRandomItemTypeFromCategoryPrefix(EItemCategory category, bool unlockedOnly, ref EItemType __result)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: 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_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Expected I4, but got Unknown
			List<EItemType> list = new List<EItemType>();
			List<EItemType> list2 = new List<EItemType>();
			List<ItemData> itemDataList = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ItemDataList;
			for (int i = 0; i < itemDataList.Count; i++)
			{
				if (itemDataList[i].category == category)
				{
					AddIfEligible(list, (EItemType)i, unlockedOnly);
				}
			}
			foreach (var (itemType, modItemData2) in EplRuntimeData.Assets.ItemLibrary.ItemData)
			{
				if (modItemData2.BaseItemData.category == category)
				{
					AddIfEligible(list2, itemType, unlockedOnly);
				}
			}
			__result = (EItemType)(int)PickCandidate(list, list2);
			return false;
		}

		[HarmonyPatch("GetShownMonsterList")]
		[HarmonyPrefix]
		private static bool GetShownMonsterListPrefix(ECardExpansionType expansionType, ref List<EMonsterType> __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			__result = value.SortedMonsterTypes;
			return false;
		}

		[HarmonyPatch("GetCardExpansionName")]
		[HarmonyPrefix]
		private static bool GetCardExpansionNamePrefix(ECardExpansionType cardExpansion, ref string __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardExpansion, out ModCardExpansionData value))
			{
				return true;
			}
			__result = value.Name;
			return false;
		}

		[HarmonyPatch("GetMonsterData", new Type[] { typeof(EMonsterType) })]
		[HarmonyPrefix]
		private static bool GetMonsterDataPrefix(EMonsterType monsterType, ref MonsterData? __result)
		{
			//IL_000e: 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_0014: Invalid comparison between Unknown and I4
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Invalid comparison between Unknown and I4
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Invalid comparison between Unknown and I4
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Invalid comparison between Unknown and I4
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Invalid comparison between Unknown and I4
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Invalid comparison between Unknown and I4
			if (!EplRuntimeData.Config.OptimizeMonsterDataLookups)
			{
				return true;
			}
			if ((int)monsterType == 0 || ((int)monsterType >= 122 && (int)monsterType < 1000))
			{
				__result = null;
				return false;
			}
			MonsterData_ScriptableObject monsterData_SO = CSingleton<InventoryBase>.Instance.m_MonsterData_SO;
			List<MonsterData> list = null;
			if ((int)monsterType < 122)
			{
				list = monsterData_SO.m_DataList;
			}
			else if ((int)monsterType > 122 && (int)monsterType < 1113)
			{
				list = monsterData_SO.m_MegabotDataList;
			}
			else if ((int)monsterType > 1113 && (int)monsterType < 2050)
			{
				list = monsterData_SO.m_FantasyRPGDataList;
			}
			else if ((int)monsterType > 2050 && (int)monsterType < 3040)
			{
				list = monsterData_SO.m_CatJobDataList;
			}
			if (list != null && TryResolveMonsterData(list, monsterType, out MonsterData result))
			{
				__result = result;
				return false;
			}
			return true;
		}

		[HarmonyPatch("GetRestockDataUsingItemType")]
		[HarmonyPrefix]
		private static bool GetRestockDataUsingItemTypePrefix(EItemType itemType, ref List<RestockData> __result)
		{
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Config.OptimizeRestockDataLookups)
			{
				return true;
			}
			List<RestockData> restockDataList = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList;
			Dictionary<EItemType, List<int>> dictionary = GetRestockIndexLookup(restockDataList);
			__result = new List<RestockData>();
			if (dictionary.TryGetValue(itemType, out List<int> value))
			{
				foreach (int item in value)
				{
					RestockData restockDataAt = GetRestockDataAt(restockDataList, item);
					restockDataAt.index = item;
					__result.Add(restockDataAt);
				}
			}
			return false;
		}

		[HarmonyPatch("GetRestockDataIndex")]
		[HarmonyPrefix]
		private static bool GetRestockDataIndexPrefix(EItemType itemType, ref int __result)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Config.OptimizeRestockDataLookups)
			{
				return true;
			}
			Dictionary<EItemType, List<int>> dictionary = GetRestockIndexLookup(CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList);
			__result = (dictionary.TryGetValue(itemType, out var value) ? value[0] : (-1));
			return false;
		}

		[HarmonyPatch("GetRestockDataIndexList")]
		[HarmonyPrefix]
		private static bool GetRestockDataIndexListPrefix(EItemType itemType, ref List<int> __result)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Config.OptimizeRestockDataLookups)
			{
				return true;
			}
			Dictionary<EItemType, List<int>> dictionary = GetRestockIndexLookup(CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList);
			__result = (dictionary.TryGetValue(itemType, out var value) ? value.ToList() : new List<int>());
			return false;
		}

		[HarmonyPatch("GetUnlockItemLevelRequired")]
		[HarmonyPrefix]
		private static bool GetUnlockItemLevelRequiredPrefix(EItemType itemType, ref int __result)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Config.OptimizeRestockDataLookups)
			{
				return true;
			}
			List<RestockData> restockDataList = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList;
			Dictionary<EItemType, List<int>> dictionary = GetRestockIndexLookup(restockDataList);
			__result = (dictionary.TryGetValue(itemType, out var value) ? GetRestockDataAt(restockDataList, value[0]).licenseShopLevelRequired : 0);
			return false;
		}

		private static EItemType PickCandidate(List<EItemType> baseCandidates, List<EItemType> eplCandidates)
		{
			//IL_002a: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			if (eplCandidates.Count > 0 && Random.Range(0, 100) < EplRuntimeData.Config.PreferEplTableItemsChance)
			{
				return eplCandidates[Random.Range(0, eplCandidates.Count)];
			}
			int num = baseCandidates.Count + eplCandidates.Count;
			if (num == 0)
			{
				return (EItemType)(-1);
			}
			int num2 = Random.Range(0, num);
			if (num2 >= baseCandidates.Count)
			{
				return eplCandidates[num2 - baseCandidates.Count];
			}
			return baseCandidates[num2];
		}

		private static void AddIfEligible(List<EItemType> candidates, EItemType itemType, bool unlockedOnly)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!unlockedOnly)
			{
				candidates.Add(itemType);
				return;
			}
			List<int> restockDataIndexList = InventoryBase.GetRestockDataIndexList(itemType);
			if (restockDataIndexList.Count > 0 && (CPlayerData.GetIsItemLicenseUnlocked(restockDataIndexList[0]) || (restockDataIndexList.Count > 1 && CPlayerData.GetIsItemLicenseUnlocked(restockDataIndexList[1]))))
			{
				candidates.Add(itemType);
			}
		}

		private static Dictionary<EItemType, List<int>> GetRestockIndexLookup(List<RestockData> baseList)
		{
			//IL_003f: 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)
			List<ModRestockData> restockEntries = EplRuntimeData.Assets.ItemLibrary.RestockEntries;
			if (restockBaseCount != baseList.Count || restockModCount != restockEntries.Count)
			{
				restockIndexLookup.Clear();
				for (int i = 0; i < baseList.Count; i++)
				{
					AddRestockIndex(baseList[i].itemType, i);
				}
				for (int j = 0; j < restockEntries.Count; j++)
				{
					AddRestockIndex(restockEntries[j].RestockData.itemType, baseList.Count + j);
				}
				restockBaseCount = baseList.Count;
				restockModCount = restockEntries.Count;
			}
			return restockIndexLookup;
		}

		private static void AddRestockIndex(EItemType itemType, int index)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (!restockIndexLookup.TryGetValue(itemType, out List<int> value))
			{
				value = new List<int>();
				restockIndexLookup[itemType] = value;
			}
			value.Add(index);
		}

		private static RestockData GetRestockDataAt(List<RestockData> baseList, int index)
		{
			if (index >= baseList.Count)
			{
				return EplRuntimeData.Assets.ItemLibrary.RestockEntries[index - baseList.Count].RestockData;
			}
			return baseList[index];
		}

		private static bool TryResolveMonsterData(List<MonsterData> sourceList, EMonsterType monsterType, out MonsterData? result)
		{
			//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)
			MonsterDataLookup orCreateValue = monsterDataLookups.GetOrCreateValue(sourceList);
			if (orCreateValue.SourceCount != sourceList.Count)
			{
				orCreateValue.ByType.Clear();
				for (int i = 0; i < sourceList.Count; i++)
				{
					orCreateValue.ByType.TryAdd(sourceList[i].MonsterType, sourceList[i]);
				}
				orCreateValue.SourceCount = sourceList.Count;
			}
			return orCreateValue.ByType.TryGetValue(monsterType, out result);
		}
	}
	[HarmonyPatch(typeof(Item))]
	internal class ItemPatches
	{
		[HarmonyPatch("SetMesh")]
		[HarmonyPrefix]
		private static bool SetMeshPrefix(Item __instance, Mesh mesh, Material material, EItemType itemType, Mesh meshSecondary, Material materialSecondary, List<Material> materialList)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			__instance.m_ItemType = itemType;
			MeshRenderer mesh2 = __instance.m_Mesh;
			__instance.m_MeshFilter.sharedMesh = mesh;
			if (materialList != null && materialList.Count > 0)
			{
				if (EplRuntimeData.BundleAssetTracker.GetBundleIdFor<EItemType>(itemType) != null)
				{
					((Renderer)mesh2).sharedMaterials = (Material[])(object)new Material[1] { materialList[Random.Range(0, materialList.Count)] };
				}
				else
				{
					((Renderer)mesh2).sharedMaterials = materialList.ToArray();
				}
			}
			else
			{
				((Renderer)mesh2).sharedMaterials = (Material[])(object)new Material[1] { material };
			}
			((Component)__instance.m_MeshFilterSecondary).gameObject.SetActive(false);
			if (Object.op_Implicit((Object)(object)meshSecondary))
			{
				__instance.m_MeshFilterSecondary.sharedMesh = meshSecondary;
				((Renderer)__instance.m_MeshSecondary).sharedMaterial = materialSecondary;
				((Component)__instance.m_MeshFilterSecondary).gameObject.SetActive(true);
			}
			else if (Object.op_Implicit((Object)(object)materialSecondary))
			{
				((Renderer)mesh2).sharedMaterials = (Material[])(object)new Material[2] { material, materialSecondary };
			}
			__instance.m_OutlineMeshFilter.sharedMesh = mesh;
			ItemData itemData = InventoryBase.GetItemData(itemType);
			__instance.m_Collider.size = itemData.colliderScale;
			__instance.m_Collider.center = itemData.colliderPosOffset;
			__instance.m_ItemVolume = itemData.GetItemVolume();
			__instance.m_ItemHandScaleOffset = itemData.itemHandScaleOffset;
			((Behaviour)__instance.m_InteractableScanItem).enabled = false;
			__instance.m_ItemContentFill = 1f;
			return false;
		}
	}
	[HarmonyPatch(typeof(ItemPriceGraphScreen))]
	internal class ItemPriceGraphScreenPatches
	{
		[HarmonyPatch("ShowCardPriceChart")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ShowCardPriceChartTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Expected O, but got Unknown
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Expected O, but got Unknown
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Expected O, but got Unknown
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_021b: Expected O, but got Unknown
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Expected O, but got Unknown
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0272: Expected O, but got Unknown
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Expected O, but got Unknown
			//IL_0289: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Expected O, but got Unknown
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_029e: Expected O, but got Unknown
			ConstructorInfo constructorInfo = AccessTools.Constructor(typeof(CardData), (Type[])null, false);
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(CardData), "cardGrade");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			MethodInfo methodInfo5 = AccessTools.Method(typeof(CardDataFactory), "Create", (Type[])null, (Type[])null);
			List<CodeInstruction> list = instructions.ToList();
			CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Newobj, (object)constructorInfo, (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[ItemPriceGraphScreenPatches.ShowCardPriceChartTranspiler]: Failed to find CardData ctor anchor, leaving ShowCardPriceChart unpatched", "ShowCardPriceChartTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\ItemPriceGraphScreenPatches.cs");
				return list;
			}
			int pos = val.Pos;
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Stfld, (object)fieldInfo2, (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[ItemPriceGraphScreenPatches.ShowCardPriceChartTranspiler]: Failed to find cardGrade anchor, leaving ShowCardPriceChart unpatched", "ShowCardPriceChartTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\ItemPriceGraphScreenPatches.cs");
				return list;
			}
			int pos2 = val.Pos;
			val.Start().Advance(pos).RemoveInstructions(pos2 - pos + 1)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Ldarg_2, (object)null),
					new CodeInstruction(OpCodes.Ldarg_3, (object)null),
					new CodeInstruction(OpCodes.Ldarg, (object)4),
					new CodeInstruction(OpCodes.Call, (object)methodInfo5),
					new CodeInstruction(OpCodes.Stloc_2, (object)null)
				})
				.Start()
				.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
				{
					new CodeMatch((OpCode?)OpCodes.Ldloc_2, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
				});
			if (!val.IsValid)
			{
				ModLogger.Error("[ItemPriceGraphScreenPatches.ShowCardPriceChartTranspiler]: Failed to find GetMonsterData anchor, leaving ShowCardPriceChart unpatched", "ShowCardPriceChartTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\ItemPriceGraphScreenPatches.cs");
				return list;
			}
			val.RemoveInstructions(3).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
			{
				new CodeInstruction(OpCodes.Call, (object)methodInfo2),
				new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
				new CodeInstruction(OpCodes.Ldloc_2, (object)null),
				new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
			});
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("ShowItemPriceChart")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ShowItemPriceChartTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(ItemPriceGraphScreen), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_2, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			else
			{
				ModLogger.Error("[ItemPriceGraphScreenPatches.ShowItemPriceChartTranspiler]: Failed to find item image sprite anchor, EPL item sprites will not show on the price graph", "ShowItemPriceChartTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\ItemPriceGraphScreenPatches.cs");
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch]
	internal class ItemSharedMaterialPatches
	{
		private static bool Prepare()
		{
			return GameBuild.HasItemSharedMaterialSlots;
		}

		private static MethodBase TargetMethod()
		{
			return AccessTools.Method(typeof(Item), "SetSharedMaterialForFirstSlot", (Type[])null, (Type[])null);
		}

		private static void Prefix(Item __instance, ref Material material)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.ItemLibrary.ItemMeshData.TryGetValue(__instance.m_ItemType, out ItemMeshData value) && value.materialList != null && value.materialList.Count != 0)
			{
				material = value.materialList[Random.Range(0, value.materialList.Count)];
			}
		}
	}
	[HarmonyPatch(typeof(LightManager))]
	internal class LightManagerPatches
	{
		private class ClockState
		{
			public int Hour = -1;

			public int Minute = -1;
		}

		private static readonly int colorPropertyId = Shader.PropertyToID("_Color");

		private static readonly int emissionColorPropertyId = Shader.PropertyToID("_EmissionColor");

		private static readonly ConditionalWeakTable<LightManager, ClockState> clockStates = new ConditionalWeakTable<LightManager, ClockState>();

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix(LightManager __instance)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			foreach (var (val, val2) in EplRuntimeData.Caches.LightingAwareMaterials)
			{
				val.SetColor(colorPropertyId, val2);
				__instance.m_ItemMatList.Add(val);
				__instance.m_ItemMatOriginalColorList.Add(val2);
			}
		}

		[HarmonyPatch("Update")]
		[HarmonyPostfix]
		private static void UpdatePostfix(LightManager __instance)
		{
			EplRuntimeData.Services.ScriptHookService.PollStateHooks(__instance);
		}

		[HarmonyPatch("EvaluateWorldUIBrightness")]
		[HarmonyPostfix]
		private static void EvaluateWorldUIBrightnessPostfix(LightManager __instance)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			Color val = __instance.m_CardBackMatOriginalEmissionColor * Mathf.Lerp(0.2f, 1f, __instance.m_GlobalBrightness);
			foreach (Material value in EplRuntimeData.Caches.CardBackMaterials.Values)
			{
				value.SetColor(emissionColorPropertyId, val);
			}
		}

		[HarmonyPatch("EvaluateTimeClock")]
		[HarmonyPrefix]
		private static bool EvaluateTimeClockPrefix(LightManager __instance)
		{
			//IL_0293: Unknown result type (might be due to invalid IL or missing references)
			//IL_029d: Expected O, but got Unknown
			if (!EplRuntimeData.Config.OptimizeClockUpdates)
			{
				return true;
			}
			if (__instance.m_TimeMin >= 60)
			{
				__instance.m_TimeMinFloat = 0f;
				__instance.m_TimeMin = 0;
				__instance.m_TimeHour++;
				for (int i = 0; i < CPlayerData.m_GradeCardInProgressList.Count; i++)
				{
					GradeCardSubmitSet obj = CPlayerData.m_GradeCardInProgressList[i];
					obj.m_MinutePassed += 60f;
				}
			}
			if (__instance.m_TimeHour >= 21 && __instance.m_TimeMin >= 0)
			{
				__instance.m_TimeHour = 21;
				__instance.m_TimeMin = 0;
			}
			ClockState orCreateValue = clockStates.GetOrCreateValue(__instance);
			if (orCreateValue.Hour != __instance.m_TimeHour || orCreateValue.Minute != __instance.m_TimeMin)
			{
				orCreateValue.Hour = __instance.m_TimeHour;
				orCreateValue.Minute = __instance.m_TimeMin;
				string text = ((__instance.m_TimeHour >= 12) ? "PM" : "AM");
				string text2 = ((__instance.m_TimeMin < 10) ? $"0{__instance.m_TimeMin}" : __instance.m_TimeMin.ToString());
				int num = ((__instance.m_TimeHour > 12) ? (__instance.m_TimeHour - 12) : __instance.m_TimeHour);
				string text3 = ((num < 10) ? $"0{num}" : num.ToString());
				__instance.m_TimeString = text3 + ":" + text2 + text;
			}
			if (__instance.m_TimeHour == 18 && __instance.m_TimeMin == 30)
			{
				__instance.m_TimeOfDayString = "Night";
				__instance.m_TImeOfDayIndex = 3;
				__instance.m_IsLerpingSunIntensity = true;
				__instance.m_LerpStartBrightness = __instance.m_GlobalBrightness;
				return false;
			}
			if (__instance.m_TimeHour == 16 && __instance.m_TimeMin == 0)
			{
				__instance.m_TimeOfDayString = "Evening";
				__instance.m_TImeOfDayIndex = 2;
				__instance.m_IsLerpingSunIntensity = true;
				__instance.m_LerpStartBrightness = __instance.m_GlobalBrightness;
				if (__instance.m_CanChangeBGM)
				{
					SoundManager.BlendToMusic("BGM_ShopNight", 0.1f, true);
				}
				return false;
			}
			if (__instance.m_TimeHour == 12 && __instance.m_TimeMin == 0)
			{
				__instance.m_TimeOfDayString = "Afternoon";
				__instance.m_TImeOfDayIndex = 1;
				__instance.m_IsLerpingSunIntensity = false;
				return false;
			}
			if (__instance.m_TimeHour == 8 && __instance.m_TimeMin == 0)
			{
				__instance.m_TimeOfDayString = "Morning";
				__instance.m_TImeOfDayIndex = 0;
				__instance.m_IsLerpingSunIntensity = false;
				__instance.m_HasDayEnded = false;
				return false;
			}
			if (__instance.m_TimeHour == 21 && __instance.m_TimeMin == 0)
			{
				__instance.m_TimeOfDayString = "Day End";
				__instance.m_HasDayEnded = true;
				__instance.m_TImeOfDayIndex = 4;
				__instance.m_IsLerpingSunIntensity = false;
				__instance.m_SkyboxBlender.rotationSpeed = 0f;
				CEventManager.QueueEvent((CEvent)new CEventPlayer_OnDayEnded());
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(LoadStreamTexture))]
	internal class LoadStreamTexturePatches
	{
		[HarmonyPatch("LoadPNG")]
		[HarmonyPostfix]
		private static void LoadPNGPostfix(Texture2D? __result)
		{
			if (EplRuntimeData.Config.ReduceStreamedTextureMemory && __result != null)
			{
				__result.Apply(false, true);
			}
		}

		[HarmonyPatch("WriteImageOnDisk")]
		[HarmonyPostfix]
		private static void WriteImageOnDiskPostfix(Texture2D texture)
		{
			if (EplRuntimeData.Config.ReduceStreamedTextureMemory)
			{
				texture.Apply(false, true);
			}
		}
	}
	[HarmonyPatch(typeof(MonsterData))]
	internal class MonsterDataPatches
	{
		private static readonly Dictionary<ERarity, string> rarityNames = new Dictionary<ERarity, string>();

		[HarmonyPatch("GetName")]
		[HarmonyPrefix]
		private static bool GetNamePrefix(MonsterData __instance, ref string __result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if ((int)__instance.MonsterType < 200000)
			{
				return true;
			}
			__result = __instance.Name;
			return false;
		}

		[HarmonyPatch("GetRarityName")]
		[HarmonyPostfix]
		private static void GetRarityNamePostfix(MonsterData __instance, ref string __result)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)__instance.MonsterType >= 200000)
			{
				if (!rarityNames.TryGetValue(__instance.Rarity, out string value))
				{
					value = StringExtensions.Prettierize(((object)Unsafe.As<ERarity, ERarity>(ref __instance.Rarity)/*cast due to .constrained prefix*/).ToString().Split("_").Last());
					rarityNames[__instance.Rarity] = value;
				}
				__result = value;
			}
		}

		[HarmonyPatch("GetIcon")]
		[HarmonyPrefix]
		private static bool GetIconPrefix(ECardExpansionType cardExpansionType, MonsterData __instance, ref Sprite __result)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardExpansionType))
			{
				return true;
			}
			__result = null;
			return false;
		}
	}
	[HarmonyPatch(typeof(PriceChangeManager))]
	internal class PriceChangeManagerPatches
	{
		[HarmonyPatch("UpdateCardMarketPrice")]
		[HarmonyPrefix]
		private static bool UpdateCardMarketPricePrefix(PriceChangeManager __instance, ECardExpansionType expansionType, EPriceChangeType priceChangeType, bool isIncrease)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Expected I4, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Invalid comparison between Unknown and I4
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Invalid comparison between Unknown and I4
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Invalid comparison between Unknown and I4
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Invalid comparison between Unknown and I4
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Invalid comparison between Unknown and I4
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Invalid comparison between Unknown and I4
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Invalid comparison between Unknown and I4
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Invalid comparison between Unknown and I4
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Invalid comparison between Unknown and I4
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			foreach (ModCardData value2 in value.Cards.Values)
			{
				int cardSaveIndex = CPlayerData.GetCardSaveIndex(value2.ToCardData());
				int num = (priceChangeType - 6) switch
				{
					11 => (value.HasRandomFoils ? ((cardSaveIndex & 1) == 1) : value2.IsFoil) ? 1 : 0, 
					12 => (value.HasRandomFoils ? ((cardSaveIndex & 1) == 0) : (!value2.IsFoil)) ? 1 : 0, 
					5 => ((int)value2.BorderType == 1) ? 1 : 0, 
					6 => ((int)value2.BorderType == 2) ? 1 : 0, 
					7 => ((int)value2.BorderType == 3) ? 1 : 0, 
					8 => ((int)value2.BorderType == 4) ? 1 : 0, 
					9 => ((int)value2.BorderType == 5) ? 1 : 0, 
					0 => ((int)value2.MonsterData.ElementIndex == 0) ? 1 : 0, 
					1 => ((int)value2.MonsterData.ElementIndex == 1) ? 1 : 0, 
					2 => ((int)value2.MonsterData.ElementIndex == 2) ? 1 : 0, 
					3 => ((int)value2.MonsterData.ElementIndex == 3) ? 1 : 0, 
					_ => 0, 
				};
				float num2 = Random.Range(__instance.m_PriceChangeMin, __instance.m_PriceChangeMax);
				if (num != 0)
				{
					num2 = (isIncrease ? num2 : (0f - num2));
					CPlayerData.AddCardPricePercentChange(cardSaveIndex, expansionType, false, num2);
				}
				int num3 = Random.Range(0, 100);
				if (num3 < 40)
				{
					if ((num3 & 1) == 0)
					{
						num2 = 0f - num2;
					}
					CPlayerData.AddCardPricePercentChange(cardSaveIndex, expansionType, false, num2 / 2.5f);
				}
			}
			return false;
		}

		[HarmonyPatch("EvaluatePriceCrash")]
		[HarmonyPostfix]
		private static void EvaluatePriceCrashPostfix(PriceChangeManager __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				__instance.EvaluateCardPriceCrash(key);
			}
		}

		[HarmonyPatch("EvaluatePriceChange")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> EvaluatePriceChangeTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(PriceChangeManagerPatches), "UpdateCustomExpansions", (Type[])null, (Type[])null);
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null);
			val.End().MatchBack(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ret, (object)null, (string)null)
			});
			if (val.IsValid)
			{
				val.Insert((CodeInstruction[])(object)new CodeInstruction[4]
				{
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldloc_2, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo)
				});
			}
			else
			{
				ModLogger.Error("[PriceChangeManagerPatches.EvaluatePriceChangeTranspiler]: Failed to find final Ret anchor, EPL expansions will not receive price changes", "EvaluatePriceChangeTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\PriceChangeManagerPatches.cs");
			}
			return val.InstructionEnumeration();
		}

		private static void UpdateCustomExpansions(PriceChangeManager priceChangeManager, EPriceChangeType positive, EPriceChangeType negative)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				priceChangeManager.UpdateCardMarketPrice(key, positive, true);
				priceChangeManager.UpdateCardMarketPrice(key, negative, false);
			}
		}
	}
	[HarmonyPatch(typeof(RestockItemBoardGameScreen))]
	internal class RestockItemBoardGameScreenPatches
	{
		[HarmonyPatch("EvaluateRestockItemPanelUI")]
		[HarmonyPrefix]
		private static void EvaluateRestockItemPanelUIPrefix(RestockItemBoardGameScreen __instance)
		{
			EplRuntimeData.Services.ShopService.SetupBoardgameShopUI(__instance);
		}
	}
	[HarmonyPatch(typeof(RestockItemPanelUI))]
	internal class RestockItemPanelUIPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Expected O, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Expected O, but got Unknown
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Expected O, but got Unknown
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Expected O, but got Unknown
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b7: Expected O, but got Unknown
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01df: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Expected O, but got Unknown
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(RestockItemPanelUI), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "get_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			FieldInfo itemTypeField = AccessTools.Field(typeof(RestockItemPanelUI), "m_ItemType");
			MethodInfo replacementSetSpriteMethod = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction instruction) => CodeInstructionExtensions.IsLdloc(instruction, (LocalBuilder)null)), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
			});
			if (val.IsValid)
			{
				CodeInstruction itemDataLoad = val.InstructionAt(1).Clone();
				val.Advance(1).RemoveInstructions(3).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
				{
					itemDataLoad,
					new CodeInstruction(OpCodes.Ldarg_0, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)itemTypeField),
					new CodeInstruction(OpCodes.Call, (object)replacementSetSpriteMethod)
				});
				val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
				{
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null),
					new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
				}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
				{
					//IL_0029: Unknown result type (might be due to invalid IL or missing references)
					//IL_002f: Expected O, but got Unknown
					//IL_003c: Unknown result type (might be due to invalid IL or missing references)
					//IL_0042: Expected O, but got Unknown
					//IL_004f: Unknown result type (might be due to invalid IL or missing references)
					//IL_0055: Expected O, but got Unknown
					matcher.Advance(1).RemoveInstructions(4).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
					{
						itemDataLoad.Clone(),
						new CodeInstruction(OpCodes.Ldarg_0, (object)null),
						new CodeInstruction(OpCodes.Ldfld, (object)itemTypeField),
						new CodeInstruction(OpCodes.Call, (object)replacementSetSpriteMethod)
					});
				}, (Action<string>)null);
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("OnPressPurchaseButton")]
		[HarmonyPrefix]
		private static bool OnPressPurchaseButtonPrefix(RestockItemPanelUI __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			return !EplRuntimeData.Services.BundleMaintenanceService.TryBlockPurchase(__instance.m_ItemType);
		}
	}
	[HarmonyPatch(typeof(RestockItemScreen))]
	internal class RestockItemScreenPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyPrefix]
		private static void InitPrefix(RestockItemScreen __instance)
		{
			EplRuntimeData.Services.ShopService.SetupItemShopUI(__instance);
		}

		[HarmonyPatch("OnPressAddToCartButton")]
		[HarmonyPrefix]
		private static bool OnPressAddToCartButtonPrefix(int index)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			RestockData restockData = InventoryBase.GetRestockData(index);
			if (restockData != null)
			{
				return !EplRuntimeData.Services.BundleMaintenanceService.TryBlockPurchase(restockData.itemType);
			}
			return true;
		}
	}
	[HarmonyPatch(typeof(RestockManager))]
	internal class RestockManagerPatches
	{
		[HarmonyPatch("Init")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_01a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Expected O, but got Unknown
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0222: Expected O, but got Unknown
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			//IL_024a: Expected O, but got Unknown
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Expected O, but got Unknown
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Expected O, but got Unknown
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0309: Expected O, but got Unknown
			//IL_0311: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Expected O, but got Unknown
			//IL_0320: Unknown result type (might be due to invalid IL or missing references)
			//IL_0326: Expected O, but got Unknown
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Expected O, but got Unknown
			//IL_0340: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Expected O, but got Unknown
			//IL_034f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0355: Expected O, but got Unknown
			//IL_035d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0363: Expected O, but got Unknown
			//IL_03a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a8: Expected O, but got Unknown
			//IL_03b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b6: Expected O, but got Unknown
			//IL_03be: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c4: Expected O, but got Unknown
			//IL_03cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Services");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplServices), "ItemService");
			MethodInfo methodInfo3 = AccessTools.Method(typeof(ItemService), "GenerateItemCost", new Type[1] { typeof(int) }, (Type[])null);
			MethodInfo methodInfo4 = AccessTools.Method(typeof(ItemService), "GenerateItemMarketPrice", new Type[2]
			{
				typeof(int),
				typeof(float)
			}, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(ItemData), "baseCost");
			List<CodeInstruction> list = instructions.ToList();
			object obj = ((IEnumerable<CodeInstruction>)list).FirstOrDefault((Func<CodeInstruction, bool>)((CodeInstruction c) => c.opcode == OpCodes.Call && c.operand is MethodInfo { Name: "InvokeGet_Item" } methodInfo5 && methodInfo5.ReturnType == typeof(float)))?.operand;
			object obj2 = ((IEnumerable<CodeInstruction>)list).FirstOrDefault((Func<CodeInstruction, bool>)((CodeInstruction c) => c.opcode == OpCodes.Ldsfld && c.operand is FieldInfo fieldInfo2 && fieldInfo2.Name == "m_GeneratedCostPriceList"))?.operand;
			if (obj == null || obj2 == null)
			{
				ModLogger.Error("[RestockManagerPatches.InitTranspiler]: Failed to find weaved accessor anchors, leaving Init unpatched", "InitTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\RestockManagerPatches.cs");
				return list;
			}
			CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null);
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[RestockManagerPatches.InitTranspiler]: Failed to find baseCost anchor", "InitTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\RestockManagerPatches.cs");
				return list;
			}
			int num = val.Pos - 6;
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"CPlayerData.m_GeneratedCostPriceList", (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[RestockManagerPatches.InitTranspiler]: Failed to find cost Ldstr anchor", "InitTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\RestockManagerPatches.cs");
				return list;
			}
			int pos = val.Pos;
			int num2 = pos + 2;
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction c) => c.opcode == OpCodes.Ldsfld && c.operand is FieldInfo fieldInfo2 && fieldInfo2.Name == "m_GeneratedMarketPriceList"), (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_1, (object)null, (string)null),
				new CodeMatch((Func<CodeInstruction, bool>)((CodeInstruction c) => c.opcode == OpCodes.Ldsfld && c.operand is FieldInfo fieldInfo2 && fieldInfo2.Name == "m_GeneratedCostPriceList"), (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[RestockManagerPatches.InitTranspiler]: Failed to find default market frame anchor", "InitTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\RestockManagerPatches.cs");
				return list;
			}
			int pos2 = val.Pos;
			int num3 = pos2 + 2;
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Ldstr, (object)"CPlayerData.m_GeneratedMarketPriceList", (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[RestockManagerPatches.InitTranspiler]: Failed to find market Ldstr anchor", "InitTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\RestockManagerPatches.cs");
				return list;
			}
			int pos3 = val.Pos;
			val.Start().Advance(num3).RemoveInstructions(pos3 - num3)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[8]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo2),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldsfld, obj2),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldstr, (object)"CPlayerData.m_GeneratedCostPriceList"),
					new CodeInstruction(OpCodes.Call, obj),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				})
				.Start()
				.Advance(num2)
				.RemoveInstructions(pos2 - num2)
				.Start()
				.Advance(num)
				.RemoveInstructions(pos - num)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[4]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo2),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3)
				});
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("Init")]
		[HarmonyPostfix]
		private static void InitPostfix(RestockManager __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			foreach (ECardExpansionType key in EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.Keys)
			{
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<ECardExpansionType, CardExpansionSaveData>(key, out CardExpansionSaveData _))
				{
					__instance.GenerateCardMarketPrice(key);
				}
			}
		}

		[HarmonyPatch("Awake")]
		[HarmonyPostfix]
		private static void AwakePostfix()
		{
			EplRuntimeData.Events.FireOnRestockManagerAwake();
		}

		[HarmonyPatch("GenerateCardMarketPrice")]
		[HarmonyPrefix]
		private static bool GenerateCardMarketPricePrefix(ECardExpansionType expansionType)
		{
			//IL_000f: 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_0080: 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)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return true;
			}
			List<ModCardData> list = value.Cards.Values.OrderBy((ModCardData data) => (int)data.MonsterData.MonsterType).ToList();
			for (int num = 0; num < list.Count; num++)
			{
				int num2 = (value.HasRandomFoils ? (num * 2) : num);
				if (CPlayerData.GetCardMarketPrice(num2, expansionType, false, 0) == 0f)
				{
					float num3 = EplRuntimeData.Services.CardExpansionService.GenerateCardMarketPrice(expansionType, list[num].MonsterData.MonsterType, list[num].IsFoil);
					CPlayerData.SetCardGeneratedMarketPrice(num2, expansionType, false, num3);
				}
				if (value.HasRandomFoils && CPlayerData.GetCardMarketPrice(num2 + 1, expansionType, false, 0) == 0f)
				{
					float num4 = EplRuntimeData.Services.CardExpansionService.GenerateCardMarketPrice(expansionType, list[num].MonsterData.MonsterType, isFoil: true);
					CPlayerData.SetCardGeneratedMarketPrice(num2 + 1, expansionType, false, num4);
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(SetItemPriceScreen))]
	internal class SetItemPriceScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> OpenScreenTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(SetItemPriceScreen), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(3).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(SettingScreen))]
	internal class SettingScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyPostfix]
		private static void OpenScreenPostfix(bool isTitleScreen)
		{
			if (EplRuntimeData.IsBundleLoadingComplete)
			{
				EplRuntimeData.Services.SettingsScreenService.Initialize(CSingleton<SettingScreen>.Instance, isTitleScreen);
				EplRuntimeData.Services.SettingsScreenService.HideModScreen();
			}
		}

		[HarmonyPatch("OnPressGameSetting")]
		[HarmonyPostfix]
		private static void OnPressGameSettingPostfix()
		{
			EplRuntimeData.Services.SettingsScreenService.HideModScreen();
		}

		[HarmonyPatch("OnPressDisplaySetting")]
		[HarmonyPostfix]
		private static void OnPressDisplaySettingPostfix()
		{
			EplRuntimeData.Services.SettingsScreenService.HideModScreen();
		}

		[HarmonyPatch("OnPressLanguage")]
		[HarmonyPostfix]
		private static void OnPressLanguagePostfix()
		{
			EplRuntimeData.Services.SettingsScreenService.HideModScreen();
		}

		[HarmonyPatch("OnPressKeybindSetting")]
		[HarmonyPostfix]
		private static void OnPressKeybindSettingPostfix()
		{
			EplRuntimeData.Services.SettingsScreenService.HideModScreen();
		}
	}
	[HarmonyPatch(typeof(ShelfManager))]
	internal class ShelfManagerPatches
	{
		private class ShelfVisibilityState
		{
			public bool? IsVisible;
		}

		private static readonly ConditionalWeakTable<Shelf, ShelfVisibilityState> shelfVisibilityStates = new ConditionalWeakTable<Shelf, ShelfVisibilityState>();

		private static float nextForcedRefreshTime;

		[HarmonyPatch("SpawnInteractableObject")]
		[HarmonyPostfix]
		private static void SpawnInteractableObjectPostfix(EObjectType objType, ref InteractableObject __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			__result.m_ObjectType = objType;
		}

		[HarmonyPatch("SpawnDecoObject")]
		[HarmonyPostfix]
		private static void SpawnDecoObjectPostfix(EDecoObject objType, ref InteractableObject __result)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			__result.m_DecoObjectType = objType;
		}

		[HarmonyPatch("Update")]
		[HarmonyPrefix]
		private static bool UpdatePrefix(ShelfManager __instance)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Config.OptimizeShelfVisibilityUpdates)
			{
				return true;
			}
			bool flag = Time.time >= nextForcedRefreshTime;
			if (flag)
			{
				nextForcedRefreshTime = Time.time + 0.5f;
			}
			Vector3 forward = ((Component)CSingleton<InteractionPlayerController>.Instance.m_Cam).transform.forward;
			Vector3 position = ((Component)CSingleton<InteractionPlayerController>.Instance.m_WalkerCtrl).transform.position;
			for (int i = 0; i < __instance.m_ShelfList.Count; i++)
			{
				Shelf val = __instance.m_ShelfList[i];
				if (!Object.op_Implicit((Object)(object)val))
				{
					continue;
				}
				float num = Vector3.Dot(forward, ((Component)val).transform.forward);
				Vector3 val2 = ((Component)val).transform.position - position;
				bool flag2 = ((Vector3)(ref val2)).sqrMagnitude <= 36f || Mathf.Abs(num) <= 0.7f;
				ShelfVisibilityState orCreateValue = shelfVisibilityStates.GetOrCreateValue(val);
				if (flag || orCreateValue.IsVisible != flag2)
				{
					orCreateValue.IsVisible = flag2;
					List<ShelfCompartment> itemCompartmentList = val.GetItemCompartmentList();
					for (int j = 0; j < itemCompartmentList.Count; j++)
					{
						itemCompartmentList[j].SetVisibilityHalfItemMesh(flag2);
					}
				}
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(ShopBuyDecoUIScreen))]
	internal class ShopBuyDecoUIScreenPatches
	{
		[HarmonyPatch("OnPressBuyShopDecoItem")]
		[HarmonyPrefix]
		private static bool OnPressBuyShopDecoItemPrefix(EDecoObject itemType)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			return !EplRuntimeData.Services.BundleMaintenanceService.TryBlockPurchase(itemType);
		}

		[HarmonyPatch("OnPressBuyShopDeco")]
		[HarmonyPrefix]
		private static bool OnPressBuyShopDecoPrefix(ShopBuyDecoUIScreen __instance, int shopDecoIndex)
		{
			return !EplRuntimeData.Services.BundleMaintenanceService.TryBlockTexturePurchase(__instance.m_CategoryIndex, shopDecoIndex);
		}
	}
	[HarmonyPatch(typeof(ShopCustomizationManager))]
	internal class ShopCustomizationManagerPatches
	{
		[HarmonyPatch("ChangeFloorMaterial")]
		[HarmonyPrefix]
		private static bool ChangeFloorMaterialPrefix(int index, bool isShopLotB)
		{
			DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
			int? num = index - decoLibrary.firstInsertedFloorTexture;
			if (!num.HasValue || num < 0 || num >= decoLibrary.DecoFloorTextureData.Count)
			{
				return true;
			}
			ShopCustomizationManager instance = CSingleton<ShopCustomizationManager>.Instance;
			ApplyModTextures(isShopLotB ? instance.m_FloorMatB : instance.m_FloorMat, decoLibrary.DecoFloorTextureData[num.Value]);
			return false;
		}

		[HarmonyPatch("ChangeCeilingMaterial")]
		[HarmonyPrefix]
		private static bool ChangeCeilingMaterialPrefix(int index, bool isShopLotB)
		{
			DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
			int? num = index - decoLibrary.firstInsertedCeilingTexture;
			if (!num.HasValue || num < 0 || num >= decoLibrary.DecoCeilingTextureData.Count)
			{
				return true;
			}
			ShopCustomizationManager instance = CSingleton<ShopCustomizationManager>.Instance;
			ApplyModTextures(isShopLotB ? instance.m_CeilingMatB : instance.m_CeilingMat, decoLibrary.DecoCeilingTextureData[num.Value]);
			return false;
		}

		[HarmonyPatch("ChangeWallMaterial")]
		[HarmonyPrefix]
		private static bool ChangeWallMaterialPrefix(int index, bool isShopLotB)
		{
			DecoLibrary decoLibrary = EplRuntimeData.Assets.DecoLibrary;
			int? num = index - decoLibrary.firstInsertedWallTexture;
			if (!num.HasValue || num < 0 || num >= decoLibrary.DecoWallTextureData.Count)
			{
				return true;
			}
			ShopCustomizationManager instance = CSingleton<ShopCustomizationManager>.Instance;
			ApplyModTextures(isShopLotB ? instance.m_WallMatB : instance.m_WallMat, decoLibrary.DecoWallTextureData[num.Value]);
			if (isShopLotB)
			{
				instance.m_ShopWall_WithBarB.SetActive(false);
				instance.m_ShopWall_NoBarB.SetActive(true);
			}
			else
			{
				instance.m_ShopWall_WithBar.SetActive(false);
				instance.m_ShopWall_NoBar.SetActive(true);
			}
			CSingleton<UnlockRoomManager>.Instance.SetWallBarVisibility(false, isShopLotB);
			return false;
		}

		private static void ApplyModTextures(Material material, ModShopDecoData modShopDecoData)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			StreamingAssetExtensions.SetTextureAsync(material, "_MainTex", modShopDecoData.MainTexture);
			StreamingAssetExtensions.SetTextureAsync(material, "_MetallicGlossMap", modShopDecoData.RoughnessMap);
			StreamingAssetExtensions.SetTextureAsync(material, "_BumpMap", modShopDecoData.NormalMap);
			material.SetFloat("_GlossMapScale", modShopDecoData.ShopDecoData.smoothness);
			material.SetColor("_Color", modShopDecoData.ShopDecoData.color);
		}
	}
	[HarmonyPatch(typeof(ShopDecoPanelUI))]
	internal class ShopDecoPanelUIPatches
	{
		[HarmonyPatch("InitDecoObject")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitDecoObjectTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Expected O, but got Unknown
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Expected O, but got Unknown
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Expected O, but got Unknown
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Expected O, but got Unknown
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(ShopDecoPanelUI), "m_Image");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(ShopDecoPanelUI), "m_DecoPurchaseData");
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(DecoPurchaseData), "icon");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(DecoPurchaseData),
				typeof(EDecoObject)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo2, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo3, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(3).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_2, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(ShowCardObtainedPage))]
	internal class ShowCardObtainedPagePatches
	{
		[HarmonyPatch("ShowCardObtained")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> ShowCardObtainedTranspiler(IEnumerable<CodeInstruction> instructions)
		{
			//IL_004c: 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_006c: Expected O, but got Unknown
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected O, but got Unknown
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			List<CodeInstruction> list = instructions.ToList();
			MethodInfo methodInfo = AccessTools.Method(typeof(CardData), "GetCardBorderType", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(ShowCardObtainedPage), "m_TotalExpGained");
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ShowCardObtainedPagePatches), "ProcessCardExp", (Type[])null, (Type[])null);
			CodeMatcher val = new CodeMatcher((IEnumerable<CodeInstruction>)list, (ILGenerator)null).MatchForward(true, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldloc_S, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[ShowCardObtainedPagePatches.ShowCardObtainedTranspiler]: Failed to find GetCardBorderType anchor, leaving ShowCardObtained unpatched", "ShowCardObtainedTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\ShowCardObtainedPagePatches.cs");
				return list;
			}
			int pos = val.Pos;
			val.MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null)
			});
			if (!val.IsValid)
			{
				ModLogger.Error("[ShowCardObtainedPagePatches.ShowCardObtainedTranspiler]: Failed to find m_TotalExpGained anchor, leaving ShowCardObtained unpatched", "ShowCardObtainedTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\ShowCardObtainedPagePatches.cs");
				return list;
			}
			int pos2 = val.Pos;
			List<CodeInstruction> list2 = val.Instructions();
			CodeInstruction val2 = null;
			for (int i = pos; i < pos2; i++)
			{
				if (list2[i].opcode == OpCodes.Stloc_S)
				{
					val2 = new CodeInstruction(OpCodes.Stloc_S, list2[i].operand);
					break;
				}
			}
			if (val2 == null)
			{
				ModLogger.Error("[ShowCardObtainedPagePatches.ShowCardObtainedTranspiler]: Failed to find exp local between anchors, leaving ShowCardObtained unpatched", "ShowCardObtainedTranspiler", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Patches\\ShowCardObtainedPagePatches.cs");
				return list;
			}
			val.Start().Advance(pos).RemoveInstructions(pos2 - pos)
				.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					val2
				});
			return val.InstructionEnumeration();
		}

		private static int ProcessCardExp(CardData cardData)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected I4, but got Unknown
			if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
			{
				return (int)EplRuntimeData.Services.CardExpansionService.GenerateCardExp(cardData);
			}
			if (EplRuntimeData.Config.UseCustomExpForBase)
			{
				return (int)new CardExpGenerator().CalculateExp(cardData);
			}
			return (cardData.GetCardBorderType() + 1) * Mathf.CeilToInt((float)(cardData.borderType + 1) / 2f) * ((!cardData.isFoil) ? 1 : 8);
		}
	}
	[HarmonyPatch(typeof(TableGameItemSet))]
	internal class TableGameItemSetPatches
	{
		[HarmonyPatch("RandomizeSetup")]
		[HarmonyPostfix]
		private static void RandomizeSetupPostfix(TableGameItemSet __instance)
		{
			ApplyEplTheming(__instance);
		}

		[HarmonyPatch("SpecificSetup")]
		[HarmonyPostfix]
		private static void SpecificSetupPostfix(TableGameItemSet __instance)
		{
			ApplyEplTheming(__instance);
		}

		private static void ApplyEplTheming(TableGameItemSet itemSet)
		{
			PlayTableService playTableService = EplRuntimeData.Services.PlayTableService;
			playTableService.ApplyTableCardMaterials(itemSet);
			playTableService.ApplyDecorationMaterials(itemSet);
			playTableService.ApplyCardFlipping(itemSet);
		}
	}
	internal static class TextureReplacerCompatibilityPatches
	{
		[HarmonyPatch]
		internal class SetCardUIPostfixPatch
		{
			private static bool Prepare()
			{
				return IsTextureReplacerLoaded();
			}

			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(AccessTools.TypeByName("TextureReplacer.BepInExPlugin+CardUI_Patch"), "Postfix_SetCardUI", (Type[])null, (Type[])null);
			}

			private static bool Prefix(CardUI __0, ref CardData cardData)
			{
				//IL_0011: Unknown result type (might be due to invalid IL or missing references)
				if (EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType))
				{
					return false;
				}
				EplRuntimeData.Services.CardUIService.SetDirty(__0);
				return true;
			}
		}

		[HarmonyPatch]
		internal class GetFullCardTypeNamePatch
		{
			private static bool Prepare()
			{
				return IsTextureReplacerLoaded();
			}

			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(AccessTools.TypeByName("TextureReplacer.BepInExPlugin+Patch_GetFullCardTypeName"), "Postfix", (Type[])null, (Type[])null);
			}

			private static bool Prefix(CardData cardData)
			{
				//IL_0010: Unknown result type (might be due to invalid IL or missing references)
				return !EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType);
			}
		}

		[HarmonyPatch]
		internal class OpenSetCardPriceScreenPatch
		{
			private static bool Prepare()
			{
				return IsTextureReplacerLoaded();
			}

			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(AccessTools.TypeByName("TextureReplacer.BepInExPlugin+Patch_SetItemPriceScreen_OpenSetCardPriceScreen"), "Postfix", (Type[])null, (Type[])null);
			}

			private static bool Prefix(ref CardData cardData)
			{
				//IL_0015: Unknown result type (might be due to invalid IL or missing references)
				if (cardData != null)
				{
					return !EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(cardData.expansionType);
				}
				return true;
			}
		}

		[HarmonyPatch]
		internal class ShowCardPriceChartPatch
		{
			private static bool Prepare()
			{
				return IsTextureReplacerLoaded();
			}

			private static MethodBase TargetMethod()
			{
				return AccessTools.Method(AccessTools.TypeByName("TextureReplacer.BepInExPlugin+Patch_ItemPriceGraphScreen_ShowCardPriceChart"), "Postfix", (Type[])null, (Type[])null);
			}

			private static bool Prefix(ECardExpansionType expansionType)
			{
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				return !EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.ContainsKey(expansionType);
			}
		}

		private static bool IsTextureReplacerLoaded()
		{
			return Chainloader.PluginInfos.ContainsKey("shaklin.TextureReplacer");
		}
	}
	[HarmonyPatch(typeof(TournamentPrizePanelUI))]
	internal class TournamentPrizePanelUIPatches
	{
		[HarmonyPatch("InitItem")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitItemTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(TournamentPrizePanelUI), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("InitCard")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> InitCardTranspiler(IEnumerable<CodeInstruction> codeInstructions, ILGenerator il)
		{
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Expected O, but got Unknown
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(CardData));
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[3]
			{
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(1).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(TournamentPrizeUIGrp))]
	internal class TournamentPrizeUIGrpPatches
	{
		[HarmonyPatch("UpdatePrizeData")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdatePrizeDataTranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Expected O, but got Unknown
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Expected O, but got Unknown
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: Expected O, but got Unknown
			//IL_017c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Expected O, but got Unknown
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Expected O, but got Unknown
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Expected O, but got Unknown
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cb: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(TournamentPrizeUIGrp), "m_ItemImageList");
			MethodInfo methodInfo = AccessTools.Method(typeof(List<Image>), "get_Item", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(TournamentPrizeData), "m_ItemType");
			MethodInfo methodInfo3 = AccessTools.Method(typeof(List<TournamentPrizeData>), "get_Item", (Type[])null, (Type[])null);
			FieldInfo fieldInfo3 = AccessTools.Field(typeof(TournamentPrizeDataList), "m_PrizeDataList");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[6]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_2, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_3, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo2, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(4).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo3),
					new CodeInstruction(OpCodes.Ldloc_2, (object)null),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldfld, (object)fieldInfo2),
					new CodeInstruction(OpCodes.Call, (object)methodInfo4)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(UI_BarcodeScannerScreen))]
	internal class UI_BarcodeScannerScreenPatches
	{
		[HarmonyPatch("UpdateScannerUI")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> UpdateScannerUITranspiler(IEnumerable<CodeInstruction> codeInstructions)
		{
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Expected O, but got Unknown
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Expected O, but got Unknown
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(UI_BarcodeScannerScreen), "m_ItemImage");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.Method(typeof(ImageExtensions), "SetSprite", new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			}, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[4]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldloc_0, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(2).RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[2]
				{
					new CodeInstruction(OpCodes.Ldarg_1, (object)null),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(UI_CashCounterScreen))]
	internal class UI_CashCounterScreenPatches
	{
		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(UI_CashCounterScreen), "OnCardScanned", (Type[])null, (Type[])null);
			MethodInfo methodInfo = AccessTools.Method(typeof(UI_CashCounterScreen), "OnLanguageChanged", (Type[])null, (Type[])null);
			if ((object)methodInfo != null)
			{
				yield return methodInfo;
			}
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			FieldInfo fieldInfo = AccessTools.Field(typeof(CardData), "monsterType");
			MethodInfo eplRuntimeServiceGet = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo cardExpansionServiceGet = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo getMonsterDataMethod = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[1] { typeof(CardData) }, (Type[])null);
			LocalBuilder localCardData = il.DeclareLocal(typeof(CardData));
			return new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[2]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			}).Repeat((Action<CodeMatcher>)delegate(CodeMatcher matcher)
			{
				//IL_001a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Expected O, but got Unknown
				//IL_002d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0033: Expected O, but got Unknown
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0046: Expected O, but got Unknown
				//IL_0053: Unknown result type (might be due to invalid IL or missing references)
				//IL_0059: Expected O, but got Unknown
				//IL_0066: Unknown result type (might be due to invalid IL or missing references)
				//IL_006c: Expected O, but got Unknown
				matcher.RemoveInstructions(2).InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[5]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localCardData),
					new CodeInstruction(OpCodes.Call, (object)eplRuntimeServiceGet),
					new CodeInstruction(OpCodes.Callvirt, (object)cardExpansionServiceGet),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localCardData),
					new CodeInstruction(OpCodes.Callvirt, (object)getMonsterDataMethod)
				});
			}, (Action<string>)null).InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(UI_PriceTag))]
	internal class UI_PriceTagAtlasPatches
	{
		private static bool Prepare()
		{
			return GameBuild.HasPriceTagAtlas;
		}

		[HarmonyPatch("SetItemImage")]
		[HarmonyPrefix]
		private static void SetItemImagePrefix(UI_PriceTag __instance, EItemType itemType)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			EplRuntimeData.Services.PriceTagAtlasService.EnsureIcon(__instance, itemType);
		}

		[HarmonyPatch("SetObjectImage")]
		[HarmonyPrefix]
		private static void SetObjectImagePrefix(UI_PriceTag __instance, EObjectType objectType)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			EplRuntimeData.Services.PriceTagAtlasService.EnsureIcon(__instance, objectType);
		}
	}
	[HarmonyPatch(typeof(UI_PriceTag))]
	internal class UI_PriceTagLegacyIconPatches
	{
		private static bool Prepare()
		{
			return GameBuild.HasLegacyPriceTagIcon;
		}

		private static IEnumerable<MethodBase> TargetMethods()
		{
			yield return AccessTools.Method(typeof(UI_PriceTag), "SetItemImage", (Type[])null, (Type[])null);
			yield return AccessTools.Method(typeof(UI_PriceTag), "SetObjectImage", (Type[])null, (Type[])null);
		}

		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> codeInstructions, MethodBase original)
		{
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Expected O, but got Unknown
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Expected O, but got Unknown
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Expected O, but got Unknown
			FieldInfo fieldInfo = AccessTools.Field(typeof(UI_PriceTag), "m_Icon");
			MethodInfo methodInfo = AccessTools.Method(typeof(Image), "set_sprite", (Type[])null, (Type[])null);
			Type typeFromHandle = typeof(ImageExtensions);
			string name = original.Name;
			Type[] array = ((name == "SetItemImage") ? new Type[3]
			{
				typeof(Image),
				typeof(ItemData),
				typeof(EItemType)
			} : ((!(name == "SetObjectImage")) ? null : new Type[2]
			{
				typeof(Image),
				typeof(FurniturePurchaseData)
			}));
			MethodInfo methodInfo2 = AccessTools.Method(typeFromHandle, "SetSprite", array, (Type[])null);
			CodeMatcher val = new CodeMatcher(codeInstructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[5]
			{
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)fieldInfo, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldarg_1, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Call, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Ldfld, (object)null, (string)null),
				new CodeMatch((OpCode?)OpCodes.Callvirt, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.Advance(3).RemoveInstructions(2);
				if (original.Name == "SetItemImage")
				{
					val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
					{
						new CodeInstruction(OpCodes.Ldarg_1, (object)null)
					});
				}
				val.InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[1]
				{
					new CodeInstruction(OpCodes.Call, (object)methodInfo2)
				});
			}
			return val.InstructionEnumeration();
		}
	}
	[HarmonyPatch(typeof(WorkbenchUIScreen))]
	internal class WorkbenchUIScreenPatches
	{
		[HarmonyPatch("OpenScreen")]
		[HarmonyPostfix]
		private static void OpenScreenPostfix(InteractableWorkbench interactableWorkbench)
		{
			CSingleton<WorkbenchUIScreen>.Instance.m_SliderPriceLimit.maxValue = 999999f;
			CSingleton<WorkbenchUIScreen>.Instance.m_SliderPriceMinimum.maxValue = 999999f;
			((TMP_Text)CSingleton<WorkbenchUIScreen>.Instance.m_PriceLimitMaxText).text = GameInstance.GetPriceString(9999.99f, false, true, false, "F2");
			((TMP_Text)CSingleton<WorkbenchUIScreen>.Instance.m_PriceMinimumMaxText).text = GameInstance.GetPriceString(9999.99f, false, true, false, "F2");
		}

		[HarmonyPatch("RunBundleCardBulkFunction")]
		[HarmonyTranspiler]
		private static IEnumerable<CodeInstruction> RunBundleCardBulkFunctionTranspiler(IEnumerable<CodeInstruction> instructions, ILGenerator il)
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Expected O, but got Unknown
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Expected O, but got Unknown
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Expected O, but got Unknown
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Expected O, but got Unknown
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Expected O, but got Unknown
			MethodInfo methodInfo = AccessTools.Method(typeof(InventoryBase), "GetMonsterData", (Type[])null, (Type[])null);
			MethodInfo methodInfo2 = AccessTools.PropertyGetter(typeof(EplRuntimeData), "Assets");
			MethodInfo methodInfo3 = AccessTools.PropertyGetter(typeof(EplAssets), "CardExpansionLibrary");
			MethodInfo methodInfo4 = AccessTools.Method(typeof(CardExpansionLibrary), "GetMonsterData", new Type[2]
			{
				typeof(ECardExpansionType),
				typeof(EMonsterType)
			}, (Type[])null);
			LocalBuilder localBuilder = il.DeclareLocal(typeof(EMonsterType));
			CodeMatcher val = new CodeMatcher(instructions, (ILGenerator)null).MatchForward(false, (CodeMatch[])(object)new CodeMatch[1]
			{
				new CodeMatch((OpCode?)OpCodes.Call, (object)methodInfo, (string)null)
			});
			if (val.IsValid)
			{
				val.RemoveInstruction().InsertAndAdvance((CodeInstruction[])(object)new CodeInstruction[6]
				{
					new CodeInstruction(OpCodes.Stloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Call, (object)methodInfo2),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo3),
					new CodeInstruction(OpCodes.Ldloc_1, (object)null),
					new CodeInstruction(OpCodes.Ldloc_S, (object)localBuilder),
					new CodeInstruction(OpCodes.Callvirt, (object)methodInfo4)
				});
			}
			return val.InstructionEnumeration();
		}

		[HarmonyPatch("OnPressChangeRarityButton")]
		[HarmonyPostfix]
		private static void OnPressChangeRarityButtonPostfix(WorkbenchUIScreen __instance)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			EplRuntimeData.Services.CardRaritySelectService.OpenScreen(__instance.m_CurrentCardExpansionType);
		}

		[HarmonyPatch("OnCardExpansionUpdated")]
		[HarmonyPostfix]
		private static void OnCardExpansionUpdatedPostfix(WorkbenchUIScreen __instance, CEventPlayer_OnCardExpansionSelectScreenUpdated evt)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Expected O, but got Unknown
			__instance.OnRarityLimitUpdated(new CEventPlayer_OnCardRaritySelectScreenUpdated(-1));
		}
	}
	[HarmonyPatch(typeof(Worker))]
	internal class WorkerPatches
	{
		[HarmonyPatch("LoadWorkerSaveData")]
		[HarmonyPostfix]
		private static void LoadWorkerSaveDataPostfix(Worker __instance)
		{
			SyncEnabledList(__instance);
		}

		private static void SyncEnabledList(Worker worker)
		{
			List<bool> cardPackItemTypeEnabledList = worker.GetCardPackItemTypeEnabledList();
			if (cardPackItemTypeEnabledList == null)
			{
				return;
			}
			int count = worker.m_CardPackItemTypeList.Count;
			if (count != 0)
			{
				while (cardPackItemTypeEnabledList.Count < count)
				{
					cardPackItemTypeEnabledList.Add(item: true);
				}
				while (cardPackItemTypeEnabledList.Count > count)
				{
					cardPackItemTypeEnabledList.RemoveAt(cardPackItemTypeEnabledList.Count - 1);
				}
			}
		}
	}
	[HarmonyPatch(typeof(WorkerSetPackOpenerTypeOptionScreen))]
	internal class WorkerSetPackOpenerTypeOptionScreenPatches
	{
		[HarmonyPatch("EvaluatePanelUIPage")]
		[HarmonyPostfix]
		private static void EvaluatePanelUIPagePostfix(WorkerSetPackOpenerTypeOptionScreen __instance, int pageIndex)
		{
			EplRuntimeData.Services.WorkerPackOpenerScreenService.ApplyEplPackIcons(__instance, pageIndex);
		}
	}
}
namespace EnhancedPrefabLoader.Core.Packs.PackGenerators
{
	internal class AllRandomPackGenerator(CardGenerationData generationData) : IPackGenerator
	{
		public List<MonsterData> GeneratePack(ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool hasRandomFoils)
		{
			if (!generationData.CanHaveDuplicates)
			{
				return cardPool.Shuffle().Take(7).ToList();
			}
			List<MonsterData> list = new List<MonsterData>();
			for (int i = 0; i < 7; i++)
			{
				int index = Random.Range(0, cardPool.Count);
				list.Add(cardPool[index]);
			}
			return list;
		}
	}
	internal class GodPackGenerator(CardGenerationData generationData) : IPackGenerator
	{
		public List<MonsterData> GeneratePack(ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool hasRandomFoils)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: 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)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ERarity, List<MonsterData>> validCardPool = cardExpansion.GetRarityPools(cardPool, requiresMutablePools: false);
			Dictionary<ERarity, float> dictionary = generationData.GodGenerationWeights.Where((KeyValuePair<ERarity, float> kvp) => kvp.Value > 0f && validCardPool.ContainsKey(kvp.Key)).ToDictionary((KeyValuePair<ERarity, float> kvp) => kvp.Key, (KeyValuePair<ERarity, float> kvp) => kvp.Value);
			List<MonsterData> list = new List<MonsterData>();
			if (dictionary.Count > 0)
			{
				for (int num = 0; num < 7; num++)
				{
					ERarity weightedRandom = dictionary.GetWeightedRandom();
					List<MonsterData> list2 = validCardPool[weightedRandom];
					int index = Random.Range(0, list2.Count);
					list.Add(list2[index]);
				}
			}
			list.FillRemainingSlots(cardPool, cardExpansion, 7);
			return list;
		}
	}
	internal class GuaranteedSlotPackGenerator(CardGenerationData generationData) : IPackGenerator
	{
		public List<MonsterData> GeneratePack(ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool hasRandomFoils)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			List<MonsterData> list = new List<MonsterData>();
			Dictionary<ERarity, List<MonsterData>> cardsByRarity = cardExpansion.GetRarityPools(cardPool, !generationData.CanHaveDuplicates);
			foreach (KeyValuePair<PackSlot, Dictionary<ERarity, float>> packSlotWeight in generationData.PackSlotWeights)
			{
				packSlotWeight.Deconstruct(out var _, out var value);
				Dictionary<ERarity, float> dictionary = value.Where((KeyValuePair<ERarity, float> kvp) => cardsByRarity.ContainsKey(kvp.Key)).ToDictionary((KeyValuePair<ERarity, float> kvp) => kvp.Key, (KeyValuePair<ERarity, float> kvp) => kvp.Value);
				if (dictionary.Count == 0)
				{
					continue;
				}
				ERarity weightedRandom = dictionary.GetWeightedRandom();
				int index = Random.Range(0, cardsByRarity[weightedRandom].Count);
				list.Add(cardsByRarity[weightedRandom][index]);
				if (!generationData.CanHaveDuplicates)
				{
					cardsByRarity[weightedRandom].SwapAndRemove(index);
					if (cardsByRarity[weightedRandom].Count == 0)
					{
						cardsByRarity.Remove(weightedRandom);
					}
				}
			}
			list.FillRemainingSlots(cardPool, cardExpansion, generationData.PackSlotWeights.Count);
			return list;
		}
	}
	public enum PackGenerationStrategy
	{
		Guaranteed = 1,
		AllRandomWeighted,
		AllRandom,
		GodPack
	}
	internal static class PackGeneratorExtensions
	{
		internal static Dictionary<ERarity, List<MonsterData>> GetRarityPools(this ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool requiresMutablePools)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(cardExpansion, out ModCardExpansionData value))
			{
				return (from c in cardPool
					group c by c.Rarity).ToDictionary((IGrouping<ERarity, MonsterData> g) => g.Key, (IGrouping<ERarity, MonsterData> g) => g.ToList());
			}
			Dictionary<ERarity, List<MonsterData>> cardsByRarity = value.CardsByRarity;
			if (!requiresMutablePools)
			{
				return cardsByRarity;
			}
			return cardsByRarity.ToDictionary((KeyValuePair<ERarity, List<MonsterData>> kvp) => kvp.Key, (KeyValuePair<ERarity, List<MonsterData>> kvp) => new List<MonsterData>(kvp.Value));
		}

		internal static void FillRemainingSlots(this List<MonsterData> selectedCards, List<MonsterData> cardPool, ECardExpansionType cardExpansion, int packSize)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			if (selectedCards.Count >= packSize)
			{
				return;
			}
			if (cardPool.Count == 0)
			{
				ModLogger.Error($"Pack for {cardExpansion} generated only {selectedCards.Count}/{packSize} cards because the expansion has no cards available", "FillRemainingSlots", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Packs\\PackGenerators\\PackGeneratorExtensions.cs");
				return;
			}
			ModLogger.Warning($"Pack weights for {cardExpansion} could not fill all {packSize} slots, drawing the remaining {packSize - selectedCards.Count} cards randomly with duplicates allowed", "FillRemainingSlots", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Packs\\PackGenerators\\PackGeneratorExtensions.cs");
			while (selectedCards.Count < packSize)
			{
				selectedCards.Add(cardPool[Random.Range(0, cardPool.Count)]);
			}
		}
	}
	internal static class PackGeneratorFactory
	{
		internal static IPackGenerator For(PackGenerationStrategy strategy, CardGenerationData generationData)
		{
			return (IPackGenerator)(strategy switch
			{
				PackGenerationStrategy.AllRandom => new AllRandomPackGenerator(generationData), 
				PackGenerationStrategy.AllRandomWeighted => new WeightedAllRandomPackGenerator(generationData), 
				PackGenerationStrategy.Guaranteed => new GuaranteedSlotPackGenerator(generationData), 
				PackGenerationStrategy.GodPack => new GodPackGenerator(generationData), 
				_ => new AllRandomPackGenerator(generationData), 
			});
		}
	}
	internal class WeightedAllRandomPackGenerator(CardGenerationData generationData) : IPackGenerator
	{
		public List<MonsterData> GeneratePack(ECardExpansionType cardExpansion, List<MonsterData> cardPool, bool hasRandomFoils)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ERarity, List<MonsterData>> validCardPool = cardExpansion.GetRarityPools(cardPool, !generationData.CanHaveDuplicates);
			Dictionary<ERarity, float> dictionary = generationData.NormalGenerationWeights.Where((KeyValuePair<ERarity, float> kvp) => kvp.Value > 0f && validCardPool.ContainsKey(kvp.Key)).ToDictionary((KeyValuePair<ERarity, float> kvp) => kvp.Key, (KeyValuePair<ERarity, float> kvp) => kvp.Value);
			List<MonsterData> list = new List<MonsterData>();
			while (list.Count < 7 && dictionary.Count > 0)
			{
				ERarity weightedRandom = dictionary.GetWeightedRandom();
				List<MonsterData> list2 = validCardPool[weightedRandom];
				int index = Random.Range(0, list2.Count);
				list.Add(list2[index]);
				if (!generationData.CanHaveDuplicates)
				{
					list2.SwapAndRemove(index);
					if (list2.Count == 0)
					{
						dictionary.Remove(weightedRandom);
					}
				}
			}
			list.FillRemainingSlots(cardPool, cardExpansion, 7);
			return list;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Models.SaveData
{
	[Serializable]
	internal class CardExpansionSaveData : EplBaseSaveData, IResettable, IPriceResettable, IPostLoadNormalizer
	{
		public List<int> CardCountList { get; set; } = new List<int>();

		public List<MarketPrice> CardMarketPriceList { get; set; } = new List<MarketPrice>();

		public List<float> CardPriceList { get; set; } = new List<float>();

		public List<List<float>> GradedCardPriceList { get; set; } = new List<List<float>>();

		public List<bool> IsCardCollectedList { get; set; } = new List<bool>();

		public CardExpansionSaveData(int numCards)
		{
			CardCountList = Enumerable.Repeat(0, Math.Max(0, numCards)).ToList();
			CardMarketPriceList = Enumerable.Range(0, Math.Max(0, numCards)).Select((Func<int, MarketPrice>)((int _) => new MarketPrice())).ToList();
			List<float> list = new List<float>();
			foreach (int item in Enumerable.Repeat(0, Math.Max(0, numCards)))
			{
				list.Add(item);
			}
			CardPriceList = list;
			IsCardCollectedList = Enumerable.Repeat(element: false, Math.Max(0, numCards)).ToList();
			GradedCardPriceList = CreateGradedCardPriceList(numCards);
		}

		public void Reset()
		{
			CardCountList = (from _ in Enumerable.Range(0, CardCountList.Count)
				select 0).ToList();
			CardMarketPriceList = Enumerable.Range(0, CardMarketPriceList.Count).Select((Func<int, MarketPrice>)((int _) => new MarketPrice())).ToList();
			List<float> list = new List<float>();
			foreach (int item in from _ in Enumerable.Range(0, CardPriceList.Count)
				select 0)
			{
				list.Add(item);
			}
			CardPriceList = list;
			IsCardCollectedList = (from _ in Enumerable.Range(0, IsCardCollectedList.Count)
				select false).ToList();
			GradedCardPriceList = CreateGradedCardPriceList(IsCardCollectedList.Count);
		}

		public void NormalizeAfterLoad(string key)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			ECardExpansionType key2 = Enum.Parse<ECardExpansionType>(key.Split(':')[1]);
			ModCardExpansionData modCardExpansionData = EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData[key2];
			int num = ((!modCardExpansionData.HasRandomFoils) ? 1 : 2);
			int num2 = modCardExpansionData.Cards.Count * num;
			List<int> cardCountList = CardCountList;
			List<int> list = new List<int>();
			list.AddRange(Enumerable.Repeat(0, Math.Max(0, num2 - CardCountList.Count)));
			cardCountList.AddRange(new <>z__ReadOnlyList<int>(list));
			List<MarketPrice> cardMarketPriceList = CardMarketPriceList;
			List<MarketPrice> list2 = new List<MarketPrice>();
			list2.AddRange(Enumerable.Range(0, Math.Max(0, num2 - CardMarketPriceList.Count)).Select((Func<int, MarketPrice>)((int _) => new MarketPrice())));
			cardMarketPriceList.AddRange(new <>z__ReadOnlyList<MarketPrice>(list2));
			List<float> cardPriceList = CardPriceList;
			List<float> list3 = new List<float>();
			foreach (int item2 in Enumerable.Repeat(0, Math.Max(0, num2 - CardPriceList.Count)))
			{
				list3.Add(item2);
			}
			cardPriceList.AddRange(new <>z__ReadOnlyList<float>(list3));
			List<bool> isCardCollectedList = IsCardCollectedList;
			List<bool> list4 = new List<bool>();
			list4.AddRange(Enumerable.Repeat(element: false, Math.Max(0, num2 - IsCardCollectedList.Count)));
			isCardCollectedList.AddRange(new <>z__ReadOnlyList<bool>(list4));
			int num3 = Math.Max(0, num2 - GradedCardPriceList.Count);
			for (int num4 = 0; num4 < num3; num4++)
			{
				list3 = new List<float>();
				foreach (int item3 in Enumerable.Repeat(0, 10))
				{
					list3.Add(item3);
				}
				List<float> item = list3;
				GradedCardPriceList.Add(item);
			}
		}

		public void ResetPrices()
		{
			CardMarketPriceList = Enumerable.Range(0, CardMarketPriceList.Count).Select((Func<int, MarketPrice>)((int _) => new MarketPrice())).ToList();
		}

		private static List<List<float>> CreateGradedCardPriceList(int numCards)
		{
			List<List<float>> list = new List<List<float>>();
			for (int i = 0; i < numCards; i++)
			{
				List<float> list2 = new List<float>();
				foreach (int item2 in Enumerable.Repeat(0, 10))
				{
					list2.Add(item2);
				}
				List<float> item = list2;
				list.Add(item);
			}
			return list;
		}
	}
	[Serializable]
	internal class DecoSaveData : EplBaseSaveData, IResettable
	{
		public bool IsUnlocked { get; set; }

		public int ItemCount { get; set; }

		public void Reset()
		{
			IsUnlocked = false;
			ItemCount = 0;
		}
	}
	internal class EplBaseSaveData
	{
	}
	public interface IPostLoadNormalizer
	{
		void NormalizeAfterLoad(string key);
	}
	public interface IPriceResettable
	{
		void ResetPrices();
	}
	public interface IResettable
	{
		void Reset();
	}
	[Serializable]
	internal class ItemSaveData : EplBaseSaveData, IResettable, IPriceResettable
	{
		[JsonProperty("IsUnlocked")]
		public bool IsBigBoxUnlocked { get; set; }

		public bool IsSmallBoxUnlocked { get; set; }

		public float ItemPriceChangePercent { get; set; }

		public float ItemPrice { get; set; }

		public float GeneratedCostPrice { get; set; }

		public float GeneratedMarketPrice { get; set; }

		public float AverageItemCost { get; set; }

		public int CurrentItemCount { get; set; }

		public FloatList ItemPriceChangeHistory { get; set; } = new FloatList();

		public void Reset()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			IsBigBoxUnlocked = false;
			IsSmallBoxUnlocked = false;
			ItemPriceChangePercent = 0f;
			ItemPrice = 0f;
			GeneratedCostPrice = 0f;
			GeneratedMarketPrice = 0f;
			AverageItemCost = 0f;
			CurrentItemCount = 0;
			ItemPriceChangeHistory = new FloatList();
		}

		public void ResetPrices()
		{
			ItemPriceChangePercent = 0f;
			GeneratedCostPrice = 0f;
			GeneratedMarketPrice = 0f;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Models.Runtime
{
	internal class CardGenerationData
	{
		internal bool CanHaveDuplicates { get; set; }

		internal bool CanHaveGodPack { get; set; }

		internal float GodPackPercentage { get; set; }

		internal IPackGenerator? PackGenerator { get; set; }

		internal IPackGenerator? GodPackGenerator { get; set; }

		internal ECardExpansionType Expansion { get; set; }

		internal ECollectionPackType PackType { get; set; }

		internal PackGenerationStrategy? Strategy { get; set; }

		internal Dictionary<ERarity, float> NormalGenerationWeights { get; set; } = new Dictionary<ERarity, float>();

		internal Dictionary<ERarity, float> GodGenerationWeights { get; set; } = new Dictionary<ERarity, float>();

		internal SortedDictionary<PackSlot, Dictionary<ERarity, float>> PackSlotWeights { get; set; } = new SortedDictionary<PackSlot, Dictionary<ERarity, float>>();
	}
	internal class CustomShopData
	{
		internal string PhoneAppId { get; set; } = string.Empty;

		internal string AppDisplayName { get; set; } = string.Empty;

		internal string AppIcon { get; set; } = string.Empty;

		internal string AppInnerBGImage { get; set; } = string.Empty;

		internal string AppOuterBGImage { get; set; } = string.Empty;

		internal StreamingAsset<Sprite>? SiteLogo { get; set; }

		internal StreamingAsset<Sprite>? SiteHeader { get; set; }

		internal StreamingAsset<Sprite>? SiteBackground { get; set; }

		internal List<RestockData> TCG { get; } = new List<RestockData>();

		internal List<RestockData> Accessories { get; } = new List<RestockData>();

		internal List<RestockData> Figurines { get; } = new List<RestockData>();
	}
	internal class ModCardData
	{
		internal bool IsFoil { get; set; }

		internal MonsterData MonsterData { get; set; }

		internal StreamingAsset<Texture>? Cardback { get; set; }

		internal StreamingAsset<Sprite> Icon { get; set; }

		internal StreamingAsset<Sprite>? FoilMask { get; set; }

		internal ECardExpansionType ExpansionType { get; set; }

		internal ECardBorderType BorderType { get; set; }

		internal CardData ToCardData()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: 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_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected O, but got Unknown
			return new CardData
			{
				monsterType = MonsterData.MonsterType,
				isFoil = IsFoil,
				borderType = BorderType,
				expansionType = ExpansionType
			};
		}
	}
	internal class ModCardExpansionData
	{
		private List<EMonsterType>? sortedMonsterTypes;

		private Dictionary<EMonsterType, int>? monsterTypeIndexLookup;

		private List<MonsterData>? monsterDataList;

		private Dictionary<ERarity, List<MonsterData>>? cardsByRarity;

		internal string Name { get; set; } = string.Empty;

		internal string MenuCategory { get; set; } = string.Empty;

		internal bool HasRandomFoils { get; set; }

		internal float FoilChance { get; set; }

		internal StreamingAsset<Texture> CardBack { get; set; }

		internal StreamingAsset<Sprite> FoilMask { get; set; }

		internal List<ERarity> Rarities { get; set; } = new List<ERarity>();

		internal Dictionary<EMonsterType, ModCardData> Cards { get; set; } = new Dictionary<EMonsterType, ModCardData>();

		internal Dictionary<EMonsterType, ECardBorderType> CardBorderMap { get; set; } = new Dictionary<EMonsterType, ECardBorderType>();

		internal int TradeUnlockLevel { get; set; }

		internal ICardPriceGenerator CardPriceGenerator { get; set; }

		internal ICardExpGenerator CardExpGenerator { get; set; }

		internal List<Material> PlayCardMaterials { get; set; } = new List<Material>();

		internal List<EMonsterType> SortedMonsterTypes => sortedMonsterTypes ?? (sortedMonsterTypes = Cards.Keys.OrderBy((EMonsterType key) => (int)key).ToList());

		internal Dictionary<EMonsterType, int> MonsterTypeIndexLookup => monsterTypeIndexLookup ?? (monsterTypeIndexLookup = SortedMonsterTypes.Select((EMonsterType monsterType, int index) => (monsterType: monsterType, index: index)).ToDictionary(((EMonsterType monsterType, int index) x) => x.monsterType, ((EMonsterType monsterType, int index) x) => x.index));

		internal List<MonsterData> MonsterDataList => monsterDataList ?? (monsterDataList = Cards.Values.Select((ModCardData card) => card.MonsterData).ToList());

		internal Dictionary<ERarity, List<MonsterData>> CardsByRarity => cardsByRarity ?? (cardsByRarity = (from card in Cards.Values
			group card by card.MonsterData.Rarity).ToDictionary((IGrouping<ERarity, ModCardData> g) => g.Key, (IGrouping<ERarity, ModCardData> g) => g.Select((ModCardData card) => card.MonsterData).ToList()));
	}
	internal class ModDecoData
	{
		internal StreamingAsset<Sprite> Icon { get; set; }

		internal DecoData BaseDecoData { get; set; }

		internal DecoPurchaseData BasePurchaseData { get; set; }
	}
	internal class ModFurniturePurchaseData
	{
		internal StreamingAsset<Sprite> Icon { get; set; }

		internal ObjectData BaseObjectData { get; set; }

		internal FurniturePurchaseData BaseFurniturePurchaseData { get; set; }
	}
	internal class ModItemData
	{
		internal StreamingAsset<Sprite> Icon { get; set; }

		internal ItemData BaseItemData { get; set; }
	}
	internal class ModRestockData
	{
		internal string? PhoneAppId { get; set; }

		internal ItemFlags ItemFlags { get; set; }

		internal RestockData RestockData { get; set; }
	}
	internal class ModShopDecoData
	{
		internal StreamingAsset<Sprite> Icon { get; set; }

		internal StreamingAsset<Texture> MainTexture { get; set; }

		internal StreamingAsset<Texture>? RoughnessMap { get; set; }

		internal StreamingAsset<Texture>? NormalMap { get; set; }

		internal ShopDecoData ShopDecoData { get; set; }
	}
}
namespace EnhancedPrefabLoader.Core.LoadingPipeline
{
	internal class BundleAssetsPreloader : IEnumerator
	{
		internal class BundleAssets
		{
			internal Dictionary<string, GameObject> GameObjects { get; } = new Dictionary<string, GameObject>();

			internal Dictionary<string, Material> Materials { get; } = new Dictionary<string, Material>();

			internal Dictionary<string, Mesh> Meshes { get; } = new Dictionary<string, Mesh>();

			internal Dictionary<string, Texture> Textures { get; } = new Dictionary<string, Texture>();
		}

		private readonly IEnumerator inner;

		internal BundleAssets Result { get; private set; }

		public object Current => inner.Current;

		private BundleAssetsPreloader(IEnumerator inner, BundleAssets bundleAssets)
		{
			this.inner = inner;
			Result = bundleAssets;
		}

		public bool MoveNext()
		{
			return inner.MoveNext();
		}

		public void Reset()
		{
			inner.Reset();
		}

		internal static BundleAssetsPreloader LoadFromAsync(BundleDescriptor descriptor, BundleManager.BundleHandle handle)
		{
			BundleAssets bundleAssets = new BundleAssets();
			return new BundleAssetsPreloader(Load(descriptor, handle, bundleAssets), bundleAssets);
		}

		private static IEnumerator Load(BundleDescriptor descriptor, BundleManager.BundleHandle handle, BundleAssets assets)
		{
			yield return LoadAllAsync<GameObject>(descriptor.Name, handle, assets.GameObjects);
			yield return LoadAllAsync<Material>(descriptor.Name, handle, assets.Materials);
			yield return LoadAllByName<Mesh>(descriptor.Name, descriptor.MeshNames, handle, assets.Meshes);
		}

		private static IEnumerator LoadAllByName<T>(string name, HashSet<string> assetNames, BundleManager.BundleHandle handle, Dictionary<string, T> assets) where T : Object
		{
			foreach (string assetName in assetNames)
			{
				AssetBundleRequest request = handle.LoadAssetAsync<T>(assetName);
				if (request == null)
				{
					ModLogger.Error($"Failed to load asset {assetName} of type {typeof(T)} from bundle {name}", "LoadAllByName", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\BundleAssetsPreloader.cs");
					yield break;
				}
				yield return request;
				Object asset = request.asset;
				T val = (T)(object)((asset is T) ? asset : null);
				if (val != null)
				{
					assets[assetName] = val;
				}
			}
		}

		private static IEnumerator LoadAllAsync<T>(string name, BundleManager.BundleHandle handle, Dictionary<string, T> gameObjects) where T : Object
		{
			AssetBundleRequest request = handle.LoadAllAsync<T>();
			if (request == null)
			{
				ModLogger.Error($"Failed to load assets of type {typeof(T)} from bundle {name}", "LoadAllAsync", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\BundleAssetsPreloader.cs");
				yield break;
			}
			yield return request;
			foreach (T item in request.allAssets.OfType<T>())
			{
				gameObjects[((Object)item).name] = item;
			}
		}
	}
	internal class BundleLoadingManager
	{
		private readonly SanitizerService sanitizerService = new SanitizerService();

		private readonly ValidationService validationService = new ValidationService();

		private readonly ProcessingService processingService = new ProcessingService();

		public bool isLoadingComplete;

		public float LoadingProgress { get; private set; }

		internal IEnumerator LoadBundlesAsync(string basePath)
		{
			if (EplRuntimeData.IsBundleLoadingComplete)
			{
				LoadingProgress = 1f;
				isLoadingComplete = true;
				yield break;
			}
			List<string> allBundleDescriptorsIn = FileHelper.GetAllBundleDescriptorsIn(basePath);
			int totalBundles = allBundleDescriptorsIn.Count;
			int processedBundles = 0;
			foreach (string item in allBundleDescriptorsIn)
			{
				BundleDescriptor bundleDescriptor;
				try
				{
					bundleDescriptor = JsonConvert.DeserializeObject<BundleDescriptor>(File.ReadAllText(item), new JsonSerializerSettings
					{
						MetadataPropertyHandling = (MetadataPropertyHandling)2
					});
				}
				catch (Exception ex)
				{
					ModLogger.Error("Issues loading jsonfile: " + ex.Message, "LoadBundlesAsync", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\BundleLoadingManager.cs");
					RegisterUnreadableBundle(item, "Descriptor failed to parse: " + ex.Message);
					continue;
				}
				if (bundleDescriptor == null)
				{
					ModLogger.Error("File deserialized to null: " + item, "LoadBundlesAsync", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\BundleLoadingManager.cs");
					RegisterUnreadableBundle(item, "Descriptor file deserialized to null.");
					continue;
				}
				string? directoryName = Path.GetDirectoryName(item);
				string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(item);
				string bundlePath = Path.Combine(directoryName, fileNameWithoutExtension);
				BundleInfo bundleInfo = new BundleInfo
				{
					JsonPath = item,
					BundlePath = bundlePath,
					Name = bundleDescriptor.Name,
					BundleId = bundleDescriptor.BundleId
				};
				sanitizerService.Sanitize(bundleDescriptor, bundleInfo);
				validationService.Validate(bundleDescriptor, bundleInfo);
				if (bundleInfo.IsValid)
				{
					yield return processingService.ProcessAsync(bundleDescriptor, bundleInfo);
					bundleInfo.IsLoaded = bundleInfo.IsValid;
				}
				EplRuntimeData.Assets.BundleRegistry.RegisterBundle(bundleInfo);
				processedBundles++;
				if (totalBundles > 0)
				{
					LoadingProgress = (float)processedBundles / (float)totalBundles;
				}
			}
			foreach (List<(int, EItemType)> value in EplRuntimeData.Assets.ItemLibrary.BulkBoxes.Values)
			{
				value.Sort(((int MinPrice, EItemType ItemType) a, (int MinPrice, EItemType ItemType) b) => b.MinPrice.CompareTo(a.MinPrice));
			}
			EplRuntimeData.Assets.ItemLibrary.RestockEntries.Sort((ModRestockData a, ModRestockData b) => a.RestockData.licenseShopLevelRequired.CompareTo(b.RestockData.licenseShopLevelRequired));
			ItemTypeResolver.InvalidateCache();
			DecoObjectResolver.InvalidateCache();
			CardExpansionTypeResolver.InvalidateCache();
			EplRuntimeData.Assets.LookupLibrary.InvalidateSortedPackTypes();
			InventoryBasePatches.InvalidateRestockDataLookup();
			ModLogger.Info("Bundle processing complete, unloading unreferenced bundle assets", "LoadBundlesAsync", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\BundleLoadingManager.cs");
			yield return Resources.UnloadUnusedAssets();
			isLoadingComplete = true;
			EplRuntimeData.Events.FireOnBundleLoadingComplete();
		}

		private static void RegisterUnreadableBundle(string jsonFile, string error)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: 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_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			string? directoryName = Path.GetDirectoryName(jsonFile);
			string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(jsonFile);
			string text = Path.Combine(directoryName, fileNameWithoutExtension);
			BundleInfo val = new BundleInfo
			{
				JsonPath = jsonFile,
				BundlePath = text,
				Name = fileNameWithoutExtension,
				BundleId = text,
				IsValid = false
			};
			val.errors.Add(error);
			EplRuntimeData.Assets.BundleRegistry.RegisterBundle(val);
		}
	}
	internal class LoadingScreenMessageService
	{
		private Coroutine? activeRoutine;

		private Localize? localize;

		private TextMeshProUGUI? textMeshPro;

		private List<string> loadingMessages = new List<string>();

		public void Initialize()
		{
			Transform val = ((Component)CSingleton<LoadingScreen>.Instance).transform.Find("ScreenGrp/AnimGrp/Text");
			localize = ((Component)val).GetComponent<Localize>();
			textMeshPro = ((Component)val).GetComponent<TextMeshProUGUI>();
			loadingMessages = BuildMessageList();
		}

		private static List<string> BuildMessageList()
		{
			return new List<string>(57)
			{
				"Rigging the booster pack RNG...", "Randomizing your binder sorting...", "Refusing to read the IKEA instructions...", "Resealing packs after removing rares...", "Calculating exactly how much you've spent on cardboard...", "Reminding players that deodorant is not optional...", "Adjusting card prices based on a single Reddit post...", "Un-sticking a customer from the entrance door...", "Alphabetizing the commons... again...", "Convincing customers that 'Near Mint' is a state of mind...",
				"Simulating the smell of a competitive local tournament...", "Scanning for customers trying to pay in loose change and buttons...", "Calculating the odds of a customer actually using the trash can...", "Debating whether a 9.5 is 'Basically a 10' or 'Basically a 1'...", "Pretending that bulk commons are 'premium inventory'...", "Setting up the 'Kids Only' tournament that's 90% adults...", "Explaining that water damage doesn't count as 'natural weathering'...", "Polishing the display case no one ever buys from...", "Restocking energy drinks for the Friday Night Magic grinders...", "Teaching new players that 'proxy' isn't a swear word...",
				"Explaining why we don't accept Monopoly money...", "Counting how many times someone's touched a card without buying it...", "Preparing the 'I know what I have' customer speech...", "Hiding the valuable cards from the guy who 'just wants to look'...", "Sweeping up crushed Doritos from under the gaming tables...", "Resetting the 'Days Since Last Rules Argument' counter to zero...", "Listening to someone explain their 'unbeatable' deck for 20 minutes...", "Nodding along while someone explains card value from 2003...", "Pretending to care about your pulls from a pack you opened in store...", "Calculating trade-in value: 'Best I can do is $3 store credit'...",
				"Stocking sleeves that will be out of stock in 4 minutes...", "Reorganizing singles that customers dumped back in the wrong box...", "Preparing the 'We're not a daycare' announcement...", "Checking if that's a legitimate grading or just a guy with a sharpie...", "Explaining that 'vintage' means old, not valuable...", "Pretending we haven't memorized every regular's usual order...", "Straightening the playmat display for the hundredth time today...", "Updating the tournament bracket that's already wrong...", "Practicing the 'Sorry, we're out of stock' face...", "Arranging deck boxes by color because someone will complain if we don't...",
				"Calculating how many packs until someone pulls something good...", "Preparing the 'Store credit only' policy speech...", "Watching someone shuffle the same deck for 10 minutes...", "Explaining why opened product can't be returned...", "Setting up chairs for an event that starts in 3 hours...", "Answering 'Do you buy cards?' for the 50th time today...", "Ignoring 42 redundant compiler warnings...", "Translating 'Developer Spaghetti' into 'Player Features'...", "Replacing 'Bugs' with 'Surprise Mechanics'...", "Feeding the hamster that powers the loading bar...",
				"Checking if the mod is still compatible with the base game...", "Distracting the player with funny text so they don't notice the lag...", "Fixing one bug, creating seventeen new ones...", "Discovering our mod conflicts with itself somehow...", "Duct taping our mod onto the existing duct tape...", "Asking ChatGPT for more loading screen messages...", "As seen on Real Civil Engineer..."
			};
		}

		public void Start(MonoBehaviour host)
		{
			if (activeRoutine != null)
			{
				ModLogger.Error("Message rotator has already been started.", "Start", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\LoadingScreenMessageService.cs");
			}
			else
			{
				activeRoutine = host.StartCoroutine(CycleMessages());
			}
		}

		public void Stop(MonoBehaviour host)
		{
			if (activeRoutine != null)
			{
				host.StopCoroutine(activeRoutine);
				activeRoutine = null;
			}
		}

		private IEnumerator CycleMessages()
		{
			while (true)
			{
				if (textMeshPro != null)
				{
					yield return FadeText(1f, 0f, 2f);
				}
				if (loadingMessages.Count == 0)
				{
					loadingMessages = BuildMessageList();
				}
				int index = Random.Range(0, loadingMessages.Count);
				Localize? obj = localize;
				if (obj != null)
				{
					obj.Term = loadingMessages[index];
				}
				loadingMessages.SwapAndRemove(index);
				if (textMeshPro != null)
				{
					yield return FadeText(0f, 1f, 2f);
				}
				yield return null;
			}
		}

		private IEnumerator FadeText(float startAlpha, float endAlpha, float duration)
		{
			float elapsed = 0f;
			Color color = ((Graphic)textMeshPro).color;
			while (elapsed < duration)
			{
				elapsed += Time.deltaTime;
				float a = Mathf.Lerp(startAlpha, endAlpha, elapsed / duration);
				color.a = a;
				((Graphic)textMeshPro).color = color;
				yield return null;
			}
			color.a = endAlpha;
			((Graphic)textMeshPro).color = color;
		}
	}
	internal class ProcessingService
	{
		private readonly CardExpansionProcessor cardExpansionProcessor = new CardExpansionProcessor();

		private readonly ItemProcessor itemProcessor = new ItemProcessor();

		private readonly PrefabProcessor prefabProcessor = new PrefabProcessor();

		internal IEnumerator ProcessAsync(BundleDescriptor descriptor, BundleInfo bundleInfo)
		{
			ProcessAssemblies(descriptor.Assemblies, bundleInfo);
			BundleManager.BundleHandle bundleHandle = EplRuntimeData.Services.BundleManager.GetOrOpen(bundleInfo.BundlePath);
			yield return bundleHandle.WaitForLoadAsync();
			if (bundleHandle.HasError)
			{
				bundleInfo.errors.Add("Bundle failed to open " + bundleInfo.BundlePath);
				ModLogger.Error("Bundle failed to open " + bundleInfo.BundlePath, "ProcessAsync", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ProcessingService.cs");
				bundleInfo.IsValid = false;
				yield break;
			}
			BundleAssetsPreloader assetRequest = BundleAssetsPreloader.LoadFromAsync(descriptor, bundleHandle);
			yield return assetRequest;
			BundleAssetsPreloader.BundleAssets assets = assetRequest.Result;
			RunStage("CardExpansions Processing", delegate
			{
				cardExpansionProcessor.Process(descriptor.CardExpansions, bundleInfo, assets);
			}, bundleInfo);
			RunStage("Prefabs Processing", delegate
			{
				prefabProcessor.Process(descriptor.Prefabs, bundleInfo, assets);
			}, bundleInfo);
			RunStage("Shops Processing", delegate
			{
				ProcessShops(descriptor.CustomShops, bundleInfo, assets);
			}, bundleInfo);
			RunStage("Items Processing", delegate
			{
				itemProcessor.Process(descriptor.Items, bundleInfo, assets);
			}, bundleInfo);
		}

		private static void RunStage(string stageName, Action stage, BundleInfo bundleInfo)
		{
			try
			{
				stage();
			}
			catch (Exception ex)
			{
				bundleInfo.errors.Add(stageName + " stage failed: " + ex.GetType().Name + ": " + ex.Message);
				ModLogger.Error("[" + bundleInfo.Name + "] " + stageName + " stage failed: " + ex.GetType().Name + ": " + ex.Message + "\n" + ex.StackTrace, "RunStage", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ProcessingService.cs");
			}
		}

		private void ProcessAssemblies(List<string> assemblies, BundleInfo bundleInfo)
		{
			foreach (string assembly in assemblies)
			{
				string directoryName = Path.GetDirectoryName(bundleInfo.BundlePath);
				string text = Path.Combine(directoryName, assembly);
				if (!File.Exists(text))
				{
					bundleInfo.errors.Add(assembly + " not found in directory " + directoryName);
					ModLogger.Error(assembly + " not found in directory " + directoryName, "ProcessAssemblies", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ProcessingService.cs");
					continue;
				}
				try
				{
					EplRuntimeData.Assemblies.Add(Assembly.LoadFrom(text));
				}
				catch (Exception ex)
				{
					bundleInfo.errors.Add("Failed to load " + text + ": " + ex.Message);
					ModLogger.Error("Failed to load " + text + ": " + ex.Message, "ProcessAssemblies", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ProcessingService.cs");
				}
			}
		}

		private void ProcessShops(List<CustomShopInfo> customShops, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			foreach (CustomShopInfo item in customShops.Where((CustomShopInfo s) => s.IsValid))
			{
				EplRuntimeData.Assets.ShopLibrary.CustomShops[item.PhoneAppId] = new CustomShopData
				{
					PhoneAppId = item.PhoneAppId,
					AppDisplayName = item.AppDisplayName,
					AppIcon = item.AppIcon,
					AppInnerBGImage = item.AppInnerBGImage,
					AppOuterBGImage = item.AppOuterBGImage,
					SiteLogo = (string.IsNullOrWhiteSpace(item.SiteLogo) ? null : new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.SiteLogo)),
					SiteHeader = (string.IsNullOrWhiteSpace(item.SiteHeader) ? null : new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.SiteHeader)),
					SiteBackground = (string.IsNullOrWhiteSpace(item.SiteBackground) ? null : new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.SiteBackground))
				};
			}
		}
	}
	internal class SanitizerService
	{
		private const float DefaultFoilChance = 0.025f;

		private const float DefaultGodPackPercentage = 0.0002f;

		internal void Sanitize(BundleDescriptor descriptor, BundleInfo bundleInfo)
		{
			Dictionary<string, List<string>> assumedFields = new Dictionary<string, List<string>>();
			if (string.IsNullOrWhiteSpace(bundleInfo.Name))
			{
				bundleInfo.Name = Path.GetFileNameWithoutExtension(bundleInfo.BundlePath);
			}
			if (string.IsNullOrWhiteSpace(bundleInfo.BundleId))
			{
				bundleInfo.BundleId = bundleInfo.BundlePath;
			}
			foreach (PrefabInfo prefab in descriptor.Prefabs)
			{
				if (string.IsNullOrWhiteSpace(prefab.PrefabName))
				{
					prefab.PrefabName = prefab.Name;
				}
				prefab.ObjectType = StringExtensions.Sanitize(prefab.ObjectType);
				prefab.DecoObject = StringExtensions.Sanitize(prefab.DecoObject);
				prefab.DecoType = StringExtensions.Sanitize(prefab.DecoType);
			}
			foreach (CardExpansionInfo cardExpansion in descriptor.CardExpansions)
			{
				cardExpansion.CardExpansion = StringExtensions.Sanitize(cardExpansion.CardExpansion);
				if (string.IsNullOrWhiteSpace(cardExpansion.CardPriceStrategy))
				{
					if (!cardExpansion.CardPriceStrategySuppliedByApi)
					{
						cardExpansion.CardPriceStrategySuppliedByApi = true;
						RecordAssumedApiField(assumedFields, "CardPriceStrategy", cardExpansion.Name);
					}
					cardExpansion.CardPriceStrategy = "Default";
				}
				cardExpansion.CardPriceStrategy = StringExtensions.Sanitize(cardExpansion.CardPriceStrategy);
				if (cardExpansion.CardPriceStrategySuppliedByApi && !Enum.TryParse<CardPriceGenerationStrategy>(cardExpansion.CardPriceStrategy, out var _))
				{
					cardExpansion.CardPriceStrategy = "Default";
				}
				if (cardExpansion.HasRandomFoils && cardExpansion.FoilChance == 0f)
				{
					cardExpansion.FoilChance = 0.025f;
				}
				for (int i = 0; i < cardExpansion.Rarities.Count; i++)
				{
					cardExpansion.Rarities[i] = StringExtensions.Sanitize(cardExpansion.Rarities[i]);
				}
				foreach (CardInfo card in cardExpansion.Cards)
				{
					card.Rarity = StringExtensions.Sanitize(card.Rarity);
					card.BorderType = StringExtensions.Sanitize(card.BorderType);
					card.ElementType = StringExtensions.Sanitize(card.ElementType);
				}
			}
			foreach (ItemInfo item in descriptor.Items)
			{
				if (!item.HasBigBox && !item.HasSmallBox)
				{
					item.HasSmallBox = true;
					item.SmallBoxHideTillUnlocked = item.BigBoxHideTillUnlocked;
					item.SmallBoxLicensePrice = item.BigBoxLicensePrice;
					item.SmallBoxLicenseLevelRequirement = item.BigBoxLicenseLevelRequirement;
					item.SmallBoxIgnoreDoubleImage = item.BigBoxIgnoreDoubleImage;
					item.BigBoxHideTillUnlocked = false;
					item.BigBoxLicensePrice = 0f;
					item.BigBoxLicenseLevelRequirement = 0;
					item.BigBoxIgnoreDoubleImage = false;
				}
				if (item.IsCardPack || item.IsCardBox || item.IsBulkBox)
				{
					if (string.IsNullOrWhiteSpace(item.Mesh) && !item.UsesBaseGameMesh)
					{
						item.UsesBaseGameMesh = true;
						item.MeshToUse = (item.IsCardPack ? "BasicCardPack" : (item.IsCardBox ? "BasicCardBox" : "BulkBox_TetramonBase"));
					}
					if (item.IsCardPack && item.CanHaveGodPacks && item.GodPackPercentage <= 0f)
					{
						item.GodPackPercentage = 0.0002f;
					}
				}
				for (int j = 0; j < item.PriceAffectedBy.Count; j++)
				{
					item.PriceAffectedBy[j] = StringExtensions.Sanitize(item.PriceAffectedBy[j]);
				}
				if (item.IsCardPack)
				{
					if (!item.ApiManaged && (string.IsNullOrWhiteSpace(item.PackType) || string.IsNullOrWhiteSpace(item.PackGenerationStrategy)))
					{
						item.ApiManaged = true;
						RecordAssumedApiField(assumedFields, "PackGenerationStrategy", item.Name);
						RecordAssumedApiField(assumedFields, "NormalWeights", item.Name);
						RecordAssumedApiField(assumedFields, "GodWeights", item.Name);
						RecordAssumedApiField(assumedFields, "SlotWeights", item.Name);
						RecordAssumedApiField(assumedFields, "CanHaveGodPacks", item.Name);
						RecordAssumedApiField(assumedFields, "GodPackPercentage", item.Name);
					}
					if (string.IsNullOrWhiteSpace(item.PackType))
					{
						item.PackType = item.ItemType;
					}
					if (item.ApiManaged)
					{
						item.NormalWeightsSuppliedByApi = true;
						item.GodWeightsSuppliedByApi = true;
						item.SlotWeightsSuppliedByApi = true;
						item.CanHaveGodPacksSuppliedByApi = true;
						item.GodPackPercentageSuppliedByApi = true;
					}
				}
				if (descriptor.ItemPricesSuppliedByApi)
				{
					item.MarketPricePercentSuppliedByApi = true;
					item.FollowItemPriceSuppliedByApi = true;
					item.AutoBoxPriceSuppliedByApi = true;
				}
				item.CardExpansion = StringExtensions.Sanitize(item.CardExpansion);
				item.FollowItemPrice = StringExtensions.Sanitize(item.FollowItemPrice);
				if (!string.IsNullOrWhiteSpace(item.FollowItemPrice) && !item.FollowItemPrice.Equals("None", StringComparison.OrdinalIgnoreCase) && !Enum.TryParse<EItemType>(item.FollowItemPrice, out EItemType _))
				{
					if (!item.FollowItemPriceSuppliedByApi)
					{
						string text = item.Name + " specifies an invalid item type " + item.FollowItemPrice + " for FollowItemPrice. Defaulting to None.";
						bundleInfo.warnings.Add(text);
						ModLogger.Warning(text, "Sanitize", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\SanitizerService.cs");
					}
					item.FollowItemPrice = "None";
				}
				item.ItemCategory = StringExtensions.Sanitize(item.ItemCategory);
				item.ItemType = StringExtensions.Sanitize(item.ItemType);
				item.PackType = StringExtensions.Sanitize(item.PackType);
				item.SpawnsPackType = StringExtensions.Sanitize(item.SpawnsPackType);
				item.MeshToUse = StringExtensions.Sanitize(item.MeshToUse);
				foreach (RarityWeightInfo generationWeight in item.GenerationWeights)
				{
					generationWeight.Rarity = StringExtensions.Sanitize(generationWeight.Rarity);
				}
				item.NormalWeights = item.NormalWeights.ToDictionary<KeyValuePair<string, float>, string, float>((KeyValuePair<string, float> kvp) => StringExtensions.Sanitize(kvp.Key), (KeyValuePair<string, float> kvp) => kvp.Value);
				item.GodWeights = item.GodWeights.ToDictionary<KeyValuePair<string, float>, string, float>((KeyValuePair<string, float> kvp) => StringExtensions.Sanitize(kvp.Key), (KeyValuePair<string, float> kvp) => kvp.Value);
				item.SlotWeights = item.SlotWeights.ToDictionary<KeyValuePair<string, Dictionary<string, float>>, string, Dictionary<string, float>>((KeyValuePair<string, Dictionary<string, float>> kvp) => StringExtensions.Sanitize(kvp.Key), (KeyValuePair<string, Dictionary<string, float>> kvp) => kvp.Value.ToDictionary((KeyValuePair<string, float> inner) => StringExtensions.Sanitize(inner.Key), (KeyValuePair<string, float> inner) => inner.Value));
				if (!item.IsCardPack || string.IsNullOrWhiteSpace(item.CardExpansion))
				{
					continue;
				}
				CardExpansionInfo cardExpansionInfo = descriptor.CardExpansions.FirstOrDefault((CardExpansionInfo e) => e.CardExpansion == item.CardExpansion);
				if (cardExpansionInfo == null)
				{
					continue;
				}
				if (item.GenerationWeights.Count == 0)
				{
					foreach (string item2 in cardExpansionInfo.Rarities.Where((string r) => !string.IsNullOrWhiteSpace(r)))
					{
						item.NormalWeights.TryAdd(item2, 0f);
						item.GodWeights.TryAdd(item2, 0f);
						foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight in item.SlotWeights)
						{
							slotWeight.Value.TryAdd(item2, 0f);
						}
					}
				}
				ZeroUnsupportedRarityWeights(item, cardExpansionInfo, bundleInfo);
			}
			WarnAssumedApiFields(assumedFields, bundleInfo);
		}

		private void RecordAssumedApiField(Dictionary<string, List<string>> assumedFields, string field, string name)
		{
			assumedFields.GetOrAdd(field, (string _) => new List<string>()).Add(name);
		}

		private void WarnAssumedApiFields(Dictionary<string, List<string>> assumedFields, BundleInfo bundleInfo)
		{
			foreach (KeyValuePair<string, List<string>> assumedField in assumedFields)
			{
				assumedField.Deconstruct(out var key, out var value);
				string text = key;
				List<string> values = value;
				string text2 = text + " is not set for " + string.Join(", ", values) + " and is assumed to be supplied via the EPL API. This assumption will likely be removed in a future release — if this value really is supplied through the API, rebundle with the \"Supplied by API\" option checked for it in the bundle exporter.";
				bundleInfo.warnings.Add(text2);
				ModLogger.Warning(text2, "WarnAssumedApiFields", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\SanitizerService.cs");
			}
		}

		private void ZeroUnsupportedRarityWeights(ItemInfo item, CardExpansionInfo expansion, BundleInfo bundleInfo)
		{
			HashSet<string> hashSet = new HashSet<string>(expansion.Cards.Select((CardInfo c) => c.Rarity));
			HashSet<string> hashSet2 = new HashSet<string>();
			foreach (string item2 in item.NormalWeights.Keys.ToList())
			{
				if (item.NormalWeights[item2] > 0f && !hashSet.Contains(item2))
				{
					item.NormalWeights[item2] = 0f;
					hashSet2.Add(item2);
				}
			}
			foreach (string item3 in item.GodWeights.Keys.ToList())
			{
				if (item.GodWeights[item3] > 0f && !hashSet.Contains(item3))
				{
					item.GodWeights[item3] = 0f;
					hashSet2.Add(item3);
				}
			}
			foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight in item.SlotWeights)
			{
				foreach (string item4 in slotWeight.Value.Keys.ToList())
				{
					if (slotWeight.Value[item4] > 0f && !hashSet.Contains(item4))
					{
						slotWeight.Value[item4] = 0f;
						hashSet2.Add(item4);
					}
				}
			}
			foreach (RarityWeightInfo generationWeight in item.GenerationWeights)
			{
				if (!hashSet.Contains(generationWeight.Rarity) && (generationWeight.NormalWeight > 0f || generationWeight.GodPackWeight > 0f))
				{
					generationWeight.NormalWeight = 0f;
					generationWeight.GodPackWeight = 0f;
					hashSet2.Add(generationWeight.Rarity);
				}
			}
			foreach (string item5 in hashSet2)
			{
				string text = item.Name + " has weight assigned to rarity " + item5 + " but expansion " + expansion.Name + " has no cards with that rarity. Weight has been set to 0.";
				bundleInfo.warnings.Add(text);
				ModLogger.Warning(text, "ZeroUnsupportedRarityWeights", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\SanitizerService.cs");
			}
		}
	}
	internal class ValidationService
	{
		private readonly PrefabValidator prefabValidator = new PrefabValidator();

		private readonly CardExpansionValidator cardExpansionValidator = new CardExpansionValidator();

		private readonly ItemValidator itemValidator = new ItemValidator();

		private readonly HashSet<string> seenBundleIds = new HashSet<string>();

		private readonly HashSet<string> seenExpansionIds = new HashSet<string>();

		internal void Validate(BundleDescriptor descriptor, BundleInfo bundleInfo)
		{
			if (!seenBundleIds.Add(bundleInfo.BundleId))
			{
				string text = "Duplicate BundleId '" + bundleInfo.BundleId + "' — another loaded bundle already uses this id. BundleIds are meant to be unique; '" + bundleInfo.Name + "' will still load, but duplicate ids may cause issues in future releases if uniqueness is ever enforced.";
				bundleInfo.warnings.Add(text);
				ModLogger.Warning(text, "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ValidationService.cs");
			}
			if (!File.Exists(bundleInfo.BundlePath))
			{
				bundleInfo.errors.Add("No asset bundle found for " + descriptor.Name);
				ModLogger.Error("No asset bundle found for " + descriptor.Name, "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ValidationService.cs");
				bundleInfo.IsValid = false;
			}
			if (bundleInfo.IsValid)
			{
				prefabValidator.Validate(descriptor.Prefabs, bundleInfo);
				cardExpansionValidator.Validate(descriptor.CardExpansions, bundleInfo);
				ValidateUniqueExpansionIds(descriptor.CardExpansions, bundleInfo);
				itemValidator.Validate(descriptor.Items, descriptor.CardExpansions, bundleInfo);
				ValidateCustomShops(descriptor.CustomShops, bundleInfo);
			}
		}

		internal void ValidateCustomShops(List<CustomShopInfo> customShops, BundleInfo bundleInfo)
		{
			foreach (CustomShopInfo customShop in customShops)
			{
				if (string.IsNullOrWhiteSpace(customShop.PhoneAppId))
				{
					bundleInfo.errors.Add(bundleInfo.Name + " has a phone app specified with no phone app id.");
					ModLogger.Error(bundleInfo.Name + " has a phone app specified with no phone app id.", "ValidateCustomShops", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ValidationService.cs");
					customShop.IsValid = false;
				}
			}
		}

		private void ValidateUniqueExpansionIds(List<CardExpansionInfo> cardExpansions, BundleInfo bundleInfo)
		{
			foreach (CardExpansionInfo cardExpansion in cardExpansions)
			{
				if (cardExpansion.IsValid && !seenExpansionIds.Add(cardExpansion.CardExpansion))
				{
					string text = "Duplicate CardExpansion id '" + cardExpansion.CardExpansion + "' in '" + bundleInfo.Name + "' — another loaded expansion already uses this id, skipping the expansion and any packs that reference it.";
					bundleInfo.errors.Add(text);
					ModLogger.Error(text, "ValidateUniqueExpansionIds", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\ValidationService.cs");
					cardExpansion.IsValid = false;
				}
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.LoadingPipeline.Validators
{
	internal class CardExpansionValidator
	{
		internal void Validate(List<CardExpansionInfo> cardExpansions, BundleInfo bundleInfo)
		{
			foreach (CardExpansionInfo cardExpansion in cardExpansions)
			{
				if (string.IsNullOrWhiteSpace(cardExpansion.Name))
				{
					bundleInfo.errors.Add("A card expansion in " + bundleInfo.Name + " is missing a Name and will not be processed");
					ModLogger.Error("A card expansion in " + bundleInfo.Name + " is missing a Name and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					cardExpansion.IsValid = false;
				}
				if (string.IsNullOrWhiteSpace(cardExpansion.FoilMask))
				{
					bundleInfo.warnings.Add(cardExpansion.Name + " is missing a foil mask");
					ModLogger.Warning(cardExpansion.Name + " is missing a foil mask", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
				}
				if (string.IsNullOrWhiteSpace(cardExpansion.Cardback))
				{
					bundleInfo.warnings.Add(cardExpansion.Name + " is missing a card back");
					ModLogger.Warning(cardExpansion.Name + " is missing a card back", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
				}
				if (!Enum.TryParse<ECardExpansionType>(cardExpansion.CardExpansion, out ECardExpansionType _))
				{
					bundleInfo.errors.Add(cardExpansion.Name + " has an invalid expansion type and will not be processed");
					ModLogger.Error(cardExpansion.Name + " has an invalid expansion type and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					cardExpansion.IsValid = false;
				}
				if (!Enum.TryParse<CardPriceGenerationStrategy>(cardExpansion.CardPriceStrategy, out var _))
				{
					bundleInfo.errors.Add(cardExpansion.Name + " has an invalid card price strategy '" + cardExpansion.CardPriceStrategy + "' and will not be processed");
					ModLogger.Error(cardExpansion.Name + " has an invalid card price strategy '" + cardExpansion.CardPriceStrategy + "' and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					cardExpansion.IsValid = false;
				}
				ERarity result3;
				if (cardExpansion.Rarities.Count == 0)
				{
					bundleInfo.errors.Add(cardExpansion.Name + " has no rarities asigned to it and will not be processed.");
					ModLogger.Error(cardExpansion.Name + " has no rarities asigned to it and will not be processed.", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					cardExpansion.IsValid = false;
				}
				else
				{
					foreach (string rarity in cardExpansion.Rarities)
					{
						if (!Enum.TryParse<ERarity>(rarity, out result3))
						{
							bundleInfo.errors.Add("The rarity " + rarity + " in " + cardExpansion.Name + " is invalid");
							ModLogger.Error("The rarity " + rarity + " in " + cardExpansion.Name + " is invalid", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
							cardExpansion.IsValid = false;
						}
					}
				}
				if (cardExpansion.Cards.Count == 0)
				{
					bundleInfo.errors.Add(cardExpansion.Name + " has no cards assigned to it and will not be processed.");
					ModLogger.Error(cardExpansion.Name + " has no cards assigned to it and will not be processed.", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					cardExpansion.IsValid = false;
					continue;
				}
				foreach (CardInfo card in cardExpansion.Cards)
				{
					if (string.IsNullOrWhiteSpace(card.Name))
					{
						bundleInfo.errors.Add("A card in " + cardExpansion.Name + " is missing a name. Expansion will not be processed");
						ModLogger.Error("A card in " + cardExpansion.Name + " is missing a name. Expansion will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
						cardExpansion.IsValid = false;
					}
					if (string.IsNullOrWhiteSpace(card.Sprite))
					{
						bundleInfo.warnings.Add(card.Name + " in expansion " + cardExpansion.Name + " is missing a sprite");
						ModLogger.Warning(card.Name + " in expansion " + cardExpansion.Name + " is missing a sprite", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
					}
					if (!Enum.TryParse<ERarity>(card.Rarity, out result3) || !cardExpansion.Rarities.Contains(card.Rarity))
					{
						bundleInfo.errors.Add(card.Name + " in expansion " + cardExpansion.Name + " has an invalid rarity. Expansion will not be processed");
						ModLogger.Error(card.Name + " in expansion " + cardExpansion.Name + " has an invalid rarity. Expansion will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
						cardExpansion.IsValid = false;
					}
					if (!Enum.TryParse<ECardBorderType>(card.BorderType, out ECardBorderType _))
					{
						bundleInfo.errors.Add(card.Name + " in expansion " + cardExpansion.Name + " has an invalid border type. Expansion will not be processed");
						ModLogger.Error(card.Name + " in expansion " + cardExpansion.Name + " has an invalid border type. Expansion will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
						cardExpansion.IsValid = false;
					}
					if (!Enum.TryParse<EElementIndex>(card.ElementType, out EElementIndex _))
					{
						bundleInfo.errors.Add(card.Name + " in expansion " + cardExpansion.Name + " has an invalid element type. Expansion will not be processed");
						ModLogger.Error(card.Name + " in expansion " + cardExpansion.Name + " has an invalid element type. Expansion will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\CardExpansionValidator.cs");
						cardExpansion.IsValid = false;
					}
				}
			}
		}
	}
	internal class ItemValidator
	{
		internal void Validate(List<ItemInfo> items, List<CardExpansionInfo> expansions, BundleInfo bundleInfo)
		{
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Invalid comparison between Unknown and I4
			foreach (ItemInfo item in items)
			{
				if (string.IsNullOrWhiteSpace(item.Name))
				{
					bundleInfo.errors.Add("An item in " + bundleInfo.Name + " is missing a name and will not be processed");
					ModLogger.Error("An item in " + bundleInfo.Name + " is missing a name and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item.IsValid = false;
				}
				if (string.IsNullOrWhiteSpace(item.SpriteName))
				{
					bundleInfo.warnings.Add(item.Name + " is missing a sprite");
					ModLogger.Warning(item.Name + " is missing a sprite", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
				}
				if (!Enum.TryParse<EItemType>(item.ItemType, out EItemType result))
				{
					bundleInfo.errors.Add(item.Name + " has an invalid item type and will not be processed");
					ModLogger.Error(item.Name + " has an invalid item type and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item.IsValid = false;
				}
				if (!Enum.TryParse<EItemCategory>(item.ItemCategory, out EItemCategory result2))
				{
					bundleInfo.errors.Add(item.Name + " has an invalid item category and will not be processed");
					ModLogger.Error(item.Name + " has an invalid item category and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item.IsValid = false;
				}
				else if (!item.AddItemAsAccessory && !item.AddItemAsBoardGame && !item.AddItemAsFigurine && (int)result2 != 1)
				{
					bundleInfo.warnings.Add(item.Name + " has no shop categories assigned and will not appear in any shop tab");
					ModLogger.Warning(item.Name + " has no shop categories assigned and will not appear in any shop tab", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
				}
				if (item.PriceAffectedBy.Count > 0)
				{
					foreach (string item3 in item.PriceAffectedBy)
					{
						if (!Enum.TryParse<EPriceChangeType>(item3, out EPriceChangeType _))
						{
							bundleInfo.errors.Add(item.Name + " specifies an invalid price affected by type " + item3 + " for price affected by and will not be processed");
							ModLogger.Error(item.Name + " specifies an invalid price affected by type " + item3 + " for price affected by and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
							item.IsValid = false;
						}
					}
				}
				if (item.UsesBaseGameMesh && !Enum.TryParse<EItemType>(item.MeshToUse, out result))
				{
					bundleInfo.errors.Add(item.Name + " specifies an invalid item type " + item.MeshToUse + " for mesh to use and will not be processed");
					ModLogger.Error(item.Name + " specifies an invalid item type " + item.MeshToUse + " for mesh to use and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item.IsValid = false;
				}
				if (item.IsCardBox && !Enum.TryParse<EItemType>(item.SpawnsPackType, out result))
				{
					bundleInfo.errors.Add(item.Name + " specifies an invalid spawn pack type " + item.SpawnsPackType + " and will not be processed");
					ModLogger.Error(item.Name + " specifies an invalid spawn pack type " + item.SpawnsPackType + " and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item.IsValid = false;
				}
				if (!item.IsCardPack)
				{
					continue;
				}
				if (!Enum.TryParse<ECardExpansionType>(item.CardExpansion, out ECardExpansionType _))
				{
					bundleInfo.errors.Add(item.Name + " is declard to be a pack for an invalid expansion type " + item.CardExpansion + " and will not be processed.");
					ModLogger.Error(item.Name + " is declard to be a pack for an invalid expansion type " + item.CardExpansion + " and will not be processed.", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item.IsValid = false;
				}
				else
				{
					CardExpansionInfo cardExpansionInfo = expansions.FirstOrDefault((CardExpansionInfo e) => e.CardExpansion == item.CardExpansion);
					if (cardExpansionInfo == null || !cardExpansionInfo.IsValid)
					{
						bundleInfo.errors.Add(item.Name + " references expansion " + item.CardExpansion + " which was not processed and will not be processed");
						ModLogger.Error(item.Name + " references expansion " + item.CardExpansion + " which was not processed and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
						item.IsValid = false;
					}
					else if (!item.CanHaveDuplicates && cardExpansionInfo.Cards.Count < 7)
					{
						bundleInfo.warnings.Add($"{item.Name} disallows duplicates but expansion {item.CardExpansion} only has {cardExpansionInfo.Cards.Count} cards; packs will include duplicates to fill all 7 slots");
						ModLogger.Warning($"{item.Name} disallows duplicates but expansion {item.CardExpansion} only has {cardExpansionInfo.Cards.Count} cards; packs will include duplicates to fill all 7 slots", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					}
				}
				if (!Enum.TryParse<ECollectionPackType>(item.PackType, out ECollectionPackType _))
				{
					bundleInfo.errors.Add(item.Name + " has an invalid pack type declard and will not be processed.");
					ModLogger.Error(item.Name + " has an invalid pack type declard and will not be processed.", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item.IsValid = false;
				}
				if (!item.ApiManaged)
				{
					ValidatePackGeneration(item, bundleInfo);
				}
			}
			foreach (ItemInfo item2 in items.Where((ItemInfo i) => i.IsValid && i.IsCardBox))
			{
				ItemInfo itemInfo = items.FirstOrDefault((ItemInfo i) => i.IsCardPack && i.ItemType == item2.SpawnsPackType);
				if (itemInfo == null || !itemInfo.IsValid)
				{
					bundleInfo.errors.Add(item2.Name + " spawns pack " + item2.SpawnsPackType + " which was not processed and will not be processed");
					ModLogger.Error(item2.Name + " spawns pack " + item2.SpawnsPackType + " which was not processed and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item2.IsValid = false;
				}
			}
		}

		private void ValidatePackGeneration(ItemInfo item, BundleInfo bundleInfo)
		{
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0303: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_030e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0312: Invalid comparison between Unknown and I4
			//IL_0314: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_031c: Unknown result type (might be due to invalid IL or missing references)
			if (!Enum.TryParse<PackGenerationStrategy>(item.PackGenerationStrategy, out var result))
			{
				bundleInfo.errors.Add(item.Name + " has an invalid pack generation strategy declard and will not be processed.");
				ModLogger.Error(item.Name + " has an invalid pack generation strategy declard and will not be processed.", "ValidatePackGeneration", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
				item.IsValid = false;
				return;
			}
			bool flag = ((item.NormalWeights.Count > 0) ? item.NormalWeights.Values.All((float w) => w <= 0f) : item.GenerationWeights.TrueForAll((RarityWeightInfo w) => w.NormalWeight <= 0f));
			if (result == PackGenerationStrategy.AllRandomWeighted && !item.NormalWeightsSuppliedByApi && flag)
			{
				bundleInfo.errors.Add(item.Name + " has a pack generation strategy that requires at least 1 normal weight to be greater than 0. Item does not meet this and will not be processed");
				ModLogger.Error(item.Name + " has a pack generation strategy that requires at least 1 normal weight to be greater than 0. Item does not meet this and will not be processed", "ValidatePackGeneration", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
				item.IsValid = false;
			}
			bool flag2 = ((item.GodWeights.Count > 0) ? item.GodWeights.Values.All((float w) => w <= 0f) : item.GenerationWeights.TrueForAll((RarityWeightInfo w) => w.GodPackWeight <= 0f));
			if (item.CanHaveGodPacks && !item.GodWeightsSuppliedByApi && flag2)
			{
				bundleInfo.errors.Add(item.Name + " can have god packs and requires at least 1 god pack weight to be greater than 0. Item does not meet this and will not be processed");
				ModLogger.Error(item.Name + " can have god packs and requires at least 1 god pack weight to be greater than 0. Item does not meet this and will not be processed", "ValidatePackGeneration", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
				item.IsValid = false;
			}
			ValidateWeightRarityKeys(item, result, bundleInfo);
			if (item.SlotWeightsSuppliedByApi)
			{
				return;
			}
			if (result == PackGenerationStrategy.Guaranteed && item.SlotWeights.Count > 0)
			{
				foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight in item.SlotWeights)
				{
					if (slotWeight.Value.Count == 0)
					{
						bundleInfo.errors.Add(item.Name + " has slot " + slotWeight.Key + " with no rarities assigned and will not be processed");
						ModLogger.Error(item.Name + " has slot " + slotWeight.Key + " with no rarities assigned and will not be processed", "ValidatePackGeneration", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
						item.IsValid = false;
					}
				}
				PackSlot val = (PackSlot)0;
				foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight2 in item.SlotWeights)
				{
					if (Enum.TryParse<PackSlot>(slotWeight2.Key, out PackSlot result2))
					{
						val |= result2;
					}
				}
				List<PackSlot> list = new List<PackSlot>();
				foreach (PackSlot value in Enum.GetValues(typeof(PackSlot)))
				{
					if ((int)value != 0 && (int)value != 127 && (val & value) == 0)
					{
						list.Add(value);
					}
				}
				if (list.Count > 0)
				{
					bundleInfo.errors.Add(item.Name + " uses the Guaranteed strategy but its slot weights do not cover " + string.Join(", ", list) + "; packs would come up short, item will not be processed");
					ModLogger.Error(item.Name + " uses the Guaranteed strategy but its slot weights do not cover " + string.Join(", ", list) + "; packs would come up short, item will not be processed", "ValidatePackGeneration", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
					item.IsValid = false;
				}
			}
			else if (result == PackGenerationStrategy.Guaranteed && item.GenerationWeights.Count == 0)
			{
				bundleInfo.errors.Add(item.Name + " uses the Guaranteed strategy but declares no slot weights; packs would be empty, item will not be processed");
				ModLogger.Error(item.Name + " uses the Guaranteed strategy but declares no slot weights; packs would be empty, item will not be processed", "ValidatePackGeneration", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
				item.IsValid = false;
			}
		}

		private void ValidateWeightRarityKeys(ItemInfo item, PackGenerationStrategy generationStrategy, BundleInfo bundleInfo)
		{
			bool flag = generationStrategy == PackGenerationStrategy.AllRandomWeighted && !item.NormalWeightsSuppliedByApi;
			bool flag2 = item.CanHaveGodPacks && !item.GodWeightsSuppliedByApi;
			bool flag3 = generationStrategy == PackGenerationStrategy.Guaranteed && !item.SlotWeightsSuppliedByApi;
			HashSet<string> hashSet = new HashSet<string>();
			ERarity result;
			if (flag)
			{
				foreach (string key in item.NormalWeights.Keys)
				{
					if (!Enum.TryParse<ERarity>(key, out result))
					{
						hashSet.Add(key);
					}
				}
			}
			if (flag2)
			{
				foreach (string key2 in item.GodWeights.Keys)
				{
					if (!Enum.TryParse<ERarity>(key2, out result))
					{
						hashSet.Add(key2);
					}
				}
			}
			if (flag3)
			{
				foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight in item.SlotWeights)
				{
					if (!Enum.TryParse<PackSlot>(slotWeight.Key, out PackSlot _))
					{
						hashSet.Add(slotWeight.Key);
					}
					foreach (string key3 in slotWeight.Value.Keys)
					{
						if (!Enum.TryParse<ERarity>(key3, out result))
						{
							hashSet.Add(key3);
						}
					}
				}
			}
			if ((flag && item.NormalWeights.Count == 0) || (flag2 && item.GodWeights.Count == 0) || (flag3 && item.SlotWeights.Count == 0))
			{
				foreach (RarityWeightInfo generationWeight in item.GenerationWeights)
				{
					if (!Enum.TryParse<ERarity>(generationWeight.Rarity, out result))
					{
						hashSet.Add(generationWeight.Rarity);
					}
				}
			}
			if (hashSet.Count > 0)
			{
				string text = item.Name + " has unknown weight keys (" + string.Join(", ", hashSet) + ") and will not be processed";
				bundleInfo.errors.Add(text);
				ModLogger.Error(text, "ValidateWeightRarityKeys", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\ItemValidator.cs");
				item.IsValid = false;
			}
		}
	}
	internal class PrefabValidator
	{
		internal void Validate(List<PrefabInfo> prefabs, BundleInfo bundleInfo)
		{
			foreach (PrefabInfo prefab in prefabs)
			{
				if (string.IsNullOrWhiteSpace(prefab.Name))
				{
					bundleInfo.errors.Add("A prefab in " + bundleInfo.Name + " is missing a Name and will not be processed");
					ModLogger.Error("A prefab in " + bundleInfo.Name + " is missing a Name and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					prefab.IsValid = false;
				}
				if (string.IsNullOrWhiteSpace(prefab.SpriteName))
				{
					bundleInfo.warnings.Add(prefab.Name + " does not specify a sprite");
					ModLogger.Warning(prefab.Name + " does not specify a sprite", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
				}
				if (!prefab.AddItemToFurnitureShop && !prefab.IsDecoObject && !prefab.IsDecoWallTexture && !prefab.IsDecoFloorTexture && !prefab.IsDecoCeilingTexture)
				{
					bundleInfo.warnings.Add(prefab.Name + " does not specify if it is a Deco or Furniture item and will not be placed in any shop");
					ModLogger.Warning(prefab.Name + " does not specify if it is a Deco or Furniture item and will not be placed in any shop", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
				}
				if (prefab.IsDecoWallTexture || prefab.IsDecoFloorTexture || prefab.IsDecoCeilingTexture)
				{
					if (string.IsNullOrWhiteSpace(prefab.NormalMap))
					{
						bundleInfo.warnings.Add(prefab.Name + " is missing a normal map.");
						ModLogger.Warning(prefab.Name + " is missing a normal map.", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					}
					if (string.IsNullOrWhiteSpace(prefab.RoughnessMap))
					{
						bundleInfo.warnings.Add(prefab.Name + " is missing a roughness map.");
						ModLogger.Warning(prefab.Name + " is missing a roughness map.", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					}
					if (string.IsNullOrWhiteSpace(prefab.Texture))
					{
						bundleInfo.warnings.Add(prefab.Name + " is missing a texture.");
						ModLogger.Warning(prefab.Name + " is missing a texture.", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					}
				}
				if (prefab.IsDecoObject)
				{
					if (!Enum.TryParse<EDecoObject>(prefab.DecoObject, out EDecoObject _))
					{
						bundleInfo.errors.Add(prefab.Name + " has an invalid Deco Object value set and will not be processed");
						ModLogger.Error(prefab.Name + " has an invalid Deco Object value set and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
						prefab.IsValid = false;
					}
					if (!Enum.TryParse<EDecoType>(prefab.DecoType, out EDecoType _))
					{
						bundleInfo.errors.Add(prefab.Name + " has an invalid Deco Type value set and will not be processed");
						ModLogger.Error(prefab.Name + " has an invalid Deco Type value set and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
						prefab.IsValid = false;
					}
				}
				if (prefab.AddItemToFurnitureShop && !Enum.TryParse<EObjectType>(prefab.ObjectType, out EObjectType _))
				{
					bundleInfo.errors.Add(prefab.Name + " has an invalid Object type set and will not be processed");
					ModLogger.Error(prefab.Name + " has an invalid Object type set and will not be processed", "Validate", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Validators\\PrefabValidator.cs");
					prefab.IsValid = false;
				}
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.LoadingPipeline.Processors
{
	internal class CardExpansionProcessor
	{
		internal void Process(List<CardExpansionInfo> cardExpansions, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_019b: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			foreach (CardExpansionInfo item2 in cardExpansions.Where((CardExpansionInfo ce) => ce.IsValid))
			{
				Dictionary<EMonsterType, ModCardData> dictionary = new Dictionary<EMonsterType, ModCardData>();
				ECardExpansionType val = Enum.Parse<ECardExpansionType>(item2.CardExpansion);
				foreach (var item3 in item2.Cards.Select((CardInfo card, int index) => (card: card, index: index)))
				{
					CardInfo item = item3.card;
					EMonsterType val2 = (EMonsterType)(item3.index + 1);
					dictionary[val2] = new ModCardData
					{
						Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.Sprite),
						FoilMask = (string.IsNullOrWhiteSpace(item.FoilMask) ? null : new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.FoilMask)),
						Cardback = (string.IsNullOrWhiteSpace(item.Cardback) ? null : new StreamingAsset<Texture>(bundleInfo.BundlePath, item.Cardback)),
						IsFoil = item.IsFoil,
						ExpansionType = val,
						BorderType = Enum.Parse<ECardBorderType>(item.BorderType),
						MonsterData = new MonsterData
						{
							Name = item.Name,
							ElementIndex = Enum.Parse<EElementIndex>(item.ElementType),
							Rarity = Enum.Parse<ERarity>(item.Rarity),
							MonsterType = val2,
							NextEvolution = (EMonsterType)0,
							PreviousEvolution = (EMonsterType)0,
							Description = "xxx yyy"
						}
					};
				}
				List<ERarity> rarities = item2.Rarities.Select((string r) => Enum.Parse<ERarity>(r)).ToList();
				CardPriceGenerationStrategy strategy = Enum.Parse<CardPriceGenerationStrategy>(item2.CardPriceStrategy);
				EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData[val] = new ModCardExpansionData
				{
					Name = item2.Name,
					MenuCategory = item2.MenuCategory,
					HasRandomFoils = item2.HasRandomFoils,
					FoilChance = item2.FoilChance,
					Cards = dictionary,
					Rarities = rarities,
					CardBack = new StreamingAsset<Texture>(bundleInfo.BundlePath, item2.Cardback),
					FoilMask = new StreamingAsset<Sprite>(bundleInfo.BundlePath, item2.FoilMask),
					TradeUnlockLevel = item2.TradeUnlockLevel,
					CardPriceGenerator = CardPriceGeneratorFactory.For(strategy, item2),
					CardExpGenerator = (ICardExpGenerator)(object)new CardExpGenerator(),
					PlayCardMaterials = (from m in item2.PlayCardMaterials.Where(assets.Materials.ContainsKey)
						select assets.Materials[m]).ToList()
				};
				bundleInfo.expansionTypes.Add(val);
				int numCards = dictionary.Count * ((!item2.HasRandomFoils) ? 1 : 2);
				EplRuntimeData.Services.SaveDataManager.RegisterSaveData<ECardExpansionType, CardExpansionSaveData>(bundleInfo.BundleId, val, new CardExpansionSaveData(numCards));
			}
		}
	}
	internal class ItemProcessor
	{
		private Material? templateMaterial;

		internal void Process(List<ItemInfo> items, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Expected O, but got Unknown
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			foreach (ItemInfo item in items.Where((ItemInfo i) => i.IsValid))
			{
				ItemMeshData val = new ItemMeshData();
				EItemType key = Enum.Parse<EItemType>(item.ItemType);
				ProcessItemMeshes(item, assets.Meshes, val);
				ProcessItemMaterials(item, assets.Materials, val);
				EplRuntimeData.Assets.ItemLibrary.ItemMeshData[key] = val;
				ProcessItem(item, bundleInfo);
			}
		}

		private void ProcessItemMeshes(ItemInfo item, Dictionary<string, Mesh> meshes, ItemMeshData itemMeshData)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (item.UsesBaseGameMesh)
			{
				EItemType baseItemType = Enum.Parse<EItemType>(item.MeshToUse);
				EItemType itemType = Enum.Parse<EItemType>(item.ItemType);
				EplRuntimeData.Events.OnInventoryBaseAwake += delegate
				{
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_001a: Expected I4, but got Unknown
					//IL_0083: Unknown result type (might be due to invalid IL or missing references)
					//IL_0092: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
					//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
					//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
					//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
					//IL_00e8: 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)
					ItemMeshData val = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ItemMeshDataList[(int)baseItemType];
					itemMeshData.mesh = val.mesh;
					itemMeshData.meshSecondary = val.meshSecondary;
					ItemMeshData val2 = itemMeshData;
					if (val2.material == null)
					{
						val2.material = val.material;
					}
					val2 = itemMeshData;
					if (val2.materialSecondary == null)
					{
						val2.materialSecondary = val.materialSecondary;
					}
					if (EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(itemType, out ModItemData value3))
					{
						ItemData itemData = InventoryBase.GetItemData(baseItemType);
						value3.BaseItemData.colliderPosOffset = itemData.colliderPosOffset;
						value3.BaseItemData.colliderScale = itemData.colliderScale;
						value3.BaseItemData.posYOffsetInBox = itemData.posYOffsetInBox;
						value3.BaseItemData.scaleOffsetInBox = itemData.scaleOffsetInBox;
						value3.BaseItemData.itemDimension = itemData.itemDimension;
						value3.BaseItemData.isTallItem = itemData.isTallItem;
					}
				};
			}
			else
			{
				if (meshes.TryGetValue(item.Mesh, out Mesh value))
				{
					itemMeshData.mesh = value;
				}
				if (!string.IsNullOrWhiteSpace(item.MeshSecondary) && meshes.TryGetValue(item.MeshSecondary, out Mesh value2))
				{
					itemMeshData.meshSecondary = value2;
				}
			}
		}

		private void ProcessItemMaterials(ItemInfo item, Dictionary<string, Material> materials, ItemMeshData itemMeshData)
		{
			if (materials.TryGetValue(item.Material, out Material value))
			{
				CreateLightingAwareMaterial(value, delegate(Material m)
				{
					itemMeshData.material = m;
				});
			}
			if (materials.TryGetValue(item.MaterialSecondary, out Material value2))
			{
				CreateLightingAwareMaterial(value2, delegate(Material m)
				{
					itemMeshData.materialSecondary = m;
				});
			}
			ItemMeshData val = itemMeshData;
			if (val.materialList == null)
			{
				val.materialList = new List<Material>();
			}
			foreach (string material in item.MaterialList)
			{
				if (materials.TryGetValue(material, out Material value3))
				{
					CreateLightingAwareMaterial(value3, delegate(Material m)
					{
						itemMeshData.materialList.Add(m);
					});
				}
			}
			EplRuntimeData.Events.OnInventoryBaseAwake += delegate
			{
				ItemMeshData val2 = itemMeshData;
				if (val2.material == null)
				{
					val2.material = itemMeshData.materialList.FirstOrDefault();
				}
			};
		}

		private void CreateLightingAwareMaterial(Material source, Action<Material> assign)
		{
			EplRuntimeData.Events.OnInventoryBaseAwake += delegate
			{
				//IL_0050: Unknown result type (might be due to invalid IL or missing references)
				//IL_0056: Expected O, but got Unknown
				//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
				Material val = FindTemplateMaterial();
				if (!Object.op_Implicit((Object)(object)val))
				{
					ModLogger.Error("No plain-shader base game item material found to template '" + ((Object)source).name + "'; using the bundle material as-is.", "CreateLightingAwareMaterial", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Processors\\ItemProcessor.cs");
					assign(source);
				}
				else
				{
					Material val2 = new Material(val);
					val2.CopyPropertiesFromMaterial(val);
					val2.ForceOpaque();
					string[] texturePropertyNames = source.GetTexturePropertyNames();
					foreach (string text in texturePropertyNames)
					{
						if (val2.HasProperty(text))
						{
							val2.SetTexture(text, source.GetTexture(text));
						}
					}
					assign(val2);
					Color val3 = default(Color);
					((Color)(ref val3))..ctor(0.885f, 0.885f, 0.885f, 1f);
					val2.SetColor("_Color", val3);
					EplRuntimeData.Caches.LightingAwareMaterials.Add((val2, val3));
				}
			};
		}

		private Material? FindTemplateMaterial()
		{
			if (Object.op_Implicit((Object)(object)templateMaterial))
			{
				return templateMaterial;
			}
			List<ItemMeshData> itemMeshDataList = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_ItemMeshDataList;
			int num = Mathf.Min(itemMeshDataList.Count, 130);
			Material val = null;
			Material val2 = null;
			for (int i = 0; i < num; i++)
			{
				ItemMeshData obj = itemMeshDataList[i];
				Material material = obj.material;
				Material materialSecondary = obj.materialSecondary;
				List<Material> list = obj.materialList ?? new List<Material>();
				int num2 = 0;
				Material[] array = (Material[])(object)new Material[2 + list.Count];
				array[num2] = material;
				num2++;
				array[num2] = materialSecondary;
				num2++;
				foreach (Material item in list)
				{
					array[num2] = item;
					num2++;
				}
				foreach (Material item2 in (IEnumerable<Material>)new <>z__ReadOnlyArray<Material>(array))
				{
					if (!Object.op_Implicit((Object)(object)item2) || !item2.HasProperty("_MainTex") || !item2.HasProperty("_Color") || item2.HasProperty("_MainTexArray") || !item2.IsOpaque())
					{
						continue;
					}
					string name = ((Object)item2.shader).name;
					if (name.Contains("StandardOptimized"))
					{
						templateMaterial = item2;
						return item2;
					}
					if (name == "Standard")
					{
						if (val == null)
						{
							val = item2;
						}
					}
					else if (val2 == null)
					{
						val2 = item2;
					}
				}
			}
			templateMaterial = val ?? val2;
			return templateMaterial;
		}

		private void ProcessItem(ItemInfo item, BundleInfo bundleInfo)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: 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)
			//IL_04fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_051e: Unknown result type (might be due to invalid IL or missing references)
			//IL_057b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0580: Unknown result type (might be due to invalid IL or missing references)
			//IL_058c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0593: Unknown result type (might be due to invalid IL or missing references)
			//IL_059f: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_05d1: Expected O, but got Unknown
			//IL_0564: Unknown result type (might be due to invalid IL or missing references)
			//IL_06c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06df: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0700: Unknown result type (might be due to invalid IL or missing references)
			//IL_070c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0718: Unknown result type (might be due to invalid IL or missing references)
			//IL_0618: Unknown result type (might be due to invalid IL or missing references)
			//IL_061d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0629: Unknown result type (might be due to invalid IL or missing references)
			//IL_0630: Unknown result type (might be due to invalid IL or missing references)
			//IL_063c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0648: Unknown result type (might be due to invalid IL or missing references)
			//IL_064a: Unknown result type (might be due to invalid IL or missing references)
			//IL_064f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0654: Unknown result type (might be due to invalid IL or missing references)
			//IL_0660: Unknown result type (might be due to invalid IL or missing references)
			//IL_066e: Expected O, but got Unknown
			//IL_0737: Unknown result type (might be due to invalid IL or missing references)
			//IL_073c: Unknown result type (might be due to invalid IL or missing references)
			//IL_074b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0757: Unknown result type (might be due to invalid IL or missing references)
			//IL_0732: Unknown result type (might be due to invalid IL or missing references)
			//IL_076e: Unknown result type (might be due to invalid IL or missing references)
			//IL_077a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0786: Unknown result type (might be due to invalid IL or missing references)
			//IL_078d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0792: Unknown result type (might be due to invalid IL or missing references)
			//IL_0797: Unknown result type (might be due to invalid IL or missing references)
			//IL_079e: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_07a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_07af: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_07b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e4: Invalid comparison between Unknown and I4
			//IL_03ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_0461: Unknown result type (might be due to invalid IL or missing references)
			//IL_0463: Unknown result type (might be due to invalid IL or missing references)
			//IL_0479: Unknown result type (might be due to invalid IL or missing references)
			//IL_084b: Expected O, but got Unknown
			//IL_04a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_049a: Unknown result type (might be due to invalid IL or missing references)
			//IL_08bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_08d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_08f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_0874: Unknown result type (might be due to invalid IL or missing references)
			//IL_0879: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_024e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0250: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Invalid comparison between Unknown and I4
			//IL_0326: Unknown result type (might be due to invalid IL or missing references)
			//IL_0328: Unknown result type (might be due to invalid IL or missing references)
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			EItemType itemType = Enum.Parse<EItemType>(item.ItemType);
			if (item.IsCardBox)
			{
				EItemType value = Enum.Parse<EItemType>(item.SpawnsPackType);
				EplRuntimeData.Assets.LookupLibrary.SpawnPackLookup[itemType] = value;
			}
			if (item.IsBulkBox)
			{
				ECardExpansionType key = Enum.Parse<ECardExpansionType>(item.CardExpansion);
				EplRuntimeData.Assets.ItemLibrary.BulkBoxes.GetOrAdd(key, (ECardExpansionType _) => new List<(int, EItemType)>()).Add((item.MinValue, itemType));
			}
			if (item.IsCardPack)
			{
				ECardExpansionType val = Enum.Parse<ECardExpansionType>(item.CardExpansion);
				ECollectionPackType val2 = Enum.Parse<ECollectionPackType>(item.PackType);
				Dictionary<ERarity, float> dictionary = ((item.NormalWeights.Count > 0) ? ToRarityWeights(item.NormalWeights.Select<KeyValuePair<string, float>, (string, float)>((KeyValuePair<string, float> kvp) => (Key: kvp.Key, Value: kvp.Value))) : ToRarityWeights(item.GenerationWeights.Select((RarityWeightInfo gw) => (Rarity: gw.Rarity, NormalWeight: gw.NormalWeight))));
				Dictionary<ERarity, float> godGenerationWeights = ((item.GodWeights.Count > 0) ? ToRarityWeights(item.GodWeights.Select<KeyValuePair<string, float>, (string, float)>((KeyValuePair<string, float> kvp) => (Key: kvp.Key, Value: kvp.Value))) : ToRarityWeights(item.GenerationWeights.Select((RarityWeightInfo gw) => (Rarity: gw.Rarity, GodPackWeight: gw.GodPackWeight))));
				SortedDictionary<PackSlot, Dictionary<ERarity, float>> sortedDictionary = new SortedDictionary<PackSlot, Dictionary<ERarity, float>>();
				if (item.SlotWeights.Count > 0)
				{
					foreach (KeyValuePair<string, Dictionary<string, float>> slotWeight in item.SlotWeights)
					{
						if (!Enum.TryParse<PackSlot>(slotWeight.Key, out PackSlot result))
						{
							continue;
						}
						Dictionary<ERarity, float> dictionary2 = ToRarityWeights(slotWeight.Value.Select((KeyValuePair<string, float> kvp) => (Key: kvp.Key, Value: kvp.Value)));
						foreach (PackSlot value6 in Enum.GetValues(typeof(PackSlot)))
						{
							if ((int)value6 != 0 && (int)value6 != 127 && (result & value6) != 0)
							{
								sortedDictionary[value6] = new Dictionary<ERarity, float>(dictionary2);
							}
						}
					}
				}
				else
				{
					foreach (PackSlot value7 in Enum.GetValues(typeof(PackSlot)))
					{
						if ((int)value7 == 0 || (int)value7 == 127)
						{
							continue;
						}
						Dictionary<ERarity, float> dictionary3 = new Dictionary<ERarity, float>();
						foreach (RarityWeightInfo generationWeight in item.GenerationWeights)
						{
							if (!string.IsNullOrWhiteSpace(generationWeight.GuaranteedSlots) && Enum.TryParse<PackSlot>(generationWeight.GuaranteedSlots, out PackSlot result2) && (result2 & value7) != 0 && Enum.TryParse<ERarity>(generationWeight.Rarity, out ERarity result3))
							{
								dictionary3[result3] = generationWeight.NormalWeight;
							}
						}
						sortedDictionary[value7] = ((dictionary3.Count > 0) ? dictionary3 : new Dictionary<ERarity, float>(dictionary));
					}
				}
				CardGenerationData cardGenerationData = new CardGenerationData
				{
					Expansion = val,
					PackType = val2,
					CanHaveDuplicates = item.CanHaveDuplicates,
					CanHaveGodPack = item.CanHaveGodPacks,
					GodPackPercentage = item.GodPackPercentage,
					NormalGenerationWeights = dictionary,
					GodGenerationWeights = godGenerationWeights,
					PackSlotWeights = sortedDictionary
				};
				if (Enum.TryParse<PackGenerationStrategy>(item.PackGenerationStrategy, out var result4))
				{
					cardGenerationData.Strategy = result4;
					cardGenerationData.PackGenerator = PackGeneratorFactory.For(result4, cardGenerationData);
				}
				cardGenerationData.GodPackGenerator = PackGeneratorFactory.For(PackGenerationStrategy.GodPack, cardGenerationData);
				EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup[itemType] = cardGenerationData;
				EplRuntimeData.Assets.LookupLibrary.ExpansionLookup[val2] = val;
				if (!EplRuntimeData.Assets.LookupLibrary.ExpansionItemLookup.TryGetValue(val, out List<EItemType> value2))
				{
					value2 = new List<EItemType>();
					EplRuntimeData.Assets.LookupLibrary.ExpansionItemLookup[val] = value2;
				}
				value2.Add(itemType);
			}
			ItemFlags itemFlags = ((item.IsCardBox || item.IsCardPack) ? ItemFlags.TCG : ((ItemFlags)((item.AddItemAsBoardGame ? 1 : 0) | (item.AddItemAsAccessory ? 2 : 0) | (item.AddItemAsFigurine ? 4 : 0))));
			if (!EplRuntimeData.Assets.LookupLibrary.RestockDataLookup.TryGetValue(itemType, out List<RestockData> value3))
			{
				value3 = new List<RestockData>();
				EplRuntimeData.Assets.LookupLibrary.RestockDataLookup[itemType] = value3;
			}
			if (!string.IsNullOrWhiteSpace(item.PhoneAppId) && EplRuntimeData.Assets.ShopLibrary.CustomShops.TryGetValue(item.PhoneAppId, out CustomShopData value4))
			{
				EplRuntimeData.Assets.ShopLibrary.ItemShopLookup.TryAdd(itemType, value4);
			}
			if (item.HasSmallBox)
			{
				RestockData val5 = new RestockData
				{
					name = item.Name,
					isBigBox = false,
					licenseShopLevelRequired = item.SmallBoxLicenseLevelRequirement,
					licensePrice = item.SmallBoxLicensePrice,
					itemType = itemType,
					isHideItemUntilUnlocked = item.SmallBoxHideTillUnlocked,
					ignoreDoubleImage = item.SmallBoxIgnoreDoubleImage
				};
				value3.Add(val5);
				EplRuntimeData.Assets.ItemLibrary.RestockEntries.Add(new ModRestockData
				{
					ItemFlags = itemFlags,
					PhoneAppId = item.PhoneAppId,
					RestockData = val5
				});
			}
			if (item.HasBigBox)
			{
				RestockData val6 = new RestockData
				{
					name = item.Name,
					isBigBox = true,
					licenseShopLevelRequired = item.BigBoxLicenseLevelRequirement,
					licensePrice = item.BigBoxLicensePrice,
					itemType = itemType,
					isHideItemUntilUnlocked = item.BigBoxHideTillUnlocked,
					ignoreDoubleImage = item.BigBoxIgnoreDoubleImage
				};
				value3.Add(val6);
				EplRuntimeData.Assets.ItemLibrary.RestockEntries.Add(new ModRestockData
				{
					ItemFlags = itemFlags,
					PhoneAppId = item.PhoneAppId,
					RestockData = val6
				});
			}
			ModItemData value5 = new ModItemData
			{
				Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, item.SpriteName),
				BaseItemData = new ItemData
				{
					name = item.Name,
					category = Enum.Parse<EItemCategory>(item.ItemCategory),
					iconScale = 1f,
					baseCost = item.BaseCost,
					marketPriceMaxPercent = item.MaxMarketPricePercent,
					marketPriceMinPercent = item.MinMarketPricePercent,
					boxFollowItemPrice = (EItemType)((!item.IsCardBox || !item.AutoSetBoxPrice) ? (-1) : ((int)Enum.Parse<EItemType>(item.SpawnsPackType))),
					isNotBoosterPack = !item.IsCardPack,
					isTallItem = item.IsTallItem,
					isHideItemUntilUnlocked = (item.BigBoxHideTillUnlocked || item.SmallBoxHideTillUnlocked),
					posYOffsetInBox = item.InBoxOffsetY,
					scaleOffsetInBox = item.InBoxOffsetScale,
					itemDimension = item.ItemDeminsion.ToUnityVector(),
					colliderPosOffset = item.CollidorPosOffset.ToUnityVector(),
					colliderScale = item.ColliderScale.ToUnityVector(),
					affectedPriceChangeType = ((from x in item.PriceAffectedBy?.Select((string price) => StringExtensions.TryParseToEnum<EPriceChangeType>(price))
						where x.HasValue
						select x.Value).ToList() ?? new List<EPriceChangeType>())
				}
			};
			if (!string.IsNullOrWhiteSpace(item.FollowItemPrice) && !item.FollowItemPrice.Equals("None", StringComparison.OrdinalIgnoreCase))
			{
				EItemType baseItemType = Enum.Parse<EItemType>(item.FollowItemPrice);
				EplRuntimeData.Events.OnRestockManagerAwake += delegate
				{
					//IL_0010: Unknown result type (might be due to invalid IL or missing references)
					//IL_001b: Unknown result type (might be due to invalid IL or missing references)
					ModItemData modItemData = EplRuntimeData.Assets.ItemLibrary.ItemData[itemType];
					ItemData itemData = InventoryBase.GetItemData(baseItemType);
					modItemData.BaseItemData.baseCost = itemData.baseCost;
					modItemData.BaseItemData.marketPriceMaxPercent = itemData.marketPriceMaxPercent;
					modItemData.BaseItemData.marketPriceMinPercent = itemData.marketPriceMinPercent;
				};
			}
			if (item.IsSprayCan)
			{
				EplRuntimeData.Assets.ItemLibrary.SprayCanList.Add(itemType);
			}
			bundleInfo.itemTypes.Add(itemType);
			EplRuntimeData.Assets.ItemLibrary.ItemData[itemType] = value5;
			EplRuntimeData.Services.SaveDataManager.RegisterSaveData<EItemType, ItemSaveData>(bundleInfo.BundleId, itemType, new ItemSaveData());
		}

		private Dictionary<ERarity, float> ToRarityWeights(IEnumerable<(string Key, float Weight)> entries)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<ERarity, float> dictionary = new Dictionary<ERarity, float>();
			foreach (var (value, value2) in entries)
			{
				if (Enum.TryParse<ERarity>(value, out ERarity result))
				{
					dictionary[result] = value2;
				}
			}
			return dictionary;
		}
	}
	internal class PrefabProcessor
	{
		internal void Process(List<PrefabInfo> prefabs, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			foreach (PrefabInfo item in prefabs.Where((PrefabInfo p) => p.IsValid))
			{
				if (item.AddItemToFurnitureShop)
				{
					ProcessFurniture(item, bundleInfo, assets);
				}
				if (item.IsDecoObject || item.IsDecoCeilingTexture || item.IsDecoWallTexture || item.IsDecoFloorTexture)
				{
					ProcessDeco(item, bundleInfo, assets);
				}
			}
		}

		private void ProcessFurniture(PrefabInfo prefab, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: 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)
			//IL_00ac: 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)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Expected O, but got Unknown
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			GameObject orDefault = assets.GameObjects.GetOrDefault(prefab.PrefabName);
			if (orDefault == null)
			{
				bundleInfo.errors.Add("Prefab not found for " + prefab.Name + " in " + bundleInfo.Name);
				ModLogger.Error("Prefab not found for " + prefab.Name + " in " + bundleInfo.Name, "ProcessFurniture", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Processors\\PrefabProcessor.cs");
				return;
			}
			EObjectType val = Enum.Parse<EObjectType>(prefab.ObjectType);
			ModFurniturePurchaseData value = new ModFurniturePurchaseData
			{
				Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, prefab.SpriteName),
				BaseFurniturePurchaseData = new FurniturePurchaseData
				{
					name = prefab.Name,
					description = prefab.Description,
					levelRequirement = prefab.LevelRequirement,
					price = prefab.Price,
					objectType = val
				},
				BaseObjectData = new ObjectData
				{
					name = prefab.Name,
					objectType = val,
					spawnPrefab = orDefault.GetComponent<InteractableObject>(),
					decoBonus = prefab.DecoBonus
				}
			};
			ProcessVideoClips(orDefault, prefab.VideoClips, prefab.Name, bundleInfo.BundlePath);
			EplRuntimeData.Services.ScriptHookService.ScanPrefab(orDefault, bundleInfo);
			bundleInfo.furnitureTypes.Add(val);
			EplRuntimeData.Assets.FurnitureLibrary.FurnitureData[val] = value;
		}

		private void ProcessDeco(PrefabInfo prefab, BundleInfo bundleInfo, BundleAssetsPreloader.BundleAssets assets)
		{
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Expected O, but got Unknown
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Expected O, but got Unknown
			//IL_012d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_014e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0204: Unknown result type (might be due to invalid IL or missing references)
			//IL_0210: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023e: Expected O, but got Unknown
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_033a: Unknown result type (might be due to invalid IL or missing references)
			if (prefab.IsDecoObject)
			{
				GameObject orDefault = assets.GameObjects.GetOrDefault(prefab.PrefabName);
				if (orDefault == null)
				{
					bundleInfo.errors.Add("Prefab not found for " + prefab.Name + " in " + bundleInfo.Name);
					ModLogger.Error("Prefab not found for " + prefab.Name + " in " + bundleInfo.Name, "ProcessDeco", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Processors\\PrefabProcessor.cs");
					return;
				}
				ModDecoData value = new ModDecoData
				{
					Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, prefab.SpriteName),
					BaseDecoData = new DecoData
					{
						name = prefab.Name,
						decoType = Enum.Parse<EDecoType>(prefab.DecoType),
						spawnPrefab = orDefault.GetComponent<InteractableObject>()
					},
					BasePurchaseData = new DecoPurchaseData
					{
						name = prefab.Name,
						mainNameText = prefab.Name,
						levelRequirement = prefab.LevelRequirement,
						price = prefab.Price
					}
				};
				ProcessVideoClips(orDefault, prefab.VideoClips, prefab.Name, bundleInfo.BundlePath);
				EplRuntimeData.Services.ScriptHookService.ScanPrefab(orDefault, bundleInfo);
				EDecoObject val = Enum.Parse<EDecoObject>(prefab.DecoObject);
				bundleInfo.decoObjects.Add(val);
				EplRuntimeData.Assets.DecoLibrary.DecoObjectData[val] = value;
				EplRuntimeData.Services.SaveDataManager.RegisterSaveData<EDecoObject, DecoSaveData>(bundleInfo.BundleId, val, new DecoSaveData());
				return;
			}
			ModShopDecoData item = new ModShopDecoData
			{
				Icon = new StreamingAsset<Sprite>(bundleInfo.BundlePath, prefab.SpriteName),
				MainTexture = new StreamingAsset<Texture>(bundleInfo.BundlePath, prefab.Texture),
				RoughnessMap = (string.IsNullOrWhiteSpace(prefab.RoughnessMap) ? null : new StreamingAsset<Texture>(bundleInfo.BundlePath, prefab.RoughnessMap)),
				NormalMap = (string.IsNullOrWhiteSpace(prefab.NormalMap) ? null : new StreamingAsset<Texture>(bundleInfo.BundlePath, prefab.NormalMap)),
				ShopDecoData = new ShopDecoData
				{
					name = prefab.Name,
					mainNameText = prefab.Name,
					price = prefab.Price,
					color = prefab.Color.ToUnityColor(),
					smoothness = prefab.Smoothness
				}
			};
			if (prefab.IsDecoWallTexture)
			{
				bundleInfo.wallTextures.Add(prefab.Name);
				EplRuntimeData.Assets.DecoLibrary.DecoWallTextureData.Add(item);
				EplRuntimeData.Services.SaveDataManager.RegisterSaveData(bundleInfo.BundleId, ((object)(DecoFlags)2/*cast due to .constrained prefix*/).ToString(), prefab.Name, new DecoSaveData());
			}
			if (prefab.IsDecoFloorTexture)
			{
				bundleInfo.floorTextures.Add(prefab.Name);
				EplRuntimeData.Assets.DecoLibrary.DecoFloorTextureData.Add(item);
				EplRuntimeData.Services.SaveDataManager.RegisterSaveData(bundleInfo.BundleId, ((object)(DecoFlags)1/*cast due to .constrained prefix*/).ToString(), prefab.Name, new DecoSaveData());
			}
			if (prefab.IsDecoCeilingTexture)
			{
				bundleInfo.ceilingTextures.Add(prefab.Name);
				EplRuntimeData.Assets.DecoLibrary.DecoCeilingTextureData.Add(item);
				EplRuntimeData.Services.SaveDataManager.RegisterSaveData(bundleInfo.BundleId, ((object)(DecoFlags)3/*cast due to .constrained prefix*/).ToString(), prefab.Name, new DecoSaveData());
			}
		}

		private void ProcessVideoClips(GameObject gameObject, List<VideoClipInfo> videoClips, string name, string bundlePath)
		{
			foreach (VideoClipInfo videoClip in videoClips)
			{
				VideoPlayer val = ((IEnumerable<VideoPlayer>)gameObject.GetComponentsInChildren<VideoPlayer>(true)).FirstOrDefault((Func<VideoPlayer, bool>)((VideoPlayer v) => ((Object)v).name == videoClip.VideoPlayerName));
				if (val == null)
				{
					ModLogger.Warning("Video player " + videoClip.VideoPlayerName + " not found on prefab " + name, "ProcessVideoClips", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\LoadingPipeline\\Processors\\PrefabProcessor.cs");
					continue;
				}
				val.source = (VideoSource)1;
				val.url = "file:///" + Path.Combine(Path.GetDirectoryName(bundlePath), videoClip.Name).Replace("\\", "/");
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.InterceptorHandlers
{
	public abstract class BaseListHandler<T> : ListInterceptorHandler<T>
	{
		protected HashSet<string> AcceptedFieldNames { get; private set; } = new HashSet<string>();

		public override bool ShouldHandleCall(string fieldName)
		{
			return AcceptedFieldNames.Contains(fieldName);
		}
	}
	[InterceptorHandler]
	public class CardPackItemTypeListHandler : BaseListHandler<EItemType>
	{
		public CardPackItemTypeListHandler()
		{
			base.AcceptedFieldNames.Add("StockItemData_ScriptableObject.m_CardPackItemTypeList");
		}

		public override int Count(List<EItemType> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.Count;
		}

		public override EItemType GetItem(List<EItemType> list, int index, string fieldName)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			if (index >= list.Count)
			{
				int num = index - list.Count;
				List<EItemType> sortedPackTypes = EplRuntimeData.Assets.LookupLibrary.SortedPackTypes;
				if (num >= sortedPackTypes.Count)
				{
					return (EItemType)(-1);
				}
				return sortedPackTypes[num];
			}
			return list[index];
		}

		public override bool Contains(List<EItemType> list, EItemType value, string fieldName)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (!list.Contains(value))
			{
				return EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.ContainsKey(value);
			}
			return true;
		}
	}
	[InterceptorHandler]
	public class CardSpriteListHandler : BaseListHandler<Sprite>
	{
		public CardSpriteListHandler()
		{
			base.AcceptedFieldNames.Add("MonsterData_ScriptableObject.m_CardBackImageList");
			base.AcceptedFieldNames.Add("MonsterData_ScriptableObject.m_CardFoilMaskImageList");
		}

		public override Sprite GetItem(List<Sprite> list, int index, string fieldName)
		{
			if (index >= 8)
			{
				if (!(fieldName == "MonsterData_ScriptableObject.m_CardBackImageList"))
				{
					if (fieldName == "MonsterData_ScriptableObject.m_CardFoilMaskImageList")
					{
						return null;
					}
					return null;
				}
				return list[0];
			}
			return list[index];
		}
	}
	[InterceptorHandler]
	public class CardUiSettingsListHandler : BaseListHandler<CardUISetting>
	{
		public CardUiSettingsListHandler()
		{
			base.AcceptedFieldNames.Add("MonsterData_ScriptableObject.m_CardUISettingList");
		}

		public override CardUISetting GetItem(List<CardUISetting> list, int index, string fieldName)
		{
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			if (index >= 8)
			{
				return new CardUISetting
				{
					expansionType = CardExpansionTypeResolver.Resolve(index)
				};
			}
			return list[index];
		}
	}
	[InterceptorHandler]
	public class DecoCountListHandler : BaseListHandler<int>
	{
		public DecoCountListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_DecorationInventoryList");
		}

		public override int Count(List<int> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.DecoLibrary.DecoObjectData.Count;
		}

		public override int GetItem(List<int> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 184)
			{
				EDecoObject enumValue = DecoObjectResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EDecoObject, DecoSaveData>(enumValue, out DecoSaveData data))
				{
					return data.ItemCount;
				}
				return 0;
			}
			return list[index];
		}

		public override void SetItem(List<int> list, int index, int value, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 184)
			{
				EDecoObject val = DecoObjectResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EDecoObject, DecoSaveData>(val, out DecoSaveData data))
				{
					data.ItemCount = value;
				}
				else
				{
					ModLogger.Error($"Dropped save-data write to {fieldName} for '{val}' — no registered save data entry, so this value cannot persist. Check earlier log entries for the owning bundle's errors or warnings.", "SetItem", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\InterceptorHandlers\\DecoCountListHandler.cs");
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class DecoDataListHandler : BaseListHandler<DecoData>
	{
		public DecoDataListHandler()
		{
			base.AcceptedFieldNames.Add("ShelfData_ScriptableObject.m_DecoDataList");
		}

		public override int Count(List<DecoData> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.DecoLibrary.DecoObjectData.Count;
		}

		public override DecoData GetItem(List<DecoData> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (index >= 184)
			{
				EDecoObject key = DecoObjectResolver.Resolve(index);
				if (!EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(key, out ModDecoData value))
				{
					return new DecoData();
				}
				return value.BaseDecoData;
			}
			return list[index];
		}

		public override void SetItem(List<DecoData> list, int index, DecoData value, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 184)
			{
				EDecoObject key = DecoObjectResolver.Resolve(index);
				if (EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(key, out ModDecoData value2))
				{
					value2.BaseDecoData = value;
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class DecoPurchaseDataListHandler : BaseListHandler<DecoPurchaseData>
	{
		public DecoPurchaseDataListHandler()
		{
			base.AcceptedFieldNames.Add("ShelfData_ScriptableObject.m_DecoPurchaseDataList");
		}

		public override int Count(List<DecoPurchaseData> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.DecoLibrary.DecoObjectData.Count;
		}

		public override DecoPurchaseData GetItem(List<DecoPurchaseData> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (index >= 184)
			{
				EDecoObject key = DecoObjectResolver.Resolve(index);
				if (!EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(key, out ModDecoData value))
				{
					return new DecoPurchaseData();
				}
				return value.BasePurchaseData;
			}
			return list[index];
		}

		public override void SetItem(List<DecoPurchaseData> list, int index, DecoPurchaseData value, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 184)
			{
				EDecoObject key = DecoObjectResolver.Resolve(index);
				if (EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(key, out ModDecoData value2))
				{
					value2.BasePurchaseData = value;
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ECollectionSortTypeListHandler : BaseListHandler<int>
	{
		public ECollectionSortTypeListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_CollectionSortingMethodIndexList");
		}

		public override int GetItem(List<int> list, int index, string fieldName)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 8)
			{
				ECardExpansionType key = CardExpansionTypeResolver.Resolve(index);
				if (!EplRuntimeData.Assets.CardExpansionLibrary.CurrentExpansionToCurrentSort.TryGetValue(key, out var value))
				{
					value = 3;
					EplRuntimeData.Assets.CardExpansionLibrary.CurrentExpansionToCurrentSort[key] = value;
				}
				return value;
			}
			return list[index];
		}

		public override void SetItem(List<int> list, int index, int value, string fieldName)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 8)
			{
				ECardExpansionType key = CardExpansionTypeResolver.Resolve(index);
				EplRuntimeData.Assets.CardExpansionLibrary.CurrentExpansionToCurrentSort[key] = value;
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemCountListHandler : BaseListHandler<int>
	{
		public ItemCountListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_CurrentTotalItemCountList");
		}

		public override int GetItem(List<int> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 130)
			{
				EItemType enumValue = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(enumValue, out ItemSaveData data))
				{
					return data.CurrentItemCount;
				}
				return 0;
			}
			return list[index];
		}

		public override void SetItem(List<int> list, int index, int value, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 130)
			{
				EItemType val = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(val, out ItemSaveData data))
				{
					data.CurrentItemCount = value;
				}
				else
				{
					ModLogger.Error($"Dropped save-data write to {fieldName} for '{val}' — no registered save data entry, so this value cannot persist. Check earlier log entries for the owning bundle's errors or warnings.", "SetItem", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\InterceptorHandlers\\ItemCountListHandler.cs");
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemDataListHandler : BaseListHandler<ItemData>
	{
		public ItemDataListHandler()
		{
			base.AcceptedFieldNames.Add("StockItemData_ScriptableObject.m_ItemDataList");
		}

		public override int Count(List<ItemData> list, string fieldName)
		{
			return 130 + EplRuntimeData.Assets.ItemLibrary.ItemData.Count;
		}

		public override ItemData GetItem(List<ItemData> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			if (index >= 130)
			{
				EItemType key = ItemTypeResolver.Resolve(index);
				if (!EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(key, out ModItemData value))
				{
					return new ItemData
					{
						affectedPriceChangeType = new List<EPriceChangeType>()
					};
				}
				return value.BaseItemData;
			}
			return list[index];
		}
	}
	[InterceptorHandler]
	public class ItemMeshDataHandler : BaseListHandler<ItemMeshData>
	{
		public ItemMeshDataHandler()
		{
			base.AcceptedFieldNames.Add("StockItemData_ScriptableObject.m_ItemMeshDataList");
		}

		public override int Count(List<ItemMeshData> list, string fieldName)
		{
			return 130 + EplRuntimeData.Assets.ItemLibrary.ItemMeshData.Count;
		}

		public override ItemMeshData GetItem(List<ItemMeshData> list, int index, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			if (index >= 130)
			{
				EItemType key = ItemTypeResolver.Resolve(index);
				if (!EplRuntimeData.Assets.ItemLibrary.ItemMeshData.TryGetValue(key, out ItemMeshData value))
				{
					return new ItemMeshData();
				}
				return value;
			}
			return list[index];
		}

		public override void SetItem(List<ItemMeshData> list, int index, ItemMeshData value, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 130)
			{
				EItemType key = ItemTypeResolver.Resolve(index);
				EplRuntimeData.Assets.ItemLibrary.ItemMeshData[key] = value;
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemPriceHistoryListHandler : BaseListHandler<FloatList>
	{
		public ItemPriceHistoryListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_ItemPricePercentPastChangeList");
		}

		public override int Count(List<FloatList> list, string fieldName)
		{
			return 130 + EplRuntimeData.Assets.ItemLibrary.ItemData.Count;
		}

		public override FloatList GetItem(List<FloatList> list, int index, string fieldName)
		{
			//IL_000c: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			//IL_0031: 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_0038: Expected O, but got Unknown
			//IL_003d: Expected O, but got Unknown
			if (index >= 130)
			{
				EItemType enumValue = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(enumValue, out ItemSaveData data))
				{
					ItemSaveData itemSaveData = data;
					FloatList val2;
					if (itemSaveData.ItemPriceChangeHistory == null)
					{
						FloatList val = new FloatList();
						val2 = val;
						itemSaveData.ItemPriceChangeHistory = val;
					}
					val2 = data.ItemPriceChangeHistory;
					if (val2.floatDataList == null)
					{
						val2.floatDataList = new List<float>();
					}
					if (data.ItemPriceChangeHistory.floatDataList.Count == 0)
					{
						data.ItemPriceChangeHistory.floatDataList.Add(data.ItemPriceChangePercent);
					}
					return data.ItemPriceChangeHistory;
				}
				return new FloatList
				{
					floatDataList = new List<float>(1) { 0f }
				};
			}
			return list[index];
		}

		public override void SetItem(List<FloatList> list, int index, FloatList value, string fieldName)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 130)
			{
				EItemType val = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(val, out ItemSaveData data))
				{
					data.ItemPriceChangeHistory = value;
				}
				else
				{
					ModLogger.Error($"Dropped save-data write to {fieldName} for '{val}' — no registered save data entry, so this value cannot persist. Check earlier log entries for the owning bundle's errors or warnings.", "SetItem", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\InterceptorHandlers\\ItemPriceHistoryListHandler.cs");
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemPriceListHandler : BaseListHandler<float>
	{
		public ItemPriceListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_GeneratedMarketPriceList");
			base.AcceptedFieldNames.Add("CPlayerData.m_GeneratedCostPriceList");
			base.AcceptedFieldNames.Add("CPlayerData.m_ItemPricePercentChangeList");
			base.AcceptedFieldNames.Add("CPlayerData.m_AverageItemCostList");
			base.AcceptedFieldNames.Add("CPlayerData.m_SetItemPriceList");
		}

		public override int Count(List<float> list, string fieldName)
		{
			return 130 + EplRuntimeData.Assets.ItemLibrary.ItemData.Count;
		}

		public override float GetItem(List<float> list, int index, string fieldName)
		{
			//IL_000c: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 130)
			{
				EItemType enumValue = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(enumValue, out ItemSaveData data))
				{
					if (fieldName.EndsWith("m_GeneratedMarketPriceList"))
					{
						return data.GeneratedMarketPrice;
					}
					if (fieldName.EndsWith("m_GeneratedCostPriceList"))
					{
						return data.GeneratedCostPrice;
					}
					if (fieldName.EndsWith("m_ItemPricePercentChangeList"))
					{
						return data.ItemPriceChangePercent;
					}
					if (fieldName.EndsWith("m_AverageItemCostList"))
					{
						return data.AverageItemCost;
					}
					if (fieldName.EndsWith("m_SetItemPriceList"))
					{
						return data.ItemPrice;
					}
					return 0f;
				}
				return 0f;
			}
			return list[index];
		}

		public override void SetItem(List<float> list, int index, float value, string fieldName)
		{
			//IL_000c: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			if (index >= 130)
			{
				EItemType val = ItemTypeResolver.Resolve(index);
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(val, out ItemSaveData data))
				{
					if (fieldName.EndsWith("m_AverageItemCostList"))
					{
						data.AverageItemCost = value;
					}
					if (fieldName.EndsWith("m_SetItemPriceList"))
					{
						data.ItemPrice = value;
					}
					if (fieldName.EndsWith("m_GeneratedCostPriceList"))
					{
						data.GeneratedCostPrice = value;
					}
					if (fieldName.EndsWith("m_GeneratedMarketPriceList"))
					{
						data.GeneratedMarketPrice = value;
					}
					if (fieldName.EndsWith("m_ItemPricePercentChangeList"))
					{
						data.ItemPriceChangePercent = value;
					}
				}
				else
				{
					ModLogger.Error($"Dropped save-data write to {fieldName} for '{val}' — no registered save data entry, so this value cannot persist. Check earlier log entries for the owning bundle's errors or warnings.", "SetItem", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\InterceptorHandlers\\ItemPriceListHandler.cs");
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class ItemUnlockedListHandler : BaseListHandler<bool>
	{
		public ItemUnlockedListHandler()
		{
			base.AcceptedFieldNames.Add("CPlayerData.m_IsItemLicenseUnlocked");
		}

		public override int Count(List<bool> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count;
		}

		public override bool GetItem(List<bool> list, int index, string fieldName)
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			int count = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList.Count;
			if (index >= count)
			{
				int num = index - count;
				if (num >= EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count)
				{
					return false;
				}
				ModRestockData modRestockData = EplRuntimeData.Assets.ItemLibrary.RestockEntries[num];
				EItemType itemType = modRestockData.RestockData.itemType;
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(itemType, out ItemSaveData data))
				{
					if (!modRestockData.RestockData.isBigBox)
					{
						return data.IsSmallBoxUnlocked;
					}
					return data.IsBigBoxUnlocked;
				}
				return false;
			}
			return list[index];
		}

		public override void SetItem(List<bool> list, int index, bool value, string fieldName)
		{
			//IL_0054: 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_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			int count = CSingleton<InventoryBase>.Instance.m_StockItemData_SO.m_RestockDataList.Count;
			if (index >= count)
			{
				int num = index - count;
				if (num >= EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count)
				{
					return;
				}
				ModRestockData modRestockData = EplRuntimeData.Assets.ItemLibrary.RestockEntries[num];
				EItemType itemType = modRestockData.RestockData.itemType;
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(itemType, out ItemSaveData data))
				{
					if (modRestockData.RestockData.isBigBox)
					{
						data.IsBigBoxUnlocked = value;
					}
					else
					{
						data.IsSmallBoxUnlocked = value;
					}
				}
				else
				{
					ModLogger.Error($"Dropped save-data write to {fieldName} for '{itemType}' — no registered save data entry, so this value cannot persist. Check earlier log entries for the owning bundle's errors or warnings.", "SetItem", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\InterceptorHandlers\\ItemUnlockedListHandler.cs");
				}
			}
			else
			{
				list[index] = value;
			}
		}
	}
	[InterceptorHandler]
	public class RestockDataListInterceptor : BaseListHandler<RestockData>
	{
		public RestockDataListInterceptor()
		{
			base.AcceptedFieldNames.Add("StockItemData_ScriptableObject.m_RestockDataList");
		}

		public override int Count(List<RestockData> list, string fieldName)
		{
			return list.Count + EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count;
		}

		public override RestockData GetItem(List<RestockData> list, int index, string fieldName)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			if (index >= list.Count)
			{
				index -= list.Count;
				if (index >= EplRuntimeData.Assets.ItemLibrary.RestockEntries.Count)
				{
					return new RestockData();
				}
				return EplRuntimeData.Assets.ItemLibrary.RestockEntries[index].RestockData;
			}
			return list[index];
		}
	}
}
namespace EnhancedPrefabLoader.Core.ExternalBridges
{
	internal class PhoneOverhaulBridge
	{
		private static PhoneOverhaulBridge instance;

		private const string phoneOverhaulGUID = "munch.PhoneOverhaul";

		private readonly MethodInfo? registerMethod;

		private readonly Type? appSpecType;

		private readonly object? registryInstanceObject;

		public static PhoneOverhaulBridge Instance => instance ?? (instance = new PhoneOverhaulBridge());

		public bool IsLoaded { get; private set; }

		private PhoneOverhaulBridge()
		{
			if (!Chainloader.PluginInfos.TryGetValue("munch.PhoneOverhaul", out var value))
			{
				ModLogger.Error("Phone Overhaul not found. Custom shops will not be created and custom items will go to the base game shop", ".ctor", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			Assembly assembly = ((object)value.Instance).GetType().Assembly;
			appSpecType = assembly.GetType("PhoneOverhaul.API.AppSpec");
			if ((object)appSpecType == null)
			{
				ModLogger.Error("Unable to find required class 'AppSpec'", ".ctor", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			Type type = assembly.GetType("PhoneOverhaul.API.PhoneOverhaulAPI");
			if ((object)type == null)
			{
				ModLogger.Error("Unable to find required class 'PhoneOverhaulAPI'.", ".ctor", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			PropertyInfo propertyInfo = AccessTools.Property(type, "Registry");
			if ((object)propertyInfo == null)
			{
				ModLogger.Error("Unable to find required property 'Registry'", ".ctor", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			registryInstanceObject = propertyInfo.GetValue(null);
			if (registryInstanceObject == null)
			{
				ModLogger.Error("PhoneOverhaul Registry instance is null.", ".ctor", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			registerMethod = AccessTools.Method(registryInstanceObject.GetType(), "Register", (Type[])null, (Type[])null);
			if ((object)registerMethod == null)
			{
				ModLogger.Error("Unable to find required method 'Register'", ".ctor", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
			}
			else
			{
				IsLoaded = true;
			}
		}

		public void RegisterApp(string appId, string displayName, string icon, string innerBackground, string outerBackground, Action onClick)
		{
			if (!IsLoaded)
			{
				ModLogger.Error("Required dependency mod Phone Overhaul is not install or there was an error in loading it.", "RegisterApp", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
				return;
			}
			try
			{
				object obj = Activator.CreateInstance(appSpecType);
				AccessTools.Field(appSpecType, "AppId").SetValue(obj, appId);
				AccessTools.Field(appSpecType, "DisplayName").SetValue(obj, displayName);
				AccessTools.Field(appSpecType, "Icon").SetValue(obj, icon);
				AccessTools.Field(appSpecType, "InnerBackground").SetValue(obj, innerBackground);
				AccessTools.Field(appSpecType, "OuterBackground").SetValue(obj, outerBackground);
				AccessTools.Field(appSpecType, "OnClick").SetValue(obj, onClick);
				registerMethod?.Invoke(registryInstanceObject, new object[1] { obj });
			}
			catch (Exception arg)
			{
				ModLogger.Error($"Failed to create new phone app {appId}: {arg}", "RegisterApp", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\ExternalBridges\\PhoneOverhaulBridge.cs");
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Extensions
{
	internal static class CardDataExtensions
	{
		public static bool IsEqual(this CardData cardData, CardData other)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: 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 (cardData.isFoil == other.isFoil && cardData.expansionType == other.expansionType && cardData.monsterType == other.monsterType && cardData.borderType == other.borderType && cardData.isDestiny == other.isDestiny)
			{
				return cardData.cardGrade == other.cardGrade;
			}
			return false;
		}
	}
	internal static class DictionaryExtensions
	{
		public static T GetWeightedRandom<T>(this Dictionary<T, float> weights)
		{
			if (weights.Count == 0)
			{
				throw new ArgumentException("Cannot select from an empty weight table", "weights");
			}
			float num = 0f;
			foreach (KeyValuePair<T, float> weight in weights)
			{
				num += weight.Value;
			}
			float num2 = Random.value * num;
			T result = default(T);
			foreach (KeyValuePair<T, float> weight2 in weights)
			{
				num2 -= weight2.Value;
				if (num2 <= 0f)
				{
					return weight2.Key;
				}
				result = weight2.Key;
			}
			return result;
		}
	}
	internal static class ImageExtensions
	{
		internal static void SetSprite(this Image image, FurniturePurchaseData data)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.FurnitureLibrary.FurnitureData.TryGetValue(data.objectType, out ModFurniturePurchaseData value))
			{
				StreamingAssetExtensions.SetSpriteAsync(image, value.Icon);
			}
			else
			{
				image.sprite = data.icon;
			}
		}

		internal static void SetSprite(this Image image, DecoPurchaseData data, EDecoObject decoObject)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.DecoLibrary.DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				StreamingAssetExtensions.SetSpriteAsync(image, value.Icon);
			}
			else
			{
				image.sprite = data.icon;
			}
		}

		internal static void SetSprite(this Image image, ItemData data, EItemType itemType)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (EplRuntimeData.Assets.ItemLibrary.ItemData.TryGetValue(itemType, out ModItemData value))
			{
				StreamingAssetExtensions.SetSpriteAsync(image, value.Icon);
			}
			else
			{
				image.sprite = data.icon;
			}
		}
	}
	internal static class ListExtensions
	{
		public static void AddIfMissing<T>(this List<T> list, T item)
		{
			if (!list.Contains(item))
			{
				list.Add(item);
			}
		}
	}
	internal static class MaterialExtensions
	{
		private static readonly string[] transparencyKeywords = new string[3] { "_ALPHABLEND_ON", "_ALPHAPREMULTIPLY_ON", "_ALPHATEST_ON" };

		private static readonly int modePropertyId = Shader.PropertyToID("_Mode");

		private static readonly int srcBlendPropertyId = Shader.PropertyToID("_SrcBlend");

		private static readonly int dstBlendPropertyId = Shader.PropertyToID("_DstBlend");

		private static readonly int zWritePropertyId = Shader.PropertyToID("_ZWrite");

		internal static bool IsOpaque(this Material material)
		{
			if (material.renderQueue > 2450)
			{
				return false;
			}
			if (material.HasProperty(modePropertyId) && material.GetFloat(modePropertyId) != 0f)
			{
				return false;
			}
			return !((IEnumerable<string>)transparencyKeywords).Any((Func<string, bool>)material.IsKeywordEnabled);
		}

		internal static void ForceOpaque(this Material material)
		{
			string[] array = transparencyKeywords;
			foreach (string text in array)
			{
				material.DisableKeyword(text);
			}
			if (material.HasProperty(modePropertyId))
			{
				material.SetFloat(modePropertyId, 0f);
			}
			if (material.HasProperty(srcBlendPropertyId))
			{
				material.SetFloat(srcBlendPropertyId, 1f);
			}
			if (material.HasProperty(dstBlendPropertyId))
			{
				material.SetFloat(dstBlendPropertyId, 0f);
			}
			if (material.HasProperty(zWritePropertyId))
			{
				material.SetFloat(zWritePropertyId, 1f);
			}
			material.SetOverrideTag("RenderType", "Opaque");
			material.renderQueue = -1;
		}
	}
	internal static class ModelExtensions
	{
		public static Color ToUnityColor(this ColorData colorData)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			return new Color(colorData.R, colorData.G, colorData.B, colorData.A);
		}

		public static Vector3 ToUnityVector(this Vector3Data vectorData)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			return new Vector3(vectorData.X, vectorData.Y, vectorData.Z);
		}
	}
	internal static class NotEnoughResourceTextPopupExtensions
	{
		internal static void ShowRawText(this NotEnoughResourceTextPopup popup, string text)
		{
			for (int i = 0; i < popup.m_ShowTextGameObjectList.Count; i++)
			{
				if (!popup.m_ShowTextGameObjectList[i].activeSelf)
				{
					((TMP_Text)popup.m_ShowTextList[i]).text = text;
					popup.m_ShowTextGameObjectList[i].SetActive(true);
					break;
				}
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Events
{
	internal class BundleEvents : IBundleEvents
	{
		public event Action<string>? OnBundleUninstalled;

		internal void FireBundleUninstalled(string bundleId)
		{
			this.OnBundleUninstalled?.Invoke(bundleId);
		}
	}
	internal class EplEvents : IEplEvents
	{
		internal readonly ShopEvents ShopEvents = new ShopEvents();

		internal readonly ItemEvents ItemEvents = new ItemEvents();

		internal readonly BundleEvents BundleEvents = new BundleEvents();

		public IShopEvents Shops => (IShopEvents)(object)ShopEvents;

		public IItemEvents Items => (IItemEvents)(object)ItemEvents;

		public IBundleEvents Bundles => (IBundleEvents)(object)BundleEvents;

		private event Action? onInventoryBaseAwake;

		private event Action? onRestockManagerAwake;

		private event Action? onBundleLoadingComplete;

		internal event Action? OnInventoryBaseAwake
		{
			add
			{
				onInventoryBaseAwake += value;
			}
			remove
			{
				onInventoryBaseAwake -= value;
			}
		}

		internal event Action? OnRestockManagerAwake
		{
			add
			{
				onRestockManagerAwake += value;
			}
			remove
			{
				onRestockManagerAwake -= value;
			}
		}

		public event Action OnBundleLoadingComplete
		{
			add
			{
				if (EplRuntimeData.IsBundleLoadingComplete)
				{
					value?.Invoke();
				}
				else
				{
					onBundleLoadingComplete += value;
				}
			}
			remove
			{
				onBundleLoadingComplete -= value;
			}
		}

		internal void FireOnInventoryBaseAwake()
		{
			this.onInventoryBaseAwake?.Invoke();
			this.onInventoryBaseAwake = null;
		}

		internal void FireOnRestockManagerAwake()
		{
			this.onRestockManagerAwake?.Invoke();
			this.onRestockManagerAwake = null;
		}

		internal void FireOnBundleLoadingComplete()
		{
			EplRuntimeData.IsBundleLoadingComplete = true;
			this.onBundleLoadingComplete?.Invoke();
			this.onBundleLoadingComplete = null;
		}
	}
	internal class ItemEvents : IItemEvents
	{
		public event Action<PackGenerationEventArgs>? OnBeforePackGenerated;

		public event Action<PackGeneratedEventArgs>? OnAfterPackGenerated;

		internal void FireBeforePackGenerated(PackGenerationEventArgs args)
		{
			this.OnBeforePackGenerated?.Invoke(args);
		}

		internal void FireAfterPackGenerated(PackGeneratedEventArgs args)
		{
			this.OnAfterPackGenerated?.Invoke(args);
		}
	}
	internal class ShopEvents : IShopEvents
	{
		public event Action? OnShopsReady;

		internal void FireShopsReady()
		{
			this.OnShopsReady?.Invoke();
		}
	}
}
namespace EnhancedPrefabLoader.Core.Components
{
	public class FlowLayoutGroup : LayoutGroup
	{
		public float SpacingX { get; set; } = 30f;

		public float SpacingY { get; set; } = -45f;

		public float ChildWidth { get; set; } = 325f;

		public float ChildHeight { get; set; } = 184.5f;

		public bool UseChildHeights { get; set; }

		public bool StretchChildWidth { get; set; }

		public bool CenterContent { get; set; } = true;

		public List<Transform> Children { get; private set; } = new List<Transform>();

		public int ItemsPerRow
		{
			get
			{
				//IL_0006: Unknown result type (might be due to invalid IL or missing references)
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				Rect rect = ((LayoutGroup)this).rectTransform.rect;
				float num = ((Rect)(ref rect)).width - (float)((LayoutGroup)this).padding.left - (float)((LayoutGroup)this).padding.right;
				return Mathf.Max(1, Mathf.FloorToInt((num + SpacingX) / (ChildWidth + SpacingX)));
			}
		}

		public static GameObject Create(Transform parent, bool isScrollable)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Expected O, but got Unknown
			GameObject val = new GameObject("FlowLayoutGroup", new Type[5]
			{
				typeof(RectTransform),
				typeof(ScrollRect),
				typeof(ScrollRectAutoScroller),
				typeof(Image),
				typeof(RectMask2D)
			});
			RectTransform component = val.GetComponent<RectTransform>();
			((Transform)component).SetParent(parent, false);
			Image component2 = ((Component)component).GetComponent<Image>();
			((Graphic)component2).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)component2).raycastTarget = true;
			GameObject val2 = new GameObject("FlowContent", new Type[2]
			{
				typeof(RectTransform),
				typeof(FlowLayoutGroup)
			});
			RectTransform component3 = val2.GetComponent<RectTransform>();
			((Transform)component3).SetParent((Transform)(object)component, false);
			component3.anchorMin = new Vector2(0f, 1f);
			component3.anchorMax = new Vector2(1f, 1f);
			component3.pivot = new Vector2(0.5f, 1f);
			component3.anchoredPosition = Vector2.zero;
			component3.sizeDelta = new Vector2(0f, 0f);
			((LayoutGroup)val2.GetComponent<FlowLayoutGroup>()).padding = new RectOffset(10, 10, 0, 0);
			ScrollRect component4 = val.GetComponent<ScrollRect>();
			component4.content = component3;
			component4.viewport = component;
			component4.horizontal = false;
			component4.vertical = isScrollable;
			component4.movementType = (MovementType)2;
			component4.scrollSensitivity = 20f;
			component4.inertia = true;
			component4.decelerationRate = 0.135f;
			return val;
		}

		public override void CalculateLayoutInputHorizontal()
		{
			((LayoutGroup)this).CalculateLayoutInputHorizontal();
			ArrangeChildren();
		}

		public override void CalculateLayoutInputVertical()
		{
			ArrangeChildren();
		}

		public Transform AddFromTemplate(Transform template)
		{
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			Transform val = Object.Instantiate<Transform>(template, ((Component)this).transform);
			((Component)val).gameObject.SetActive(true);
			((Object)val).name = ((Object)template).name + "_CLONE";
			val.localPosition = Vector3.zero;
			val.localScale = Vector3.one;
			RectTransform component = ((Component)val).GetComponent<RectTransform>();
			if (component != null)
			{
				component.sizeDelta = new Vector2(ChildWidth, ChildHeight);
				component.pivot = new Vector2(0f, 1f);
				component.anchoredPosition = new Vector2(0f, 1f);
			}
			Children.Add(((Component)val).transform);
			return ((Component)val).transform;
		}

		public void AdoptExisting(Transform child)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			child.SetParent(((Component)this).transform, false);
			RectTransform component = ((Component)child).GetComponent<RectTransform>();
			if (component != null)
			{
				component.pivot = new Vector2(0f, 1f);
				component.anchoredPosition = new Vector2(0f, 1f);
			}
			Children.Add(child);
		}

		public void ClearChildren()
		{
			Children.Clear();
			for (int num = ((Component)this).transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)((Component)this).transform.GetChild(num)).gameObject);
			}
		}

		public override void SetLayoutHorizontal()
		{
		}

		public override void SetLayoutVertical()
		{
		}

		private void ArrangeChildren()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			Rect rect = ((LayoutGroup)this).rectTransform.rect;
			float num = ((Rect)(ref rect)).width - (float)((LayoutGroup)this).padding.left - (float)((LayoutGroup)this).padding.right;
			float num2 = ((StretchChildWidth && num > 0f) ? num : ChildWidth);
			float num3 = ((LayoutGroup)this).padding.top;
			List<List<RectTransform>> list = new List<List<RectTransform>>();
			List<RectTransform> list2 = new List<RectTransform>();
			float num4 = 0f;
			foreach (RectTransform rectChild in ((LayoutGroup)this).rectChildren)
			{
				if (((Component)rectChild).gameObject.activeSelf)
				{
					if (num4 + num2 > num && list2.Count > 0)
					{
						list.Add(list2);
						list2 = new List<RectTransform>();
						num4 = 0f;
					}
					list2.Add(rectChild);
					num4 += num2 + SpacingX;
				}
			}
			if (list2.Count > 0)
			{
				list.Add(list2);
			}
			foreach (List<RectTransform> item in list)
			{
				float num5 = (float)item.Count * num2 + (float)(item.Count - 1) * SpacingX;
				float num6 = ((LayoutGroup)this).padding.left;
				if (CenterContent)
				{
					num6 = (float)((LayoutGroup)this).padding.left + (num - num5) / 2f;
				}
				float num7 = num6;
				float num8 = ChildHeight;
				foreach (RectTransform item2 in item)
				{
					((LayoutGroup)this).SetChildAlongAxis(item2, 0, num7, num2);
					float num9 = (UseChildHeights ? Mathf.Max(ChildHeight, LayoutUtility.GetPreferredSize(item2, 1)) : ChildHeight);
					num8 = Mathf.Max(num8, num9);
					((LayoutGroup)this).SetChildAlongAxis(item2, 1, num3, num9);
					num7 += num2 + SpacingX;
				}
				num3 += num8 + SpacingY;
			}
			float num10 = num3 - SpacingY + (float)((LayoutGroup)this).padding.bottom;
			Vector2 sizeDelta = ((LayoutGroup)this).rectTransform.sizeDelta;
			((LayoutGroup)this).rectTransform.sizeDelta = new Vector2(sizeDelta.x, num10);
			((LayoutGroup)this).SetLayoutInputForAxis(num10, num10, -1f, 1);
		}
	}
	public class ModdedCardUI : MonoBehaviour
	{
		private bool isInitialized;

		private CardUI cardUI;

		private GameObject? foilMask;

		private Transform foilGrpParent;

		private Vector2 centerFrameImageAnchorPos;

		private Vector2 centerFrameImageOffsetMin;

		private Vector2 centerFrameImageOffsetMax;

		private Vector2 centerFrameMaskOffsetMin;

		private Vector2 centerFrameMaskOffsetMax;

		public bool IsDirty { get; set; }

		public void Initialize(CardUI cardUI)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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_0075: Unknown result type (might be due to invalid IL or missing references)
			if (!isInitialized)
			{
				this.cardUI = cardUI;
				Transform transform = ((Component)this.cardUI.m_CenterFrameImage).transform;
				RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
				centerFrameImageAnchorPos = val.anchoredPosition;
				centerFrameImageOffsetMin = val.offsetMin;
				centerFrameImageOffsetMax = val.offsetMax;
				Transform transform2 = this.cardUI.m_CenterFrameMaskGrp.transform;
				RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
				centerFrameMaskOffsetMin = val2.offsetMin;
				centerFrameMaskOffsetMax = val2.offsetMax;
				foilGrpParent = cardUI.m_FoilGrp.transform.parent;
				CreateFoilMask();
				isInitialized = true;
			}
		}

		public void ApplyModdedCardSpecs(Sprite? cardMask, StreamingAsset<Sprite> cardFoilMask)
		{
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0138: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			if (IsDirty)
			{
				RestoreDefaults(cardUI.GetCardData());
				IsDirty = false;
			}
			GameObject? obj = foilMask;
			if (obj != null)
			{
				StreamingAssetExtensions.SetSpriteAsync(obj.GetComponent<Image>(), cardFoilMask);
			}
			Transform transform = cardUI.m_CenterFoilGlitter.transform;
			GameObject? obj2 = foilMask;
			transform.SetParent((obj2 != null) ? obj2.transform : null, false);
			Transform transform2 = cardUI.m_FoilGrp.transform;
			GameObject? obj3 = foilMask;
			transform2.SetParent((obj3 != null) ? obj3.transform : null, false);
			cardUI.m_EvoAndArtistNameGrp.SetActive(false);
			cardUI.m_StatGrp.SetActive(false);
			((Component)cardUI.m_RarityImage).gameObject.SetActive(false);
			((Component)cardUI.m_FirstEditionText).gameObject.SetActive(false);
			((Component)cardUI.m_NumberText).gameObject.SetActive(false);
			((Component)cardUI.m_MonsterNameText).gameObject.SetActive(false);
			Transform transform3 = ((Component)cardUI.m_CenterFrameImage).transform;
			Transform obj4 = ((transform3 is RectTransform) ? transform3 : null);
			if (obj4 != null)
			{
				((RectTransform)obj4).anchoredPosition = Vector2.zero;
			}
			if (obj4 != null)
			{
				((RectTransform)obj4).offsetMax = new Vector2(-22f, 206f);
			}
			if (obj4 != null)
			{
				((RectTransform)obj4).offsetMin = new Vector2(14f, -206f);
			}
			Transform transform4 = cardUI.m_CenterFrameMaskGrp.transform;
			Transform obj5 = ((transform4 is RectTransform) ? transform4 : null);
			if (obj5 != null)
			{
				((RectTransform)obj5).offsetMax = new Vector2(0.25f, 0.1f);
			}
			if (obj5 != null)
			{
				((RectTransform)obj5).offsetMin = new Vector2(0f, 0.95f);
			}
			Transform parent = ((Component)cardUI.m_CardBGImage).transform.parent;
			Transform obj6 = ((parent is RectTransform) ? parent : null);
			if (obj6 != null)
			{
				((RectTransform)obj6).offsetMax = new Vector2(-10f, -10f);
			}
			if (obj6 != null)
			{
				((RectTransform)obj6).offsetMin = new Vector2(10f, 10f);
			}
			cardUI.m_CenterFrameMaskImage.sprite = cardMask;
			cardUI.m_CenterFoilGlitter.SetActive(EplRuntimeData.Config.SparkleFoilEnabled);
		}

		public void RestoreDefaults(CardData cardData)
		{
			//IL_005f: 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_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Invalid comparison between Unknown and I4
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Invalid comparison between Unknown and I4
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Invalid comparison between Unknown and I4
			//IL_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Invalid comparison between Unknown and I4
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Invalid comparison between Unknown and I4
			cardUI.m_FoilGrp.transform.SetParent(foilGrpParent, false);
			cardUI.m_CenterFoilGlitter.transform.SetParent(cardUI.m_CenterFrameMaskGrp.transform, false);
			Transform transform = cardUI.m_CenterFrameMaskGrp.transform;
			Transform obj = ((transform is RectTransform) ? transform : null);
			if (obj != null)
			{
				((RectTransform)obj).offsetMin = centerFrameMaskOffsetMin;
			}
			if (obj != null)
			{
				((RectTransform)obj).offsetMax = centerFrameMaskOffsetMax;
			}
			Transform transform2 = ((Component)cardUI.m_CenterFrameImage).transform;
			Transform obj2 = ((transform2 is RectTransform) ? transform2 : null);
			if (obj2 != null)
			{
				((RectTransform)obj2).anchoredPosition = centerFrameImageAnchorPos;
			}
			if (obj2 != null)
			{
				((RectTransform)obj2).offsetMax = centerFrameImageOffsetMax;
			}
			if (obj2 != null)
			{
				((RectTransform)obj2).offsetMin = centerFrameImageOffsetMin;
			}
			Transform parent = ((Component)cardUI.m_CardBGImage).transform.parent;
			Transform obj3 = ((parent is RectTransform) ? parent : null);
			if (obj3 != null)
			{
				((RectTransform)obj3).offsetMax = Vector2.zero;
			}
			if (obj3 != null)
			{
				((RectTransform)obj3).offsetMin = Vector2.zero;
			}
			cardUI.m_EvoAndArtistNameGrp.SetActive((int)cardData.expansionType != 2);
			cardUI.m_StatGrp.SetActive(true);
			((Component)cardUI.m_RarityImage).gameObject.SetActive((int)cardData.expansionType != 2);
			((Component)cardUI.m_FirstEditionText).gameObject.SetActive((int)cardData.expansionType != 2);
			((Component)cardUI.m_NumberText).gameObject.SetActive((int)cardData.expansionType != 2);
			((Component)cardUI.m_MonsterNameText).gameObject.SetActive((int)cardData.borderType != 5);
		}

		private void CreateFoilMask()
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			foilMask = new GameObject("FoilMask", new Type[1] { typeof(RectTransform) });
			Transform transform = foilMask.transform;
			RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
			if (val != null)
			{
				((Transform)val).SetParent(cardUI.m_CenterFrameMaskGrp.transform, false);
			}
			if (val != null)
			{
				((Transform)val).SetAsLastSibling();
			}
			Transform transform2 = cardUI.m_CenterFrameMaskGrp.transform;
			RectTransform val2 = (RectTransform)(object)((transform2 is RectTransform) ? transform2 : null);
			if (val2 != null)
			{
				if (val != null)
				{
					val.anchorMin = Vector2.zero;
				}
				if (val != null)
				{
					val.anchorMax = Vector2.one;
				}
				if (val != null)
				{
					val.anchoredPosition = Vector2.zero;
				}
				if (val != null)
				{
					val.sizeDelta = Vector2.zero;
				}
				if (val != null)
				{
					((Transform)val).localRotation = Quaternion.identity;
				}
				if (val != null)
				{
					((Transform)val).localScale = Vector3.one;
				}
				if (val != null)
				{
					val.pivot = val2.pivot;
				}
			}
			Mask obj = ((val != null) ? ((Component)val).gameObject.AddComponent<Mask>() : null);
			if (obj != null)
			{
				obj.showMaskGraphic = false;
			}
			Image component = cardUI.m_CenterFrameMaskGrp.GetComponent<Image>();
			if (component != null)
			{
				Image obj2 = ((val != null) ? ((Component)val).gameObject.AddComponent<Image>() : null);
				if (obj2 != null)
				{
					obj2.sprite = component.sprite;
				}
				if (obj2 != null)
				{
					((Graphic)obj2).color = ((Graphic)component).color;
				}
				if (obj2 != null)
				{
					((Graphic)obj2).material = ((Graphic)component).material;
				}
				if (obj2 != null)
				{
					((Graphic)obj2).raycastTarget = false;
				}
				if (obj2 != null)
				{
					obj2.type = component.type;
				}
				if (obj2 != null)
				{
					obj2.fillMethod = component.fillMethod;
				}
				if (obj2 != null)
				{
					obj2.fillAmount = component.fillAmount;
				}
			}
			else
			{
				ModLogger.Error("CenterFrameMask has no mask component", "CreateFoilMask", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Components\\ModdedCardUI.cs");
				Object.Destroy((Object)(object)foilMask);
				foilMask = null;
			}
		}
	}
	public class NestedMenu : MonoBehaviour
	{
		public class MenuEntry
		{
			public string Label = string.Empty;

			public UnityAction OnClick;

			public List<MenuEntry>? SubMenu;
		}

		private readonly Stack<List<MenuEntry>> menuHistory = new Stack<List<MenuEntry>>();

		private FlowLayoutGroup flowLayoutGroup;

		private Transform buttonTemplate;

		public NestedMenu Setup(FlowLayoutGroup flowLayoutGroup, Transform buttonTemplate)
		{
			this.flowLayoutGroup = flowLayoutGroup;
			this.buttonTemplate = buttonTemplate;
			return this;
		}

		public void OnOpen(List<MenuEntry> menuEntries, ControllerScreenUIExtension controllerExtension, bool saveLastEntry = false)
		{
			menuHistory.Clear();
			RefreshMenuEntries(menuEntries, controllerExtension, saveLastEntry);
		}

		private void RefreshMenuEntries(List<MenuEntry> menuEntries, ControllerScreenUIExtension controllerExtension, bool saveLastEntry)
		{
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Expected O, but got Unknown
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Expected O, but got Unknown
			flowLayoutGroup.ClearChildren();
			foreach (MenuEntry menuEntry in menuEntries)
			{
				if (menuEntry.SubMenu != null)
				{
					AddNewMenuButton(menuEntry.Label ?? "", (UnityAction)delegate
					{
						menuHistory.Push(menuEntries);
						RefreshMenuEntries(menuEntry.SubMenu, controllerExtension, saveLastEntry);
					});
				}
				else
				{
					AddNewMenuButton(menuEntry.Label ?? "", menuEntry.OnClick);
				}
			}
			if (menuHistory.Count > 0)
			{
				AddNewMenuButton("Previous", (UnityAction)delegate
				{
					RefreshMenuEntries(menuHistory.Pop(), controllerExtension, saveLastEntry);
				});
			}
			UpdateControllerNav(controllerExtension, saveLastEntry);
			controllerExtension.OnOpenScreen();
		}

		private void AddNewMenuButton(string label, UnityAction onClick)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Expected O, but got Unknown
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			Transform obj = flowLayoutGroup.AddFromTemplate(buttonTemplate);
			Localize componentInChildren = ((Component)obj).GetComponentInChildren<Localize>(true);
			if (componentInChildren != null)
			{
				componentInChildren.SetTerm(label);
			}
			Button componentInChildren2 = ((Component)obj).GetComponentInChildren<Button>(true);
			if (componentInChildren2 != null)
			{
				componentInChildren2.onClick = new ButtonClickedEvent();
				if (onClick != null)
				{
					((UnityEvent)componentInChildren2.onClick).AddListener(onClick);
				}
				((Selectable)componentInChildren2).navigation = Navigation.defaultNavigation;
			}
		}

		private void UpdateControllerNav(ControllerScreenUIExtension controllerExtension, bool saveLastEntry)
		{
			int buttonsPerRow = flowLayoutGroup.ItemsPerRow;
			int num = (flowLayoutGroup.Children.Count + buttonsPerRow - 1) / buttonsPerRow;
			if (saveLastEntry)
			{
				num = Mathf.Max(num, 6);
			}
			List<ControllerButton> controllerButtons = flowLayoutGroup.Children.Select((Transform c) => ((Component)c).GetComponent<ControllerButton>()).ToList();
			List<ControllerBtnList> collection = Enumerable.Range(0, num).Select(delegate(int i)
			{
				//IL_0002: 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_0015: 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_00a1: 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_0074: Unknown result type (might be due to invalid IL or missing references)
				//IL_0075: Unknown result type (might be due to invalid IL or missing references)
				//IL_0083: Unknown result type (might be due to invalid IL or missing references)
				//IL_0089: Unknown result type (might be due to invalid IL or missing references)
				ControllerBtnList val = new ControllerBtnList
				{
					rowList = new List<ControllerButton>()
				};
				int count = i * buttonsPerRow;
				val.rowList.AddRange(controllerButtons.Skip(count).Take(buttonsPerRow));
				if (saveLastEntry && i < controllerExtension.m_ControllerBtnColumnList.Count)
				{
					ControllerBtnList val2 = controllerExtension.m_ControllerBtnColumnList[Mathf.Clamp(i, 0, 5)];
					if (val2.rowList.Count > 0)
					{
						List<ControllerButton> rowList = val.rowList;
						List<ControllerButton> rowList2 = val2.rowList;
						rowList.Add(rowList2[rowList2.Count - 1]);
					}
				}
				return val;
			}).ToList();
			controllerExtension.m_ControllerBtnColumnList.Clear();
			controllerExtension.m_ControllerBtnColumnList.AddRange(collection);
			controllerExtension.m_CtrlBtnXChangeMethodList.Clear();
			controllerExtension.m_CtrlBtnXChangeMethodList.Add((ECtrlBtnXChangeMethod)0);
			if (controllerButtons.Count > 0)
			{
				controllerExtension.m_StartControllerButton = controllerButtons[0];
			}
		}
	}
	internal class ScriptHookTracker : MonoBehaviour
	{
		private void OnEnable()
		{
			EplRuntimeData.Services.ScriptHookService.Register(this);
		}

		private void OnDisable()
		{
			EplRuntimeData.Services.ScriptHookService.Unregister(this);
		}
	}
	public class ScrollRectAutoScroller : MonoBehaviour
	{
		private ScrollRect scrollRect;

		private RectTransform viewportRect;

		private RectTransform contentRect;

		public float ControllerScrollSpeed { get; set; } = 800f;

		private void Start()
		{
			scrollRect = ((Component)this).GetComponent<ScrollRect>();
			viewportRect = scrollRect.viewport;
			contentRect = scrollRect.content;
		}

		private void Update()
		{
			if (HandleControllerInput())
			{
				return;
			}
			EventSystem current = EventSystem.current;
			if (!Object.op_Implicit((Object)(object)current))
			{
				return;
			}
			GameObject currentSelectedGameObject = current.currentSelectedGameObject;
			if (Object.op_Implicit((Object)(object)currentSelectedGameObject))
			{
				RectTransform component = currentSelectedGameObject.GetComponent<RectTransform>();
				if (Object.op_Implicit((Object)(object)component) && ((Transform)component).IsChildOf((Transform)(object)contentRect))
				{
					ScrollToRect(component);
				}
			}
		}

		private bool HandleControllerInput()
		{
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			if (CSingleton<CGameManager>.Instance.m_DisableController || !CSingleton<InputManager>.Instance.m_IsControllerActive)
			{
				return false;
			}
			Gamepad currentGamepad = CSingleton<InputManager>.Instance.m_CurrentGamepad;
			if (((currentGamepad != null) ? currentGamepad.rightStick : null) == null)
			{
				return false;
			}
			float num = ((InputControl<float>)(object)((Vector2Control)currentGamepad.rightStick).y).ReadValue();
			if (Mathf.Abs(num) > 0.1f)
			{
				scrollRect.velocity = Vector2.zero;
				float num2 = num * ControllerScrollSpeed * Time.deltaTime;
				Vector2 anchoredPosition = contentRect.anchoredPosition;
				anchoredPosition.y -= num2;
				Rect rect = contentRect.rect;
				float height = ((Rect)(ref rect)).height;
				rect = viewportRect.rect;
				float height2 = ((Rect)(ref rect)).height;
				float num3 = Mathf.Max(0f, height - height2);
				anchoredPosition.y = Mathf.Clamp(anchoredPosition.y, 0f, num3);
				contentRect.anchoredPosition = anchoredPosition;
				return true;
			}
			return false;
		}

		private void ScrollToRect(RectTransform target)
		{
			//IL_005c: 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_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[4];
			viewportRect.GetWorldCorners(array);
			Vector3[] array2 = (Vector3[])(object)new Vector3[4];
			target.GetWorldCorners(array2);
			if (array2[0].y < array[0].y)
			{
				float num = array[0].y - array2[0].y;
				RectTransform obj = contentRect;
				obj.anchoredPosition += new Vector2(0f, num);
			}
			else if (array2[1].y > array[1].y)
			{
				float num2 = array2[1].y - array[1].y;
				RectTransform obj2 = contentRect;
				obj2.anchoredPosition -= new Vector2(0f, num2);
			}
		}
	}
}
namespace EnhancedPrefabLoader.Core.Cards
{
	internal static class CardDataFactory
	{
		internal static CardData Create(int cardIndex, ECardExpansionType expansionType, bool isDestiny, int cardGrade)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: 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_006d: Expected O, but got Unknown
			EMonsterType monsterTypeFromCardSaveIndex = CPlayerData.GetMonsterTypeFromCardSaveIndex(cardIndex, expansionType);
			if (!EplRuntimeData.Assets.CardExpansionLibrary.CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				return new CardData
				{
					monsterType = monsterTypeFromCardSaveIndex,
					isFoil = (cardIndex % CPlayerData.GetCardAmountPerMonsterType(expansionType, true) >= CPlayerData.GetCardAmountPerMonsterType(expansionType, false)),
					borderType = (ECardBorderType)(cardIndex % CPlayerData.GetCardAmountPerMonsterType(expansionType, false)),
					isDestiny = isDestiny,
					expansionType = expansionType,
					cardGrade = cardGrade
				};
			}
			CardData val = value.Cards[monsterTypeFromCardSaveIndex].ToCardData();
			if (value.HasRandomFoils)
			{
				val.isFoil = (cardIndex & 1) == 1;
			}
			val.cardGrade = cardGrade;
			return val;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Cards.PriceGenerators
{
	internal enum CardPriceGenerationStrategy
	{
		Default = 1,
		RarityDriven
	}
	internal static class CardPriceGeneratorFactory
	{
		internal static ICardPriceGenerator For(CardPriceGenerationStrategy strategy, CardExpansionInfo expansion)
		{
			return (ICardPriceGenerator)(strategy switch
			{
				CardPriceGenerationStrategy.Default => new DefaultCardPriceGenerator(expansion.DefaultBorderMultiplierBase, expansion.DefaultFoilMultiplier), 
				CardPriceGenerationStrategy.RarityDriven => new RarityDrivenCardPriceGenerator(expansion.RarityDrivenFloor, expansion.RarityDrivenStepSize, expansion.RarityDrivenBorderMultiplierBase, expansion.RarityDrivenFoilMultiplier), 
				_ => new DefaultCardPriceGenerator(expansion.DefaultBorderMultiplierBase, expansion.DefaultFoilMultiplier), 
			});
		}
	}
	internal class DefaultCardPriceGenerator(float borderMultiplierBase, float foilMultiplier) : ICardPriceGenerator
	{
		public float GenerateCardMarketPrice(ECardExpansionType expansionType, EMonsterType monsterType, ECardBorderType borderType, ERarity rarity, List<ERarity> expansionRarities, bool isFoil)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			int count = expansionRarities.Count;
			float num = ((count > 1) ? ((float)expansionRarities.IndexOf(rarity) / (float)(count - 1)) : 0.5f);
			float num2 = Mathf.Pow(borderMultiplierBase, (float)borderType);
			float num3 = 1f + Mathf.Pow(num, 1.6f) * 4f;
			float num4 = 1f + num * 1f;
			float num5 = (isFoil ? foilMultiplier : 1f);
			float num6 = Random.Range(Mathf.Lerp(0.2f, 0.85f, (float)borderType / 5f), 1.15f);
			return num4 * num2 * num3 * num5 * num6;
		}
	}
	internal class RarityDrivenCardPriceGenerator(float floor, float stepSize, float borderMultiplierBase, float foilMultiplier) : ICardPriceGenerator
	{
		public float GenerateCardMarketPrice(ECardExpansionType expansionType, EMonsterType monsterType, ECardBorderType borderType, ERarity rarity, List<ERarity> expansionRarities, bool isFoil)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			int num = expansionRarities.IndexOf(rarity);
			float num2 = floor + (float)num * stepSize;
			float num3 = Mathf.Pow(borderMultiplierBase, (float)borderType);
			float num4 = (isFoil ? foilMultiplier : 1f);
			float num5 = Random.Range(Mathf.Lerp(0.05f, 0.7f, (float)num / 20f), 1.3f);
			return num2 * num3 * num4 * num5;
		}
	}
}
namespace EnhancedPrefabLoader.Core.Cards.ExpGenerators
{
	internal class CardExpGenerator : ICardExpGenerator
	{
		public float CalculateExp(CardData cardData)
		{
			float num = Mathf.Max(0.01f, CPlayerData.GetCardMarketPrice(cardData));
			return Mathf.Clamp((num < 10f) ? Mathf.RoundToInt(Mathf.Lerp(2f, 10f, num / 10f)) : Mathf.RoundToInt(10f + (Mathf.Log10(num) - 1f) * 47.1831f), 2, 150);
		}
	}
}
namespace EnhancedPrefabLoader.Core.Assets
{
	internal class CardExpansionLibrary : ICardExpansionLibrary
	{
		private List<(ECardExpansionType Expansion, List<Material> Materials)>? playCardMaterialSets;

		internal static IReadOnlyList<ECardExpansionType> BaseExpansionTypes { get; }

		internal Dictionary<ECardExpansionType, ModCardExpansionData> CardExpansionData { get; set; } = new Dictionary<ECardExpansionType, ModCardExpansionData>();

		internal Dictionary<ECardExpansionType, int> CurrentExpansionToCurrentSort { get; set; } = new Dictionary<ECardExpansionType, int>();

		internal List<(ECardExpansionType Expansion, List<Material> Materials)> PlayCardMaterialSets => playCardMaterialSets ?? (playCardMaterialSets = (from kvp in CardExpansionData
			where kvp.Value.PlayCardMaterials.Count > 0
			select (Key: kvp.Key, PlayCardMaterials: kvp.Value.PlayCardMaterials)).ToList());

		public StreamingAsset<Texture>? GetCardExpansionCardBack(ECardExpansionType cardExpansionType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				return null;
			}
			return value.CardBack;
		}

		public StreamingAsset<Sprite>? GetCardExpansionFoilMask(ECardExpansionType cardExpansionType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				return null;
			}
			return value.FoilMask;
		}

		public StreamingAsset<Sprite>? GetCardFoilMask(ECardExpansionType cardExpansionType, EMonsterType monsterType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value) && value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				return value2.FoilMask ?? value.FoilMask;
			}
			return null;
		}

		public StreamingAsset<Texture>? GetCardBack(ECardExpansionType cardExpansionType, EMonsterType monsterType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value) && value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				return value2.Cardback ?? value.CardBack;
			}
			return null;
		}

		public StreamingAsset<Sprite>? GetCardSprite(ECardExpansionType cardExpansionType, EMonsterType monsterType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			if (!CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				return null;
			}
			if (!value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				return null;
			}
			return value2.Icon;
		}

		public IReadOnlyDictionary<EMonsterType, StreamingAsset<Sprite>> GetCardSprites(ECardExpansionType cardExpansionType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!CardExpansionData.TryGetValue(cardExpansionType, out ModCardExpansionData value))
			{
				return new Dictionary<EMonsterType, StreamingAsset<Sprite>>();
			}
			return value.Cards.ToDictionary<KeyValuePair<EMonsterType, ModCardData>, EMonsterType, StreamingAsset<Sprite>>((KeyValuePair<EMonsterType, ModCardData> kvp) => kvp.Key, (KeyValuePair<EMonsterType, ModCardData> kvp) => kvp.Value.Icon);
		}

		public MonsterData GetMonsterData(CardData cardData)
		{
			//IL_0007: 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_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			if (CardExpansionData.TryGetValue(cardData.expansionType, out ModCardExpansionData value))
			{
				if (value.Cards.TryGetValue(cardData.monsterType, out ModCardData value2))
				{
					return value2.MonsterData;
				}
				return InventoryBase.GetMonsterData(cardData.monsterType);
			}
			return InventoryBase.GetMonsterData(cardData.monsterType);
		}

		public MonsterData GetMonsterData(ECardExpansionType expansionType, EMonsterType monsterType)
		{
			//IL_0006: 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_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			if (CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value))
			{
				if (value.Cards.TryGetValue(monsterType, out ModCardData value2))
				{
					return value2.MonsterData;
				}
				return InventoryBase.GetMonsterData(monsterType);
			}
			return InventoryBase.GetMonsterData(monsterType);
		}

		public bool IsCardFoil(ECardExpansionType expansionType, EMonsterType monsterType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			if (!CardExpansionData.TryGetValue(expansionType, out ModCardExpansionData value) || value.HasRandomFoils)
			{
				return false;
			}
			if (value.Cards.TryGetValue(monsterType, out ModCardData value2))
			{
				return value2.IsFoil;
			}
			return false;
		}

		public bool IsCardExpansionUnlocked(ECardExpansionType expansionType)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.ExpansionItemLookup.TryGetValue(expansionType, out List<EItemType> value))
			{
				return false;
			}
			foreach (EItemType item in value)
			{
				if (EplRuntimeData.Services.SaveDataManager.TryGetSaveData<EItemType, ItemSaveData>(item, out ItemSaveData data) && (data.IsBigBoxUnlocked || data.IsSmallBoxUnlocked))
				{
					return true;
				}
			}
			return false;
		}

		static CardExpansionLibrary()
		{
			ECardExpansionType[] array = new ECardExpansionType[4];
			RuntimeHelpers.InitializeArray(array, (RuntimeFieldHandle)/*OpCode not supported: LdMemberToken*/);
			BaseExpansionTypes = new <>z__ReadOnlyArray<ECardExpansionType>((ECardExpansionType[])(object)array);
		}
	}
	internal class DecoLibrary : IDecoLibrary
	{
		internal int? firstInsertedWallTexture;

		internal int? firstInsertedCeilingTexture;

		internal int? firstInsertedFloorTexture;

		internal Dictionary<EDecoObject, ModDecoData> DecoObjectData { get; set; } = new Dictionary<EDecoObject, ModDecoData>();

		internal List<ModShopDecoData> DecoWallTextureData { get; set; } = new List<ModShopDecoData>();

		internal List<ModShopDecoData> DecoFloorTextureData { get; set; } = new List<ModShopDecoData>();

		internal List<ModShopDecoData> DecoCeilingTextureData { get; set; } = new List<ModShopDecoData>();

		public StreamingAsset<Sprite>? GetIcon(EDecoObject decoObject)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				return null;
			}
			return value.Icon;
		}

		public IReadOnlyDictionary<EDecoObject, StreamingAsset<Sprite>> GetIcons()
		{
			return DecoObjectData.ToDictionary<KeyValuePair<EDecoObject, ModDecoData>, EDecoObject, StreamingAsset<Sprite>>((KeyValuePair<EDecoObject, ModDecoData> kvp) => kvp.Key, (KeyValuePair<EDecoObject, ModDecoData> kvp) => kvp.Value.Icon);
		}

		public InteractableObject? GetPrefab(EDecoObject decoObject)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				return null;
			}
			return value.BaseDecoData.spawnPrefab;
		}

		public IReadOnlyDictionary<EDecoObject, InteractableObject> GetPrefabs()
		{
			return DecoObjectData.ToDictionary<KeyValuePair<EDecoObject, ModDecoData>, EDecoObject, InteractableObject>((KeyValuePair<EDecoObject, ModDecoData> kvp) => kvp.Key, (KeyValuePair<EDecoObject, ModDecoData> kvp) => kvp.Value.BaseDecoData.spawnPrefab);
		}

		public int GetLevelRequirement(EDecoObject decoObject)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!DecoObjectData.TryGetValue(decoObject, out ModDecoData value))
			{
				throw new ArgumentException($"{decoObject} is not a registered decoration object.");
			}
			return value.BasePurchaseData.levelRequirement;
		}
	}
	internal class EplAssets : IEplAssets
	{
		internal CardExpansionLibrary CardExpansionLibrary { get; set; } = new CardExpansionLibrary();

		internal DecoLibrary DecoLibrary { get; set; } = new DecoLibrary();

		internal FurnitureLibrary FurnitureLibrary { get; set; } = new FurnitureLibrary();

		internal ItemLibrary ItemLibrary { get; set; } = new ItemLibrary();

		internal ShopLibrary ShopLibrary { get; set; } = new ShopLibrary();

		internal LookupLibrary LookupLibrary { get; set; } = new LookupLibrary();

		internal BundleRegistry BundleRegistry { get; set; }

		public ICardExpansionLibrary CardExpansions => (ICardExpansionLibrary)(object)CardExpansionLibrary;

		public IFurnitureLibrary Furniture => (IFurnitureLibrary)(object)FurnitureLibrary;

		public IItemLibrary Items => (IItemLibrary)(object)ItemLibrary;

		public IDecoLibrary Deco => (IDecoLibrary)(object)DecoLibrary;

		public IShopLibrary Shops => (IShopLibrary)(object)ShopLibrary;

		public EplAssets(BundleRegistry bundleRegistry)
		{
			BundleRegistry = bundleRegistry;
			base..ctor();
		}
	}
	internal class FurnitureLibrary : IFurnitureLibrary
	{
		internal Dictionary<EObjectType, ModFurniturePurchaseData> FurnitureData { get; set; } = new Dictionary<EObjectType, ModFurniturePurchaseData>();

		public StreamingAsset<Sprite>? GetIcon(EObjectType objectType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value))
			{
				return null;
			}
			return value.Icon;
		}

		public IReadOnlyDictionary<EObjectType, StreamingAsset<Sprite>> GetIcons()
		{
			return FurnitureData.ToDictionary<KeyValuePair<EObjectType, ModFurniturePurchaseData>, EObjectType, StreamingAsset<Sprite>>((KeyValuePair<EObjectType, ModFurniturePurchaseData> kvp) => kvp.Key, (KeyValuePair<EObjectType, ModFurniturePurchaseData> kvp) => kvp.Value.Icon);
		}

		public InteractableObject? GetPrefab(EObjectType objectType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value))
			{
				return null;
			}
			return value.BaseObjectData.spawnPrefab;
		}

		public IReadOnlyDictionary<EObjectType, InteractableObject> GetPrefabs()
		{
			return FurnitureData.ToDictionary<KeyValuePair<EObjectType, ModFurniturePurchaseData>, EObjectType, InteractableObject>((KeyValuePair<EObjectType, ModFurniturePurchaseData> kvp) => kvp.Key, (KeyValuePair<EObjectType, ModFurniturePurchaseData> kvp) => kvp.Value.BaseObjectData.spawnPrefab);
		}

		public int GetLevelRequirement(EObjectType objectType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			if (!FurnitureData.TryGetValue(objectType, out ModFurniturePurchaseData value))
			{
				throw new ArgumentException($"{objectType} is not a registered furniture object.");
			}
			return value.BaseFurniturePurchaseData.levelRequirement;
		}
	}
	internal class ItemLibrary : IItemLibrary
	{
		internal Dictionary<ECardExpansionType, List<(int MinPrice, EItemType ItemType)>> BulkBoxes { get; set; } = new Dictionary<ECardExpansionType, List<(int, EItemType)>>();

		internal Dictionary<EItemType, ModItemData> ItemData { get; set; } = new Dictionary<EItemType, ModItemData>();

		internal Dictionary<EItemType, ItemMeshData> ItemMeshData { get; set; } = new Dictionary<EItemType, ItemMeshData>();

		internal List<ModRestockData> RestockEntries { get; set; } = new List<ModRestockData>();

		internal List<EItemType> SprayCanList { get; set; } = new List<EItemType>();

		internal Dictionary<string, IItemPriceGenerator> ItemPriceGenerators { get; set; } = new Dictionary<string, IItemPriceGenerator>();

		public StreamingAsset<Sprite>? GetIcon(EItemType itemType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemData.TryGetValue(itemType, out ModItemData value))
			{
				return null;
			}
			return value.Icon;
		}

		public IReadOnlyDictionary<EItemType, StreamingAsset<Sprite>> GetIcons()
		{
			return ItemData.ToDictionary<KeyValuePair<EItemType, ModItemData>, EItemType, StreamingAsset<Sprite>>((KeyValuePair<EItemType, ModItemData> kvp) => kvp.Key, (KeyValuePair<EItemType, ModItemData> kvp) => kvp.Value.Icon);
		}

		public ItemMeshData? GetItemMeshData(EItemType itemType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			if (!ItemMeshData.TryGetValue(itemType, out ItemMeshData value))
			{
				return null;
			}
			return value;
		}

		public IReadOnlyDictionary<EItemType, ItemMeshData> GetAllItemMeshData()
		{
			return ItemMeshData;
		}

		public EItemType GetBulkBox(ECardExpansionType expansionType, int priceCutoff)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: 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)
			if (BulkBoxes.TryGetValue(expansionType, out List<(int, EItemType)> value))
			{
				foreach (var (num, result) in value)
				{
					if (priceCutoff > num)
					{
						return result;
					}
				}
			}
			return (EItemType)(-1);
		}

		public IReadOnlyDictionary<ECardExpansionType, IReadOnlyList<(int MinPrice, EItemType ItemType)>> GetBulkBoxes()
		{
			return BulkBoxes.ToDictionary<KeyValuePair<ECardExpansionType, List<(int, EItemType)>>, ECardExpansionType, IReadOnlyList<(int, EItemType)>>((KeyValuePair<ECardExpansionType, List<(int MinPrice, EItemType ItemType)>> kvp) => kvp.Key, (KeyValuePair<ECardExpansionType, List<(int MinPrice, EItemType ItemType)>> kvp) => kvp.Value.AsReadOnly());
		}

		public PackWeightData GetPackWeights(EItemType pack)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Expected O, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			Dictionary<PackSlot, IReadOnlyDictionary<ERarity, float>> dictionary = new Dictionary<PackSlot, IReadOnlyDictionary<ERarity, float>>();
			foreach (KeyValuePair<PackSlot, Dictionary<ERarity, float>> packSlotWeight in value.PackSlotWeights)
			{
				packSlotWeight.Deconstruct(out var key, out var value2);
				PackSlot key2 = key;
				Dictionary<ERarity, float> dictionary2 = value2;
				dictionary[key2] = new ReadOnlyDictionary<ERarity, float>(new Dictionary<ERarity, float>(dictionary2));
			}
			return new PackWeightData
			{
				NormalWeights = new ReadOnlyDictionary<ERarity, float>(new Dictionary<ERarity, float>(value.NormalGenerationWeights)),
				GodWeights = new ReadOnlyDictionary<ERarity, float>(new Dictionary<ERarity, float>(value.GodGenerationWeights)),
				SlotWeights = new ReadOnlyDictionary<PackSlot, IReadOnlyDictionary<ERarity, float>>(dictionary)
			};
		}

		public PackConfigData GetPackConfig(EItemType pack)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: 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_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			if (!EplRuntimeData.Assets.LookupLibrary.GenerationDataLookup.TryGetValue(pack, out CardGenerationData value))
			{
				throw new ArgumentException($"{pack} is not a registered card pack item.");
			}
			return new PackConfigData
			{
				Pack = pack,
				Expansion = value.Expansion,
				PackType = value.PackType,
				CanHaveDuplicates = value.CanHaveDuplicates,
				CanHaveGodPacks = value.CanHaveGodPack,
				GodPackPercentage = value.GodPackPercentage,
				PackGenerationStrategy = (value.Strategy?.ToString() ?? string.Empty)
			};
		}

		public EItemType? GetSpawnedPackType(EItemType cardBox)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.SpawnPackLookup.TryGetValue(cardBox, out var value))
			{
				return null;
			}
			return value;
		}

		public IReadOnlyList<EItemType> GetPacksForExpansion(ECardExpansionType expansionType)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.ExpansionItemLookup.TryGetValue(expansionType, out List<EItemType> value))
			{
				return Array.Empty<EItemType>();
			}
			return new <>z__ReadOnlyArray<EItemType>(value.ToArray());
		}

		public ECardExpansionType? GetExpansionForPackType(ECollectionPackType packType)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!EplRuntimeData.Assets.LookupLibrary.ExpansionLookup.TryGetValue(packType, out var value))
			{
				return null;
			}
			return value;
		}
	}
	internal class LookupLibrary
	{
		private List<EItemType>? sortedPackTypes;

		internal Dictionary<EItemType, EItemType> SpawnPackLookup { get; set; } = new Dictionary<EItemType, EItemType>();

		internal Dictionary<EItemType, CardGenerationData> GenerationDataLookup { get; set; } = new Dictionary<EItemType, CardGenerationData>();

		internal Dictionary<ECollectionPackType, ECardExpansionType> ExpansionLookup { get; set; } = new Dictionary<ECollectionPackType, ECardExpansionType>();

		internal Dictionary<EItemType, List<RestockData>> RestockDataLookup { get; set; } = new Dictionary<EItemType, List<RestockData>>();

		internal Dictionary<ECardExpansionType, List<EItemType>> ExpansionItemLookup { get; set; } = new Dictionary<ECardExpansionType, List<EItemType>>();

		internal List<EItemType> SortedPackTypes => sortedPackTypes ?? (sortedPackTypes = GenerationDataLookup.Keys.OrderBy((EItemType key) => (int)key).ToList());

		internal void InvalidateSortedPackTypes()
		{
			sortedPackTypes = null;
		}
	}
	internal class ShopLibrary : IShopLibrary
	{
		internal Dictionary<string, CustomShopData> CustomShops { get; set; } = new Dictionary<string, CustomShopData>();

		internal Dictionary<EItemType, CustomShopData> ItemShopLookup { get; set; } = new Dictionary<EItemType, CustomShopData>();

		public IReadOnlyList<string> GetPhoneAppIds()
		{
			return new <>z__ReadOnlyArray<string>(CustomShops.Keys.ToArray());
		}

		public ShopData? GetShopDataFor(string appId)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: 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_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Expected O, but got Unknown
			if (CustomShops.TryGetValue(appId, out CustomShopData value))
			{
				return new ShopData
				{
					PhoneAppId = value.PhoneAppId,
					AppDisplayName = value.AppDisplayName,
					TCG = value.TCG.AsReadOnly(),
					Accessories = value.Accessories,
					Figurines = value.Figurines
				};
			}
			return null;
		}

		public ItemShopInfo? GetShopInfoFor(EItemType itemType)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Expected O, but got Unknown
			if (!ItemShopLookup.TryGetValue(itemType, out CustomShopData value))
			{
				return null;
			}
			RestockData smallBox = null;
			RestockData bigBox = null;
			if (EplRuntimeData.Assets.LookupLibrary.RestockDataLookup.TryGetValue(itemType, out List<RestockData> value2))
			{
				foreach (RestockData item in value2)
				{
					if (item.isBigBox)
					{
						bigBox = item;
					}
					else
					{
						smallBox = item;
					}
				}
			}
			return new ItemShopInfo
			{
				PhoneAppId = value.PhoneAppId,
				AppDisplayName = value.AppDisplayName,
				SmallBox = smallBox,
				BigBox = bigBox
			};
		}
	}
	internal class StreamingAssetService : IAssetLoadBridge, IAssetRefTracker
	{
		private class LoadedAsset
		{
			public Object Asset { get; set; }

			public float CooldownTime { get; set; }

			public int RefCount { get; set; }
		}

		private readonly Dictionary<string, LoadedAsset> loadedAssets = new Dictionary<string, LoadedAsset>();

		private readonly Dictionary<string, List<Action<Object?>>> pendingCallbacks = new Dictionary<string, List<Action<Object>>>();

		private Coroutine? cleanupCoroutine;

		public void StartLoadingCoroutine(string bundlePath, string assetName, Type type, Action<Object?> callback)
		{
			((MonoBehaviour)Plugin.Instance).StartCoroutine(LoadAssetAsync(bundlePath, assetName, type, callback));
		}

		internal void StartCleanupCoroutine()
		{
			if (cleanupCoroutine == null)
			{
				cleanupCoroutine = ((MonoBehaviour)Plugin.Instance).StartCoroutine(CleanUpAsync());
			}
		}

		internal IEnumerator LoadAssetAsync(string bundlePath, string assetName, Type type, Action<Object?> callback)
		{
			string assetKey = bundlePath + "|" + assetName + "|" + type.Name;
			if (loadedAssets.TryGetValue(assetKey, out LoadedAsset value))
			{
				callback(value.Asset);
				yield break;
			}
			if (pendingCallbacks.TryGetValue(assetKey, out List<Action<Object>> value2))
			{
				value2.Add(delegate(Object? obj)
				{
					callback?.Invoke(obj);
				});
				yield break;
			}
			pendingCallbacks[assetKey] = new List<Action<Object>>();
			Object loadedAsset = null;
			try
			{
				BundleManager.BundleHandle handle = EplRuntimeData.Services.BundleManager.GetOrOpen(bundlePath);
				yield return handle.WaitForLoadAsync();
				if (handle.HasError)
				{
					ModLogger.Error("Bundle '" + bundlePath + "' failed to load.", "LoadAssetAsync", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Assets\\StreamingAssetService.cs");
					yield break;
				}
				AssetBundleRequest assetRequest = handle.LoadAssetAsync(assetName, type);
				if (assetRequest == null)
				{
					ModLogger.Error("LoadAssetAsync returned null for '" + assetName + "' from '" + bundlePath + "'", "LoadAssetAsync", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Assets\\StreamingAssetService.cs");
					yield break;
				}
				yield return assetRequest;
				loadedAsset = assetRequest.asset;
				if (loadedAsset == null)
				{
					ModLogger.Error("Asset '" + assetName + "' loaded as null from '" + bundlePath + "'.", "LoadAssetAsync", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Assets\\StreamingAssetService.cs");
				}
				else
				{
					loadedAssets[assetKey] = new LoadedAsset
					{
						Asset = loadedAsset,
						CooldownTime = Time.realtimeSinceStartup + 30f
					};
				}
			}
			finally
			{
				StreamingAssetService streamingAssetService = this;
				callback?.Invoke(loadedAsset);
				if (streamingAssetService.pendingCallbacks.TryGetValue(assetKey, out List<Action<Object>> value3))
				{
					foreach (Action<Object> item in value3)
					{
						item?.Invoke(loadedAsset);
					}
					streamingAssetService.pendingCallbacks.Remove(assetKey);
				}
			}
		}

		public void IncrementRef(string assetKey)
		{
			if (loadedAssets.TryGetValue(assetKey, out LoadedAsset value))
			{
				value.RefCount++;
			}
		}

		public void DecrementRef(string assetKey)
		{
			if (loadedAssets.TryGetValue(assetKey, out LoadedAsset value))
			{
				value.RefCount--;
				if (value.RefCount < 0)
				{
					ModLogger.Error("Ref count for '" + assetKey + "' went negative. A StreamingAsset may have been assigned outside of EPL extension methods.", "DecrementRef", "C:\\GitLab-Runner\\builds\\-F4_x1RGt\\0\\tcg-mods\\prefabloader\\EnhancedPrefabLoader.Core\\Assets\\StreamingAssetService.cs");
					value.RefCount = 0;
				}
				if (value.RefCount == 0)
				{
					value.CooldownTime = Time.realtimeSinceStartup;
				}
			}
		}

		internal IEnumerator CleanUpAsync()
		{
			while (true)
			{
				yield return (object)new WaitForSeconds(60f);
				List<string> list = new List<string>();
				foreach (var (item, loadedAsset2) in loadedAssets)
				{
					if (loadedAsset2.RefCount == 0 && Time.realtimeSinceStartup - loadedAsset2.CooldownTime > 60f)
					{
						list.Add(item);
						Resources.UnloadAsset(loadedAsset2.Asset);
					}
				}
				foreach (string item2 in list)
				{
					loadedAssets.Remove(item2);
				}
			}
		}
	}
}
namespace System.Runtime.CompilerServices
{
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = true)]
	internal sealed class IgnoresAccessChecksToAttribute : Attribute
	{
		internal IgnoresAccessChecksToAttribute(string assemblyName)
		{
		}
	}
}