using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Configuration;
using BepInEx.Logging;
using Extensions;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Mirror;
using MoreMountains.Tools;
using MoreUpgrades.Menu;
using Steamworks;
using TMPro;
using TryConnect;
using UnityEngine;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.InputSystem;
using UnityEngine.InputSystem.Controls;
using UnityEngine.UI;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyVersion("0.0.0.0")]
[module: RefSafetyRules(11)]
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;
		}
	}
}
namespace MoreUpgrades
{
	public class ExtraDailyTimeUpgrade : Upgrade
	{
		public const float SecondsPerUse = 30f;

		private static readonly FieldRef<Upgrade, TextMeshPro> ValueTextField = AccessTools.FieldRefAccess<Upgrade, TextMeshPro>("valueText");

		private bool _hasBeenUsed;

		private void Start()
		{
			TextMeshPro val = ValueTextField.Invoke((Upgrade)(object)this);
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)val).text = $"+{30f:0.#}s";
			}
		}

		protected override void OnUseItem(bool isPressed)
		{
			if (!_hasBeenUsed)
			{
				_hasBeenUsed = true;
				if (((NetworkBehaviour)this).isServer)
				{
					((MonoBehaviour)this).StartCoroutine(UseRoutine());
				}
			}
		}

		private IEnumerator UseRoutine()
		{
			yield return (object)new WaitForSecondsRealtime(0.5f);
			GameManager val = Object.FindFirstObjectByType<GameManager>();
			if ((Object)(object)val != (Object)null)
			{
				GameUpgradeState.ShareAcrossLobby(GamePlayerUpgradeType.ExtraDailyTime, 30f);
				GrantExtraTime(val, 30f);
				PluginMain.Log.LogInfo((object)$"Extra Time granted +{30f}s of day duration (state={val.state}).");
			}
			else
			{
				PluginMain.Log.LogWarning((object)"Extra Time: no GameManager found — skipping.");
			}
			((ConsumableItem)this).DestroyItem();
		}

		internal static void GrantExtraTime(GameManager gameManager, float seconds)
		{
			if (NetworkServer.active && !((Object)(object)gameManager == (Object)null) && !(seconds <= 0f))
			{
				gameManager.Network_dayDuration += seconds;
			}
		}

		public override bool Weaved()
		{
			return true;
		}
	}
	public class GameFlavoredUpgrade : Upgrade
	{
		private static readonly FieldRef<Upgrade, Animator> AnimField = AccessTools.FieldRefAccess<Upgrade, Animator>("anim");

		private static readonly FieldRef<Upgrade, SFXComponent> UpgradeSfxField = AccessTools.FieldRefAccess<Upgrade, SFXComponent>("upgradeSfx");

		private static readonly FieldRef<Upgrade, TextMeshPro> ValueTextField = AccessTools.FieldRefAccess<Upgrade, TextMeshPro>("valueText");

		[SerializeField]
		private GamePlayerUpgradeType _upgradeType;

		[SerializeField]
		private float _amount;

		[SerializeField]
		private bool _configured;

		private bool _hasBeenUsed;

		protected GamePlayerUpgradeType UpgradeType => _upgradeType;

		protected float Amount => _amount;

		public void Configure(GamePlayerUpgradeType upgradeType, float amount)
		{
			_upgradeType = upgradeType;
			_amount = amount;
			_configured = true;
		}

		private void Start()
		{
			TextMeshPro val = ValueTextField.Invoke((Upgrade)(object)this);
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)val).text = (_amount * 100f).ToString("0.#") + "%";
			}
		}

		protected override void OnUseItem(bool isPressed)
		{
			if (!_hasBeenUsed && _configured)
			{
				_hasBeenUsed = true;
				Animator val = AnimField.Invoke((Upgrade)(object)this);
				if ((Object)(object)val != (Object)null)
				{
					val.SetTrigger("Use");
				}
				if (((NetworkBehaviour)this).isServer)
				{
					((MonoBehaviour)this).StartCoroutine(UseRoutine());
				}
			}
		}

		private IEnumerator UseRoutine()
		{
			yield return (object)new WaitForSecondsRealtime(0.5f);
			PlayerProfile[] array = Object.FindObjectsByType<PlayerProfile>((FindObjectsSortMode)0);
			foreach (PlayerProfile val in array)
			{
				GameUpgradeState.Add(val.steamId, _upgradeType, _amount);
				RpcUpgradeChanged(val.steamId, _upgradeType, GameUpgradeState.Get(val.steamId, _upgradeType));
			}
			PluginMain.Log.LogInfo((object)$"Granted {_upgradeType} +{_amount} to the lobby.");
			SFXComponent val2 = UpgradeSfxField.Invoke((Upgrade)(object)this);
			if ((Object)(object)val2 != (Object)null)
			{
				val2.RpcPlayOneShotWith3DPos();
			}
			((ConsumableItem)this).DestroyItem();
		}

		[ClientRpc]
		private void RpcUpgradeChanged(ulong steamId, GamePlayerUpgradeType type, float newTotal)
		{
			UpgradeHudSync.OnUpgradeChanged(steamId, type, newTotal);
		}

		public override bool Weaved()
		{
			return true;
		}
	}
	public enum GamePlayerUpgradeType
	{
		SlotsLuck,
		RouletteLuck,
		WheelLuck,
		BlackjackLuck,
		PokerLuck,
		BaccaratLuck,
		CrapsLuck,
		MinesweeperLuck,
		CrashLuck,
		PlinkoLuck,
		KenoLuck,
		HiLoLuck,
		DuckRaceLuck,
		CrossyRoadLuck,
		CoinFlipLuck,
		ExtraShopItems,
		ExtraDailyTime
	}
	internal static class GameTypeMap
	{
		private static readonly Dictionary<CasinoGameType, GamePlayerUpgradeType> Map = new Dictionary<CasinoGameType, GamePlayerUpgradeType>
		{
			[(CasinoGameType)12] = GamePlayerUpgradeType.SlotsLuck,
			[(CasinoGameType)11] = GamePlayerUpgradeType.RouletteLuck,
			[(CasinoGameType)9] = GamePlayerUpgradeType.WheelLuck,
			[(CasinoGameType)13] = GamePlayerUpgradeType.WheelLuck,
			[(CasinoGameType)0] = GamePlayerUpgradeType.BlackjackLuck,
			[(CasinoGameType)14] = GamePlayerUpgradeType.PokerLuck,
			[(CasinoGameType)16] = GamePlayerUpgradeType.BaccaratLuck,
			[(CasinoGameType)1] = GamePlayerUpgradeType.CrapsLuck,
			[(CasinoGameType)8] = GamePlayerUpgradeType.MinesweeperLuck,
			[(CasinoGameType)5] = GamePlayerUpgradeType.MinesweeperLuck,
			[(CasinoGameType)2] = GamePlayerUpgradeType.CrashLuck,
			[(CasinoGameType)10] = GamePlayerUpgradeType.PlinkoLuck,
			[(CasinoGameType)7] = GamePlayerUpgradeType.KenoLuck,
			[(CasinoGameType)4] = GamePlayerUpgradeType.HiLoLuck,
			[(CasinoGameType)6] = GamePlayerUpgradeType.DuckRaceLuck,
			[(CasinoGameType)3] = GamePlayerUpgradeType.CrossyRoadLuck,
			[(CasinoGameType)15] = GamePlayerUpgradeType.CoinFlipLuck
		};

		public static GamePlayerUpgradeType? ToUpgrade(CasinoGameType gameType)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			if (!Map.TryGetValue(gameType, out var value))
			{
				return null;
			}
			return value;
		}
	}
	[Serializable]
	public sealed class GameUpgradeSaveData
	{
		[Serializable]
		public sealed class PlayerEntry
		{
			public string steamId = "";

			public List<ValueEntry> upgrades = new List<ValueEntry>();
		}

		[Serializable]
		public sealed class ValueEntry
		{
			public GamePlayerUpgradeType type;

			public float value;
		}

		public List<PlayerEntry> players = new List<PlayerEntry>();
	}
	internal static class GameUpgradeState
	{
		private static readonly ConcurrentDictionary<ulong, ConcurrentDictionary<GamePlayerUpgradeType, float>> Values = new ConcurrentDictionary<ulong, ConcurrentDictionary<GamePlayerUpgradeType, float>>();

		public static float Get(ulong steamId, GamePlayerUpgradeType type)
		{
			if (Values.TryGetValue(steamId, out ConcurrentDictionary<GamePlayerUpgradeType, float> value) && value.TryGetValue(type, out var value2))
			{
				return value2;
			}
			return 0f;
		}

		public static void Add(ulong steamId, GamePlayerUpgradeType type, float amount)
		{
			Values.GetOrAdd(steamId, (ulong _) => new ConcurrentDictionary<GamePlayerUpgradeType, float>()).AddOrUpdate(type, amount, (GamePlayerUpgradeType _, float existing) => existing + amount);
		}

		public static void Set(ulong steamId, GamePlayerUpgradeType type, float value)
		{
			Values.GetOrAdd(steamId, (ulong _) => new ConcurrentDictionary<GamePlayerUpgradeType, float>())[type] = value;
		}

		public static void ShareAcrossLobby(GamePlayerUpgradeType type, float amount)
		{
			PlayerProfile[] array = Object.FindObjectsByType<PlayerProfile>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				Add(array[i].steamId, type, amount);
			}
		}

		public static void ResetAll()
		{
			Values.Clear();
		}

		public static IEnumerable<(ulong SteamId, GamePlayerUpgradeType Type, float Value)> All()
		{
			foreach (KeyValuePair<ulong, ConcurrentDictionary<GamePlayerUpgradeType, float>> kvp in Values)
			{
				foreach (KeyValuePair<GamePlayerUpgradeType, float> item in kvp.Value)
				{
					yield return (SteamId: kvp.Key, Type: item.Key, Value: item.Value);
				}
			}
		}
	}
	internal static class ItemDescriptionRegistry
	{
		private static readonly ConcurrentDictionary<int, string> DescriptionsBySpawnableId = new ConcurrentDictionary<int, string>();

		private static readonly ConcurrentDictionary<int, string> NamesBySpawnableId = new ConcurrentDictionary<int, string>();

		public static void Register(int spawnableId, string displayName, string description)
		{
			NamesBySpawnableId[spawnableId] = displayName;
			DescriptionsBySpawnableId[spawnableId] = description;
		}

		public static bool TryGetDescription(int spawnableId, out string description)
		{
			return DescriptionsBySpawnableId.TryGetValue(spawnableId, out description);
		}

		public static bool TryGetName(int spawnableId, out string name)
		{
			return NamesBySpawnableId.TryGetValue(spawnableId, out name);
		}
	}
	internal static class ItemRegistrar
	{
		private readonly struct OddsUpgradeDefinition
		{
			public readonly string Key;

			public readonly string DisplayName;

			public readonly string GameLabel;

			public readonly GamePlayerUpgradeType UpgradeType;

			public readonly Color Tint;

			public OddsUpgradeDefinition(string key, string displayName, string gameLabel, GamePlayerUpgradeType upgradeType, Color tint)
			{
				//IL_001e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0020: Unknown result type (might be due to invalid IL or missing references)
				Key = key;
				DisplayName = displayName;
				GameLabel = gameLabel;
				UpgradeType = upgradeType;
				Tint = tint;
			}
		}

		private const float DefaultOddsBoost = 0.15f;

		private const string ScrollBundlePath = "Assets/moreupgrades.scroll";

		private const string ScrollVisualPrefabName = "scroll";

		private static readonly Vector3 ScrollVisualScale = new Vector3(0.8f, 0.8f, 1.15f);

		private const string PillsBundlePath = "Assets/moreupgrades.pills";

		private const string PillsVisualPrefabName = "pills";

		private static readonly Vector3 PillsVisualScale = Vector3.one * 0.32f;

		private static readonly Vector3 PillsVisualEulerAngles = new Vector3(0f, -180f, 0f);

		private static readonly OddsUpgradeDefinition[] OddsUpgrades = new OddsUpgradeDefinition[15]
		{
			new OddsUpgradeDefinition("slots_luck", "Slots Luck", "Slots", GamePlayerUpgradeType.SlotsLuck, HsvColor(0f, 0.85f, 0.9f)),
			new OddsUpgradeDefinition("roulette_reader", "Roulette Reader", "Roulette", GamePlayerUpgradeType.RouletteLuck, HsvColor(24f, 0.9f, 0.75f)),
			new OddsUpgradeDefinition("wheel_whisperer", "Wheel Whisperer", "Money Wheel and Wheel of Fortune", GamePlayerUpgradeType.WheelLuck, HsvColor(48f, 0.9f, 0.95f)),
			new OddsUpgradeDefinition("card_counter", "Card Counter", "Blackjack", GamePlayerUpgradeType.BlackjackLuck, HsvColor(72f, 0.75f, 0.75f)),
			new OddsUpgradeDefinition("poker_face", "Poker Face", "Poker", GamePlayerUpgradeType.PokerLuck, HsvColor(96f, 0.8f, 0.65f)),
			new OddsUpgradeDefinition("baccarat_instinct", "Baccarat Instinct", "Baccarat", GamePlayerUpgradeType.BaccaratLuck, HsvColor(120f, 0.75f, 0.6f)),
			new OddsUpgradeDefinition("loaded_dice", "Loaded Dice", "Craps", GamePlayerUpgradeType.CrapsLuck, HsvColor(144f, 0.85f, 0.7f)),
			new OddsUpgradeDefinition("steady_hands", "Steady Hands", "Minesweeper and Dragon Tower", GamePlayerUpgradeType.MinesweeperLuck, HsvColor(168f, 0.8f, 0.75f)),
			new OddsUpgradeDefinition("crash_sense", "Crash Sense", "Crash", GamePlayerUpgradeType.CrashLuck, HsvColor(192f, 0.85f, 0.9f)),
			new OddsUpgradeDefinition("plinko_precision", "Plinko Precision", "Plinko", GamePlayerUpgradeType.PlinkoLuck, HsvColor(216f, 0.85f, 0.9f)),
			new OddsUpgradeDefinition("keno_clairvoyance", "Keno Clairvoyance", "Keno", GamePlayerUpgradeType.KenoLuck, HsvColor(240f, 0.75f, 0.85f)),
			new OddsUpgradeDefinition("hilo_hunch", "Hi-Lo Hunch", "Hi-Lo", GamePlayerUpgradeType.HiLoLuck, HsvColor(264f, 0.8f, 0.8f)),
			new OddsUpgradeDefinition("duck_whisperer", "Duck Whisperer", "Duck Race", GamePlayerUpgradeType.DuckRaceLuck, HsvColor(288f, 0.85f, 0.85f)),
			new OddsUpgradeDefinition("crossy_confidence", "Crossy Confidence", "Crossy Road", GamePlayerUpgradeType.CrossyRoadLuck, HsvColor(312f, 0.85f, 0.85f)),
			new OddsUpgradeDefinition("coin_sense", "Coin Sense", "Coin Flip", GamePlayerUpgradeType.CoinFlipLuck, HsvColor(336f, 0.9f, 0.8f))
		};

		private static string DurationWord
		{
			get
			{
				if (!PluginMain.PersistentUpgradesPresent)
				{
					return "Boosts (for the rest of today)";
				}
				return "Permanently boosts";
			}
		}

		private static Color HsvColor(float hueDegrees, float saturation, float value)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			return Color.HSVToRGB(hueDegrees / 360f, saturation, value);
		}

		public static void RegisterAll(BaseUnityPlugin plugin)
		{
			//IL_0069: 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)
			SpawnableSO val = TryConnectApi.FindVanillaSpawnable<Upgrade>();
			if ((Object)(object)val == (Object)null)
			{
				PluginMain.Log.LogError((object)"Could not find the vanilla Upgrade spawnable — no items were registered.");
				return;
			}
			OddsUpgradeDefinition[] oddsUpgrades = OddsUpgrades;
			for (int i = 0; i < oddsUpgrades.Length; i++)
			{
				OddsUpgradeDefinition oddsUpgradeDefinition = oddsUpgrades[i];
				string description = DurationWord + " your winnings at " + oddsUpgradeDefinition.GameLabel + ".";
				RegisterGameFlavoredUpgrade(plugin, val, oddsUpgradeDefinition.Key, oddsUpgradeDefinition.DisplayName, description, oddsUpgradeDefinition.UpgradeType, 0.15f, oddsUpgradeDefinition.Tint);
			}
			RegisterGameFlavoredUpgrade(plugin, val, "shop_scout", "Shop Scout", DurationWord + " the shop by one extra random item each day.", GamePlayerUpgradeType.ExtraShopItems, 1f, new Color(0.4f, 0.75f, 0.9f));
			RegisterExtraDailyTime(plugin, val);
			RegisterSecondWind(plugin, val);
		}

		private static void RegisterGameFlavoredUpgrade(BaseUnityPlugin plugin, SpawnableSO baseSpawnable, string key, string displayName, string description, GamePlayerUpgradeType upgradeType, float amount, Color tint)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = CreateScrollPrefab(plugin, baseSpawnable, key, "CustomPrefab");
			GameObject val2 = CreateScrollPrefab(plugin, baseSpawnable, key, "MarkerPrefab");
			TryConnectApi.SwapPrefabComponent<Upgrade, GameFlavoredUpgrade>(val).Configure(upgradeType, amount);
			TryConnectApi.SwapPrefabComponent<Upgrade, GameFlavoredUpgrade>(val2).Configure(upgradeType, amount);
			Register(plugin, key, displayName, description, baseSpawnable, val, val2, tint);
		}

		private static void RegisterExtraDailyTime(BaseUnityPlugin plugin, SpawnableSO baseSpawnable)
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			Color tint = default(Color);
			((Color)(ref tint))..ctor(0.95f, 0.55f, 0.75f);
			GameObject val = CreateScrollPrefab(plugin, baseSpawnable, "extra_time", "CustomPrefab");
			GameObject val2 = CreateScrollPrefab(plugin, baseSpawnable, "extra_time", "MarkerPrefab");
			TryConnectApi.SwapPrefabComponent<Upgrade, ExtraDailyTimeUpgrade>(val);
			TryConnectApi.SwapPrefabComponent<Upgrade, ExtraDailyTimeUpgrade>(val2);
			string description = "Adds 30 seconds to today's gambling timer." + (PluginMain.PersistentUpgradesPresent ? " Carries over to future days too." : "");
			Register(plugin, "extra_time", "Extra Time", description, baseSpawnable, val, val2, tint);
		}

		private static GameObject CreateScrollPrefab(BaseUnityPlugin plugin, SpawnableSO baseSpawnable, string key, string suffix)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return CreateBundledVisualPrefab(plugin, baseSpawnable, key, suffix, "Assets/moreupgrades.scroll", "scroll", ScrollVisualScale, Vector3.zero);
		}

		private static GameObject CreatePillsPrefab(BaseUnityPlugin plugin, SpawnableSO baseSpawnable, string key, string suffix)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			return CreateBundledVisualPrefab(plugin, baseSpawnable, key, suffix, "Assets/moreupgrades.pills", "pills", PillsVisualScale, PillsVisualEulerAngles);
		}

		private static GameObject CreateBundledVisualPrefab(BaseUnityPlugin plugin, SpawnableSO baseSpawnable, string key, string suffix, string bundlePath, string visualPrefabName, Vector3 visualScale, Vector3 visualEulerAngles)
		{
			//IL_0027: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = TryConnectApi.CreatePrefabTemplate(baseSpawnable, key + "_" + suffix);
			AssetBundle val2 = TryConnectAssetBundles.LoadRelativeToPlugin(plugin, bundlePath);
			try
			{
				GameObject val3 = TryConnectAssetBundles.LoadAsset<GameObject>(val2, visualPrefabName);
				TryConnectApi.ReplaceVisualsWithPrefab(val, val3, visualScale, true, Vector3.zero, visualEulerAngles);
				return val;
			}
			finally
			{
				val2.Unload(false);
			}
		}

		private static void RegisterSecondWind(BaseUnityPlugin plugin, SpawnableSO baseSpawnable)
		{
			GameObject val = CreatePillsPrefab(plugin, baseSpawnable, "second_wind", "CustomPrefab");
			GameObject val2 = CreatePillsPrefab(plugin, baseSpawnable, "second_wind", "MarkerPrefab");
			TryConnectApi.SwapPrefabComponent<Upgrade, SecondWindItem>(val);
			TryConnectApi.SwapPrefabComponent<Upgrade, SecondWindItem>(val2);
			Register(plugin, "second_wind", "Second Wind", "Regenerates one random missing body part. Single use.", baseSpawnable, val, val2, null, 4);
		}

		private static void Register(BaseUnityPlugin plugin, string key, string displayName, string description, SpawnableSO baseSpawnable, GameObject customPrefab, GameObject markerPrefab, Color tint)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			Register(plugin, key, displayName, description, baseSpawnable, customPrefab, markerPrefab, tint, 4);
		}

		private static void Register(BaseUnityPlugin plugin, string key, string displayName, string description, SpawnableSO baseSpawnable, GameObject customPrefab, GameObject markerPrefab, Color? tint, int replacementChancePercent)
		{
			//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_004a: 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_0058: 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_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: 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_008e: 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_009e: 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)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Expected O, but got Unknown
			//IL_00be: 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_00cf: Unknown result type (might be due to invalid IL or missing references)
			int num = TryConnectApi.GenerateSpawnableId(plugin.Info.Metadata.GUID, key);
			ItemDescriptionRegistry.Register(num, displayName, description);
			ApplyInteractableName(customPrefab, displayName);
			ApplyInteractableName(markerPrefab, displayName);
			TryConnectRegistrationResult val = TryConnectApi.RegisterCustomItem(new TryConnectItemRegistration
			{
				OwnerGuid = plugin.Info.Metadata.GUID,
				Key = key,
				SpawnableId = num,
				DisplayName = displayName,
				Description = description,
				BaseSpawnable = baseSpawnable,
				BaseItemComponentType = typeof(Upgrade),
				CustomPrefab = customPrefab,
				MarkerPrefab = markerPrefab,
				ApplyTint = tint.HasValue,
				Tint = tint.GetValueOrDefault(),
				ReplacementChancePercent = replacementChancePercent,
				ExtraBasePrice = 0,
				ExtraFloorPrice = 0
			});
			PluginMain.Log.LogInfo((object)$"Registered '{key}': {val}");
			TryConnectRegisteredItemInfo val2 = default(TryConnectRegisteredItemInfo);
			if (TryConnectApi.TryGetRegisteredItem(num, ref val2) && (Object)(object)val2.Spawnable != (Object)null)
			{
				ApplySpawnableSo(customPrefab, val2.Spawnable);
				ApplySpawnableSo(markerPrefab, val2.Spawnable);
			}
			else
			{
				PluginMain.Log.LogWarning((object)("'" + key + "': could not resolve the registered SpawnableSO — spawnableSo may still point at the wrong item."));
			}
		}

		private static void ApplySpawnableSo(GameObject prefab, SpawnableSO spawnable)
		{
			Item component = prefab.GetComponent<Item>();
			if (!((Object)(object)component == (Object)null))
			{
				component.spawnableSo = spawnable;
			}
		}

		private static void ApplyInteractableName(GameObject prefab, string displayName)
		{
			Item component = prefab.GetComponent<Item>();
			if ((Object)(object)component == (Object)null)
			{
				PluginMain.Log.LogWarning((object)("ApplyInteractableName: '" + ((Object)prefab).name + "' has no Item component — could not set InteractableName."));
				return;
			}
			string interactableName = ((InteractableBase)component).InteractableName;
			((InteractableBase)component).InteractableName = displayName;
			PluginMain.Log.LogInfo((object)("ApplyInteractableName: '" + ((Object)prefab).name + "'.InteractableName '" + interactableName + "' -> '" + displayName + "'."));
		}
	}
	[BepInPlugin("com.cristokos.moreupgrades", "MoreUpgrades", "1.0.2")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public sealed class PluginMain : BaseUnityPlugin
	{
		public const string PluginGuid = "com.cristokos.moreupgrades";

		public const string PluginName = "MoreUpgrades";

		public const string PluginVersion = "1.0.2";

		private const string TryConnectGuid = "com.Try-4646.TryConnect";

		internal const string PersistentUpgradesGuid = "com.cristokos.persistentupgrades";

		private Harmony? _harmony;

		internal static ManualLogSource Log { get; private set; }

		internal static bool PersistentUpgradesPresent { get; private set; }

		internal static ConfigEntry<bool> UnlockDevConsole { get; private set; }

		internal static ConfigFile ConfigFile { get; private set; }

		private void Awake()
		{
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Expected O, but got Unknown
			Log = ((BaseUnityPlugin)this).Logger;
			ConfigFile = ((BaseUnityPlugin)this).Config;
			UnlockDevConsole = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "UnlockDevConsole", false, "Unlocks the game's built-in dev console (spawn any item on demand) for testing. Leave off for normal play.");
			PersistentUpgradesPresent = Chainloader.PluginInfos.ContainsKey("com.cristokos.persistentupgrades");
			Log.LogInfo((object)(PersistentUpgradesPresent ? "PersistentUpgrades detected — MoreUpgrades upgrades will be permanent and lobby-shared." : "PersistentUpgrades not detected — MoreUpgrades upgrades will reset daily, like vanilla upgrades."));
			_harmony = new Harmony("com.cristokos.moreupgrades");
			PatchAllSafely(_harmony);
			try
			{
				ItemRegistrar.RegisterAll((BaseUnityPlugin)(object)this);
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"ItemRegistrar.RegisterAll threw — some or all items may not have registered: {arg}");
			}
			Log.LogInfo((object)"MoreUpgrades 1.0.2 initialized.");
		}

		private static void PatchAllSafely(Harmony harmony)
		{
			Type[] typesFromAssembly = AccessTools.GetTypesFromAssembly(typeof(PluginMain).Assembly);
			foreach (Type type in typesFromAssembly)
			{
				try
				{
					harmony.CreateClassProcessor(type).Patch();
				}
				catch (Exception arg)
				{
					Log.LogError((object)$"Failed to patch '{type.FullName}' — that patch is disabled, everything else continues: {arg}");
				}
			}
		}

		private void OnDestroy()
		{
			Harmony? harmony = _harmony;
			if (harmony != null)
			{
				harmony.UnpatchSelf();
			}
		}
	}
	public class SecondWindItem : Upgrade
	{
		private static readonly Random Random = new Random();

		private bool _hasBeenUsed;

		protected override void OnUseItem(bool isPressed)
		{
			if (!_hasBeenUsed)
			{
				_hasBeenUsed = true;
				if (((NetworkBehaviour)this).isServer)
				{
					((MonoBehaviour)this).StartCoroutine(UseRoutine());
				}
			}
		}

		private IEnumerator UseRoutine()
		{
			yield return (object)new WaitForSecondsRealtime(0.5f);
			GameManager val = Object.FindFirstObjectByType<GameManager>();
			if ((Object)(object)val == (Object)null)
			{
				PluginMain.Log.LogWarning((object)"Second Wind: no GameManager found — skipping.");
			}
			else if ((int)val.state != 1)
			{
				PluginMain.Log.LogWarning((object)$"Second Wind: GameManager.state is '{val.state}', not Game — skipping.");
			}
			else
			{
				PlayerInventory networkHolder = ((Item)this).NetworkHolder;
				if ((Object)(object)networkHolder == (Object)null)
				{
					PluginMain.Log.LogWarning((object)"Second Wind: NetworkHolder is null — skipping.");
				}
				else
				{
					PlayerOrgans component = ((Component)networkHolder).GetComponent<PlayerOrgans>();
					if ((Object)(object)component == (Object)null)
					{
						PluginMain.Log.LogWarning((object)"Second Wind: holder has no PlayerOrgans component — skipping.");
					}
					else
					{
						RegenerateRandomMissingOrgan(component);
					}
				}
			}
			((ConsumableItem)this).DestroyItem();
		}

		private static void RegenerateRandomMissingOrgan(PlayerOrgans organs)
		{
			//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_013b: 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)
			OrganManager val = Object.FindFirstObjectByType<OrganManager>();
			if ((Object)(object)val == (Object)null)
			{
				PluginMain.Log.LogWarning((object)"Second Wind: no OrganManager found — skipping.");
				return;
			}
			if (((NetworkBehaviour)organs).connectionToClient == null)
			{
				PluginMain.Log.LogWarning((object)"Second Wind: organs.connectionToClient is null — skipping.");
				return;
			}
			if (!val.OrganData.TryGetValue(((NetworkBehaviour)organs).connectionToClient.connectionId, out var value))
			{
				PluginMain.Log.LogWarning((object)$"Second Wind: no OrganData entry for connectionId {((NetworkBehaviour)organs).connectionToClient.connectionId} — skipping.");
				return;
			}
			PluginMain.Log.LogInfo((object)$"Second Wind: current organ state — leftEye={value.leftEye}, rightEye={value.rightEye}, body={value.body}, mouth={value.mouth}.");
			List<OrganType> list = new List<OrganType>();
			if (!value.leftEye)
			{
				list.Add((OrganType)0);
			}
			if (!value.rightEye)
			{
				list.Add((OrganType)1);
			}
			if (!value.body)
			{
				list.Add((OrganType)2);
			}
			if (!value.mouth)
			{
				list.Add((OrganType)3);
			}
			if (list.Count == 0)
			{
				PluginMain.Log.LogInfo((object)"Second Wind: no missing organs — nothing to regenerate.");
				return;
			}
			OrganType val2 = list[Random.Next(list.Count)];
			val.ServerToggleOrgan(organs, val2, true);
			PluginMain.Log.LogInfo((object)$"Second Wind regenerated {val2}.");
		}

		public override bool Weaved()
		{
			return true;
		}
	}
}
namespace MoreUpgrades.Patches
{
	[HarmonyPatch(typeof(SettingsLayoutRuntimeUI), "ShowTab")]
	internal static class BulkToggleButtonsPatch
	{
		private static readonly FieldInfo? ResetEntryPrefabField = AccessTools.Field(typeof(SettingsLayoutRuntimeUI), "resetEntryPrefab");

		private static readonly FieldInfo? LayoutField = AccessTools.Field(typeof(SettingsLayoutRuntimeUI), "layout");

		private static readonly FieldInfo? TabContentsField = AccessTools.Field(typeof(SettingsLayoutRuntimeUI), "tabContents");

		private static readonly Random Random = new Random();

		private static void Postfix(SettingsLayoutRuntimeUI __instance, string tabName)
		{
			object? obj = LayoutField?.GetValue(__instance);
			SettingsLayout val = (SettingsLayout)((obj is SettingsLayout) ? obj : null);
			if (val == null || val.tabs == null)
			{
				return;
			}
			List<ToggleSettingItem> toggleEntries = (from e in val.tabs.Find((Tab t) => string.Equals(t.tabName, tabName, StringComparison.OrdinalIgnoreCase))?.entries?.OfType<ToggleSettingItem>()
				where ItemToggleMenu.IsShopToggleKey(((SettingItemBase)e).key)
				select e).ToList();
			if (toggleEntries == null || toggleEntries.Count == 0)
			{
				return;
			}
			Transform val2 = FindContentRoot(__instance, tabName);
			object? obj2 = ResetEntryPrefabField?.GetValue(__instance);
			GameObject val3 = (GameObject)((obj2 is GameObject) ? obj2 : null);
			if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null))
			{
				CreateBulkButton(val3, val2, "\"MoreUpgrades\" — All On", delegate
				{
					SetAll(__instance, tabName, toggleEntries, enabled: true);
				});
				CreateBulkButton(val3, val2, "\"MoreUpgrades\" — All Off", delegate
				{
					SetAll(__instance, tabName, toggleEntries, enabled: false);
				});
				CreateBulkButton(val3, val2, "\"MoreUpgrades\" — Randomize", delegate
				{
					Randomize(__instance, tabName, toggleEntries);
				});
			}
		}

		private static Transform? FindContentRoot(SettingsLayoutRuntimeUI runtimeUi, string tabName)
		{
			if (!(TabContentsField?.GetValue(runtimeUi) is IEnumerable enumerable))
			{
				return null;
			}
			foreach (object item in enumerable)
			{
				FieldInfo? field = item.GetType().GetField("tabName");
				FieldInfo field2 = item.GetType().GetField("contentRoot");
				if (string.Equals(field?.GetValue(item) as string, tabName, StringComparison.OrdinalIgnoreCase))
				{
					object? obj = field2?.GetValue(item);
					object? obj2 = ((obj is RectTransform) ? obj : null);
					return (obj2 != null) ? ((Component)obj2).transform : null;
				}
			}
			return null;
		}

		private static void CreateBulkButton(GameObject resetPrefab, Transform parent, string label, Action onClick)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Expected O, but got Unknown
			GameObject obj = Object.Instantiate<GameObject>(resetPrefab, parent);
			((Object)obj).name = "MoreUpgrades_" + label;
			TMP_Text componentInChildren = obj.GetComponentInChildren<TMP_Text>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				componentInChildren.text = label;
			}
			Button componentInChildren2 = obj.GetComponentInChildren<Button>(true);
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				((UnityEvent)componentInChildren2.onClick).AddListener((UnityAction)delegate
				{
					onClick();
				});
			}
		}

		private static void SetAll(SettingsLayoutRuntimeUI runtimeUi, string tabName, List<ToggleSettingItem> entries, bool enabled)
		{
			foreach (ToggleSettingItem entry in entries)
			{
				entry.value = enabled;
				((SettingItemBase)entry).NotifyChanged();
			}
			PluginMain.Log.LogInfo((object)string.Format("MoreUpgrades: bulk-set {0} shop item(s) to {1}.", entries.Count, enabled ? "enabled" : "disabled"));
			runtimeUi.ShowTab(tabName);
		}

		private static void Randomize(SettingsLayoutRuntimeUI runtimeUi, string tabName, List<ToggleSettingItem> entries)
		{
			foreach (ToggleSettingItem entry in entries)
			{
				entry.value = Random.Next(2) == 0;
				((SettingItemBase)entry).NotifyChanged();
			}
			PluginMain.Log.LogInfo((object)$"MoreUpgrades: randomized {entries.Count} shop item(s)' enabled state.");
			runtimeUi.ShowTab(tabName);
		}
	}
	[HarmonyPatch(typeof(UpgradeManager), "ServerResetAllUpgradesToDefaults")]
	internal static class DefaultDailyResetPatch
	{
		private static void Postfix()
		{
			if (NetworkServer.active && !PluginMain.PersistentUpgradesPresent)
			{
				GameUpgradeState.ResetAll();
				PluginMain.Log.LogInfo((object)"Reset MoreUpgrades upgrade values for the new day (PersistentUpgrades not installed).");
			}
		}
	}
	[HarmonyPatch(typeof(NewConsole), "Start")]
	internal static class DevConsoleUnlockPatch
	{
		private static void Postfix(NewConsole __instance)
		{
			if (PluginMain.UnlockDevConsole.Value && (Object)(object)__instance._devConsoleSetting != (Object)null && !__instance._devConsoleSetting.value)
			{
				__instance._devConsoleSetting.value = true;
				PluginMain.Log.LogInfo((object)"Dev console unlocked for testing (MoreUpgrades Debug.UnlockDevConsole is enabled).");
			}
		}
	}
	[HarmonyPatch(typeof(UpgradeManager), "ServerResetAllUpgradesToDefaults")]
	internal static class ExtraDailyTimeDayResetPatch
	{
		private static void Postfix()
		{
			if (!NetworkServer.active)
			{
				return;
			}
			GameManager val = Object.FindFirstObjectByType<GameManager>();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			GameSettings val2 = Resources.Load<GameSettings>("GameSettings");
			float num = (val.Network_dayDuration = (((Object)(object)val2 != (Object)null) ? val2.dayDuration : 300f));
			if (!PluginMain.PersistentUpgradesPresent)
			{
				PluginMain.Log.LogInfo((object)$"Extra Time: day duration reset to base {num}s (PersistentUpgrades not installed).");
				return;
			}
			float num3 = 0f;
			PlayerProfile[] array = Object.FindObjectsByType<PlayerProfile>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				float num4 = GameUpgradeState.Get(array[i].steamId, GamePlayerUpgradeType.ExtraDailyTime);
				if (num4 > num3)
				{
					num3 = num4;
				}
			}
			if (num3 > 0f)
			{
				ExtraDailyTimeUpgrade.GrantExtraTime(val, num3);
			}
			PluginMain.Log.LogInfo((object)$"Extra Time: day duration reset to base {num}s, then restored +{num3}s (PersistentUpgrades installed).");
		}
	}
	internal static class ExtraShopItemSpawner
	{
		private static readonly Random Random = new Random();

		private static readonly List<GameObject> SpawnedInstances = new List<GameObject>();

		private static readonly HashSet<string> ExcludedLootTableNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "Cosmetics", "MysteryBox" };

		private static readonly FieldInfo? LootTableField = AccessTools.Field(typeof(ItemStamp), "lootTable");

		public static void SpawnForNewDay(MonoBehaviour coroutineHost)
		{
			SpawnedInstances.RemoveAll((GameObject x) => (Object)(object)x == (Object)null);
			Spawn(coroutineHost, "for the new day");
		}

		public static void RespawnForReroll(MonoBehaviour coroutineHost)
		{
			foreach (GameObject spawnedInstance in SpawnedInstances)
			{
				if ((Object)(object)spawnedInstance != (Object)null)
				{
					NetworkServer.Destroy(spawnedInstance);
				}
			}
			SpawnedInstances.Clear();
			Spawn(coroutineHost, "for the reroll");
		}

		private static void Spawn(MonoBehaviour coroutineHost, string logContext)
		{
			int num = Mathf.RoundToInt(HighestStackedExtraShopItems());
			if (num <= 0)
			{
				return;
			}
			List<ItemStamp> list = FindShopStamps();
			if (list.Count == 0)
			{
				PluginMain.Log.LogWarning((object)("Shop Scout: no shop ItemStamp pedestals found to spawn extra items near (" + logContext + ") — skipping."));
				return;
			}
			List<GameObject> eligiblePrefabs = GetEligiblePrefabs(list);
			if (eligiblePrefabs.Count == 0)
			{
				PluginMain.Log.LogWarning((object)("Shop Scout: found shop pedestals but no eligible items in their loot tables (" + logContext + ") — skipping."));
				return;
			}
			List<Vector3> stampPositions = list.Select((ItemStamp s) => ((Component)s).transform.position).ToList();
			coroutineHost.StartCoroutine(SpawnExtraItems(stampPositions, eligiblePrefabs, num, logContext));
		}

		private static List<ItemStamp> FindShopStamps()
		{
			ItemStamp[] array = Object.FindObjectsByType<ItemStamp>((FindObjectsSortMode)0);
			List<ItemStamp> list = new List<ItemStamp>();
			ItemStamp[] array2 = array;
			foreach (ItemStamp val in array2)
			{
				if (!((Object)(object)val == (Object)null))
				{
					object? obj = LootTableField?.GetValue(val);
					MMLootTableGameObjectSO val2 = (MMLootTableGameObjectSO)((obj is MMLootTableGameObjectSO) ? obj : null);
					string text = (((Object)(object)val2 != (Object)null) ? ((Object)val2).name : null);
					if (text == null || !ExcludedLootTableNames.Contains(text))
					{
						list.Add(val);
					}
				}
			}
			return list;
		}

		private static List<GameObject> GetEligiblePrefabs(List<ItemStamp> shopStamps)
		{
			HashSet<GameObject> hashSet = new HashSet<GameObject>();
			foreach (ItemStamp shopStamp in shopStamps)
			{
				object? obj = LootTableField?.GetValue(shopStamp);
				List<MMLootGameObject> list = ((MMLootTable<MMLootGameObject, GameObject>)(object)((MMLootTableGameObjectSO)(((obj is MMLootTableGameObjectSO) ? obj : null)?)).LootTable)?.ObjectsToLoot;
				if (list == null)
				{
					continue;
				}
				foreach (MMLootGameObject item in list)
				{
					if ((Object)(object)((MMLoot<GameObject>)(object)item)?.Loot != (Object)null)
					{
						hashSet.Add(((MMLoot<GameObject>)(object)item).Loot);
					}
				}
			}
			return hashSet.ToList();
		}

		private static IEnumerator SpawnExtraItems(List<Vector3> stampPositions, List<GameObject> eligible, int count, string logContext)
		{
			for (int i = 0; i < count; i++)
			{
				GameObject obj = eligible[Random.Next(eligible.Count)];
				Vector3 val = stampPositions[Random.Next(stampPositions.Count)];
				Vector3 val2 = new Vector3((float)(Random.NextDouble() * 2.0 - 1.0), 0f, (float)(Random.NextDouble() * 2.0 - 1.0)) * 0.75f;
				Vector3 val3 = val + val2 + Vector3.up * 0.5f;
				GameObject val4 = Object.Instantiate<GameObject>(obj, val3, Quaternion.identity);
				NetworkServer.Spawn(val4, (NetworkConnectionToClient)null);
				SpawnedInstances.Add(val4);
				yield return (object)new WaitForSeconds(0.1f);
			}
			PluginMain.Log.LogInfo((object)$"Shop Scout spawned {count} extra item(s) near the shop pedestals ({logContext}).");
		}

		private static float HighestStackedExtraShopItems()
		{
			float num = 0f;
			PlayerProfile[] array = Object.FindObjectsByType<PlayerProfile>((FindObjectsSortMode)0);
			for (int i = 0; i < array.Length; i++)
			{
				float num2 = GameUpgradeState.Get(array[i].steamId, GamePlayerUpgradeType.ExtraShopItems);
				if (num2 > num)
				{
					num = num2;
				}
			}
			return num;
		}
	}
	[HarmonyPatch(typeof(ItemManager), "ServerResetItems")]
	internal static class ExtraShopItemDayResetPatch
	{
		private static void Postfix(ItemManager __instance)
		{
			if (NetworkServer.active)
			{
				ExtraShopItemSpawner.SpawnForNewDay((MonoBehaviour)(object)__instance);
			}
		}
	}
	[HarmonyPatch(typeof(ItemStampManager), "RerollAllItemStamps")]
	internal static class ExtraShopItemRerollPatch
	{
		private static void Postfix(ItemStampManager __instance)
		{
			if (NetworkServer.active)
			{
				ExtraShopItemSpawner.RespawnForReroll((MonoBehaviour)(object)__instance);
			}
		}
	}
	[HarmonyPatch(typeof(ItemStampManager), "RetrieveAndRespawnAllItemStamps")]
	internal static class ExtraShopItemRetrievePatch
	{
		private static void Postfix(ItemStampManager __instance)
		{
			if (NetworkServer.active)
			{
				ExtraShopItemSpawner.RespawnForReroll((MonoBehaviour)(object)__instance);
			}
		}
	}
	[HarmonyPatch(typeof(GameBase), "Payout")]
	internal static class GameOddsUpgradePatch
	{
		private static readonly FieldRef<GameBase, PlayerProfile> InteractingPlayerRef = AccessTools.FieldRefAccess<GameBase, PlayerProfile>("interactingPlayer");

		private static void Prefix(GameBase __instance, ref double multiplier)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active)
			{
				return;
			}
			GamePlayerUpgradeType? gamePlayerUpgradeType = GameTypeMap.ToUpgrade(__instance.GameType);
			if (!gamePlayerUpgradeType.HasValue)
			{
				return;
			}
			PlayerProfile val = InteractingPlayerRef.Invoke(__instance);
			if (!((Object)(object)val == (Object)null))
			{
				float num = GameUpgradeState.Get(val.steamId, gamePlayerUpgradeType.Value);
				if (num != 0f)
				{
					multiplier *= 1.0 + (double)num;
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class GameUpgradeSaveLoadPatch
	{
		private static string SaveDirectoryPath => Path.Combine(Application.persistentDataPath, "Saves");

		internal static string SidecarPathFor(string saveName)
		{
			return Path.Combine(SaveDirectoryPath, saveName + ".moreupgrades.json");
		}

		[HarmonyPatch(typeof(SaveManager), "SaveGame")]
		[HarmonyPostfix]
		private static void AfterSaveGame(SaveManager __instance)
		{
			if (!NetworkServer.active || string.IsNullOrEmpty(__instance.CurrentSaveName))
			{
				return;
			}
			GameUpgradeSaveData gameUpgradeSaveData = new GameUpgradeSaveData();
			Dictionary<ulong, GameUpgradeSaveData.PlayerEntry> dictionary = new Dictionary<ulong, GameUpgradeSaveData.PlayerEntry>();
			foreach (var (key, type, value) in GameUpgradeState.All())
			{
				if (!dictionary.TryGetValue(key, out var value2))
				{
					GameUpgradeSaveData.PlayerEntry obj = new GameUpgradeSaveData.PlayerEntry
					{
						steamId = key.ToString()
					};
					value2 = (dictionary[key] = obj);
					gameUpgradeSaveData.players.Add(value2);
				}
				value2.upgrades.Add(new GameUpgradeSaveData.ValueEntry
				{
					type = type,
					value = value
				});
			}
			try
			{
				if (!Directory.Exists(SaveDirectoryPath))
				{
					Directory.CreateDirectory(SaveDirectoryPath);
				}
				File.WriteAllText(SidecarPathFor(__instance.CurrentSaveName), JsonUtility.ToJson((object)gameUpgradeSaveData, true));
				PluginMain.Log.LogInfo((object)$"Saved {gameUpgradeSaveData.players.Count} player(s) worth of MoreUpgrades values.");
			}
			catch (Exception ex)
			{
				PluginMain.Log.LogError((object)("Failed to save MoreUpgrades values: " + ex.Message));
			}
		}

		[HarmonyPatch(typeof(SaveManager), "LoadGame")]
		[HarmonyPostfix]
		private static void AfterLoadGame(SaveManager __instance)
		{
			if (!NetworkServer.active || string.IsNullOrEmpty(__instance.CurrentSaveName))
			{
				return;
			}
			string path = SidecarPathFor(__instance.CurrentSaveName);
			if (!File.Exists(path))
			{
				return;
			}
			try
			{
				GameUpgradeSaveData gameUpgradeSaveData = JsonUtility.FromJson<GameUpgradeSaveData>(File.ReadAllText(path));
				if (gameUpgradeSaveData?.players == null)
				{
					return;
				}
				int num = 0;
				foreach (GameUpgradeSaveData.PlayerEntry player in gameUpgradeSaveData.players)
				{
					if (string.IsNullOrEmpty(player.steamId) || !ulong.TryParse(player.steamId, out var result))
					{
						continue;
					}
					foreach (GameUpgradeSaveData.ValueEntry upgrade in player.upgrades)
					{
						GameUpgradeState.Set(result, upgrade.type, upgrade.value);
						num++;
					}
				}
				if (num > 0)
				{
					PluginMain.Log.LogInfo((object)$"Restored {num} MoreUpgrades value(s) from the loaded save.");
				}
			}
			catch (Exception ex)
			{
				PluginMain.Log.LogError((object)("Failed to load MoreUpgrades values: " + ex.Message));
			}
		}
	}
	[HarmonyPatch(typeof(ItemDescriptionLocalization), "FetchDescription")]
	internal static class ItemDescriptionLocalizationPatch
	{
		private static bool Prefix(int spawnableId, Action<string> onComplete, ref IEnumerator __result)
		{
			if (!ItemDescriptionRegistry.TryGetDescription(spawnableId, out string description))
			{
				return true;
			}
			onComplete?.Invoke(description);
			__result = NoOp();
			return false;
		}

		private static IEnumerator NoOp()
		{
			yield break;
		}
	}
	[HarmonyPatch(typeof(ItemInteractLocalization), "FetchName")]
	internal static class ItemNameLocalizationPatch
	{
		private static bool Prefix(int spawnableId, Action<string> onComplete, ref IEnumerator __result)
		{
			if (!ItemDescriptionRegistry.TryGetName(spawnableId, out string name))
			{
				return true;
			}
			PluginMain.Log.LogInfo((object)$"ItemNameLocalizationPatch: serving '{name}' for spawnableId {spawnableId}.");
			onComplete?.Invoke(name);
			__result = NoOp();
			return false;
		}

		private static IEnumerator NoOp()
		{
			yield break;
		}
	}
	[HarmonyPatch(typeof(MysteryBox), "GetRandomSpawnableByWeight")]
	internal static class MysteryBoxEnforcementPatch
	{
		private static readonly Random Random = new Random();

		private static readonly FieldInfo? SpawnableListField = AccessTools.Field(typeof(MysteryBox), "spawnableList");

		private static readonly FieldInfo? SpawnableField = ResolveSpawnableEntryField();

		private static void Postfix(MysteryBox __instance, ref SpawnableSO __result)
		{
			if ((Object)(object)__result == (Object)null || ItemEnabledState.IsEnabled(ShopCatalog.KeyForVanilla(__result.spawnableID)) || !(SpawnableListField?.GetValue(__instance) is IEnumerable enumerable))
			{
				return;
			}
			List<SpawnableSO> list = new List<SpawnableSO>();
			foreach (object item in enumerable)
			{
				object? obj = SpawnableField?.GetValue(item);
				SpawnableSO val = (SpawnableSO)((obj is SpawnableSO) ? obj : null);
				if ((Object)(object)val != (Object)null && (Object)(object)val != (Object)(object)__result && ItemEnabledState.IsEnabled(ShopCatalog.KeyForVanilla(val.spawnableID)))
				{
					list.Add(val);
				}
			}
			if (list.Count == 0)
			{
				PluginMain.Log.LogWarning((object)("MysteryBox: no enabled alternative to disabled item '" + __result.spawnableName + "' — spawning it anyway."));
				return;
			}
			SpawnableSO val2 = __result;
			__result = list[Random.Next(list.Count)];
			PluginMain.Log.LogInfo((object)("MysteryBox: replaced disabled item '" + val2.spawnableName + "' with '" + __result.spawnableName + "'."));
		}

		private static FieldInfo? ResolveSpawnableEntryField()
		{
			FieldInfo fieldInfo = AccessTools.Field(typeof(MysteryBox), "spawnableList");
			Type type = (((object)fieldInfo != null && fieldInfo.FieldType.IsGenericType) ? fieldInfo.FieldType.GetGenericArguments().FirstOrDefault() : null);
			if (!(type != null))
			{
				return null;
			}
			return AccessTools.Field(type, "spawnable");
		}
	}
	[HarmonyPatch(typeof(UpgradeManager), "ServerResetAllUpgradesToDefaults")]
	internal static class PersistentModeRestorePatch
	{
		private static void Postfix()
		{
			if (NetworkServer.active && PluginMain.PersistentUpgradesPresent)
			{
				PluginMain.Log.LogInfo((object)"PersistentUpgrades active — MoreUpgrades values carried over the new day unchanged.");
			}
		}
	}
	[HarmonyPatch(typeof(SaveManager), "ResetCurrentSaveToDefaults")]
	internal static class GameUpgradeStateResetPatch
	{
		private static void Prefix(SaveManager __instance)
		{
			if (!NetworkServer.active)
			{
				return;
			}
			GameUpgradeState.ResetAll();
			if (!string.IsNullOrEmpty(__instance.CurrentSaveName))
			{
				try
				{
					string path = GameUpgradeSaveLoadPatch.SidecarPathFor(__instance.CurrentSaveName);
					if (File.Exists(path))
					{
						File.Delete(path);
					}
				}
				catch (Exception ex)
				{
					PluginMain.Log.LogError((object)("Failed to delete stale MoreUpgrades save file: " + ex.Message));
				}
			}
			PluginMain.Log.LogInfo((object)"Cleared MoreUpgrades upgrade values for new save.");
		}
	}
	[HarmonyPatch(typeof(SettingItemBase), "NotifyChanged")]
	internal static class SettingsChangePatch
	{
		private static void Postfix(SettingItemBase __instance)
		{
			ToggleSettingItem val = (ToggleSettingItem)(object)((__instance is ToggleSettingItem) ? __instance : null);
			if (val != null && ItemToggleMenu.IsShopToggleKey(((SettingItemBase)val).key))
			{
				string text = ItemToggleMenu.CatalogKeyFromSettingKey(((SettingItemBase)val).key);
				ItemEnabledState.SetEnabled(text, val.value);
				PluginMain.Log.LogInfo((object)("Shop item '" + text + "' " + (val.value ? "enabled" : "disabled") + "."));
			}
		}
	}
	[HarmonyPatch]
	internal static class SettingsInjectionPatch
	{
		private static readonly FieldRef<LobbyModeDropdownButton, SettingsLayout> ButtonLayoutRef = AccessTools.FieldRefAccess<LobbyModeDropdownButton, SettingsLayout>("settingsLayout");

		private static readonly FieldRef<SettingsLayoutRuntimeUI, SettingsLayout> RuntimeUiLayoutRef = AccessTools.FieldRefAccess<SettingsLayoutRuntimeUI, SettingsLayout>("layout");

		[HarmonyPostfix]
		[HarmonyPatch(typeof(LobbyModeDropdownButton), "Awake")]
		private static void LobbyModeDropdownButton_Awake_Postfix(LobbyModeDropdownButton __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				SettingsLayout val = ButtonLayoutRef.Invoke(__instance);
				if ((Object)(object)val != (Object)null)
				{
					ItemToggleMenu.EnsureInjected(val, "LobbyModeDropdownButton.Awake");
				}
			}
		}

		[HarmonyPrefix]
		[HarmonyPatch(typeof(SettingsLayoutRuntimeUI), "Awake")]
		private static void SettingsLayoutRuntimeUI_Awake_Prefix(SettingsLayoutRuntimeUI __instance)
		{
			if (!((Object)(object)__instance == (Object)null))
			{
				SettingsLayout val = RuntimeUiLayoutRef.Invoke(__instance);
				if ((Object)(object)val != (Object)null)
				{
					ItemToggleMenu.EnsureInjected(val, "SettingsLayoutRuntimeUI.Awake");
				}
			}
		}
	}
	[HarmonyPatch(typeof(SettingsLocalization), "ApplyString")]
	internal static class SettingsLabelLocalizationPatch
	{
		private const string KeyPrefix = "settings.label.moreupgrades.";

		private static bool Prefix(TMP_Text label, string key, string fallback, ref IEnumerator __result)
		{
			if ((Object)(object)label == (Object)null || key == null || !key.StartsWith("settings.label.moreupgrades."))
			{
				return true;
			}
			label.text = fallback;
			__result = NoOp();
			return false;
		}

		private static IEnumerator NoOp()
		{
			yield break;
		}
	}
	[HarmonyPatch(typeof(SettingsLayoutRuntimeUI), "CreateDropdownEntry")]
	internal static class SettingsTooltipPatch
	{
		private static void Postfix(RectTransform parent, SettingItemBase entry)
		{
			if (entry is ToggleSettingItem && ItemToggleMenu.IsShopToggleKey(entry.key) && ((Transform)parent).childCount != 0)
			{
				((Component)((Transform)parent).GetChild(((Transform)parent).childCount - 1)).gameObject.AddComponent<SettingsTooltipTrigger>().Description = ItemToggleMenu.DescriptionForSettingKey(entry.key);
			}
		}
	}
	[HarmonyPatch]
	internal static class ShopSpawnEnforcementPatch
	{
		private unsafe static void Postfix(MMLootTableGameObjectSO lootTable, Vector3 stampPosition, GameObject fallbackPrefab, ref GameObject __result)
		{
			if ((Object)(object)fallbackPrefab == (Object)null)
			{
				return;
			}
			PluginMain.Log.LogInfo((object)("ShopSpawnEnforcementPatch.Postfix: fallback='" + ((Object)fallbackPrefab).name + "' result='" + (((Object)(object)__result != (Object)null) ? ((Object)__result).name : "null") + "'."));
			if ((Object)(object)__result != (Object)null && (Object)(object)__result != (Object)(object)fallbackPrefab)
			{
				GameObject rolledPrefab = __result;
				TryConnectRegisteredItemInfo val = ((IEnumerable<TryConnectRegisteredItemInfo>)TryConnectApi.GetRegisteredItems()).FirstOrDefault((Func<TryConnectRegisteredItemInfo, bool>)((TryConnectRegisteredItemInfo i) => i.IsRegistered && (Object)(object)i.Spawnable != (Object)null && (Object)(object)i.Spawnable.prefab == (Object)(object)rolledPrefab));
				if (val != null && !ItemEnabledState.IsEnabled(ShopCatalog.KeyForMod(val.OwnerGuid, val.Key)))
				{
					__result = fallbackPrefab;
				}
			}
			else if (IsDisabledVanillaItem(fallbackPrefab))
			{
				List<(string, string, GameObject, bool)> list = (from r in TryConnectInternals.GetReplacements(fallbackPrefab)
					where r.IsEnabled
					select r).ToList();
				if (list.Count != 0)
				{
					string text = (((Object)(object)lootTable != (Object)null) ? ((Object)lootTable).name : "ItemStamp");
					Random random = new Random((((object)(*(Vector3*)(&stampPosition))/*cast due to .constrained prefix*/).GetHashCode() * 397) ^ (text.GetHashCode() * 31 + ((Object)fallbackPrefab).name.GetHashCode()));
					(string, string, GameObject, bool) tuple = list[random.Next(list.Count)];
					__result = tuple.Item3;
					PluginMain.Log.LogInfo((object)("GetShopReplacement's roll missed every registered item for '" + ((Object)fallbackPrefab).name + "' — forced enabled replacement '" + tuple.Item2 + "' instead of the disabled vanilla fallback."));
				}
			}
		}

		private static bool IsDisabledVanillaItem(GameObject prefab)
		{
			SpawnableSettings val = Resources.Load<SpawnableSettings>("SpawnableSettings");
			if (val?.spawnables == null)
			{
				return false;
			}
			foreach (SpawnableSO spawnable in val.spawnables)
			{
				if ((Object)(object)spawnable != (Object)null && (Object)(object)spawnable.prefab == (Object)(object)prefab)
				{
					return !ItemEnabledState.IsEnabled(ShopCatalog.KeyForVanilla(spawnable.spawnableID));
				}
			}
			return false;
		}

		private static MethodBase? TargetMethod()
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			foreach (Assembly assembly in assemblies)
			{
				if (assembly.GetName().Name.Contains("TryConnect"))
				{
					Type type = assembly.GetType("TryConnect.RuntimeItemRegistry");
					if (type != null)
					{
						return AccessTools.Method(type, "GetShopReplacement", (Type[])null, (Type[])null);
					}
				}
			}
			PluginMain.Log.LogWarning((object)"ShopSpawnEnforcementPatch: could not find TryConnect.RuntimeItemRegistry.GetShopReplacement — the shop item toggle menu will no longer be able to block disabled mod items from spawning. This usually means an incompatible TryConnect update; everything else in this mod is unaffected.");
			return null;
		}
	}
	[HarmonyPatch(typeof(UpgradeManager), "UserCode_RpcClearUpgradeUI")]
	internal static class UpgradeHudClearPatch
	{
		private static void Postfix()
		{
			if (!PluginMain.PersistentUpgradesPresent)
			{
				UpgradeHudSync.Clear();
			}
		}
	}
	[HarmonyPatch(typeof(ItemStampManager), "GetUniqueLoot", new Type[]
	{
		typeof(MMLootTableGameObjectSO),
		typeof(Vector3)
	})]
	internal static class VanillaShopEnforcementPatch
	{
		[HarmonyPriority(0)]
		private static void Postfix(ItemStampManager __instance, MMLootTableGameObjectSO lootTable, Vector3 stampPosition, ref GameObject __result)
		{
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			if (!NetworkServer.active || (Object)(object)__result == (Object)null || ((MMLootTable<MMLootGameObject, GameObject>)(object)lootTable?.LootTable)?.ObjectsToLoot == null)
			{
				return;
			}
			if (!TryDescribeFinalResult(__result, out string description, out bool isEnabled))
			{
				PluginMain.Log.LogInfo((object)("VanillaShopEnforcementPatch: '" + ((Object)__result).name + "' is not a recognized vanilla or mod catalog entry — skipping enforcement."));
				return;
			}
			PluginMain.Log.LogInfo((object)$"VanillaShopEnforcementPatch: final pick '{description}' isEnabled={isEnabled}.");
			if (!isEnabled)
			{
				GameObject val = PickEnabledAlternative(lootTable, stampPosition, __result);
				if ((Object)(object)val != (Object)null)
				{
					__result = val;
					PluginMain.Log.LogInfo((object)("Replaced disabled item '" + description + "' with '" + ((Object)val).name + "' in the shop."));
				}
				else
				{
					PluginMain.Log.LogWarning((object)("Loot table '" + ((Object)lootTable).name + "' has no enabled alternative to '" + description + "' — spawning it anyway."));
				}
			}
		}

		private static bool TryDescribeFinalResult(GameObject result, out string description, out bool isEnabled)
		{
			if (BuildVanillaLookup().TryGetValue(result, out SpawnableSO value))
			{
				description = $"{value.spawnableName} (id={value.spawnableID})";
				isEnabled = ItemEnabledState.IsEnabled(ShopCatalog.KeyForVanilla(value.spawnableID));
				return true;
			}
			TryConnectRegisteredItemInfo[] registeredItems = TryConnectApi.GetRegisteredItems();
			foreach (TryConnectRegisteredItemInfo val in registeredItems)
			{
				if (val.IsRegistered && (Object)(object)val.Spawnable != (Object)null && (Object)(object)val.Spawnable.prefab == (Object)(object)result)
				{
					description = val.DisplayName;
					isEnabled = ItemEnabledState.IsEnabled(ShopCatalog.KeyForMod(val.OwnerGuid, val.Key));
					return true;
				}
			}
			description = string.Empty;
			isEnabled = false;
			return false;
		}

		private static Dictionary<GameObject, SpawnableSO> BuildVanillaLookup()
		{
			Dictionary<GameObject, SpawnableSO> dictionary = new Dictionary<GameObject, SpawnableSO>();
			SpawnableSettings val = Resources.Load<SpawnableSettings>("SpawnableSettings");
			if (val?.spawnables == null)
			{
				return dictionary;
			}
			foreach (SpawnableSO spawnable in val.spawnables)
			{
				if ((Object)(object)spawnable != (Object)null && (Object)(object)spawnable.prefab != (Object)null && !dictionary.ContainsKey(spawnable.prefab))
				{
					dictionary[spawnable.prefab] = spawnable;
				}
			}
			return dictionary;
		}

		private unsafe static GameObject? PickEnabledAlternative(MMLootTableGameObjectSO lootTable, Vector3 stampPosition, GameObject excluded)
		{
			Dictionary<GameObject, SpawnableSO> dictionary = BuildVanillaLookup();
			List<GameObject> list = new List<GameObject>();
			foreach (MMLootGameObject item in ((MMLootTable<MMLootGameObject, GameObject>)(object)lootTable.LootTable).ObjectsToLoot)
			{
				if ((Object)(object)((MMLoot<GameObject>)(object)item)?.Loot == (Object)null || (Object)(object)((MMLoot<GameObject>)(object)item).Loot == (Object)(object)excluded)
				{
					continue;
				}
				if (!dictionary.TryGetValue(((MMLoot<GameObject>)(object)item).Loot, out var value))
				{
					list.Add(((MMLoot<GameObject>)(object)item).Loot);
					continue;
				}
				if (ItemEnabledState.IsEnabled(ShopCatalog.KeyForVanilla(value.spawnableID)))
				{
					list.Add(((MMLoot<GameObject>)(object)item).Loot);
					continue;
				}
				(string, string, GameObject, bool) tuple = TryConnectInternals.GetReplacements(((MMLoot<GameObject>)(object)item).Loot).FirstOrDefault<(string, string, GameObject, bool)>(((string OwnerGuid, string Key, GameObject MarkerPrefab, bool IsEnabled) r) => r.IsEnabled);
				if ((Object)(object)tuple.Item3 != (Object)null)
				{
					list.Add(tuple.Item3);
				}
			}
			if (list.Count == 0)
			{
				return null;
			}
			SeededRandomManager val = Object.FindFirstObjectByType<SeededRandomManager>();
			GameManager val2 = Object.FindFirstObjectByType<GameManager>();
			int num = (((Object)(object)val != (Object)null) ? val.CurrentSeed : 0);
			int num2 = (((Object)(object)val2 != (Object)null) ? val2.successfulQuota : 0);
			Random random = new Random((((object)(*(Vector3*)(&stampPosition))/*cast due to .constrained prefix*/).GetHashCode() * 397) ^ (num * 31 + num2));
			return list[random.Next(list.Count)];
		}
	}
}
namespace MoreUpgrades.Menu
{
	internal static class ItemEnabledState
	{
		private const string ConfigSection = "ShopItems";

		private const string ConfigDescription = "Whether this shop item can appear in the shop. Set via the in-game settings menu.";

		private static readonly ConcurrentDictionary<string, ConfigEntry<bool>> Entries = new ConcurrentDictionary<string, ConfigEntry<bool>>();

		public static bool IsEnabled(string catalogToggleKey)
		{
			return GetEntry(catalogToggleKey).Value;
		}

		public static void SetEnabled(string catalogToggleKey, bool isEnabled)
		{
			GetEntry(catalogToggleKey).Value = isEnabled;
		}

		public static bool HasSavedValue(string catalogToggleKey)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			if (Entries.ContainsKey(catalogToggleKey))
			{
				return true;
			}
			return PluginMain.ConfigFile.ContainsKey(new ConfigDefinition("ShopItems", SanitizeConfigKey(catalogToggleKey)));
		}

		private static ConfigEntry<bool> GetEntry(string catalogToggleKey)
		{
			return Entries.GetOrAdd(catalogToggleKey, (Func<string, ConfigEntry<bool>>)((string key) => PluginMain.ConfigFile.Bind<bool>("ShopItems", SanitizeConfigKey(key), true, "Whether this shop item can appear in the shop. Set via the in-game settings menu.")));
		}

		private static string SanitizeConfigKey(string key)
		{
			return key.Replace('=', '_');
		}
	}
	internal static class ItemToggleMenu
	{
		private const string HeaderKey = "moreupgrades.section";

		private const string StatusKey = "moreupgrades.status";

		private const string ToggleKeyPrefix = "moreupgrades.toggle.";

		private const string NoDescriptionFallback = "No description available.";

		private static readonly HashSet<string> DefaultDisabledCatalogKeys = new HashSet<string> { ShopCatalog.KeyForMod("com.Try-4646.TryConnect", "ticket_fizz") };

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

		private static string StatusLabel
		{
			get
			{
				if (!PluginMain.PersistentUpgradesPresent)
				{
					return "\"PersistentUpgrades\" not installed — upgrades from \"MoreUpgrades\" reset each day.";
				}
				return "\"PersistentUpgrades\" detected — upgrades from \"MoreUpgrades\" are permanent and lobby-shared.";
			}
		}

		public static string SettingKeyFor(string catalogToggleKey)
		{
			return "moreupgrades.toggle." + catalogToggleKey;
		}

		public static bool IsShopToggleKey(string? key)
		{
			return key?.StartsWith("moreupgrades.toggle.") ?? false;
		}

		public static string CatalogKeyFromSettingKey(string settingKey)
		{
			return settingKey.Substring("moreupgrades.toggle.".Length);
		}

		public static string DescriptionForSettingKey(string settingKey)
		{
			if (!DescriptionsBySettingKey.TryGetValue(settingKey, out string value))
			{
				return "No description available.";
			}
			return value;
		}

		public static bool EnsureInjected(SettingsLayout layout, string source)
		{
			if ((Object)(object)layout == (Object)null || layout.tabs == null || layout.tabs.Count == 0)
			{
				return false;
			}
			Tab val = FindTargetTab(layout);
			if (val == null)
			{
				return false;
			}
			Tab val2 = val;
			if (val2.entries == null)
			{
				val2.entries = new List<SettingItemBase>();
			}
			int num = 0;
			num += EnsureTitleEntry(val.entries, "moreupgrades.section", "\"MoreUpgrades\" — Shop Items");
			num += EnsureTitleEntry(val.entries, "moreupgrades.status", StatusLabel);
			RefreshStatusLabel(val.entries);
			foreach (ShopCatalogEntry item in ShopCatalog.GetAll())
			{
				string key = SettingKeyFor(item.ToggleKey);
				DescriptionsBySettingKey[key] = (string.IsNullOrWhiteSpace(item.Description) ? "No description available." : item.Description);
				if (!ItemEnabledState.HasSavedValue(item.ToggleKey) && DefaultDisabledCatalogKeys.Contains(item.ToggleKey))
				{
					ItemEnabledState.SetEnabled(item.ToggleKey, isEnabled: false);
				}
				bool defaultEnabled = ItemEnabledState.IsEnabled(item.ToggleKey);
				bool flag = EnsureToggleEntry(val.entries, key, item.DisplayName, defaultEnabled) > 0;
				num += (flag ? 1 : 0);
			}
			if (num > 0)
			{
				PluginMain.Log.LogInfo((object)$"Injected {num} MoreUpgrades settings entries from {source}. Tab='{val.tabName}'.");
			}
			return true;
		}

		private static Tab? FindTargetTab(SettingsLayout layout)
		{
			foreach (Tab tab in layout.tabs)
			{
				if (tab.entries != null && tab.entries.Any(IsLobbyModeEntry))
				{
					return tab;
				}
			}
			foreach (Tab tab2 in layout.tabs)
			{
				if (tab2.entries != null && tab2.entries.Count != 0 && !string.IsNullOrWhiteSpace(tab2.tabName) && string.Equals(tab2.tabName.Trim(), "Settings", StringComparison.OrdinalIgnoreCase))
				{
					return tab2;
				}
			}
			return null;
		}

		private static bool IsLobbyModeEntry(SettingItemBase entry)
		{
			if (!(entry is DropdownSettingItem) || entry.key == "moreupgrades.section")
			{
				return false;
			}
			return string.Equals(entry.label?.Trim(), "Lobby Mode", StringComparison.OrdinalIgnoreCase);
		}

		private static void RefreshStatusLabel(ICollection<SettingItemBase> entries)
		{
			TitleSettingItem val = entries.OfType<TitleSettingItem>().FirstOrDefault((Func<TitleSettingItem, bool>)((TitleSettingItem entry) => ((SettingItemBase)entry).key == "moreupgrades.status"));
			if ((Object)(object)val != (Object)null)
			{
				((SettingItemBase)val).label = StatusLabel;
			}
		}

		private static int EnsureTitleEntry(ICollection<SettingItemBase> entries, string key, string label)
		{
			if (entries.Any((SettingItemBase entry) => entry.key == key))
			{
				return 0;
			}
			TitleSettingItem val = ScriptableObject.CreateInstance<TitleSettingItem>();
			((Object)val).hideFlags = (HideFlags)61;
			((SettingItemBase)val).key = key;
			((SettingItemBase)val).label = label;
			entries.Add((SettingItemBase)(object)val);
			return 1;
		}

		private static int EnsureToggleEntry(ICollection<SettingItemBase> entries, string key, string label, bool defaultEnabled)
		{
			if (entries.Any((SettingItemBase entry) => entry.key == key))
			{
				return 0;
			}
			ToggleSettingItem val = ScriptableObject.CreateInstance<ToggleSettingItem>();
			((Object)val).hideFlags = (HideFlags)61;
			((SettingItemBase)val).key = key;
			((SettingItemBase)val).label = label;
			val.value = defaultEnabled;
			val.defaultValue = defaultEnabled;
			val.loadOnSceneStart = false;
			entries.Add((SettingItemBase)(object)val);
			return 1;
		}
	}
	internal static class SettingsTooltip
	{
		private const float MaxWidth = 420f;

		private const float Padding = 10f;

		private const float CursorOffset = 36f;

		private static Canvas? _canvas;

		private static RectTransform? _root;

		private static TextMeshProUGUI? _text;

		public static void Show(string message, TMP_FontAsset? fontToMatch, Vector2 screenPosition)
		{
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			EnsureBuilt(fontToMatch);
			if (!((Object)(object)_text == (Object)null) && !((Object)(object)_root == (Object)null))
			{
				((TMP_Text)_text).text = message;
				((Component)_root).gameObject.SetActive(true);
				SetPosition(screenPosition);
			}
		}

		public static void Hide()
		{
			if ((Object)(object)_root != (Object)null)
			{
				((Component)_root).gameObject.SetActive(false);
			}
		}

		public static void SetPosition(Vector2 screenPosition)
		{
			//IL_0024: 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_0041: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_root == (Object)null) && ((Component)_root).gameObject.activeSelf)
			{
				((Transform)_root).position = new Vector3(screenPosition.x + 36f, screenPosition.y + 36f, 0f);
			}
		}

		private static void EnsureBuilt(TMP_FontAsset? fontToMatch)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: 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_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected O, but got Unknown
			//IL_00d4: 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)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: 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)
			//IL_015e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0174: 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_017f: Unknown result type (might be due to invalid IL or missing references)
			//IL_018a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0221: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_root != (Object)null)
			{
				if ((Object)(object)fontToMatch != (Object)null && (Object)(object)_text != (Object)null)
				{
					((TMP_Text)_text).font = fontToMatch;
				}
				return;
			}
			GameObject val = new GameObject("MoreUpgrades_TooltipCanvas");
			Object.DontDestroyOnLoad((Object)(object)val);
			_canvas = val.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 32767;
			val.AddComponent<CanvasScaler>();
			((Behaviour)val.AddComponent<GraphicRaycaster>()).enabled = false;
			GameObject val2 = new GameObject("MoreUpgrades_Tooltip", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			val2.transform.SetParent(val.transform, false);
			_root = (RectTransform)val2.transform;
			_root.pivot = new Vector2(0f, 1f);
			_root.sizeDelta = new Vector2(420f, 40f);
			Image component = val2.GetComponent<Image>();
			((Graphic)component).color = new Color(0.05f, 0.05f, 0.06f, 0.95f);
			((Graphic)component).raycastTarget = false;
			GameObject val3 = new GameObject("Text", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val3.transform.SetParent(val2.transform, false);
			RectTransform val4 = (RectTransform)val3.transform;
			val4.anchorMin = Vector2.zero;
			val4.anchorMax = Vector2.one;
			val4.offsetMin = new Vector2(10f, 10f);
			val4.offsetMax = new Vector2(-10f, -10f);
			_text = val3.GetComponent<TextMeshProUGUI>();
			((TMP_Text)_text).fontSize = 22f;
			((Graphic)_text).color = Color.white;
			((TMP_Text)_text).textWrappingMode = (TextWrappingModes)1;
			((Graphic)_text).raycastTarget = false;
			if ((Object)(object)fontToMatch != (Object)null)
			{
				((TMP_Text)_text).font = fontToMatch;
			}
			ContentSizeFitter obj = val2.AddComponent<ContentSizeFitter>();
			obj.horizontalFit = (FitMode)0;
			obj.verticalFit = (FitMode)2;
			((Component)_text).GetComponent<RectTransform>().sizeDelta = new Vector2(400f, 0f);
			val2.SetActive(false);
		}
	}
	internal sealed class SettingsTooltipTrigger : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerMoveHandler, IPointerExitHandler
	{
		public string? Description { get; set; }

		private void Awake()
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			Graphic componentInChildren = ((Component)this).GetComponentInChildren<Graphic>(true);
			if (componentInChildren == null || !componentInChildren.raycastTarget)
			{
				((Graphic)((Component)this).gameObject.AddComponent<Image>()).color = Color.clear;
			}
		}

		public void OnPointerEnter(PointerEventData eventData)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrWhiteSpace(Description))
			{
				TMP_Text componentInChildren = ((Component)this).GetComponentInChildren<TMP_Text>(true);
				TMP_FontAsset fontToMatch = ((componentInChildren != null) ? componentInChildren.font : null);
				SettingsTooltip.Show(Description, fontToMatch, eventData.position);
			}
		}

		public void OnPointerMove(PointerEventData eventData)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			SettingsTooltip.SetPosition(eventData.position);
		}

		public void OnPointerExit(PointerEventData eventData)
		{
			SettingsTooltip.Hide();
		}

		private void OnDisable()
		{
			SettingsTooltip.Hide();
		}
	}
	internal readonly struct ShopCatalogEntry
	{
		public readonly string ToggleKey;

		public readonly string DisplayName;

		public readonly string Description;

		public readonly SpawnableSO Spawnable;

		public readonly bool IsVanilla;

		public ShopCatalogEntry(string toggleKey, string displayName, string description, SpawnableSO spawnable, bool isVanilla)
		{
			ToggleKey = toggleKey;
			DisplayName = displayName;
			Description = description;
			Spawnable = spawnable;
			IsVanilla = isVanilla;
		}
	}
	internal static class ShopCatalog
	{
		private const string VanillaKeyPrefix = "vanilla.";

		private const string ModKeyPrefix = "mod.";

		public static string KeyForVanilla(int spawnableId)
		{
			return "vanilla." + spawnableId;
		}

		public static string KeyForMod(string ownerGuid, string itemKey)
		{
			return "mod." + ownerGuid + ":" + itemKey;
		}

		public static bool IsVanillaKey(string toggleKey)
		{
			return toggleKey.StartsWith("vanilla.");
		}

		public static bool TryParseVanillaSpawnableId(string toggleKey, out int spawnableId)
		{
			if (IsVanillaKey(toggleKey) && int.TryParse(toggleKey.Substring("vanilla.".Length), out spawnableId))
			{
				return true;
			}
			spawnableId = 0;
			return false;
		}

		public static IReadOnlyList<ShopCatalogEntry> GetAll()
		{
			List<ShopCatalogEntry> list = new List<ShopCatalogEntry>();
			HashSet<int> hashSet = new HashSet<int>();
			ItemDescriptionSettings descriptionSettings = Resources.Load<ItemDescriptionSettings>("ItemDescriptionSettings");
			TryConnectRegisteredItemInfo[] registeredItems = TryConnectApi.GetRegisteredItems();
			foreach (TryConnectRegisteredItemInfo val in registeredItems)
			{
				if (val.IsRegistered && !((Object)(object)val.Spawnable == (Object)null))
				{
					hashSet.Add(val.SpawnableId);
					string description = ResolveDescription(descriptionSettings, val.Spawnable, val.Description);
					list.Add(new ShopCatalogEntry(KeyForMod(val.OwnerGuid, val.Key), val.DisplayName, description, val.Spawnable, isVanilla: false));
				}
			}
			SpawnableSettings val2 = Resources.Load<SpawnableSettings>("SpawnableSettings");
			if (val2?.spawnables != null)
			{
				foreach (SpawnableSO spawnable in val2.spawnables)
				{
					if (!((Object)(object)spawnable == (Object)null) && !((Object)(object)spawnable.prefab == (Object)null) && !hashSet.Contains(spawnable.spawnableID) && !((Object)(object)spawnable.prefab.GetComponent<Item>() == (Object)null))
					{
						hashSet.Add(spawnable.spawnableID);
						string displayName = (string.IsNullOrWhiteSpace(spawnable.spawnableName) ? ((Object)spawnable.prefab).name : spawnable.spawnableName);
						string description2 = ResolveDescription(descriptionSettings, spawnable, spawnable.spawnableDescription);
						list.Add(new ShopCatalogEntry(KeyForVanilla(spawnable.spawnableID), displayName, description2, spawnable, isVanilla: true));
					}
				}
			}
			return list.OrderBy((ShopCatalogEntry e) => e.DisplayName).ToList();
		}

		private static string ResolveDescription(ItemDescriptionSettings? descriptionSettings, SpawnableSO spawnable, string fallback)
		{
			string text = (((Object)(object)descriptionSettings != (Object)null) ? descriptionSettings.GetDescription(spawnable) : null);
			if (!string.IsNullOrWhiteSpace(text))
			{
				return text;
			}
			return fallback;
		}
	}
	internal static class TryConnectInternals
	{
		private static readonly Type? RuntimeItemRegistryType = FindType("TryConnect.RuntimeItemRegistry");

		private static readonly FieldInfo? DefinitionsByBasePrefabField = RuntimeItemRegistryType?.GetField("DefinitionsByBasePrefab", BindingFlags.Static | BindingFlags.NonPublic);

		private static readonly Type? CustomItemDefinitionType = RuntimeItemRegistryType?.GetNestedType("CustomItemDefinition", BindingFlags.NonPublic);

		private static readonly FieldInfo? OwnerGuidField = CustomItemDefinitionType?.GetField("OwnerGuid", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo? KeyField = CustomItemDefinitionType?.GetField("Key", BindingFlags.Instance | BindingFlags.NonPublic);

		private static readonly FieldInfo? MarkerPrefabField = CustomItemDefinitionType?.GetField("MarkerPrefab", BindingFlags.Instance | BindingFlags.NonPublic);

		private static Type? FindType(string fullName)
		{
			Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
			for (int i = 0; i < assemblies.Length; i++)
			{
				Type type = assemblies[i].GetType(fullName);
				if (type != null)
				{
					return type;
				}
			}
			return null;
		}

		public static IReadOnlyList<(string OwnerGuid, string Key, GameObject MarkerPrefab, bool IsEnabled)> GetReplacements(GameObject basePrefab)
		{
			try
			{
				if (DefinitionsByBasePrefabField == null || OwnerGuidField == null || KeyField == null || MarkerPrefabField == null)
				{
					return Array.Empty<(string, string, GameObject, bool)>();
				}
				if (!(DefinitionsByBasePrefabField.GetValue(null) is IDictionary dictionary) || !dictionary.Contains(basePrefab) || !(dictionary[basePrefab] is IEnumerable enumerable))
				{
					return Array.Empty<(string, string, GameObject, bool)>();
				}
				List<(string, string, GameObject, bool)> list = new List<(string, string, GameObject, bool)>();
				foreach (object item2 in enumerable)
				{
					string text = OwnerGuidField.GetValue(item2) as string;
					string text2 = KeyField.GetValue(item2) as string;
					object? value = MarkerPrefabField.GetValue(item2);
					GameObject val = (GameObject)((value is GameObject) ? value : null);
					if (text != null && text2 != null && !((Object)(object)val == (Object)null))
					{
						bool item = ItemEnabledState.IsEnabled(ShopCatalog.KeyForMod(text, text2));
						list.Add((text, text2, val, item));
					}
				}
				return list;
			}
			catch (Exception ex)
			{
				PluginMain.Log.LogWarning((object)("TryConnectInternals.GetReplacements: reflection into TryConnect internals failed: " + ex.Message));
				return Array.Empty<(string, string, GameObject, bool)>();
			}
		}

		public static bool HasEnabledReplacement(GameObject basePrefab)
		{
			return GetReplacements(basePrefab).Any<(string, string, GameObject, bool)>(((string OwnerGuid, string Key, GameObject MarkerPrefab, bool IsEnabled) r) => r.IsEnabled);
		}
	}
	internal static class UpgradeHudSync
	{
		private static readonly Dictionary<GamePlayerUpgradeType, UpgradeEntryUI> Entries = new Dictionary<GamePlayerUpgradeType, UpgradeEntryUI>();

		private static readonly Dictionary<GamePlayerUpgradeType, float> LastKnownTotals = new Dictionary<GamePlayerUpgradeType, float>();

		private static Transform? _lastEntryParent;

		private static readonly Dictionary<GamePlayerUpgradeType, (string Label, string Description)> Display = new Dictionary<GamePlayerUpgradeType, (string, string)>
		{
			[GamePlayerUpgradeType.SlotsLuck] = ("Slots Luck", "Boosts winnings at Slots"),
			[GamePlayerUpgradeType.RouletteLuck] = ("Roulette Reader", "Boosts winnings at Roulette"),
			[GamePlayerUpgradeType.WheelLuck] = ("Wheel Whisperer", "Boosts winnings at Money Wheel and Wheel of Fortune"),
			[GamePlayerUpgradeType.BlackjackLuck] = ("Card Counter", "Boosts winnings at Blackjack"),
			[GamePlayerUpgradeType.PokerLuck] = ("Poker Face", "Boosts winnings at Poker"),
			[GamePlayerUpgradeType.BaccaratLuck] = ("Baccarat Instinct", "Boosts winnings at Baccarat"),
			[GamePlayerUpgradeType.CrapsLuck] = ("Loaded Dice", "Boosts winnings at Craps"),
			[GamePlayerUpgradeType.MinesweeperLuck] = ("Steady Hands", "Boosts winnings at Minesweeper and Dragon Tower"),
			[GamePlayerUpgradeType.CrashLuck] = ("Crash Sense", "Boosts winnings at Crash"),
			[GamePlayerUpgradeType.PlinkoLuck] = ("Plinko Precision", "Boosts winnings at Plinko"),
			[GamePlayerUpgradeType.KenoLuck] = ("Keno Clairvoyance", "Boosts winnings at Keno"),
			[GamePlayerUpgradeType.HiLoLuck] = ("Hi-Lo Hunch", "Boosts winnings at Hi-Lo"),
			[GamePlayerUpgradeType.DuckRaceLuck] = ("Duck Whisperer", "Boosts winnings at Duck Race"),
			[GamePlayerUpgradeType.CrossyRoadLuck] = ("Crossy Confidence", "Boosts winnings at Crossy Road"),
			[GamePlayerUpgradeType.CoinFlipLuck] = ("Coin Sense", "Boosts winnings at Coin Flip"),
			[GamePlayerUpgradeType.ExtraShopItems] = ("Shop Scout", "Adds extra items to the shop")
		};

		public static void OnUpgradeChanged(ulong steamId, GamePlayerUpgradeType type, float newTotal)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if (SteamUser.GetSteamID().m_SteamID != steamId)
			{
				return;
			}
			if (newTotal <= 0f)
			{
				LastKnownTotals.Remove(type);
			}
			else
			{
				LastKnownTotals[type] = newTotal;
			}
			UpgradeUI instance = MonoSingleton<UpgradeUI>.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return;
			}
			Transform val = UpgradeUiAccess.EntryParent(instance);
			UpgradeEntryUI val2 = UpgradeUiAccess.EntryTemplate(instance);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return;
			}
			if (_lastEntryParent != val)
			{
				Entries.Clear();
				_lastEntryParent = val;
				foreach (var (gamePlayerUpgradeType2, newTotal2) in LastKnownTotals)
				{
					if (gamePlayerUpgradeType2 != type)
					{
						Draw(val, val2, gamePlayerUpgradeType2, newTotal2);
					}
				}
			}
			if (newTotal <= 0f)
			{
				if (Entries.TryGetValue(type, out UpgradeEntryUI value) && (Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
				Entries.Remove(type);
			}
			else
			{
				Draw(val, val2, type, newTotal);
			}
		}

		private static void Draw(Transform parent, UpgradeEntryUI template, GamePlayerUpgradeType type, float newTotal)
		{
			if (Display.TryGetValue(type, out (string, string) value))
			{
				if (!Entries.TryGetValue(type, out UpgradeEntryUI value2) || (Object)(object)value2 == (Object)null)
				{
					value2 = Object.Instantiate<UpgradeEntryUI>(template, parent);
					Entries[type] = value2;
				}
				string formattedValue = ((type == GamePlayerUpgradeType.ExtraShopItems) ? $"+{newTotal:0.#}" : ((newTotal * 100f).ToString("0.#") + "%"));
				UpgradeEntryUiText.Set(value2, value.Item1, value.Item2, formattedValue);
			}
		}

		public static void Clear()
		{
			foreach (UpgradeEntryUI value in Entries.Values)
			{
				if ((Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)((Component)value).gameObject);
				}
			}
			Entries.Clear();
			LastKnownTotals.Clear();
		}
	}
	internal static class UpgradeUiAccess
	{
		private static readonly FieldRef<UpgradeUI, Transform> EntryParentField = AccessTools.FieldRefAccess<UpgradeUI, Transform>("entryParent");

		private static readonly FieldRef<UpgradeUI, UpgradeEntryUI> EntryTemplateField = AccessTools.FieldRefAccess<UpgradeUI, UpgradeEntryUI>("upgradeEntryUI");

		public static Transform EntryParent(UpgradeUI ui)
		{
			return UpgradeHudScroll.EnsureScrollable(EntryParentField.Invoke(ui));
		}

		public static UpgradeEntryUI EntryTemplate(UpgradeUI ui)
		{
			return EntryTemplateField.Invoke(ui);
		}
	}
	internal static class UpgradeHudScroll
	{
		private const float VisibleHeight = 548.4f;

		private const float ScrollbarWidth = 12f;

		private static Transform? _wrappedSource;

		private static Transform? _scrollableParent;

		public static Transform EnsureScrollable(Transform entryParent)
		{
			//IL_0055: 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_007f: Expected O, but got Unknown
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Expected O, but got Unknown
			//IL_00a1: 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_00bb: 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_00e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0122: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: 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)
			//IL_0134: Expected O, but got Unknown
			//IL_014a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: 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_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0206: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Unknown result type (might be due to invalid IL or missing references)
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0254: Expected O, but got Unknown
			//IL_025b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Expected O, but got Unknown
			//IL_0278: Unknown result type (might be due to invalid IL or missing references)
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_031a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_032c: Expected O, but got Unknown
			//IL_0338: Unknown result type (might be due to invalid IL or missing references)
			//IL_0344: Unknown result type (might be due to invalid IL or missing references)
			//IL_0350: Unknown result type (might be due to invalid IL or missing references)
			//IL_0377: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_wrappedSource == (Object)(object)entryParent && (Object)(object)_scrollableParent != (Object)null)
			{
				return _scrollableParent;
			}
			Transform parent = entryParent.parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			Transform val2 = ((val != null) ? ((Transform)val).parent : null);
			if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
			{
				return entryParent;
			}
			int siblingIndex = ((Transform)val).GetSiblingIndex();
			float x = val.sizeDelta.x;
			GameObject val3 = new GameObject("MoreUpgrades_UpgradeScrollViewport", new Type[1] { typeof(RectTransform) });
			RectTransform val4 = (RectTransform)val3.transform;
			((Transform)val4).SetParent(val2, false);
			((Transform)val4).SetSiblingIndex(siblingIndex);
			val4.anchorMin = val.anchorMin;
			val4.anchorMax = val.anchorMax;
			val4.pivot = val.pivot;
			val4.anchoredPosition = val.anchoredPosition;
			val4.sizeDelta = new Vector2(x + 4f + 12f, 548.4f);
			GameObject val5 = new GameObject("MoreUpgrades_UpgradeScrollMask", new Type[3]
			{
				typeof(RectTransform),
				typeof(RectMask2D),
				typeof(Image)
			});
			RectTransform val6 = (RectTransform)val5.transform;
			((Transform)val6).SetParent((Transform)(object)val4, false);
			val6.anchorMin = new Vector2(0f, 0f);
			val6.anchorMax = new Vector2(0f, 1f);
			val6.pivot = new Vector2(0f, 1f);
			val6.anchoredPosition = Vector2.zero;
			val6.sizeDelta = new Vector2(x, 0f);
			Image component = val5.GetComponent<Image>();
			((Graphic)component).color = new Color(0f, 0f, 0f, 0f);
			((Graphic)component).raycastTarget = true;
			((Transform)val).SetParent((Transform)(object)val6, false);
			val.anchorMin = new Vector2(0f, 1f);
			val.anchorMax = new Vector2(0f, 1f);
			val.pivot = new Vector2(0f, 1f);
			val.anchoredPosition = Vector2.zero;
			GameObject val7 = new GameObject("MoreUpgrades_UpgradeScrollbar", new Type[3]
			{
				typeof(RectTransform),
				typeof(Image),
				typeof(Scrollbar)
			});
			RectTransform val8 = (RectTransform)val7.transform;
			((Transform)val8).SetParent((Transform)(object)val4, false);
			val8.anchorMin = new Vector2(1f, 0f);
			val8.anchorMax = new Vector2(1f, 1f);
			val8.pivot = new Vector2(1f, 1f);
			val8.sizeDelta = new Vector2(12f, 0f);
			val8.anchoredPosition = Vector2.zero;
			((Graphic)val7.GetComponent<Image>()).color = new Color(1f, 1f, 1f, 0.15f);
			GameObject val9 = new GameObject("Handle", new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			RectTransform val10 = (RectTransform)val9.transform;
			((Transform)val10).SetParent((Transform)(object)val8, false);
			val10.anchorMin = Vector2.zero;
			val10.anchorMax = Vector2.one;
			val10.sizeDelta = Vector2.zero;
			Image component2 = val9.GetComponent<Image>();
			((Graphic)component2).color = new Color(1f, 1f, 1f, 0.6f);
			Scrollbar component3 = val7.GetComponent<Scrollbar>();
			component3.direction = (Direction)2;
			((Selectable)component3).targetGraphic = (Graphic)(object)component2;
			component3.handleRect = val10;
			ScrollRect val11 = val3.AddComponent<ScrollRect>();
			val11.content = val;
			val11.viewport = val6;
			val11.horizontal = false;
			val11.vertical = true;
			val11.verticalScrollbar = component3;
			val11.verticalScrollbarVisibility = (ScrollbarVisibility)1;
			val11.movementType = (MovementType)2;
			val11.scrollSensitivity = 20f;
			val3.AddComponent<UpgradeHudWheelScroll>().Target = val11;
			_wrappedSource = entryParent;
			_scrollableParent = entryParent;
			return entryParent;
		}
	}
	internal sealed class UpgradeHudWheelScroll : MonoBehaviour
	{
		private const float PixelsPerRawUnit = 64.05f;

		public ScrollRect? Target;

		private void Update()
		{
			//IL_005a: 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_0072: 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)
			if ((Object)(object)Target == (Object)null || !((Component)Target.content).gameObject.activeInHierarchy)
			{
				return;
			}
			Mouse current = Mouse.current;
			float num = ((current != null) ? ((InputControl<float>)(object)((Vector2Control)current.scroll).y).ReadValue() : 0f);
			if (num != 0f)
			{
				Rect rect = Target.content.rect;
				float height = ((Rect)(ref rect)).height;
				rect = Target.viewport.rect;
				float num2 = height - ((Rect)(ref rect)).height;
				if (!(num2 <= 0f))
				{
					float num3 = num * 64.05f;
					Target.verticalNormalizedPosition = Mathf.Clamp01(Target.verticalNormalizedPosition + num3 / num2);
				}
			}
		}
	}
	internal static class UpgradeEntryUiText
	{
		private static readonly FieldRef<UpgradeEntryUI, TextMeshProUGUI> LabelField = AccessTools.FieldRefAccess<UpgradeEntryUI, TextMeshProUGUI>("labelText");

		private static readonly FieldRef<UpgradeEntryUI, TextMeshProUGUI> DescriptionField = AccessTools.FieldRefAccess<UpgradeEntryUI, TextMeshProUGUI>("descriptionText");

		private static readonly FieldRef<UpgradeEntryUI, TextMeshProUGUI> ValueField = AccessTools.FieldRefAccess<UpgradeEntryUI, TextMeshProUGUI>("valueText");

		public static void Set(UpgradeEntryUI entry, string label, string description, string formattedValue)
		{
			TextMeshProUGUI val = LabelField.Invoke(entry);
			if ((Object)(object)val != (Object)null)
			{
				((TMP_Text)val).text = label;
			}
			TextMeshProUGUI val2 = DescriptionField.Invoke(entry);
			if ((Object)(object)val2 != (Object)null)
			{
				((TMP_Text)val2).text = description;
			}
			TextMeshProUGUI val3 = ValueField.Invoke(entry);
			if ((Object)(object)val3 != (Object)null)
			{
				((TMP_Text)val3).text = formattedValue;
			}
		}
	}
}