using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using Battle;
using Battle.Attacks;
using Battle.Attacks.AttackBehaviours;
using Battle.Enemies;
using Battle.Enemies.Behaviours.SpiritOfRadia;
using Battle.Pachinko;
using Battle.Pachinko.Obstacles;
using Battle.PegBehaviour;
using Battle.StatusEffects;
using BepInEx;
using BepInEx.Logging;
using Challenges;
using ClassSystem;
using Cruciball;
using Currency;
using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using Data;
using Data.Scenarios;
using HarmonyLib;
using I2.Loc;
using LiteNetLib;
using LiteNetLib.Layers;
using LiteNetLib.Utils;
using Loading;
using Loading.Pegboards;
using Map;
using Microsoft.CodeAnalysis;
using Multipeglin.Continue;
using Multipeglin.DI;
using Multipeglin.Debug;
using Multipeglin.Events;
using Multipeglin.Events.Handlers;
using Multipeglin.Events.Handlers.Ball;
using Multipeglin.Events.Handlers.Battle;
using Multipeglin.Events.Handlers.Coop;
using Multipeglin.Events.Handlers.Currency;
using Multipeglin.Events.Handlers.Cursor;
using Multipeglin.Events.Handlers.Deck;
using Multipeglin.Events.Handlers.Enemy;
using Multipeglin.Events.Handlers.Health;
using Multipeglin.Events.Handlers.Lobby;
using Multipeglin.Events.Handlers.Map;
using Multipeglin.Events.Handlers.Peg;
using Multipeglin.Events.Handlers.Relic;
using Multipeglin.Events.Handlers.Scenarios;
using Multipeglin.Events.Handlers.State;
using Multipeglin.Events.Handlers.StatusEffect;
using Multipeglin.Events.Network;
using Multipeglin.Events.Network.Ball;
using Multipeglin.Events.Network.Battle;
using Multipeglin.Events.Network.Coop;
using Multipeglin.Events.Network.Currency;
using Multipeglin.Events.Network.Cursor;
using Multipeglin.Events.Network.Deck;
using Multipeglin.Events.Network.Enemy;
using Multipeglin.Events.Network.Health;
using Multipeglin.Events.Network.Lobby;
using Multipeglin.Events.Network.Map;
using Multipeglin.Events.Network.Peg;
using Multipeglin.Events.Network.Relic;
using Multipeglin.Events.Network.Scenarios;
using Multipeglin.Events.Network.StatusEffect;
using Multipeglin.Events.Subscriptions;
using Multipeglin.Events.Subscriptions.Coop;
using Multipeglin.GameState;
using Multipeglin.GameState.Appliers;
using Multipeglin.GameState.Providers;
using Multipeglin.GameState.Snapshots;
using Multipeglin.Multiplayer;
using Multipeglin.Network;
using Multipeglin.Network.Protocol;
using Multipeglin.Patches;
using Multipeglin.UI;
using Multipeglin.Utility;
using NLog;
using NLog.Config;
using NLog.Layouts;
using NLog.Targets;
using NLog.Targets.Wrappers;
using Newtonsoft.Json;
using Peglin;
using Peglin.ClassSystem;
using Peglin.PegMinigame;
using PeglinUI;
using PeglinUI.ControllerSupport;
using PeglinUI.LoadoutManager;
using PeglinUI.MainMenu;
using PeglinUI.OrbDisplay;
using PeglinUI.PostBattle;
using PeglinUI.RunSummary;
using PeglinUI.UIUtils;
using PixelCrushers;
using PixelCrushers.DialogueSystem;
using RNG.Scenarios;
using Relics;
using Rewired;
using Rewired.Integration.UnityUI;
using Scenarios;
using Scenarios.Shop;
using Stats;
using Steamworks;
using TMPro;
using ToolBox.Serialization;
using Tutorial;
using UI.OrbDisplay;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.EventSystems;
using UnityEngine.Events;
using UnityEngine.ResourceManagement.ResourceLocations;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using Worldmap;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("Multipeglin")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyDescription("Multiplayer mode for Peglin")]
[assembly: AssemblyFileVersion("0.1.10.0")]
[assembly: AssemblyInformationalVersion("0.1.10+fa08d30a0345f919382a92e95e02120aab7c2ac1")]
[assembly: AssemblyProduct("Multipeglin")]
[assembly: AssemblyTitle("Multipeglin")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("0.1.10.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.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 Multipeglin
{
	[BepInPlugin("com.multipeglin", "Multipeglin", "0.1.10")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MultiplayerPlugin : BaseUnityPlugin
	{
		private Harmony _harmony;

		private FileLogger _fileLogger;

		private static GameObject _modObject;

		public static MultiplayerPlugin Instance { get; private set; }

		public static IServiceContainer Services { get; private set; }

		public static ManualLogSource Logger { get; private set; }

		public static IReadOnlyList<string> MissingPatches { get; private set; }

		private void Awake()
		{
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Expected O, but got Unknown
			Instance = this;
			Logger = ((BaseUnityPlugin)this).Logger;
			try
			{
				string logsDirectory = Path.Combine(Paths.BepInExRootPath, "logs");
				_fileLogger = new FileLogger(logsDirectory);
				Logger.Listeners.Add((ILogListener)(object)new FileLogListener(_fileLogger));
				Logger.LogInfo((object)("Log file: " + _fileLogger.FilePath));
				Services = ServiceRegistration.CreateAndConfigure(Logger);
				_modObject = new GameObject("Multipeglin")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)(object)_modObject);
				_modObject.AddComponent<NetworkPollBehaviour>().Initialize(Services.Resolve<INetworkTransport>());
				MainThreadDispatcher instance = _modObject.AddComponent<MainThreadDispatcher>();
				Services.RegisterSingleton(instance);
				_modObject.AddComponent<MultiplayerUI>();
				_modObject.AddComponent<SceneWatcher>();
				_modObject.AddComponent<BallPositionSync>();
				_modObject.AddComponent<HostBallSync>();
				_modObject.AddComponent<ClientBallRenderer>();
				_modObject.AddComponent<ClientAimRenderer>();
				_modObject.AddComponent<RttPingTicker>();
				_modObject.AddComponent<HostRttTickerBehaviour>();
				_modObject.AddComponent<CursorSync>();
				_modObject.AddComponent<RemoteCursorRenderer>();
				_modObject.AddComponent<ClientAttackProjectile>();
				_modObject.AddComponent<CoopPlayerVisuals>();
				_modObject.AddComponent<PendingDamageOverlay>();
				_modObject.AddComponent<SkipTurnButton>();
				_modObject.AddComponent<CoopRewardUI>();
				_modObject.AddComponent<CoopNavigateClientInput>();
				_modObject.AddComponent<ClientRelicChoiceApplier>();
				_modObject.AddComponent<DebugHotkeys>();
				_harmony = new Harmony("com.multipeglin");
				try
				{
					_harmony.PatchAll();
				}
				catch (Exception ex)
				{
					Logger.LogError((object)$"Harmony PatchAll failed: {ex}");
					MissingPatches = new List<string> { "PatchAll failed: " + ex.Message };
				}
				int num = 0;
				foreach (MethodBase patchedMethod in _harmony.GetPatchedMethods())
				{
					Logger.LogInfo((object)("Harmony patched: " + patchedMethod.DeclaringType?.FullName + "." + patchedMethod.Name));
					num++;
				}
				Logger.LogInfo((object)$"Harmony total patches applied: {num}");
				if (MissingPatches == null)
				{
					List<string> list = PatchValidator.FindMissingPatchTargets(Logger);
					if (list.Count > 0)
					{
						Logger.LogWarning((object)$"[PatchValidator] {list.Count} patch target(s) not found:");
						foreach (string item in list)
						{
							Logger.LogWarning((object)("  Missing: " + item));
						}
						MissingPatches = list;
					}
				}
				Logger.LogInfo((object)"Multipeglin v0.1.10 loaded");
			}
			catch (Exception arg)
			{
				Logger.LogError((object)$"Failed to initialize: {arg}");
			}
		}

		private void OnDestroy()
		{
		}
	}
	public static class MultiplayerPluginInfo
	{
		public const string GUID = "com.multipeglin";

		public const string NAME = "Multipeglin";

		public const string VERSION = "0.1.10";

		public const string COMPILED_GAME_VERSION = "2.0.12";
	}
}
namespace Multipeglin.Utility
{
	public class BallIdentifier
	{
		private readonly Dictionary<string, PachinkoBall> _guidToBall = new Dictionary<string, PachinkoBall>();

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

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public int Count => _guidToBall.Count;

		public string GetOrAssignGuid(PachinkoBall ball)
		{
			if ((Object)(object)ball == (Object)null)
			{
				return "null";
			}
			if (_ballToGuid.TryGetValue(ball, out var value))
			{
				return value;
			}
			string text = Guid.NewGuid().ToString("N").Substring(0, 12);
			_guidToBall[text] = ball;
			_ballToGuid[ball] = text;
			return text;
		}

		public string GetGuid(PachinkoBall ball)
		{
			if ((Object)(object)ball == (Object)null)
			{
				return null;
			}
			if (!_ballToGuid.TryGetValue(ball, out var value))
			{
				return null;
			}
			return value;
		}

		public void Forget(PachinkoBall ball)
		{
			if (!((Object)(object)ball == (Object)null) && _ballToGuid.TryGetValue(ball, out var value))
			{
				_guidToBall.Remove(value);
				_ballToGuid.Remove(ball);
			}
		}

		public void ForgetByGuid(string guid)
		{
			if (!string.IsNullOrEmpty(guid) && _guidToBall.TryGetValue(guid, out var value))
			{
				_guidToBall.Remove(guid);
				if ((Object)(object)value != (Object)null)
				{
					_ballToGuid.Remove(value);
				}
			}
		}

		public List<string> PruneDestroyed()
		{
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			foreach (KeyValuePair<string, PachinkoBall> item in _guidToBall)
			{
				if ((Object)(object)item.Value == (Object)null)
				{
					list2.Add(item.Key);
				}
			}
			foreach (string item2 in list2)
			{
				_guidToBall.Remove(item2);
				list.Add(item2);
			}
			List<PachinkoBall> list3 = new List<PachinkoBall>();
			foreach (KeyValuePair<PachinkoBall, string> item3 in _ballToGuid)
			{
				if ((Object)(object)item3.Key == (Object)null)
				{
					list3.Add(item3.Key);
				}
			}
			foreach (PachinkoBall item4 in list3)
			{
				_ballToGuid.Remove(item4);
			}
			return list;
		}

		public void Clear()
		{
			int count = _guidToBall.Count;
			_guidToBall.Clear();
			_ballToGuid.Clear();
			if (count > 0)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"[BallGUID] Cleared {count} entries");
				}
			}
		}
	}
	public static class DiagnosticLogger
	{
		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public static void DumpBattleState(string trigger)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_03af: Unknown result type (might be due to invalid IL or missing references)
			//IL_03c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_05be: Unknown result type (might be due to invalid IL or missing references)
			//IL_0684: Unknown result type (might be due to invalid IL or missing references)
			//IL_069a: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ab: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)("=== DIAG [" + trigger + "] scene=" + name + " ==="));
				}
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)($"  SGD: seed={StaticGameData.currentSeed}, floor={StaticGameData.totalFloorCount}, " + $"class={StaticGameData.chosenClass}, nodeIdx={StaticGameData.chosenNextNodeIndex}, " + string.Format("seedSet={0}, dataToLoad={1}", StaticGameData.seedSet, ((Object)(object)StaticGameData.dataToLoad != (Object)null) ? ((object)StaticGameData.dataToLoad).GetType().Name : "NULL")));
				}
				MapData dataToLoad = StaticGameData.dataToLoad;
				MapDataBattle val = (MapDataBattle)(object)((dataToLoad is MapDataBattle) ? dataToLoad : null);
				if (val != null)
				{
					ManualLogSource log3 = Log;
					if (log3 != null)
					{
						string[] obj = new string[6]
						{
							"  MapDataBattle: name=",
							((Object)val).name,
							", pegLayout=",
							((Object)(object)val.pegLayout != (Object)null) ? ((Object)val.pegLayout).name : "NULL",
							", ",
							null
						};
						object arg = val.NumberOfSlots;
						object arg2 = val.starterSpawns?.Count ?? (-1);
						WaveGroup[] waveGroups = val.waveGroups;
						obj[5] = $"slots={arg}, starterSpawns={arg2}, waves={((waveGroups != null) ? waveGroups.Length : (-1))}";
						log3.LogInfo((object)string.Concat(obj));
					}
				}
				try
				{
					RelicManager[] array = Resources.FindObjectsOfTypeAll<RelicManager>();
					RelicManager val2 = ((array.Length != 0) ? array[0] : null);
					if ((Object)(object)val2 != (Object)null)
					{
						IDictionary dictionary = AccessTools.Field(typeof(RelicManager), "_ownedRelics")?.GetValue(val2) as IDictionary;
						ManualLogSource log4 = Log;
						if (log4 != null)
						{
							log4.LogInfo((object)$"  Relics: {dictionary?.Count ?? 0} owned");
						}
					}
				}
				catch
				{
				}
				try
				{
					List<GameObject> completeDeck = DeckManager.completeDeck;
					ManualLogSource log5 = Log;
					if (log5 != null)
					{
						log5.LogInfo((object)$"  CompleteDeck: {completeDeck?.Count ?? 0} orbs");
					}
				}
				catch
				{
				}
				try
				{
					Dictionary<string, GameObject> dictionary2 = AssetLoading.Instance?.EnemyPrefabs;
					ManualLogSource log6 = Log;
					if (log6 != null)
					{
						log6.LogInfo((object)$"  EnemyPrefabCache: {dictionary2?.Count ?? (-1)} entries");
					}
				}
				catch
				{
				}
				if (name != "Battle")
				{
					ManualLogSource log7 = Log;
					if (log7 != null)
					{
						log7.LogInfo((object)("=== END DIAG [" + trigger + "] (not Battle) ==="));
					}
					return;
				}
				EnemyManager val3 = Object.FindObjectOfType<EnemyManager>();
				if ((Object)(object)val3 != (Object)null)
				{
					List<Enemy> enemies = val3.Enemies;
					ManualLogSource log8 = Log;
					if (log8 != null)
					{
						log8.LogInfo((object)$"  Enemies ({enemies?.Count ?? 0}):");
					}
					if (enemies != null)
					{
						for (int i = 0; i < enemies.Count; i++)
						{
							Enemy val4 = enemies[i];
							if ((Object)(object)val4 == (Object)null)
							{
								ManualLogSource log9 = Log;
								if (log9 != null)
								{
									log9.LogInfo((object)$"    [{i}] NULL");
								}
								continue;
							}
							ManualLogSource log10 = Log;
							if (log10 != null)
							{
								log10.LogInfo((object)($"    [{i}] {val4.locKey} name={((Object)((Component)val4).gameObject).name} hp={val4.CurrentHealth}/{GetMaxHp(val4):F0} " + $"pos=({((Component)val4).transform.position.x:F2},{((Component)val4).transform.position.y:F2}) flying={val4.IsFlying}"));
							}
						}
					}
				}
				else
				{
					ManualLogSource log11 = Log;
					if (log11 != null)
					{
						log11.LogInfo((object)"  EnemyManager: NOT FOUND");
					}
				}
				BattleController obj5 = Object.FindObjectOfType<BattleController>();
				PegManager val5 = ((obj5 != null) ? obj5.pegManager : null);
				if (val5 != null && val5.allPegs != null)
				{
					List<Bomb> list = AccessTools.Field(typeof(BattleController).Assembly.GetType("Battle.PegManager"), "_bombs")?.GetValue(val5) as List<Bomb>;
					List<Peg> list2 = new List<Peg>(val5.allPegs);
					if (list != null)
					{
						foreach (Bomb item in list)
						{
							list2.Add((Peg)(object)item);
						}
					}
					Peg[] array2 = list2.Where((Peg p) => (Object)(object)p != (Object)null && ((Component)p).gameObject.activeSelf).ToArray();
					IOrderedEnumerable<IGrouping<PegType, Peg>> orderedEnumerable = from p in array2
						group p by p.pegType into g
						orderby g.Count() descending
						select g;
					ManualLogSource log12 = Log;
					if (log12 != null)
					{
						log12.LogInfo((object)$"  Pegs: {array2.Length} active / {list2.Count} total (allPegs={val5.allPegs.Count}, bombs={list?.Count ?? 0})");
					}
					foreach (IGrouping<PegType, Peg> item2 in orderedEnumerable)
					{
						ManualLogSource log13 = Log;
						if (log13 != null)
						{
							log13.LogInfo((object)$"    {item2.Key}: {item2.Count()}");
						}
					}
					IEnumerable<Peg> enumerable = (from p in array2
						orderby ((Component)p).transform.position.y, ((Component)p).transform.position.x
						select p).Take(10);
					ManualLogSource log14 = Log;
					if (log14 != null)
					{
						log14.LogInfo((object)"  First 10 pegs by pos:");
					}
					foreach (Peg item3 in enumerable)
					{
						ManualLogSource log15 = Log;
						if (log15 != null)
						{
							log15.LogInfo((object)$"    ({((Component)item3).transform.position.x:F3},{((Component)item3).transform.position.y:F3}) type={item3.pegType}");
						}
					}
				}
				else
				{
					ManualLogSource log16 = Log;
					if (log16 != null)
					{
						log16.LogInfo((object)"  PegManager: NOT FOUND");
					}
				}
				ManualLogSource log17 = Log;
				if (log17 != null)
				{
					log17.LogInfo((object)$"  BattleState: {BattleController.CurrentBattleState}");
				}
				PachinkoBall[] array3 = Object.FindObjectsOfType<PachinkoBall>();
				ManualLogSource log18 = Log;
				if (log18 != null)
				{
					log18.LogInfo((object)$"  Balls: {array3.Length} (dummy={array3.Count((PachinkoBall b) => b.IsDummy)}, real={array3.Count((PachinkoBall b) => !b.IsDummy)})");
				}
				ManualLogSource log19 = Log;
				if (log19 != null)
				{
					log19.LogInfo((object)("=== END DIAG [" + trigger + "] ==="));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log20 = Log;
				if (log20 != null)
				{
					log20.LogError((object)("DiagnosticLogger.DumpBattleState failed: " + ex.Message));
				}
			}
		}

		private static float GetMaxHp(Enemy e)
		{
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Enemy), "_maxHealth");
				return (fieldInfo != null) ? ((float)fieldInfo.GetValue(e)) : (-1f);
			}
			catch
			{
				return -1f;
			}
		}
	}
	public class EnemyIdentifier
	{
		private readonly Dictionary<string, Enemy> _guidToEnemy = new Dictionary<string, Enemy>();

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

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public string GetOrAssignGuid(Enemy enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				return "null";
			}
			if (_enemyToGuid.TryGetValue(enemy, out var value))
			{
				return value;
			}
			string text = Guid.NewGuid().ToString("N").Substring(0, 12);
			_guidToEnemy[text] = enemy;
			_enemyToGuid[enemy] = text;
			return text;
		}

		public void Register(Enemy enemy, string guid)
		{
			if ((Object)(object)enemy == (Object)null || string.IsNullOrEmpty(guid))
			{
				return;
			}
			if (_guidToEnemy.TryGetValue(guid, out var value) && (Object)(object)value != (Object)(object)enemy)
			{
				_enemyToGuid.Remove(value);
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)("[EnemyGUID] Replaced stale mapping for " + guid + " (was '" + value?.locKey + "')"));
				}
			}
			if (_enemyToGuid.TryGetValue(enemy, out var value2) && value2 != guid)
			{
				_guidToEnemy.Remove(value2);
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)("[EnemyGUID] Enemy '" + enemy.locKey + "' had old GUID " + value2 + ", replacing with " + guid));
				}
			}
			_guidToEnemy[guid] = enemy;
			_enemyToGuid[enemy] = guid;
		}

		public Enemy Find(string guid)
		{
			if (string.IsNullOrEmpty(guid))
			{
				return null;
			}
			if (_guidToEnemy.TryGetValue(guid, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if ((Object)(object)value == (Object)null && _guidToEnemy.ContainsKey(guid))
			{
				_guidToEnemy.Remove(guid);
			}
			return null;
		}

		public string GetGuid(Enemy enemy)
		{
			if ((Object)(object)enemy == (Object)null)
			{
				return null;
			}
			if (!_enemyToGuid.TryGetValue(enemy, out var value))
			{
				return null;
			}
			return value;
		}

		public void Unregister(Enemy enemy)
		{
			if (!((Object)(object)enemy == (Object)null) && _enemyToGuid.TryGetValue(enemy, out var value))
			{
				_enemyToGuid.Remove(enemy);
				_guidToEnemy.Remove(value);
			}
		}

		public void Unregister(string guid)
		{
			if (!string.IsNullOrEmpty(guid) && _guidToEnemy.TryGetValue(guid, out var value))
			{
				_guidToEnemy.Remove(guid);
				if ((Object)(object)value != (Object)null)
				{
					_enemyToGuid.Remove(value);
				}
			}
		}

		public void Clear()
		{
			int count = _guidToEnemy.Count;
			_guidToEnemy.Clear();
			_enemyToGuid.Clear();
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"[EnemyGUID] Cleared {count} entries");
			}
		}

		public void DumpState(string trigger)
		{
			//IL_00ba: 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)
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"[EnemyGUID] === DUMP ({trigger}) {_guidToEnemy.Count} entries ===");
			}
			foreach (KeyValuePair<string, Enemy> item in _guidToEnemy)
			{
				Enemy value = item.Value;
				if ((Object)(object)value != (Object)null)
				{
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogInfo((object)("[EnemyGUID]   " + item.Key + " → '" + value.locKey + "' (" + ((Object)((Component)value).gameObject).name + ") " + $"pos=({((Component)value).transform.position.x:F1},{((Component)value).transform.position.y:F1}) hp={value.CurrentHealth}"));
					}
				}
				else
				{
					ManualLogSource log3 = Log;
					if (log3 != null)
					{
						log3.LogInfo((object)("[EnemyGUID]   " + item.Key + " → DESTROYED"));
					}
				}
			}
		}

		public string GetId(Enemy enemy)
		{
			return GetOrAssignGuid(enemy);
		}
	}
	public sealed class EventDiscovery
	{
		private readonly ManualLogSource _log;

		public Dictionary<string, FieldInfo> AvailableEvents { get; } = new Dictionary<string, FieldInfo>();


		public HashSet<string> RegisteredTypeIds { get; } = new HashSet<string>();


		public EventDiscovery(ManualLogSource log)
		{
			_log = log;
		}

		public void ScanGameDelegates()
		{
			AvailableEvents.Clear();
			try
			{
				Assembly assembly = Assembly.Load("Assembly-CSharp");
				if (assembly == null)
				{
					_log.LogWarning((object)"Could not load Assembly-CSharp for event discovery");
					return;
				}
				Type[] types = assembly.GetTypes();
				foreach (Type type in types)
				{
					try
					{
						FieldInfo[] fields = type.GetFields(BindingFlags.Static | BindingFlags.Public);
						foreach (FieldInfo fieldInfo in fields)
						{
							if (typeof(Delegate).IsAssignableFrom(fieldInfo.FieldType))
							{
								string key = type.FullName + "." + fieldInfo.Name;
								AvailableEvents[key] = fieldInfo;
							}
						}
					}
					catch
					{
					}
				}
				_log.LogInfo((object)$"Event discovery: found {AvailableEvents.Count} static delegate fields in game");
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("Event discovery scan failed: " + ex.Message));
			}
		}

		public void MarkRegistered(string typeId)
		{
			RegisteredTypeIds.Add(typeId);
		}

		public void LogReport()
		{
			_log.LogInfo((object)"=== Event Discovery Report ===");
			_log.LogInfo((object)$"Game delegates found: {AvailableEvents.Count}");
			_log.LogInfo((object)$"Handlers registered:  {RegisteredTypeIds.Count}");
			foreach (IGrouping<string, KeyValuePair<string, FieldInfo>> item in from kv in AvailableEvents
				group kv by kv.Value.DeclaringType?.Name ?? "Unknown" into g
				orderby g.Key
				select g)
			{
				IOrderedEnumerable<string> values = from kv in item
					select kv.Value.Name into n
					orderby n
					select n;
				_log.LogInfo((object)("  [" + item.Key + "] " + string.Join(", ", values)));
			}
			_log.LogInfo((object)"--- Registered handler typeIds ---");
			foreach (string item2 in RegisteredTypeIds.OrderBy((string s) => s))
			{
				_log.LogInfo((object)("  " + item2));
			}
		}
	}
	public sealed class FileLogger : IDisposable
	{
		private readonly Logger _nlog;

		private readonly string _filePath;

		private static string _roleTag = string.Empty;

		public string FilePath => _filePath;

		public static string RoleTag
		{
			get
			{
				return _roleTag;
			}
			set
			{
				_roleTag = AnnotateClientTag(value);
			}
		}

		public FileLogger(string logsDirectory)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Expected O, but got Unknown
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Expected O, but got Unknown
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Expected O, but got Unknown
			Directory.CreateDirectory(logsDirectory);
			string text = Environment.GetEnvironmentVariable("MULTIPEGLIN_LOGNAME");
			if (string.IsNullOrEmpty(text))
			{
				text = "multipeglin_log.log";
			}
			_filePath = Path.Combine(logsDirectory, text);
			string environmentVariable = Environment.GetEnvironmentVariable("MULTIPEGLIN_INSTANCE");
			if (!string.IsNullOrEmpty(environmentVariable))
			{
				RoleTag = environmentVariable;
			}
			LoggingConfiguration val = new LoggingConfiguration();
			FileTarget val2 = new FileTarget("multipeglinFile")
			{
				FileName = Layout.op_Implicit(_filePath),
				Layout = Layout.op_Implicit("${message}"),
				KeepFileOpen = true,
				AutoFlush = false,
				OpenFileFlushTimeout = 2,
				BufferSize = 32768
			};
			AsyncTargetWrapper val3 = new AsyncTargetWrapper("multipeglinFileAsync", (Target)(object)val2)
			{
				QueueLimit = 10000,
				BatchSize = 200,
				TimeToSleepBetweenBatches = 0,
				OverflowAction = (AsyncTargetWrapperOverflowAction)1
			};
			val.AddRule(LogLevel.Trace, LogLevel.Fatal, (Target)(object)val3, "*");
			LogManager.Configuration = val;
			_nlog = LogManager.GetLogger("Multipeglin");
			_nlog.Info($"--- Multipeglin [{RoleTag}] log started at {DateTime.Now:O} ---");
		}

		private static string AnnotateClientTag(string baseTag)
		{
			if (baseTag != "CLIENT")
			{
				return baseTag;
			}
			try
			{
				string environmentVariable = Environment.GetEnvironmentVariable("MULTIPEGLIN_INSTANCE");
				if (string.IsNullOrEmpty(environmentVariable))
				{
					return baseTag;
				}
				int num = environmentVariable.Length;
				while (num > 0 && char.IsDigit(environmentVariable[num - 1]))
				{
					num--;
				}
				string text = environmentVariable.Substring(num);
				return string.IsNullOrEmpty(text) ? baseTag : ("CLIENT" + text);
			}
			catch
			{
				return baseTag;
			}
		}

		public void Log(LogLevel level, string message)
		{
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			string text = (string.IsNullOrEmpty(RoleTag) ? string.Empty : ("[" + RoleTag + "] "));
			string text2 = $"[{DateTime.Now:HH:mm:ss.fff}] [{level}] {text}{message}";
			_nlog.Info(text2);
		}

		public void Dispose()
		{
			LogManager.Shutdown();
		}
	}
	public sealed class FileLogListener : ILogListener, IDisposable
	{
		private readonly FileLogger _fileLogger;

		public FileLogListener(FileLogger fileLogger)
		{
			_fileLogger = fileLogger;
		}

		public void LogEvent(object sender, LogEventArgs eventArgs)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			ILogSource source = eventArgs.Source;
			if (source != null && (source.SourceName?.StartsWith("Multipeglin")).GetValueOrDefault())
			{
				_fileLogger.Log(eventArgs.Level, $"[{eventArgs.Source.SourceName}] {eventArgs.Data}");
			}
		}

		public void Dispose()
		{
		}
	}
	public static class LongPegVisualHelper
	{
		public static void ApplyHitVisual(LongPeg peg)
		{
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)peg == (Object)null)
			{
				return;
			}
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(LongPeg), "_hit");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(Peg), "_cleared");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(LongPeg), "_renderer");
				FieldInfo fieldInfo4 = AccessTools.Field(typeof(LongPeg), "_colors");
				FieldInfo fieldInfo5 = AccessTools.Field(typeof(LongPeg), "_activeMaterial");
				FieldInfo fieldInfo6 = AccessTools.Field(typeof(LongPeg), "_destroyedMaterial");
				FieldInfo fieldInfo7 = AccessTools.Field(typeof(Peg), "_poppedPegTrigger");
				fieldInfo?.SetValue(peg, true);
				fieldInfo2?.SetValue(peg, true);
				object? obj = fieldInfo3?.GetValue(peg);
				MeshRenderer val = (MeshRenderer)((obj is MeshRenderer) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				object? obj2 = fieldInfo7?.GetValue(peg);
				Collider2D val2 = (Collider2D)((obj2 is Collider2D) ? obj2 : null);
				object? obj3 = (((Object)(object)val2 != (Object)null && ((Behaviour)val2).enabled) ? fieldInfo6 : fieldInfo5)?.GetValue(peg);
				Material val3 = (Material)((obj3 is Material) ? obj3 : null);
				if ((Object)(object)val3 != (Object)null)
				{
					((Renderer)val).material = val3;
				}
				object obj4 = fieldInfo4?.GetValue(peg);
				if (obj4 != null)
				{
					FieldInfo field = obj4.GetType().GetField("Hit");
					if (field != null && (Object)(object)((Renderer)val).material != (Object)null)
					{
						Color color = (Color)field.GetValue(obj4);
						((Renderer)val).material.color = color;
					}
				}
			}
			catch
			{
			}
		}
	}
	public class MainThreadDispatcher : MonoBehaviour
	{
		private readonly ConcurrentQueue<Action> _queue = new ConcurrentQueue<Action>();

		private float _heartbeatTimer;

		private int _heartbeatCount;

		public static MainThreadDispatcher Instance { get; private set; }

		private void Awake()
		{
			if ((Object)(object)Instance != (Object)null && (Object)(object)Instance != (Object)(object)this)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)"[MainThreadDispatcher] Duplicate detected — destroying old instance");
				}
				Object.Destroy((Object)(object)((Component)Instance).gameObject);
			}
			Instance = this;
			_heartbeatCount = 0;
			ManualLogSource logger2 = MultiplayerPlugin.Logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)"[MainThreadDispatcher] Awake — Instance set, heartbeat will auto-start");
			}
		}

		public void Enqueue(Action action)
		{
			_queue.Enqueue(action);
		}

		private void Update()
		{
			Action result;
			while (_queue.TryDequeue(out result))
			{
				result();
			}
			RunHeartbeat();
		}

		private void RunHeartbeat()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Invalid comparison between Unknown and I4
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Invalid comparison between Unknown and I4
			BattleState currentBattleState = BattleController.CurrentBattleState;
			bool flag = (int)currentBattleState == 3 || (int)currentBattleState == 9;
			float num = (flag ? 1f : 2f);
			_heartbeatTimer += Time.unscaledDeltaTime;
			if (_heartbeatTimer < num)
			{
				return;
			}
			_heartbeatTimer = 0f;
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting && services.TryResolve<IGameStateSyncService>(out var instance2))
				{
					_heartbeatCount++;
					string trigger = (flag ? $"HEARTBEAT#{_heartbeatCount}(shot)" : $"HEARTBEAT#{_heartbeatCount}");
					instance2.SyncAll(trigger);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"[HEARTBEAT#{_heartbeatCount}] Exception: {ex.Message}");
				}
			}
		}
	}
	public class OrbIdentifier
	{
		private readonly Dictionary<string, GameObject> _guidToOrb = new Dictionary<string, GameObject>();

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

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public int Count => _guidToOrb.Count;

		public string GetOrAssignGuid(GameObject orb)
		{
			if ((Object)(object)orb == (Object)null)
			{
				return "null";
			}
			if (_orbToGuid.TryGetValue(orb, out var value))
			{
				return value;
			}
			string text = Guid.NewGuid().ToString("N").Substring(0, 12);
			_guidToOrb[text] = orb;
			_orbToGuid[orb] = text;
			return text;
		}

		public void Register(GameObject orb, string guid)
		{
			if (!((Object)(object)orb == (Object)null) && !string.IsNullOrEmpty(guid))
			{
				if (_guidToOrb.TryGetValue(guid, out var value) && (Object)(object)value != (Object)(object)orb)
				{
					_orbToGuid.Remove(value);
				}
				if (_orbToGuid.TryGetValue(orb, out var value2) && value2 != guid)
				{
					_guidToOrb.Remove(value2);
				}
				_guidToOrb[guid] = orb;
				_orbToGuid[orb] = guid;
			}
		}

		public GameObject Find(string guid)
		{
			if (string.IsNullOrEmpty(guid))
			{
				return null;
			}
			if (_guidToOrb.TryGetValue(guid, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if ((Object)(object)value == (Object)null && _guidToOrb.ContainsKey(guid))
			{
				_guidToOrb.Remove(guid);
			}
			return null;
		}

		public string GetGuid(GameObject orb)
		{
			if ((Object)(object)orb == (Object)null)
			{
				return null;
			}
			if (!_orbToGuid.TryGetValue(orb, out var value))
			{
				return null;
			}
			return value;
		}

		public string GetId(GameObject ball)
		{
			if ((Object)(object)ball == (Object)null)
			{
				return "unknown";
			}
			Attack component = ball.GetComponent<Attack>();
			if ((Object)(object)component != (Object)null && !string.IsNullOrEmpty(component.locNameString))
			{
				return component.locNameString;
			}
			return ((Object)ball).name;
		}

		public int GetLevel(GameObject ball)
		{
			if ((Object)(object)ball == (Object)null)
			{
				return 0;
			}
			return ball.GetComponent<Attack>()?.Level ?? 0;
		}

		public void Clear()
		{
			int count = _guidToOrb.Count;
			_guidToOrb.Clear();
			_orbToGuid.Clear();
			if (count > 0)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"[OrbGUID] Cleared {count} entries");
				}
			}
		}
	}
	public static class PatchValidator
	{
		public static List<string> FindMissingPatchTargets(ManualLogSource log)
		{
			List<string> list = new List<string>();
			Assembly executingAssembly = Assembly.GetExecutingAssembly();
			Type[] array;
			try
			{
				array = executingAssembly.GetTypes();
			}
			catch (ReflectionTypeLoadException ex)
			{
				array = ex.Types.Where((Type t) => t != null).ToArray();
				foreach (Exception item in ex.LoaderExceptions?.Where((Exception e) => e != null).Distinct() ?? Array.Empty<Exception>())
				{
					string text = item.Message ?? "Unknown type load error";
					if (log != null)
					{
						log.LogWarning((object)("[PatchValidator] Type load failed: " + text));
					}
					list.Add(text);
				}
			}
			Type[] array2 = array;
			foreach (Type type in array2)
			{
				try
				{
					HarmonyPatch[] array3 = type.GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Cast<HarmonyPatch>().ToArray();
					if (array3.Length == 0)
					{
						continue;
					}
					Type type2 = null;
					string text2 = null;
					HarmonyPatch[] array4 = array3;
					foreach (HarmonyPatch val in array4)
					{
						if (((HarmonyAttribute)val).info.declaringType != null)
						{
							type2 = ((HarmonyAttribute)val).info.declaringType;
						}
						if (((HarmonyAttribute)val).info.methodName != null)
						{
							text2 = ((HarmonyAttribute)val).info.methodName;
						}
					}
					if (type2 != null && text2 != null && !HasMember(type2, text2))
					{
						list.Add(type2.Name + "." + text2);
					}
					MethodInfo[] methods = type.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
					for (int j = 0; j < methods.Length; j++)
					{
						HarmonyPatch[] array5 = methods[j].GetCustomAttributes(typeof(HarmonyPatch), inherit: false).Cast<HarmonyPatch>().ToArray();
						if (array5.Length == 0)
						{
							continue;
						}
						Type type3 = type2;
						string text3 = text2;
						array4 = array5;
						foreach (HarmonyPatch val2 in array4)
						{
							if (((HarmonyAttribute)val2).info.declaringType != null)
							{
								type3 = ((HarmonyAttribute)val2).info.declaringType;
							}
							if (((HarmonyAttribute)val2).info.methodName != null)
							{
								text3 = ((HarmonyAttribute)val2).info.methodName;
							}
						}
						if (type3 != null && text3 != null && !HasMember(type3, text3))
						{
							list.Add(type3.Name + "." + text3);
						}
					}
				}
				catch
				{
				}
			}
			return list.Distinct().ToList();
		}

		private static bool HasMember(Type type, string name)
		{
			return type.GetMember(name, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic).Length != 0;
		}
	}
	public class PegIdentifier
	{
		private readonly Dictionary<string, Peg> _guidToPeg = new Dictionary<string, Peg>();

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

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public int Count => _guidToPeg.Count;

		public string GetOrAssignGuid(Peg peg)
		{
			if ((Object)(object)peg == (Object)null)
			{
				return "null";
			}
			if (_pegToGuid.TryGetValue(peg, out var value))
			{
				return value;
			}
			string text = Guid.NewGuid().ToString("N").Substring(0, 12);
			_guidToPeg[text] = peg;
			_pegToGuid[peg] = text;
			return text;
		}

		public void Register(Peg peg, string guid)
		{
			if (!((Object)(object)peg == (Object)null) && !string.IsNullOrEmpty(guid))
			{
				if (_guidToPeg.TryGetValue(guid, out var value) && (Object)(object)value != (Object)(object)peg)
				{
					_pegToGuid.Remove(value);
				}
				if (_pegToGuid.TryGetValue(peg, out var value2) && value2 != guid)
				{
					_guidToPeg.Remove(value2);
				}
				_guidToPeg[guid] = peg;
				_pegToGuid[peg] = guid;
			}
		}

		public Peg Find(string guid)
		{
			if (string.IsNullOrEmpty(guid))
			{
				return null;
			}
			if (_guidToPeg.TryGetValue(guid, out var value) && (Object)(object)value != (Object)null)
			{
				return value;
			}
			if ((Object)(object)value == (Object)null && _guidToPeg.ContainsKey(guid))
			{
				_guidToPeg.Remove(guid);
			}
			return null;
		}

		public string GetGuid(Peg peg)
		{
			if ((Object)(object)peg == (Object)null)
			{
				return null;
			}
			if (!_pegToGuid.TryGetValue(peg, out var value))
			{
				return null;
			}
			return value;
		}

		public void Clear()
		{
			int count = _guidToPeg.Count;
			_guidToPeg.Clear();
			_pegToGuid.Clear();
			if (count > 0)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"[PegGUID] Cleared {count} entries");
				}
			}
		}

		public void DumpState(string trigger)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"[PegGUID] === DUMP ({trigger}) {_guidToPeg.Count} entries ===");
			}
			int num = 0;
			foreach (KeyValuePair<string, Peg> item in _guidToPeg)
			{
				Peg value = item.Value;
				if ((Object)(object)value != (Object)null)
				{
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogInfo((object)$"[PegGUID]   {item.Key} → type={value.pegType} pos=({((Component)value).transform.position.x:F2},{((Component)value).transform.position.y:F2}) active={((Component)value).gameObject.activeSelf}");
					}
				}
				else
				{
					ManualLogSource log3 = Log;
					if (log3 != null)
					{
						log3.LogInfo((object)("[PegGUID]   " + item.Key + " → DESTROYED"));
					}
				}
				if (++num >= 20)
				{
					ManualLogSource log4 = Log;
					if (log4 != null)
					{
						log4.LogInfo((object)$"[PegGUID]   ... and {_guidToPeg.Count - num} more");
					}
					break;
				}
			}
		}
	}
	public sealed class VersionChecker
	{
		private readonly ManualLogSource _log;

		public string CompiledGameVersion => "2.0.12";

		public string ModVersion => "0.1.10";

		public string RuntimeGameVersion { get; private set; }

		public bool IsVersionMatch { get; private set; }

		public VersionChecker(ManualLogSource log)
		{
			_log = log;
		}

		public void Check()
		{
			RuntimeGameVersion = Application.version ?? "unknown";
			IsVersionMatch = RuntimeGameVersion == CompiledGameVersion;
			_log.LogInfo((object)("Mod version: " + ModVersion));
			_log.LogInfo((object)("Compiled against Peglin: " + CompiledGameVersion));
			_log.LogInfo((object)("Running Peglin: " + RuntimeGameVersion));
			if (!IsVersionMatch)
			{
				_log.LogWarning((object)"========================================");
				_log.LogWarning((object)"GAME VERSION MISMATCH");
				_log.LogWarning((object)("  Mod compiled for: " + CompiledGameVersion));
				_log.LogWarning((object)("  Game running:     " + RuntimeGameVersion));
				_log.LogWarning((object)"  Some features may not work correctly.");
				_log.LogWarning((object)"========================================");
			}
		}
	}
}
namespace Multipeglin.UI
{
	public sealed class ClientRelicChoiceApplier : MonoBehaviour
	{
	}
	public static class CoopNavigateSlotPainter
	{
		private static readonly Color WinnerColor = new Color(0.25f, 0.85f, 0.25f, 1f);

		private static readonly Color LoserColor = new Color(0.85f, 0.2f, 0.2f, 1f);

		private static readonly Color ZeroVoteColor = new Color(0.95f, 0.85f, 0.15f, 1f);

		private static List<int> _lastTally;

		private static int _lastChildCount = -1;

		public static void Tick()
		{
			if (!CoopNavigateState.PhaseActive)
			{
				_lastTally = null;
				_lastChildCount = -1;
				return;
			}
			List<int> voteCounts = CoopNavigateState.VoteCounts;
			if (voteCounts == null || voteCounts.Count == 0 || !TallyChanged(voteCounts, CoopNavigateState.ChildNodeCount))
			{
				return;
			}
			_lastTally = new List<int>(voteCounts);
			_lastChildCount = CoopNavigateState.ChildNodeCount;
			try
			{
				if (CoopNavigateState.Source == "nav_only")
				{
					PaintNavOnly(voteCounts, CoopNavigateState.ChildNodeCount);
				}
				else
				{
					PaintPostBattle(voteCounts, CoopNavigateState.ChildNodeCount);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopNavigate] Slot paint failed: " + ex.Message));
				}
			}
		}

		private static bool TallyChanged(List<int> votes, int childCount)
		{
			if (_lastTally == null || _lastChildCount != childCount || _lastTally.Count != votes.Count)
			{
				return true;
			}
			for (int i = 0; i < votes.Count; i++)
			{
				if (_lastTally[i] != votes[i])
				{
					return true;
				}
			}
			return false;
		}

		private static void PaintPostBattle(List<int> votes, int childCount)
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			PostBattleController[] array = Resources.FindObjectsOfTypeAll<PostBattleController>();
			PostBattleController val = null;
			PostBattleController[] array2 = array;
			foreach (PostBattleController val2 in array2)
			{
				if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).gameObject != (Object)null && ((Component)val2).gameObject.activeInHierarchy)
				{
					val = val2;
					break;
				}
			}
			if (!((Object)(object)val == (Object)null))
			{
				object? obj = AccessTools.Field(typeof(PostBattleController), "_leftSlotManager")?.GetValue(val);
				SlotManager slot = (SlotManager)((obj is SlotManager) ? obj : null);
				object? obj2 = AccessTools.Field(typeof(PostBattleController), "_centerSlotManager")?.GetValue(val);
				SlotManager slot2 = (SlotManager)((obj2 is SlotManager) ? obj2 : null);
				object? obj3 = AccessTools.Field(typeof(PostBattleController), "_rightSlotManager")?.GetValue(val);
				SlotManager slot3 = (SlotManager)((obj3 is SlotManager) ? obj3 : null);
				switch (childCount)
				{
				case 1:
				{
					Color color = ColorFor(votes, 0);
					ApplyColor(slot, color);
					ApplyColor(slot2, color);
					ApplyColor(slot3, color);
					break;
				}
				case 2:
					ApplyColor(slot, ColorFor(votes, 0));
					ApplyColor(slot3, ColorFor(votes, 1));
					break;
				default:
					ApplyColor(slot, ColorFor(votes, 0));
					ApplyColor(slot2, ColorFor(votes, 1));
					ApplyColor(slot3, ColorFor(votes, childCount - 1));
					break;
				}
			}
		}

		private static void PaintNavOnly(List<int> votes, int childCount)
		{
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			NavOnlyController[] array = Resources.FindObjectsOfTypeAll<NavOnlyController>();
			NavOnlyController val = null;
			NavOnlyController[] array2 = array;
			foreach (NavOnlyController val2 in array2)
			{
				if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).gameObject != (Object)null && ((Component)val2).gameObject.activeInHierarchy)
				{
					val = val2;
					break;
				}
			}
			if (!((Object)(object)val == (Object)null))
			{
				object? obj = AccessTools.Field(typeof(NavOnlyController), "_leftSlotManager")?.GetValue(val);
				SlotManager slot = (SlotManager)((obj is SlotManager) ? obj : null);
				object? obj2 = AccessTools.Field(typeof(NavOnlyController), "_centreSlotManager")?.GetValue(val);
				SlotManager slot2 = (SlotManager)((obj2 is SlotManager) ? obj2 : null);
				object? obj3 = AccessTools.Field(typeof(NavOnlyController), "_rightSlotManager")?.GetValue(val);
				SlotManager slot3 = (SlotManager)((obj3 is SlotManager) ? obj3 : null);
				if (childCount == 1)
				{
					Color color = ColorFor(votes, 0);
					ApplyColor(slot, color);
					ApplyColor(slot2, color);
					ApplyColor(slot3, color);
				}
				else
				{
					ApplyColor(slot, ColorFor(votes, 0));
					ApplyColor(slot3, ColorFor(votes, childCount - 1));
				}
			}
		}

		private static Color ColorFor(List<int> votes, int childIdx)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			if (childIdx < 0 || childIdx >= votes.Count)
			{
				return ZeroVoteColor;
			}
			if (votes[childIdx] == 0)
			{
				return ZeroVoteColor;
			}
			int num = 0;
			for (int i = 0; i < votes.Count; i++)
			{
				if (votes[i] > num)
				{
					num = votes[i];
				}
			}
			if (votes[childIdx] != num)
			{
				return LoserColor;
			}
			return WinnerColor;
		}

		private static void ApplyColor(SlotManager slot, Color color)
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)slot == (Object)null) && ((Component)slot).gameObject.activeInHierarchy)
			{
				if ((Object)(object)slot.highlightHalf != (Object)null && ((Component)slot.highlightHalf).gameObject.activeInHierarchy)
				{
					Color color2 = slot.highlightHalf.color;
					slot.highlightHalf.color = new Color(color.r, color.g, color.b, (color2.a > 0f) ? color2.a : 1f);
				}
				if ((Object)(object)slot.highlightFull != (Object)null && ((Component)slot.highlightFull).gameObject.activeInHierarchy)
				{
					Color color3 = slot.highlightFull.color;
					slot.highlightFull.color = new Color(color.r, color.g, color.b, (color3.a > 0f) ? color3.a : 1f);
				}
			}
		}
	}
	public class CoopPlayerVisuals : MonoBehaviour
	{
		private class PlayerVisual
		{
			public int SlotIndex;

			public GameObject SpriteClone;

			public GameObject NamePanel;

			public TextMeshProUGUI NameText;

			public GameObject HpPanel;

			public TextMeshProUGUI HpText;

			public GameObject ArrowPanel;

			public TextMeshProUGUI ArrowText;

			public GameObject StatusIconContainer;

			public Dictionary<int, StatusIconEntry> StatusIcons = new Dictionary<int, StatusIconEntry>();
		}

		private class StatusIconEntry
		{
			public GameObject Root;

			public Image IconImage;

			public TextMeshProUGUI IntensityText;

			public StatusIconHoverHandler Hover;
		}

		internal class StatusIconHoverHandler : MonoBehaviour, IPointerEnterHandler, IEventSystemHandler, IPointerExitHandler
		{
			public StatusEffectType EffectType;

			public Vector3 WorldAnchor;

			private bool _tooltipShowing;

			public void OnPointerEnter(PointerEventData eventData)
			{
				//IL_001c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0022: Unknown result type (might be due to invalid IL or missing references)
				//IL_0031: Unknown result type (might be due to invalid IL or missing references)
				if (_tooltipShowing)
				{
					return;
				}
				TooltipManager instance = TooltipManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				try
				{
					instance.ShowTooltipStatusEffect(EffectType, WorldAnchor, new Vector3(1f, -1f), true, false);
					_tooltipShowing = true;
				}
				catch
				{
				}
			}

			public void OnPointerExit(PointerEventData eventData)
			{
				if (!_tooltipShowing)
				{
					return;
				}
				try
				{
					TooltipManager instance = TooltipManager.Instance;
					if (instance != null)
					{
						instance.HideTooltip();
					}
				}
				catch
				{
				}
				_tooltipShowing = false;
			}

			private void OnDisable()
			{
				if (!_tooltipShowing)
				{
					return;
				}
				try
				{
					TooltipManager instance = TooltipManager.Instance;
					if (instance != null)
					{
						instance.HideTooltip();
					}
				}
				catch
				{
				}
				_tooltipShowing = false;
			}
		}

		private static StatusEffectData _statusEffectData;

		private static bool _statusEffectDataSearched;

		private readonly List<PlayerVisual> _visuals = new List<PlayerVisual>();

		private bool _inBattle;

		private string _lastScene = string.Empty;

		private GameObject _playerRef;

		private PlayerVisual _hostLabel;

		private bool _updateErrorLogged;

		private PlayerStatusEffectController _cachedStatusCtrl;

		private float _lastHeavyTickTime;

		private const float HeavyTickInterval = 0.2f;

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

		private readonly List<int> _removeScratch = new List<int>();

		private static GameObject _overlayCanvasObj;

		private static Canvas _overlayCanvas;

		private static RectTransform _overlayCanvasRect;

		private static TMP_FontAsset _gameFont;

		private static bool _gameFontSearched;

		private static TMP_FontAsset _numberFont;

		private static bool _numberFontSearched;

		private const int HostSlot = 0;

		private static readonly Color _nameColorBase = new Color(0.9f, 0.5f, 0.1f);

		private static readonly Color _nameColorActive = new Color(1f, 0.95f, 0.4f);

		private static readonly Color _arrowColorDim = new Color(1f, 0.9f, 0.3f, 0.5f);

		private static readonly Color _arrowColorBright = new Color(1f, 1f, 0.6f, 1f);

		private static readonly HashSet<int> _loggedMissingClassSprite = new HashSet<int>();

		private static Sprite _cachedPeglinSprite;

		private static Sprite _cachedBalladinSprite;

		private static Sprite _cachedRoundrelSprite;

		private static Sprite _cachedSpinventorSprite;

		private static RuntimeAnimatorController _cachedPeglinCtrl;

		private static RuntimeAnimatorController _cachedBalladinCtrl;

		private static RuntimeAnimatorController _cachedRoundrelCtrl;

		private static RuntimeAnimatorController _cachedSpinventorCtrl;

		private static readonly HashSet<int> _loggedMissingClassCtrl = new HashSet<int>();

		private static readonly HashSet<int> _addressableAttempted = new HashSet<int>();

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public static List<CoopPlayerSummary> LatestPlayerSummaries { get; set; }

		public static int LatestActiveSlot { get; set; } = -1;


		private void Update()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (name != _lastScene)
				{
					_lastScene = name;
					CleanupVisuals();
					_playerRef = null;
					_inBattle = false;
					_updateErrorLogged = false;
					_cachedStatusCtrl = null;
					_lastHeavyTickTime = 0f;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || (!instance.IsHosting && !instance.IsSpectating))
				{
					return;
				}
				if (name != "Battle")
				{
					if (_inBattle)
					{
						CleanupVisuals();
						_inBattle = false;
					}
					return;
				}
				_inBattle = true;
				float unscaledTime = Time.unscaledTime;
				if (unscaledTime - _lastHeavyTickTime >= 0.2f)
				{
					_lastHeavyTickTime = unscaledTime;
					HideNativeStatusIcons();
					if (instance.IsHosting)
					{
						BuildHostSummaries(services);
					}
				}
				List<CoopPlayerSummary> latestPlayerSummaries = LatestPlayerSummaries;
				if (latestPlayerSummaries == null || latestPlayerSummaries.Count <= 1)
				{
					return;
				}
				if ((Object)(object)_playerRef == (Object)null)
				{
					_playerRef = GameObject.FindGameObjectWithTag("Player");
					if ((Object)(object)_playerRef == (Object)null)
					{
						return;
					}
				}
				if (!((Object)(object)Camera.main == (Object)null))
				{
					EnsureVisuals(latestPlayerSummaries);
					UpdateVisuals(latestPlayerSummaries);
					_updateErrorLogged = false;
				}
			}
			catch (Exception arg)
			{
				if (!_updateErrorLogged)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)$"[CoopPlayerVisuals] Update error (will suppress repeats): {arg}");
					}
					_updateErrorLogged = true;
				}
			}
		}

		private void BuildHostSummaries(IServiceContainer services)
		{
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!services.TryResolve<CoopStateManager>(out var instance) || instance.TotalPlayerCount < 2)
				{
					return;
				}
				List<StatusEffectEntry> list = null;
				try
				{
					PlayerStatusEffectController cachedStatusController = GetCachedStatusController();
					if ((Object)(object)cachedStatusController != (Object)null && AccessTools.Field(typeof(PlayerStatusEffectController), "_statusEffects")?.GetValue(cachedStatusController) is IList list2 && list2.Count > 0)
					{
						list = new List<StatusEffectEntry>();
						foreach (object item in list2)
						{
							FieldInfo fieldInfo = AccessTools.Field(item.GetType(), "EffectType");
							FieldInfo fieldInfo2 = AccessTools.Field(item.GetType(), "Intensity");
							if (!(fieldInfo == null))
							{
								object value = fieldInfo.GetValue(item);
								int num = (int)(fieldInfo2?.GetValue(item) ?? ((object)0));
								if (num > 0)
								{
									list.Add(new StatusEffectEntry
									{
										EffectType = (int)value,
										EffectName = value.ToString(),
										Intensity = num
									});
								}
							}
						}
					}
				}
				catch
				{
				}
				float num2 = -1f;
				float num3 = -1f;
				try
				{
					PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
					if ((Object)(object)val != (Object)null)
					{
						num2 = val.CurrentHealth;
						num3 = val.MaxHealth;
					}
				}
				catch
				{
				}
				List<CoopPlayerSummary> list3 = new List<CoopPlayerSummary>();
				foreach (KeyValuePair<int, CoopPlayerState> playerState in instance.PlayerStates)
				{
					CoopPlayerState value2 = playerState.Value;
					bool num4 = value2.SlotIndex == instance.ActivePlayerSlot;
					float currentHealth = ((num4 && num2 >= 0f) ? num2 : value2.CurrentHealth);
					float maxHealth = ((num4 && num3 > 0f) ? num3 : value2.MaxHealth);
					CoopPlayerSummary coopPlayerSummary = new CoopPlayerSummary
					{
						SlotIndex = value2.SlotIndex,
						PlayerName = value2.PlayerName,
						ChosenClass = value2.ChosenClass,
						CurrentHealth = currentHealth,
						MaxHealth = maxHealth,
						Gold = value2.Gold,
						HasShotThisRound = value2.HasShotThisRound
					};
					if (num4 && list != null)
					{
						coopPlayerSummary.StatusEffects = list;
					}
					else if (value2.StatusEffects != null)
					{
						foreach (SerializedStatusEffect statusEffect in value2.StatusEffects)
						{
							List<StatusEffectEntry> statusEffects = coopPlayerSummary.StatusEffects;
							StatusEffectEntry obj3 = new StatusEffectEntry
							{
								EffectType = statusEffect.EffectType
							};
							StatusEffectType val2 = (StatusEffectType)statusEffect.EffectType;
							obj3.EffectName = ((object)(StatusEffectType)(ref val2)).ToString();
							obj3.Intensity = statusEffect.Intensity;
							statusEffects.Add(obj3);
						}
					}
					list3.Add(coopPlayerSummary);
				}
				LatestPlayerSummaries = list3;
				LatestActiveSlot = instance.ActivePlayerSlot;
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogError((object)("[CoopPlayerVisuals] BuildHostSummaries failed: " + ex.Message));
				}
			}
		}

		private void OnDestroy()
		{
			CleanupVisuals();
		}

		private void EnsureVisuals(List<CoopPlayerSummary> summaries)
		{
			int localSlotIndex = GetLocalSlotIndex();
			CoopPlayerSummary coopPlayerSummary = null;
			foreach (CoopPlayerSummary summary in summaries)
			{
				if (summary.SlotIndex == 0)
				{
					coopPlayerSummary = summary;
					break;
				}
			}
			for (int num = _visuals.Count - 1; num >= 0; num--)
			{
				PlayerVisual playerVisual = _visuals[num];
				bool flag = false;
				foreach (CoopPlayerSummary summary2 in summaries)
				{
					if (summary2.SlotIndex == playerVisual.SlotIndex)
					{
						flag = true;
						break;
					}
				}
				if (!flag || (Object)(object)playerVisual.SpriteClone == (Object)null || playerVisual.SlotIndex == 0)
				{
					DestroyVisual(playerVisual);
					_visuals.RemoveAt(num);
				}
			}
			if (_hostLabel != null && (Object)(object)_hostLabel.NamePanel == (Object)null)
			{
				_hostLabel = null;
			}
			if (_hostLabel == null && (Object)(object)_playerRef != (Object)null && coopPlayerSummary != null)
			{
				_hostLabel = CreatePlayerLabels(coopPlayerSummary, null);
			}
			if (localSlotIndex != 0 && coopPlayerSummary != null && (Object)(object)_playerRef != (Object)null)
			{
				ApplyHostClassToPlayerRef(coopPlayerSummary.ChosenClass);
			}
			foreach (CoopPlayerSummary summary3 in summaries)
			{
				if (summary3.SlotIndex == 0)
				{
					continue;
				}
				bool flag2 = false;
				foreach (PlayerVisual visual in _visuals)
				{
					if (visual.SlotIndex == summary3.SlotIndex)
					{
						flag2 = true;
						break;
					}
				}
				if (!flag2)
				{
					PlayerVisual playerVisual2 = CreatePlayerVisual(summary3);
					if (playerVisual2 != null)
					{
						_visuals.Add(playerVisual2);
					}
				}
			}
		}

		private static int GetLocalSlotIndex()
		{
			try
			{
				return CoopSlotHelper.GetLocalSlotIndex(MultiplayerPlugin.Services);
			}
			catch
			{
				return -1;
			}
		}

		private void EnsureOverlayCanvas()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_overlayCanvasObj != (Object)null))
			{
				_overlayCanvasObj = new GameObject("CoopPlayerLabelsOverlay");
				Object.DontDestroyOnLoad((Object)(object)_overlayCanvasObj);
				_overlayCanvas = _overlayCanvasObj.AddComponent<Canvas>();
				_overlayCanvas.renderMode = (RenderMode)0;
				_overlayCanvas.sortingOrder = 9000;
				CanvasScaler obj = _overlayCanvasObj.AddComponent<CanvasScaler>();
				obj.uiScaleMode = (ScaleMode)1;
				obj.referenceResolution = new Vector2(1920f, 1080f);
				obj.matchWidthOrHeight = 0.5f;
				_overlayCanvasObj.AddComponent<GraphicRaycaster>();
				_overlayCanvasRect = _overlayCanvasObj.GetComponent<RectTransform>();
			}
		}

		private static TMP_FontAsset GetGameFont()
		{
			if (_gameFontSearched)
			{
				return _gameFont;
			}
			_gameFontSearched = true;
			try
			{
				TextMeshProUGUI[] array = Object.FindObjectsOfType<TextMeshProUGUI>();
				foreach (TextMeshProUGUI val in array)
				{
					if ((Object)(object)((TMP_Text)val).font != (Object)null)
					{
						_gameFont = ((TMP_Text)val).font;
						break;
					}
				}
			}
			catch
			{
			}
			return _gameFont;
		}

		private static TMP_FontAsset GetStatusEffectNumberFont()
		{
			if (_numberFontSearched)
			{
				return _numberFont ?? GetGameFont();
			}
			_numberFontSearched = true;
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(StatusEffectIcon), "_intensityText");
				if (fieldInfo != null)
				{
					StatusEffectIcon[] array = Resources.FindObjectsOfTypeAll<StatusEffectIcon>();
					foreach (StatusEffectIcon val in array)
					{
						if (!((Object)(object)val == (Object)null))
						{
							object? value = fieldInfo.GetValue(val);
							TextMeshProUGUI val2 = (TextMeshProUGUI)((value is TextMeshProUGUI) ? value : null);
							if ((Object)(object)((val2 != null) ? ((TMP_Text)val2).font : null) != (Object)null)
							{
								_numberFont = ((TMP_Text)val2).font;
								break;
							}
						}
					}
				}
			}
			catch
			{
			}
			return _numberFont ?? GetGameFont();
		}

		private static string FormatName(string name, int slot)
		{
			if (string.IsNullOrEmpty(name))
			{
				name = $"P{slot}";
			}
			if (name.Length > 14)
			{
				name = name.Substring(0, 14);
			}
			if (name.Length > 7)
			{
				name = name.Substring(0, 7) + "\n" + name.Substring(7);
			}
			return name;
		}

		private GameObject CreateTextPanel(string goName, float width, float height, string text, float fontSize, Color textColor, Color bgColor, out TextMeshProUGUI tmpText)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Expected O, but got Unknown
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			EnsureOverlayCanvas();
			GameObject val = new GameObject(goName);
			val.transform.SetParent(_overlayCanvasObj.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.sizeDelta = new Vector2(width, height);
			obj.pivot = new Vector2(0.5f, 0.5f);
			Image obj2 = val.AddComponent<Image>();
			((Graphic)obj2).color = bgColor;
			((Graphic)obj2).raycastTarget = false;
			GameObject val2 = new GameObject("Text");
			val2.transform.SetParent(val.transform, false);
			tmpText = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)tmpText).text = text;
			((TMP_Text)tmpText).fontSize = fontSize;
			((TMP_Text)tmpText).fontStyle = (FontStyles)1;
			TMP_FontAsset gameFont = GetGameFont();
			if ((Object)(object)gameFont != (Object)null)
			{
				((TMP_Text)tmpText).font = gameFont;
			}
			((TMP_Text)tmpText).alignment = (TextAlignmentOptions)514;
			((Graphic)tmpText).color = textColor;
			try
			{
				((TMP_Text)tmpText).outlineWidth = 0.3f;
			}
			catch
			{
			}
			try
			{
				((TMP_Text)tmpText).outlineColor = Color32.op_Implicit(Color.black);
			}
			catch
			{
			}
			((TMP_Text)tmpText).enableWordWrapping = false;
			((TMP_Text)tmpText).overflowMode = (TextOverflowModes)0;
			((TMP_Text)tmpText).lineSpacing = -25f;
			((Graphic)tmpText).raycastTarget = false;
			RectTransform rectTransform = ((TMP_Text)tmpText).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			return val;
		}

		private PlayerVisual CreatePlayerLabels(CoopPlayerSummary summary, GameObject spriteClone)
		{
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0145: Unknown result type (might be due to invalid IL or missing references)
			//IL_0176: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Color textColor = default(Color);
				((Color)(ref textColor))..ctor(0.9f, 0.5f, 0.1f);
				Color textColor2 = default(Color);
				((Color)(ref textColor2))..ctor(0.6f, 1f, 0.6f);
				Color textColor3 = default(Color);
				((Color)(ref textColor3))..ctor(1f, 0.9f, 0.3f);
				Color bgColor = default(Color);
				((Color)(ref bgColor))..ctor(0f, 0f, 0f, 0.3f);
				string text = FormatName(summary.PlayerName, summary.SlotIndex);
				bool flag = text.Contains("\n");
				TextMeshProUGUI tmpText;
				GameObject namePanel = CreateTextPanel($"CoopName_Slot{summary.SlotIndex}", 187f, flag ? 80 : 50, text, 45f, textColor, bgColor, out tmpText);
				TextMeshProUGUI tmpText2;
				GameObject hpPanel = CreateTextPanel($"CoopHP_Slot{summary.SlotIndex}", 160f, 45f, $"{summary.CurrentHealth:F0}/{summary.MaxHealth:F0}", 38f, textColor2, bgColor, out tmpText2);
				TextMeshProUGUI tmpText3;
				GameObject val = CreateTextPanel($"CoopArrow_Slot{summary.SlotIndex}", 80f, 100f, "◀", 64f, textColor3, new Color(0f, 0f, 0f, 0f), out tmpText3);
				val.SetActive(false);
				EnsureOverlayCanvas();
				GameObject val2 = new GameObject($"CoopStatusIcons_Slot{summary.SlotIndex}");
				val2.transform.SetParent(_overlayCanvasObj.transform, false);
				RectTransform obj = val2.AddComponent<RectTransform>();
				obj.sizeDelta = new Vector2(380f, 56f);
				obj.pivot = new Vector2(0.5f, 0.5f);
				HorizontalLayoutGroup obj2 = val2.AddComponent<HorizontalLayoutGroup>();
				((HorizontalOrVerticalLayoutGroup)obj2).spacing = 6f;
				((LayoutGroup)obj2).childAlignment = (TextAnchor)4;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandWidth = false;
				((HorizontalOrVerticalLayoutGroup)obj2).childForceExpandHeight = false;
				val2.SetActive(false);
				return new PlayerVisual
				{
					SlotIndex = summary.SlotIndex,
					SpriteClone = spriteClone,
					NamePanel = namePanel,
					NameText = tmpText,
					HpPanel = hpPanel,
					HpText = tmpText2,
					ArrowPanel = val,
					ArrowText = tmpText3,
					StatusIconContainer = val2
				};
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogError((object)$"[CoopPlayerVisuals] CreatePlayerLabels failed for slot {summary.SlotIndex}: {ex.Message}");
				}
				return null;
			}
		}

		private PlayerVisual CreatePlayerVisual(CoopPlayerSummary summary)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Expected O, but got Unknown
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_playerRef == (Object)null)
			{
				return null;
			}
			try
			{
				GameObject val = new GameObject($"CoopPlayer_Slot{summary.SlotIndex}");
				val.transform.position = _playerRef.transform.position;
				val.layer = _playerRef.layer;
				SpriteRenderer val2 = FindPlayerSpriteRenderer();
				if ((Object)(object)val2 != (Object)null)
				{
					SpriteRenderer obj = val.AddComponent<SpriteRenderer>();
					Sprite val3 = (obj.sprite = GetClassBaseSprite(summary.ChosenClass));
					if ((Object)(object)val3 == (Object)null)
					{
						ManualLogSource log = Log;
						if (log != null)
						{
							log.LogWarning((object)$"[CoopPlayerVisuals] GetClassBaseSprite returned null for slot {summary.SlotIndex} class {summary.ChosenClass}");
						}
					}
					((Renderer)obj).material = ((Renderer)val2).material;
					((Renderer)obj).sortingLayerID = ((Renderer)val2).sortingLayerID;
					((Renderer)obj).sortingOrder = ((Renderer)val2).sortingOrder - 1;
					obj.color = GetSlotColor(summary.SlotIndex);
					obj.flipX = val2.flipX;
					obj.flipY = val2.flipY;
					Animator val4 = val.AddComponent<Animator>();
					RuntimeAnimatorController classAnimationController = GetClassAnimationController(summary.ChosenClass);
					if ((Object)(object)classAnimationController != (Object)null)
					{
						val4.runtimeAnimatorController = classAnimationController;
					}
				}
				else
				{
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogWarning((object)$"[CoopPlayerVisuals] No SpriteRenderer found on _playerRef for slot {summary.SlotIndex}");
					}
				}
				return CreatePlayerLabels(summary, val);
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogError((object)$"[CoopPlayerVisuals] Failed to create visual for slot {summary.SlotIndex}: {ex.Message}");
				}
				return null;
			}
		}

		private SpriteRenderer FindPlayerSpriteRenderer()
		{
			if ((Object)(object)_playerRef == (Object)null)
			{
				return null;
			}
			SpriteRenderer component = _playerRef.GetComponent<SpriteRenderer>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
			return _playerRef.GetComponentInChildren<SpriteRenderer>(true);
		}

		private void ApplyHostClassToPlayerRef(int hostClass)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected I4, but got Unknown
			try
			{
				SpriteRenderer val = FindPlayerSpriteRenderer();
				PeglinClassAnimationSwitcher val2 = FindClassAnimationSwitcher();
				if (!((Object)(object)val2 == (Object)null))
				{
					Class val3 = (Class)hostClass;
					Sprite val4;
					RuntimeAnimatorController val5;
					switch (val3 - 1)
					{
					case 0:
						val4 = val2.balladinBaseSprite;
						val5 = val2.balladinAnimationController;
						break;
					case 1:
						val4 = val2.roundrelBaseSprite;
						val5 = val2.roundrelAnimationController;
						break;
					case 2:
						val4 = val2.spinventorBaseSprite;
						val5 = val2.spinventorAnimationController;
						break;
					default:
						val4 = val2.peglinBaseSprite;
						val5 = val2.peglinAnimationController;
						break;
					}
					Animator component = ((Component)val2).GetComponent<Animator>();
					if ((Object)(object)component != (Object)null && (Object)(object)val5 != (Object)null && (Object)(object)component.runtimeAnimatorController != (Object)(object)val5)
					{
						component.runtimeAnimatorController = val5;
					}
					if ((Object)(object)val != (Object)null && (Object)(object)val4 != (Object)null && (Object)(object)val.sprite != (Object)(object)val4)
					{
						val.sprite = val4;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[CoopPlayerVisuals] ApplyHostClassToPlayerRef failed: " + ex.Message));
				}
			}
		}

		private static PeglinClassAnimationSwitcher FindClassAnimationSwitcher()
		{
			try
			{
				GameObject val = GameObject.FindGameObjectWithTag("Player");
				if ((Object)(object)val != (Object)null)
				{
					PeglinClassAnimationSwitcher val2 = val.GetComponentInChildren<PeglinClassAnimationSwitcher>(true) ?? val.GetComponentInParent<PeglinClassAnimationSwitcher>();
					if ((Object)(object)val2 != (Object)null)
					{
						return val2;
					}
				}
				PeglinClassAnimationSwitcher val3 = Object.FindObjectOfType<PeglinClassAnimationSwitcher>();
				if ((Object)(object)val3 != (Object)null)
				{
					return val3;
				}
				PeglinClassAnimationSwitcher[] array = Resources.FindObjectsOfTypeAll<PeglinClassAnimationSwitcher>();
				if (array != null && array.Length != 0)
				{
					return array[0];
				}
			}
			catch
			{
			}
			return null;
		}

		private void UpdateVisuals(List<CoopPlayerSummary> summaries)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: 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_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0208: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_0269: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0299: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_playerRef == (Object)null)
			{
				return;
			}
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null)
			{
				return;
			}
			Vector3 position = _playerRef.transform.position;
			int latestActiveSlot = LatestActiveSlot;
			try
			{
				float num = ((latestActiveSlot == 0) ? 1.15f : 1f);
				_playerRef.transform.localScale = Vector3.Lerp(_playerRef.transform.localScale, Vector3.one * num, Time.deltaTime * 5f);
			}
			catch
			{
			}
			if (_hostLabel != null)
			{
				CoopPlayerSummary coopPlayerSummary = null;
				foreach (CoopPlayerSummary summary in summaries)
				{
					if (summary.SlotIndex == 0)
					{
						coopPlayerSummary = summary;
						break;
					}
				}
				if (coopPlayerSummary != null)
				{
					UpdatePlayerLabel(_hostLabel, coopPlayerSummary, position, latestActiveSlot, main);
				}
			}
			Vector3 val = default(Vector3);
			foreach (PlayerVisual visual in _visuals)
			{
				if ((Object)(object)visual.SpriteClone == (Object)null)
				{
					continue;
				}
				CoopPlayerSummary coopPlayerSummary2 = null;
				foreach (CoopPlayerSummary summary2 in summaries)
				{
					if (summary2.SlotIndex == visual.SlotIndex)
					{
						coopPlayerSummary2 = summary2;
						break;
					}
				}
				if (coopPlayerSummary2 == null)
				{
					continue;
				}
				((Vector3)(ref val))..ctor(-2.5f * (float)visual.SlotIndex, -0.2f * (float)visual.SlotIndex, 0f);
				visual.SpriteClone.transform.position = position + val;
				Vector3 position2 = visual.SpriteClone.transform.position;
				UpdatePlayerLabel(visual, coopPlayerSummary2, position2, latestActiveSlot, main);
				float num2 = ((latestActiveSlot == visual.SlotIndex) ? 1.15f : 1f);
				visual.SpriteClone.transform.localScale = Vector3.Lerp(visual.SpriteClone.transform.localScale, Vector3.one * num2, Time.deltaTime * 5f);
				SpriteRenderer component = visual.SpriteClone.GetComponent<SpriteRenderer>();
				if ((Object)(object)component != (Object)null)
				{
					if ((Object)(object)component.sprite == (Object)null)
					{
						Sprite classBaseSprite = GetClassBaseSprite(coopPlayerSummary2.ChosenClass);
						if ((Object)(object)classBaseSprite != (Object)null)
						{
							component.sprite = classBaseSprite;
						}
					}
					Color slotColor = GetSlotColor(visual.SlotIndex);
					component.color = ((latestActiveSlot == visual.SlotIndex) ? Color.Lerp(component.color, Color.white, Time.deltaTime * 3f) : Color.Lerp(component.color, slotColor, Time.deltaTime * 3f));
				}
				Animator component2 = visual.SpriteClone.GetComponent<Animator>();
				if ((Object)(object)component2 != (Object)null && (Object)(object)component2.runtimeAnimatorController == (Object)null)
				{
					RuntimeAnimatorController classAnimationController = GetClassAnimationController(coopPlayerSummary2.ChosenClass);
					if ((Object)(object)classAnimationController != (Object)null)
					{
						component2.runtimeAnimatorController = classAnimationController;
					}
				}
			}
		}

		private void UpdatePlayerLabel(PlayerVisual visual, CoopPlayerSummary summary, Vector3 charPos, int activeSlot, Camera cam)
		{
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: 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_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			if (visual == null || (Object)(object)cam == (Object)null)
			{
				return;
			}
			if ((Object)(object)visual.HpText != (Object)null)
			{
				((TMP_Text)visual.HpText).text = $"{summary.CurrentHealth:F0}/{summary.MaxHealth:F0}";
			}
			if ((Object)(object)visual.NameText != (Object)null)
			{
				((TMP_Text)visual.NameText).text = FormatName(summary.PlayerName, summary.SlotIndex);
			}
			PositionPanelAtWorld(visual.NamePanel, charPos + new Vector3(0f, 2f, 0f), cam);
			PositionPanelAtWorld(visual.HpPanel, charPos + new Vector3(0f, -0.6f, 0f), cam);
			bool flag = activeSlot == visual.SlotIndex;
			if ((Object)(object)visual.NameText != (Object)null)
			{
				if (flag)
				{
					float num = (Mathf.Sin(Time.unscaledTime * 3f) + 1f) * 0.5f;
					((Graphic)visual.NameText).color = Color.Lerp(_nameColorBase, _nameColorActive, num);
				}
				else
				{
					((Graphic)visual.NameText).color = _nameColorBase;
				}
			}
			if ((Object)(object)visual.ArrowPanel != (Object)null)
			{
				visual.ArrowPanel.SetActive(flag);
				if (flag)
				{
					PositionPanelAtWorld(visual.ArrowPanel, charPos + new Vector3(1f, 0.5f, 0f), cam);
					float num2 = (Mathf.Sin(Time.unscaledTime * 4f) + 1f) * 0.5f;
					float num3 = Mathf.Lerp(0.85f, 1.15f, num2);
					visual.ArrowPanel.transform.localScale = new Vector3(num3, num3, 1f);
					if ((Object)(object)visual.ArrowText != (Object)null)
					{
						((Graphic)visual.ArrowText).color = Color.Lerp(_arrowColorDim, _arrowColorBright, num2);
					}
				}
			}
			UpdateStatusIcons(visual, summary.StatusEffects, charPos, cam);
		}

		private void UpdateStatusIcons(PlayerVisual visual, List<StatusEffectEntry> effects, Vector3 charPos, Camera cam)
		{
			//IL_024d: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c2: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)visual.StatusIconContainer == (Object)null)
			{
				return;
			}
			bool flag = effects != null && effects.Count > 0;
			_activeTypesScratch.Clear();
			_removeScratch.Clear();
			if (flag)
			{
				foreach (StatusEffectEntry effect in effects)
				{
					if (effect.Intensity > 0)
					{
						_activeTypesScratch.Add(effect.EffectType);
					}
				}
			}
			foreach (KeyValuePair<int, StatusIconEntry> statusIcon in visual.StatusIcons)
			{
				if (_activeTypesScratch.Contains(statusIcon.Key))
				{
					continue;
				}
				try
				{
					if ((Object)(object)statusIcon.Value.Root != (Object)null)
					{
						Object.Destroy((Object)(object)statusIcon.Value.Root);
					}
				}
				catch
				{
				}
				_removeScratch.Add(statusIcon.Key);
			}
			foreach (int item in _removeScratch)
			{
				visual.StatusIcons.Remove(item);
			}
			if (!flag)
			{
				visual.StatusIconContainer.SetActive(false);
				return;
			}
			foreach (StatusEffectEntry effect2 in effects)
			{
				if (effect2.Intensity <= 0)
				{
					continue;
				}
				if (visual.StatusIcons.TryGetValue(effect2.EffectType, out var value))
				{
					if ((Object)(object)value.IntensityText != (Object)null)
					{
						((TMP_Text)value.IntensityText).text = ((effect2.Intensity > 999) ? (effect2.Intensity / 1000 + "K") : effect2.Intensity.ToString());
					}
					continue;
				}
				StatusIconEntry statusIconEntry = CreateStatusIcon(effect2.EffectType, effect2.Intensity, visual.StatusIconContainer.transform);
				if (statusIconEntry != null)
				{
					visual.StatusIcons[effect2.EffectType] = statusIconEntry;
				}
			}
			visual.StatusIconContainer.SetActive(true);
			PositionPanelAtWorld(visual.StatusIconContainer, charPos + new Vector3(0f, 2.9f, 0f), cam);
			Vector3 worldAnchor = charPos + new Vector3(0f, 2.2f, 0f);
			foreach (KeyValuePair<int, StatusIconEntry> statusIcon2 in visual.StatusIcons)
			{
				if ((Object)(object)statusIcon2.Value.Hover != (Object)null)
				{
					statusIcon2.Value.Hover.WorldAnchor = worldAnchor;
				}
			}
		}

		private StatusIconEntry CreateStatusIcon(int effectType, int intensity, Transform parent)
		{
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = new GameObject($"StatusIcon_{effectType}", new Type[1] { typeof(RectTransform) });
				val.transform.SetParent(parent, false);
				RectTransform component = val.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null)
				{
					component.sizeDelta = new Vector2(50f, 50f);
				}
				LayoutElement val2 = val.AddComponent<LayoutElement>();
				if ((Object)(object)val2 != (Object)null)
				{
					val2.preferredWidth = 50f;
					val2.preferredHeight = 50f;
				}
				Image val3 = val.AddComponent<Image>();
				if ((Object)(object)val3 != (Object)null)
				{
					Sprite statusEffectSprite = GetStatusEffectSprite(effectType);
					if ((Object)(object)statusEffectSprite != (Object)null)
					{
						val3.sprite = statusEffectSprite;
						val3.preserveAspect = true;
					}
					else
					{
						((Graphic)val3).color = new Color(0.4f, 0.3f, 0.6f, 0.8f);
					}
					((Graphic)val3).raycastTarget = true;
				}
				StatusIconHoverHandler statusIconHoverHandler = val.AddComponent<StatusIconHoverHandler>();
				statusIconHoverHandler.EffectType = (StatusEffectType)effectType;
				GameObject val4 = new GameObject("Intensity", new Type[1] { typeof(RectTransform) });
				val4.transform.SetParent(val.transform, false);
				TextMeshProUGUI val5 = val4.AddComponent<TextMeshProUGUI>();
				if ((Object)(object)val5 == (Object)null)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)$"[CoopPlayerVisuals] AddComponent<TextMeshProUGUI> returned null for effect {effectType}");
					}
					return new StatusIconEntry
					{
						Root = val,
						IconImage = val3,
						IntensityText = null
					};
				}
				((TMP_Text)val5).text = ((intensity > 999) ? (intensity / 1000 + "K") : intensity.ToString());
				((TMP_Text)val5).fontSize = 32f;
				((TMP_Text)val5).fontStyle = (FontStyles)0;
				TMP_FontAsset statusEffectNumberFont = GetStatusEffectNumberFont();
				if ((Object)(object)statusEffectNumberFont != (Object)null)
				{
					((TMP_Text)val5).font = statusEffectNumberFont;
				}
				((TMP_Text)val5).alignment = (TextAlignmentOptions)1028;
				((Graphic)val5).color = Color.white;
				try
				{
					((TMP_Text)val5).outlineWidth = 0.35f;
				}
				catch
				{
				}
				try
				{
					((TMP_Text)val5).outlineColor = Color32.op_Implicit(Color.black);
				}
				catch
				{
				}
				((TMP_Text)val5).enableWordWrapping = false;
				((TMP_Text)val5).overflowMode = (TextOverflowModes)0;
				((Graphic)val5).raycastTarget = false;
				RectTransform rectTransform = ((TMP_Text)val5).rectTransform;
				if ((Object)(object)rectTransform != (Object)null)
				{
					rectTransform.anchorMin = new Vector2(1f, 0f);
					rectTransform.anchorMax = new Vector2(1f, 0f);
					rectTransform.pivot = new Vector2(1f, 0f);
					rectTransform.sizeDelta = new Vector2(44f, 30f);
					rectTransform.anchoredPosition = new Vector2(8f, -6f);
				}
				return new StatusIconEntry
				{
					Root = val,
					IconImage = val3,
					IntensityText = val5,
					Hover = statusIconHoverHandler
				};
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)$"[CoopPlayerVisuals] CreateStatusIcon({effectType}, {intensity}) failed: {arg}");
				}
				return null;
			}
		}

		private void HideNativeStatusIcons()
		{
			try
			{
				PlayerStatusEffectController cachedStatusController = GetCachedStatusController();
				if (!((Object)(object)cachedStatusController == (Object)null))
				{
					object? obj = AccessTools.Field(typeof(PlayerStatusEffectController), "_statusEffectUI")?.GetValue(cachedStatusController);
					StatusEffectIconManager val = (StatusEffectIconManager)((obj is StatusEffectIconManager) ? obj : null);
					if (!((Object)(object)val == (Object)null) && (Object)(object)val.horizontalContainer != (Object)null && ((Component)val.horizontalContainer).gameObject.activeSelf)
					{
						((Component)val.horizontalContainer).gameObject.SetActive(false);
					}
				}
			}
			catch
			{
			}
		}

		private PlayerStatusEffectController GetCachedStatusController()
		{
			if ((Object)(object)_cachedStatusCtrl == (Object)null)
			{
				_cachedStatusCtrl = Object.FindObjectOfType<PlayerStatusEffectController>();
			}
			return _cachedStatusCtrl;
		}

		private static StatusEffectData GetStatusEffectData()
		{
			if (_statusEffectDataSearched)
			{
				return _statusEffectData;
			}
			_statusEffectDataSearched = true;
			try
			{
				StatusEffectData[] array = Resources.FindObjectsOfTypeAll<StatusEffectData>();
				if (array.Length != 0)
				{
					_statusEffectData = array[0];
				}
			}
			catch
			{
			}
			return _statusEffectData;
		}

		private static Sprite GetStatusEffectSprite(int effectType)
		{
			StatusEffectData statusEffectData = GetStatusEffectData();
			if ((Object)(object)statusEffectData == (Object)null)
			{
				return null;
			}
			return statusEffectData.GetStatusEffectIcon((StatusEffectType)effectType);
		}

		private void PositionPanelAtWorld(GameObject panel, Vector3 worldPos, Camera cam)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: 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_0073: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)panel == (Object)null || (Object)(object)cam == (Object)null)
			{
				return;
			}
			Vector3 val = cam.WorldToScreenPoint(worldPos);
			if (val.z < 0f)
			{
				panel.SetActive(false);
				return;
			}
			if (!panel.activeSelf)
			{
				panel.SetActive(true);
			}
			RectTransform component = panel.GetComponent<RectTransform>();
			if (!((Object)(object)component == (Object)null))
			{
				if ((Object)(object)_overlayCanvasRect != (Object)null)
				{
					Vector2 val2 = default(Vector2);
					RectTransformUtility.ScreenPointToLocalPointInRectangle(_overlayCanvasRect, Vector2.op_Implicit(val), (Camera)null, ref val2);
					((Transform)component).localPosition = Vector2.op_Implicit(val2);
				}
				else
				{
					((Transform)component).position = val;
				}
			}
		}

		private void CleanupVisuals()
		{
			foreach (PlayerVisual visual in _visuals)
			{
				DestroyVisual(visual);
			}
			_visuals.Clear();
			if (_hostLabel != null)
			{
				DestroyPanels(_hostLabel);
				_hostLabel = null;
			}
		}

		private void DestroyVisual(PlayerVisual v)
		{
			try
			{
				if ((Object)(object)v.SpriteClone != (Object)null)
				{
					Object.Destroy((Object)(object)v.SpriteClone);
				}
			}
			catch
			{
			}
			DestroyPanels(v);
		}

		private void DestroyPanels(PlayerVisual v)
		{
			try
			{
				if ((Object)(object)v.NamePanel != (Object)null)
				{
					Object.Destroy((Object)(object)v.NamePanel);
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)v.HpPanel != (Object)null)
				{
					Object.Destroy((Object)(object)v.HpPanel);
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)v.ArrowPanel != (Object)null)
				{
					Object.Destroy((Object)(object)v.ArrowPanel);
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)v.StatusIconContainer != (Object)null)
				{
					Object.Destroy((Object)(object)v.StatusIconContainer);
				}
			}
			catch
			{
			}
			v.StatusIcons?.Clear();
		}

		private static Color GetSlotColor(int slot)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(slot switch
			{
				1 => new Color(0.7f, 0.85f, 1f), 
				2 => new Color(1f, 0.8f, 0.7f), 
				3 => new Color(0.8f, 1f, 0.7f), 
				_ => new Color(0.9f, 0.9f, 0.9f), 
			});
		}

		private static RuntimeAnimatorController GetClassAnimationController(int chosenClass)
		{
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: 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_0124: Expected I4, but got Unknown
			try
			{
				RuntimeAnimatorController cachedController = GetCachedController(chosenClass);
				if ((Object)(object)cachedController != (Object)null)
				{
					return cachedController;
				}
				PeglinClassAnimationSwitcher[] array = Resources.FindObjectsOfTypeAll<PeglinClassAnimationSwitcher>();
				if (array != null)
				{
					PeglinClassAnimationSwitcher[] array2 = array;
					foreach (PeglinClassAnimationSwitcher val in array2)
					{
						if (!((Object)(object)val == (Object)null))
						{
							if ((Object)(object)_cachedPeglinCtrl == (Object)null && (Object)(object)val.peglinAnimationController != (Object)null)
							{
								_cachedPeglinCtrl = val.peglinAnimationController;
							}
							if ((Object)(object)_cachedBalladinCtrl == (Object)null && (Object)(object)val.balladinAnimationController != (Object)null)
							{
								_cachedBalladinCtrl = val.balladinAnimationController;
							}
							if ((Object)(object)_cachedRoundrelCtrl == (Object)null && (Object)(object)val.roundrelAnimationController != (Object)null)
							{
								_cachedRoundrelCtrl = val.roundrelAnimationController;
							}
							if ((Object)(object)_cachedSpinventorCtrl == (Object)null && (Object)(object)val.spinventorAnimationController != (Object)null)
							{
								_cachedSpinventorCtrl = val.spinventorAnimationController;
							}
						}
					}
				}
				cachedController = GetCachedController(chosenClass);
				if ((Object)(object)cachedController != (Object)null)
				{
					return cachedController;
				}
				Class val2 = (Class)chosenClass;
				string value = (val2 - 1) switch
				{
					0 => "balladin", 
					1 => "roundrel", 
					2 => "spinventor", 
					_ => "peglin", 
				};
				RuntimeAnimatorController[] array3 = Resources.FindObjectsOfTypeAll<RuntimeAnimatorController>();
				if (array3 != null)
				{
					RuntimeAnimatorController[] array4 = array3;
					foreach (RuntimeAnimatorController val3 in array4)
					{
						if (!((Object)(object)val3 == (Object)null) && !string.IsNullOrEmpty(((Object)val3).name))
						{
							string text = ((Object)val3).name.ToLowerInvariant();
							if (text.Contains(value) && !text.Contains("peg_") && !text.Contains("bomb") && !text.Contains("slime"))
							{
								SetCachedController(chosenClass, val3);
								return val3;
							}
						}
					}
				}
				if (_loggedMissingClassCtrl.Add(chosenClass))
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)$"[CoopPlayerVisuals] No animation controller for class {chosenClass} — clone will show static sprite");
					}
				}
				return null;
			}
			catch
			{
				return null;
			}
		}

		private static RuntimeAnimatorController GetCachedController(int chosenClass)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected I4, but got Unknown
			Class val = (Class)chosenClass;
			return (RuntimeAnimatorController)((val - 1) switch
			{
				0 => _cachedBalladinCtrl, 
				1 => _cachedRoundrelCtrl, 
				2 => _cachedSpinventorCtrl, 
				_ => _cachedPeglinCtrl, 
			});
		}

		private static void SetCachedController(int chosenClass, RuntimeAnimatorController ctrl)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected I4, but got Unknown
			Class val = (Class)chosenClass;
			switch (val - 1)
			{
			case 0:
				_cachedBalladinCtrl = ctrl;
				break;
			case 1:
				_cachedRoundrelCtrl = ctrl;
				break;
			case 2:
				_cachedSpinventorCtrl = ctrl;
				break;
			default:
				_cachedPeglinCtrl = ctrl;
				break;
			}
		}

		private static Sprite GetClassBaseSprite(int chosenClass)
		{
			try
			{
				Sprite cachedSprite = GetCachedSprite(chosenClass);
				if ((Object)(object)cachedSprite != (Object)null)
				{
					return cachedSprite;
				}
				PeglinClassAnimationSwitcher[] array = Resources.FindObjectsOfTypeAll<PeglinClassAnimationSwitcher>();
				if (array != null)
				{
					PeglinClassAnimationSwitcher[] array2 = array;
					foreach (PeglinClassAnimationSwitcher val in array2)
					{
						if (!((Object)(object)val == (Object)null))
						{
							if ((Object)(object)_cachedPeglinSprite == (Object)null && (Object)(object)val.peglinBaseSprite != (Object)null)
							{
								_cachedPeglinSprite = val.peglinBaseSprite;
							}
							if ((Object)(object)_cachedBalladinSprite == (Object)null && (Object)(object)val.balladinBaseSprite != (Object)null)
							{
								_cachedBalladinSprite = val.balladinBaseSprite;
							}
							if ((Object)(object)_cachedRoundrelSprite == (Object)null && (Object)(object)val.roundrelBaseSprite != (Object)null)
							{
								_cachedRoundrelSprite = val.roundrelBaseSprite;
							}
							if ((Object)(object)_cachedSpinventorSprite == (Object)null && (Object)(object)val.spinventorBaseSprite != (Object)null)
							{
								_cachedSpinventorSprite = val.spinventorBaseSprite;
							}
						}
					}
				}
				cachedSprite = GetCachedSprite(chosenClass);
				if ((Object)(object)cachedSprite != (Object)null)
				{
					return cachedSprite;
				}
				Sprite classBaseSpriteFromClassInfo = GetClassBaseSpriteFromClassInfo(chosenClass);
				if ((Object)(object)classBaseSpriteFromClassInfo != (Object)null)
				{
					SetCachedSprite(chosenClass, classBaseSpriteFromClassInfo);
					return classBaseSpriteFromClassInfo;
				}
				Sprite classBaseSpriteFromSelectableCharacter = GetClassBaseSpriteFromSelectableCharacter(chosenClass);
				if ((Object)(object)classBaseSpriteFromSelectableCharacter != (Object)null)
				{
					SetCachedSprite(chosenClass, classBaseSpriteFromSelectableCharacter);
					return classBaseSpriteFromSelectableCharacter;
				}
				Sprite classBaseSpriteFromAddressable = GetClassBaseSpriteFromAddressable(chosenClass);
				if ((Object)(object)classBaseSpriteFromAddressable != (Object)null)
				{
					SetCachedSprite(chosenClass, classBaseSpriteFromAddressable);
					return classBaseSpriteFromAddressable;
				}
				if (_loggedMissingClassSprite.Add(chosenClass))
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)$"[CoopPlayerVisuals] No sprite for class {chosenClass} — switchers={((array != null) ? array.Length : 0)}, caches: P={(Object)(object)_cachedPeglinSprite != (Object)null} B={(Object)(object)_cachedBalladinSprite != (Object)null} R={(Object)(object)_cachedRoundrelSprite != (Object)null} S={(Object)(object)_cachedSpinventorSprite != (Object)null}");
					}
				}
				return null;
			}
			catch
			{
				return null;
			}
		}

		private static Sprite GetCachedSprite(int chosenClass)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected I4, but got Unknown
			Class val = (Class)chosenClass;
			return (Sprite)((val - 1) switch
			{
				0 => _cachedBalladinSprite, 
				1 => _cachedRoundrelSprite, 
				2 => _cachedSpinventorSprite, 
				_ => _cachedPeglinSprite, 
			});
		}

		private static void SetCachedSprite(int chosenClass, Sprite sprite)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected I4, but got Unknown
			Class val = (Class)chosenClass;
			switch (val - 1)
			{
			case 0:
				_cachedBalladinSprite = sprite;
				break;
			case 1:
				_cachedRoundrelSprite = sprite;
				break;
			case 2:
				_cachedSpinventorSprite = sprite;
				break;
			default:
				_cachedPeglinSprite = sprite;
				break;
			}
		}

		private static Sprite GetClassBaseSpriteFromClassInfo(int chosenClass)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			try
			{
				ClassInfo[] array = Resources.FindObjectsOfTypeAll<ClassInfo>();
				if (array == null)
				{
					return null;
				}
				ClassInfo[] array2 = array;
				foreach (ClassInfo val in array2)
				{
					if ((Object)(object)val != (Object)null && (int)val.characterClass == chosenClass && (Object)(object)val.classSprite != (Object)null)
					{
						return val.classSprite;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static Sprite GetClassBaseSpriteFromSelectableCharacter(int chosenClass)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Invalid comparison between Unknown and I4
			try
			{
				SelectableCharacter[] array = Resources.FindObjectsOfTypeAll<SelectableCharacter>();
				if (array == null)
				{
					return null;
				}
				SelectableCharacter[] array2 = array;
				foreach (SelectableCharacter val in array2)
				{
					if ((Object)(object)val != (Object)null && (int)val.characterClass == chosenClass && (Object)(object)val.idleSprite != (Object)null)
					{
						return val.idleSprite;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static Sprite GetClassBaseSpriteFromAddressable(int chosenClass)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Invalid comparison between Unknown and I4
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Invalid comparison between Unknown and I4
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!_addressableAttempted.Add(chosenClass))
				{
					return null;
				}
				Class val = (Class)chosenClass;
				string[] array = (((int)val == 2) ? new string[1] { "Assets/Art/Peglin/Roundrel/Sprites/roundrel.png" } : (((int)val != 3) ? new string[0] : new string[1] { "Assets/Art/Peglin/Spinventor/spinventor.png" }));
				array = array;
				Rect val4 = default(Rect);
				foreach (string text in array)
				{
					Sprite val2 = null;
					try
					{
						val2 = Addressables.LoadAssetAsync<Sprite>((object)text).WaitForCompletion();
					}
					catch
					{
						val2 = null;
					}
					if ((Object)(object)val2 != (Object)null)
					{
						ManualLogSource log = Log;
						if (log != null)
						{
							log.LogInfo((object)$"[CoopPlayerVisuals] Loaded class {chosenClass} sprite from Addressable '{text}'");
						}
						return val2;
					}
					try
					{
						Texture2D val3 = Addressables.LoadAssetAsync<Texture2D>((object)text).WaitForCompletion();
						if (!((Object)(object)val3 != (Object)null))
						{
							continue;
						}
						((Rect)(ref val4))..ctor(0f, 0f, (float)((Texture)val3).width, (float)((Texture)val3).height);
						Sprite val5 = Sprite.Create(val3, val4, new Vector2(0.5f, 0.5f), 16f);
						if ((Object)(object)val5 != (Object)null)
						{
							ManualLogSource log2 = Log;
							if (log2 != null)
							{
								log2.LogInfo((object)$"[CoopPlayerVisuals] Built class {chosenClass} sprite from Addressable Texture2D '{text}' (size={((Texture)val3).width}x{((Texture)val3).height})");
							}
							return val5;
						}
					}
					catch
					{
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogWarning((object)$"[CoopPlayerVisuals] Addressable sprite fallback failed for class {chosenClass}: {ex.Message}");
				}
			}
			return null;
		}

		public static void Reset()
		{
			LatestPlayerSummaries = null;
			LatestActiveSlot = -1;
			_statusEffectDataSearched = false;
			_statusEffectData = null;
			_loggedMissingClassSprite.Clear();
			_addressableAttempted.Clear();
			_cachedPeglinSprite = (_cachedBalladinSprite = (_cachedRoundrelSprite = (_cachedSpinventorSprite = null)));
			_cachedPeglinCtrl = (_cachedBalladinCtrl = (_cachedRoundrelCtrl = (_cachedSpinventorCtrl = null)));
			_loggedMissingClassCtrl.Clear();
		}
	}
	public class CoopRewardUI : MonoBehaviour
	{
		private enum DisplayState
		{
			Hidden,
			RelicChoices,
			RewardChoices,
			Waiting
		}

		private GameObject _canvasObj;

		private GameObject _overlayPanel;

		private TextMeshProUGUI _titleText;

		private TextMeshProUGUI _statusText;

		private GameObject _buttonContainer;

		private readonly List<GameObject> _buttons = new List<GameObject>();

		private DisplayState _currentState;

		private int _displayedRelicCount;

		private int _displayedRewardCount;

		private string _lastSceneName;

		public const int FORCE_SKIP_SECONDS = 45;

		private float _hostWaitingStartTime = -1f;

		private string _hostWaitingPhaseKey;

		private GameObject _forceContinueButton;

		private GameObject _navForceButton;

		private float _navPhaseStartedAt = -1f;

		private GameObject _navWaitBanner;

		private TextMeshProUGUI _navWaitBannerText;

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		private void Start()
		{
			try
			{
				CreateUI();
			}
			catch (Exception arg)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogError((object)$"[CoopRewardUI] Start failed: {arg}");
				}
			}
		}

		private void CreateUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Expected O, but got Unknown
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Expected O, but got Unknown
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Expected O, but got Unknown
			//IL_01fc: 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_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_024f: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0301: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_032b: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			_canvasObj = new GameObject("CoopRewardCanvas");
			Object.DontDestroyOnLoad((Object)(object)_canvasObj);
			Canvas obj = _canvasObj.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 200;
			CanvasScaler obj2 = _canvasObj.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			obj2.matchWidthOrHeight = 0.5f;
			_canvasObj.AddComponent<GraphicRaycaster>();
			_overlayPanel = new GameObject("RewardOverlay");
			_overlayPanel.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_overlayPanel.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.88f);
			StretchFill(_overlayPanel.GetComponent<RectTransform>());
			GameObject val = new GameObject("Title");
			val.transform.SetParent(_overlayPanel.transform, false);
			_titleText = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_titleText).text = "Choose a Reward";
			((TMP_Text)_titleText).fontSize = 48f;
			((TMP_Text)_titleText).alignment = (TextAlignmentOptions)514;
			((Graphic)_titleText).color = Color.white;
			RectTransform rectTransform = ((TMP_Text)_titleText).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 1f);
			rectTransform.anchorMax = new Vector2(0.5f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, -40f);
			rectTransform.sizeDelta = new Vector2(800f, 64f);
			_buttonContainer = new GameObject("ButtonContainer");
			_buttonContainer.transform.SetParent(_overlayPanel.transform, false);
			RectTransform obj3 = _buttonContainer.AddComponent<RectTransform>();
			obj3.anchorMin = new Vector2(0.5f, 0.5f);
			obj3.anchorMax = new Vector2(0.5f, 0.5f);
			obj3.pivot = new Vector2(0.5f, 0.5f);
			obj3.anchoredPosition = new Vector2(0f, 0f);
			obj3.sizeDelta = new Vector2(900f, 400f);
			GameObject val2 = new GameObject("StatusText");
			val2.transform.SetParent(_overlayPanel.transform, false);
			_statusText = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_statusText).text = string.Empty;
			((TMP_Text)_statusText).fontSize = 32f;
			((TMP_Text)_statusText).alignment = (TextAlignmentOptions)514;
			((Graphic)_statusText).color = new Color(0.8f, 0.8f, 0.3f);
			RectTransform rectTransform2 = ((TMP_Text)_statusText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.5f, 0f);
			rectTransform2.anchorMax = new Vector2(0.5f, 0f);
			rectTransform2.pivot = new Vector2(0.5f, 0f);
			rectTransform2.anchoredPosition = new Vector2(0f, 80f);
			rectTransform2.sizeDelta = new Vector2(800f, 48f);
			_overlayPanel.SetActive(false);
			CreateNavWaitBanner();
		}

		private void CreateNavWaitBanner()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_004c: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Expected O, but got Unknown
			//IL_0142: 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_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			_navWaitBanner = new GameObject("NavWaitBanner");
			_navWaitBanner.transform.SetParent(_canvasObj.transform, false);
			Image obj = _navWaitBanner.AddComponent<Image>();
			((Graphic)obj).color = new Color(0f, 0f, 0f, 0.55f);
			((Graphic)obj).raycastTarget = false;
			RectTransform component = _navWaitBanner.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 1f);
			component.anchorMax = new Vector2(0.5f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = new Vector2(0f, -24f);
			component.sizeDelta = new Vector2(720f, 60f);
			GameObject val = new GameObject("Text");
			val.transform.SetParent(_navWaitBanner.transform, false);
			_navWaitBannerText = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_navWaitBannerText).text = "Waiting for other players to navigate...";
			((TMP_Text)_navWaitBannerText).fontSize = 28f;
			((TMP_Text)_navWaitBannerText).alignment = (TextAlignmentOptions)514;
			((Graphic)_navWaitBannerText).color = new Color(1f, 0.92f, 0.6f);
			((Graphic)_navWaitBannerText).raycastTarget = false;
			RectTransform rectTransform = ((TMP_Text)_navWaitBannerText).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = new Vector2(16f, 4f);
			rectTransform.offsetMax = new Vector2(-16f, -4f);
			_navWaitBanner.SetActive(false);
		}

		private void Update()
		{
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_overlayPanel == (Object)null)
				{
					return;
				}
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (_lastSceneName != null && _lastSceneName != name)
				{
					if (!(name == "Battle") && !(_lastSceneName == "Battle"))
					{
						switch (name)
						{
						case "ForestMap":
						case "CastleMap":
						case "MinesMap":
							goto IL_0094;
						}
						if (!(name == "CoreMap"))
						{
							goto IL_0103;
						}
					}
					goto IL_0094;
				}
				goto IL_0103;
				IL_0094:
				if (_currentState != 0)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogInfo((object)("[CoopRewardUI] Scene change " + _lastSceneName + " -> " + name + ", hiding overlay"));
					}
					HideOverlay();
					CoopRewardState.Reset();
					CoopNavigateState.Reset();
					DestroyNavForceButton();
					_navPhaseStartedAt = -1f;
					MultiplayerClientPatches.AllowNavigateLogic = false;
				}
				goto IL_0103;
				IL_0103:
				_lastSceneName = name;
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || (!instance.IsHosting && !instance.IsSpectating))
				{
					return;
				}
				TickNavigateStandaloneForce(instance);
				CoopNavigateResolver.TickWatchdog();
				CoopWaitWatchdog.Tick(instance);
				CoopNavigateSlotPainter.Tick();
				bool flag = CoopNavigateState.PhaseActive && CoopNavigateState.LocalVoteCast && !CoopNavigateState.Resolved;
				if (flag && !CoopRewardState.WaitingForOtherPlayers)
				{
					if (_currentState != 0)
					{
						HideOverlay();
					}
					ShowNavWaitBanner();
					TickHostForceContinue();
					return;
				}
				HideNavWaitBanner();
				if (CoopRewardState.AllChoicesComplete)
				{
					if (_currentState != 0)
					{
						HideOverlay();
						CoopRewardState.Reset();
					}
					return;
				}
				if (CoopRewardState.WaitingForOtherPlayers || flag)
				{
					if (_currentState != DisplayState.Waiting)
					{
						ShowWaiting();
					}
					TickHostForceContinue();
					return;
				}
				RelicChoicesEvent pendingRelicChoices = CoopRewardState.PendingRelicChoices;
				if (pendingRelicChoices?.Choices != null && pendingRelicChoices.Choices.Count > 0)
				{
					if (_currentState != DisplayState.RelicChoices || _displayedRelicCount != pendingRelicChoices.Choices.Count)
					{
						ShowRelicChoices(pendingRelicChoices);
					}
				}
				else if (_currentState != 0)
				{
					HideOverlay();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogError((object)("[CoopRewardUI] Update error: " + ex.Message));
				}
			}
		}

		private void ShowRelicChoices(RelicChoicesEvent choices)
		{
			//IL_0174: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ba: Expected O, but got Unknown
			ClearButtons();
			((TMP_Text)_titleText).text = "Choose a Relic";
			((TMP_Text)_statusText).text = string.Empty;
			_overlayPanel.SetActive(true);
			_currentState = DisplayState.RelicChoices;
			_displayedRelicCount = choices.Choices.Count;
			float num = 340f;
			float num2 = 20f;
			float num3 = (0f - ((float)choices.Choices.Count * num + (float)(choices.Choices.Count - 1) * num2)) / 2f + num / 2f;
			for (int i = 0; i < choices.Choices.Count; i++)
			{
				RelicEntry relicEntry = choices.Choices[i];
				float num4 = num3 + (float)i * (num + num2);
				string text = relicEntry.LocKey ?? string.Empty;
				try
				{
					if (!string.IsNullOrEmpty(text) && !text.Contains(" "))
					{
						string translation = LocalizationManager.GetTranslation("Relics/" + text + "_desc", true, 0, true, false, (GameObject)null, (string)null, true);
						if (string.IsNullOrEmpty(translation))
						{
							translation = LocalizationManager.GetTranslation(text, true, 0, true, false, (GameObject)null, (string)null, true);
						}
						if (!string.IsNullOrEmpty(translation))
						{
							text = translation;
						}
					}
				}
				catch
				{
				}
				Button obj2 = CreateChoiceButton(_buttonContainer.transform, $"RelicBtn_{i}", relicEntry.EffectName ?? $"Relic {relicEntry.Effect}", text, new Color(0.25f, 0.2f, 0.45f), new Vector2(num4, 0f), new Vector2(num, 260f));
				int capturedEffect = relicEntry.Effect;
				((UnityEvent)obj2.onClick).AddListener((UnityAction)delegate
				{
					OnRelicChosen(capturedEffect);
				});
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"[CoopRewardUI] Showing {choices.Choices.Count} relic choices");
			}
		}

		private void ShowRewardChoices(RewardChoicesEvent choices)
		{
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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_0142: Expected O, but got Unknown
			ClearButtons();
			((TMP_Text)_titleText).text = "Choose a Reward";
			((TMP_Text)_statusText).text = string.Empty;
			_overlayPanel.SetActive(true);
			_currentState = DisplayState.RewardChoices;
			_displayedRewardCount = choices.Options.Count;
			float num = 240f;
			float num2 = 16f;
			float num3 = (0f - ((float)choices.Options.Count * num + (float)(choices.Options.Count - 1) * num2)) / 2f + num / 2f;
			for (int i = 0; i < choices.Options.Count; i++)
			{
				RewardOption rewardOption = choices.Options[i];
				float num4 = num3 + (float)i * (num + num2);
				Color rewardColor = GetRewardColor(rewardOption.Type);
				Button obj = CreateChoiceButton(_buttonContainer.transform, $"RewardBtn_{i}", rewardOption.DisplayName ?? rewardOption.Type, rewardOption.Description ?? string.Empty, rewardColor, new Vector2(num4, 0f), new Vector2(num, 200f));
				int capturedIndex = rewardOption.OptionIndex;
				((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
				{
					OnRewardChosen(capturedIndex);
				});
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"[CoopRewardUI] Showing {choices.Options.Count} reward choices");
			}
		}

		private void ShowNavWaitBanner()
		{
			if (!((Object)(object)_navWaitBanner == (Object)null))
			{
				if (!_navWaitBanner.activeSelf)
				{
					_navWaitBanner.SetActive(true);
				}
				if (Object.op_Implicit((Object)(object)_navWaitBannerText))
				{
					((TMP_Text)_navWaitBannerText).text = "Waiting for other players to navigate...";
				}
			}
		}

		private void HideNavWaitBanner()
		{
			if ((Object)(object)_navWaitBanner != (Object)null && _navWaitBanner.activeSelf)
			{
				_navWaitBanner.SetActive(false);
			}
		}

		private void ShowWaiting()
		{
			ClearButtons();
			IServiceContainer services = MultiplayerPlugin.Services;
			IMultiplayerMode instance;
			bool flag = services != null && services.TryResolve<IMultiplayerMode>(out instance) && instance.IsHosting;
			if (CoopRewardState.ShopAwaitingHostNavigation || CoopRewardState.TextScenarioAwaitingHostNavigation || CoopRewardState.PegMinigameAwaitingHostNavigation)
			{
				((TMP_Text)_titleText).text = "Waiting for other players to select the next stage...";
			}
			else if (CoopRewardState.TreasureAwaitingHostNavigation)
			{
				((TMP_Text)_titleText).text = "Waiting for other players...";
			}
			else if (CoopRewardState.TextScenarioPhaseActive)
			{
				((TMP_Text)_titleText).text = "Waiting for other players to finish the event...";
			}
			else if (CoopRewardState.ShopPhaseActive)
			{
				((TMP_Text)_titleText).text = "Waiting for other players to finish shopping...";
			}
			else if (CoopRewardState.TreasurePhaseActive)
			{
				((TMP_Text)_titleText).text = "Waiting for other players to choose a relic...";
			}
			else if (CoopRewardState.PegMinigamePhaseActive)
			{
				((TMP_Text)_titleText).text = "Waiting for other players to finish...";
			}
			else if (CoopNavigateState.PhaseActive && CoopNavigateState.LocalVoteCast && !CoopNavigateState.Resolved)
			{
				((TMP_Text)_titleText).text = "Waiting for other players to navigate...";
			}
			else if (CoopRewardState.HostRelicSelectionActive)
			{
				((TMP_Text)_titleText).text = (flag ? "Waiting for all players to choose their initial relic..." : "Other players are choosing their initial relics...");
			}
			else if (CoopRewardState.ClientInNativeRewardPhase || CoopRewardState.HostRewardPhaseActive)
			{
				((TMP_Text)_titleText).text = "Waiting for other players...";
			}
			else
			{
				((TMP_Text)_titleText).text = "Waiting...";
			}
			((TMP_Text)_statusText).text = string.Empty;
			_overlayPanel.SetActive(true);
			_currentState = DisplayState.Waiting;
			if (flag)
			{
				string text = ResolveHostWaitingPhase();
				if (text != null)
				{
					if (_hostWaitingPhaseKey != text)
					{
						_hostWaitingPhaseKey = text;
						_hostWaitingStartTime = Time.unscaledTime;
						DestroyForceContinueButton();
					}
				}
				else
				{
					ClearHostWaitingTimer();
				}
			}
			else
			{
				ClearHostWaitingTimer();
			}
		}

		private void HideOverlay()
		{
			ClearButtons();
			DestroyForceContinueButton();
			ClearHostWaitingTimer();
			_overlayPanel.SetActive(false);
			HideNavWaitBanner();
			_currentState = DisplayState.Hidden;
			_displayedRelicCount = 0;
			_displayedRewardCount = 0;
		}

		private static string ResolveHostWaitingPhase()
		{
			if (CoopRewardState.ShopPhaseActive && CoopRewardState.HostShopDone)
			{
				return "shop";
			}
			if (CoopRewardState.TreasurePhaseActive && CoopRewardState.HostTreasureDone)
			{
				return "treasure";
			}
			if (CoopRewardState.PegMinigamePhaseActive && CoopRewardState.HostPegMinigameDone)
			{
				return "peg_minigame";
			}
			if (CoopRewardState.TextScenarioPhaseActive && CoopRewardState.HostTextScenarioDone)
			{
				return "text_scenario";
			}
			if (CoopRewardState.HostRewardPhaseActive && CoopRewardState.HostRewardsDone)
			{
				return "post_battle";
			}
			if (CoopRewardState.HostRelicSelectionActive && CoopRewardState.HostHasChosenRelic)
			{
				return "starting_relic";
			}
			if (CoopNavigateState.PhaseActive && !CoopNavigateState.Resolved)
			{
				return "navigate";
			}
			return null;
		}

		private void ClearHostWaitingTimer()
		{
			_hostWaitingStartTime = -1f;
			_hostWaitingPhaseKey = null;
		}

		private void DestroyForceContinueButton()
		{
			if ((Object)(object)_forceContinueButton != (Object)null)
			{
				Object.Destroy((Object)(object)_forceContinueButton);
				_forceContinueButton = null;
			}
		}

		private void TickHostForceContinue()
		{
			if (_currentState == DisplayState.Waiting && !(_hostWaitingStartTime < 0f) && _hostWaitingPhaseKey != null)
			{
				if (ResolveHostWaitingPhase() != _hostWaitingPhaseKey)
				{
					ClearHostWaitingTimer();
					DestroyForceContinueButton();
				}
				else if (!((Object)(object)_forceContinueButton != (Object)null) && !(Time.unscaledTime - _hostWaitingStartTime < 45f))
				{
					_forceContinueButton = CreateForceContinueButton();
				}
			}
		}

		private GameObject CreateForceContinueButton()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: 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_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: 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_0169: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0189: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Expected O, but got Unknown
			GameObject val = new GameObject("ForceContinueButton");
			val.transform.SetParent(_overlayPanel.transform, false);
			((Graphic)val.AddComponent<Image>()).color = new Color(0.55f, 0.18f, 0.18f);
			Button obj = val.AddComponent<Button>();
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.7f, 0.25f, 0.25f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.4f, 0.12f, 0.12f);
			((Selectable)obj).colors = colors;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0f);
			component.anchorMax = new Vector2(0.5f, 0f);
			component.pivot = new Vector2(0.5f, 0f);
			component.anchoredPosition = new Vector2(0f, 160f);
			component.sizeDelta = new Vector2(360f, 70f);
			GameObject val2 = new GameObject("Label");
			val2.transform.SetParent(val.transform, false);
			TextMeshProUGUI obj2 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = "Force Continue";
			((TMP_Text)obj2).fontSize = 32f;
			((TMP_Text)obj2).fontStyle = (FontStyles)1;
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)514;
			((Graphic)obj2).color = Color.white;
			RectTransform rectTransform = ((TMP_Text)obj2).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			((UnityEvent)obj.onClick).AddListener(new UnityAction(OnForceContinueClicked));
			return val;
		}

		private void OnForceContinueClicked()
		{
			string hostWaitingPhaseKey = _hostWaitingPhaseKey;
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogWarning((object)("[CoopRewardUI] Force Continue clicked — phase='" + hostWaitingPhaseKey + "'"));
			}
			try
			{
				switch (hostWaitingPhaseKey)
				{
				case "shop":
					ForceContinueShop();
					break;
				case "treasure":
					ForceContinueTreasure();
					break;
				case "peg_minigame":
					ForceContinuePegMinigame();
					break;
				case "text_scenario":
					ForceContinueTextScenario();
					break;
				case "post_battle":
					ForceContinuePostBattle();
					break;
				case "starting_relic":
					ForceContinueStartingRelic();
					break;
				case "navigate":
					ForceContinueNavigate();
					break;
				default:
				{
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogWarning((object)("[CoopRewardUI] Force Continue: unknown phase '" + hostWaitingPhaseKey + "'"));
					}
					break;
				}
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogError((object)$"[CoopRewardUI] Force Continue failed: {arg}");
				}
			}
			DestroyForceContinueButton();
			ClearHostWaitingTimer();
		}

		private static void DispatchAllChoicesComplete(string phase)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<IGameEventRegistry>(out var instance))
			{
				instance.Dispatch(new AllChoicesCompleteEvent
				{
					Phase = phase
				});
			}
		}

		private void ForceContinueShop()
		{
			CoopRewardState.WaitingForOtherPlayers = false;
			CoopRewardState.ShopPhaseActive = false;
			CoopRewardState.ShopCompletionProceeded = true;
			DispatchAllChoicesComplete("shop");
			object pendingShopManager = CoopRewardState.PendingShopManager;
			CoopRewardState.PendingShopManager = null;
			ShopManager val = (ShopManager)((pendingShopManager is ShopManager) ? pendingShopManager : null);
			if (val != null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"[CoopRewardUI] Force-resuming host CloseStore");
				}
				val.CloseStore();
			}
		}

		private void ForceContinueTreasure()
		{
			CoopRewardState.WaitingForOtherPlayers = false;
			CoopRewardState.TreasurePhaseActive = false;
			DispatchAllChoicesComplete("treasure");
			ChestScenarioController pendingChestController = CoopRewardState.PendingChestController;
			CoopRewardState.PendingChestController = null;
			if ((Object)(object)pendingChestController != (Object)null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"[CoopRewardUI] Force-resuming host ChestScenarioController.Skip");
				}
				pendingChestController.Skip();
			}
		}

		private void ForceContinuePegMinigame()
		{
			CoopRewardState.WaitingForOtherPlayers = false;
			CoopRewardState.PegMinigamePhaseActive = false;
			DispatchAllChoicesComplete("peg_minigame");
			PegMinigameManager pendingPegMinigameManager = CoopRewardState.PendingPegMinigameManager;
			CoopRewardState.PendingPegMinigameManager = null;
			if ((Object)(object)pendingPegMinigameManager != (Object)null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"[CoopRewardUI] Force-resuming host PegMinigameManager.FadeAndLoad");
				}
				pendingPegMinigameManager.FadeAndLoad((Scene)0, -1f);
			}
		}

		private void ForceContinueTextScenario()
		{
			CoopRewardState.WaitingForOtherPlayers = false;
			CoopRewardState.TextScenarioPhaseActive = false;
			DispatchAllChoicesComplete("text_scenario");
			object pendingDialogueSystemScenario = CoopRewardState.PendingDialogueSystemScenario;
			CoopRewardState.PendingDialogueSystemScenario = null;
			DialogueSystemScenario val = (DialogueSystemScenario)((pendingDialogueSystemScenario is DialogueSystemScenario) ? pendingDialogueSystemScenario : null);
			if (val != null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"[CoopRewardUI] Force-resuming host DialogueSystemScenario.ConversationEnded");
				}
				val.ConversationEnded();
			}
		}

		private void ForceContinuePostBattle()
		{
			CoopRewardState.WaitingForOtherPlayers = false;
			CoopRewardState.HostRewardPhaseActive = false;
			DispatchAllChoicesComplete("post_battle");
			PostBattleController pendingPostBattleController = CoopRewardState.PendingPostBattleController;
			CoopRewardState.PendingPostBattleController = null;
			if ((Object)(object)pendingPostBattleController != (Object)null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"[CoopRewardUI] Force-resuming host PostBattleController.StartNavigation");
				}
				AccessTools.Method(typeof(PostBattleController), "StartNavigation", (Type[])null, (Type[])null)?.Invoke(pendingPostBattleController, new object[1] { true });
			}
		}

		private void ForceContinueNavigate()
		{
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogWarning((object)"[CoopRewardUI] Force-resolving navigate phase");
			}
			CoopNavigateResolver.ForceResolve();
			DestroyNavForceButton();
		}

		private void TickNavigateStandaloneForce(IMultiplayerMode mode)
		{
			if (mode == null || !mode.IsHosting)
			{
				DestroyNavForceButton();
				_navPhaseStartedAt = -1f;
				return;
			}
			if (!CoopNavigateState.PhaseActive || CoopNavigateState.Resolved)
			{
				DestroyNavForceButton();
				_navPhaseStartedAt = -1f;
				return;
			}
			if (_navPhaseStartedAt < 0f)
			{
				_navPhaseStartedAt = Time.unscaledTime;
			}
			if (_currentState == DisplayState.Waiting && _hostWaitingPhaseKey == "navigate")
			{
				DestroyNavForceButton();
			}
			else if (!(Time.unscaledTime - _navPhaseStartedAt < 45f) && !((Object)(object)_navForceButton != (Object)null))
			{
				_navForceButton = CreateNavForceButton();
			}
		}

		private GameObject CreateNavForceButton()
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Expected O, but got Unknown
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			GameObject val = new GameObject("NavForceContinueButton");
			val.transform.SetParent(_canvasObj.transform, false);
			((Graphic)val.AddComponent<Image>()).color = new Color(0.55f, 0.18f, 0.18f, 0.9f);
			Button obj = val.AddComponent<Button>();
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.7f, 0.25f, 0.25f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.4f, 0.12f, 0.12f);
			((Selectable)obj).colors = colors;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 0f);
			component.anchorMax = new Vector2(1f, 0f);
			component.pivot = new Vector2(1f, 0f);
			component.anchoredPosition = new Vector2(-30f, 30f);
			component.sizeDelta = new Vector2(280f, 60f);
			GameObject val2 = new GameObject("Label");
			val2.transform.SetParent(val.transform, false);
			TextMeshProUGUI obj2 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = "Force Continue";
			((TMP_Text)obj2).fontSize = 26f;
			((TMP_Text)obj2).fontStyle = (FontStyles)1;
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)514;
			((Graphic)obj2).color = Color.white;
			RectTransform rectTransform = ((TMP_Text)obj2).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			((UnityEvent)obj.onClick).AddListener(new UnityAction(ForceContinueNavigate));
			return val;
		}

		private void DestroyNavForceButton()
		{
			if ((Object)(object)_navForceButton != (Object)null)
			{
				Object.Destroy((Object)(object)_navForceButton);
				_navForceButton = null;
			}
		}

		private void ForceContinueStartingRelic()
		{
			CoopRewardState.HostRelicSelectionActive = false;
			CoopRewardState.AllChoicesComplete = true;
			CoopRewardState.WaitingForOtherPlayers = false;
			DispatchAllChoicesComplete("starting_relic");
			object pendingGameInitInstance = CoopRewardState.PendingGameInitInstance;
			GameInit val = (GameInit)((pendingGameInitInstance is GameInit) ? pendingGameInitInstance : null);
			if (val != null)
			{
				CoopRewardState.PendingGameInitInstance = null;
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"[CoopRewardUI] Force-resuming host GameInit.LoadMapScene");
				}
				typeof(GameInit).GetMethod("LoadMapScene", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(val, null);
			}
		}

		private void OnRelicChosen(int relicEffect)
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Invalid comparison between Unknown and I4
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Invalid comparison between Unknown and I4
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"[CoopRewardUI] Relic chosen: effect={relicEffect}");
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting)
				{
					RelicManager[] array = Resources.FindObjectsOfTypeAll<RelicManager>();
					Relic[] array2 = Resources.FindObjectsOfTypeAll<Relic>();
					foreach (Relic val in array2)
					{
						if ((int)val.effect != relicEffect)
						{
							continue;
						}
						if (array != null && array.Length != 0)
						{
							MultiplayerClientPatches.AllowRelicSync = true;
							try
							{
								array[0].AddRelic(val);
							}
							finally
							{
								MultiplayerClientPatches.AllowRelicSync = false;
							}
						}
						ManualLogSource log2 = Log;
						if (log2 != null)
						{
							log2.LogInfo((object)$"[CoopRewardUI] Host added relic: {val.effect} ({val.locKey})");
						}
						break;
					}
					CoopRewardState.HostHasChosenRelic = true;
					if (services.TryResolve<CoopStateManager>(out var instance2))
					{
						instance2.SaveActivePlayerState();
					}
					if (CoopRewardState.AllClientRelicChoicesReceived)
					{
						ManualLogSource log3 = Log;
						if (log3 != null)
						{
							log3.LogInfo((object)"[CoopRewardUI] All relic choices received — proceeding to map");
						}
						CoopRewardState.HostRelicSelectionActive = false;
						CoopRewardState.AllChoicesComplete = true;
						CoopRewardState.WaitingForOtherPlayers = false;
						if (services.TryResolve<IGameEventRegistry>(out var instance3))
						{
							instance3.Dispatch(new AllChoicesCompleteEvent
							{
								Phase = "starting_relic"
							});
						}
						object pendingGameInitInstance = CoopRewardState.PendingGameInitInstance;
						GameInit val2 = (GameInit)((pendingGameInitInstance is GameInit) ? pendingGameInitInstance : null);
						if ((Object)(object)val2 != (Object)null)
						{
							typeof(GameInit).GetMethod("LoadMapScene", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(val2, null);
						}
					}
				}
				else
				{
					if (services != null && services.TryResolve<IMessageSender>(out var instance4))
					{
						instance4.Send(new RelicChoiceEvent
						{
							ChosenRelicEffect = relicEffect
						});
					}
					RelicManager[] array3 = Resources.FindObjectsOfTypeAll<RelicManager>();
					if (array3 != null && array3.Length != 0)
					{
						Relic[] array2 = Resources.FindObjectsOfTypeAll<Relic>();
						foreach (Relic val3 in array2)
						{
							if ((int)val3.effect == relicEffect)
							{
								MultiplayerClientPatches.AllowRelicSync = true;
								try
								{
									array3[0].AddRelic(val3);
								}
								finally
								{
									MultiplayerClientPatches.AllowRelicSync = false;
								}
								ManualLogSource log4 = Log;
								if (log4 != null)
								{
									log4.LogInfo((object)$"[CoopRewardUI] Client added relic locally: {val3.effect}");
								}
								break;
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log5 = Log;
				if (log5 != null)
				{
					log5.LogError((object)("[CoopRewardUI] Failed to process relic choice: " + ex.Message));
				}
			}
			CoopRewardState.PendingRelicChoices = null;
			if (!CoopRewardState.AllChoicesComplete)
			{
				CoopRewardState.WaitingForOtherPlayers = true;
				ShowWaiting();
			}
		}

		private void OnRewardChosen(int optionIndex)
		{
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"[CoopRewardUI] Reward chosen: index={optionIndex}");
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMessageSender>(out var instance))
				{
					instance.Send(new RewardChoiceEvent
					{
						ChosenOptionIndex = optionIndex
					});
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogError((object)("[CoopRewardUI] Failed to send reward choice: " + ex.Message));
				}
			}
			CoopRewardState.PendingRewardChoices = null;
			CoopRewardState.AllChoicesComplete = true;
		}

		private Button CreateChoiceButton(Transform parent, string name, string title, string description, Color bgColor, Vector2 position, Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0093: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: 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_0221: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_025e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0273: Unknown result type (might be due to invalid IL or missing references)
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = bgColor;
			Button obj = val.AddComponent<Button>();
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).highlightedColor = new Color(Mathf.Min(bgColor.r + 0.15f, 1f), Mathf.Min(bgColor.g + 0.15f, 1f), Mathf.Min(bgColor.b + 0.15f, 1f), 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(bgColor.r * 0.7f, bgColor.g * 0.7f, bgColor.b * 0.7f, 1f);
			((Selectable)obj).colors = colors;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = size;
			GameObject val2 = new GameObject("Title");
			val2.transform.SetParent(val.transform, false);
			TextMeshProUGUI obj2 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = title;
			((TMP_Text)obj2).fontSize = 42f;
			((TMP_Text)obj2).fontStyle = (FontStyles)1;
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)514;
			((Graphic)obj2).color = Color.white;
			((TMP_Text)obj2).enableWordWrapping = true;
			RectTransform rectTransform = ((TMP_Text)obj2).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 0.55f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.offsetMin = new Vector2(8f, 0f);
			rectTransform.offsetMax = new Vector2(-8f, -8f);
			if (!string.IsNullOrEmpty(description))
			{
				GameObject val3 = new GameObject("Description");
				val3.transform.SetParent(val.transform, false);
				TextMeshProUGUI obj3 = val3.AddComponent<TextMeshProUGUI>();
				((TMP_Text)obj3).text = description;
				((TMP_Text)obj3).fontSize = 30f;
				((TMP_Text)obj3).alignment = (TextAlignmentOptions)514;
				((Graphic)obj3).color = new Color(0.8f, 0.8f, 0.8f);
				((TMP_Text)obj3).enableWordWrapping = true;
				((TMP_Text)obj3).overflowMode = (TextOverflowModes)1;
				RectTransform rectTransform2 = ((TMP_Text)obj3).rectTransform;
				rectTransform2.anchorMin = new Vector2(0f, 0f);
				rectTransform2.anchorMax = new Vector2(1f, 0.55f);
				rectTransform2.offsetMin = new Vector2(8f, 8f);
				rectTransform2.offsetMax = new Vector2(-8f, 0f);
			}
			_buttons.Add(val);
			return obj;
		}

		private void ClearButtons()
		{
			foreach (GameObject button in _buttons)
			{
				if ((Object)(object)button != (Object)null)
				{
					Object.Destroy((Object)(object)button);
				}
			}
			_buttons.Clear();
		}

		private static Color GetRewardColor(string type)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: 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_00b3: 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_00dd: Unknown result type (might be due to invalid IL or missing references)
			return (Color)(type switch
			{
				"relic" => new Color(0.25f, 0.2f, 0.45f), 
				"orb_upgrade" => new Color(0.2f, 0.35f, 0.5f), 
				"orb_add" => new Color(0.2f, 0.4f, 0.3f), 
				"heal" => new Color(0.4f, 0.25f, 0.25f), 
				"max_hp" => new Color(0.45f, 0.2f, 0.3f), 
				"skip" => new Color(0.3f, 0.3f, 0.2f), 
				_ => new Color(0.25f, 0.25f, 0.25f), 
			});
		}

		private static void StretchFill(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
		}

		private void OnDestroy()
		{
			ClearButtons();
			DestroyNavForceButton();
			if ((Object)(object)_canvasObj != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObj);
			}
		}
	}
	public static class EventFeed
	{
		private static readonly List<string> _entries = new List<string>();

		private const int MaxEntries = 200;

		private static int _version;

		public static int Version => _version;

		public static void Add(string typeId, string jsonPayload)
		{
			string item = "<color=#88AAFF>[" + typeId.Substring(typeId.LastIndexOf('.') + 1) + "]</color> " + jsonPayload;
			lock (_entries)
			{
				_entries.Add(item);
				if (_entries.Count > 200)
				{
					_entries.RemoveAt(0);
				}
				_version++;
			}
		}

		public static string GetText(int maxLines = 50)
		{
			lock (_entries)
			{
				int num = ((_entries.Count > maxLines) ? (_entries.Count - maxLines) : 0);
				StringBuilder stringBuilder = new StringBuilder();
				for (int i = num; i < _entries.Count; i++)
				{
					stringBuilder.AppendLine(_entries[i]);
				}
				return stringBuilder.ToString();
			}
		}

		public static void Clear()
		{
			lock (_entries)
			{
				_entries.Clear();
				_version++;
			}
		}
	}
	public static class LobbyUI
	{
		private class PlayerRow
		{
			public GameObject Root;

			public TextMeshProUGUI NameText;

			public TextMeshProUGUI ClassText;

			public Button LeftArrow;

			public Button RightArrow;

			public TextMeshProUGUI ReadyText;

			public TextMeshProUGUI VersionText;

			public int SlotIndex;

			public bool IsLocalPlayer;
		}

		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__OnStartClicked;

			public static UnityAction <1>__OnReadyToggle;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static Func<LobbyPlayerEntry, string> <>9__30_0;

			public static UnityAction <>9__32_0;

			public static UnityAction <>9__32_1;

			internal string <UpdateLobbyUI>b__30_0(LobbyPlayerEntry p)
			{
				return p.PlayerName;
			}

			internal void <CreateCruciballRow>b__32_0()
			{
				OnCruciballArrow(-1);
			}

			internal void <CreateCruciballRow>b__32_1()
			{
				OnCruciballArrow(1);
			}
		}

		private static readonly string[] ClassNames = new string[4] { "Peglin", "Balladin", "Roundrel", "Spinventor" };

		private static LobbyStateEvent _latestLobbyState;

		private static int _localChosenClass;

		private static bool _localIsReady;

		private static bool _gameStartReceived;

		private static GameStartEvent _gameStartEvent;

		private static int _hostCruciballLevel;

		private static GameObject _lobbyRoot;

		private static readonly List<PlayerRow> _playerRows = new List<PlayerRow>();

		private static Button _startButton;

		private static TextMeshProUGUI _startButtonText;

		private static Button _readyButton;

		private static TextMeshProUGUI _readyButtonText;

		private static GameObject _cruciballRow;

		private static TextMeshProUGUI _cruciballValueText;

		private static Button _cruciballLeftBtn;

		private static Button _cruciballRightBtn;

		private static bool _isHost;

		public static int HostCruciballLevel => _hostCruciballLevel;

		public static bool GameStartReceived => _gameStartReceived;

		public static GameStartEvent LatestGameStartEvent => _gameStartEvent;

		public static void Reset()
		{
			_latestLobbyState = null;
			_localChosenClass = 0;
			_localIsReady = false;
			_gameStartReceived = false;
			_gameStartEvent = null;
			_hostCruciballLevel = 0;
			foreach (PlayerRow playerRow in _playerRows)
			{
				if ((Object)(object)playerRow.Root != (Object)null)
				{
					Object.Destroy((Object)(object)playerRow.Root);
				}
			}
			_playerRows.Clear();
			if ((Object)(object)_startButton != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_startButton).gameObject);
				_startButton = null;
				_startButtonText = null;
			}
			if ((Object)(object)_readyButton != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)_readyButton).gameObject);
				_readyButton = null;
				_readyButtonText = null;
			}
			if ((Object)(object)_cruciballRow != (Object)null)
			{
				Object.Destroy((Object)(object)_cruciballRow);
				_cruciballRow = null;
				_cruciballValueText = null;
				_cruciballLeftBtn = null;
				_cruciballRightBtn = null;
			}
			if ((Object)(object)_lobbyRoot != (Object)null)
			{
				Object.Destroy((Object)(object)_lobbyRoot);
				_lobbyRoot = null;
			}
		}

		public static void ApplyLobbyState(LobbyStateEvent state)
		{
			_latestLobbyState = state;
			if (state == null)
			{
				return;
			}
			_hostCruciballLevel = state.CruciballLevel;
			if (!state.IsContinue || state.Players == null || _isHost || string.IsNullOrEmpty(MultiplayerUI.LocalPlayerName))
			{
				return;
			}
			foreach (LobbyPlayerEntry player in state.Players)
			{
				if (!player.IsHost && player.PlayerName == MultiplayerUI.LocalPlayerName)
				{
					_localChosenClass = player.ChosenClass;
					break;
				}
			}
		}

		public static void SetLocalChosenClass(int classIndex)
		{
			_localChosenClass = classIndex;
		}

		public static void OnGameStartReceived(GameStartEvent evt)
		{
			_gameStartReceived = true;
			_gameStartEvent = evt;
		}

		public static GameObject CreateLobbyPanel(Transform parent, bool isHost, Action<string> createText, Func<Transform, string, string, Color, Vector2, Vector2, Button> createButton)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0057: Unknown result type (might be due to invalid IL or missing references)
			_isHost = isHost;
			_gameStartReceived = false;
			_lobbyRoot = new GameObject("CoopLobbyPanel");
			_lobbyRoot.transform.SetParent(parent, false);
			RectTransform obj = _lobbyRoot.AddComponent<RectTransform>();
			obj.anchorMin = Vector2.zero;
			obj.anchorMax = Vector2.one;
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			return _lobbyRoot;
		}

		public static void UpdateLobbyUI(Transform lobbyParent, bool isHost, Func<Transform, string, string, int, TextMeshProUGUI> createText, Func<Transform, string, string, Color, Vector2, Vector2, Button> createButton)
		{
			//IL_0565: Unknown result type (might be due to invalid IL or missing references)
			//IL_0574: Unknown result type (might be due to invalid IL or missing references)
			//IL_0583: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b7: Expected O, but got Unknown
			//IL_0279: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0746: Unknown result type (might be due to invalid IL or missing references)
			//IL_0755: Unknown result type (might be due to invalid IL or missing references)
			//IL_0764: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_078d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0792: Unknown result type (might be due to invalid IL or missing references)
			//IL_0798: Expected O, but got Unknown
			//IL_07f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_07f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0826: Unknown result type (might be due to invalid IL or missing references)
			//IL_0810: Unknown result type (might be due to invalid IL or missing references)
			//IL_0835: Unknown result type (might be due to invalid IL or missing references)
			//IL_04fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			_isHost = isHost;
			List<LobbyPlayerEntry> list2;
			if (isHost)
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<PlayerRegistry>(out var instance))
				{
					return;
				}
				List<LobbyPlayerEntry> list = new List<LobbyPlayerEntry>();
				foreach (PlayerSlot allSlot in instance.GetAllSlots())
				{
					list.Add(new LobbyPlayerEntry
					{
						SlotIndex = allSlot.SlotIndex,
						PlayerName = allSlot.PlayerName,
						ChosenClass = allSlot.ChosenClass,
						ChosenClassName = LobbyHelper.GetClassName(allSlot.ChosenClass),
						IsReady = allSlot.IsReady,
						IsHost = allSlot.IsHost,
						GameVersion = allSlot.GameVersion,
						ModVersion = allSlot.ModVersion
					});
				}
				list2 = LobbyHelper.BuildOrderedRoster(list);
			}
			else
			{
				if (_latestLobbyState?.Players == null)
				{
					return;
				}
				list2 = _latestLobbyState.Players;
			}
			while (_playerRows.Count < list2.Count)
			{
				AddPlayerRow(lobbyParent, _playerRows.Count, createText, createButton);
			}
			for (int i = list2.Count; i < _playerRows.Count; i++)
			{
				_playerRows[i].Root.SetActive(false);
			}
			string text = Application.version ?? "unknown";
			string text2 = "0.1.10";
			string text3 = "Peglin " + text + " (mod " + text2 + ")";
			bool flag = false;
			string localPlayerName = MultiplayerUI.LocalPlayerName;
			Color color = default(Color);
			for (int j = 0; j < list2.Count; j++)
			{
				LobbyPlayerEntry lobbyPlayerEntry = list2[j];
				PlayerRow playerRow = _playerRows[j];
				bool isMissing = lobbyPlayerEntry.IsMissing;
				playerRow.Root.SetActive(true);
				playerRow.SlotIndex = lobbyPlayerEntry.SlotIndex;
				if (isHost)
				{
					playerRow.IsLocalPlayer = lobbyPlayerEntry.IsHost;
				}
				else if (!string.IsNullOrEmpty(localPlayerName))
				{
					playerRow.IsLocalPlayer = !lobbyPlayerEntry.IsHost && lobbyPlayerEntry.PlayerName == localPlayerName;
				}
				else
				{
					playerRow.IsLocalPlayer = !lobbyPlayerEntry.IsHost;
				}
				((TMP_Text)playerRow.NameText).text = lobbyPlayerEntry.PlayerName ?? "???";
				if (isMissing)
				{
					((Color)(ref color))..ctor(0.55f, 0.55f, 0.55f);
					((Graphic)playerRow.NameText).color = color;
					((TMP_Text)playerRow.ClassText).text = lobbyPlayerEntry.ChosenClassName ?? LobbyHelper.GetClassName(lobbyPlayerEntry.ChosenClass);
					((Graphic)playerRow.ClassText).color = color;
					((Component)playerRow.LeftArrow).gameObject.SetActive(false);
					((Component)playerRow.RightArrow).gameObject.SetActive(false);
					((TMP_Text)playerRow.ReadyText).text = "<color=#888888>MISSING</color>";
					((TMP_Text)playerRow.VersionText).text = string.Empty;
					continue;
				}
				((Graphic)playerRow.NameText).color = (playerRow.IsLocalPlayer ? new Color(0.53f, 1f, 0.53f) : new Color(0.53f, 0.67f, 1f));
				((Graphic)playerRow.ClassText).color = Color.white;
				((TMP_Text)playerRow.ClassText).text = (playerRow.IsLocalPlayer ? LobbyHelper.GetClassName(_localChosenClass) : (lobbyPlayerEntry.ChosenClassName ?? LobbyHelper.GetClassName(lobbyPlayerEntry.ChosenClass)));
				bool flag2 = (isHost ? ContinueSession.IsActive : (_latestLobbyState?.IsContinue ?? false));
				bool active = playerRow.IsLocalPlayer && !flag2;
				((Component)playerRow.LeftArrow).gameObject.SetActive(active);
				((Component)playerRow.RightArrow).gameObject.SetActive(active);
				if (lobbyPlayerEntry.IsHost)
				{
					((TMP_Text)playerRow.ReadyText).text = "<color=#88FF88>HOST</color>";
				}
				else if (playerRow.IsLocalPlayer)
				{
					((TMP_Text)playerRow.ReadyText).text = (_localIsReady ? "<color=#88FF88>READY</color>" : "<color=#FF8888>NOT READY</color>");
				}
				else
				{
					((TMP_Text)playerRow.ReadyText).text = (lobbyPlayerEntry.IsReady ? "<color=#88FF88>READY</color>" : "<color=#FF8888>NOT READY</color>");
				}
				string text4 = (playerRow.IsLocalPlayer ? text : (lobbyPlayerEntry.GameVersion ?? "?"));
				string text5 = (playerRow.IsLocalPlayer ? text2 : (lobbyPlayerEntry.ModVersion ?? "?"));
				string text6 = "Peglin " + text4 + " (mod " + text5 + ")";
				bool flag3 = text6 == text3;
				if (!flag3)
				{
					flag = true;
				}
				((TMP_Text)playerRow.VersionText).text = text6;
				((Graphic)playerRow.VersionText).color = (flag3 ? new Color(0.53f, 1f, 0.53f) : new Color(1f, 0.4f, 0.4f));
			}
			if ((Object)(object)_cruciballRow == (Object)null)
			{
				CreateCruciballRow(lobbyParent, createText, createButton);
			}
			UpdateCruciballRow(isHost);
			if ((Object)(object)_startButton == (Object)null && isHost)
			{
				_startButton = createButton(lobbyParent, "StartGameBtn", "Start Game", new Color(0.2f, 0.55f, 0.25f, 1f), new Vector2(0f, -280f), new Vector2(400f, 72f));
				ButtonClickedEvent onClick = _startButton.onClick;
				object obj = <>O.<0>__OnStartClicked;
				if (obj == null)
				{
					UnityAction val = OnStartClicked;
					<>O.<0>__OnStartClicked = val;
					obj = (object)val;
				}
				((UnityEvent)onClick).AddListener((UnityAction)obj);
				_startButtonText = ((Component)_startButton).GetComponentInChildren<TextMeshProUGUI>();
			}
			if ((Object)(object)_startButton != (Object)null)
			{
				((Component)_startButton).gameObject.SetActive(isHost);
				if (isHost)
				{
					if (flag)
					{
						((Selectable)_startButton).interactable = false;
						((TMP_Text)_startButtonText).text = "Unable to start, version mismatch";
					}
					else
					{
						bool flag4 = true;
						foreach (LobbyPlayerEntry item in list2)
						{
							if (!item.IsHost && !item.IsReady)
							{
								flag4 = false;
								break;
							}
						}
						bool flag5 = list2.Count > 1;
						if (ContinueSession.IsActive)
						{
							bool flag6 = ContinueSession.AllExpectedPlayersPresent(list2.Select((LobbyPlayerEntry p) => p.PlayerName));
							((Selectable)_startButton).interactable = flag4 && flag6;
							if (!flag6)
							{
								int count = list2.Count;
								int expectedPlayerCount = ContinueSession.ExpectedPlayerCount;
								((TMP_Text)_startButtonText).text = $"Waiting for saved players ({count}/{expectedPlayerCount})";
							}
							else
							{
								((TMP_Text)_startButtonText).text = "Continue Run";
							}
						}
						else
						{
							((Selectable)_startButton).interactable = flag4 && flag5;
							((TMP_Text)_startButtonText).text = "Start Game";
						}
					}
				}
			}
			if ((Object)(object)_readyButton == (Object)null && !isHost)
			{
				_readyButton = createButton(lobbyParent, "ReadyBtn", "Ready", new Color(0.5f, 0.3f, 0.2f, 1f), new Vector2(0f, -280f), new Vector2(400f, 72f));
				ButtonClickedEvent onClick2 = _readyButton.onClick;
				object obj2 = <>O.<1>__OnReadyToggle;
				if (obj2 == null)
				{
					UnityAction val2 = OnReadyToggle;
					<>O.<1>__OnReadyToggle = val2;
					obj2 = (object)val2;
				}
				((UnityEvent)onClick2).AddListener((UnityAction)obj2);
				_readyButtonText = ((Component)_readyButton).GetComponentInChildren<TextMeshProUGUI>();
			}
			if ((Object)(object)_readyButton != (Object)null)
			{
				((Component)_readyButton).gameObject.SetActive(!isHost);
				((TMP_Text)_readyButtonText).text = (_localIsReady ? "Not Ready" : "Ready");
				ColorBlock colors = ((Selectable)_readyButton).colors;
				((ColorBlock)(ref colors)).normalColor = (_localIsReady ? new Color(0.5f, 0.3f, 0.2f) : new Color(0.2f, 0.55f, 0.25f));
				((Selectable)_readyButton).colors = colors;
			}
		}

		private static void AddPlayerRow(Transform parent, int rowIndex, Func<Transform, string, string, int, TextMeshProUGUI> createText, Func<Transform, string, string, Color, Vector2, Vector2, Button> createButton)
		{
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Expected O, but got Unknown
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Expected O, but got Unknown
			//IL_0223: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: 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_0262: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02df: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Expected O, but got Unknown
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0369: Unknown result type (might be due to invalid IL or missing references)
			//IL_037e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0393: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0415: Unknown result type (might be due to invalid IL or missing references)
			//IL_042a: Unknown result type (might be due to invalid IL or missing references)
			//IL_043f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			float num = 170 - rowIndex * 67;
			GameObject val = new GameObject($"PlayerRow_{rowIndex}");
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.5f, 0.5f);
			obj.anchorMax = new Vector2(0.5f, 0.5f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.anchoredPosition = new Vector2(0f, num);
			obj.sizeDelta = new Vector2(920f, 56f);
			PlayerRow playerRow = new PlayerRow
			{
				Root = val,
				NameText = createText(val.transform, $"Name_{rowIndex}", string.Empty, 30)
			};
			RectTransform rectTransform = ((TMP_Text)playerRow.NameText).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(-300f, 0f);
			rectTransform.sizeDelta = new Vector2(220f, 44f);
			((TMP_Text)playerRow.NameText).alignment = (TextAlignmentOptions)513;
			int ri = rowIndex;
			playerRow.LeftArrow = createButton(val.transform, $"Left_{rowIndex}", "<", new Color(0.3f, 0.3f, 0.4f, 1f), new Vector2(-100f, 0f), new Vector2(44f, 44f));
			((UnityEvent)playerRow.LeftArrow.onClick).AddListener((UnityAction)delegate
			{
				OnClassArrow(ri, -1);
			});
			OffsetArrowLabel(playerRow.LeftArrow);
			playerRow.ClassText = createText(val.transform, $"Class_{rowIndex}", "Peglin", 30);
			RectTransform rectTransform2 = ((TMP_Text)playerRow.ClassText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform2.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform2.pivot = new Vector2(0.5f, 0.5f);
			rectTransform2.anchoredPosition = new Vector2(-10f, 0f);
			rectTransform2.sizeDelta = new Vector2(140f, 44f);
			((TMP_Text)playerRow.ClassText).alignment = (TextAlignmentOptions)514;
			playerRow.RightArrow = createButton(val.transform, $"Right_{rowIndex}", ">", new Color(0.3f, 0.3f, 0.4f, 1f), new Vector2(80f, 0f), new Vector2(44f, 44f));
			((UnityEvent)playerRow.RightArrow.onClick).AddListener((UnityAction)delegate
			{
				OnClassArrow(ri, 1);
			});
			OffsetArrowLabel(playerRow.RightArrow);
			playerRow.ReadyText = createText(val.transform, $"Ready_{rowIndex}", string.Empty, 28);
			RectTransform rectTransform3 = ((TMP_Text)playerRow.ReadyText).rectTransform;
			rectTransform3.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform3.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform3.pivot = new Vector2(0.5f, 0.5f);
			rectTransform3.anchoredPosition = new Vector2(180f, 0f);
			rectTransform3.sizeDelta = new Vector2(160f, 44f);
			((TMP_Text)playerRow.ReadyText).alignment = (TextAlignmentOptions)514;
			playerRow.VersionText = createText(val.transform, $"Version_{rowIndex}", string.Empty, 18);
			RectTransform rectTransform4 = ((TMP_Text)playerRow.VersionText).rectTransform;
			rectTransform4.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform4.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform4.pivot = new Vector2(0.5f, 0.5f);
			rectTransform4.anchoredPosition = new Vector2(380f, 0f);
			rectTransform4.sizeDelta = new Vector2(260f, 44f);
			((TMP_Text)playerRow.VersionText).alignment = (TextAlignmentOptions)513;
			_playerRows.Add(playerRow);
		}

		private static void CreateCruciballRow(Transform parent, Func<Transform, string, string, int, TextMeshProUGUI> createText, Func<Transform, string, string, Color, Vector2, Vector2, Button> createButton)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Expected O, but got Unknown
			//IL_0035: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_014f: 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_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_027f: 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_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_019f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Expected O, but got Unknown
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d5: Expected O, but got Unknown
			_cruciballRow = new GameObject("CruciballRow");
			_cruciballRow.transform.SetParent(parent, false);
			RectTransform obj = _cruciballRow.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.5f, 0.5f);
			obj.anchorMax = new Vector2(0.5f, 0.5f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.anchoredPosition = new Vector2(0f, -200f);
			obj.sizeDelta = new Vector2(560f, 48f);
			TextMeshProUGUI obj2 = createText(_cruciballRow.transform, "CruciballLabel", "Cruciball Level:", 28);
			RectTransform rectTransform = ((TMP_Text)obj2).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(-110f, 0f);
			rectTransform.sizeDelta = new Vector2(260f, 44f);
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)516;
			_cruciballLeftBtn = createButton(_cruciballRow.transform, "CruciballLeft", "<", new Color(0.3f, 0.3f, 0.4f, 1f), new Vector2(50f, 0f), new Vector2(40f, 40f));
			ButtonClickedEvent onClick = _cruciballLeftBtn.onClick;
			object obj3 = <>c.<>9__32_0;
			if (obj3 == null)
			{
				UnityAction val = delegate
				{
					OnCruciballArrow(-1);
				};
				<>c.<>9__32_0 = val;
				obj3 = (object)val;
			}
			((UnityEvent)onClick).AddListener((UnityAction)obj3);
			OffsetArrowLabel(_cruciballLeftBtn);
			_cruciballValueText = createText(_cruciballRow.transform, "CruciballValue", "0", 30);
			RectTransform rectTransform2 = ((TMP_Text)_cruciballValueText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform2.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform2.pivot = new Vector2(0.5f, 0.5f);
			rectTransform2.anchoredPosition = new Vector2(120f, 0f);
			rectTransform2.sizeDelta = new Vector2(80f, 44f);
			((TMP_Text)_cruciballValueText).alignment = (TextAlignmentOptions)514;
			_cruciballRightBtn = createButton(_cruciballRow.transform, "CruciballRight", ">", new Color(0.3f, 0.3f, 0.4f, 1f), new Vector2(190f, 0f), new Vector2(40f, 40f));
			ButtonClickedEvent onClick2 = _cruciballRightBtn.onClick;
			object obj4 = <>c.<>9__32_1;
			if (obj4 == null)
			{
				UnityAction val2 = delegate
				{
					OnCruciballArrow(1);
				};
				<>c.<>9__32_1 = val2;
				obj4 = (object)val2;
			}
			((UnityEvent)onClick2).AddListener((UnityAction)obj4);
			OffsetArrowLabel(_cruciballRightBtn);
		}

		private static void OffsetArrowLabel(Button btn)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)btn == (Object)null))
			{
				TextMeshProUGUI componentInChildren = ((Component)btn).GetComponentInChildren<TextMeshProUGUI>();
				if (!((Object)(object)componentInChildren == (Object)null))
				{
					RectTransform rectTransform = ((TMP_Text)componentInChildren).rectTransform;
					rectTransform.offsetMin = new Vector2(rectTransform.offsetMin.x, rectTransform.offsetMin.y - 3f);
					rectTransform.offsetMax = new Vector2(rectTransform.offsetMax.x, rectTransform.offsetMax.y - 3f);
				}
			}
		}

		private static void UpdateCruciballRow(bool isHost)
		{
			if (!((Object)(object)_cruciballValueText == (Object)null))
			{
				bool flag = isHost && ContinueSession.IsActive;
				if (flag && ContinueSession.ActiveSave != null)
				{
					_hostCruciballLevel = ContinueSession.ActiveSave.CruciballLevel;
				}
				((TMP_Text)_cruciballValueText).text = _hostCruciballLevel.ToString();
				bool active = isHost && !flag;
				Button cruciballLeftBtn = _cruciballLeftBtn;
				if (cruciballLeftBtn != null)
				{
					((Component)cruciballLeftBtn).gameObject.SetActive(active);
				}
				Button cruciballRightBtn = _cruciballRightBtn;
				if (cruciballRightBtn != null)
				{
					((Component)cruciballRightBtn).gameObject.SetActive(active);
				}
			}
		}

		private static void OnCruciballArrow(int direction)
		{
			if (_isHost && !ContinueSession.IsActive)
			{
				int num = _hostCruciballLevel + direction;
				if (num < 0)
				{
					num = 20;
				}
				if (num > 20)
				{
					num = 0;
				}
				_hostCruciballLevel = num;
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<PlayerRegistry>(out var instance) && services.TryResolve<IGameEventRegistry>(out var instance2))
				{
					LobbyHelper.BroadcastLobbyState(instance, instance2);
				}
			}
		}

		private static void OnClassArrow(int rowIndex, int direction)
		{
			bool num;
			if (!_isHost)
			{
				LobbyStateEvent latestLobbyState = _latestLobbyState;
				if (latestLobbyState == null)
				{
					goto IL_0022;
				}
				num = latestLobbyState.IsContinue;
			}
			else
			{
				num = ContinueSession.IsActive;
			}
			if (num)
			{
				return;
			}
			goto IL_0022;
			IL_0022:
			_localChosenClass = (_localChosenClass + direction + ClassNames.Length) % ClassNames.Length;
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null)
			{
				return;
			}
			IMessageSender instance4;
			if (_isHost)
			{
				if (services.TryResolve<PlayerRegistry>(out var instance))
				{
					PlayerSlot hostSlot = instance.GetHostSlot();
					if (hostSlot != null)
					{
						hostSlot.ChosenClass = _localChosenClass;
					}
				}
				if (services.TryResolve<PlayerRegistry>(out var instance2) && services.TryResolve<IGameEventRegistry>(out var instance3))
				{
					LobbyHelper.BroadcastLobbyState(instance2, instance3);
				}
			}
			else if (services.TryResolve<IMessageSender>(out instance4))
			{
				instance4.Send(new ClassSelectEvent
				{
					ChosenClass = _localChosenClass
				});
			}
		}

		private static void OnReadyToggle()
		{
			_localIsReady = !_localIsReady;
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<IMessageSender>(out var instance))
			{
				instance.Send(new ReadyEvent
				{
					IsReady = _localIsReady
				});
			}
		}

		private static void OnStartClicked()
		{
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<PlayerRegistry>(out var instance) || !services.TryResolve<IGameEventRegistry>(out var instance2) || !instance.AllClientsReady)
			{
				return;
			}
			List<LobbyPlayerEntry> list = new List<LobbyPlayerEntry>();
			foreach (PlayerSlot allSlot in instance.GetAllSlots())
			{
				list.Add(new LobbyPlayerEntry
				{
					SlotIndex = allSlot.SlotIndex,
					PlayerName = allSlot.PlayerName,
					ChosenClass = allSlot.ChosenClass,
					ChosenClassName = LobbyHelper.GetClassName(allSlot.ChosenClass),
					IsReady = true,
					IsHost = allSlot.IsHost
				});
			}
			if (services.TryResolve<ISteamTransport>(out var instance3))
			{
				try
				{
					instance3.CloseLobbyOnStart();
				}
				catch (Exception ex)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)("[Lobby] CloseLobbyOnStart failed: " + ex.Message));
					}
				}
			}
			instance2.Dispatch(new GameStartEvent
			{
				FinalPlayers = list,
				CruciballLevel = _hostCruciballLevel,
				IsContinue = ContinueSession.IsActive
			});
			PlayerSlot hostSlot = instance.GetHostSlot();
			if (hostSlot != null)
			{
				int chosenClass = hostSlot.ChosenClass;
				StaticGameData.chosenClass = (Class)chosenClass;
				MultiplayerClientPatches.SetCruciballManagerClass((Class)chosenClass);
				MultiplayerClientPatches.SetCruciballManagerLevel(_hostCruciballLevel);
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[Lobby] Starting game: host class={hostSlot.ChosenClass}, cruciball={_hostCruciballLevel}, {list.Count} players, continue={ContinueSession.IsActive}");
				}
			}
			_gameStartReceived = true;
			_gameStartEvent = new GameStartEvent
			{
				FinalPlayers = list,
				CruciballLevel = _hostCruciballLevel,
				IsContinue = ContinueSession.IsActive
			};
			if (ContinueSession.IsActive)
			{
				ContinueSaveData activeSave = ContinueSession.ActiveSave;
				if (activeSave != null)
				{
					ContinueLoader.LaunchScene(activeSave);
					return;
				}
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)"[Lobby] Continue mode but ActiveSave is null");
				}
				return;
			}
			PlayButton val = Object.FindObjectOfType<PlayButton>();
			if ((Object)(object)val != (Object)null)
			{
				val.MovetoCharacterSelect();
				return;
			}
			ManualLogSource logger4 = MultiplayerPlugin.Logger;
			if (logger4 != null)
			{
				logger4.LogWarning((object)"[Lobby] PlayButton not found");
			}
		}
	}
	public static class MirrorEventUI
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__OnRemoveOneClicked;

			public static UnityAction <1>__OnRemoveAllClicked;
		}

		private static GameObject _canvasObj;

		private static GameObject _choicePanel;

		private static GameObject _orbGridPanel;

		private static bool _isActive;

		public static bool IsActive => _isActive;

		public static void Show()
		{
			if (!_isActive)
			{
				_isActive = true;
				CreateChoiceUI();
			}
		}

		public static void Hide()
		{
			_isActive = false;
			if ((Object)(object)_canvasObj != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObj);
				_canvasObj = null;
			}
			_choicePanel = null;
			_orbGridPanel = null;
		}

		private static void CreateChoiceUI()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: 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_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Expected O, but got Unknown
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_015d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			//IL_022d: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_024b: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cb: Expected O, but got Unknown
			//IL_032c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_0337: Expected O, but got Unknown
			if ((Object)(object)_canvasObj != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObj);
			}
			_canvasObj = new GameObject("MirrorEventCanvas");
			Object.DontDestroyOnLoad((Object)(object)_canvasObj);
			Canvas obj = _canvasObj.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 95;
			CanvasScaler obj2 = _canvasObj.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			obj2.matchWidthOrHeight = 0.5f;
			_canvasObj.AddComponent<GraphicRaycaster>();
			GameObject val = new GameObject("Background");
			val.transform.SetParent(_canvasObj.transform, false);
			((Graphic)val.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.7f);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = Vector2.zero;
			component.anchorMax = Vector2.one;
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			_choicePanel = new GameObject("ChoicePanel");
			_choicePanel.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_choicePanel.AddComponent<Image>()).color = new Color(0.1f, 0.1f, 0.15f, 0.95f);
			RectTransform component2 = _choicePanel.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.25f, 0.3f);
			component2.anchorMax = new Vector2(0.75f, 0.7f);
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			CreateText(_choicePanel.transform, "Title", "Mirror Event", 36f, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -15f), new Vector2(400f, 50f));
			CreateText(_choicePanel.transform, "Subtitle", "Choose your fate:", 24f, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -60f), new Vector2(400f, 36f));
			Transform transform = _choicePanel.transform;
			Color bgColor = new Color(0.3f, 0.5f, 0.7f, 1f);
			Vector2 pos = new Vector2(0f, -30f);
			Vector2 size = new Vector2(360f, 70f);
			object obj3 = <>O.<0>__OnRemoveOneClicked;
			if (obj3 == null)
			{
				UnityAction val2 = OnRemoveOneClicked;
				<>O.<0>__OnRemoveOneClicked = val2;
				obj3 = (object)val2;
			}
			CreateButton(transform, "RemoveOneBtn", "Remove an Orb", bgColor, pos, size, (UnityAction)obj3);
			Transform transform2 = _choicePanel.transform;
			Color bgColor2 = new Color(0.7f, 0.3f, 0.3f, 1f);
			Vector2 pos2 = new Vector2(0f, -115f);
			Vector2 size2 = new Vector2(360f, 70f);
			object obj4 = <>O.<1>__OnRemoveAllClicked;
			if (obj4 == null)
			{
				UnityAction val3 = OnRemoveAllClicked;
				<>O.<1>__OnRemoveAllClicked = val3;
				obj4 = (object)val3;
			}
			CreateButton(transform2, "RemoveAllBtn", "Remove All Orbs", bgColor2, pos2, size2, (UnityAction)obj4);
		}

		private static void OnRemoveOneClicked()
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[MirrorEventUI] Remove One clicked — showing orb grid");
			}
			GameObject choicePanel = _choicePanel;
			if (choicePanel != null)
			{
				choicePanel.SetActive(false);
			}
			ShowOrbGrid();
		}

		private static void OnRemoveAllClicked()
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[MirrorEventUI] Remove All clicked — sending to host");
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMessageSender>(out var instance))
				{
					instance.Send(new MirrorEventCompleteEvent
					{
						Action = "remove_all"
					});
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogError((object)("[MirrorEventUI] Failed to send remove_all: " + ex.Message));
				}
			}
			Hide();
		}

		private static void ShowOrbGrid()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Expected O, but got Unknown
			//IL_014d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_0232: Expected O, but got Unknown
			if ((Object)(object)_orbGridPanel != (Object)null)
			{
				Object.Destroy((Object)(object)_orbGridPanel);
			}
			_orbGridPanel = new GameObject("OrbGridPanel");
			_orbGridPanel.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_orbGridPanel.AddComponent<Image>()).color = new Color(0.1f, 0.1f, 0.15f, 0.95f);
			RectTransform component = _orbGridPanel.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.1f, 0.1f);
			component.anchorMax = new Vector2(0.9f, 0.9f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			CreateText(_orbGridPanel.transform, "Title", "Choose an orb to remove:", 30f, new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0.5f, 1f), new Vector2(0f, -15f), new Vector2(500f, 44f));
			GameObject val = new GameObject("ScrollView");
			val.transform.SetParent(_orbGridPanel.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.05f, 0.05f);
			obj.anchorMax = new Vector2(0.95f, 0.9f);
			obj.offsetMin = Vector2.zero;
			obj.offsetMax = Vector2.zero;
			GameObject val2 = new GameObject("Content");
			val2.transform.SetParent(val.transform, false);
			RectTransform val3 = val2.AddComponent<RectTransform>();
			val3.anchorMin = new Vector2(0f, 1f);
			val3.anchorMax = new Vector2(1f, 1f);
			val3.pivot = new Vector2(0.5f, 1f);
			val3.anchoredPosition = Vector2.zero;
			GridLayoutGroup obj2 = val2.AddComponent<GridLayoutGroup>();
			obj2.cellSize = new Vector2(180f, 50f);
			obj2.spacing = new Vector2(10f, 8f);
			((LayoutGroup)obj2).padding = new RectOffset(10, 10, 10, 10);
			((LayoutGroup)obj2).childAlignment = (TextAnchor)0;
			val2.AddComponent<ContentSizeFitter>().verticalFit = (FitMode)2;
			ScrollRect obj3 = val.AddComponent<ScrollRect>();
			obj3.content = val3;
			obj3.horizontal = false;
			obj3.vertical = true;
			List<GameObject> completeDeck = DeckManager.completeDeck;
			if (completeDeck == null)
			{
				return;
			}
			OrbIdentifier instance = null;
			MultiplayerPlugin.Services?.TryResolve<OrbIdentifier>(out instance);
			for (int i = 0; i < completeDeck.Count; i++)
			{
				GameObject val4 = completeDeck[i];
				if (!((Object)(object)val4 == (Object)null) && !((Object)(object)val4.GetComponent<CannotBeRemoved>() != (Object)null))
				{
					Attack component2 = val4.GetComponent<Attack>();
					string displayName = (((Object)(object)component2 != (Object)null) ? component2.GetNameWithLevel() : ((Object)val4).name);
					string prefabName = ((Object)val4).name.Replace("(Clone)", string.Empty).Trim();
					string guid = instance?.GetGuid(val4) ?? string.Empty;
					CreateOrbButton(val2.transform, i, displayName, prefabName, guid);
				}
			}
		}

		private static void CreateOrbButton(Transform parent, int index, string displayName, string prefabName, string guid)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: 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_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"Orb_{index}");
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = new Color(0.2f, 0.25f, 0.35f, 1f);
			Button obj = val.AddComponent<Button>();
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.35f, 0.4f, 0.55f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.15f, 0.2f, 0.3f, 1f);
			((Selectable)obj).colors = colors;
			string capturedPrefab = prefabName;
			string capturedGuid = guid;
			((UnityEvent)obj.onClick).AddListener((UnityAction)delegate
			{
				OnOrbSelected(capturedPrefab, capturedGuid);
			});
			GameObject val2 = new GameObject("Text");
			val2.transform.SetParent(val.transform, false);
			TextMeshProUGUI obj2 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = displayName;
			((TMP_Text)obj2).fontSize = 18f;
			((Graphic)obj2).color = Color.white;
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)514;
			RectTransform rectTransform = ((TMP_Text)obj2).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = new Vector2(5f, 2f);
			rectTransform.offsetMax = new Vector2(-5f, -2f);
		}

		private static void OnOrbSelected(string prefabName, string guid)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)("[MirrorEventUI] Orb selected for removal: " + prefabName + " (guid=" + guid + ")"));
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMessageSender>(out var instance))
				{
					instance.Send(new MirrorEventCompleteEvent
					{
						Action = "remove_one",
						RemovedOrbName = prefabName,
						RemovedOrbGuid = guid
					});
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogError((object)("[MirrorEventUI] Failed to send remove_one: " + ex.Message));
				}
			}
			Hide();
		}

		private static TextMeshProUGUI CreateText(Transform parent, string name, string text, float fontSize, Vector2 anchorMin, Vector2 anchorMax, Vector2 pivot, Vector2 pos, Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).text = text;
			((TMP_Text)obj).fontSize = fontSize;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			((Graphic)obj).color = Color.white;
			RectTransform rectTransform = ((TMP_Text)obj).rectTransform;
			rectTransform.anchorMin = anchorMin;
			rectTransform.anchorMax = anchorMax;
			rectTransform.pivot = pivot;
			rectTransform.anchoredPosition = pos;
			rectTransform.sizeDelta = size;
			return obj;
		}

		private static Button CreateButton(Transform parent, string name, string label, Color bgColor, Vector2 pos, Vector2 size, UnityAction onClick)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = bgColor;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = pos;
			component.sizeDelta = size;
			Button obj = val.AddComponent<Button>();
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).highlightedColor = bgColor * 1.2f;
			((ColorBlock)(ref colors)).pressedColor = bgColor * 0.8f;
			((Selectable)obj).colors = colors;
			((UnityEvent)obj.onClick).AddListener(onClick);
			GameObject val2 = new GameObject("Text");
			val2.transform.SetParent(val.transform, false);
			TextMeshProUGUI obj2 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).text = label;
			((TMP_Text)obj2).fontSize = 28f;
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)514;
			((Graphic)obj2).color = Color.white;
			RectTransform rectTransform = ((TMP_Text)obj2).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = new Vector2(10f, 5f);
			rectTransform.offsetMax = new Vector2(-10f, -5f);
			return obj;
		}
	}
	public class MultiplayerUI : MonoBehaviour
	{
		private INetworkTransport _transport;

		private ISteamTransport _steamTransport;

		private TransportRouter _router;

		private IMultiplayerMode _multiplayerMode;

		private AppId_t _currentAppId = new AppId_t(1296610u);

		private GameObject _canvasObj;

		private Canvas _canvas;

		private GameObject _overlayPanel;

		private GameObject _mainPanel;

		private GameObject _hostPanel;

		private GameObject _joinPanel;

		private GameObject _lobbyPanel;

		private GameObject _continuePanel;

		private GameObject _continueListContent;

		private TextMeshProUGUI _continueStatusText;

		private GameObject _multiplayerPanel;

		private Button _hostButton;

		private Button _joinButton;

		private Button _hostSteamButton;

		private Button _joinFriendButton;

		private Button _continueButton;

		private GameObject _advancedIpContainer;

		private Button _advancedToggleButton;

		private bool _advancedIpVisible;

		private GameObject _friendListPanel;

		private GameObject _friendListContent;

		private TextMeshProUGUI _friendListStatusText;

		private Button _inviteFriendButton;

		private TMP_InputField _codeInput;

		private TextMeshProUGUI _statusText;

		private TextMeshProUGUI _hostInfoText;

		private TextMeshProUGUI _lobbyStatusText;

		private TextMeshProUGUI _lobbyJoinLinkText;

		private float _inviteCopiedFlashUntil;

		private TextMeshProUGUI _multiplayerFeedText;

		private int _lastFeedVersion;

		private GameObject _waitingPanel;

		private TextMeshProUGUI _waitingText;

		private GameObject _spectatorBanner;

		private TextMeshProUGUI _spectatorBannerText;

		private GameObject _turnIndicatorPanel;

		private TextMeshProUGUI _turnIndicatorText;

		private GameObject _errorPanel;

		private static MultiplayerUI _instance;

		private bool _overlayVisible;

		private string _lastConnectionStatus = string.Empty;

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public static string LocalPlayerName { get; private set; } = string.Empty;


		private void Start()
		{
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_instance = this;
				_transport = MultiplayerPlugin.Services.Resolve<INetworkTransport>();
				_multiplayerMode = MultiplayerPlugin.Services.Resolve<IMultiplayerMode>();
				MultiplayerPlugin.Services.TryResolve<TransportRouter>(out _router);
				if (_router != null && !_router.HasSteam && Environment.GetEnvironmentVariable("SKIP_STEAM_INIT") != "1")
				{
					try
					{
						if (SteamManager.Initialized)
						{
							_router.AttachSteam(new SteamTransport());
						}
						else
						{
							ManualLogSource log = Log;
							if (log != null)
							{
								log.LogInfo((object)"[Steam] SteamManager not initialized — Steam UI disabled");
							}
						}
					}
					catch (Exception ex)
					{
						ManualLogSource log2 = Log;
						if (log2 != null)
						{
							log2.LogWarning((object)("[Steam] Attach failed: " + ex.Message));
						}
					}
				}
				_steamTransport = ((_router != null && _router.HasSteam) ? _router : null);
				if (_steamTransport != null)
				{
					try
					{
						_currentAppId = SteamUtils.GetAppID();
					}
					catch
					{
					}
					ManualLogSource log3 = Log;
					if (log3 != null)
					{
						log3.LogInfo((object)$"[Steam] Friend filter using appId={_currentAppId.m_AppId}");
					}
				}
				_transport.OnClientConnected += delegate
				{
					OnConnected();
				};
				_transport.OnDisconnected += delegate(int peerId)
				{
					OnDisconnected(peerId);
				};
				_transport.OnConnectionRejected += delegate(string reason)
				{
					OnConnectionRejected(reason);
				};
				if (_steamTransport != null)
				{
					_steamTransport.OnIncomingInvite += OnSteamInviteReceived;
				}
				string environmentVariable = Environment.GetEnvironmentVariable("MULTIPEGLIN_PLAYER_NAME");
				if (!string.IsNullOrEmpty(environmentVariable))
				{
					LocalPlayerName = environmentVariable;
				}
				else
				{
					try
					{
						if (SteamManager.Initialized)
						{
							LocalPlayerName = SteamFriends.GetPersonaName();
						}
					}
					catch
					{
					}
				}
				if (string.IsNullOrEmpty(LocalPlayerName))
				{
					LocalPlayerName = "Player";
				}
				ManualLogSource log4 = Log;
				if (log4 != null)
				{
					log4.LogInfo((object)("Player name: " + LocalPlayerName));
				}
				CreateCanvas();
				CreateOverlay();
				HideOverlay();
				IReadOnlyList<string> missingPatches = MultiplayerPlugin.MissingPatches;
				if (missingPatches != null && missingPatches.Count > 0)
				{
					ShowErrorDialog("Multipeglin v0.1.10 was built for Peglin v2.0.12.\n\n" + $"{missingPatches.Count} game method(s) could not be found.\n" + "A game update may have affected the mod.\nCheck for a mod update.");
				}
				ManualLogSource log5 = Log;
				if (log5 != null)
				{
					log5.LogInfo((object)"MultiplayerUI initialized");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log6 = Log;
				if (log6 != null)
				{
					log6.LogError((object)$"MultiplayerUI.Start() failed: {arg}");
				}
			}
		}

		private void Update()
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_lobbyPanel != (Object)null && _lobbyPanel.activeSelf)
			{
				UpdateLobbyPanel();
			}
			if ((Object)(object)_multiplayerPanel != (Object)null && _multiplayerPanel.activeSelf && _multiplayerMode.ClientMode == ClientMode.Diagnostics && EventFeed.Version != _lastFeedVersion)
			{
				_lastFeedVersion = EventFeed.Version;
				((TMP_Text)_multiplayerFeedText).text = EventFeed.GetText(40);
			}
			if (_multiplayerMode.IsSpectating && _multiplayerMode.ClientMode == ClientMode.Mirror && LobbyUI.GameStartReceived)
			{
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				string clientWaitingMessage = MapStateApplier.ClientWaitingMessage;
				bool flag = name == "Battle" && (Object)(object)_turnIndicatorPanel != (Object)null && _turnIndicatorPanel.activeSelf;
				bool flag2 = name == "PegMinigame" || name == "TextScenario";
				if (!string.IsNullOrEmpty(clientWaitingMessage) && !flag)
				{
					if (flag2)
					{
						if ((Object)(object)_spectatorBanner == (Object)null)
						{
							CreateSpectatorBanner();
						}
						_spectatorBanner.SetActive(true);
						((TMP_Text)_spectatorBannerText).text = clientWaitingMessage;
						GameObject waitingPanel = _waitingPanel;
						if (waitingPanel != null)
						{
							waitingPanel.SetActive(false);
						}
					}
					else
					{
						if ((Object)(object)_waitingPanel == (Object)null)
						{
							CreateWaitingPanel();
						}
						_waitingPanel.SetActive(true);
						((TMP_Text)_waitingText).text = clientWaitingMessage;
						GameObject spectatorBanner = _spectatorBanner;
						if (spectatorBanner != null)
						{
							spectatorBanner.SetActive(false);
						}
					}
				}
				else
				{
					GameObject waitingPanel2 = _waitingPanel;
					if (waitingPanel2 != null)
					{
						waitingPanel2.SetActive(false);
					}
					GameObject spectatorBanner2 = _spectatorBanner;
					if (spectatorBanner2 != null)
					{
						spectatorBanner2.SetActive(false);
					}
				}
			}
			else
			{
				GameObject waitingPanel3 = _waitingPanel;
				if (waitingPanel3 != null)
				{
					waitingPanel3.SetActive(false);
				}
				GameObject spectatorBanner3 = _spectatorBanner;
				if (spectatorBanner3 != null)
				{
					spectatorBanner3.SetActive(false);
				}
			}
			UpdateTurnIndicator();
		}

		private void OnDestroy()
		{
			if ((Object)(object)_canvasObj != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObj);
			}
		}

		private void CreateCanvas()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			_canvasObj = new GameObject("MultiplayerMultiplayerCanvas");
			Object.DontDestroyOnLoad((Object)(object)_canvasObj);
			_canvas = _canvasObj.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 100;
			CanvasScaler obj = _canvasObj.AddComponent<CanvasScaler>();
			obj.uiScaleMode = (ScaleMode)1;
			obj.referenceResolution = new Vector2(1920f, 1080f);
			obj.matchWidthOrHeight = 0.5f;
			_canvasObj.AddComponent<GraphicRaycaster>();
		}

		private void CreateOverlay()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			_overlayPanel = new GameObject("OverlayPanel");
			_overlayPanel.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_overlayPanel.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.85f);
			StretchFill(_overlayPanel.GetComponent<RectTransform>());
			GameObject val = CreatePanel(_overlayPanel.transform, "CenterPanel", new Color(0.12f, 0.12f, 0.12f, 1f), new Vector2(960f, 880f));
			RectTransform rectTransform = ((TMP_Text)CreateText(val.transform, "Title", "Multiplayer", 48f)).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 1f);
			rectTransform.anchorMax = new Vector2(0.5f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, -32f);
			rectTransform.sizeDelta = new Vector2(640f, 64f);
			CreateMainPanel(val.transform);
			CreateHostPanel(val.transform);
			CreateJoinPanel(val.transform);
			CreateLobbyPanel(val.transform);
			CreateContinuePanel(val.transform);
			ShowMainPanel();
		}

		private void CreateMainPanel(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_04f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0503: Unknown result type (might be due to invalid IL or missing references)
			//IL_0512: Unknown result type (might be due to invalid IL or missing references)
			//IL_0533: Unknown result type (might be due to invalid IL or missing references)
			//IL_053d: Expected O, but got Unknown
			//IL_0567: Unknown result type (might be due to invalid IL or missing references)
			//IL_0576: Unknown result type (might be due to invalid IL or missing references)
			//IL_0585: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b0: Expected O, but got Unknown
			//IL_05da: Unknown result type (might be due to invalid IL or missing references)
			//IL_05e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_05f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0619: Unknown result type (might be due to invalid IL or missing references)
			//IL_0623: Expected O, but got Unknown
			//IL_064c: Unknown result type (might be due to invalid IL or missing references)
			//IL_065b: Unknown result type (might be due to invalid IL or missing references)
			//IL_066a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0680: Unknown result type (might be due to invalid IL or missing references)
			//IL_068a: Expected O, but got Unknown
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0097: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Expected O, but got Unknown
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Expected O, but got Unknown
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_0246: Unknown result type (might be due to invalid IL or missing references)
			//IL_025a: 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_029d: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d7: Expected O, but got Unknown
			//IL_02dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Expected O, but got Unknown
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_032e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0343: Unknown result type (might be due to invalid IL or missing references)
			//IL_034e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Unknown result type (might be due to invalid IL or missing references)
			//IL_0396: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_03df: Expected O, but got Unknown
			//IL_0409: Unknown result type (might be due to invalid IL or missing references)
			//IL_0418: Unknown result type (might be due to invalid IL or missing references)
			//IL_0427: Unknown result type (might be due to invalid IL or missing references)
			//IL_0448: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Expected O, but got Unknown
			//IL_0487: Unknown result type (might be due to invalid IL or missing references)
			//IL_0496: Unknown result type (might be due to invalid IL or missing references)
			//IL_04a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c5: Expected O, but got Unknown
			//IL_06aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_06cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_06e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_070a: Unknown result type (might be due to invalid IL or missing references)
			//IL_071e: Unknown result type (might be due to invalid IL or missing references)
			_mainPanel = new GameObject("MainPanel");
			_mainPanel.transform.SetParent(parent, false);
			StretchFill(_mainPanel.GetComponent<RectTransform>() ?? _mainPanel.AddComponent<RectTransform>());
			if (_steamTransport != null)
			{
				_hostSteamButton = CreateButton(_mainPanel.transform, "HostSteamBtn", "Host (Steam)", new Color(0.2f, 0.55f, 0.25f, 1f), new Vector2(0f, 144f), new Vector2(480f, 80f));
				((UnityEvent)_hostSteamButton.onClick).AddListener(new UnityAction(OnHostSteamClicked));
				_joinFriendButton = CreateButton(_mainPanel.transform, "JoinFriendBtn", "Join Friend", new Color(0.2f, 0.35f, 0.6f, 1f), new Vector2(0f, 56f), new Vector2(480f, 80f));
				((UnityEvent)_joinFriendButton.onClick).AddListener(new UnityAction(OnJoinFriendClicked));
				_continueButton = CreateButton(_mainPanel.transform, "ContinueBtn", "Continue", new Color(0.4f, 0.35f, 0.55f, 1f), new Vector2(0f, -32f), new Vector2(480f, 80f));
				((UnityEvent)_continueButton.onClick).AddListener(new UnityAction(OnContinueClicked));
				TextMeshProUGUI obj = CreateText(_mainPanel.transform, "SteamStatus", "Steam: " + LocalPlayerName, 22f);
				((Graphic)obj).color = new Color(0.7f, 0.85f, 0.7f, 1f);
				((Graphic)obj).raycastTarget = false;
				RectTransform rectTransform = ((TMP_Text)obj).rectTransform;
				rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
				rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
				rectTransform.pivot = new Vector2(0.5f, 0.5f);
				rectTransform.anchoredPosition = new Vector2(0f, 212f);
				rectTransform.sizeDelta = new Vector2(480f, 30f);
				_advancedToggleButton = CreateButton(_mainPanel.transform, "AdvancedToggle", "Advanced: Direct IP", new Color(0.25f, 0.25f, 0.3f, 1f), new Vector2(0f, -112f), new Vector2(360f, 44f));
				((UnityEvent)_advancedToggleButton.onClick).AddListener(new UnityAction(OnAdvancedToggleClicked));
				_advancedIpContainer = new GameObject("AdvancedIpContainer");
				_advancedIpContainer.transform.SetParent(_mainPanel.transform, false);
				RectTransform obj2 = _advancedIpContainer.AddComponent<RectTransform>();
				obj2.anchorMin = new Vector2(0.5f, 0.5f);
				obj2.anchorMax = new Vector2(0.5f, 0.5f);
				obj2.pivot = new Vector2(0.5f, 0.5f);
				obj2.anchoredPosition = Vector2.zero;
				obj2.sizeDelta = new Vector2(480f, 160f);
				_hostButton = CreateButton(_advancedIpContainer.transform, "HostBtn", "Host (Direct IP)", new Color(0.3f, 0.45f, 0.3f, 1f), new Vector2(0f, -116f), new Vector2(420f, 64f));
				((UnityEvent)_hostButton.onClick).AddListener(new UnityAction(OnHostClicked));
				_joinButton = CreateButton(_advancedIpContainer.transform, "JoinBtn", "Join (Direct IP)", new Color(0.3f, 0.35f, 0.5f, 1f), new Vector2(0f, -184f), new Vector2(420f, 64f));
				((UnityEvent)_joinButton.onClick).AddListener(new UnityAction(OnJoinClicked));
				_advancedIpContainer.SetActive(false);
				((UnityEvent)CreateButton(_mainPanel.transform, "BackBtn", "Close", new Color(0.35f, 0.2f, 0.2f, 1f), new Vector2(0f, -260f), new Vector2(360f, 56f)).onClick).AddListener(new UnityAction(HideOverlay));
			}
			else
			{
				_hostButton = CreateButton(_mainPanel.transform, "HostBtn", "Host Game", new Color(0.2f, 0.55f, 0.25f, 1f), new Vector2(0f, 96f), new Vector2(480f, 80f));
				((UnityEvent)_hostButton.onClick).AddListener(new UnityAction(OnHostClicked));
				_joinButton = CreateButton(_mainPanel.transform, "JoinBtn", "Join Game", new Color(0.2f, 0.35f, 0.6f, 1f), new Vector2(0f, 8f), new Vector2(480f, 80f));
				((UnityEvent)_joinButton.onClick).AddListener(new UnityAction(OnJoinClicked));
				_continueButton = CreateButton(_mainPanel.transform, "ContinueBtn", "Continue", new Color(0.4f, 0.35f, 0.55f, 1f), new Vector2(0f, -80f), new Vector2(480f, 80f));
				((UnityEvent)_continueButton.onClick).AddListener(new UnityAction(OnContinueClicked));
				((UnityEvent)CreateButton(_mainPanel.transform, "BackBtn", "Close", new Color(0.35f, 0.2f, 0.2f, 1f), new Vector2(0f, -184f), new Vector2(480f, 80f)).onClick).AddListener(new UnityAction(HideOverlay));
			}
			TextMeshProUGUI obj3 = CreateText(_mainPanel.transform, "VersionText", "Multipeglin v0.1.10", 40f);
			((Graphic)obj3).color = Color.white;
			((Graphic)obj3).raycastTarget = false;
			RectTransform rectTransform2 = ((TMP_Text)obj3).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform2.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform2.pivot = new Vector2(0.5f, 0.5f);
			rectTransform2.anchoredPosition = new Vector2(0f, -310f);
			rectTransform2.sizeDelta = new Vector2(480f, 30f);
		}

		private void OnAdvancedToggleClicked()
		{
			_advancedIpVisible = !_advancedIpVisible;
			GameObject advancedIpContainer = _advancedIpContainer;
			if (advancedIpContainer != null)
			{
				advancedIpContainer.SetActive(_advancedIpVisible);
			}
			if ((Object)(object)_advancedToggleButton != (Object)null)
			{
				TextMeshProUGUI componentInChildren = ((Component)_advancedToggleButton).GetComponentInChildren<TextMeshProUGUI>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)componentInChildren).text = "Advanced: Direct IP";
				}
			}
		}

		private void CreateHostPanel(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: 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)
			_hostPanel = new GameObject("HostPanel");
			_hostPanel.transform.SetParent(parent, false);
			StretchFill(_hostPanel.GetComponent<RectTransform>() ?? _hostPanel.AddComponent<RectTransform>());
			_hostInfoText = CreateText(_hostPanel.transform, "HostInfo", string.Empty, 29f);
			RectTransform rectTransform = ((TMP_Text)_hostInfoText).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(0f, 80f);
			rectTransform.sizeDelta = new Vector2(640f, 48f);
			_hostPanel.SetActive(false);
		}

		private void CreateJoinPanel(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Unknown result type (might be due to invalid IL or missing references)
			//IL_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Expected O, but got Unknown
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Expected O, but got Unknown
			//IL_02d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_030a: Unknown result type (might be due to invalid IL or missing references)
			//IL_031f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			//IL_0348: Unknown result type (might be due to invalid IL or missing references)
			_joinPanel = new GameObject("JoinPanel");
			_joinPanel.transform.SetParent(parent, false);
			StretchFill(_joinPanel.GetComponent<RectTransform>() ?? _joinPanel.AddComponent<RectTransform>());
			RectTransform rectTransform = ((TMP_Text)CreateText(_joinPanel.transform, "Label", "Enter host address (IP:PORT):", 29f)).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(0f, 96f);
			rectTransform.sizeDelta = new Vector2(640f, 48f);
			_codeInput = CreateInputField(_joinPanel.transform, "CodeInput", "IP:PORT", new Vector2(0f, 32f), new Vector2(560f, 72f));
			_codeInput.text = $"127.0.0.1:{7777}";
			((UnityEvent)CreateButton(_joinPanel.transform, "ConnectBtn", "Connect", new Color(0.2f, 0.35f, 0.6f, 1f), new Vector2(0f, -104f), new Vector2(480f, 88f)).onClick).AddListener(new UnityAction(OnConnectClicked));
			_statusText = CreateText(_joinPanel.transform, "StatusText", string.Empty, 26f);
			((Graphic)_statusText).color = new Color(0.8f, 0.8f, 0.3f, 1f);
			RectTransform rectTransform2 = ((TMP_Text)_statusText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform2.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform2.pivot = new Vector2(0.5f, 0.5f);
			rectTransform2.anchoredPosition = new Vector2(0f, -184f);
			rectTransform2.sizeDelta = new Vector2(640f, 48f);
			((UnityEvent)CreateButton(_joinPanel.transform, "CancelBtn", "Back", new Color(0.35f, 0.2f, 0.2f, 1f), new Vector2(0f, -248f), new Vector2(480f, 88f)).onClick).AddListener(new UnityAction(OnCancelJoinClicked));
			TextMeshProUGUI obj = CreateText(_joinPanel.transform, "VersionText", "Multipeglin v0.1.10", 40f);
			((Graphic)obj).color = Color.white;
			((Graphic)obj).raycastTarget = false;
			RectTransform rectTransform3 = ((TMP_Text)obj).rectTransform;
			rectTransform3.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform3.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform3.pivot = new Vector2(0.5f, 0.5f);
			rectTransform3.anchoredPosition = new Vector2(0f, -310f);
			rectTransform3.sizeDelta = new Vector2(480f, 30f);
			_joinPanel.SetActive(false);
		}

		private void CreateLobbyPanel(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_020d: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Expected O, but got Unknown
			//IL_0272: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Unknown result type (might be due to invalid IL or missing references)
			//IL_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Expected O, but got Unknown
			_lobbyPanel = new GameObject("LobbyPanel");
			_lobbyPanel.transform.SetParent(parent, false);
			StretchFill(_lobbyPanel.GetComponent<RectTransform>() ?? _lobbyPanel.AddComponent<RectTransform>());
			_lobbyStatusText = CreateText(_lobbyPanel.transform, "LobbyStatus", string.Empty, 22f);
			((Graphic)_lobbyStatusText).color = new Color(0.6f, 0.6f, 0.6f, 1f);
			RectTransform rectTransform = ((TMP_Text)_lobbyStatusText).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(0f, 290f);
			rectTransform.sizeDelta = new Vector2(640f, 36f);
			_lobbyJoinLinkText = CreateText(_lobbyPanel.transform, "LobbyJoinLink", string.Empty, 16f);
			((Graphic)_lobbyJoinLinkText).color = new Color(0.55f, 0.75f, 0.95f, 1f);
			((TMP_Text)_lobbyJoinLinkText).enableWordWrapping = true;
			RectTransform rectTransform2 = ((TMP_Text)_lobbyJoinLinkText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform2.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform2.pivot = new Vector2(0.5f, 0.5f);
			rectTransform2.anchoredPosition = new Vector2(0f, 240f);
			rectTransform2.sizeDelta = new Vector2(780f, 44f);
			_inviteFriendButton = CreateButton(_lobbyPanel.transform, "InviteFriendBtn", "Copy Invite Link", new Color(0.2f, 0.45f, 0.55f, 1f), new Vector2(0f, -345f), new Vector2(400f, 56f));
			((UnityEvent)_inviteFriendButton.onClick).AddListener(new UnityAction(OnInviteFriendClicked));
			((Component)_inviteFriendButton).gameObject.SetActive(false);
			((UnityEvent)CreateButton(_lobbyPanel.transform, "DisconnectBtn", "Disconnect", new Color(0.5f, 0.2f, 0.2f, 1f), new Vector2(0f, -395f), new Vector2(400f, 56f)).onClick).AddListener(new UnityAction(OnDisconnectClicked));
			_lobbyPanel.SetActive(false);
		}

		private void OnInviteFriendClicked()
		{
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)"[Invite] Clicked");
			}
			if (_steamTransport == null)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)"[Invite] No Steam transport");
				}
				return;
			}
			CSteamID hostedLobbyId = _steamTransport.HostedLobbyId;
			if (!((CSteamID)(ref hostedLobbyId)).IsValid())
			{
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogWarning((object)"[Invite] No hosted lobby id");
				}
				return;
			}
			uint num = 0u;
			try
			{
				num = SteamUtils.GetAppID().m_AppId;
			}
			catch
			{
			}
			string text = $"steam://joinlobby/{num}/{hostedLobbyId.m_SteamID}/{SteamUser.GetSteamID().m_SteamID}";
			bool flag = false;
			try
			{
				flag = SteamUtils.IsOverlayEnabled();
			}
			catch (Exception ex)
			{
				ManualLogSource log4 = Log;
				if (log4 != null)
				{
					log4.LogWarning((object)("[Invite] IsOverlayEnabled threw: " + ex.Message));
				}
			}
			ManualLogSource log5 = Log;
			if (log5 != null)
			{
				log5.LogInfo((object)$"[Invite] appId={num} lobby={hostedLobbyId.m_SteamID} overlayEnabled={flag} joinUrl={text}");
			}
			if (flag)
			{
				try
				{
					SteamFriends.ActivateGameOverlayInviteDialog(hostedLobbyId);
					ManualLogSource log6 = Log;
					if (log6 != null)
					{
						log6.LogInfo((object)"[Invite] ActivateGameOverlayInviteDialog called");
					}
					return;
				}
				catch (Exception arg)
				{
					ManualLogSource log7 = Log;
					if (log7 != null)
					{
						log7.LogError((object)$"[Invite] ActivateGameOverlayInviteDialog failed: {arg}");
					}
					return;
				}
			}
			try
			{
				GUIUtility.systemCopyBuffer = text;
			}
			catch (Exception ex2)
			{
				ManualLogSource log8 = Log;
				if (log8 != null)
				{
					log8.LogWarning((object)("[Invite] Clipboard copy failed: " + ex2.Message));
				}
			}
			_inviteCopiedFlashUntil = Time.unscaledTime + 3f;
		}

		private void CreateFriendListPanel(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: 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_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Expected O, but got Unknown
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_016a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0198: Expected O, but got Unknown
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_0277: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_030c: Unknown result type (might be due to invalid IL or missing references)
			//IL_031b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0331: Unknown result type (might be due to invalid IL or missing references)
			//IL_033b: Expected O, but got Unknown
			//IL_0364: Unknown result type (might be due to invalid IL or missing references)
			//IL_0373: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_0398: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a2: Expected O, but got Unknown
			_friendListPanel = new GameObject("FriendListPanel");
			_friendListPanel.transform.SetParent(parent, false);
			StretchFill(_friendListPanel.GetComponent<RectTransform>() ?? _friendListPanel.AddComponent<RectTransform>());
			RectTransform rectTransform = ((TMP_Text)CreateText(_friendListPanel.transform, "FriendsTitle", "Friends in Peglin", 30f)).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(0f, 210f);
			rectTransform.sizeDelta = new Vector2(640f, 40f);
			GameObject val = new GameObject("Viewport");
			val.transform.SetParent(_friendListPanel.transform, false);
			((Graphic)val.AddComponent<Image>()).color = new Color(0.08f, 0.08f, 0.1f, 1f);
			val.AddComponent<RectMask2D>();
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = new Vector2(0f, 0f);
			component.sizeDelta = new Vector2(760f, 340f);
			_friendListContent = new GameObject("Content");
			_friendListContent.transform.SetParent(val.transform, false);
			RectTransform obj = _friendListContent.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 1f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.pivot = new Vector2(0.5f, 1f);
			obj.anchoredPosition = Vector2.zero;
			obj.sizeDelta = new Vector2(0f, 0f);
			_friendListStatusText = CreateText(_friendListPanel.transform, "FriendsStatus", string.Empty, 22f);
			((Graphic)_friendListStatusText).color = new Color(0.8f, 0.8f, 0.3f, 1f);
			RectTransform rectTransform2 = ((TMP_Text)_friendListStatusText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform2.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform2.pivot = new Vector2(0.5f, 0.5f);
			rectTransform2.anchoredPosition = new Vector2(0f, -195f);
			rectTransform2.sizeDelta = new Vector2(640f, 36f);
			((UnityEvent)CreateButton(_friendListPanel.transform, "RefreshBtn", "Refresh", new Color(0.25f, 0.4f, 0.55f, 1f), new Vector2(-160f, -250f), new Vector2(260f, 56f)).onClick).AddListener(new UnityAction(PopulateFriendList));
			((UnityEvent)CreateButton(_friendListPanel.transform, "FriendsBackBtn", "Back", new Color(0.35f, 0.2f, 0.2f, 1f), new Vector2(160f, -250f), new Vector2(260f, 56f)).onClick).AddListener((UnityAction)delegate
			{
				_friendListPanel.SetActive(false);
				ShowMainPanel();
			});
			_friendListPanel.SetActive(false);
		}

		private void ShowFriendListPanel()
		{
			_mainPanel.SetActive(false);
			_hostPanel.SetActive(false);
			_joinPanel.SetActive(false);
			_lobbyPanel.SetActive(false);
			if ((Object)(object)_friendListPanel == (Object)null)
			{
				Transform parent = _mainPanel.transform.parent;
				CreateFriendListPanel(parent);
			}
			_friendListPanel.SetActive(true);
			PopulateFriendList();
		}

		private void PopulateFriendList()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0075: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: 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)
			if ((Object)(object)_friendListContent == (Object)null)
			{
				return;
			}
			for (int num = _friendListContent.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)_friendListContent.transform.GetChild(num)).gameObject);
			}
			int num2 = 0;
			try
			{
				int friendCount = SteamFriends.GetFriendCount((EFriendFlags)4);
				FriendGameInfo_t val = default(FriendGameInfo_t);
				for (int i = 0; i < friendCount; i++)
				{
					CSteamID friendByIndex = SteamFriends.GetFriendByIndex(i, (EFriendFlags)4);
					if (SteamFriends.GetFriendGamePlayed(friendByIndex, ref val) && !(((CGameID)(ref val.m_gameID)).AppID() != _currentAppId) && ((CSteamID)(ref val.m_steamIDLobby)).IsValid())
					{
						string friendPersonaName = SteamFriends.GetFriendPersonaName(friendByIndex);
						AddFriendRow(num2, friendPersonaName, val.m_steamIDLobby);
						num2++;
					}
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogError((object)$"PopulateFriendList failed: {arg}");
				}
				((TMP_Text)_friendListStatusText).text = "Failed to read Steam friends list.";
				return;
			}
			((TMP_Text)_friendListStatusText).text = ((num2 == 0) ? "No friends are hosting a Multipeglin lobby right now." : string.Format("{0} friend{1} hosting.", num2, (num2 == 1) ? string.Empty : "s"));
		}

		private void AddFriendRow(int index, string name, CSteamID lobbyId)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: 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_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: 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_016f: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Expected O, but got Unknown
			GameObject val = new GameObject($"Friend_{index}");
			val.transform.SetParent(_friendListContent.transform, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0f, 1f);
			obj.anchorMax = new Vector2(1f, 1f);
			obj.pivot = new Vector2(0.5f, 1f);
			obj.anchoredPosition = new Vector2(0f, (float)(-index * 64 - 8));
			obj.sizeDelta = new Vector2(-20f, 56f);
			((Graphic)val.AddComponent<Image>()).color = new Color(0.15f, 0.15f, 0.18f, 1f);
			TextMeshProUGUI obj2 = CreateText(val.transform, "Name", name, 26f);
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)4097;
			RectTransform rectTransform = ((TMP_Text)obj2).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 0f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.offsetMin = new Vector2(20f, 0f);
			rectTransform.offsetMax = new Vector2(-180f, 0f);
			Button obj3 = CreateButton(val.transform, "JoinBtn", "Join", new Color(0.2f, 0.45f, 0.25f, 1f), Vector2.zero, new Vector2(140f, 44f));
			RectTransform component = ((Component)obj3).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(1f, 0.5f);
			component.anchorMax = new Vector2(1f, 0.5f);
			component.pivot = new Vector2(1f, 0.5f);
			component.anchoredPosition = new Vector2(-16f, 0f);
			CSteamID lobbyCapture = lobbyId;
			((UnityEvent)obj3.onClick).AddListener((UnityAction)delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				OnJoinLobbyClicked(lobbyCapture);
			});
		}

		private void OnJoinLobbyClicked(CSteamID lobbyId)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			if (_steamTransport == null)
			{
				return;
			}
			try
			{
				_router?.UseSteam();
				_multiplayerMode.EnableSpectating();
				FileLogger.RoleTag = "CLIENT";
				if (_multiplayerMode is MultiplayerMode multiplayerMode)
				{
					multiplayerMode.ClientMode = ClientMode.Mirror;
				}
				_steamTransport.JoinSteamLobby(lobbyId);
				((TMP_Text)_friendListStatusText).text = "Joining...";
				Log.LogInfo((object)$"Joining Steam lobby {lobbyId.m_SteamID}");
			}
			catch (Exception ex)
			{
				Log.LogError((object)$"Failed to join Steam lobby: {ex}");
				((TMP_Text)_friendListStatusText).text = "Error: " + ex.Message;
			}
		}

		private void UpdateLobbyPanel()
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_lobbyStatusText == (Object)null)
			{
				return;
			}
			bool flag = _router != null && _router.ActiveIsSteam;
			if (Time.unscaledTime < _inviteCopiedFlashUntil)
			{
				((TMP_Text)_lobbyStatusText).text = "Join link copied to clipboard — paste to a friend in Steam chat";
			}
			else if (_multiplayerMode.IsHosting)
			{
				((TMP_Text)_lobbyStatusText).text = (flag ? "Hosting via Steam lobby" : $"Hosting on port {7777}");
			}
			else if (_transport.IsConnected)
			{
				((TMP_Text)_lobbyStatusText).text = "Connected";
			}
			else
			{
				((TMP_Text)_lobbyStatusText).text = "Connecting...";
			}
			Button inviteFriendButton = _inviteFriendButton;
			if (inviteFriendButton != null)
			{
				((Component)inviteFriendButton).gameObject.SetActive(_multiplayerMode.IsHosting && flag);
			}
			if ((Object)(object)_lobbyJoinLinkText != (Object)null)
			{
				bool active = false;
				if (_multiplayerMode.IsHosting && flag && _steamTransport != null)
				{
					CSteamID hostedLobbyId = _steamTransport.HostedLobbyId;
					bool flag2 = false;
					try
					{
						flag2 = SteamUtils.IsOverlayEnabled();
					}
					catch
					{
					}
					if (((CSteamID)(ref hostedLobbyId)).IsValid() && !flag2)
					{
						uint num = 0u;
						try
						{
							num = SteamUtils.GetAppID().m_AppId;
						}
						catch
						{
						}
						((TMP_Text)_lobbyJoinLinkText).text = $"steam://joinlobby/{num}/{hostedLobbyId.m_SteamID}/{SteamUser.GetSteamID().m_SteamID}";
						active = true;
					}
				}
				((Component)_lobbyJoinLinkText).gameObject.SetActive(active);
			}
			LobbyUI.UpdateLobbyUI(_lobbyPanel.transform, _multiplayerMode.IsHosting, (Transform parent, string name, string text, int size) => CreateText(parent, name, text, size), (Transform parent, string name, string text, Color color, Vector2 pos, Vector2 sz) => CreateButton(parent, name, text, color, pos, sz));
			if (LobbyUI.GameStartReceived)
			{
				HideOverlay();
			}
		}

		private void OnDisconnectClicked()
		{
			MultiplayerSession.DisconnectAndReset("User clicked disconnect");
			GameObject multiplayerPanel = _multiplayerPanel;
			if (multiplayerPanel != null)
			{
				multiplayerPanel.SetActive(false);
			}
			GameObject waitingPanel = _waitingPanel;
			if (waitingPanel != null)
			{
				waitingPanel.SetActive(false);
			}
			GameObject turnIndicatorPanel = _turnIndicatorPanel;
			if (turnIndicatorPanel != null)
			{
				turnIndicatorPanel.SetActive(false);
			}
			_overlayPanel.SetActive(true);
			ShowMainPanel();
		}

		private void CreateMultiplayerPanel()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: 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_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0213: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_023c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_025c: Expected O, but got Unknown
			_multiplayerPanel = new GameObject("MultiplayerPanel");
			_multiplayerPanel.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_multiplayerPanel.AddComponent<Image>()).color = new Color(0.05f, 0.05f, 0.1f, 0.95f);
			StretchFill(_multiplayerPanel.GetComponent<RectTransform>());
			RectTransform rectTransform = ((TMP_Text)CreateText(_multiplayerPanel.transform, "MultiplayerTitle", "Spectating — Event Feed", 42f)).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, -10f);
			rectTransform.sizeDelta = new Vector2(0f, 48f);
			_multiplayerFeedText = CreateText(_multiplayerPanel.transform, "FeedText", string.Empty, 36f);
			((TMP_Text)_multiplayerFeedText).alignment = (TextAlignmentOptions)257;
			((TMP_Text)_multiplayerFeedText).enableWordWrapping = true;
			((TMP_Text)_multiplayerFeedText).overflowMode = (TextOverflowModes)3;
			RectTransform rectTransform2 = ((TMP_Text)_multiplayerFeedText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 0f);
			rectTransform2.anchorMax = new Vector2(1f, 1f);
			rectTransform2.offsetMin = new Vector2(20f, 80f);
			rectTransform2.offsetMax = new Vector2(-20f, -64f);
			Button obj = CreateButton(_multiplayerPanel.transform, "MultiplayerDisconnect", "Disconnect", new Color(0.5f, 0.2f, 0.2f, 1f), new Vector2(0f, 0f), new Vector2(300f, 60f));
			RectTransform component = ((Component)obj).GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0f);
			component.anchorMax = new Vector2(0.5f, 0f);
			component.pivot = new Vector2(0.5f, 0f);
			component.anchoredPosition = new Vector2(0f, 10f);
			((UnityEvent)obj.onClick).AddListener(new UnityAction(OnDisconnectClicked));
			_multiplayerPanel.SetActive(false);
		}

		private void CreateWaitingPanel()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_004b: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			_waitingPanel = new GameObject("WaitingPanel");
			_waitingPanel.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_waitingPanel.AddComponent<Image>()).color = new Color(0.05f, 0.05f, 0.1f, 0.92f);
			StretchFill(_waitingPanel.GetComponent<RectTransform>());
			_waitingText = CreateText(_waitingPanel.transform, "WaitingText", string.Empty, 42f);
			((TMP_Text)_waitingText).alignment = (TextAlignmentOptions)514;
			RectTransform rectTransform = ((TMP_Text)_waitingText).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = Vector2.zero;
			rectTransform.sizeDelta = new Vector2(800f, 200f);
			_waitingPanel.SetActive(false);
		}

		private void CreateSpectatorBanner()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			_spectatorBanner = new GameObject("SpectatorBanner");
			_spectatorBanner.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_spectatorBanner.AddComponent<Image>()).color = new Color(0.05f, 0.05f, 0.15f, 0.7f);
			RectTransform component = _spectatorBanner.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 1f);
			component.anchorMax = new Vector2(1f, 1f);
			component.pivot = new Vector2(0.5f, 1f);
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = new Vector2(0f, 60f);
			_spectatorBannerText = CreateText(_spectatorBanner.transform, "SpectatorText", string.Empty, 32f);
			((TMP_Text)_spectatorBannerText).alignment = (TextAlignmentOptions)514;
			RectTransform rectTransform = ((TMP_Text)_spectatorBannerText).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = new Vector2(10f, 5f);
			rectTransform.offsetMax = new Vector2(-10f, -5f);
			_spectatorBanner.SetActive(false);
		}

		private void UpdateTurnIndicator()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			string turnMessage = TurnChangeClientHandler.TurnMessage;
			if (name == "Battle" && _transport != null && _transport.IsConnected && LobbyUI.GameStartReceived && !string.IsNullOrEmpty(turnMessage))
			{
				if ((Object)(object)_turnIndicatorPanel == (Object)null)
				{
					CreateTurnIndicator();
				}
				_turnIndicatorPanel.SetActive(true);
				((TMP_Text)_turnIndicatorText).text = turnMessage;
			}
			else
			{
				GameObject turnIndicatorPanel = _turnIndicatorPanel;
				if (turnIndicatorPanel != null)
				{
					turnIndicatorPanel.SetActive(false);
				}
			}
		}

		private void CreateTurnIndicator()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_004c: 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_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: 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)
			_turnIndicatorPanel = new GameObject("TurnIndicatorPanel");
			_turnIndicatorPanel.transform.SetParent(_canvasObj.transform, false);
			Image obj = _turnIndicatorPanel.AddComponent<Image>();
			((Graphic)obj).color = new Color(0.05f, 0.05f, 0.15f, 0.75f);
			((Graphic)obj).raycastTarget = false;
			RectTransform component = _turnIndicatorPanel.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.25f, 0.92f);
			component.anchorMax = new Vector2(0.75f, 1f);
			component.offsetMin = Vector2.zero;
			component.offsetMax = Vector2.zero;
			_turnIndicatorText = CreateText(_turnIndicatorPanel.transform, "TurnText", string.Empty, 28f);
			((TMP_Text)_turnIndicatorText).alignment = (TextAlignmentOptions)514;
			((Graphic)_turnIndicatorText).raycastTarget = false;
			RectTransform rectTransform = ((TMP_Text)_turnIndicatorText).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = new Vector2(10f, 2f);
			rectTransform.offsetMax = new Vector2(-10f, -2f);
			_turnIndicatorPanel.SetActive(false);
		}

		private void ShowMultiplayerView()
		{
			_overlayPanel.SetActive(false);
			if (_multiplayerMode.ClientMode == ClientMode.Diagnostics)
			{
				if ((Object)(object)_multiplayerPanel == (Object)null)
				{
					CreateMultiplayerPanel();
				}
				_multiplayerPanel.SetActive(true);
				_overlayVisible = true;
				EventFeed.Clear();
				_lastFeedVersion = -1;
			}
			else
			{
				GameObject multiplayerPanel = _multiplayerPanel;
				if (multiplayerPanel != null)
				{
					multiplayerPanel.SetActive(false);
				}
				_overlayVisible = false;
			}
		}

		private void ShowMainPanel()
		{
			_mainPanel.SetActive(true);
			_hostPanel.SetActive(false);
			_joinPanel.SetActive(false);
			_lobbyPanel.SetActive(false);
			GameObject friendListPanel = _friendListPanel;
			if (friendListPanel != null)
			{
				friendListPanel.SetActive(false);
			}
			GameObject continuePanel = _continuePanel;
			if (continuePanel != null)
			{
				continuePanel.SetActive(false);
			}
		}

		private void ShowLobby()
		{
			_mainPanel.SetActive(false);
			_hostPanel.SetActive(false);
			_joinPanel.SetActive(false);
			_lobbyPanel.SetActive(true);
			GameObject friendListPanel = _friendListPanel;
			if (friendListPanel != null)
			{
				friendListPanel.SetActive(false);
			}
			GameObject continuePanel = _continuePanel;
			if (continuePanel != null)
			{
				continuePanel.SetActive(false);
			}
			GameObject waitingPanel = _waitingPanel;
			if (waitingPanel != null)
			{
				waitingPanel.SetActive(false);
			}
			UpdateLobbyPanel();
		}

		private void ShowOverlay()
		{
			_overlayVisible = true;
			if (_multiplayerMode.IsSpectating && _transport.IsConnected && LobbyUI.GameStartReceived)
			{
				ShowMultiplayerView();
				return;
			}
			_overlayPanel.SetActive(true);
			if ((_multiplayerMode.IsHosting || _multiplayerMode.IsSpectating) && _transport.IsConnected)
			{
				ShowLobby();
			}
			else if (_multiplayerMode.IsHosting)
			{
				ShowLobby();
			}
			else
			{
				ShowMainPanel();
			}
		}

		private void HideOverlay()
		{
			_overlayVisible = false;
			_overlayPanel.SetActive(false);
		}

		private void ToggleOverlay()
		{
			if (_overlayVisible)
			{
				HideOverlay();
			}
			else
			{
				ShowOverlay();
			}
		}

		public static void ToggleOverlayStatic()
		{
			try
			{
				if ((Object)(object)_instance != (Object)null)
				{
					_instance.ToggleOverlay();
					return;
				}
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)"MultiplayerUI: instance is null, cannot toggle overlay");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogError((object)$"MultiplayerUI.ToggleOverlay crashed: {arg}");
				}
			}
		}

		private void ShowJoinPanel()
		{
			_mainPanel.SetActive(false);
			_hostPanel.SetActive(false);
			_joinPanel.SetActive(true);
			_lobbyPanel.SetActive(false);
			GameObject friendListPanel = _friendListPanel;
			if (friendListPanel != null)
			{
				friendListPanel.SetActive(false);
			}
			GameObject continuePanel = _continuePanel;
			if (continuePanel != null)
			{
				continuePanel.SetActive(false);
			}
			((TMP_Text)_statusText).text = _lastConnectionStatus;
		}

		private void ShowContinuePanel()
		{
			_mainPanel.SetActive(false);
			_hostPanel.SetActive(false);
			_joinPanel.SetActive(false);
			_lobbyPanel.SetActive(false);
			GameObject friendListPanel = _friendListPanel;
			if (friendListPanel != null)
			{
				friendListPanel.SetActive(false);
			}
			GameObject continuePanel = _continuePanel;
			if (continuePanel != null)
			{
				continuePanel.SetActive(true);
			}
			RefreshContinueList();
		}

		private void OnContinueClicked()
		{
			ShowContinuePanel();
		}

		private void CreateContinuePanel(Transform parent)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0052: 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_0093: 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_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Expected O, but got Unknown
			//IL_011d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0147: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_021a: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0285: Unknown result type (might be due to invalid IL or missing references)
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_02aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Expected O, but got Unknown
			_continuePanel = new GameObject("ContinuePanel");
			_continuePanel.transform.SetParent(parent, false);
			StretchFill(_continuePanel.AddComponent<RectTransform>());
			TextMeshProUGUI obj = CreateText(_continuePanel.transform, "ContinueHeader", "Continue Run", 36f);
			((Graphic)obj).color = Color.white;
			((Graphic)obj).raycastTarget = false;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			RectTransform rectTransform = ((TMP_Text)obj).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 1f);
			rectTransform.anchorMax = new Vector2(0.5f, 1f);
			rectTransform.pivot = new Vector2(0.5f, 1f);
			rectTransform.anchoredPosition = new Vector2(0f, -100f);
			rectTransform.sizeDelta = new Vector2(800f, 50f);
			_continueListContent = new GameObject("ContinueListContent");
			_continueListContent.transform.SetParent(_continuePanel.transform, false);
			RectTransform obj2 = _continueListContent.AddComponent<RectTransform>();
			obj2.anchorMin = new Vector2(0.5f, 1f);
			obj2.anchorMax = new Vector2(0.5f, 1f);
			obj2.pivot = new Vector2(0.5f, 1f);
			obj2.anchoredPosition = new Vector2(0f, -160f);
			obj2.sizeDelta = new Vector2(820f, 600f);
			_continueStatusText = CreateText(_continuePanel.transform, "ContinueStatus", string.Empty, 22f);
			((Graphic)_continueStatusText).color = new Color(0.85f, 0.85f, 0.85f);
			((Graphic)_continueStatusText).raycastTarget = false;
			((TMP_Text)_continueStatusText).alignment = (TextAlignmentOptions)514;
			RectTransform rectTransform2 = ((TMP_Text)_continueStatusText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform2.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform2.pivot = new Vector2(0.5f, 0.5f);
			rectTransform2.anchoredPosition = new Vector2(0f, -240f);
			rectTransform2.sizeDelta = new Vector2(800f, 40f);
			((UnityEvent)CreateButton(_continuePanel.transform, "ContinueBackBtn", "Back", new Color(0.35f, 0.2f, 0.2f, 1f), new Vector2(0f, -340f), new Vector2(360f, 56f)).onClick).AddListener(new UnityAction(OnContinueBackClicked));
			_continuePanel.SetActive(false);
		}

		private void OnContinueBackClicked()
		{
			ContinueSession.Clear();
			ShowMainPanel();
		}

		private void RefreshContinueList()
		{
			if ((Object)(object)_continueListContent == (Object)null)
			{
				return;
			}
			for (int num = _continueListContent.transform.childCount - 1; num >= 0; num--)
			{
				Object.Destroy((Object)(object)((Component)_continueListContent.transform.GetChild(num)).gameObject);
			}
			IReadOnlyList<ContinueSaveEntry> readOnlyList = ContinueFiles.ListUsableSaves(5, "0.1.10", Application.version ?? string.Empty, LocalPlayerName);
			if (readOnlyList.Count == 0)
			{
				((TMP_Text)_continueStatusText).text = "No saved coop runs found.";
				return;
			}
			((TMP_Text)_continueStatusText).text = string.Format("{0} save{1} available.", readOnlyList.Count, (readOnlyList.Count == 1) ? string.Empty : "s");
			for (int i = 0; i < readOnlyList.Count; i++)
			{
				ContinueSaveEntry entry = readOnlyList[i];
				CreateContinueRow(_continueListContent.transform, entry, i, 96f, 8f);
			}
		}

		private void CreateContinueRow(Transform parent, ContinueSaveEntry entry, int index, float rowHeight, float rowGap)
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_008a: 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_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0152: Unknown result type (might be due to invalid IL or missing references)
			//IL_015c: Expected O, but got Unknown
			//IL_015c: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0261: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"ContinueRow_{index}");
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.5f, 1f);
			obj.anchorMax = new Vector2(0.5f, 1f);
			obj.pivot = new Vector2(0.5f, 1f);
			obj.anchoredPosition = new Vector2(0f, (float)(-index) * (rowHeight + rowGap));
			obj.sizeDelta = new Vector2(820f, rowHeight);
			Image val2 = val.AddComponent<Image>();
			((Graphic)val2).color = new Color(0.18f, 0.18f, 0.22f, 1f);
			Button obj2 = val.AddComponent<Button>();
			ColorBlock colors = ((Selectable)obj2).colors;
			((ColorBlock)(ref colors)).normalColor = new Color(0.18f, 0.18f, 0.22f, 1f);
			((ColorBlock)(ref colors)).highlightedColor = new Color(0.28f, 0.28f, 0.36f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.12f, 0.12f, 0.18f, 1f);
			((Selectable)obj2).colors = colors;
			((Selectable)obj2).targetGraphic = (Graphic)(object)val2;
			((UnityEvent)obj2.onClick).AddListener((UnityAction)delegate
			{
				OnContinueSaveSelected(entry);
			});
			TextMeshProUGUI obj3 = CreateText(val.transform, "Names", entry.DisplayPlayerNames, 26f);
			((Graphic)obj3).color = Color.white;
			((Graphic)obj3).raycastTarget = false;
			((TMP_Text)obj3).alignment = (TextAlignmentOptions)4097;
			RectTransform rectTransform = ((TMP_Text)obj3).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 0.5f);
			rectTransform.anchorMax = new Vector2(1f, 0.5f);
			rectTransform.pivot = new Vector2(0f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(20f, 18f);
			rectTransform.sizeDelta = new Vector2(-40f, 36f);
			TextMeshProUGUI obj4 = CreateText(val.transform, "Stage", entry.DisplayStageLabel, 20f);
			((Graphic)obj4).color = new Color(0.75f, 0.85f, 0.95f);
			((Graphic)obj4).raycastTarget = false;
			((TMP_Text)obj4).alignment = (TextAlignmentOptions)4097;
			RectTransform rectTransform2 = ((TMP_Text)obj4).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 0.5f);
			rectTransform2.anchorMax = new Vector2(1f, 0.5f);
			rectTransform2.pivot = new Vector2(0f, 0.5f);
			rectTransform2.anchoredPosition = new Vector2(20f, -18f);
			rectTransform2.sizeDelta = new Vector2(-40f, 30f);
		}

		private void OnContinueSaveSelected(ContinueSaveEntry entry)
		{
			try
			{
				if (entry?.Data == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[ContinueUI] selected entry has no data");
					}
					return;
				}
				ContinueSession.Begin(entry.Data, entry.FilePath);
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[ContinueUI] Continue armed: {entry.FileName} (expecting {ContinueSession.ExpectedPlayerCount} players)");
				}
				if (_steamTransport != null)
				{
					OnHostSteamClicked();
				}
				else
				{
					OnHostClicked();
				}
			}
			catch (Exception arg)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogError((object)$"[ContinueUI] OnContinueSaveSelected failed: {arg}");
				}
			}
		}

		private void ShowHostingState()
		{
			ShowLobby();
		}

		private static void LockHostClassFromContinue(PlayerSlot hostSlot)
		{
			if (hostSlot != null && ContinueSession.IsActive)
			{
				int num = (hostSlot.ChosenClass = ContinueSession.GetClassForPlayer(hostSlot.PlayerName));
				LobbyUI.SetLocalChosenClass(num);
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[Lobby] Continue: locked host '{hostSlot.PlayerName}' to saved class {num}");
				}
			}
		}

		private void OnHostClicked()
		{
			try
			{
				_router?.UseLite();
				_multiplayerMode.EnableHosting();
				_transport.StartHost(7777);
				FileLogger.RoleTag = "HOST";
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<PlayerRegistry>(out var instance))
				{
					LockHostClassFromContinue(instance.RegisterHost(LocalPlayerName, Application.version ?? "unknown", "0.1.10"));
				}
				Log.LogInfo((object)$"Started hosting on port {7777}");
				ShowLobby();
			}
			catch (Exception ex)
			{
				Log.LogError((object)$"Failed to start hosting: {ex}");
				_lastConnectionStatus = "Error: " + ex.Message;
				ShowMainPanel();
			}
		}

		private void OnHostSteamClicked()
		{
			if (_steamTransport == null || _router == null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"Host (Steam) clicked but Steam transport unavailable");
				}
				return;
			}
			try
			{
				_router.UseSteam();
				_multiplayerMode.EnableHosting();
				_steamTransport.StartHost(0);
				FileLogger.RoleTag = "HOST";
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<PlayerRegistry>(out var instance))
				{
					LockHostClassFromContinue(instance.RegisterHost(LocalPlayerName, Application.version ?? "unknown", "0.1.10"));
				}
				Log.LogInfo((object)"Started Steam lobby hosting");
				ShowLobby();
			}
			catch (Exception ex)
			{
				Log.LogError((object)$"Failed to start Steam hosting: {ex}");
				_lastConnectionStatus = "Error: " + ex.Message;
				ShowMainPanel();
			}
		}

		private void OnJoinFriendClicked()
		{
			if (_steamTransport == null)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"Join Friend clicked but Steam transport unavailable");
				}
			}
			else
			{
				ShowFriendListPanel();
			}
		}

		private void OnSteamInviteReceived(CSteamID lobbyId)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			MainThreadDispatcher instance = MainThreadDispatcher.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.Enqueue(delegate
				{
					//IL_0007: Unknown result type (might be due to invalid IL or missing references)
					PromptAcceptInvite(lobbyId);
				});
			}
			else
			{
				PromptAcceptInvite(lobbyId);
			}
		}

		private void PromptAcceptInvite(CSteamID lobbyId)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			if (_multiplayerMode.IsHosting || _multiplayerMode.IsSpectating || _transport.IsConnected)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"[Steam] Ignoring incoming invite {lobbyId.m_SteamID}: already in session");
				}
				return;
			}
			string text = "A friend";
			try
			{
				CSteamID lobbyOwner = SteamMatchmaking.GetLobbyOwner(lobbyId);
				if (((CSteamID)(ref lobbyOwner)).IsValid())
				{
					string friendPersonaName = SteamFriends.GetFriendPersonaName(lobbyOwner);
					if (!string.IsNullOrEmpty(friendPersonaName))
					{
						text = friendPersonaName;
					}
				}
			}
			catch
			{
			}
			ShowConfirmDialog(text + " invited you to a Multipeglin lobby.\nJoin them?", delegate
			{
				//IL_0007: Unknown result type (might be due to invalid IL or missing references)
				AcceptSteamInvite(lobbyId);
			}, delegate
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)$"[Steam] Declined invite to {lobbyId.m_SteamID}");
				}
			});
		}

		private void AcceptSteamInvite(CSteamID lobbyId)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_router?.UseSteam();
				_multiplayerMode.EnableSpectating();
				FileLogger.RoleTag = "CLIENT";
				if (_multiplayerMode is MultiplayerMode multiplayerMode)
				{
					multiplayerMode.ClientMode = ClientMode.Mirror;
				}
				_steamTransport?.JoinSteamLobby(lobbyId);
				_overlayPanel.SetActive(true);
				ShowLobby();
				Log.LogInfo((object)$"[Steam] Accepted invite, joining lobby {lobbyId.m_SteamID}");
			}
			catch (Exception arg)
			{
				Log.LogError((object)$"AcceptSteamInvite failed: {arg}");
			}
		}

		private void OnJoinClicked()
		{
			_lastConnectionStatus = string.Empty;
			ShowJoinPanel();
		}

		private void OnConnectClicked()
		{
			string text = _codeInput.text.Trim();
			if (string.IsNullOrEmpty(text))
			{
				((TMP_Text)_statusText).text = "Please enter a host code.";
				return;
			}
			if (!TryParseHostCode(text, out var ip, out var port))
			{
				((TMP_Text)_statusText).text = "Invalid format. Use IP:PORT";
				return;
			}
			try
			{
				((TMP_Text)_statusText).text = $"Connecting to {ip}:{port}...";
				_router?.UseLite();
				_multiplayerMode.EnableSpectating();
				FileLogger.RoleTag = "CLIENT";
				if (_multiplayerMode is MultiplayerMode multiplayerMode)
				{
					multiplayerMode.ClientMode = ClientMode.Mirror;
				}
				_transport.Connect(ip, port);
				Log.LogInfo((object)$"Connecting to {ip}:{port}");
			}
			catch (Exception ex)
			{
				((TMP_Text)_statusText).text = "Error: " + ex.Message;
				_lastConnectionStatus = ((TMP_Text)_statusText).text;
				Log.LogError((object)$"Failed to connect: {ex}");
			}
		}

		private void OnCancelJoinClicked()
		{
			ShowMainPanel();
		}

		private void OnConnected()
		{
			_lastConnectionStatus = "Connected!";
			_overlayPanel.SetActive(true);
			ShowLobby();
			Log.LogInfo((object)"Connected — showing lobby");
		}

		private void OnDisconnected(int peerId)
		{
			if (_multiplayerMode != null && _multiplayerMode.IsHosting && !LobbyUI.GameStartReceived)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"[Lobby] Client peer {peerId} disconnected during lobby — keeping lobby open");
				}
				MainThreadDispatcher instance = MainThreadDispatcher.Instance;
				Action action = delegate
				{
					try
					{
						IServiceContainer services = MultiplayerPlugin.Services;
						if (services != null && services.TryResolve<PlayerRegistry>(out var instance3) && services.TryResolve<IGameEventRegistry>(out var instance4))
						{
							LobbyHelper.BroadcastLobbyState(instance3, instance4);
						}
					}
					catch (Exception ex)
					{
						ManualLogSource log3 = Log;
						if (log3 != null)
						{
							log3.LogWarning((object)("[Lobby] Rebroadcast after disconnect failed: " + ex.Message));
						}
					}
				};
				if ((Object)(object)instance != (Object)null)
				{
					instance.Enqueue(action);
				}
				else
				{
					action();
				}
			}
			else
			{
				_lastConnectionStatus = "Disconnected";
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)"Transport disconnected — scheduling full reset");
				}
				MainThreadDispatcher instance2 = MainThreadDispatcher.Instance;
				if ((Object)(object)instance2 != (Object)null)
				{
					instance2.Enqueue(HandleDisconnectReset);
				}
				else
				{
					HandleDisconnectReset();
				}
			}
		}

		private void HandleDisconnectReset()
		{
			MultiplayerSession.DisconnectAndReset("Transport disconnected");
			GameObject multiplayerPanel = _multiplayerPanel;
			if (multiplayerPanel != null)
			{
				multiplayerPanel.SetActive(false);
			}
			GameObject waitingPanel = _waitingPanel;
			if (waitingPanel != null)
			{
				waitingPanel.SetActive(false);
			}
			GameObject turnIndicatorPanel = _turnIndicatorPanel;
			if (turnIndicatorPanel != null)
			{
				turnIndicatorPanel.SetActive(false);
			}
			GameObject overlayPanel = _overlayPanel;
			if (overlayPanel != null)
			{
				overlayPanel.SetActive(true);
			}
			ShowMainPanel();
		}

		private void OnConnectionRejected(string reason)
		{
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogWarning((object)("Connection rejected (reason=" + reason + "). Local version: 0.1.10"));
			}
			MainThreadDispatcher instance = MainThreadDispatcher.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.Enqueue(delegate
				{
					HandleConnectionRejected(reason);
				});
			}
			else
			{
				HandleConnectionRejected(reason);
			}
		}

		private void HandleConnectionRejected(string reason)
		{
			_transport.Stop();
			_multiplayerMode.Disable();
			FileLogger.RoleTag = null;
			if (reason == "full")
			{
				ShowErrorDialog("Game is at the maximum number of players,\nunable to join.");
			}
			else
			{
				ShowErrorDialog("Failed to connect to host.\nYour version: 0.1.10\n\nMake sure you and the host have the\nsame version of Multipeglin installed.");
			}
		}

		private void ShowErrorDialog(string message)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Expected O, but got Unknown
			//IL_0064: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: 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_0127: 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_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0177: Unknown result type (might be due to invalid IL or missing references)
			//IL_0186: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a6: Expected O, but got Unknown
			if ((Object)(object)_errorPanel != (Object)null)
			{
				Object.Destroy((Object)(object)_errorPanel);
			}
			_errorPanel = new GameObject("ErrorPanel");
			_errorPanel.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_errorPanel.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.9f);
			StretchFill(_errorPanel.GetComponent<RectTransform>());
			GameObject obj = CreatePanel(_errorPanel.transform, "ErrorBox", new Color(0.15f, 0.1f, 0.1f, 1f), new Vector2(700f, 280f));
			TextMeshProUGUI obj2 = CreateText(obj.transform, "ErrorMessage", message, 26f);
			((TMP_Text)obj2).enableWordWrapping = true;
			RectTransform rectTransform = ((TMP_Text)obj2).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(0f, 30f);
			rectTransform.sizeDelta = new Vector2(620f, 160f);
			((UnityEvent)CreateButton(obj.transform, "OkBtn", "Ok", new Color(0.3f, 0.3f, 0.5f, 1f), new Vector2(0f, -100f), new Vector2(200f, 56f)).onClick).AddListener((UnityAction)delegate
			{
				Object.Destroy((Object)(object)_errorPanel);
				_errorPanel = null;
			});
		}

		private void ShowConfirmDialog(string message, Action onAccept, Action onDecline)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Expected O, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a2: 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_01c2: Expected O, but got Unknown
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0219: Unknown result type (might be due to invalid IL or missing references)
			//IL_0223: Expected O, but got Unknown
			if ((Object)(object)_errorPanel != (Object)null)
			{
				Object.Destroy((Object)(object)_errorPanel);
			}
			_errorPanel = new GameObject("ConfirmPanel");
			_errorPanel.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_errorPanel.AddComponent<Image>()).color = new Color(0f, 0f, 0f, 0.9f);
			StretchFill(_errorPanel.GetComponent<RectTransform>());
			GameObject obj = CreatePanel(_errorPanel.transform, "ConfirmBox", new Color(0.1f, 0.15f, 0.2f, 1f), new Vector2(700f, 280f));
			TextMeshProUGUI obj2 = CreateText(obj.transform, "ConfirmMessage", message, 26f);
			((TMP_Text)obj2).enableWordWrapping = true;
			RectTransform rectTransform = ((TMP_Text)obj2).rectTransform;
			rectTransform.anchorMin = new Vector2(0.5f, 0.5f);
			rectTransform.anchorMax = new Vector2(0.5f, 0.5f);
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			rectTransform.anchoredPosition = new Vector2(0f, 30f);
			rectTransform.sizeDelta = new Vector2(620f, 160f);
			((UnityEvent)CreateButton(obj.transform, "AcceptBtn", "Join", new Color(0.2f, 0.5f, 0.3f, 1f), new Vector2(-110f, -100f), new Vector2(200f, 56f)).onClick).AddListener((UnityAction)delegate
			{
				Object.Destroy((Object)(object)_errorPanel);
				_errorPanel = null;
				try
				{
					onAccept?.Invoke();
				}
				catch (Exception arg2)
				{
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogError((object)$"ConfirmDialog onAccept threw: {arg2}");
					}
				}
			});
			((UnityEvent)CreateButton(obj.transform, "DeclineBtn", "Decline", new Color(0.5f, 0.2f, 0.2f, 1f), new Vector2(110f, -100f), new Vector2(200f, 56f)).onClick).AddListener((UnityAction)delegate
			{
				Object.Destroy((Object)(object)_errorPanel);
				_errorPanel = null;
				try
				{
					onDecline?.Invoke();
				}
				catch (Exception arg)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogError((object)$"ConfirmDialog onDecline threw: {arg}");
					}
				}
			});
		}

		private static string GetLocalIP()
		{
			try
			{
				return Dns.GetHostEntry(Dns.GetHostName()).AddressList.FirstOrDefault((IPAddress a) => a.AddressFamily == AddressFamily.InterNetwork)?.ToString() ?? "127.0.0.1";
			}
			catch
			{
				return "127.0.0.1";
			}
		}

		private static bool TryParseHostCode(string code, out string ip, out int port)
		{
			ip = null;
			port = 0;
			int num = code.LastIndexOf(':');
			if (num < 0)
			{
				ip = code;
				port = 7777;
				return !string.IsNullOrWhiteSpace(ip);
			}
			ip = code.Substring(0, num);
			string s = code.Substring(num + 1);
			if (!string.IsNullOrWhiteSpace(ip) && int.TryParse(s, out port) && port > 0)
			{
				return port <= 65535;
			}
			return false;
		}

		private static TextMeshProUGUI CreateText(Transform parent, string name, string text, float fontSize)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			TextMeshProUGUI obj = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj).text = text;
			((TMP_Text)obj).fontSize = fontSize;
			((TMP_Text)obj).alignment = (TextAlignmentOptions)514;
			((Graphic)obj).color = Color.white;
			((TMP_Text)obj).richText = true;
			return obj;
		}

		private static Button CreateButton(Transform parent, string name, string label, Color bgColor, Vector2 position, Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = bgColor;
			Button obj = val.AddComponent<Button>();
			ColorBlock colors = ((Selectable)obj).colors;
			((ColorBlock)(ref colors)).highlightedColor = new Color(Mathf.Min(bgColor.r + 0.15f, 1f), Mathf.Min(bgColor.g + 0.15f, 1f), Mathf.Min(bgColor.b + 0.15f, 1f), 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(bgColor.r * 0.7f, bgColor.g * 0.7f, bgColor.b * 0.7f, 1f);
			((Selectable)obj).colors = colors;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = size;
			StretchFill(((TMP_Text)CreateText(val.transform, "Label", label, 35f)).rectTransform);
			return obj;
		}

		private static TMP_InputField CreateInputField(Transform parent, string name, string placeholder, Vector2 position, Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_007e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0114: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = new Color(0.15f, 0.15f, 0.15f, 1f);
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = position;
			component.sizeDelta = size;
			GameObject val2 = new GameObject("TextArea");
			val2.transform.SetParent(val.transform, false);
			RectTransform val3 = val2.AddComponent<RectTransform>();
			StretchFill(val3);
			val3.offsetMin = new Vector2(10f, 5f);
			val3.offsetMax = new Vector2(-10f, -5f);
			val2.AddComponent<RectMask2D>();
			GameObject val4 = new GameObject("Text");
			val4.transform.SetParent(val2.transform, false);
			TextMeshProUGUI val5 = val4.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val5).fontSize = 32f;
			((Graphic)val5).color = Color.white;
			((TMP_Text)val5).alignment = (TextAlignmentOptions)4097;
			StretchFill(((TMP_Text)val5).rectTransform);
			GameObject val6 = new GameObject("Placeholder");
			val6.transform.SetParent(val2.transform, false);
			TextMeshProUGUI val7 = val6.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val7).text = placeholder;
			((TMP_Text)val7).fontSize = 32f;
			((Graphic)val7).color = new Color(0.5f, 0.5f, 0.5f, 0.8f);
			((TMP_Text)val7).fontStyle = (FontStyles)2;
			((TMP_Text)val7).alignment = (TextAlignmentOptions)4097;
			StretchFill(((TMP_Text)val7).rectTransform);
			TMP_InputField obj = val.AddComponent<TMP_InputField>();
			obj.textViewport = val3;
			obj.textComponent = (TMP_Text)(object)val5;
			obj.placeholder = (Graphic)(object)val7;
			obj.fontAsset = ((TMP_Text)val5).font;
			obj.pointSize = 32f;
			obj.characterLimit = 50;
			return obj;
		}

		private static GameObject CreatePanel(Transform parent, string name, Color color, Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: 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_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			((Graphic)val.AddComponent<Image>()).color = color;
			RectTransform component = val.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.5f, 0.5f);
			component.anchorMax = new Vector2(0.5f, 0.5f);
			component.pivot = new Vector2(0.5f, 0.5f);
			component.anchoredPosition = Vector2.zero;
			component.sizeDelta = size;
			return val;
		}

		private static Toggle CreateToggle(Transform parent, string name, string label, Vector2 position, Vector2 size)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Expected O, but got Unknown
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Expected O, but got Unknown
			//IL_00a0: 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_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_011d: 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_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_0150: 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_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_0194: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_021e: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject(name);
			val.transform.SetParent(parent, false);
			RectTransform obj = val.AddComponent<RectTransform>();
			obj.anchorMin = new Vector2(0.5f, 0.5f);
			obj.anchorMax = new Vector2(0.5f, 0.5f);
			obj.pivot = new Vector2(0.5f, 0.5f);
			obj.anchoredPosition = position;
			obj.sizeDelta = size;
			GameObject val2 = new GameObject("Background");
			val2.transform.SetParent(val.transform, false);
			Image val3 = val2.AddComponent<Image>();
			((Graphic)val3).color = new Color(0.2f, 0.2f, 0.2f, 1f);
			RectTransform component = val2.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0.5f);
			component.anchorMax = new Vector2(0f, 0.5f);
			component.pivot = new Vector2(0f, 0.5f);
			component.anchoredPosition = new Vector2(0f, 0f);
			component.sizeDelta = new Vector2(32f, 32f);
			GameObject val4 = new GameObject("Checkmark");
			val4.transform.SetParent(val2.transform, false);
			Image val5 = val4.AddComponent<Image>();
			((Graphic)val5).color = new Color(0.3f, 0.8f, 0.3f, 1f);
			RectTransform component2 = val4.GetComponent<RectTransform>();
			component2.anchorMin = new Vector2(0.15f, 0.15f);
			component2.anchorMax = new Vector2(0.85f, 0.85f);
			component2.offsetMin = Vector2.zero;
			component2.offsetMax = Vector2.zero;
			Toggle obj2 = val.AddComponent<Toggle>();
			((Selectable)obj2).targetGraphic = (Graphic)(object)val3;
			obj2.graphic = (Graphic)(object)val5;
			obj2.isOn = false;
			TextMeshProUGUI obj3 = CreateText(val.transform, "Label", label, 22f);
			((TMP_Text)obj3).alignment = (TextAlignmentOptions)4097;
			RectTransform rectTransform = ((TMP_Text)obj3).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 0f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.offsetMin = new Vector2(42f, 0f);
			rectTransform.offsetMax = Vector2.zero;
			return obj2;
		}

		private static void StretchFill(RectTransform rect)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			rect.anchorMin = Vector2.zero;
			rect.anchorMax = Vector2.one;
			rect.offsetMin = Vector2.zero;
			rect.offsetMax = Vector2.zero;
		}
	}
	public sealed class PendingDamageOverlay : MonoBehaviour
	{
		private class PlayerDamageInfo
		{
			public string PlayerName;

			public long Damage;

			public string TargetEnemyGuid;

			public bool IsAoE;
		}

		private class EnemyPanel
		{
			public GameObject Root;

			public TextMeshProUGUI Label;
		}

		private static PendingDamageOverlay _instance;

		private GameObject _canvasObj;

		private Canvas _canvas;

		private RectTransform _canvasRect;

		private readonly Dictionary<int, PlayerDamageInfo> _playerData = new Dictionary<int, PlayerDamageInfo>();

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

		private static TMP_FontAsset _gameFont;

		private static bool _gameFontSearched;

		public static PendingDamageOverlay Instance => _instance;

		private void Awake()
		{
			_instance = this;
		}

		private void OnDestroy()
		{
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
			DestroyCanvas();
		}

		private void LateUpdate()
		{
			if (_panels.Count != 0)
			{
				RepositionPanels();
			}
		}

		public static void SetPlayerDamage(int slotIndex, string playerName, long damage, string targetEnemyGuid, bool isAoE)
		{
			if (!((Object)(object)_instance == (Object)null))
			{
				_instance.SetPlayerDamageInternal(slotIndex, playerName, damage, targetEnemyGuid, isAoE);
			}
		}

		public static void ClearAll()
		{
			if (!((Object)(object)_instance == (Object)null))
			{
				_instance.ClearAllInternal();
			}
		}

		private void SetPlayerDamageInternal(int slotIndex, string playerName, long damage, string targetGuid, bool isAoE)
		{
			_playerData[slotIndex] = new PlayerDamageInfo
			{
				PlayerName = playerName,
				Damage = damage,
				TargetEnemyGuid = targetGuid,
				IsAoE = isAoE
			};
			RebuildPanels();
		}

		private void ClearAllInternal()
		{
			_playerData.Clear();
			foreach (EnemyPanel value in _panels.Values)
			{
				if ((Object)(object)value.Root != (Object)null)
				{
					Object.Destroy((Object)(object)value.Root);
				}
			}
			_panels.Clear();
		}

		private void RebuildPanels()
		{
			//IL_0248: Unknown result type (might be due to invalid IL or missing references)
			//IL_0252: Expected O, but got Unknown
			//IL_0288: Unknown result type (might be due to invalid IL or missing references)
			//IL_029c: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0319: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			EnsureCanvas();
			Dictionary<string, long> dictionary = new Dictionary<string, long>();
			EnemyIdentifier instance = null;
			EnemyManager val = null;
			try
			{
				MultiplayerPlugin.Services?.TryResolve<EnemyIdentifier>(out instance);
				val = Object.FindObjectOfType<EnemyManager>();
			}
			catch
			{
			}
			foreach (KeyValuePair<int, PlayerDamageInfo> playerDatum in _playerData)
			{
				PlayerDamageInfo value = playerDatum.Value;
				if (value.Damage <= 0)
				{
					continue;
				}
				if (value.IsAoE && (Object)(object)val != (Object)null && instance != null)
				{
					foreach (Enemy enemy in val.Enemies)
					{
						if (!((Object)(object)enemy == (Object)null) && !(enemy.CurrentHealth <= 0f))
						{
							string guid = instance.GetGuid(enemy);
							if (!string.IsNullOrEmpty(guid))
							{
								dictionary.TryGetValue(guid, out var value2);
								dictionary[guid] = value2 + value.Damage;
							}
						}
					}
				}
				else if (!string.IsNullOrEmpty(value.TargetEnemyGuid))
				{
					string targetEnemyGuid = value.TargetEnemyGuid;
					dictionary.TryGetValue(targetEnemyGuid, out var value3);
					dictionary[targetEnemyGuid] = value3 + value.Damage;
				}
			}
			List<string> list = new List<string>();
			foreach (string key2 in _panels.Keys)
			{
				if (!dictionary.ContainsKey(key2))
				{
					list.Add(key2);
				}
			}
			foreach (string item in list)
			{
				if ((Object)(object)_panels[item].Root != (Object)null)
				{
					Object.Destroy((Object)(object)_panels[item].Root);
				}
				_panels.Remove(item);
			}
			foreach (KeyValuePair<string, long> item2 in dictionary)
			{
				string key = item2.Key;
				long value4 = item2.Value;
				if (!_panels.TryGetValue(key, out var value5))
				{
					value5 = new EnemyPanel
					{
						Root = new GameObject("PendingDmg_" + key)
					};
					value5.Root.transform.SetParent(_canvasObj.transform, false);
					RectTransform obj2 = value5.Root.AddComponent<RectTransform>();
					obj2.sizeDelta = new Vector2(50f, 22f);
					obj2.pivot = new Vector2(0.5f, 1f);
					GameObject val2 = new GameObject("BG");
					val2.transform.SetParent(value5.Root.transform, false);
					Image obj3 = val2.AddComponent<Image>();
					((Graphic)obj3).color = new Color(0f, 0f, 0f, 0.75f);
					((Graphic)obj3).raycastTarget = false;
					RectTransform rectTransform = ((Graphic)obj3).rectTransform;
					rectTransform.anchorMin = Vector2.zero;
					rectTransform.anchorMax = Vector2.one;
					rectTransform.offsetMin = new Vector2(-4f, 3f);
					rectTransform.offsetMax = new Vector2(4f, 7f);
					value5.Label = CreateLabel(value5.Root.transform);
					_panels[key] = value5;
				}
				((TMP_Text)value5.Label).text = "-" + DamageCountDisplay.FormatDamageNumberAsString(value4);
			}
		}

		private void RepositionPanels()
		{
			//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null)
			{
				return;
			}
			EnemyIdentifier instance = null;
			try
			{
				MultiplayerPlugin.Services?.TryResolve<EnemyIdentifier>(out instance);
			}
			catch
			{
			}
			if (instance == null)
			{
				return;
			}
			Vector2 val4 = default(Vector2);
			foreach (KeyValuePair<string, EnemyPanel> panel in _panels)
			{
				EnemyPanel value = panel.Value;
				if ((Object)(object)value.Root == (Object)null)
				{
					continue;
				}
				Enemy val = instance.Find(panel.Key);
				if ((Object)(object)val == (Object)null || val.CurrentHealth <= 0f)
				{
					value.Root.SetActive(false);
					continue;
				}
				Vector3 val2 = ((Component)val).transform.position + new Vector3(0.6f, 2.55f, 0f);
				Vector3 val3 = main.WorldToScreenPoint(val2);
				if (val3.z < 0f)
				{
					value.Root.SetActive(false);
					continue;
				}
				if (!value.Root.activeSelf)
				{
					value.Root.SetActive(true);
				}
				RectTransform component = value.Root.GetComponent<RectTransform>();
				if ((Object)(object)component != (Object)null && (Object)(object)_canvasRect != (Object)null)
				{
					RectTransformUtility.ScreenPointToLocalPointInRectangle(_canvasRect, Vector2.op_Implicit(val3), (Camera)null, ref val4);
					((Transform)component).localPosition = Vector2.op_Implicit(val4);
				}
			}
		}

		private void EnsureCanvas()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected O, but got Unknown
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			if (!((Object)(object)_canvasObj != (Object)null))
			{
				_canvasObj = new GameObject("PendingDamageOverlayCanvas");
				Object.DontDestroyOnLoad((Object)(object)_canvasObj);
				_canvas = _canvasObj.AddComponent<Canvas>();
				_canvas.renderMode = (RenderMode)0;
				_canvas.sortingOrder = 9500;
				CanvasScaler obj = _canvasObj.AddComponent<CanvasScaler>();
				obj.uiScaleMode = (ScaleMode)1;
				obj.referenceResolution = new Vector2(1920f, 1080f);
				obj.matchWidthOrHeight = 0.5f;
				_canvasRect = _canvasObj.GetComponent<RectTransform>();
			}
		}

		private TextMeshProUGUI CreateLabel(Transform parent)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("Label_Damage");
			val.transform.SetParent(parent, false);
			TextMeshProUGUI val2 = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)val2).fontSize = 35f;
			((TMP_Text)val2).fontStyle = (FontStyles)1;
			((TMP_Text)val2).alignment = (TextAlignmentOptions)514;
			((Graphic)val2).color = new Color(1f, 0.2f, 0.2f);
			((TMP_Text)val2).outlineWidth = 0.2f;
			((TMP_Text)val2).outlineColor = Color32.op_Implicit(Color.black);
			((TMP_Text)val2).enableWordWrapping = false;
			((TMP_Text)val2).overflowMode = (TextOverflowModes)0;
			((Graphic)val2).raycastTarget = false;
			TMP_FontAsset gameFont = GetGameFont();
			if ((Object)(object)gameFont != (Object)null)
			{
				((TMP_Text)val2).font = gameFont;
			}
			RectTransform rectTransform = ((TMP_Text)val2).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
			rectTransform.pivot = new Vector2(0.5f, 0.5f);
			return val2;
		}

		private static TMP_FontAsset GetGameFont()
		{
			if (_gameFontSearched)
			{
				return _gameFont;
			}
			_gameFontSearched = true;
			try
			{
				TextMeshProUGUI[] array = Object.FindObjectsOfType<TextMeshProUGUI>();
				foreach (TextMeshProUGUI val in array)
				{
					if ((Object)(object)((TMP_Text)val).font != (Object)null)
					{
						_gameFont = ((TMP_Text)val).font;
						break;
					}
				}
			}
			catch
			{
			}
			return _gameFont;
		}

		private void DestroyCanvas()
		{
			ClearAllInternal();
			if ((Object)(object)_canvasObj != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObj);
			}
			_canvasObj = null;
			_canvas = null;
			_canvasRect = null;
		}
	}
	public sealed class SkipTurnButton : MonoBehaviour
	{
		private GameObject _canvasObj;

		private Canvas _canvas;

		private GameObject _buttonObj;

		private Button _button;

		private TMP_FontAsset _font;

		private void Start()
		{
			TryEnsureFont();
		}

		private void OnDestroy()
		{
			if ((Object)(object)_canvasObj != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObj);
			}
		}

		private void Update()
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Invalid comparison between Unknown and I4
			if (MultiplayerPlugin.Services == null)
			{
				SetVisible(visible: false);
				return;
			}
			if (!MultiplayerPlugin.Services.TryResolve<IMultiplayerMode>(out var instance))
			{
				SetVisible(visible: false);
				return;
			}
			if (!instance.IsHosting && !instance.IsSpectating)
			{
				SetVisible(visible: false);
				return;
			}
			bool visible;
			if (instance.IsHosting)
			{
				if ((int)BattleController.CurrentBattleState != 2)
				{
					SetVisible(visible: false);
					return;
				}
				if (!MultiplayerPlugin.Services.TryResolve<TurnManager>(out var instance2))
				{
					SetVisible(visible: false);
					return;
				}
				visible = instance2.Phase == TurnPhase.PLAYER_AIMING && instance2.CurrentPlayerSlot == 0;
			}
			else
			{
				visible = TurnChangeClientHandler.IsMyTurn;
			}
			SetVisible(visible);
		}

		private void SetVisible(bool visible)
		{
			if (!visible)
			{
				GameObject canvasObj = _canvasObj;
				if (canvasObj != null)
				{
					canvasObj.SetActive(false);
				}
			}
			else
			{
				if ((Object)(object)_canvasObj == (Object)null)
				{
					Build();
				}
				_canvasObj.SetActive(true);
			}
		}

		private void TryEnsureFont()
		{
			if ((Object)(object)_font != (Object)null)
			{
				return;
			}
			try
			{
				TextMeshProUGUI[] array = Object.FindObjectsOfType<TextMeshProUGUI>();
				foreach (TextMeshProUGUI val in array)
				{
					if ((Object)(object)((TMP_Text)val).font != (Object)null)
					{
						_font = ((TMP_Text)val).font;
						break;
					}
				}
			}
			catch
			{
			}
		}

		private void Build()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Expected O, but got Unknown
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0168: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Expected O, but got Unknown
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01da: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: Unknown result type (might be due to invalid IL or missing references)
			//IL_0212: Unknown result type (might be due to invalid IL or missing references)
			//IL_0217: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Unknown result type (might be due to invalid IL or missing references)
			//IL_0253: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_026e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0283: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_0325: Unknown result type (might be due to invalid IL or missing references)
			//IL_0336: Unknown result type (might be due to invalid IL or missing references)
			//IL_0341: Unknown result type (might be due to invalid IL or missing references)
			//IL_034c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0356: Unknown result type (might be due to invalid IL or missing references)
			_canvasObj = new GameObject("SkipTurnCanvas");
			Object.DontDestroyOnLoad((Object)(object)_canvasObj);
			_canvas = _canvasObj.AddComponent<Canvas>();
			_canvas.renderMode = (RenderMode)0;
			_canvas.sortingOrder = 8500;
			CanvasScaler obj = _canvasObj.AddComponent<CanvasScaler>();
			obj.uiScaleMode = (ScaleMode)1;
			obj.referenceResolution = new Vector2(1920f, 1080f);
			obj.matchWidthOrHeight = 0.5f;
			_canvasObj.AddComponent<GraphicRaycaster>();
			_buttonObj = new GameObject("SkipTurnButton");
			_buttonObj.transform.SetParent(_canvasObj.transform, false);
			Image obj2 = _buttonObj.AddComponent<Image>();
			Color color = default(Color);
			((Color)(ref color))..ctor(0.35f, 0.35f, 0.38f, 0.95f);
			((Graphic)obj2).color = color;
			_button = _buttonObj.AddComponent<Button>();
			ColorBlock colors = ((Selectable)_button).colors;
			((ColorBlock)(ref colors)).normalColor = Color.white;
			((ColorBlock)(ref colors)).highlightedColor = new Color(1.2f, 1.2f, 1.2f, 1f);
			((ColorBlock)(ref colors)).pressedColor = new Color(0.7f, 0.7f, 0.7f, 1f);
			((ColorBlock)(ref colors)).selectedColor = Color.white;
			((ColorBlock)(ref colors)).disabledColor = new Color(0.5f, 0.5f, 0.5f, 0.5f);
			((Selectable)_button).colors = colors;
			((UnityEvent)_button.onClick).AddListener(new UnityAction(OnClick));
			RectTransform component = _buttonObj.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0f, 0.5f);
			component.anchorMax = new Vector2(0f, 0.5f);
			component.pivot = new Vector2(0f, 0.5f);
			component.anchoredPosition = new Vector2(161f, 151.67f);
			component.sizeDelta = new Vector2(260f, 70f);
			GameObject val = new GameObject("Border");
			val.transform.SetParent(_buttonObj.transform, false);
			val.transform.SetAsFirstSibling();
			((Graphic)val.AddComponent<Image>()).color = new Color(0.08f, 0.08f, 0.1f, 0.95f);
			RectTransform component2 = val.GetComponent<RectTransform>();
			component2.anchorMin = Vector2.zero;
			component2.anchorMax = Vector2.one;
			component2.offsetMin = new Vector2(-4f, -4f);
			component2.offsetMax = new Vector2(4f, 4f);
			GameObject val2 = new GameObject("Label");
			val2.transform.SetParent(_buttonObj.transform, false);
			TextMeshProUGUI val3 = val2.AddComponent<TextMeshProUGUI>();
			TryEnsureFont();
			if ((Object)(object)_font != (Object)null)
			{
				((TMP_Text)val3).font = _font;
			}
			((TMP_Text)val3).text = "SKIP TURN";
			((TMP_Text)val3).fontSize = 32f;
			((TMP_Text)val3).fontStyle = (FontStyles)1;
			((TMP_Text)val3).alignment = (TextAlignmentOptions)514;
			((Graphic)val3).color = new Color(0.95f, 0.95f, 0.95f, 1f);
			RectTransform rectTransform = ((TMP_Text)val3).rectTransform;
			rectTransform.anchorMin = Vector2.zero;
			rectTransform.anchorMax = Vector2.one;
			rectTransform.offsetMin = Vector2.zero;
			rectTransform.offsetMax = Vector2.zero;
		}

		private void OnClick()
		{
			try
			{
				if (MultiplayerPlugin.Services == null || !MultiplayerPlugin.Services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return;
				}
				if (instance.IsHosting)
				{
					CoopSubscriptions instance2 = CoopSubscriptions.Instance;
					if (instance2 == null)
					{
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogWarning((object)"[SkipTurnButton] Host click but CoopSubscriptions.Instance null");
						}
					}
					else
					{
						instance2.SkipCurrentTurn(0, "host UI");
					}
				}
				else
				{
					if (!instance.IsSpectating)
					{
						return;
					}
					if (!MultiplayerPlugin.Services.TryResolve<IMessageSender>(out var instance3))
					{
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogWarning((object)"[SkipTurnButton] Client click but IMessageSender not resolvable");
						}
						return;
					}
					instance3.Send(new SkipTurnRequestEvent());
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogInfo((object)"[SkipTurnButton] Client sent SkipTurnRequestEvent");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("[SkipTurnButton] Click failed: " + ex.Message));
				}
			}
		}
	}
	public class TextScenarioSpectatorUI : MonoBehaviour
	{
		private static TextScenarioSpectatorUI _instance;

		private GameObject _canvasObj;

		private GameObject _dialoguePanel;

		private TextMeshProUGUI _speakerText;

		private TextMeshProUGUI _subtitleText;

		private GameObject _responsesContainer;

		private readonly List<GameObject> _responseItems = new List<GameObject>();

		private int _lastHighlightIndex = -1;

		private static readonly Color HighlightColor = new Color(1f, 0.85f, 0.3f, 1f);

		private static readonly Color NormalColor = new Color(0.9f, 0.9f, 0.9f, 1f);

		private static readonly Color ArrowColor = new Color(1f, 0.85f, 0.3f, 1f);

		public static TextScenarioSpectatorUI Instance => _instance;

		private void Awake()
		{
			_instance = this;
			CreateUI();
			Hide();
		}

		private void OnDestroy()
		{
			if ((Object)(object)_instance == (Object)(object)this)
			{
				_instance = null;
			}
			if ((Object)(object)_canvasObj != (Object)null)
			{
				Object.Destroy((Object)(object)_canvasObj);
			}
		}

		private void CreateUI()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Expected O, but got Unknown
			//IL_0068: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_00c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_0134: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected O, but got Unknown
			//IL_0193: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0202: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0225: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Expected O, but got Unknown
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_02de: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f8: Expected O, but got Unknown
			//IL_032a: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0354: Unknown result type (might be due to invalid IL or missing references)
			//IL_0368: Unknown result type (might be due to invalid IL or missing references)
			_canvasObj = new GameObject("TextScenarioSpectatorCanvas");
			_canvasObj.transform.SetParent(((Component)this).transform, false);
			Object.DontDestroyOnLoad((Object)(object)_canvasObj);
			Canvas obj = _canvasObj.AddComponent<Canvas>();
			obj.renderMode = (RenderMode)0;
			obj.sortingOrder = 90;
			CanvasScaler obj2 = _canvasObj.AddComponent<CanvasScaler>();
			obj2.uiScaleMode = (ScaleMode)1;
			obj2.referenceResolution = new Vector2(1920f, 1080f);
			obj2.matchWidthOrHeight = 0.5f;
			_dialoguePanel = new GameObject("DialoguePanel");
			_dialoguePanel.transform.SetParent(_canvasObj.transform, false);
			((Graphic)_dialoguePanel.AddComponent<Image>()).color = new Color(0.05f, 0.05f, 0.1f, 0.85f);
			RectTransform component = _dialoguePanel.GetComponent<RectTransform>();
			component.anchorMin = new Vector2(0.1f, 0f);
			component.anchorMax = new Vector2(0.9f, 0.4f);
			component.offsetMin = new Vector2(0f, 20f);
			component.offsetMax = new Vector2(0f, 0f);
			GameObject val = new GameObject("SpeakerName");
			val.transform.SetParent(_dialoguePanel.transform, false);
			_speakerText = val.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_speakerText).fontSize = 28f;
			((TMP_Text)_speakerText).fontStyle = (FontStyles)1;
			((Graphic)_speakerText).color = new Color(0.9f, 0.75f, 0.4f, 1f);
			((TMP_Text)_speakerText).alignment = (TextAlignmentOptions)257;
			RectTransform rectTransform = ((TMP_Text)_speakerText).rectTransform;
			rectTransform.anchorMin = new Vector2(0f, 1f);
			rectTransform.anchorMax = new Vector2(1f, 1f);
			rectTransform.pivot = new Vector2(0f, 1f);
			rectTransform.anchoredPosition = new Vector2(20f, -10f);
			rectTransform.sizeDelta = new Vector2(-40f, 36f);
			GameObject val2 = new GameObject("SubtitleText");
			val2.transform.SetParent(_dialoguePanel.transform, false);
			_subtitleText = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)_subtitleText).fontSize = 24f;
			((Graphic)_subtitleText).color = Color.white;
			((TMP_Text)_subtitleText).alignment = (TextAlignmentOptions)257;
			((TMP_Text)_subtitleText).enableWordWrapping = true;
			RectTransform rectTransform2 = ((TMP_Text)_subtitleText).rectTransform;
			rectTransform2.anchorMin = new Vector2(0f, 0.4f);
			rectTransform2.anchorMax = new Vector2(1f, 1f);
			rectTransform2.offsetMin = new Vector2(20f, 0f);
			rectTransform2.offsetMax = new Vector2(-20f, -50f);
			_responsesContainer = new GameObject("ResponsesContainer");
			_responsesContainer.transform.SetParent(_dialoguePanel.transform, false);
			RectTransform obj3 = _responsesContainer.AddComponent<RectTransform>();
			obj3.anchorMin = new Vector2(0f, 0f);
			obj3.anchorMax = new Vector2(1f, 0.4f);
			obj3.offsetMin = new Vector2(20f, 10f);
			obj3.offsetMax = new Vector2(-20f, 0f);
			VerticalLayoutGroup obj4 = _responsesContainer.AddComponent<VerticalLayoutGroup>();
			((LayoutGroup)obj4).childAlignment = (TextAnchor)0;
			((HorizontalOrVerticalLayoutGroup)obj4).spacing = 4f;
			((HorizontalOrVerticalLayoutGroup)obj4).childControlWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj4).childControlHeight = false;
			((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandWidth = true;
			((HorizontalOrVerticalLayoutGroup)obj4).childForceExpandHeight = false;
		}

		public void Show()
		{
			GameObject canvasObj = _canvasObj;
			if (canvasObj != null)
			{
				canvasObj.SetActive(true);
			}
		}

		public void Hide()
		{
			GameObject canvasObj = _canvasObj;
			if (canvasObj != null)
			{
				canvasObj.SetActive(false);
			}
		}

		public void UpdateDialogue(string speakerName, string subtitleText, List<string> responses, int highlightedIndex)
		{
			if (!((Object)(object)_canvasObj == (Object)null))
			{
				((TMP_Text)_speakerText).text = speakerName ?? string.Empty;
				((TMP_Text)_subtitleText).text = subtitleText ?? string.Empty;
				UpdateResponses(responses, highlightedIndex);
				Show();
			}
		}

		private void UpdateResponses(List<string> responses, int highlightedIndex)
		{
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			if (responses == null)
			{
				responses = new List<string>();
			}
			while (_responseItems.Count < responses.Count)
			{
				GameObject item = CreateResponseItem(_responsesContainer.transform, _responseItems.Count);
				_responseItems.Add(item);
			}
			while (_responseItems.Count > responses.Count)
			{
				GameObject obj = _responseItems[_responseItems.Count - 1];
				_responseItems.RemoveAt(_responseItems.Count - 1);
				Object.Destroy((Object)(object)obj);
			}
			for (int i = 0; i < responses.Count; i++)
			{
				GameObject obj2 = _responseItems[i];
				obj2.SetActive(true);
				Transform obj3 = obj2.transform.Find("Arrow");
				TextMeshProUGUI val = ((obj3 != null) ? ((Component)obj3).GetComponent<TextMeshProUGUI>() : null);
				Transform obj4 = obj2.transform.Find("Text");
				TextMeshProUGUI val2 = ((obj4 != null) ? ((Component)obj4).GetComponent<TextMeshProUGUI>() : null);
				bool flag = i == highlightedIndex;
				if ((Object)(object)val != (Object)null)
				{
					((TMP_Text)val).text = (flag ? ">" : " ");
					((Graphic)val).color = ArrowColor;
				}
				if ((Object)(object)val2 != (Object)null)
				{
					((TMP_Text)val2).text = responses[i];
					((Graphic)val2).color = (flag ? HighlightColor : NormalColor);
				}
			}
			_lastHighlightIndex = highlightedIndex;
		}

		private GameObject CreateResponseItem(Transform parent, int index)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: 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_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject($"Response_{index}");
			val.transform.SetParent(parent, false);
			val.AddComponent<LayoutElement>().preferredHeight = 32f;
			HorizontalLayoutGroup obj = val.AddComponent<HorizontalLayoutGroup>();
			((LayoutGroup)obj).childAlignment = (TextAnchor)3;
			((HorizontalOrVerticalLayoutGroup)obj).spacing = 8f;
			((HorizontalOrVerticalLayoutGroup)obj).childControlWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childControlHeight = true;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandWidth = false;
			((HorizontalOrVerticalLayoutGroup)obj).childForceExpandHeight = false;
			GameObject val2 = new GameObject("Arrow");
			val2.transform.SetParent(val.transform, false);
			TextMeshProUGUI obj2 = val2.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj2).fontSize = 24f;
			((TMP_Text)obj2).fontStyle = (FontStyles)1;
			((Graphic)obj2).color = ArrowColor;
			((TMP_Text)obj2).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)obj2).text = " ";
			val2.AddComponent<LayoutElement>().preferredWidth = 24f;
			GameObject val3 = new GameObject("Text");
			val3.transform.SetParent(val.transform, false);
			TextMeshProUGUI obj3 = val3.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj3).fontSize = 22f;
			((Graphic)obj3).color = NormalColor;
			((TMP_Text)obj3).alignment = (TextAlignmentOptions)4097;
			((TMP_Text)obj3).enableWordWrapping = true;
			val3.AddComponent<LayoutElement>().flexibleWidth = 1f;
			return val;
		}
	}
}
namespace Multipeglin.Patches
{
	[HarmonyPatch]
	internal static class Act4BossPegBoardFrameManagerPatches
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static SpiritOfRadiaPhaseTransitionStarted <0>__DispatchPreTransition;

			public static SpiritOfRadiaPhaseTransitionStarted <1>__DispatchMainTransition;
		}

		[HarmonyPatch(typeof(Act4BossPegBoardFrameManager), "RegisterCallbacks")]
		[HarmonyPostfix]
		public static void Act4BossPegBoardFrameManager_RegisterCallbacks_Postfix()
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Expected O, but got Unknown
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Expected O, but got Unknown
			//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_0065: Expected O, but got Unknown
			if (MultiplayerClientPatches.IsHosting && !MultiplayerClientPatches._spiritRadiaHostSubscribed)
			{
				MultiplayerClientPatches._spiritRadiaHostSubscribed = true;
				SpiritOfRadiaPhaseTransitionStarted preTransitionStarted = SpiritOfRadiaBoss.PreTransitionStarted;
				object obj = <>O.<0>__DispatchPreTransition;
				if (obj == null)
				{
					SpiritOfRadiaPhaseTransitionStarted val = MultiplayerClientPatches.DispatchPreTransition;
					<>O.<0>__DispatchPreTransition = val;
					obj = (object)val;
				}
				SpiritOfRadiaBoss.PreTransitionStarted = (SpiritOfRadiaPhaseTransitionStarted)Delegate.Combine((Delegate?)(object)preTransitionStarted, (Delegate?)obj);
				SpiritOfRadiaPhaseTransitionStarted onSpiritOfRadiaPhaseTransitionStarted = SpiritOfRadiaBoss.OnSpiritOfRadiaPhaseTransitionStarted;
				object obj2 = <>O.<1>__DispatchMainTransition;
				if (obj2 == null)
				{
					SpiritOfRadiaPhaseTransitionStarted val2 = MultiplayerClientPatches.DispatchMainTransition;
					<>O.<1>__DispatchMainTransition = val2;
					obj2 = (object)val2;
				}
				SpiritOfRadiaBoss.OnSpiritOfRadiaPhaseTransitionStarted = (SpiritOfRadiaPhaseTransitionStarted)Delegate.Combine((Delegate?)(object)onSpiritOfRadiaPhaseTransitionStarted, (Delegate?)obj2);
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[SpiritOfRadia] Host: subscribed to phase-2 delegates");
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class AnimatorPatches
	{
		[HarmonyPatch(typeof(Animator), "SetTrigger", new Type[] { typeof(string) })]
		[HarmonyPostfix]
		public static void Animator_SetTrigger_Postfix(Animator __instance, string name)
		{
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.IsHosting || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			Enemy componentInParent = ((Component)__instance).GetComponentInParent<Enemy>();
			if (!((Object)(object)componentInParent == (Object)null) && MultiplayerPlugin.Services != null && MultiplayerPlugin.Services.TryResolve<IGameEventRegistry>(out var instance) && MultiplayerPlugin.Services.TryResolve<EnemyIdentifier>(out var instance2))
			{
				string guid = instance2.GetGuid(componentInParent);
				if (!string.IsNullOrEmpty(guid))
				{
					instance.Dispatch(new AnimationSyncEvent
					{
						EntityGuid = guid,
						ParamType = "trigger",
						ParamName = name,
						PosX = ((Component)componentInParent).transform.position.x,
						PosY = ((Component)componentInParent).transform.position.y
					});
				}
			}
		}

		[HarmonyPatch(typeof(Animator), "SetBool", new Type[]
		{
			typeof(string),
			typeof(bool)
		})]
		[HarmonyPostfix]
		public static void Animator_SetBool_Postfix(Animator __instance, string name, bool value)
		{
			if (!MultiplayerClientPatches.IsHosting || (Object)(object)__instance == (Object)null)
			{
				return;
			}
			Enemy componentInParent = ((Component)__instance).GetComponentInParent<Enemy>();
			if (!((Object)(object)componentInParent == (Object)null) && MultiplayerPlugin.Services != null && MultiplayerPlugin.Services.TryResolve<IGameEventRegistry>(out var instance) && MultiplayerPlugin.Services.TryResolve<EnemyIdentifier>(out var instance2))
			{
				string guid = instance2.GetGuid(componentInParent);
				if (!string.IsNullOrEmpty(guid))
				{
					instance.Dispatch(new AnimationSyncEvent
					{
						EntityGuid = guid,
						ParamType = "bool",
						ParamName = name,
						Value = (value ? 1 : 0)
					});
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class AttackManagerPatches
	{
		[HarmonyPatch(typeof(AttackManager), "Attack")]
		[HarmonyPostfix]
		public static void AttackManager_Attack_Postfix(AttackManager __instance, Enemy target, int numPegsHitThisShot, int criticalHitCount)
		{
			if (!MultiplayerClientPatches.IsHosting)
			{
				return;
			}
			try
			{
				object? obj = AccessTools.Field(typeof(AttackManager), "_attack")?.GetValue(__instance);
				object? obj2 = ((obj is Attack) ? obj : null);
				MultiplayerClientPatches.LastAttackAnimTrigger = ((Attack)(obj2?)).PeglinAttackAnimationTrigger ?? "attack";
				MultiplayerClientPatches.LastAttackNumPegsHit = numPegsHitThisShot;
				MultiplayerClientPatches.LastAttackIsCrit = criticalHitCount > 0;
				object lastAttackOrbName;
				if (obj2 == null)
				{
					lastAttackOrbName = null;
				}
				else
				{
					GameObject gameObject = ((Component)obj2).gameObject;
					lastAttackOrbName = ((gameObject == null) ? null : ((Object)gameObject).name?.Replace("(Clone)", string.Empty).Trim());
				}
				MultiplayerClientPatches.LastAttackOrbName = (string)lastAttackOrbName;
				if ((Object)(object)target != (Object)null)
				{
					IServiceContainer services = MultiplayerPlugin.Services;
					MultiplayerClientPatches.LastAttackTargetGuid = ((services != null && services.TryResolve<EnemyIdentifier>(out var instance)) ? instance : null)?.GetGuid(target);
				}
			}
			catch
			{
			}
		}

		[HarmonyPatch(typeof(AttackManager), "Attack")]
		[HarmonyPrefix]
		public static bool AttackManager_Attack_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked AttackManager.Attack on client");
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class BattleControllerPatches
	{
		public struct RoundCountSnapshot
		{
			public bool Engaged;

			public int SavedRoundCount;

			public RoundCountIncremented SavedDelegate;
		}

		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static BallDrawn <>9__1_0;

			public static BallDrawn <>9__1_1;

			public static Shuffled <>9__1_2;

			public static PersistBallUsed <>9__1_3;

			internal void <BattleController_Update_Postfix>b__1_0(GameObject _)
			{
			}

			internal void <BattleController_Update_Postfix>b__1_1(GameObject _)
			{
			}

			internal void <BattleController_Update_Postfix>b__1_2(int _)
			{
			}

			internal void <BattleController_Update_Postfix>b__1_3()
			{
			}
		}

		private static int _lastFiredCoopRound;

		[HarmonyPatch(typeof(BattleController), "Update")]
		[HarmonyPrefix]
		public static bool BattleController_Update_Prefix(BattleController __instance)
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			bool isMyTurn = TurnChangeClientHandler.IsMyTurn;
			bool clientShotSentThisTurn = MultiplayerClientPatches.ClientShotSentThisTurn;
			if (isMyTurn && !clientShotSentThisTurn)
			{
				if (MultiplayerClientPatches._clientBallInitialized && (Object)(object)MultiplayerClientPatches._clientBallGO == (Object)null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[ClientAim] Ball was destroyed externally — resetting for retry");
					}
					MultiplayerClientPatches._clientBallInitialized = false;
				}
				MultiplayerClientPatches.HandleClientAiming(__instance);
				if (MultiplayerClientPatches._clientBallInitialized && (Object)(object)MultiplayerClientPatches._clientBallGO != (Object)null)
				{
					MultiplayerClientPatches._clientAimSendTimer += Time.unscaledDeltaTime;
					if (MultiplayerClientPatches._clientAimSendTimer >= 0.1f)
					{
						MultiplayerClientPatches._clientAimSendTimer = 0f;
						MultiplayerClientPatches.SendClientAimUpdate();
					}
				}
				if (MultiplayerClientPatches._clientBallInitialized && !MultiplayerClientPatches._clientDiscardSentThisTurn && (Input.GetMouseButtonDown(1) || Input.GetKeyDown((KeyCode)8)))
				{
					IServiceContainer services = MultiplayerPlugin.Services;
					if (services != null && services.TryResolve<IMessageSender>(out var instance))
					{
						instance.Send(new OrbDiscardRequestEvent());
						MultiplayerClientPatches._clientDiscardSentThisTurn = true;
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogInfo((object)"[ClientAim] Sent OrbDiscardRequest to host");
						}
					}
				}
				if (MultiplayerClientPatches._clientBallInitialized && (Object)(object)MultiplayerClientPatches._clientBallGO != (Object)null && !MultiplayerClientPatches.ClientShotSentThisTurn && Input.GetMouseButtonDown(0) && !MultiplayerClientPatches.IsPointerOverInteractiveUI() && !MultiplayerClientPatches.IsPointerOverEnemy())
				{
					MultiplayerClientPatches.TrySendDirectShot();
				}
			}
			else
			{
				if (MultiplayerClientPatches._clientBallInitialized)
				{
					MultiplayerClientPatches.CleanupClientAiming();
				}
				MultiplayerClientPatches._clientAimSendTimer = 0f;
			}
			return false;
		}

		[HarmonyPatch(typeof(BattleController), "Update")]
		[HarmonyPostfix]
		public static void BattleController_Update_Postfix()
		{
			//IL_0198: Unknown result type (might be due to invalid IL or missing references)
			//IL_019e: Invalid comparison between Unknown and I4
			//IL_0ad8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0ae4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b04: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b1a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b49: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b86: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03be: Invalid comparison between Unknown and I4
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: 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: Invalid comparison between Unknown and I4
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0450: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_045b: Expected O, but got Unknown
			//IL_0860: Unknown result type (might be due to invalid IL or missing references)
			//IL_0865: Unknown result type (might be due to invalid IL or missing references)
			//IL_08ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_08c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_090e: Unknown result type (might be due to invalid IL or missing references)
			//IL_091d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0938: Unknown result type (might be due to invalid IL or missing references)
			//IL_06a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_06ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_06b3: Expected O, but got Unknown
			//IL_06cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_06d7: Expected O, but got Unknown
			//IL_099c: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_09a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_09aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_088d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0892: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_06f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_06fb: Expected O, but got Unknown
			//IL_09db: Unknown result type (might be due to invalid IL or missing references)
			//IL_09e1: Invalid comparison between Unknown and I4
			//IL_09ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_09cf: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.IsHosting || !LobbyUI.GameStartReceived)
			{
				return;
			}
			if ((Object)(object)MultiplayerClientPatches._firedBallGO != (Object)null && MultiplayerClientPatches._firedBallLogCount < 5)
			{
				MultiplayerClientPatches._firedBallTimer += Time.deltaTime;
				if (MultiplayerClientPatches._firedBallTimer >= 0.5f * (float)(MultiplayerClientPatches._firedBallLogCount + 1))
				{
					MultiplayerClientPatches._firedBallLogCount++;
					Rigidbody2D component = MultiplayerClientPatches._firedBallGO.GetComponent<Rigidbody2D>();
					PachinkoBall component2 = MultiplayerClientPatches._firedBallGO.GetComponent<PachinkoBall>();
					if ((Object)(object)component != (Object)null)
					{
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)($"[BallTrack] t={MultiplayerClientPatches._firedBallTimer:F1}s pos=({MultiplayerClientPatches._firedBallGO.transform.position.x:F1},{MultiplayerClientPatches._firedBallGO.transform.position.y:F1}), " + $"vel=({component.velocity.x:F1},{component.velocity.y:F1}), sim={component.simulated}, bodyType={component.bodyType}, " + $"state={((component2 != null) ? new FireballState?(component2.CurrentState) : null)}, active={MultiplayerClientPatches._firedBallGO.activeInHierarchy}"));
						}
					}
					else
					{
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogInfo((object)$"[BallTrack] t={MultiplayerClientPatches._firedBallTimer:F1}s ball destroyed or rb null");
						}
						MultiplayerClientPatches._firedBallGO = null;
					}
				}
			}
			if ((int)BattleController.CurrentBattleState == 3)
			{
				BattleController val = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val != (Object)null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(BattleController), "_remainingPachinkoBalls");
					int num = ((fieldInfo != null) ? ((int)fieldInfo.GetValue(val)) : 0);
					float num2 = Time.unscaledTime - MultiplayerClientPatches._shotFiredUnscaledTime;
					if (num > 0 && num2 >= 10f)
					{
						MultiplayerClientPatches._stuckCompletionScanTimer += Time.unscaledDeltaTime;
						if (MultiplayerClientPatches._stuckCompletionScanTimer >= 0.5f)
						{
							MultiplayerClientPatches._stuckCompletionScanTimer = 0f;
							PachinkoBall[] array = Object.FindObjectsOfType<PachinkoBall>(true);
							int num3 = 0;
							foreach (PachinkoBall val2 in array)
							{
								if ((Object)(object)val2 != (Object)null && !val2.IsDummy && val2.IsFiring())
								{
									num3++;
								}
							}
							if (num3 == 0)
							{
								if (MultiplayerClientPatches._stuckCompletionSinceUnscaledTime == 0f)
								{
									MultiplayerClientPatches._stuckCompletionSinceUnscaledTime = Time.unscaledTime;
									ManualLogSource logger3 = MultiplayerPlugin.Logger;
									if (logger3 != null)
									{
										logger3.LogWarning((object)$"[ShotWatchdog] AWAITING_SHOT_COMPLETION counter={num} but no live firing balls (elapsed={num2:F1}s) — arming unstick timer");
									}
								}
								else if (Time.unscaledTime - MultiplayerClientPatches._stuckCompletionSinceUnscaledTime >= 15f)
								{
									ManualLogSource logger4 = MultiplayerPlugin.Logger;
									if (logger4 != null)
									{
										logger4.LogWarning((object)$"[ShotWatchdog] Stuck for >15s with no live firing balls — force-zeroing _remainingPachinkoBalls (was {num}) to release the turn");
									}
									foreach (PachinkoBall val3 in array)
									{
										if (!((Object)(object)val3 != (Object)null) || val3.IsDummy || (int)val3.CurrentState == 3)
										{
											continue;
										}
										try
										{
											val3.StartDestroy();
										}
										catch (Exception ex)
										{
											ManualLogSource logger5 = MultiplayerPlugin.Logger;
											if (logger5 != null)
											{
												logger5.LogWarning((object)("[ShotWatchdog] StartDestroy on lingering ball failed: " + ex.Message));
											}
										}
									}
									fieldInfo?.SetValue(val, 0);
									MultiplayerClientPatches._stuckCompletionSinceUnscaledTime = 0f;
								}
							}
							else
							{
								MultiplayerClientPatches._stuckCompletionSinceUnscaledTime = 0f;
							}
						}
					}
					else
					{
						MultiplayerClientPatches._stuckCompletionSinceUnscaledTime = 0f;
						MultiplayerClientPatches._stuckCompletionScanTimer = 0f;
					}
				}
			}
			else
			{
				MultiplayerClientPatches._stuckCompletionSinceUnscaledTime = 0f;
				MultiplayerClientPatches._stuckCompletionScanTimer = 0f;
			}
			if ((int)BattleController.CurrentBattleState != 2)
			{
				return;
			}
			if (OrbDiscardRequestClientHandler.PendingDiscard)
			{
				OrbDiscardRequestClientHandler.PendingDiscard = false;
				BattleController val4 = Object.FindObjectOfType<BattleController>();
				if (!((Object)(object)val4 != (Object)null))
				{
					return;
				}
				object? obj = AccessTools.Field(typeof(BattleController), "_activePachinkoBall")?.GetValue(val4);
				GameObject val5 = (GameObject)((obj is GameObject) ? obj : null);
				if ((Object)(object)val5 != (Object)null && !val5.activeInHierarchy)
				{
					val5.SetActive(true);
				}
				DeckInfoManager.populatingDisplayOrb = false;
				BallDrawn onBallUsed = DeckManager.onBallUsed;
				object obj2 = <>c.<>9__1_0;
				if (obj2 == null)
				{
					BallDrawn val6 = delegate
					{
					};
					<>c.<>9__1_0 = val6;
					obj2 = (object)val6;
				}
				DeckManager.onBallUsed = (BallDrawn)obj2;
				MultiplayerClientPatches._executingPendingDiscard = true;
				try
				{
					AccessTools.Method(typeof(BattleController), "AttemptOrbDiscard", (Type[])null, (Type[])null)?.Invoke(val4, null);
				}
				finally
				{
					MultiplayerClientPatches._executingPendingDiscard = false;
					DeckManager.onBallUsed = onBallUsed;
				}
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(BattleController), "_skipPlayerTurnCount");
				if (fieldInfo2 != null)
				{
					int num4 = (int)fieldInfo2.GetValue(val4);
					if (num4 > 0)
					{
						fieldInfo2.SetValue(val4, 0);
						ManualLogSource logger6 = MultiplayerPlugin.Logger;
						if (logger6 != null)
						{
							logger6.LogInfo((object)$"[ClientPatches] Cleared _skipPlayerTurnCount={num4} after client discard (reload triggered)");
						}
					}
				}
				ManualLogSource logger7 = MultiplayerPlugin.Logger;
				if (logger7 != null)
				{
					logger7.LogInfo((object)"[ClientPatches] Executed pending OrbDiscard for client");
				}
				return;
			}
			PendingShot pendingShot = ShootRequestClientHandler.PeekPendingShot();
			if (pendingShot == null)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<TurnManager>(out var instance) && pendingShot.SlotIndex != instance.CurrentPlayerSlot)
			{
				ManualLogSource logger8 = MultiplayerPlugin.Logger;
				if (logger8 != null)
				{
					logger8.LogWarning((object)$"[ClientPatches] PendingShot slot mismatch: shot.slot={pendingShot.SlotIndex} current={instance.CurrentPlayerSlot} — discarding");
				}
				return;
			}
			try
			{
				BattleController val7 = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val7 == (Object)null)
				{
					return;
				}
				object? obj3 = AccessTools.Field(typeof(BattleController), "_activePachinkoBall")?.GetValue(val7);
				GameObject val8 = (GameObject)((obj3 is GameObject) ? obj3 : null);
				if ((Object)(object)val8 == (Object)null)
				{
					float unscaledTime = Time.unscaledTime;
					if (MultiplayerClientPatches._stuckPendingShotSlot != pendingShot.SlotIndex)
					{
						MultiplayerClientPatches._stuckPendingShotSlot = pendingShot.SlotIndex;
						MultiplayerClientPatches._stuckPendingShotSinceUnscaledTime = unscaledTime;
						MultiplayerClientPatches._stuckPendingShotRedraws = 0;
						MultiplayerClientPatches._stuckPendingShotLastWarnTime = 0f;
					}
					if (unscaledTime - MultiplayerClientPatches._stuckPendingShotLastWarnTime >= 1f)
					{
						MultiplayerClientPatches._stuckPendingShotLastWarnTime = unscaledTime;
						ManualLogSource logger9 = MultiplayerPlugin.Logger;
						if (logger9 != null)
						{
							logger9.LogWarning((object)("[ClientPatches] PendingShot from " + pendingShot.PlayerName + " but _activePachinkoBall is null " + $"(stuck for {unscaledTime - MultiplayerClientPatches._stuckPendingShotSinceUnscaledTime:F1}s, retries={MultiplayerClientPatches._stuckPendingShotRedraws})"));
						}
					}
					if (!(unscaledTime - MultiplayerClientPatches._stuckPendingShotSinceUnscaledTime >= 1.5f) || MultiplayerClientPatches._stuckPendingShotRedraws >= 3)
					{
						return;
					}
					MultiplayerClientPatches._stuckPendingShotRedraws++;
					MultiplayerClientPatches._stuckPendingShotSinceUnscaledTime = unscaledTime;
					BallDrawn onBallUsed2 = DeckManager.onBallUsed;
					Shuffled onDeckShuffled = DeckManager.onDeckShuffled;
					PersistBallUsed onPersistBallUsed = DeckManager.onPersistBallUsed;
					object obj4 = <>c.<>9__1_1;
					if (obj4 == null)
					{
						BallDrawn val9 = delegate
						{
						};
						<>c.<>9__1_1 = val9;
						obj4 = (object)val9;
					}
					DeckManager.onBallUsed = (BallDrawn)obj4;
					object obj5 = <>c.<>9__1_2;
					if (obj5 == null)
					{
						Shuffled val10 = delegate
						{
						};
						<>c.<>9__1_2 = val10;
						obj5 = (object)val10;
					}
					DeckManager.onDeckShuffled = (Shuffled)obj5;
					object obj6 = <>c.<>9__1_3;
					if (obj6 == null)
					{
						PersistBallUsed val11 = delegate
						{
						};
						<>c.<>9__1_3 = val11;
						obj6 = (object)val11;
					}
					DeckManager.onPersistBallUsed = (PersistBallUsed)obj6;
					DeckInfoManager.populatingDisplayOrb = false;
					try
					{
						AccessTools.Method(typeof(BattleController), "DrawBall", (Type[])null, (Type[])null)?.Invoke(val7, null);
						ManualLogSource logger10 = MultiplayerPlugin.Logger;
						if (logger10 != null)
						{
							logger10.LogWarning((object)$"[ClientPatches] Retried DrawBall for stuck slot {pendingShot.SlotIndex} (attempt {MultiplayerClientPatches._stuckPendingShotRedraws})");
						}
						return;
					}
					catch (Exception ex2)
					{
						ManualLogSource logger11 = MultiplayerPlugin.Logger;
						if (logger11 != null)
						{
							logger11.LogWarning((object)$"[ClientPatches] DrawBall retry failed for slot {pendingShot.SlotIndex}: {ex2.InnerException?.Message ?? ex2.Message}");
						}
						return;
					}
					finally
					{
						DeckManager.onBallUsed = onBallUsed2;
						DeckManager.onDeckShuffled = onDeckShuffled;
						DeckManager.onPersistBallUsed = onPersistBallUsed;
					}
				}
				if (MultiplayerClientPatches._stuckPendingShotSlot != -1)
				{
					ManualLogSource logger12 = MultiplayerPlugin.Logger;
					if (logger12 != null)
					{
						logger12.LogInfo((object)$"[ClientPatches] Stuck pending shot recovered for slot {MultiplayerClientPatches._stuckPendingShotSlot} after {MultiplayerClientPatches._stuckPendingShotRedraws} retry(ies)");
					}
					MultiplayerClientPatches._stuckPendingShotSlot = -1;
					MultiplayerClientPatches._stuckPendingShotRedraws = 0;
					MultiplayerClientPatches._stuckPendingShotLastWarnTime = 0f;
				}
				PachinkoBall component3 = val8.GetComponent<PachinkoBall>();
				if ((Object)(object)component3 == (Object)null)
				{
					ManualLogSource logger13 = MultiplayerPlugin.Logger;
					if (logger13 != null)
					{
						logger13.LogWarning((object)("[ClientPatches] PendingShot from " + pendingShot.PlayerName + " but _activePachinkoBall has no PachinkoBall component"));
					}
					return;
				}
				List<Tween> list = DOTween.TweensByTarget((object)val8.transform, false, (List<Tween>)null);
				Vector3 val12 = val8.transform.localScale;
				bool flag = false;
				if (list != null)
				{
					foreach (Tween item in list)
					{
						if (item is TweenerCore<Vector3, Vector3, VectorOptions> val13)
						{
							val12 = val13.endValue;
							flag = true;
							break;
						}
					}
				}
				DOTween.Kill((object)val8.transform, false);
				if (!flag && val12.x < 0.1f)
				{
					((Vector3)(ref val12))..ctor(0.32f, 0.32f, 0.32f);
				}
				val8.transform.localScale = val12;
				ManualLogSource logger14 = MultiplayerPlugin.Logger;
				if (logger14 != null)
				{
					logger14.LogInfo((object)$"[ClientPatches] Scale snap: ({val12.x:F2},{val12.y:F2}) hadTween={flag} state={component3.CurrentState}");
				}
				component3.InitializeMembers();
				if (component3.IsDummy)
				{
					component3.IsDummy = false;
					ManualLogSource logger15 = MultiplayerPlugin.Logger;
					if (logger15 != null)
					{
						logger15.LogInfo((object)"[ClientPatches] Cleared IsDummy flag on ball");
					}
				}
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(PachinkoBall), "_aimVector");
				Vector2 val14 = new Vector2(pendingShot.AimDirectionX, pendingShot.AimDirectionY);
				Vector2 normalized = ((Vector2)(ref val14)).normalized;
				if (fieldInfo3 != null)
				{
					fieldInfo3.SetValue(component3, normalized);
					val8.transform.right = Vector2.op_Implicit(normalized);
				}
				if ((int)component3.CurrentState != 1)
				{
					AccessTools.Property(typeof(PachinkoBall), "CurrentState")?.GetSetMethod(nonPublic: true)?.Invoke(component3, new object[1] { (object)(FireballState)1 });
				}
				if (!val8.activeInHierarchy)
				{
					val8.SetActive(true);
					ManualLogSource logger16 = MultiplayerPlugin.Logger;
					if (logger16 != null)
					{
						logger16.LogInfo((object)"[ClientPatches] Pre-activated ball before Fire()");
					}
				}
				CoopSubscriptions.LastPendingShotTargetGuid = pendingShot.TargetEnemyGuid;
				try
				{
					if (!string.IsNullOrEmpty(pendingShot.TargetEnemyGuid) && services != null && services.TryResolve<EnemyIdentifier>(out var instance2))
					{
						Enemy val15 = instance2.Find(pendingShot.TargetEnemyGuid);
						if ((Object)(object)val15 != (Object)null)
						{
							TargetingManager obj7 = Object.FindObjectOfType<TargetingManager>();
							if (obj7 != null)
							{
								obj7.SetEnemyAsTarget(val15, true);
							}
						}
					}
				}
				catch
				{
				}
				MultiplayerClientPatches.ExecutingPendingShot = true;
				try
				{
					component3.Fire(true);
					Rigidbody2D component4 = val8.GetComponent<Rigidbody2D>();
					CircleCollider2D component5 = val8.GetComponent<CircleCollider2D>();
					ManualLogSource logger17 = MultiplayerPlugin.Logger;
					if (logger17 != null)
					{
						logger17.LogInfo((object)($"[ClientPatches] PachinkoBall.Fire() succeeded, aim=({normalized.x:F2},{normalized.y:F2}), " + $"pos=({val8.transform.position.x:F1},{val8.transform.position.y:F1}), " + $"isDummy={component3.IsDummy}, scale=({val8.transform.localScale.x:F2}), " + "layer=" + LayerMask.LayerToName(val8.layer) + ", " + $"state={component3.CurrentState}, " + $"rb.sim={((component4 != null) ? new bool?(component4.simulated) : null)}, rb.grav={((component4 != null) ? new float?(component4.gravityScale) : null):F1}, rb.mass={((component4 != null) ? new float?(component4.mass) : null):F2}, " + $"collider={(Object)(object)component5 != (Object)null && ((Behaviour)component5).enabled}, radius={((component5 != null) ? new float?(component5.radius) : null):F3}"));
					}
					MultiplayerClientPatches._firedBallGO = val8;
					MultiplayerClientPatches._firedBallTimer = 0f;
					MultiplayerClientPatches._firedBallLogCount = 0;
				}
				catch (Exception arg)
				{
					ManualLogSource logger18 = MultiplayerPlugin.Logger;
					if (logger18 != null)
					{
						logger18.LogError((object)$"[ClientPatches] Fire() failed even after InitializeMembers(): {arg}");
					}
				}
				finally
				{
					MultiplayerClientPatches.ExecutingPendingShot = false;
				}
				ShootRequestClientHandler.ConsumePendingShot();
				ManualLogSource logger19 = MultiplayerPlugin.Logger;
				if (logger19 != null)
				{
					logger19.LogInfo((object)($"[ClientPatches] Executed PendingShot from {pendingShot.PlayerName} (slot {pendingShot.SlotIndex}): " + $"aim=({pendingShot.AimDirectionX:F2},{pendingShot.AimDirectionY:F2})"));
				}
			}
			catch (Exception arg2)
			{
				ManualLogSource logger20 = MultiplayerPlugin.Logger;
				if (logger20 != null)
				{
					logger20.LogWarning((object)$"[ClientPatches] PendingShot execution failed: {arg2}");
				}
			}
		}

		[HarmonyPatch(typeof(BattleController), "DrawBall")]
		[HarmonyPostfix]
		public static void BattleController_DrawBall_Postfix()
		{
			if (!LobbyUI.GameStartReceived)
			{
				return;
			}
			BattleController val = Object.FindObjectOfType<BattleController>();
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			object? obj = AccessTools.Field(typeof(BattleController), "_activePachinkoBall")?.GetValue(val);
			GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
			if ((Object)(object)val2 == (Object)null)
			{
				return;
			}
			if (MultiplayerClientPatches.IsHosting)
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<TurnManager>(out var instance) && instance.CurrentPlayerSlot > 0)
				{
					if (val2.activeInHierarchy)
					{
						val2.SetActive(false);
					}
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[ClientPatches] DrawBall postfix: hid ball '{((Object)val2).name}' (client's turn, slot {instance.CurrentPlayerSlot})");
					}
					return;
				}
			}
			if (!val2.activeInHierarchy)
			{
				val2.SetActive(true);
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)("[ClientPatches] DrawBall postfix: activated ball '" + ((Object)val2).name + "'"));
				}
			}
		}

		[HarmonyPatch(typeof(BattleController), "AttemptOrbDiscard")]
		[HarmonyPrefix]
		public static bool BattleController_AttemptOrbDiscard_Prefix()
		{
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return false;
			}
			if (!MultiplayerClientPatches.IsHosting)
			{
				return true;
			}
			if (MultiplayerClientPatches._executingPendingDiscard)
			{
				return true;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<TurnManager>(out var instance) && instance.CurrentPlayerSlot > 0)
			{
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(BattleController), "Awake")]
		[HarmonyPrefix]
		public static void BattleController_Awake_Prefix()
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected O, but got Unknown
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return;
			}
			PreInstancedPegboardData preInstancedPegboardData = StaticGameData.preInstancedPegboardData;
			if (preInstancedPegboardData != null)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					string[] obj = new string[5]
					{
						"[ClientPatches] Destroying preInstancedPegboardData on client (pegboard=",
						preInstancedPegboardData.pegboardData?.name,
						", root=",
						null,
						null
					};
					GameObject rootGameObject = preInstancedPegboardData.rootGameObject;
					obj[3] = ((rootGameObject != null) ? ((Object)rootGameObject).name : null);
					obj[4] = ")";
					logger.LogInfo((object)string.Concat(obj));
				}
				if ((Object)(object)preInstancedPegboardData.rootGameObject != (Object)null)
				{
					Object.DestroyImmediate((Object)(object)preInstancedPegboardData.rootGameObject);
				}
				StaticGameData.preInstancedPegboardData = null;
			}
			MapData dataToLoad = StaticGameData.dataToLoad;
			MapDataBattle val = (MapDataBattle)(object)((dataToLoad is MapDataBattle) ? dataToLoad : null);
			if ((Object)(object)val != (Object)null)
			{
				if ((Object)(object)((MapData)val).pegboardFrame == (Object)null)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)"[ClientPatches] pegboardFrame is null — creating dummy to prevent Awake crash");
					}
					((MapData)val).pegboardFrame = new GameObject("ClientDummyPegboardFrame");
				}
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					string[] obj2 = new string[9]
					{
						"[ClientPatches] Battle init: name=",
						((Object)val).name,
						", pegLayout=",
						null,
						null,
						null,
						null,
						null,
						null
					};
					PegLayout pegLayout = val.pegLayout;
					obj2[3] = ((pegLayout != null) ? ((Object)pegLayout).name : null);
					obj2[4] = ", pegboardFrame=";
					GameObject pegboardFrame = ((MapData)val).pegboardFrame;
					obj2[5] = ((pegboardFrame != null) ? ((Object)pegboardFrame).name : null);
					obj2[6] = ", ";
					object arg = val.starterSpawns?.Count ?? (-1);
					WaveGroup[] waveGroups = val.waveGroups;
					obj2[7] = $"starterSpawns={arg}, waves={((waveGroups != null) ? waveGroups.Length : (-1))}, ";
					object arg2 = val.NumberOfSlots;
					GameObject background = ((MapData)val).background;
					obj2[8] = string.Format("slots={0}, background={1}", arg2, ((background != null) ? ((Object)background).name : null) ?? "NULL");
					logger3.LogInfo((object)string.Concat(obj2));
				}
			}
			else
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)"[ClientPatches] dataToLoad is not MapDataBattle — BattleController.Awake may fail");
				}
			}
			if (string.IsNullOrEmpty(MultiplayerClientPatches.PendingBattleRngState))
			{
				return;
			}
			State? val2 = MultiplayerClientPatches.DeserializeRandomState(MultiplayerClientPatches.PendingBattleRngState);
			if (val2.HasValue)
			{
				Random.state = val2.Value;
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogInfo((object)"[ClientPatches] Restored host RNG state for pegboard generation");
				}
			}
			MultiplayerClientPatches.PendingBattleRngState = null;
		}

		[HarmonyPatch(typeof(BattleController), "Awake")]
		[HarmonyFinalizer]
		public static Exception BattleController_Awake_Finalizer(Exception __exception)
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			if (__exception == null)
			{
				return null;
			}
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return __exception;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogError((object)("[ClientPatches] BattleController.Awake CRASHED on client (swallowed):\n  " + __exception.GetType().Name + ": " + __exception.Message + "\n" + __exception.StackTrace));
			}
			try
			{
				BattleController.BattleActive = true;
				MapData dataToLoad = StaticGameData.dataToLoad;
				MapDataBattle val = (MapDataBattle)(object)((dataToLoad is MapDataBattle) ? dataToLoad : null);
				if (val?.starterSpawns != null)
				{
					Dictionary<string, GameObject> dictionary = AssetLoading.Instance?.EnemyPrefabs;
					if (dictionary != null)
					{
						int num = 0;
						foreach (StarterSpawn starterSpawn in val.starterSpawns)
						{
							try
							{
								if (starterSpawn?.spawnData?.enemyAssetReference == null)
								{
									continue;
								}
								string key = ((AssetReference)starterSpawn.spawnData.enemyAssetReference).RuntimeKey.ToString();
								if (!dictionary.ContainsKey(key))
								{
									GameObject val2 = ((AssetReference)starterSpawn.spawnData.enemyAssetReference).LoadAssetAsync<GameObject>().WaitForCompletion();
									if ((Object)(object)val2 != (Object)null)
									{
										dictionary[key] = val2;
										num++;
									}
								}
							}
							catch
							{
							}
						}
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogInfo((object)$"[ClientPatches] Recovery: loaded {num} enemy prefabs (cache={dictionary.Count})");
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogError((object)("[ClientPatches] Recovery failed: " + ex.Message));
				}
			}
			return null;
		}

		[HarmonyPatch(typeof(BattleController), "ResetField")]
		[HarmonyPrefix]
		public static bool BattleController_ResetField_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (LobbyUI.GameStartReceived && TurnChangeClientHandler.IsMyTurn)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(BattleController), "AddInitialCoinsToBoard")]
		[HarmonyPrefix]
		public static bool BattleController_AddInitialCoinsToBoard_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatches] Blocked AddInitialCoinsToBoard — host will send gold state");
			}
			return false;
		}

		[HarmonyPatch(typeof(BattleController), "HandlePegActivated")]
		[HarmonyPrefix]
		public static bool BattleController_HandlePegActivated_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(BattleController), "HandlePegActivated")]
		[HarmonyPostfix]
		public static void BattleController_HandlePegActivated_Postfix(BattleController __instance)
		{
			if (!MultiplayerClientPatches.IsHosting || !LobbyUI.GameStartReceived)
			{
				return;
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<CoopStateManager>(out var instance) || instance.TotalPlayerCount < 2 || !services.TryResolve<IGameEventRegistry>(out var instance2))
				{
					return;
				}
				int activePlayerSlot = instance.ActivePlayerSlot;
				FieldInfo fieldInfo = AccessTools.Field(typeof(BattleController), "_pegMultiplierDamageTally");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(BattleController), "_criticalHitCount");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(BattleController), "_damageMultiplier");
				FieldInfo fieldInfo4 = AccessTools.Field(typeof(BattleController), "_damageBonus");
				int num = ((fieldInfo != null) ? ((int)fieldInfo.GetValue(__instance)) : 0);
				int num2 = ((fieldInfo2 != null) ? ((int)fieldInfo2.GetValue(null)) : 0);
				float num3 = ((fieldInfo3 != null) ? ((float)fieldInfo3.GetValue(__instance)) : 1f);
				long num4 = ((fieldInfo4 != null) ? ((int)fieldInfo4.GetValue(__instance)) : 0);
				object? obj = AccessTools.Field(typeof(BattleController), "_attackManager")?.GetValue(__instance);
				AttackManager val = (AttackManager)((obj is AttackManager) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				long currentDamage = val.GetCurrentDamage(num, num3, num4, num2, false);
				if (num > CoopSubscriptions.HighWaterPegTally)
				{
					CoopSubscriptions.HighWaterPegTally = num;
				}
				if (currentDamage > CoopSubscriptions.HighWaterDamage)
				{
					CoopSubscriptions.HighWaterDamage = currentDamage;
				}
				if (currentDamage <= 0 && val.isHeal)
				{
					return;
				}
				bool isAoE = false;
				object? obj2 = AccessTools.Field(typeof(AttackManager), "_attack")?.GetValue(val);
				if (((obj2 is Attack) ? obj2 : null) is SimpleAttack)
				{
					isAoE = true;
				}
				string targetEnemyGuid = null;
				TargetingManager val2 = Object.FindObjectOfType<TargetingManager>();
				if ((Object)(object)((val2 != null) ? val2.currentTarget : null) != (Object)null && services.TryResolve<EnemyIdentifier>(out var instance3))
				{
					targetEnemyGuid = instance3.GetGuid(val2.currentTarget);
				}
				string text = $"Slot {activePlayerSlot}";
				if (instance.PlayerStates.TryGetValue(activePlayerSlot, out var value))
				{
					text = value.PlayerName ?? text;
				}
				List<PendingDamagePreviewEvent.DamageEntry> list = CoopSubscriptions.GetAccumulatedDamageEntries() ?? new List<PendingDamagePreviewEvent.DamageEntry>();
				bool flag = false;
				for (int i = 0; i < list.Count; i++)
				{
					if (list[i].SlotIndex == activePlayerSlot)
					{
						list[i] = new PendingDamagePreviewEvent.DamageEntry
						{
							SlotIndex = activePlayerSlot,
							PlayerName = text,
							Damage = currentDamage,
							TargetEnemyGuid = targetEnemyGuid,
							IsAoE = isAoE
						};
						flag = true;
						break;
					}
				}
				if (!flag)
				{
					list.Add(new PendingDamagePreviewEvent.DamageEntry
					{
						SlotIndex = activePlayerSlot,
						PlayerName = text,
						Damage = currentDamage,
						TargetEnemyGuid = targetEnemyGuid,
						IsAoE = isAoE
					});
				}
				instance2.Dispatch(new PendingDamagePreviewEvent
				{
					Entries = list
				});
				foreach (PendingDamagePreviewEvent.DamageEntry item in list)
				{
					PendingDamageOverlay.SetPlayerDamage(item.SlotIndex, item.PlayerName, item.Damage, item.TargetEnemyGuid, item.IsAoE);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopDmgOverlay] HandlePegActivated postfix failed: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(BattleController), "ShotFired")]
		[HarmonyPostfix]
		public static void BattleController_ShotFired_Postfix()
		{
			if (MultiplayerClientPatches.IsHosting)
			{
				CoopSubscriptions.HighWaterPegTally = 0;
				CoopSubscriptions.HighWaterDamage = 0L;
				CoopSubscriptions.MultiballSpawnCount = 0;
				MultiplayerClientPatches._shotFiredUnscaledTime = Time.unscaledTime;
				MultiplayerClientPatches._stuckCompletionSinceUnscaledTime = 0f;
				MultiplayerClientPatches._stuckCompletionScanTimer = 0f;
			}
		}

		[HarmonyPatch(typeof(PachinkoBall), "SpawnMultiball")]
		[HarmonyPostfix]
		public static void PachinkoBall_SpawnMultiball_Postfix()
		{
			if (MultiplayerClientPatches.IsHosting)
			{
				CoopSubscriptions.MultiballSpawnCount++;
			}
		}

		[HarmonyPatch(typeof(BattleController), "DoAttack")]
		[HarmonyPrefix]
		public static bool BattleController_DoAttack_Prefix(BattleController __instance)
		{
			if (!MultiplayerClientPatches.IsHosting)
			{
				return true;
			}
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			try
			{
				PendingDamageOverlay.ClearAll();
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IGameEventRegistry>(out var instance))
				{
					instance.Dispatch(new PendingDamagePreviewEvent());
				}
			}
			catch
			{
			}
			try
			{
				List<PlayerAttackData> list = CoopSubscriptions.ConsumeNonHostShotData();
				if (list == null || list.Count == 0)
				{
					return true;
				}
				IServiceContainer services2 = MultiplayerPlugin.Services;
				if (services2 == null || !services2.TryResolve<EnemyIdentifier>(out var instance2))
				{
					return true;
				}
				EnemyManager val = Object.FindObjectOfType<EnemyManager>();
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				object? obj2 = AccessTools.Field(typeof(BattleController), "_attackManager")?.GetValue(__instance);
				AttackManager val2 = (AttackManager)((obj2 is AttackManager) ? obj2 : null);
				FieldInfo fieldInfo = AccessTools.Field(typeof(AttackManager), "_isAttacking");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(AttackManager), "_attackAnimationFinished");
				if ((Object)(object)val2 != (Object)null)
				{
					fieldInfo?.SetValue(val2, true);
					fieldInfo2?.SetValue(val2, false);
				}
				MultiplayerClientPatches.SuppressOnAttackStartedDispatch = true;
				((MonoBehaviour)__instance).StartCoroutine(MultiplayerClientPatches.PlayCoopAttackSequence(__instance, val2, list, val, instance2));
				return false;
			}
			catch (Exception arg)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"[CoopAttack] Per-player damage resolution failed: {arg}");
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(BattleController), "Awake")]
		[HarmonyPostfix]
		public static void BattleController_Awake_Postfix()
		{
			if (!MultiplayerClientPatches.IsHosting || !LobbyUI.GameStartReceived)
			{
				return;
			}
			CoopSubscriptions instance = CoopSubscriptions.Instance;
			if (instance == null)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)"[ClientPatches] BattleController.Awake: CoopSubscriptions.Instance is null");
				}
				return;
			}
			instance.Subscribe();
			ManualLogSource logger2 = MultiplayerPlugin.Logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)"[ClientPatches] BattleController.Awake: re-subscribed CoopSubscriptions");
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<CoopStateManager>(out var instance2))
			{
				instance2.MergeBoardRelics();
			}
		}

		[HarmonyPatch(typeof(BattleController), "TriggerVictory")]
		[HarmonyPrefix]
		public static bool BattleController_TriggerVictory_Prefix()
		{
			if (!MultiplayerClientPatches.IsHosting)
			{
				return true;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<CoopStateManager>(out var instance))
			{
				return true;
			}
			if (instance.TotalPlayerCount < 2)
			{
				return true;
			}
			PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
			if ((Object)(object)val == (Object)null)
			{
				return true;
			}
			if (instance.AllPlayersDead)
			{
				try
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)"[ClientPatches] TriggerVictory: all players dead — routing to defeat instead of victory");
					}
					val.CheckForDeathAndUpdateBar();
				}
				catch (Exception ex)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)("[ClientPatches] TriggerVictory defeat route failed: " + ex.Message));
					}
				}
				return false;
			}
			if (val.CurrentHealth <= 0f)
			{
				try
				{
					object obj = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth")?.GetValue(val);
					obj?.GetType().GetMethod("Set", new Type[1] { typeof(float) })?.Invoke(obj, new object[1] { 1f });
					CoopPlayerState playerState = instance.GetPlayerState(0);
					if (playerState != null)
					{
						playerState.CurrentHealth = 1f;
					}
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogInfo((object)"[ClientPatches] TriggerVictory: host was dead but others alive — revived host PHC to 1 HP so victory fires");
					}
				}
				catch (Exception ex2)
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogWarning((object)("[ClientPatches] TriggerVictory host revive failed: " + ex2.Message));
					}
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(BattleController), "Update")]
		[HarmonyPrefix]
		public static void BattleController_Update_RoundCount_Prefix(out RoundCountSnapshot __state)
		{
			__state = default(RoundCountSnapshot);
			if (MultiplayerClientPatches.IsHosting && LobbyUI.GameStartReceived)
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<CoopStateManager>(out var instance) && instance.TotalPlayerCount >= 2)
				{
					__state.Engaged = true;
					__state.SavedRoundCount = BattleController.RoundCount;
					__state.SavedDelegate = BattleController.OnRoundCountIncremented;
					BattleController.OnRoundCountIncremented = null;
				}
			}
		}

		[HarmonyPatch(typeof(BattleController), "Update")]
		[HarmonyPostfix]
		public static void BattleController_Update_RoundCount_Postfix(RoundCountSnapshot __state)
		{
			if (!__state.Engaged)
			{
				return;
			}
			BattleController.OnRoundCountIncremented = __state.SavedDelegate;
			int roundCount = BattleController.RoundCount;
			if (roundCount == __state.SavedRoundCount)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			TurnManager instance = null;
			services?.TryResolve<TurnManager>(out instance);
			if (instance != null && instance.RoundNumber < _lastFiredCoopRound)
			{
				_lastFiredCoopRound = 0;
			}
			int num = instance?.RoundNumber ?? 0;
			if (num > _lastFiredCoopRound)
			{
				_lastFiredCoopRound = num;
				try
				{
					RoundCountIncremented savedDelegate = __state.SavedDelegate;
					if (savedDelegate != null)
					{
						savedDelegate.Invoke(roundCount);
					}
					return;
				}
				catch (Exception ex)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)("[CoopRoundCount] Delegate invoke failed: " + ex.Message));
					}
					return;
				}
			}
			AccessTools.Field(typeof(BattleController), "_roundCount")?.SetValue(null, __state.SavedRoundCount);
		}

		[HarmonyPatch(typeof(BattleController), "ThrowAllBombs")]
		[HarmonyPrefix]
		public static bool BattleController_ThrowAllBombs_Prefix(BattleController __instance, ref IEnumerator __result)
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			MultiplayerClientPatches._bombsRegularField?.SetValue(__instance, 0);
			MultiplayerClientPatches._bombsRiggedField?.SetValue(__instance, 0);
			__result = MultiplayerClientPatches.EmptyCoroutine();
			return false;
		}
	}
	[HarmonyPatch]
	internal static class BattleUpgradeCanvasPatches
	{
		[HarmonyPatch(typeof(BattleUpgradeCanvas), "AcceptRelic")]
		[HarmonyPostfix]
		public static void BattleUpgradeCanvas_AcceptRelic_Postfix(Relic relic)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected I4, but got Unknown
			//IL_003c: 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_0088: Expected I4, but got Unknown
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return;
			}
			if (MultiplayerClientPatches.AllowNativeRewardLogic)
			{
				MultiplayerClientPatches.ClientChosenPostBattleRelicEffect = (int)relic.effect;
				MultiplayerClientPatches.ClientChosenPostBattleRelicName = relic.locKey;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[ClientPatch] Client chose post-battle relic: '{relic.locKey}' (effect={relic.effect})");
				}
			}
			if (!MultiplayerClientPatches.AllowTreasureLogic || CoopRewardState.ClientTreasureChoiceSent)
			{
				return;
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMessageSender>(out var instance))
				{
					instance.Send(new TreasureCompleteEvent
					{
						ChosenRelicEffect = (int)relic.effect,
						ChosenRelicName = relic.locKey
					});
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)("[ClientPatch] Client accepted treasure relic '" + relic.locKey + "' — sent TreasureCompleteEvent"));
					}
				}
				CoopRewardState.ClientTreasureChoiceSent = true;
				CoopRewardState.WaitingForOtherPlayers = true;
				CoopRewardState.TreasurePhaseActive = true;
				CoopRewardState.AllChoicesComplete = false;
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogError((object)("[ClientPatch] Failed to send TreasureCompleteEvent: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(BattleUpgradeCanvas), "ConfigureForPostBattleRewards")]
		[HarmonyPostfix]
		public static void BattleUpgradeCanvas_ConfigureForPostBattleRewards_Postfix(BattleUpgradeCanvas __instance)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			try
			{
				if (!MultiplayerClientPatches.IsHosting || (Object)(object)StaticGameData.currentNode == (Object)null || (int)StaticGameData.currentNode.RoomType != 7)
				{
					return;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<CoopStateManager>(out var instance) || instance == null || instance.PlayerStates.Count == 0)
				{
					return;
				}
				object? obj = AccessTools.Field(typeof(BattleUpgradeCanvas), "_cruciballManager")?.GetValue(__instance);
				CruciballManager val = (CruciballManager)((obj is CruciballManager) ? obj : null);
				bool flag = (Object)(object)val != (Object)null && val.LessHealingFromBosses();
				instance.SaveActivePlayerState();
				int activePlayerSlot = instance.ActivePlayerSlot;
				List<PostBattleBossHealEvent.Entry> list = new List<PostBattleBossHealEvent.Entry>();
				foreach (KeyValuePair<int, CoopPlayerState> item in instance.PlayerStates.OrderBy((KeyValuePair<int, CoopPlayerState> p) => p.Key))
				{
					int key = item.Key;
					CoopPlayerState value = item.Value;
					if (value != null && !(value.MaxHealth <= 0f))
					{
						float currentHealth = value.CurrentHealth;
						if (key != activePlayerSlot)
						{
							float currentHealth2 = ((!flag) ? value.MaxHealth : Mathf.Min(value.MaxHealth, currentHealth + Mathf.Ceil(value.MaxHealth / 2f)));
							value.CurrentHealth = currentHealth2;
						}
						float num = value.CurrentHealth - currentHealth;
						if (!(num <= 0f))
						{
							list.Add(new PostBattleBossHealEvent.Entry
							{
								SlotIndex = key,
								NewCurrentHealth = value.CurrentHealth,
								MaxHealth = value.MaxHealth,
								HealedAmount = num
							});
						}
					}
				}
				if (list.Count != 0)
				{
					if (services.TryResolve<IGameEventRegistry>(out var instance2))
					{
						instance2.Dispatch(new PostBattleBossHealEvent
						{
							Entries = list
						});
					}
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[BossHeal] dispatched heal for {list.Count} slot(s); lessHealing={flag}");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[BossHeal] postfix failed: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(BattleUpgradeCanvas), "SetupRelicGrant")]
		[HarmonyPrefix]
		public static bool BattleUpgradeCanvas_SetupRelicGrant_ClientOverride_Prefix(BattleUpgradeCanvas __instance, RelicRarity rarity, bool isTreasure)
		{
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			//IL_0284: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Invalid comparison between Unknown and I4
			//IL_028d: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Invalid comparison between Unknown and I4
			//IL_0294: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Invalid comparison between Unknown and I4
			//IL_019b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0329: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Unknown result type (might be due to invalid IL or missing references)
			//IL_042e: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (!MultiplayerClientPatches.AllowTreasureLogic && !MultiplayerClientPatches.AllowNativeRewardLogic)
			{
				return true;
			}
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(BattleUpgradeCanvas), "_mainOptionsPanel");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(BattleUpgradeCanvas), "_relicPanel");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(BattleUpgradeCanvas), "_state");
				FieldInfo fieldInfo4 = AccessTools.Field(typeof(BattleUpgradeCanvas), "_relicGrantRarity");
				FieldInfo fieldInfo5 = AccessTools.Field(typeof(BattleUpgradeCanvas), "_relicManager");
				FieldInfo fieldInfo6 = AccessTools.Field(typeof(BattleUpgradeCanvas), "_relicSkipButtonGoldContainer");
				object? obj = fieldInfo?.GetValue(__instance);
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				object? obj2 = fieldInfo2?.GetValue(__instance);
				GameObject val2 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				object? obj3 = fieldInfo5?.GetValue(__instance);
				RelicManager val3 = (RelicManager)((obj3 is RelicManager) ? obj3 : null);
				if ((Object)(object)val2 == (Object)null)
				{
					return true;
				}
				if (val != null)
				{
					val.SetActive(false);
				}
				val2.SetActive(true);
				if (fieldInfo3 != null && fieldInfo3.FieldType.IsEnum)
				{
					try
					{
						fieldInfo3.SetValue(__instance, Enum.Parse(fieldInfo3.FieldType, "RELIC"));
					}
					catch
					{
					}
				}
				fieldInfo4?.SetValue(__instance, rarity);
				int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(MultiplayerPlugin.Services);
				RelicIcon[] componentsInChildren = val2.GetComponentsInChildren<RelicIcon>(true);
				if (isTreasure)
				{
					Relic val4 = null;
					string text = "host";
					if (localSlotIndex >= 0 && CoopRewardState.PerSlotTreasureRelics.TryGetValue(localSlotIndex, out var value))
					{
						val4 = MultiplayerClientPatches.FindRelicByName(value);
						if ((Object)(object)val4 == (Object)null)
						{
							text = "host(missing prefab, fallback)";
						}
					}
					if ((Object)(object)val4 == (Object)null)
					{
						val4 = MultiplayerClientPatches.PickRandomLocalRelic(rarity, val3, localSlotIndex);
						if (text == "host")
						{
							text = "local-slot-keyed";
						}
					}
					for (int i = 0; i < componentsInChildren.Length; i++)
					{
						if (i == 0 && (Object)(object)val4 != (Object)null)
						{
							componentsInChildren[i].SetRelic(val4);
							componentsInChildren[i].shouldShowTooltip = false;
							((Component)((Component)componentsInChildren[i]).transform.parent).gameObject.SetActive(true);
						}
						else
						{
							((Component)((Component)componentsInChildren[i]).transform.parent).gameObject.SetActive(false);
						}
					}
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)($"[ClientPatch] Treasure relic grant ({text}) slot={localSlotIndex} relic=" + string.Format("'{0}' rarity={1}", ((val4 != null) ? ((Object)val4).name : null) ?? "<none>", rarity)));
					}
					return false;
				}
				int num = 1;
				if ((int)rarity == 3)
				{
					num = 3;
				}
				else if ((int)rarity == 2)
				{
					num = 2;
				}
				if ((int)rarity == 3)
				{
					object? obj5 = fieldInfo6?.GetValue(__instance);
					object? obj6 = ((obj5 is GameObject) ? obj5 : null);
					if (obj6 != null)
					{
						((GameObject)obj6).SetActive(true);
					}
				}
				MapData dataToLoad = StaticGameData.dataToLoad;
				MapDataBattle val5 = (MapDataBattle)(object)((dataToLoad is MapDataBattle) ? dataToLoad : null);
				if ((Object)(object)val5 != (Object)null && ((Object)val5).name == "MimicMinibossMapData")
				{
					num++;
				}
				if ((Object)(object)val3 != (Object)null && val3.AttemptUseRelic((RelicEffect)60))
				{
					num++;
				}
				if ((Object)(object)val3 != (Object)null && val3.AttemptUseRelic((RelicEffect)97))
				{
					num++;
				}
				int slotIndex = ((localSlotIndex >= 0) ? localSlotIndex : 0);
				List<Relic> list = MultiplayerClientPatches.PickMultipleLocalRelics(rarity, num, val3, slotIndex);
				for (int j = 0; j < componentsInChildren.Length; j++)
				{
					if (j < list.Count && (Object)(object)list[j] != (Object)null)
					{
						componentsInChildren[j].SetRelic(list[j]);
						componentsInChildren[j].shouldShowTooltip = false;
						((Component)((Component)componentsInChildren[j]).transform.parent).gameObject.SetActive(true);
					}
					else
					{
						((Component)((Component)componentsInChildren[j]).transform.parent).gameObject.SetActive(false);
					}
				}
				List<string> list2 = new List<string>();
				foreach (Relic item in list)
				{
					list2.Add(((item != null) ? ((Object)item).name : null) ?? "<null>");
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)string.Format("[ClientPatch] Post-battle relic grant slot={0} rarity={1} count={2} relics=[{3}]", localSlotIndex, rarity, list.Count, string.Join(",", list2)));
				}
				return false;
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[ClientPatch] SetupRelicGrant client override failed, falling through: " + ex.Message));
				}
				return true;
			}
		}
	}
	[HarmonyPatch]
	internal static class ChestScenarioControllerPatches
	{
		[HarmonyPatch(typeof(ChestScenarioController), "HandlePegDestruction")]
		[HarmonyPrefix]
		public static bool ChestScenarioController_HandlePegDestruction_Prefix(ChestScenarioController __instance, PegType type)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Invalid comparison between Unknown and I4
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if ((int)type != 4)
			{
				return true;
			}
			FieldInfo fieldInfo = AccessTools.Field(typeof(ChestScenarioController), "_bombsRemaining");
			if (fieldInfo == null)
			{
				return true;
			}
			int num = (int)fieldInfo.GetValue(__instance);
			fieldInfo.SetValue(__instance, num - 1);
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)$"[ClientPatch] Coop: bonus-chest bomb suppressed (remaining {num - 1})");
			}
			return false;
		}

		[HarmonyPatch(typeof(ChestScenarioController), "OpenChest")]
		[HarmonyPrefix]
		public static bool ChestScenarioController_OpenChest_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTreasureLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked ChestScenarioController.OpenChest on client");
			}
			return false;
		}

		[HarmonyPatch(typeof(ChestScenarioController), "Skip")]
		[HarmonyPrefix]
		public static bool ChestScenarioController_Skip_Prefix(ChestScenarioController __instance)
		{
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				if (CoopRewardState.AllChoicesComplete || CoopNavigateState.PhaseActive || CoopNavigateState.Resolved)
				{
					MultiplayerClientPatches.AllowTreasureLogic = false;
					return false;
				}
				if (!CoopRewardState.ClientTreasureChoiceSent)
				{
					try
					{
						IServiceContainer services = MultiplayerPlugin.Services;
						if (services != null && services.TryResolve<IMessageSender>(out var instance))
						{
							instance.Send(new TreasureCompleteEvent
							{
								ChosenRelicEffect = -1,
								ChosenRelicName = null
							});
							ManualLogSource logger = MultiplayerPlugin.Logger;
							if (logger != null)
							{
								logger.LogInfo((object)"[ClientPatch] Client skipped treasure relic — sent TreasureCompleteEvent");
							}
						}
						CoopRewardState.ClientTreasureChoiceSent = true;
					}
					catch (Exception ex)
					{
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogError((object)("[ClientPatch] Failed to send TreasureCompleteEvent: " + ex.Message));
						}
					}
				}
				MultiplayerClientPatches.AllowTreasureLogic = false;
				CoopRewardState.WaitingForOtherPlayers = true;
				CoopRewardState.TreasurePhaseActive = true;
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)"[ClientPatch] Client finished treasure — waiting for other players");
				}
				return false;
			}
			if (MultiplayerClientPatches.IsHosting && CoopRewardState.TreasurePhaseActive)
			{
				CoopRewardState.HostTreasureDone = true;
				if (CoopRewardState.AllClientTreasureChoicesReceived)
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogInfo((object)"[ClientPatch] Host Skip — all clients done, proceeding");
					}
					CoopRewardState.TreasurePhaseActive = false;
					CoopRewardState.WaitingForOtherPlayers = false;
					IServiceContainer services2 = MultiplayerPlugin.Services;
					if (services2 != null && services2.TryResolve<IGameEventRegistry>(out var instance2))
					{
						instance2.Dispatch(new AllChoicesCompleteEvent
						{
							Phase = "treasure"
						});
					}
					return true;
				}
				CoopRewardState.PendingChestController = __instance;
				CoopRewardState.WaitingForOtherPlayers = true;
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogInfo((object)"[ClientPatch] Host Skip — waiting for other players to finish treasure");
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class CoopAct4ContinuePatch
	{
		private static bool IsMultiplayer
		{
			get
			{
				if (MultiplayerPlugin.Services == null)
				{
					return false;
				}
				if (!MultiplayerPlugin.Services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return false;
				}
				if (!instance.IsHosting)
				{
					return instance.IsSpectating;
				}
				return true;
			}
		}

		[HarmonyPatch(typeof(ChallengeManager), "IsAct4Unlocked")]
		[HarmonyPostfix]
		private static void ForceAct4Unlocked(ref bool __result)
		{
			if (IsMultiplayer)
			{
				__result = true;
			}
		}

		[HarmonyPatch(typeof(PostBattleController), "OnEnable")]
		[HarmonyPostfix]
		private static void AutoContinueToCore(PostBattleController __instance)
		{
			if (!IsMultiplayer || !__instance.showGoToCoreOption)
			{
				return;
			}
			try
			{
				((MonoBehaviour)__instance).StopAllCoroutines();
				__instance.showGoToCoreOption = false;
				__instance.GoToCoreButtonPressed();
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[CoopAct4] Skipped Act 3 -> Core choice; auto-continuing to The Core");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[CoopAct4] Auto-continue failed: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class CoopNavigatePatches
	{
		[HarmonyPatch(typeof(PostBattleController), "HandleSlotTriggerActivated")]
		[HarmonyPrefix]
		public static bool PostBattle_HandleSlot_Prefix(int index, PachinkoBall pBall)
		{
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (!CoopNavigateState.PhaseActive || CoopNavigateState.Resolved)
			{
				return true;
			}
			if ((Object)(object)pBall != (Object)null && pBall.IsDummy)
			{
				return false;
			}
			if (CoopNavigateState.LocalVoteCast)
			{
				return false;
			}
			int num;
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				MapNode currentNode = StaticGameData.currentNode;
				num = ((currentNode == null) ? null : currentNode.ChildNodes?.Length) ?? CoopNavigateState.ChildNodeCount;
			}
			else
			{
				num = CoopNavigateState.ChildNodeCount;
			}
			int num2 = num;
			int num3 = ResolvePostBattleChildIndex(index, num2);
			if (num3 < 0)
			{
				if (MultiplayerClientPatches.ShouldSuppressClientLogic)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[CoopNavigate] Client miss: triggerIndex={index}, childCount={num2}");
					}
					SafeDestroyBall(pBall);
					return false;
				}
				return true;
			}
			SubmitVote(num3);
			LockBattleNavigationComplete();
			return false;
		}

		private static int ResolvePostBattleChildIndex(int triggerIndex, int childCount)
		{
			if (childCount == 1)
			{
				if (triggerIndex <= 0 || triggerIndex >= 4)
				{
					return -1;
				}
				return 0;
			}
			if (childCount > 1)
			{
				if (triggerIndex < 2)
				{
					return 0;
				}
				if (triggerIndex > 2)
				{
					return childCount - 1;
				}
				if (childCount > 2)
				{
					return 1;
				}
				return -1;
			}
			return -1;
		}

		[HarmonyPatch(typeof(NavOnlyController), "HandleSlotTriggerActivated")]
		[HarmonyPrefix]
		public static bool NavOnly_HandleSlot_Prefix(NavOnlyController __instance, int index, PachinkoBall pBall)
		{
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (!CoopNavigateState.PhaseActive || CoopNavigateState.Resolved)
			{
				return true;
			}
			if ((Object)(object)pBall != (Object)null && pBall.IsDummy)
			{
				return false;
			}
			if (CoopNavigateState.LocalVoteCast)
			{
				return false;
			}
			int num;
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				MapNode currentNode = StaticGameData.currentNode;
				num = ((currentNode == null) ? null : currentNode.ChildNodes?.Length) ?? CoopNavigateState.ChildNodeCount;
			}
			else
			{
				num = CoopNavigateState.ChildNodeCount;
			}
			int childCount = num;
			int num2 = ResolveNavOnlyChildIndex(index, childCount);
			if (num2 < 0)
			{
				if (MultiplayerClientPatches.ShouldSuppressClientLogic)
				{
					SafeDestroyBall(pBall);
					return false;
				}
				return true;
			}
			SubmitVote(num2);
			LockNavOnlyStarted(__instance);
			return false;
		}

		private static int ResolveNavOnlyChildIndex(int triggerIndex, int childCount)
		{
			if (childCount <= 0)
			{
				return -1;
			}
			if (triggerIndex < 2)
			{
				return 0;
			}
			if (triggerIndex > 2)
			{
				return childCount - 1;
			}
			if (childCount == 1)
			{
				return 0;
			}
			return -1;
		}

		private static void SubmitVote(int childIndex)
		{
			CoopNavigateState.LocalVoteCast = true;
			if (MultiplayerClientPatches.IsHosting)
			{
				CoopNavigateResolver.RecordHostVote(childIndex);
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<IMessageSender>(out var instance))
			{
				instance.Send(new NavigateVoteEvent
				{
					ChildIndex = childIndex
				});
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopNavigate] Client sent vote: child={childIndex}");
				}
			}
		}

		private static void SafeDestroyBall(PachinkoBall pBall)
		{
			try
			{
				if (pBall != null)
				{
					pBall.StartDestroy();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopNavigate] StartDestroy failed: " + ex.Message));
				}
			}
		}

		private static void LockBattleNavigationComplete()
		{
			try
			{
				BattleController.CurrentBattleState = (BattleState)10;
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopNavigate] LockBattleNavigationComplete failed: " + ex.Message));
				}
			}
		}

		private static void LockNavOnlyStarted(NavOnlyController noc)
		{
			try
			{
				AccessTools.Field(typeof(NavOnlyController), "_navStarted")?.SetValue(noc, true);
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopNavigate] LockNavOnlyStarted failed: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(NavOnlyController), "PrepareForNavigation")]
		[HarmonyPostfix]
		public static void NavOnlyController_PrepareForNavigation_Postfix(NavOnlyController __instance)
		{
			if (LobbyUI.GameStartReceived && MultiplayerClientPatches.IsHosting && !CoopNavigateState.PhaseActive)
			{
				MapNode currentNode = StaticGameData.currentNode;
				int num = ((currentNode == null) ? null : currentNode.ChildNodes?.Length).GetValueOrDefault(1);
				if (num < 1)
				{
					num = 1;
				}
				CoopNavigateResolver.StartPhase("nav_only", num, CoopNavigateResolver.CaptureChildRoomTypes());
			}
		}

		[HarmonyPatch(typeof(PachinkoBall), "Fire")]
		[HarmonyPrefix]
		[HarmonyPriority(500)]
		public static bool PachinkoBall_Fire_NavigateGuard(PachinkoBall __instance)
		{
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (!CoopNavigateState.PhaseActive)
			{
				return true;
			}
			if (CoopNavigateState.LocalVoteCast || CoopNavigateState.Resolved)
			{
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class CurrencyManagerPatches
	{
		[HarmonyPatch(typeof(CurrencyManager), "AddGold")]
		[HarmonyPrefix]
		public static bool CurrencyManager_AddGold_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowCurrencySync)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowNativeRewardLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowShopLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTreasureLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(CurrencyManager), "RemoveGold")]
		[HarmonyPrefix]
		public static bool CurrencyManager_RemoveGold_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowCurrencySync)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowNativeRewardLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowShopLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked CurrencyManager.RemoveGold on client");
			}
			return false;
		}

		[HarmonyPatch(typeof(CurrencyManager), "RemoveGold")]
		[HarmonyPostfix]
		public static void CurrencyManager_RemoveGold_Postfix(int amount)
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic || !MultiplayerClientPatches.AllowNativeRewardLogic || MultiplayerClientPatches.AllowCurrencySync || amount <= 0)
			{
				return;
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMessageSender>(out var sender))
				{
					return;
				}
				PostBattleGoldSpentEvent evt = new PostBattleGoldSpentEvent
				{
					Amount = amount
				};
				MainThreadDispatcher instance = MainThreadDispatcher.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					instance.Enqueue(delegate
					{
						try
						{
							PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
							evt.CurrentHealth = (((Object)(object)val != (Object)null) ? val.CurrentHealth : (-1f));
							evt.MaxHealth = (((Object)(object)val != (Object)null) ? val.MaxHealth : 0f);
							sender.Send(evt);
							ManualLogSource logger2 = MultiplayerPlugin.Logger;
							if (logger2 != null)
							{
								logger2.LogInfo((object)$"[ClientPatch] Sent PostBattleGoldSpentEvent amount={evt.Amount} hp={evt.CurrentHealth}/{evt.MaxHealth}");
							}
						}
						catch (Exception ex2)
						{
							ManualLogSource logger3 = MultiplayerPlugin.Logger;
							if (logger3 != null)
							{
								logger3.LogWarning((object)("[ClientPatch] Deferred send failed: " + ex2.Message));
							}
						}
					});
				}
				else
				{
					evt.CurrentHealth = -1f;
					sender.Send(evt);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[ClientPatch] Failed to send PostBattleGoldSpentEvent: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class DamageCountDisplayPatches
	{
		[HarmonyPatch(typeof(DamageCountDisplay), "CreateText")]
		[HarmonyPostfix]
		public static void DamageCountDisplay_CreateText_Postfix(string textOrLocKey, Vector2 position, Color color)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: 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_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: Unknown result type (might be due to invalid IL or missing references)
			if (MultiplayerClientPatches.IsHosting && MultiplayerPlugin.Services != null && MultiplayerPlugin.Services.TryResolve<IGameEventRegistry>(out var instance))
			{
				instance.Dispatch(new DamageTextEvent
				{
					Text = textOrLocKey,
					PosX = position.x,
					PosY = position.y,
					R = color.r,
					G = color.g,
					B = color.b,
					A = color.a
				});
			}
		}

		[HarmonyPatch(typeof(DamageCountDisplay), "DisplayDamage")]
		[HarmonyPrefix]
		public static bool DamageCountDisplay_DisplayDamage_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch]
	public static class DebugForceLevel
	{
		private static Scene? _forcedScene;

		private static int? _forcedFloorCount;

		private static string _forcedSeed;

		private static bool _parsed;

		private static void Parse()
		{
			if (_parsed)
			{
				return;
			}
			_parsed = true;
			string environmentVariable = Environment.GetEnvironmentVariable("PEGLIN_MULTI_DEBUG_FORCE_LEVEL");
			if (!string.IsNullOrEmpty(environmentVariable))
			{
				string[] array = environmentVariable.Split('-');
				if (int.TryParse(array[0], out var result))
				{
					_forcedScene = result switch
					{
						1 => (Scene)3, 
						2 => (Scene)5, 
						3 => (Scene)7, 
						4 => (Scene)15, 
						_ => null, 
					};
					if (array.Length > 1 && int.TryParse(array[1], out var result2))
					{
						_forcedFloorCount = result2;
					}
					if (_forcedScene.HasValue)
					{
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)string.Format("[DebugForceLevel] Forcing start scene to {0} (floor={1})", _forcedScene, _forcedFloorCount?.ToString() ?? "default"));
						}
					}
				}
			}
			_forcedSeed = Environment.GetEnvironmentVariable("PEGLIN_SEED");
			if (!string.IsNullOrEmpty(_forcedSeed))
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)("[DebugForceLevel] Forcing seed to '" + _forcedSeed + "'"));
				}
			}
		}

		[HarmonyPatch(typeof(GameInit), "Start")]
		[HarmonyPrefix]
		public static void GameInit_Start_Prefix()
		{
			Parse();
			if (!string.IsNullOrEmpty(_forcedSeed))
			{
				StaticGameData.currentSeed = _forcedSeed;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)("[DebugForceLevel] Set StaticGameData.currentSeed = '" + _forcedSeed + "'"));
				}
			}
		}

		[HarmonyPatch(typeof(GameInit), "LoadMapScene")]
		[HarmonyPrefix]
		public static void GameInit_LoadMapScene_Prefix(LoadMapData ___LoadData)
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			Parse();
			if (!_forcedScene.HasValue || (Object)(object)___LoadData == (Object)null)
			{
				return;
			}
			if (ContinueSession.IsActive)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[DebugForceLevel] Continue is active (saved scene={___LoadData.SceneToLoad}); skipping force-level override");
				}
			}
			else
			{
				___LoadData.SceneToLoad = _forcedScene.Value;
				if (_forcedFloorCount.HasValue)
				{
					StaticGameData.totalFloorCount = _forcedFloorCount.Value;
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class DeckInfoManagerPatches
	{
		[HarmonyPatch(typeof(DeckInfoManager), "StartShuffleAnimation")]
		[HarmonyPrefix]
		public static bool DeckInfoManager_StartShuffleAnimation_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatches] Blocked StartShuffleAnimation on client — host controls deck visuals");
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class DeckManagerPatches
	{
		[HarmonyPatch(typeof(DeckManager), "DrawBall")]
		[HarmonyPrefix]
		public static bool DeckManager_DrawBall_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (LobbyUI.GameStartReceived && TurnChangeClientHandler.IsMyTurn)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(DeckManager), "ShuffleBattleDeck")]
		[HarmonyPrefix]
		public static bool DeckManager_ShuffleBattleDeck_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (LobbyUI.GameStartReceived && TurnChangeClientHandler.IsMyTurn)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(DeckManager), "UpgradeSpecificOrb")]
		[HarmonyPostfix]
		public static void DeckManager_UpgradeSpecificOrb_SharePostfix(GameObject toUpgrade, GameObject __result)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.IsHosting)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name != "TextScenario" || (Object)(object)__result == (Object)null || CoopRewardState.TextScenarioPhaseActive)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<CoopStateManager>(out var instance) || instance.TotalPlayerCount < 2)
			{
				return;
			}
			try
			{
				instance.SaveActivePlayerState();
				foreach (KeyValuePair<int, CoopPlayerState> playerState in instance.PlayerStates)
				{
					if (playerState.Key == instance.ActivePlayerSlot)
					{
						continue;
					}
					List<int> list = new List<int>();
					for (int i = 0; i < playerState.Value.CompleteDeck.Count; i++)
					{
						SerializedOrb serializedOrb = playerState.Value.CompleteDeck[i];
						try
						{
							AssetLoading instance2 = AssetLoading.Instance;
							GameObject val = ((instance2 != null) ? instance2.GetOrbPrefab(serializedOrb.PrefabName) : null);
							if ((Object)(object)val != (Object)null && (Object)(object)val.GetComponent<Attack>()?.NextLevelPrefab != (Object)null)
							{
								list.Add(i);
							}
						}
						catch
						{
						}
					}
					if (list.Count == 0)
					{
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)$"[CoopReward] TextScenario: slot {playerState.Key} has no upgradeable orbs");
						}
						continue;
					}
					int index = list[Random.Range(0, list.Count)];
					SerializedOrb serializedOrb2 = playerState.Value.CompleteDeck[index];
					try
					{
						AssetLoading instance3 = AssetLoading.Instance;
						GameObject obj2 = ((instance3 != null) ? instance3.GetOrbPrefab(serializedOrb2.PrefabName) : null);
						GameObject val2 = ((obj2 == null) ? null : obj2.GetComponent<Attack>()?.NextLevelPrefab);
						if ((Object)(object)val2 != (Object)null)
						{
							string text = ((Object)val2).name.Replace("(Clone)", string.Empty).Trim();
							int level = val2.GetComponent<Attack>()?.Level ?? (serializedOrb2.Level + 1);
							playerState.Value.CompleteDeck[index] = new SerializedOrb
							{
								PrefabName = text,
								Guid = serializedOrb2.Guid,
								Level = level
							};
							ManualLogSource logger2 = MultiplayerPlugin.Logger;
							if (logger2 != null)
							{
								logger2.LogInfo((object)$"[CoopReward] TextScenario: upgraded orb '{serializedOrb2.PrefabName}' → '{text}' for slot {playerState.Key}");
							}
						}
					}
					catch (Exception ex)
					{
						ManualLogSource logger3 = MultiplayerPlugin.Logger;
						if (logger3 != null)
						{
							logger3.LogWarning((object)$"[CoopReward] TextScenario: orb upgrade failed for slot {playerState.Key}: {ex.Message}");
						}
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("[CoopReward] TextScenario orb upgrade sharing failed: " + ex2.Message));
				}
			}
		}

		[HarmonyPatch(typeof(DeckManager), "ShuffleCompleteDeck")]
		[HarmonyPrefix]
		public static bool DeckManager_ShuffleCompleteDeck_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (LobbyUI.GameStartReceived && TurnChangeClientHandler.IsMyTurn)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked DeckManager.ShuffleCompleteDeck on client");
			}
			return false;
		}

		[HarmonyPatch(typeof(DeckManager), "AddOrbToDeck")]
		[HarmonyPrefix]
		public static bool DeckManager_AddOrbToDeck_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowNativeRewardLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowShopLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowPegMinigameLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked DeckManager.AddOrbToDeck on client");
			}
			return false;
		}

		[HarmonyPatch(typeof(DeckManager), "RemoveOrbFromBattleDeck")]
		[HarmonyPrefix]
		public static bool DeckManager_RemoveOrbFromBattleDeck_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked DeckManager.RemoveOrbFromBattleDeck on client");
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class DialogueManagerPatches
	{
		[HarmonyPatch(typeof(DialogueManager), "StartConversation", new Type[]
		{
			typeof(string),
			typeof(Transform),
			typeof(Transform),
			typeof(int)
		})]
		[HarmonyPrefix]
		public static bool DialogueManager_StartConversation_Prefix()
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatch] ALLOWING StartConversation on client (native dialogue UI)");
				}
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class DialogueSystemScenarioPatches
	{
		[HarmonyPatch(typeof(DialogueSystemScenario), "DisableFadeCurtain")]
		[HarmonyPrefix]
		public static bool DialogueSystemScenario_DisableFadeCurtain_Prefix()
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatch] ALLOWING DisableFadeCurtain on client (native dialogue UI)");
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(DialogueSystemScenario), "ConversationEnded")]
		[HarmonyPrefix]
		public static bool DialogueSystemScenario_ConversationEnded_Prefix(DialogueSystemScenario __instance)
		{
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				if (MultiplayerClientPatches.AllowTextScenarioLogic)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)"[ClientPatch] ALLOWING DialogueSystemScenario.ConversationEnded (AllowTextScenarioLogic)");
					}
					MultiplayerClientPatches.CaptureAndSendTextScenarioState();
					return false;
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)"[ClientPatch] Blocked DialogueSystemScenario.ConversationEnded (spectating)");
				}
				return false;
			}
			if (MultiplayerClientPatches.IsHosting && CoopRewardState.TextScenarioPhaseActive)
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<CoopStateManager>(out var instance))
				{
					instance.SaveActivePlayerState();
				}
				CoopRewardState.HostTextScenarioDone = true;
				if (CoopRewardState.AllClientTextScenarioChoicesReceived)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogInfo((object)"[ClientPatch] Host ConversationEnded — all clients done, proceeding");
					}
					CoopRewardState.TextScenarioPhaseActive = false;
					CoopRewardState.WaitingForOtherPlayers = false;
					if (services != null && services.TryResolve<IGameEventRegistry>(out var instance2))
					{
						instance2.Dispatch(new AllChoicesCompleteEvent
						{
							Phase = "text_scenario"
						});
					}
					return true;
				}
				CoopRewardState.PendingDialogueSystemScenario = __instance;
				CoopRewardState.WaitingForOtherPlayers = true;
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogInfo((object)"[ClientPatch] Host ConversationEnded — waiting for other players to finish TextScenario");
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(DialogueSystemScenario), "ShouldSkipNavigation")]
		[HarmonyPrefix]
		public static bool DialogueSystemScenario_ShouldSkipNavigation_Prefix(ref bool __result)
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			__result = false;
			return false;
		}

		[HarmonyPatch(typeof(DialogueSystemScenario), "StartNavigation")]
		[HarmonyPrefix]
		public static bool DialogueSystemScenario_StartNavigation_Prefix()
		{
			if (MultiplayerClientPatches.IsHosting)
			{
				TextScenarioHoverTracker.IsNavigating = true;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatches] Host TextScenario navigation started");
				}
				return true;
			}
			if (MultiplayerClientPatches.ShouldSuppressClientLogic && !MultiplayerClientPatches.AllowTextScenarioNavigation)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)"[ClientPatch] Blocked DialogueSystemScenario.StartNavigation (spectating)");
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class EnemyInfoManagerPatches
	{
		[HarmonyPatch(typeof(EnemyInfoManager), "Initialize")]
		[HarmonyPrefix]
		public static bool EnemyInfoManager_Initialize_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatches] Blocked EnemyInfoManager.Initialize — host will send upcoming enemies");
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class EnemyManagerPatches
	{
		[HarmonyPatch(typeof(EnemyManager), "AddStarterEnemies")]
		[HarmonyPrefix]
		public static bool EnemyManager_AddStarterEnemies_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatches] Blocked AddStarterEnemies — host will send enemies");
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class EnemyPatches
	{
		[HarmonyPatch(typeof(Enemy), "ApplyStatusEffect")]
		[HarmonyPrefix]
		public static bool Enemy_ApplyStatusEffect_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return MultiplayerClientPatches.AllowStatusEffectSync;
		}

		[HarmonyPatch(typeof(Enemy), "SpawnFloatingText")]
		[HarmonyPostfix]
		public static void Enemy_SpawnFloatingText_Postfix(Enemy __instance, long damage, Color color, EnemyDamageSource damageSource, float damageMod)
		{
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.IsHosting || MultiplayerPlugin.Services == null || !MultiplayerPlugin.Services.TryResolve<IGameEventRegistry>(out var instance))
			{
				return;
			}
			object? obj = typeof(Enemy).GetField("_exampleFloatingText", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance);
			FloatingText val = (FloatingText)((obj is FloatingText) ? obj : null);
			if (!((Object)(object)val == (Object)null))
			{
				Vector3 position = ((Component)val).transform.position;
				string text = DamageCountDisplay.FormatDamageNumberAsString(damage);
				if (damageMod > 1f)
				{
					text = "<style=enemyBonusDmg>" + text + "x" + damageMod + "</style>";
				}
				else if (damageMod < 1f)
				{
					text = "<style=enemyNegDmg>" + text + "x" + damageMod + "</style>";
				}
				instance.Dispatch(new DamageTextEvent
				{
					Text = text,
					PosX = position.x,
					PosY = position.y,
					R = color.r,
					G = color.g,
					B = color.b,
					A = color.a
				});
			}
		}

		[HarmonyPatch(typeof(Enemy), "Damage")]
		[HarmonyPrefix]
		public static bool Enemy_Damage_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class GameInitPatches
	{
		[HarmonyPatch(typeof(GameInit), "Start")]
		[HarmonyPrefix]
		public static bool GameInit_Start_Prefix()
		{
			if (LobbyUI.GameStartReceived)
			{
				return true;
			}
			return !MultiplayerClientPatches.ShouldSuppressClientLogic;
		}

		[HarmonyPatch(typeof(GameInit), "Start")]
		[HarmonyPostfix]
		public static void GameInit_Start_Postfix(GameInit __instance)
		{
			//IL_0c24: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c2e: Expected I4, but got Unknown
			//IL_0c41: Unknown result type (might be due to invalid IL or missing references)
			//IL_0c4b: Expected I4, but got Unknown
			//IL_0df3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0dfd: Expected I4, but got Unknown
			//IL_0e10: Unknown result type (might be due to invalid IL or missing references)
			//IL_0e1a: Expected I4, but got Unknown
			//IL_09e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_04d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0420: Unknown result type (might be due to invalid IL or missing references)
			//IL_0425: Unknown result type (might be due to invalid IL or missing references)
			//IL_0437: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_0443: Unknown result type (might be due to invalid IL or missing references)
			//IL_05eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_0491: Unknown result type (might be due to invalid IL or missing references)
			//IL_0493: Unknown result type (might be due to invalid IL or missing references)
			//IL_0498: Unknown result type (might be due to invalid IL or missing references)
			//IL_049c: Unknown result type (might be due to invalid IL or missing references)
			//IL_05ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_065a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0664: Expected I4, but got Unknown
			//IL_067d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0687: Expected I4, but got Unknown
			if (!LobbyUI.GameStartReceived)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<CoopStateManager>(out var instance))
			{
				return;
			}
			CoopRewardState.Reset();
			GameStartEvent latestGameStartEvent = LobbyUI.LatestGameStartEvent;
			if (latestGameStartEvent?.FinalPlayers != null)
			{
				bool flag = instance.TotalPlayerCount != latestGameStartEvent.FinalPlayers.Count;
				if (!flag)
				{
					foreach (LobbyPlayerEntry finalPlayer in latestGameStartEvent.FinalPlayers)
					{
						CoopPlayerState playerState = instance.GetPlayerState(finalPlayer.SlotIndex);
						if (playerState == null || !playerState.IsInitialized)
						{
							flag = true;
							break;
						}
					}
				}
				if (flag)
				{
					foreach (LobbyPlayerEntry finalPlayer2 in latestGameStartEvent.FinalPlayers)
					{
						instance.InitializePlayer(finalPlayer2.SlotIndex, finalPlayer2.ChosenClass, finalPlayer2.PlayerName);
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)$"[ClientPatches] Initialized coop player: slot={finalPlayer2.SlotIndex}, name={finalPlayer2.PlayerName}, class={finalPlayer2.ChosenClass}");
						}
					}
				}
				else
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)$"[ClientPatches] Players already initialized ({instance.TotalPlayerCount}), re-capturing state");
					}
				}
				if (MultiplayerClientPatches.IsHosting)
				{
					DebugStartingDeck.TryGrantHostDebugOrbs();
				}
				instance.CaptureInitialState(0);
				instance.ActivePlayerSlot = 0;
				CoopPlayerState playerState2 = instance.GetPlayerState(0);
				if (playerState2 != null && playerState2.MaxHealth <= 0f)
				{
					try
					{
						FloatVariable playerHealth = __instance.playerHealth;
						float num = ((playerHealth != null) ? playerHealth.Value : 0f);
						FloatVariable maxPlayerHealth = __instance.maxPlayerHealth;
						float num2 = ((maxPlayerHealth != null) ? maxPlayerHealth.Value : 0f);
						if (num2 > 0f)
						{
							playerState2.CurrentHealth = num;
							playerState2.MaxHealth = num2;
							ManualLogSource logger3 = MultiplayerPlugin.Logger;
							if (logger3 != null)
							{
								logger3.LogInfo((object)$"[ClientPatches] Health from GameInit FloatVars: hp={num}/{num2}");
							}
						}
					}
					catch (Exception ex)
					{
						ManualLogSource logger4 = MultiplayerPlugin.Logger;
						if (logger4 != null)
						{
							logger4.LogWarning((object)("[ClientPatches] Failed to read health from GameInit: " + ex.Message));
						}
					}
				}
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogInfo((object)("[ClientPatches] Coop: captured host initial state, ActivePlayerSlot=0, " + $"{latestGameStartEvent.FinalPlayers.Count} players, hp={playerState2?.CurrentHealth}/{playerState2?.MaxHealth}, " + $"deck={playerState2?.CompleteDeck.Count}"));
				}
				foreach (LobbyPlayerEntry finalPlayer3 in latestGameStartEvent.FinalPlayers)
				{
					if (finalPlayer3.IsHost)
					{
						continue;
					}
					CoopPlayerState playerState3 = instance.GetPlayerState(finalPlayer3.SlotIndex);
					if (playerState3 == null)
					{
						continue;
					}
					if (playerState3.IsInitialized && playerState3.CompleteDeck.Count > 0)
					{
						ManualLogSource logger6 = MultiplayerPlugin.Logger;
						if (logger6 != null)
						{
							logger6.LogInfo((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex} already initialized with {playerState3.CompleteDeck.Count} orbs, skipping re-init");
						}
						continue;
					}
					float num3;
					if (playerState2 == null)
					{
						FloatVariable maxPlayerHealth2 = __instance.maxPlayerHealth;
						num3 = ((maxPlayerHealth2 != null) ? maxPlayerHealth2.Value : 0f);
					}
					else
					{
						num3 = playerState2.MaxHealth;
					}
					float maxHealth = (playerState3.CurrentHealth = num3);
					playerState3.MaxHealth = maxHealth;
					Class val = (Class)finalPlayer3.ChosenClass;
					ClassLoadoutPairs[] classLoadouts = StaticGameData.classLoadouts;
					ClassLoadoutData val2 = null;
					if (classLoadouts != null)
					{
						ManualLogSource logger7 = MultiplayerPlugin.Logger;
						if (logger7 != null)
						{
							logger7.LogInfo((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex}: searching {classLoadouts.Length} classLoadouts for class {val} (int={finalPlayer3.ChosenClass})");
						}
						ClassLoadoutPairs[] array = classLoadouts;
						foreach (ClassLoadoutPairs val3 in array)
						{
							ManualLogSource logger8 = MultiplayerPlugin.Logger;
							if (logger8 != null)
							{
								logger8.LogInfo((object)$"[ClientPatches]   classLoadout: {val3.Class} orbs={(val3.Loadout?.StartingOrbs?.Count).GetValueOrDefault()}");
							}
							if (val3.Class == val)
							{
								val2 = val3.Loadout;
								break;
							}
						}
					}
					else
					{
						ManualLogSource logger9 = MultiplayerPlugin.Logger;
						if (logger9 != null)
						{
							logger9.LogWarning((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex}: StaticGameData.classLoadouts is NULL — cannot look up {val}");
						}
					}
					if (val2?.StartingOrbs != null)
					{
						playerState3.CompleteDeck.Clear();
						foreach (GameObject startingOrb in val2.StartingOrbs)
						{
							if (!((Object)(object)startingOrb == (Object)null))
							{
								playerState3.CompleteDeck.Add(new SerializedOrb
								{
									PrefabName = ((Object)startingOrb).name,
									Level = 0
								});
							}
						}
						string arg = string.Join(", ", playerState3.CompleteDeck.Select((SerializedOrb o) => o.PrefabName));
						ManualLogSource logger10 = MultiplayerPlugin.Logger;
						if (logger10 != null)
						{
							logger10.LogInfo((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex}: built deck from {val} ClassLoadoutData: [{arg}]");
						}
					}
					else
					{
						ManualLogSource logger11 = MultiplayerPlugin.Logger;
						if (logger11 != null)
						{
							logger11.LogWarning((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex}: ClassLoadoutData for {val} has NO StartingOrbs (loadout={(Object)(object)val2 != (Object)null})");
						}
					}
					if (val2?.StartingRelics != null)
					{
						playerState3.OwnedRelics.Clear();
						foreach (Relic startingRelic in val2.StartingRelics)
						{
							if (!((Object)(object)startingRelic == (Object)null))
							{
								playerState3.OwnedRelics.Add(new SerializedRelic
								{
									Effect = (int)startingRelic.effect,
									LocKey = (startingRelic.locKey ?? string.Empty),
									Rarity = (int)startingRelic.globalRarity
								});
							}
						}
					}
					try
					{
						CruciballManager[] array2 = Resources.FindObjectsOfTypeAll<CruciballManager>();
						CruciballManager val4 = ((array2 != null && array2.Length != 0) ? array2[0] : null);
						if ((Object)(object)val4 != (Object)null)
						{
							int num5 = val4.AdditionalStarterStones();
							if (num5 > 0 && (Object)(object)val4.stonePrefab != (Object)null)
							{
								string name = ((Object)((Component)val4.stonePrefab).gameObject).name;
								for (int j = 0; j < num5; j++)
								{
									playerState3.CompleteDeck.Add(new SerializedOrb
									{
										PrefabName = name,
										Level = 0
									});
								}
								ManualLogSource logger12 = MultiplayerPlugin.Logger;
								if (logger12 != null)
								{
									logger12.LogInfo((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex}: cruciball added {num5}x {name}");
								}
							}
							if (val4.ShouldAddCursedOrb() && (Object)(object)val4.dudOrb1Prefab != (Object)null)
							{
								string name2 = ((Object)((Component)val4.dudOrb1Prefab).gameObject).name;
								playerState3.CompleteDeck.Add(new SerializedOrb
								{
									PrefabName = name2,
									Level = 0
								});
								ManualLogSource logger13 = MultiplayerPlugin.Logger;
								if (logger13 != null)
								{
									logger13.LogInfo((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex}: cruciball added cursed orb {name2}");
								}
							}
							if (val4.ShouldAddUnremovableCursedOrb() && (Object)(object)val4.unremovalbeDudOrb1Prefab != (Object)null)
							{
								string name3 = ((Object)((Component)val4.unremovalbeDudOrb1Prefab).gameObject).name;
								playerState3.CompleteDeck.Add(new SerializedOrb
								{
									PrefabName = name3,
									Level = 0
								});
								ManualLogSource logger14 = MultiplayerPlugin.Logger;
								if (logger14 != null)
								{
									logger14.LogInfo((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex}: cruciball added unremovable cursed orb {name3}");
								}
							}
						}
						else
						{
							ManualLogSource logger15 = MultiplayerPlugin.Logger;
							if (logger15 != null)
							{
								logger15.LogWarning((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex}: no CruciballManager — skipping cruciball deck penalties");
							}
						}
					}
					catch (Exception ex2)
					{
						ManualLogSource logger16 = MultiplayerPlugin.Logger;
						if (logger16 != null)
						{
							logger16.LogWarning((object)$"[ClientPatches] Slot {finalPlayer3.SlotIndex}: cruciball deck penalties failed: {ex2.Message}");
						}
					}
					playerState3.IsInitialized = true;
					ManualLogSource logger17 = MultiplayerPlugin.Logger;
					if (logger17 != null)
					{
						logger17.LogInfo((object)($"[ClientPatches] Built slot {finalPlayer3.SlotIndex} state from ClassLoadoutData: " + $"hp={playerState3.CurrentHealth}/{playerState3.MaxHealth}, deck={playerState3.CompleteDeck.Count}, relics={playerState3.OwnedRelics.Count}"));
					}
					bool flag2 = false;
					if (!MultiplayerClientPatches.IsHosting && services.TryResolve<PlayerRegistry>(out var instance2) && instance2.LocalSlot != null && instance2.LocalSlot.SlotIndex == finalPlayer3.SlotIndex)
					{
						flag2 = true;
					}
					if (!flag2 || val2?.StartingRelics == null)
					{
						continue;
					}
					try
					{
						RelicManager[] array3 = Resources.FindObjectsOfTypeAll<RelicManager>();
						if (array3 == null || array3.Length == 0)
						{
							continue;
						}
						foreach (Relic startingRelic2 in val2.StartingRelics)
						{
							if ((Object)(object)startingRelic2 == (Object)null)
							{
								continue;
							}
							try
							{
								MultiplayerClientPatches.AllowRelicSync = true;
								array3[0].AddRelic(startingRelic2);
								ManualLogSource logger18 = MultiplayerPlugin.Logger;
								if (logger18 != null)
								{
									logger18.LogInfo((object)$"[ClientPatches] Client slot {finalPlayer3.SlotIndex}: added starting class relic {startingRelic2.effect} ({startingRelic2.locKey})");
								}
							}
							catch
							{
							}
							finally
							{
								MultiplayerClientPatches.AllowRelicSync = false;
							}
						}
					}
					catch
					{
					}
				}
			}
			if (MultiplayerClientPatches.IsHosting)
			{
				int num6 = 0;
				if (latestGameStartEvent?.FinalPlayers != null)
				{
					foreach (LobbyPlayerEntry finalPlayer4 in latestGameStartEvent.FinalPlayers)
					{
						if (!finalPlayer4.IsHost)
						{
							num6++;
						}
					}
				}
				CoopRewardState.HostRelicSelectionActive = true;
				CoopRewardState.HostHasChosenRelic = false;
				CoopRewardState.TotalClientsExpected = num6;
				CoopRewardState.ClientRelicChoicesReceived.Clear();
				CoopRewardState.PendingGameInitInstance = __instance;
				ManualLogSource logger19 = MultiplayerPlugin.Logger;
				if (logger19 != null)
				{
					logger19.LogInfo((object)$"[ClientPatches] Coop host: entering relic selection phase, waiting for {num6} client(s)");
				}
				if (services.TryResolve<IGameEventRegistry>(out var instance3) && latestGameStartEvent?.FinalPlayers != null)
				{
					RelicManager[] array4 = Resources.FindObjectsOfTypeAll<RelicManager>();
					if (array4 != null && array4.Length != 0)
					{
						RelicManager val5 = array4[0];
						foreach (LobbyPlayerEntry finalPlayer5 in latestGameStartEvent.FinalPlayers)
						{
							if (finalPlayer5.IsHost)
							{
								continue;
							}
							List<RelicEntry> list = new List<RelicEntry>();
							try
							{
								Relic[] multipleRelicsOffOfQueue = val5.GetMultipleRelicsOffOfQueue(3, (RelicRarity)1, false);
								foreach (Relic val6 in multipleRelicsOffOfQueue)
								{
									string empty = string.Empty;
									try
									{
										empty = LocalizationManager.GetTranslation(val6.nameKey, true, 0, true, false, (GameObject)null, (string)null, true);
										if (string.IsNullOrEmpty(empty))
										{
											empty = val6.englishDisplayName ?? val6.locKey ?? "Unknown";
										}
									}
									catch
									{
										empty = val6.englishDisplayName ?? val6.locKey ?? "Unknown";
									}
									string empty2 = string.Empty;
									try
									{
										empty2 = LocalizationManager.GetTranslation(val6.descKey, true, 0, true, false, (GameObject)null, (string)null, true);
										if (string.IsNullOrEmpty(empty2))
										{
											empty2 = val6.locKey ?? string.Empty;
										}
									}
									catch
									{
										empty2 = val6.locKey ?? string.Empty;
									}
									list.Add(new RelicEntry
									{
										Effect = (int)val6.effect,
										EffectName = empty,
										LocKey = empty2,
										Rarity = (int)val6.globalRarity,
										IsEnabled = true
									});
								}
							}
							catch (Exception ex3)
							{
								ManualLogSource logger20 = MultiplayerPlugin.Logger;
								if (logger20 != null)
								{
									logger20.LogWarning((object)$"[GameInit] Failed to generate relic choices for slot {finalPlayer5.SlotIndex}: {ex3.Message}");
								}
							}
							if (list.Count > 0)
							{
								instance3.Dispatch(new RelicChoicesEvent
								{
									TargetSlotIndex = finalPlayer5.SlotIndex,
									Choices = list
								});
								ManualLogSource logger21 = MultiplayerPlugin.Logger;
								if (logger21 != null)
								{
									logger21.LogInfo((object)$"[GameInit] Sent {list.Count} relic choices to slot {finalPlayer5.SlotIndex}");
								}
							}
						}
						try
						{
							List<RelicEntry> list2 = new List<RelicEntry>();
							Relic[] multipleRelicsOffOfQueue = val5.GetMultipleRelicsOffOfQueue(3, (RelicRarity)1, false);
							foreach (Relic val7 in multipleRelicsOffOfQueue)
							{
								string empty3 = string.Empty;
								try
								{
									empty3 = LocalizationManager.GetTranslation(val7.nameKey, true, 0, true, false, (GameObject)null, (string)null, true);
									if (string.IsNullOrEmpty(empty3))
									{
										empty3 = val7.englishDisplayName ?? val7.locKey ?? "Unknown";
									}
								}
								catch
								{
									empty3 = val7.englishDisplayName ?? val7.locKey ?? "Unknown";
								}
								string empty4 = string.Empty;
								try
								{
									empty4 = LocalizationManager.GetTranslation(val7.descKey, true, 0, true, false, (GameObject)null, (string)null, true);
									if (string.IsNullOrEmpty(empty4))
									{
										empty4 = val7.locKey ?? string.Empty;
									}
								}
								catch
								{
									empty4 = val7.locKey ?? string.Empty;
								}
								list2.Add(new RelicEntry
								{
									Effect = (int)val7.effect,
									EffectName = empty3,
									LocKey = empty4,
									Rarity = (int)val7.globalRarity,
									IsEnabled = true
								});
							}
							CoopRewardState.PendingRelicChoices = new RelicChoicesEvent
							{
								TargetSlotIndex = 0,
								Choices = list2
							};
							ManualLogSource logger22 = MultiplayerPlugin.Logger;
							if (logger22 != null)
							{
								logger22.LogInfo((object)$"[GameInit] Generated {list2.Count} relic choices for host (slot 0)");
							}
						}
						catch (Exception ex4)
						{
							ManualLogSource logger23 = MultiplayerPlugin.Logger;
							if (logger23 != null)
							{
								logger23.LogWarning((object)("[GameInit] Failed to generate host relic choices: " + ex4.Message));
							}
						}
					}
				}
				try
				{
					object? obj7 = typeof(GameInit).GetField("_chooseRelicCanvas", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance);
					GameObject val8 = (GameObject)((obj7 is GameObject) ? obj7 : null);
					if ((Object)(object)val8 != (Object)null)
					{
						val8.SetActive(false);
						ManualLogSource logger24 = MultiplayerPlugin.Logger;
						if (logger24 != null)
						{
							logger24.LogInfo((object)"[ClientPatches] Coop host: hid native relic canvas, using CoopRewardUI");
						}
					}
					return;
				}
				catch (Exception ex5)
				{
					ManualLogSource logger25 = MultiplayerPlugin.Logger;
					if (logger25 != null)
					{
						logger25.LogWarning((object)("[ClientPatches] Failed to hide host relic canvas: " + ex5.Message));
					}
					return;
				}
			}
			if (MultiplayerClientPatches.IsHosting)
			{
				return;
			}
			try
			{
				object? obj8 = typeof(GameInit).GetField("_chooseRelicCanvas", BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(__instance);
				GameObject val9 = (GameObject)((obj8 is GameObject) ? obj8 : null);
				if ((Object)(object)val9 != (Object)null)
				{
					val9.SetActive(false);
					ManualLogSource logger26 = MultiplayerPlugin.Logger;
					if (logger26 != null)
					{
						logger26.LogInfo((object)"[ClientPatches] Coop client: hid native relic canvas, using CoopRewardUI");
					}
				}
			}
			catch (Exception ex6)
			{
				ManualLogSource logger27 = MultiplayerPlugin.Logger;
				if (logger27 != null)
				{
					logger27.LogWarning((object)("[ClientPatches] Failed to hide relic canvas: " + ex6.Message));
				}
			}
		}

		[HarmonyPatch(typeof(GameInit), "LoadMapScene")]
		[HarmonyPrefix]
		public static bool GameInit_LoadMapScene_Prefix()
		{
			if (!CoopRewardState.HostRelicSelectionActive)
			{
				return true;
			}
			if (!MultiplayerClientPatches.IsHosting)
			{
				return true;
			}
			CoopRewardState.HostHasChosenRelic = true;
			if (CoopRewardState.AllClientRelicChoicesReceived)
			{
				CoopRewardState.HostRelicSelectionActive = false;
				CoopRewardState.AllChoicesComplete = true;
				CoopRewardState.WaitingForOtherPlayers = false;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatches] All relic choices received -- proceeding to map");
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IGameEventRegistry>(out var instance))
				{
					instance.Dispatch(new AllChoicesCompleteEvent
					{
						Phase = "starting_relic"
					});
				}
				return true;
			}
			ManualLogSource logger2 = MultiplayerPlugin.Logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)("[ClientPatches] Host chose relic, waiting for " + $"{CoopRewardState.TotalClientsExpected - CoopRewardState.ClientRelicChoicesReceived.Count} more client(s)"));
			}
			CoopRewardState.WaitingForOtherPlayers = true;
			return false;
		}
	}
	[HarmonyPatch]
	internal static class LongPegPatches
	{
		[HarmonyPatch(typeof(LongPeg), "SetActiveStatus")]
		[HarmonyPostfix]
		public static void LongPeg_SetActiveStatus_Postfix(LongPeg __instance, bool active)
		{
			if (active || !MultiplayerClientPatches.IsHosting)
			{
				return;
			}
			try
			{
				if ((bool)(AccessTools.Field(typeof(Peg), "_cleared")?.GetValue(__instance) ?? ((object)false)))
				{
					((Peg)__instance).RemoveIfCleared();
				}
			}
			catch
			{
			}
		}
	}
	public static class MenuButtonInjector
	{
		[CompilerGenerated]
		private static class <>O
		{
			public static UnityAction <0>__ToggleOverlayStatic;
		}

		private static GameObject _multiplayerButton;

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public static void InjectIfNeeded()
		{
			//IL_0197: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a1: Expected O, but got Unknown
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c3: Expected O, but got Unknown
			try
			{
				if ((Object)(object)_multiplayerButton != (Object)null && Object.op_Implicit((Object)(object)_multiplayerButton))
				{
					return;
				}
				GameObject val = GameObject.Find("MultiplayerButton");
				if ((Object)(object)val != (Object)null)
				{
					_multiplayerButton = val;
					return;
				}
				Button[] array = Object.FindObjectsOfType<Button>(true);
				Button val2 = null;
				Transform val3 = null;
				Button[] array2 = array;
				foreach (Button val4 in array2)
				{
					string text = ((Object)((Component)val4).gameObject).name.ToUpperInvariant();
					if (text.Contains("ENCIRCLEPEDIA") || text.Contains("ENCYCLOPEDIA"))
					{
						val3 = ((Component)val4).transform;
					}
					if ((Object)(object)val2 == (Object)null && (text.Contains("CREDIT") || text.Contains("OPTION")))
					{
						val2 = val4;
					}
				}
				if ((Object)(object)val2 == (Object)null)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)"MenuButtonInjector: no Credits/Options button found to clone");
					}
					return;
				}
				_multiplayerButton = Object.Instantiate<GameObject>(((Component)val2).gameObject, ((Component)val2).transform.parent);
				((Object)_multiplayerButton).name = "MultiplayerButton";
				TextMeshProUGUI componentInChildren = _multiplayerButton.GetComponentInChildren<TextMeshProUGUI>(true);
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((TMP_Text)componentInChildren).text = "Multiplayer";
				}
				Component[] componentsInChildren = _multiplayerButton.GetComponentsInChildren<Component>(true);
				foreach (Component val5 in componentsInChildren)
				{
					if ((Object)(object)val5 != (Object)null && ((object)val5).GetType().Name == "Localize")
					{
						Object.Destroy((Object)(object)val5);
					}
				}
				Button component = _multiplayerButton.GetComponent<Button>();
				if ((Object)(object)component != (Object)null)
				{
					component.onClick = new ButtonClickedEvent();
					ButtonClickedEvent onClick = component.onClick;
					object obj = <>O.<0>__ToggleOverlayStatic;
					if (obj == null)
					{
						UnityAction val6 = MultiplayerUI.ToggleOverlayStatic;
						<>O.<0>__ToggleOverlayStatic = val6;
						obj = (object)val6;
					}
					((UnityEvent)onClick).AddListener((UnityAction)obj);
				}
				Transform val7 = val3 ?? ((Component)val2).transform;
				_multiplayerButton.transform.SetSiblingIndex(val7.GetSiblingIndex());
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)("MenuButtonInjector: cloned '" + ((Object)((Component)val2).gameObject).name + "', placed above '" + ((Object)((Component)val7).gameObject).name + "'"));
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogError((object)$"MenuButtonInjector: {arg}");
				}
			}
		}

		public static void OnSceneChanged()
		{
			_multiplayerButton = null;
		}
	}
	[HarmonyPatch(typeof(PlayButton), "Awake")]
	public static class PlayButtonAwakePatch
	{
		public static void Postfix()
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"PlayButtonAwakePatch: PlayButton.Awake fired");
			}
			MenuButtonInjector.InjectIfNeeded();
		}
	}
	public class SceneWatcher : MonoBehaviour
	{
		[CompilerGenerated]
		private sealed class <DelayedInject>d__6 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					MenuButtonInjector.InjectIfNeeded();
					return false;
				}
			}

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

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

		private string _lastScene = string.Empty;

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		private void OnEnable()
		{
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		private void OnDisable()
		{
			SceneManager.sceneLoaded -= OnSceneLoaded;
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			try
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)("SceneWatcher: scene '" + ((Scene)(ref scene)).name + "' loaded"));
				}
				if (((Scene)(ref scene)).name != _lastScene)
				{
					MenuButtonInjector.OnSceneChanged();
					_lastScene = ((Scene)(ref scene)).name;
				}
				if (!(((Scene)(ref scene)).name == "MainMenu"))
				{
					return;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance) && (instance.IsHosting || instance.IsSpectating))
				{
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogInfo((object)"SceneWatcher: MainMenu reached while in multiplayer — disconnecting");
					}
					MultiplayerSession.DisconnectAndReset("Game returned to main menu");
				}
				((MonoBehaviour)this).StartCoroutine(DelayedInject());
			}
			catch
			{
			}
		}

		[IteratorStateMachine(typeof(<DelayedInject>d__6))]
		private IEnumerator DelayedInject()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <DelayedInject>d__6(0);
		}
	}
	[HarmonyPatch(typeof(PauseMenu), "QuitToMenu")]
	public static class PauseMenuQuitToMenuPatch
	{
		public static bool Prefix(PauseMenu __instance)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null)
			{
				return true;
			}
			if (!services.TryResolve<IMultiplayerMode>(out var instance))
			{
				return true;
			}
			if (!instance.IsSpectating && !instance.IsHosting)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[PauseMenu] QuitToMenu in multiplayer — disconnecting");
			}
			try
			{
				__instance.Resume();
			}
			catch
			{
			}
			MultiplayerSession.DisconnectAndReset("Returned to main menu");
			return false;
		}
	}
	[HarmonyPatch]
	internal static class MapControllerPatches
	{
		[HarmonyPatch(typeof(MapController), "CreateMapDataLists")]
		[HarmonyPostfix]
		public static void MapController_CreateMapDataLists_Postfix()
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatches] CreateMapDataLists ran on client (lists unused, prevents NRE)");
				}
			}
		}

		[HarmonyPatch(typeof(MapController), "PostProcessMap")]
		[HarmonyPrefix]
		public static bool MapController_PostProcessMap_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(MapController), "SeedMapContents")]
		[HarmonyPrefix]
		public static bool MapController_SeedMapContents_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(MapController), "LoadSceneFromMapData")]
		[HarmonyPrefix]
		public static bool MapController_LoadSceneFromMapData_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatches] Blocked LoadSceneFromMapData — host will send transitions");
			}
			try
			{
				FadeCurtain obj = Object.FindObjectOfType<FadeCurtain>();
				if (obj != null)
				{
					obj.FadeOut();
				}
			}
			catch
			{
			}
			return false;
		}

		[HarmonyPatch(typeof(MapController), "ResolveNode")]
		[HarmonyPrefix]
		public static bool MapController_ResolveNode_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatches] Blocked MapController.ResolveNode (client — scene handled by NodeActivatedClientHandler)");
			}
			return false;
		}

		[HarmonyPatch(typeof(MapController), "ResolveNode")]
		[HarmonyPostfix]
		public static void MapController_ResolveNode_Postfix(MapNode node)
		{
			if (MultiplayerClientPatches.IsHosting)
			{
				string text = (((Object)(object)node != (Object)null) ? ((Object)((Component)node).gameObject).name : "(null)");
				MapData obj = ((node != null) ? node.MapData : null);
				MapData obj2 = ((obj is MapDataBattle) ? obj : null);
				string text2 = ((obj2 != null) ? ((Object)obj2).name : null);
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)("[ClientPatches] Host ResolveNode: node=" + text + ", battle=" + (text2 ?? "(none)")));
				}
			}
		}

		[HarmonyPatch(typeof(MapController), "LoadSceneFromMapData")]
		[HarmonyPostfix]
		public static void MapController_LoadSceneFromMapData_Postfix(MapData data)
		{
			if (MultiplayerClientPatches.IsHosting)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)("[ClientPatches] Host LoadSceneFromMapData: mapData=" + (((data != null) ? ((Object)data).name : null) ?? "(null)")));
				}
			}
		}

		[HarmonyPatch(typeof(MapController), "Start")]
		[HarmonyFinalizer]
		public static Exception MapController_Start_Finalizer(Exception __exception, MapController __instance)
		{
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			if (MultiplayerClientPatches.IsHosting)
			{
				if (__exception != null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)("[ClientPatches] Host MapController.Start threw (" + __exception.GetType().Name + "): " + __exception.Message + " — recovering intro chain"));
					}
					try
					{
						AccessTools.Method(typeof(MapController), "IntroCameraPan", (Type[])null, (Type[])null)?.Invoke(__instance, null);
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogInfo((object)"[ClientPatches] Recovered: invoked IntroCameraPan after Start exception");
						}
					}
					catch (Exception ex)
					{
						ManualLogSource logger3 = MultiplayerPlugin.Logger;
						if (logger3 != null)
						{
							logger3.LogWarning((object)("[ClientPatches] Recovery IntroCameraPan failed: " + ex.Message));
						}
					}
				}
				try
				{
					if (AccessTools.Field(typeof(MapController), "_nodes")?.GetValue(__instance) is MapNode[] array && array.Length != 0)
					{
						int num = 0;
						MapNode[] array2 = array;
						foreach (MapNode val in array2)
						{
							if ((Object)(object)val != (Object)null && (int)val.RoomType == 0)
							{
								num++;
							}
						}
						if (num > array.Length / 2)
						{
							ManualLogSource logger4 = MultiplayerPlugin.Logger;
							if (logger4 != null)
							{
								logger4.LogWarning((object)$"[ClientPatches] Continue-load detected {num}/{array.Length} NONE nodes — regenerating map types");
							}
							try
							{
								__instance.rootNode.SetActiveState((RoomState)3, true, true);
								AccessTools.Method(typeof(MapController), "SeedMapContents", (Type[])null, (Type[])null)?.Invoke(__instance, null);
								array2 = array;
								foreach (MapNode obj in array2)
								{
									if (obj != null)
									{
										obj.SaveNode();
									}
								}
								DataSerializer.SaveFile((SaveType)1);
								ManualLogSource logger5 = MultiplayerPlugin.Logger;
								if (logger5 != null)
								{
									logger5.LogInfo((object)"[ClientPatches] Map regen complete — types rebuilt and flushed to disk");
								}
							}
							catch (Exception ex2)
							{
								ManualLogSource logger6 = MultiplayerPlugin.Logger;
								if (logger6 != null)
								{
									logger6.LogWarning((object)("[ClientPatches] Map regen failed: " + ex2.Message));
								}
							}
						}
					}
				}
				catch (Exception ex3)
				{
					ManualLogSource logger7 = MultiplayerPlugin.Logger;
					if (logger7 != null)
					{
						logger7.LogWarning((object)("[ClientPatches] Continue-load NONE check failed: " + ex3.Message));
					}
				}
				try
				{
					IServiceContainer services = MultiplayerPlugin.Services;
					if (services != null && services.TryResolve<IGameStateSyncService>(out var instance))
					{
						instance.SyncMap();
						ManualLogSource logger8 = MultiplayerPlugin.Logger;
						if (logger8 != null)
						{
							logger8.LogInfo((object)"[ClientPatches] Host MapController.Start done — sent immediate map sync with node types");
						}
					}
				}
				catch
				{
				}
				try
				{
					ContinueLoader.ApplyPendingCoopState();
				}
				catch
				{
				}
				return null;
			}
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return __exception;
			}
			MultiplayerClientPatches.MapControllerStartCompleted = true;
			if (__exception != null)
			{
				ManualLogSource logger9 = MultiplayerPlugin.Logger;
				if (logger9 != null)
				{
					logger9.LogWarning((object)("[ClientPatches] MapController.Start threw on client (swallowed): " + __exception.Message));
				}
			}
			try
			{
				IServiceContainer services2 = MultiplayerPlugin.Services;
				if (services2 != null && services2.TryResolve<GameStateApplyService>(out var instance2))
				{
					instance2.ReapplyLastMapState();
				}
			}
			catch
			{
			}
			ManualLogSource logger10 = MultiplayerPlugin.Logger;
			if (logger10 != null)
			{
				logger10.LogInfo((object)"[ClientPatches] MapController.Start finished on client — re-applied host node types");
			}
			return null;
		}

		[HarmonyPatch(typeof(MapController), "IntroFade")]
		[HarmonyPrefix]
		public static bool MapController_IntroFade_Prefix(MapController __instance)
		{
			//IL_00a1: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.IsHosting)
			{
				return true;
			}
			try
			{
				if ((Object)(object)GameObject.FindGameObjectWithTag("Curtain") == (Object)null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[ClientPatches] IntroFade: no 'Curtain' tagged GO in scene — skipping DOFade, calling IntroCameraPan directly");
					}
					try
					{
						object? obj = AccessTools.Field(typeof(MapController), "_previousNode")?.GetValue(__instance);
						MapNode val = (MapNode)((obj is MapNode) ? obj : null);
						object? obj2 = AccessTools.Field(typeof(MapController), "_player")?.GetValue(__instance);
						GameObject val2 = (GameObject)((obj2 is GameObject) ? obj2 : null);
						if ((Object)(object)val != (Object)null && (Object)(object)val2 != (Object)null)
						{
							val2.transform.position = ((Component)val).transform.position;
						}
					}
					catch
					{
					}
					AccessTools.Method(typeof(MapController), "IntroCameraPan", (Type[])null, (Type[])null)?.Invoke(__instance, null);
					return false;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[ClientPatches] IntroFade prefix check failed: " + ex.Message));
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(MapController), "IntroFade")]
		[HarmonyPostfix]
		public static void MapController_IntroFade_Postfix()
		{
			if (MultiplayerClientPatches.IsHosting)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatches] Intro: IntroFade entered");
				}
			}
		}

		[HarmonyPatch(typeof(MapController), "IntroCameraPan")]
		[HarmonyPostfix]
		public static void MapController_IntroCameraPan_Postfix()
		{
			if (MultiplayerClientPatches.IsHosting)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatches] Intro: IntroCameraPan entered");
				}
			}
		}

		[HarmonyPatch(typeof(MapController), "PostFadeInit")]
		[HarmonyPostfix]
		public static void MapController_PostFadeInit_Postfix()
		{
			if (MultiplayerClientPatches.IsHosting)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatches] Intro: PostFadeInit entered");
				}
			}
		}

		[HarmonyPatch(typeof(MapController), "OnSceneLoaded")]
		[HarmonyPostfix]
		public static void MapController_OnSceneLoaded_Postfix(Scene scene, MapController __instance)
		{
			if (MultiplayerClientPatches.IsHosting && ((Scene)(ref scene)).isLoaded && ((Scene)(ref scene)).name.Contains("Map"))
			{
				bool flag = true;
				try
				{
					flag = (bool)(AccessTools.Field(typeof(MapController), "_firstLoad")?.GetValue(__instance) ?? ((object)true));
				}
				catch
				{
				}
				if (!flag)
				{
					ContinueSaver.Save("map-loaded:" + ((Scene)(ref scene)).name);
				}
			}
		}

		[HarmonyPatch(typeof(MapController), "Awake")]
		[HarmonyPrefix]
		public static void MapController_Awake_Prefix(MapController __instance)
		{
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0063: Unknown result type (might be due to invalid IL or missing references)
			//IL_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 (!MultiplayerClientPatches.IsHosting && (Object)(object)MapController.instance != (Object)null && (Object)(object)MapController.instance != (Object)(object)__instance)
			{
				try
				{
					MapController instance = MapController.instance;
					if (instance.Act != __instance.Act || !string.Equals(instance.mapNameLocKey, __instance.mapNameLocKey, StringComparison.Ordinal))
					{
						Scene scene = ((Component)instance).gameObject.scene;
						string name = ((Scene)(ref scene)).name;
						scene = ((Component)__instance).gameObject.scene;
						string name2 = ((Scene)(ref scene)).name;
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)$"[ClientPatches] Client: destroying stale MapController (act {instance.Act} '{instance.mapNameLocKey}' from '{name}') so new MC (act {__instance.Act} '{__instance.mapNameLocKey}' from '{name2}') can take over");
						}
						MapController.instance = null;
						Object.Destroy((Object)(object)((Component)instance).gameObject);
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)("[ClientPatches] Failed to clear stale MapController: " + ex.Message));
					}
				}
			}
			if (MultiplayerClientPatches.IsHosting)
			{
				MultiplayerClientPatches.CapturedPreMapGenRngState = MultiplayerClientPatches.SerializeRandomState(Random.state);
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)"[ClientPatches] Captured pre-map-gen RNG state");
				}
			}
			else
			{
				if (!MultiplayerClientPatches.ShouldSuppressClientLogic || string.IsNullOrEmpty(MultiplayerClientPatches.PendingRngStateToRestore))
				{
					return;
				}
				State? val = MultiplayerClientPatches.DeserializeRandomState(MultiplayerClientPatches.PendingRngStateToRestore);
				if (val.HasValue)
				{
					Random.state = val.Value;
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogInfo((object)"[ClientPatches] Restored host RNG state before map generation");
					}
				}
				MultiplayerClientPatches.PendingRngStateToRestore = null;
			}
		}
	}
	[HarmonyPatch]
	internal static class MapDataPegMinigameOrbsPatches
	{
		[HarmonyPatch(typeof(MapDataPegMinigameOrbs), "PopulateRewards")]
		[HarmonyPrefix]
		public static bool MapDataPegMinigameOrbs_PopulateRewards_PerSlot_Prefix(MapDataPegMinigameOrbs __instance)
		{
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Expected O, but got Unknown
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (!MultiplayerClientPatches.AllowPegMinigameLogic)
			{
				return true;
			}
			try
			{
				int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(MultiplayerPlugin.Services);
				if (localSlotIndex < 0)
				{
					return true;
				}
				DeckManager deckManager = __instance.deckManager;
				if ((Object)(object)deckManager == (Object)null)
				{
					return true;
				}
				List<GameObject> randomOrbPool = deckManager.GetRandomOrbPool();
				if (randomOrbPool == null || randomOrbPool.Count == 0)
				{
					return true;
				}
				List<GameObject> list = new List<GameObject>(randomOrbPool);
				list.Sort((GameObject a, GameObject b) => string.CompareOrdinal((a != null) ? ((Object)a).name : null, (b != null) ? ((Object)b).name : null));
				int num = Math.Min(Math.Max(1, __instance.numberOfRewards), list.Count);
				Random random = new Random((StaticGameData.currentSeed ?? string.Empty).GetHashCode() ^ (localSlotIndex * 7919) ^ (StaticGameData.totalFloorCount * 104729) ^ 0x4F2BD17);
				List<Reward> list2 = new List<Reward>();
				List<string> list3 = new List<string>();
				Attack val3 = default(Attack);
				Attack val4 = default(Attack);
				for (int i = 0; i < num; i++)
				{
					int index = i + random.Next(0, list.Count - i);
					GameObject value = list[i];
					list[i] = list[index];
					list[index] = value;
					GameObject val = list[i];
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					GameObject val2 = val;
					int num2 = (((Object)(object)MapController.instance != (Object)null) ? MapController.instance.Act : 0);
					if (num2 > 1 && val2.TryGetComponent<Attack>(ref val3) && (Object)(object)val3.NextLevelPrefab != (Object)null)
					{
						val2 = val3.NextLevelPrefab;
						if (num2 > 2 && val2.TryGetComponent<Attack>(ref val4) && (Object)(object)val4.NextLevelPrefab != (Object)null)
						{
							val2 = val4.NextLevelPrefab;
						}
					}
					list2.Add((Reward)new OrbReward(val2, deckManager));
					list3.Add(((Object)val2).name);
				}
				((MapDataPegMinigame)__instance).Rewards = list2;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)string.Format("[ClientPatch] PegMinigame orb rewards (slot {0}) = [{1}]", localSlotIndex, string.Join(",", list3)));
				}
				return false;
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[ClientPatch] PegMinigameOrbs PopulateRewards override failed: " + ex.Message));
				}
				return true;
			}
		}
	}
	[HarmonyPatch]
	internal static class MapDataPegMinigameRelicsPatches
	{
		[HarmonyPatch(typeof(MapDataPegMinigameRelics), "PopulateRewards")]
		[HarmonyPrefix]
		public static bool MapDataPegMinigameRelics_PopulateRewards_PerSlot_Prefix(MapDataPegMinigameRelics __instance)
		{
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Expected O, but got Unknown
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (!MultiplayerClientPatches.AllowPegMinigameLogic)
			{
				return true;
			}
			try
			{
				int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(MultiplayerPlugin.Services);
				if (localSlotIndex < 0)
				{
					return true;
				}
				RelicManager relicManager = __instance.relicManager;
				int count = Math.Max(1, __instance.numberOfRewards);
				List<Relic> list = MultiplayerClientPatches.PickMultipleLocalRelics(__instance.rarity, count, relicManager, localSlotIndex);
				if (list.Count == 0)
				{
					return true;
				}
				List<Reward> list2 = new List<Reward>();
				foreach (Relic item in list)
				{
					list2.Add((Reward)new RelicReward(item, relicManager, __instance.relicInfoWidget));
				}
				((MapDataPegMinigame)__instance).Rewards = list2;
				List<string> list3 = new List<string>();
				foreach (Relic item2 in list)
				{
					list3.Add(((item2 != null) ? ((Object)item2).name : null) ?? "<null>");
				}
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)string.Format("[ClientPatch] PegMinigame relic rewards (slot {0}, rarity {1}) = [{2}]", localSlotIndex, __instance.rarity, string.Join(",", list3)));
				}
				return false;
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[ClientPatch] PegMinigameRelics PopulateRewards override failed: " + ex.Message));
				}
				return true;
			}
		}
	}
	[HarmonyPatch]
	internal static class MapNodePatches
	{
		[HarmonyPatch(typeof(MapNode), "GenerateRoomType")]
		[HarmonyPrefix]
		public static bool MapNode_GenerateRoomType_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(MapNode), "GenerateIcon")]
		[HarmonyPrefix]
		public static bool MapNode_GenerateIcon_Prefix(MapNode __instance)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Invalid comparison between Unknown and I4
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return (int)__instance.RoomType > 0;
		}

		[HarmonyPatch(typeof(MapNode), "ActivateNode")]
		[HarmonyPostfix]
		public static void MapNode_ActivateNode_Postfix(MapNode __instance)
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: 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_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Invalid comparison between Unknown and I4
			//IL_0165: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.IsHosting || MultiplayerPlugin.Services == null || !MultiplayerPlugin.Services.TryResolve<IGameEventRegistry>(out var instance))
			{
				return;
			}
			Vector3 position = ((Component)__instance).transform.position;
			MapData mapData = __instance.MapData;
			MapData obj = ((mapData is MapDataBattle) ? mapData : null);
			string text = ((obj != null) ? ((Object)obj).name : null);
			object obj2;
			if (!string.IsNullOrEmpty(text))
			{
				obj2 = null;
			}
			else
			{
				MapData mapData2 = __instance.MapData;
				obj2 = ((mapData2 != null) ? ((Object)mapData2).name : null);
			}
			string text2 = (string)obj2;
			object obj3 = AccessTools.Field(typeof(MapNode), "_roomStatus")?.GetValue(__instance);
			string text3 = obj3?.ToString() ?? "?";
			instance.Dispatch(new NodeActivatedEvent
			{
				PosX = position.x,
				PosY = position.y,
				BattleName = text,
				RngState = MultiplayerClientPatches.SerializeRandomState(Random.state),
				MapDataName = text2
			});
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)$"[ClientPatches] Host activated node at ({position.x:F1}, {position.y:F1}), battle={text}, mapData={text2}, roomStatus={text3}");
			}
			if (obj3 is RoomState val && (int)val != 3 && (Object)(object)__instance.MapData != (Object)null)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					object arg = val;
					MapData mapData3 = __instance.MapData;
					logger2.LogWarning((object)$"[ClientPatches] Host node activate had roomStatus={arg} (expected NEXT). Forcing scene transition to {((mapData3 != null) ? ((Object)mapData3).name : null)}");
				}
				try
				{
					StaticGameData.seededNodeData = __instance.seededNodeData;
					if ((Object)(object)MapController.instance != (Object)null)
					{
						AccessTools.Field(typeof(MapController), "_previousNode")?.SetValue(MapController.instance, __instance);
					}
					AccessTools.Method(typeof(MapController), "LoadSceneFromMapData", (Type[])null, (Type[])null)?.Invoke(MapController.instance, new object[1] { __instance.MapData });
				}
				catch (Exception arg2)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogError((object)$"[ClientPatches] Forced LoadSceneFromMapData failed: {arg2}");
					}
				}
			}
			string text4 = ((!string.IsNullOrEmpty(text)) ? text : ((!string.IsNullOrEmpty(text2)) ? text2 : "node"));
			ContinueSaver.Save("node-activated:" + text4);
		}
	}
	[HarmonyPatch]
	public static class MultiplayerClientPatches
	{
		internal struct OrbShotInfo
		{
			public ShotType ShotType;

			public bool CanAimUp;

			public int EnemiesToPierce;

			public bool Valid;
		}

		[CompilerGenerated]
		private sealed class <EmptyCoroutine>d__97 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <EmptyEnumerator>d__66 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

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

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

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

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

			private bool MoveNext()
			{
				if (<>1__state != 0)
				{
					return false;
				}
				<>1__state = -1;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <PlayCoopAttackSequence>d__67 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public List<PlayerAttackData> shots;

			public EnemyManager em;

			public EnemyIdentifier enemyId;

			public BattleController bc;

			public AttackManager am;

			private IGameEventRegistry <reg>5__2;

			private List<PlayerAttackData>.Enumerator <>7__wrap2;

			private PlayerAttackData <shot>5__4;

			private List<Enemy> <targets>5__5;

			private ClientAttackProjectile <cap>5__6;

			private float <waited>5__7;

			private Enemy <reverseTarget>5__8;

			private string <reverseGuid>5__9;

			private float <reverseWaited>5__10;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				int num = <>1__state;
				if (num == -3 || (uint)(num - 1) <= 4u)
				{
					try
					{
					}
					finally
					{
						<>m__Finally1();
					}
				}
				<reg>5__2 = null;
				<>7__wrap2 = default(List<PlayerAttackData>.Enumerator);
				<shot>5__4 = null;
				<targets>5__5 = null;
				<cap>5__6 = null;
				<reverseTarget>5__8 = null;
				<reverseGuid>5__9 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_08ec: Unknown result type (might be due to invalid IL or missing references)
				//IL_08f6: Expected O, but got Unknown
				//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Expected O, but got Unknown
				//IL_04ca: Unknown result type (might be due to invalid IL or missing references)
				//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
				//IL_0612: Unknown result type (might be due to invalid IL or missing references)
				//IL_061c: Expected O, but got Unknown
				try
				{
					ManualLogSource logger;
					Enemy val2;
					string text;
					List<Enemy> list2;
					ManualLogSource logger4;
					switch (<>1__state)
					{
					default:
						return false;
					case 0:
					{
						<>1__state = -1;
						IServiceContainer services = MultiplayerPlugin.Services;
						<reg>5__2 = null;
						services?.TryResolve<IGameEventRegistry>(out <reg>5__2);
						shots.Sort((PlayerAttackData a, PlayerAttackData b) => a.SlotIndex.CompareTo(b.SlotIndex));
						<>7__wrap2 = shots.GetEnumerator();
						<>1__state = -3;
						goto IL_0921;
					}
					case 1:
						<>1__state = -3;
						goto IL_0921;
					case 2:
						<>1__state = -3;
						goto IL_0451;
					case 3:
						<>1__state = -3;
						<reverseTarget>5__8 = em.GetFarthestEnemyFromPlayer();
						if ((Object)(object)<reverseTarget>5__8 != (Object)null && <reverseTarget>5__8.CurrentHealth > 0f)
						{
							<reverseGuid>5__9 = enemyId?.GetGuid(<reverseTarget>5__8);
							try
							{
								<reg>5__2?.Dispatch(new AttackStartedEvent
								{
									AnimTrigger = "attack",
									TargetEnemyGuid = <reverseGuid>5__9,
									NumPegsHit = <shot>5__4.NumPegsHit,
									IsCrit = (<shot>5__4.CriticalHitCount > 0),
									OrbName = <shot>5__4.OrbPrefabName,
									SlotIndex = <shot>5__4.SlotIndex
								});
							}
							catch
							{
							}
							try
							{
								AttackPerformed onAttackPerformed = AttackManager.OnAttackPerformed;
								if (onAttackPerformed != null)
								{
									onAttackPerformed.Invoke("attack");
								}
							}
							catch
							{
							}
							if ((Object)(object)<cap>5__6 != (Object)null && !string.IsNullOrEmpty(<reverseGuid>5__9))
							{
								<cap>5__6.SetupAttack(<reverseGuid>5__9, <shot>5__4.NumPegsHit, <shot>5__4.CriticalHitCount > 0, <shot>5__4.OrbPrefabName);
							}
							<reverseWaited>5__10 = 0f;
							goto IL_07a7;
						}
						goto IL_08df;
					case 4:
						<>1__state = -3;
						goto IL_07a7;
					case 5:
						{
							<>1__state = -3;
							<targets>5__5 = null;
							<cap>5__6 = null;
							<shot>5__4 = null;
							goto IL_0921;
						}
						IL_0451:
						if ((Object)(object)<cap>5__6 != (Object)null && <cap>5__6.IsAttacking && <waited>5__7 < 2f)
						{
							<waited>5__7 += Time.deltaTime;
							<>2__current = null;
							<>1__state = 2;
							return true;
						}
						EnemySubscriptions.DamageAttributionSlotOverride = <shot>5__4.SlotIndex;
						try
						{
							foreach (Enemy item in <targets>5__5)
							{
								if (!((Object)(object)item == (Object)null) && !(item.CurrentHealth <= 0f))
								{
									EnemyDamageSource val = (EnemyDamageSource)(<shot>5__4.IsAoE ? 3 : 2);
									item.Damage(<shot>5__4.Damage, false, 0.25f, 1f, false, val, true, false);
									ApplyStatusEffectsToEnemy(item, <shot>5__4.StatusEffectsToApply);
								}
							}
						}
						finally
						{
							EnemySubscriptions.DamageAttributionSlotOverride = -1;
						}
						logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)($"[CoopAttack] Played slot {<shot>5__4.SlotIndex} ({<shot>5__4.PlayerName}): " + $"orb={<shot>5__4.OrbPrefabName} dmg={<shot>5__4.Damage} targets={<targets>5__5.Count} " + $"aoe={<shot>5__4.IsAoE} effects={<shot>5__4.StatusEffectsToApply?.Count ?? 0}"));
						}
						if (<shot>5__4.HasReverseShot && !<shot>5__4.IsAoE && !<shot>5__4.IsHeal && <shot>5__4.Damage > 0)
						{
							<>2__current = (object)new WaitForSeconds(0.15f);
							<>1__state = 3;
							return true;
						}
						break;
						IL_0921:
						while (true)
						{
							if (<>7__wrap2.MoveNext())
							{
								<shot>5__4 = <>7__wrap2.Current;
								if (<shot>5__4.IsHeal && <shot>5__4.Damage > 0)
								{
									ApplyCoopHeal(<shot>5__4, em, enemyId, <reg>5__2);
									<>2__current = (object)new WaitForSeconds(0.3f);
									<>1__state = 1;
									return true;
								}
								if (<shot>5__4.Damage <= 0)
								{
									continue;
								}
								val2 = null;
								<targets>5__5 = new List<Enemy>();
								if (<shot>5__4.IsAoE)
								{
									foreach (Enemy enemy in em.Enemies)
									{
										if ((Object)(object)enemy != (Object)null && enemy.CurrentHealth > 0f)
										{
											<targets>5__5.Add(enemy);
										}
									}
									if (<targets>5__5.Count != 0)
									{
										val2 = <targets>5__5[0];
										break;
									}
									continue;
								}
								if (!string.IsNullOrEmpty(<shot>5__4.TargetEnemyGuid))
								{
									val2 = enemyId.Find(<shot>5__4.TargetEnemyGuid);
								}
								if ((Object)(object)val2 == (Object)null || val2.CurrentHealth <= 0f)
								{
									val2 = em.GetFarthestEnemyFromPlayer();
								}
								if ((Object)(object)val2 == (Object)null)
								{
									continue;
								}
								int orbPierceCount = GetOrbPierceCount(<shot>5__4.OrbPrefabName);
								<targets>5__5.Add(val2);
								if (orbPierceCount > 0)
								{
									<targets>5__5.AddRange(GetEnemiesBehindTarget(em, val2, orbPierceCount));
								}
								try
								{
									List<Enemy> list = ResolveShotTargetsViaRaycast(bc, em, val2, <shot>5__4.OrbPrefabName, orbPierceCount);
									if (list != null && list.Count > 0 && (orbPierceCount == 0 || list.Count >= <targets>5__5.Count))
									{
										<targets>5__5 = list;
										val2 = list[0];
									}
								}
								catch (Exception ex)
								{
									ManualLogSource logger2 = MultiplayerPlugin.Logger;
									if (logger2 != null)
									{
										logger2.LogWarning((object)("[CoopAttack] Raycast redirect failed for " + <shot>5__4.OrbPrefabName + ": " + ex.Message));
									}
								}
								ExtendTargetsForTranspherency(em, <targets>5__5);
								ExpandTargetsForShooterRelics(em, <shot>5__4, val2, <targets>5__5);
								break;
							}
							<>m__Finally1();
							<>7__wrap2 = default(List<PlayerAttackData>.Enumerator);
							CoopSubscriptions.CleanupTempOrb();
							try
							{
								AccessTools.Field(typeof(BattleController), "_pegMultiplierDamageTally")?.SetValue(bc, 0);
								AccessTools.Field(typeof(BattleController), "_numPegsHit")?.SetValue(bc, 0);
								AccessTools.Field(typeof(BattleController), "_cactusDamageTally")?.SetValue(bc, 0);
								AccessTools.Field(typeof(BattleController), "_criticalHitCount")?.SetValue(null, 0);
								AccessTools.Field(typeof(BattleController), "_damageMultiplier")?.SetValue(bc, 1f);
								AccessTools.Field(typeof(BattleController), "_damageBonus")?.SetValue(bc, 0);
							}
							catch (Exception ex2)
							{
								ManualLogSource logger3 = MultiplayerPlugin.Logger;
								if (logger3 != null)
								{
									logger3.LogWarning((object)("[CoopAttack] Failed to zero BC tallies post-sequence: " + ex2.Message));
								}
							}
							if ((Object)(object)am != (Object)null)
							{
								try
								{
									am.AttackAnimationEnded();
								}
								catch
								{
									FieldInfo fieldInfo = AccessTools.Field(typeof(AttackManager), "_isAttacking");
									FieldInfo fieldInfo2 = AccessTools.Field(typeof(AttackManager), "_attackAnimationFinished");
									fieldInfo?.SetValue(am, false);
									fieldInfo2?.SetValue(am, true);
								}
							}
							SuppressOnAttackStartedDispatch = false;
							return false;
						}
						text = <shot>5__4.TargetEnemyGuid;
						if (string.IsNullOrEmpty(text) && (Object)(object)val2 != (Object)null)
						{
							text = enemyId?.GetGuid(val2);
						}
						try
						{
							<reg>5__2?.Dispatch(new AttackStartedEvent
							{
								AnimTrigger = "attack",
								TargetEnemyGuid = text,
								NumPegsHit = <shot>5__4.NumPegsHit,
								IsCrit = (<shot>5__4.CriticalHitCount > 0),
								OrbName = <shot>5__4.OrbPrefabName,
								SlotIndex = <shot>5__4.SlotIndex
							});
						}
						catch
						{
						}
						try
						{
							AttackPerformed onAttackPerformed2 = AttackManager.OnAttackPerformed;
							if (onAttackPerformed2 != null)
							{
								onAttackPerformed2.Invoke("attack");
							}
						}
						catch
						{
						}
						<cap>5__6 = ClientAttackProjectile.Instance;
						if ((Object)(object)<cap>5__6 != (Object)null && !string.IsNullOrEmpty(text))
						{
							<cap>5__6.SetupAttack(text, <shot>5__4.NumPegsHit, <shot>5__4.CriticalHitCount > 0, <shot>5__4.OrbPrefabName);
						}
						<waited>5__7 = 0f;
						goto IL_0451;
						IL_07a7:
						if ((Object)(object)<cap>5__6 != (Object)null && <cap>5__6.IsAttacking && <reverseWaited>5__10 < 2f)
						{
							<reverseWaited>5__10 += Time.deltaTime;
							<>2__current = null;
							<>1__state = 4;
							return true;
						}
						list2 = new List<Enemy> { <reverseTarget>5__8 };
						ExpandTargetsForShooterRelics(em, <shot>5__4, <reverseTarget>5__8, list2);
						EnemySubscriptions.DamageAttributionSlotOverride = <shot>5__4.SlotIndex;
						try
						{
							foreach (Enemy item2 in list2)
							{
								if (!((Object)(object)item2 == (Object)null) && !(item2.CurrentHealth <= 0f))
								{
									item2.Damage(<shot>5__4.Damage, false, 0.25f, 1f, false, (EnemyDamageSource)2, true, false);
								}
							}
						}
						finally
						{
							EnemySubscriptions.DamageAttributionSlotOverride = -1;
						}
						logger4 = MultiplayerPlugin.Logger;
						if (logger4 != null)
						{
							logger4.LogInfo((object)$"[CoopAttack] Pincer reverse for slot {<shot>5__4.SlotIndex}: dmg={<shot>5__4.Damage} target={<reverseGuid>5__9} splashTargets={list2.Count}");
						}
						<reverseGuid>5__9 = null;
						goto IL_08df;
						IL_08df:
						<reverseTarget>5__8 = null;
						break;
					}
					<>2__current = (object)new WaitForSeconds(0.3f);
					<>1__state = 5;
					return true;
				}
				catch
				{
					//try-fault
					((IDisposable)this).Dispose();
					throw;
				}
			}

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

			private void <>m__Finally1()
			{
				<>1__state = -1;
				((IDisposable)<>7__wrap2).Dispose();
			}

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

		internal static string CapturedPreMapGenRngState;

		internal static string PendingRngStateToRestore;

		internal static string PendingBattleRngState;

		internal static bool MapControllerStartCompleted;

		internal static bool AllowNextSceneLoad;

		internal static bool ExecutingPendingShot;

		internal static bool AllowNativeRewardLogic;

		internal static bool AllowShopLogic;

		internal static bool AllowTreasureLogic;

		internal static bool AllowPegMinigameLogic;

		internal static bool AllowTextScenarioLogic;

		internal static bool AllowNavigateLogic;

		internal static int ClientChosenPostBattleRelicEffect = -1;

		internal static string ClientChosenPostBattleRelicName;

		internal static GameObject _firedBallGO;

		internal static float _firedBallTimer;

		internal static int _firedBallLogCount;

		internal static bool ClientShotSentThisTurn;

		internal static bool _clientDiscardSentThisTurn;

		internal static float _clientAimSendTimer;

		internal const float ClientAimSendInterval = 0.1f;

		internal static bool _clientBallInitialized;

		internal static GameObject _clientBallGO;

		internal static string _clientBallOrbName;

		internal static string _clientPendingOrbName;

		internal static GameObject _clientTrajectoryGO;

		internal static LineRenderer _clientTrajectoryLR;

		internal static float _clientFireForce;

		internal static float _clientBallMass;

		internal static float _clientGravityScale;

		internal static int _clientBallRetryCount;

		internal const int MaxBallRetries = 30;

		internal static readonly List<RaycastResult> _uiRaycastBuf = new List<RaycastResult>(8);

		internal static readonly Collider2D[] _enemyOverlapBuf = (Collider2D[])(object)new Collider2D[8];

		internal static bool _executingPendingDiscard;

		internal static int _stuckPendingShotSlot = -1;

		internal static float _stuckPendingShotSinceUnscaledTime;

		internal static int _stuckPendingShotRedraws;

		internal static float _stuckPendingShotLastWarnTime;

		internal static float _shotFiredUnscaledTime;

		internal static float _stuckCompletionSinceUnscaledTime;

		internal static float _stuckCompletionScanTimer;

		internal static bool AllowStatusEffectSync;

		internal static readonly Dictionary<string, int> _orbPierceCache = new Dictionary<string, int>();

		internal static readonly Dictionary<string, OrbShotInfo> _orbShotInfoCache = new Dictionary<string, OrbShotInfo>();

		internal static string LastAttackAnimTrigger;

		internal static string LastAttackTargetGuid;

		internal static int LastAttackNumPegsHit;

		internal static bool LastAttackIsCrit;

		internal static string LastAttackOrbName;

		internal static bool SuppressOnAttackStartedDispatch;

		internal static bool AllowRelicSync;

		internal static bool AllowCurrencySync;

		public static bool AllowMirrorEventLogic;

		public static bool AllowTextScenarioNavigation;

		internal static readonly List<ShopPurchase> ClientShopPurchases = new List<ShopPurchase>();

		internal static int ClientShopStartGold;

		internal static readonly FieldInfo _bombsRegularField = AccessTools.Field(typeof(BattleController), "_bombsToThrowRegular");

		internal static readonly FieldInfo _bombsRiggedField = AccessTools.Field(typeof(BattleController), "_bombsToThrowRigged");

		internal static bool _spiritRadiaHostSubscribed;

		internal static bool ShouldSuppressClientLogic
		{
			get
			{
				if (MultiplayerPlugin.Services == null)
				{
					return false;
				}
				if (!MultiplayerPlugin.Services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return false;
				}
				return instance.IsSpectating;
			}
		}

		internal static bool IsHosting
		{
			get
			{
				if (MultiplayerPlugin.Services == null)
				{
					return false;
				}
				if (!MultiplayerPlugin.Services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return false;
				}
				return instance.IsHosting;
			}
		}

		public static GameObject PrimaryBall => _firedBallGO;

		public static void SetRelicManagerClass(Class chosenClass)
		{
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RelicManager[] array = Resources.FindObjectsOfTypeAll<RelicManager>();
				if (array == null || array.Length == 0)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[ClientPatches] RelicManager not found — shop relics may be wrong class");
					}
					return;
				}
				RelicManager val = array[0];
				val.PopulateRelicPools(chosenClass);
				try
				{
					val.SetupInternalRelicPools();
				}
				catch (Exception ex)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)("[ClientPatches] SetupInternalRelicPools failed: " + ex.Message));
					}
				}
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)$"[ClientPatches] Called RelicManager.PopulateRelicPools({chosenClass}) + SetupInternalRelicPools");
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("[ClientPatches] SetRelicManagerClass failed: " + ex2.Message));
				}
			}
		}

		public static void SetCruciballManagerClass(Class chosenClass)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CruciballManager[] array = Resources.FindObjectsOfTypeAll<CruciballManager>();
				if (array == null || array.Length == 0)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[ClientPatches] CruciballManager not found — class sprite may be wrong");
					}
					return;
				}
				array[0].currentClass = chosenClass;
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[ClientPatches] Set CruciballManager.currentClass = {chosenClass}");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[ClientPatches] SetCruciballManagerClass failed: " + ex.Message));
				}
			}
		}

		public static void SetCruciballManagerLevel(int level)
		{
			try
			{
				CruciballManager[] array = Resources.FindObjectsOfTypeAll<CruciballManager>();
				if (array == null || array.Length == 0)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[ClientPatches] CruciballManager not found — cruciball level not applied");
					}
					return;
				}
				array[0].currentCruciballLevel = level;
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[ClientPatches] Set CruciballManager.currentCruciballLevel = {level}");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[ClientPatches] SetCruciballManagerLevel failed: " + ex.Message));
				}
			}
		}

		public static void SetStartingLoadoutFromClass(Class chosenClass)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0069: 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)
			ClassLoadoutPairs[] classLoadouts = StaticGameData.classLoadouts;
			if (classLoadouts == null || classLoadouts.Length == 0)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)"[ClientPatches] StaticGameData.classLoadouts is null/empty — cannot set starting orbs");
				}
				return;
			}
			ClassLoadoutData val = null;
			ClassLoadoutPairs[] array = classLoadouts;
			foreach (ClassLoadoutPairs val2 in array)
			{
				if (val2.Class == chosenClass)
				{
					val = val2.Loadout;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)$"[ClientPatches] No ClassLoadoutData found for class {chosenClass}");
				}
				return;
			}
			StaticGameData.StartingOrbs = val.StartingOrbs?.ToArray();
			StaticGameData.StartingRelics = val.StartingRelics?.ToArray();
			ManualLogSource logger3 = MultiplayerPlugin.Logger;
			if (logger3 != null)
			{
				string text = $"[ClientPatches] Set starting loadout for {chosenClass}: ";
				GameObject[] startingOrbs = StaticGameData.StartingOrbs;
				object arg = ((startingOrbs != null) ? startingOrbs.Length : 0);
				Relic[] startingRelics = StaticGameData.StartingRelics;
				logger3.LogInfo((object)(text + $"{arg} orbs, {((startingRelics != null) ? startingRelics.Length : 0)} relics"));
			}
		}

		private static GameObject FindOrbPrefabByName(DeckManager dm, string cleanName)
		{
			if (string.IsNullOrEmpty(cleanName))
			{
				return null;
			}
			if (dm?.battleDeck != null)
			{
				foreach (GameObject item in dm.battleDeck)
				{
					if ((Object)(object)item != (Object)null && ((Object)item).name.Replace("(Clone)", string.Empty).Trim() == cleanName)
					{
						return item;
					}
				}
			}
			if (DeckManager.completeDeck != null)
			{
				foreach (GameObject item2 in DeckManager.completeDeck)
				{
					if ((Object)(object)item2 != (Object)null && ((Object)item2).name.Replace("(Clone)", string.Empty).Trim() == cleanName)
					{
						return item2;
					}
				}
			}
			AssetLoading instance = AssetLoading.Instance;
			if (instance == null)
			{
				return null;
			}
			return instance.GetOrbPrefab(cleanName);
		}

		internal static void ResetClientAimingBall()
		{
			_clientDiscardSentThisTurn = false;
			CleanupClientAiming();
		}

		internal static void CleanupClientAiming()
		{
			if ((Object)(object)_clientBallGO != (Object)null)
			{
				try
				{
					PachinkoBall component = _clientBallGO.GetComponent<PachinkoBall>();
					if ((Object)(object)component != (Object)null)
					{
						object? obj = AccessTools.Field(typeof(PachinkoBall), "_predictionManager")?.GetValue(component);
						PredictionManager val = (PredictionManager)((obj is PredictionManager) ? obj : null);
						try
						{
							if (val != null)
							{
								val.PlayerFired();
							}
						}
						catch
						{
						}
					}
					BattleController val2 = Object.FindObjectOfType<BattleController>();
					if ((Object)(object)val2 != (Object)null)
					{
						FieldInfo fieldInfo = AccessTools.Field(typeof(BattleController), "_activePachinkoBall");
						if (fieldInfo?.GetValue(val2) == _clientBallGO)
						{
							fieldInfo.SetValue(val2, null);
						}
					}
				}
				catch
				{
				}
				Object.Destroy((Object)(object)_clientBallGO);
				_clientBallGO = null;
			}
			if ((Object)(object)_clientTrajectoryGO != (Object)null)
			{
				Object.Destroy((Object)(object)_clientTrajectoryGO);
				_clientTrajectoryGO = null;
			}
			_clientTrajectoryLR = null;
			_clientBallInitialized = false;
			_clientBallRetryCount = 0;
			_clientDiscardSentThisTurn = false;
			_clientBallOrbName = null;
		}

		internal static void HandleClientAiming(BattleController bc)
		{
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: 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_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_05b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0610: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			if (_clientBallInitialized)
			{
				string text = _clientPendingOrbName;
				if (string.IsNullOrEmpty(text))
				{
					text = ClientBallRenderer.Instance?.CurrentOrbName;
				}
				string text2 = text?.Replace("(Clone)", string.Empty).Trim();
				if (!string.IsNullOrEmpty(text2) && text2 != _clientBallOrbName)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)("[ClientAim] Orb identity changed: was '" + _clientBallOrbName + "' now '" + text2 + "' — rebuilding aimer"));
					}
					CleanupClientAiming();
				}
			}
			if (_clientBallInitialized || _clientBallRetryCount >= 30)
			{
				return;
			}
			CleanupClientAiming();
			Vector2 val = bc.pachinkoBallSpawnLocation;
			if (val == Vector2.zero)
			{
				GameObject val2 = GameObject.FindGameObjectWithTag("Player");
				if ((Object)(object)val2 != (Object)null)
				{
					val = Vector2.op_Implicit(val2.transform.position);
				}
			}
			try
			{
				DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
				DeckManager val3 = ((array.Length != 0) ? array[0] : null);
				if ((Object)(object)val3 == (Object)null)
				{
					_clientBallRetryCount++;
					if (_clientBallRetryCount == 1 || _clientBallRetryCount == 30)
					{
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogWarning((object)$"[ClientAim] No DeckManager (retry {_clientBallRetryCount})");
						}
					}
					return;
				}
				Stack<GameObject> stack = AccessTools.Field(typeof(DeckManager), "shuffledDeck")?.GetValue(val3) as Stack<GameObject>;
				GameObject val4 = null;
				string text3 = _clientPendingOrbName;
				if (string.IsNullOrEmpty(text3))
				{
					text3 = ClientBallRenderer.Instance?.CurrentOrbName;
				}
				string text4 = text3?.Replace("(Clone)", string.Empty).Trim();
				if (!string.IsNullOrEmpty(text4))
				{
					val4 = FindOrbPrefabByName(val3, text4);
				}
				if ((Object)(object)val4 == (Object)null && stack != null && stack.Count > 0)
				{
					val4 = stack.Peek();
				}
				if ((Object)(object)val4 == (Object)null && DeckManager.completeDeck != null && DeckManager.completeDeck.Count > 0)
				{
					val4 = DeckManager.completeDeck[0];
				}
				if ((Object)(object)val4 == (Object)null)
				{
					_clientBallRetryCount++;
					if (_clientBallRetryCount == 1 || _clientBallRetryCount == 30)
					{
						ManualLogSource logger3 = MultiplayerPlugin.Logger;
						if (logger3 != null)
						{
							logger3.LogWarning((object)$"[ClientAim] No orb prefab (shuffled={stack?.Count ?? (-1)}, complete={DeckManager.completeDeck?.Count ?? (-1)}, retry {_clientBallRetryCount})");
						}
					}
					return;
				}
				_clientBallGO = Object.Instantiate<GameObject>(val4, Vector2.op_Implicit(val), Quaternion.identity);
				_clientBallGO.SetActive(true);
				PachinkoBall component = _clientBallGO.GetComponent<PachinkoBall>();
				Rigidbody2D component2 = _clientBallGO.GetComponent<Rigidbody2D>();
				_clientFireForce = (((Object)(object)component != (Object)null) ? component.FireForce : 400f);
				_clientBallMass = (((Object)(object)component2 != (Object)null) ? component2.mass : 1f);
				_clientGravityScale = (((Object)(object)component != (Object)null) ? component.GravityScale : 1.2f);
				if (_clientGravityScale < 0f)
				{
					_clientGravityScale = 0f - _clientGravityScale;
				}
				if ((Object)(object)component2 != (Object)null)
				{
					component2.simulated = false;
				}
				AccessTools.Field(typeof(BattleController), "_activePachinkoBall")?.SetValue(bc, _clientBallGO);
				if ((Object)(object)component != (Object)null)
				{
					RelicManager val5 = Resources.FindObjectsOfTypeAll<RelicManager>()?.FirstOrDefault();
					PredictionManager predictionManager = bc.PredictionManager;
					PlayerStatusEffectController val6 = Object.FindObjectOfType<PlayerStatusEffectController>();
					component.Init(val5, val3, Vector2.right, predictionManager, val6);
					SummoningCirclePachinkoBall val7 = (SummoningCirclePachinkoBall)(object)((component is SummoningCirclePachinkoBall) ? component : null);
					if (val7 != null)
					{
						try
						{
							val7.InitSummoningCircle(val3, Vector2.op_Implicit(val));
						}
						catch (Exception ex)
						{
							ManualLogSource logger4 = MultiplayerPlugin.Logger;
							if (logger4 != null)
							{
								logger4.LogWarning((object)("[ClientAim] InitSummoningCircle failed: " + ex.GetType().Name + ": " + ex.Message));
							}
						}
					}
					component.InitializeMembers();
					try
					{
						component.Arm();
					}
					catch (Exception ex2)
					{
						ManualLogSource logger5 = MultiplayerPlugin.Logger;
						if (logger5 != null)
						{
							logger5.LogWarning((object)("[ClientAim] Arm() failed (non-fatal): " + ex2.GetType().Name + ": '" + ex2.Message + "' pm=" + (((Object)(object)predictionManager == (Object)null) ? "null" : "ok") + " trajSim=" + (((Object)(object)((Component)component).GetComponent<TrajectorySimulation>() == (Object)null) ? "null" : "ok") + "\n" + ex2.StackTrace));
						}
					}
					try
					{
						component.SetTrajectorySimulationRadius();
					}
					catch (Exception ex3)
					{
						ManualLogSource logger6 = MultiplayerPlugin.Logger;
						if (logger6 != null)
						{
							logger6.LogWarning((object)("[ClientAim] SetTrajectorySimulationRadius failed: " + ex3.GetType().Name + ": " + ex3.Message));
						}
					}
					TrajectorySimulation component3 = ((Component)component).GetComponent<TrajectorySimulation>();
					if ((Object)(object)component3 != (Object)null)
					{
						((Behaviour)component3).enabled = true;
					}
					AccessTools.Property(typeof(PachinkoBall), "CurrentState")?.GetSetMethod(nonPublic: true)?.Invoke(component, new object[1] { (object)(FireballState)1 });
				}
				_clientBallInitialized = true;
				_clientBallRetryCount = 0;
				_clientBallOrbName = ((Object)val4).name?.Replace("(Clone)", string.Empty).Trim();
				_clientPendingOrbName = null;
				ManualLogSource logger7 = MultiplayerPlugin.Logger;
				if (logger7 != null)
				{
					logger7.LogInfo((object)($"[ClientAim] Created ball '{_clientBallOrbName}' at ({val.x:F1},{val.y:F1}), " + $"fireForce={_clientFireForce}, mass={_clientBallMass}, gravity={_clientGravityScale}, " + $"state={((component != null) ? new FireballState?(component.CurrentState) : null)}, active={_clientBallGO.activeInHierarchy}"));
				}
			}
			catch (Exception arg)
			{
				_clientBallRetryCount++;
				ManualLogSource logger8 = MultiplayerPlugin.Logger;
				if (logger8 != null)
				{
					logger8.LogError((object)$"[ClientAim] Failed to create ball (retry {_clientBallRetryCount}): {arg}");
				}
				if ((Object)(object)_clientBallGO != (Object)null)
				{
					Object.Destroy((Object)(object)_clientBallGO);
					_clientBallGO = null;
				}
			}
		}

		internal static bool IsPointerOverUI()
		{
			EventSystem current = EventSystem.current;
			if ((Object)(object)current != (Object)null)
			{
				return current.IsPointerOverGameObject();
			}
			return false;
		}

		internal static bool IsPointerOverInteractiveUI()
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Expected O, but got Unknown
			//IL_0053: 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)
			EventSystem current = EventSystem.current;
			if ((Object)(object)current == (Object)null)
			{
				return false;
			}
			if (!current.IsPointerOverGameObject())
			{
				return false;
			}
			try
			{
				PointerEventData val = new PointerEventData(current)
				{
					position = Vector2.op_Implicit(Input.mousePosition)
				};
				_uiRaycastBuf.Clear();
				current.RaycastAll(val, _uiRaycastBuf);
				for (int i = 0; i < _uiRaycastBuf.Count; i++)
				{
					RaycastResult val2 = _uiRaycastBuf[i];
					GameObject gameObject = ((RaycastResult)(ref val2)).gameObject;
					if (!((Object)(object)gameObject == (Object)null) && (Object)(object)gameObject.GetComponentInParent<Button>() != (Object)null)
					{
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		internal static bool IsPointerOverEnemy()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Camera main = Camera.main;
				if ((Object)(object)main == (Object)null)
				{
					return false;
				}
				Vector3 val = main.ScreenToWorldPoint(Input.mousePosition);
				int num = Physics2D.OverlapPointNonAlloc(new Vector2(val.x, val.y), _enemyOverlapBuf);
				for (int i = 0; i < num; i++)
				{
					Collider2D val2 = _enemyOverlapBuf[i];
					if (!((Object)(object)val2 == (Object)null) && (Object)(object)((Component)val2).GetComponentInParent<Enemy>() != (Object)null)
					{
						return true;
					}
				}
			}
			catch
			{
			}
			return false;
		}

		internal static void TrySendDirectShot()
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Camera main = Camera.main;
				if ((Object)(object)main == (Object)null)
				{
					return;
				}
				Vector3 position = _clientBallGO.transform.position;
				Vector2 val = Vector2.op_Implicit(main.ScreenToWorldPoint(Input.mousePosition) - position);
				Vector2 normalized = ((Vector2)(ref val)).normalized;
				if (((Vector2)(ref normalized)).sqrMagnitude < 0.0001f)
				{
					return;
				}
				string text = null;
				try
				{
					TargetingManager val2 = Object.FindObjectOfType<TargetingManager>();
					IServiceContainer services = MultiplayerPlugin.Services;
					if ((Object)(object)((val2 != null) ? val2.currentTarget : null) != (Object)null && services != null && services.TryResolve<EnemyIdentifier>(out var instance))
					{
						text = instance.GetGuid(val2.currentTarget);
					}
				}
				catch
				{
				}
				IServiceContainer services2 = MultiplayerPlugin.Services;
				if (services2 != null && services2.TryResolve<IMessageSender>(out var instance2))
				{
					instance2.Send(new ShootRequestEvent
					{
						AimDirectionX = normalized.x,
						AimDirectionY = normalized.y,
						TargetEnemyGuid = text
					});
					ClientShotSentThisTurn = true;
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)string.Format("[ClientAim] Direct click → ShootRequest: aim=({0:F2},{1:F2}), target={2}", normalized.x, normalized.y, text ?? "auto"));
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[ClientAim] TrySendDirectShot failed: " + ex.GetType().Name + ": " + ex.Message));
				}
			}
		}

		internal static void SendClientAimUpdate()
		{
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_clientBallGO == (Object)null)
			{
				return;
			}
			PachinkoBall component = _clientBallGO.GetComponent<PachinkoBall>();
			if ((Object)(object)component == (Object)null)
			{
				return;
			}
			Vector2 aimVector = component.aimVector;
			if (!(aimVector == Vector2.zero))
			{
				Vector3 position = ((Component)component).transform.position;
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMessageSender>(out var instance))
				{
					instance.Send(new AimUpdateEvent
					{
						AimX = aimVector.x,
						AimY = aimVector.y,
						SpawnX = position.x,
						SpawnY = position.y
					});
				}
			}
		}

		internal static void DrawClientTrajectory(Vector3 start, Vector2 aimDir)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: 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_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			Vector3[] array = (Vector3[])(object)new Vector3[20]
			{
				start,
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3),
				default(Vector3)
			};
			Vector3 val = Vector2.op_Implicit(aimDir * (_clientFireForce * Time.fixedDeltaTime) / _clientBallMass);
			for (int i = 1; i < 20; i++)
			{
				float num = ((((Vector3)(ref val)).sqrMagnitude > 0f) ? (1f / ((Vector3)(ref val)).magnitude) : 0f);
				val += Physics.gravity * (_clientGravityScale * num);
				array[i] = array[i - 1] + val * num;
			}
			_clientTrajectoryLR.positionCount = 20;
			_clientTrajectoryLR.SetPositions(array);
		}

		[HarmonyPatch(typeof(PeglinSceneLoader), "LoadScene", new Type[]
		{
			typeof(Scene),
			typeof(LoadSceneMode),
			typeof(bool),
			typeof(float)
		})]
		[HarmonyPrefix]
		public static bool PeglinSceneLoader_LoadScene_Prefix(Scene scene)
		{
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			if (!ShouldSuppressClientLogic)
			{
				return true;
			}
			if (AllowNextSceneLoad)
			{
				AllowNextSceneLoad = false;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[ClientPatches] ALLOWING scene load: {scene} (sync-initiated)");
				}
				return true;
			}
			ManualLogSource logger2 = MultiplayerPlugin.Logger;
			if (logger2 != null)
			{
				logger2.LogWarning((object)$"[ClientPatches] BLOCKED scene load: {scene} (not sync-initiated)");
			}
			return false;
		}

		[HarmonyPatch(typeof(MapController), "Awake")]
		[HarmonyPostfix]
		public static void MapController_Awake_Postfix(MapController __instance)
		{
			if (!IsHosting && ShouldSuppressClientLogic && !((Object)(object)__instance == (Object)null) && !((Object)(object)MapController.instance != (Object)(object)__instance))
			{
				MapStateApplier.ApplyCachedOnAwake(__instance, MultiplayerPlugin.Logger);
			}
		}

		internal static string DescribeShuffleCaller()
		{
			try
			{
				StackTrace stackTrace = new StackTrace(2, fNeedFileInfo: false);
				List<string> list = new List<string>();
				for (int i = 0; i < stackTrace.FrameCount; i++)
				{
					if (list.Count >= 3)
					{
						break;
					}
					MethodBase methodBase = stackTrace.GetFrame(i)?.GetMethod();
					if (!(methodBase == null))
					{
						string text = methodBase.DeclaringType?.FullName ?? "?";
						if (!text.StartsWith("HarmonyLib") && !text.StartsWith("System.") && !text.Contains("DMD<") && !text.Contains("MultiplayerClientPatches"))
						{
							list.Add((methodBase.DeclaringType?.Name ?? "?") + "." + methodBase.Name);
						}
					}
				}
				return (list.Count == 0) ? "<unknown>" : string.Join(" > ", list);
			}
			catch
			{
				return "<stacktrace-failed>";
			}
		}

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

		[IteratorStateMachine(typeof(<PlayCoopAttackSequence>d__67))]
		internal static IEnumerator PlayCoopAttackSequence(BattleController bc, AttackManager am, List<PlayerAttackData> shots, EnemyManager em, EnemyIdentifier enemyId)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <PlayCoopAttackSequence>d__67(0)
			{
				bc = bc,
				am = am,
				shots = shots,
				em = em,
				enemyId = enemyId
			};
		}

		internal static void ApplyCoopHeal(PlayerAttackData shot, EnemyManager em, EnemyIdentifier enemyId, IGameEventRegistry reg)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<CoopStateManager>(out var instance))
			{
				return;
			}
			CoopPlayerState playerState = instance.GetPlayerState(shot.SlotIndex);
			if (playerState == null)
			{
				return;
			}
			float currentHealth = playerState.CurrentHealth;
			float num = Mathf.Min(playerState.MaxHealth, currentHealth + (float)shot.Damage);
			float num2 = num - currentHealth;
			if (num2 <= 0f)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)($"[CoopAttack] Heal slot {shot.SlotIndex} ({shot.PlayerName}): " + $"already at full hp ({currentHealth}/{playerState.MaxHealth}), no heal applied"));
				}
				return;
			}
			playerState.CurrentHealth = num;
			if (instance.ActivePlayerSlot == shot.SlotIndex)
			{
				try
				{
					PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
					if ((Object)(object)val != (Object)null)
					{
						object? obj = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth")?.GetValue(val);
						object? obj2 = ((obj is FloatVariable) ? obj : null);
						if (obj2 != null)
						{
							((FloatVariable)obj2).Set(num);
						}
					}
				}
				catch
				{
				}
			}
			try
			{
				reg?.Dispatch(new PlayerHealedEvent
				{
					Amount = num2,
					RemainingHealth = num,
					TargetSlotIndex = shot.SlotIndex
				});
			}
			catch
			{
			}
			float num3 = 0f;
			float num4 = 0f;
			try
			{
				AssetLoading instance2 = AssetLoading.Instance;
				GameObject obj5 = ((instance2 != null) ? instance2.GetOrbPrefab(shot.OrbPrefabName) : null);
				HealAction val2 = ((obj5 != null) ? obj5.GetComponent<HealAction>() : null);
				if ((Object)(object)val2 != (Object)null)
				{
					num3 = val2.damageTargetedEnemyMultiplier;
					num4 = val2.damageAllEnemiesMultiplier;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[CoopAttack] Failed to read HealAction multipliers for " + shot.OrbPrefabName + ": " + ex.Message));
				}
			}
			if (num3 > 0f && (Object)(object)em != (Object)null)
			{
				int num5 = Mathf.RoundToInt(num2 * num3);
				if (num5 > 0)
				{
					Enemy val3 = null;
					if (!string.IsNullOrEmpty(shot.TargetEnemyGuid))
					{
						val3 = enemyId?.Find(shot.TargetEnemyGuid);
					}
					if ((Object)(object)val3 == (Object)null || val3.CurrentHealth <= 0f)
					{
						val3 = em.GetFarthestEnemyFromPlayer();
					}
					if ((Object)(object)val3 != (Object)null && val3.CurrentHealth > 0f)
					{
						EnemySubscriptions.DamageAttributionSlotOverride = shot.SlotIndex;
						try
						{
							val3.Damage((long)num5, false, 0.25f, 1f, false, (EnemyDamageSource)2, true, false);
						}
						finally
						{
							EnemySubscriptions.DamageAttributionSlotOverride = -1;
						}
					}
				}
			}
			else if (num4 > 0f && (Object)(object)em != (Object)null)
			{
				int num6 = Mathf.RoundToInt(num2 * num4);
				if (num6 > 0)
				{
					EnemySubscriptions.DamageAttributionSlotOverride = shot.SlotIndex;
					try
					{
						foreach (Enemy enemy in em.Enemies)
						{
							if ((Object)(object)enemy != (Object)null && enemy.CurrentHealth > 0f)
							{
								enemy.Damage((long)num6, false, 0.25f, 1f, false, (EnemyDamageSource)3, true, false);
							}
						}
					}
					finally
					{
						EnemySubscriptions.DamageAttributionSlotOverride = -1;
					}
				}
			}
			ManualLogSource logger3 = MultiplayerPlugin.Logger;
			if (logger3 != null)
			{
				logger3.LogInfo((object)($"[CoopAttack] Heal slot {shot.SlotIndex} ({shot.PlayerName}): " + $"orb={shot.OrbPrefabName} healed={num2} ({currentHealth}→{num}/{playerState.MaxHealth}) " + $"targetedMult={num3} allMult={num4}"));
			}
		}

		internal static void ApplyStatusEffectsToEnemy(Enemy enemy, List<(StatusEffectType Type, int Intensity)> effects)
		{
			//IL_006f: 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_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Expected O, but got Unknown
			if (effects == null || effects.Count == 0 || (Object)(object)enemy == (Object)null || enemy.CurrentHealth <= 0f)
			{
				return;
			}
			foreach (var (val, num) in effects)
			{
				if ((int)val == 0)
				{
					continue;
				}
				try
				{
					enemy.ApplyStatusEffect(new StatusEffect(val, num), (StatusEffectSource)0, true, false);
				}
				catch (Exception ex)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[CoopAttack] Failed to apply {val}({num}) to {((Object)enemy).name}: {ex.Message}");
					}
				}
			}
		}

		internal static void ExpandTargetsForShooterRelics(EnemyManager em, PlayerAttackData shot, Enemy primaryTarget, List<Enemy> targets)
		{
			//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: 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)
			if ((Object)(object)em == (Object)null || shot == null || (Object)(object)primaryTarget == (Object)null || shot.IsAoE || (!shot.HasTargetedSplash && !shot.HasTargetedHitAll))
			{
				return;
			}
			try
			{
				if (shot.HasTargetedHitAll)
				{
					foreach (Enemy enemy in em.Enemies)
					{
						if (!((Object)(object)enemy == (Object)null) && !(enemy.CurrentHealth <= 0f) && !targets.Contains(enemy))
						{
							targets.Add(enemy);
						}
					}
					return;
				}
				bool flag = default(bool);
				int slotIndexForEnemy = em.GetSlotIndexForEnemy(primaryTarget, ref flag);
				SlotType slotForEnemy = em.GetSlotForEnemy(primaryTarget);
				Enemy[] splashRangeEnemies = em.GetSplashRangeEnemies((float)slotIndexForEnemy, slotForEnemy, 1, (AoeType)0);
				if (splashRangeEnemies == null)
				{
					return;
				}
				Enemy[] array = splashRangeEnemies;
				foreach (Enemy val in array)
				{
					if (!((Object)(object)val == (Object)null) && !(val.CurrentHealth <= 0f) && !targets.Contains(val))
					{
						targets.Add(val);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopAttack] ExpandTargetsForShooterRelics failed: " + ex.Message));
				}
			}
		}

		internal static void ExtendTargetsForTranspherency(EnemyManager em, List<Enemy> targets)
		{
			if ((Object)(object)em == (Object)null || targets == null || targets.Count == 0)
			{
				return;
			}
			try
			{
				bool flag = default(bool);
				for (int i = 0; i < 16; i++)
				{
					Enemy val = targets[targets.Count - 1];
					if ((Object)(object)val == (Object)null || val.CurrentHealth <= 0f || val.GetEffect((StatusEffectType)33) == null)
					{
						break;
					}
					Enemy val2 = null;
					float num = float.PositiveInfinity;
					float num2;
					try
					{
						num2 = em.GetSlotIndexForEnemy(val, ref flag);
					}
					catch
					{
						break;
					}
					foreach (Enemy enemy in em.Enemies)
					{
						if (!((Object)(object)enemy == (Object)null) && !(enemy.CurrentHealth <= 0f) && !targets.Contains(enemy))
						{
							float num3;
							try
							{
								num3 = em.GetSlotIndexForEnemy(enemy, ref flag);
							}
							catch
							{
								continue;
							}
							if (num3 > num2 && num3 < num)
							{
								val2 = enemy;
								num = num3;
							}
						}
					}
					if ((Object)(object)val2 == (Object)null)
					{
						break;
					}
					targets.Add(val2);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopAttack] ExtendTargetsForTranspherency failed: " + ex.Message));
				}
			}
		}

		internal static int GetOrbPierceCount(string orbPrefabName)
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Invalid comparison between Unknown and I4
			if (string.IsNullOrEmpty(orbPrefabName))
			{
				return 0;
			}
			if (_orbPierceCache.TryGetValue(orbPrefabName, out var value))
			{
				return value;
			}
			int num = 0;
			try
			{
				AssetLoading instance = AssetLoading.Instance;
				GameObject val = ((instance != null) ? instance.GetOrbPrefab(orbPrefabName) : null);
				if ((Object)(object)val != (Object)null)
				{
					ProjectileAttack component = val.GetComponent<ProjectileAttack>();
					if ((Object)(object)component != (Object)null)
					{
						object? obj = AccessTools.Field(typeof(ProjectileAttack), "_shotPrefab")?.GetValue(component);
						GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
						if ((Object)(object)val2 != (Object)null)
						{
							ShotBehavior component2 = val2.GetComponent<ShotBehavior>();
							if ((Object)(object)component2 != (Object)null)
							{
								FieldInfo fieldInfo = AccessTools.Field(typeof(ShotBehavior), "_shotType");
								FieldInfo fieldInfo2 = AccessTools.Field(typeof(ShotBehavior), "_enemiesToPierce");
								ShotType val3 = (ShotType)(fieldInfo?.GetValue(component2) ?? ((object)0));
								int num2 = (int)(fieldInfo2?.GetValue(component2) ?? ((object)0));
								if ((int)val3 == 2)
								{
									num = num2;
								}
							}
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopAttack] GetOrbPierceCount(" + orbPrefabName + ") failed: " + ex.Message));
				}
			}
			_orbPierceCache[orbPrefabName] = num;
			return num;
		}

		internal static List<Enemy> GetEnemiesBehindTarget(EnemyManager em, Enemy target, int count)
		{
			List<Enemy> list = new List<Enemy>();
			if ((Object)(object)em == (Object)null || (Object)(object)target == (Object)null || count <= 0)
			{
				return list;
			}
			float num;
			bool flag = default(bool);
			try
			{
				num = em.GetSlotIndexForEnemy(target, ref flag);
			}
			catch
			{
				return list;
			}
			List<(Enemy, float)> list2 = new List<(Enemy, float)>();
			foreach (Enemy enemy in em.Enemies)
			{
				if (!((Object)(object)enemy == (Object)null) && !((Object)(object)enemy == (Object)(object)target) && !(enemy.CurrentHealth <= 0f))
				{
					float num2;
					try
					{
						num2 = em.GetSlotIndexForEnemy(enemy, ref flag);
					}
					catch
					{
						continue;
					}
					if (num2 > num)
					{
						list2.Add((enemy, num2));
					}
				}
			}
			list2.Sort(((Enemy e, float slot) a, (Enemy e, float slot) b) => a.slot.CompareTo(b.slot));
			for (int i = 0; i < list2.Count; i++)
			{
				if (list.Count >= count)
				{
					break;
				}
				list.Add(list2[i].Item1);
			}
			return list;
		}

		internal static OrbShotInfo GetOrbShotInfo(string orbPrefabName)
		{
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(orbPrefabName))
			{
				return default(OrbShotInfo);
			}
			if (_orbShotInfoCache.TryGetValue(orbPrefabName, out var value))
			{
				return value;
			}
			OrbShotInfo orbShotInfo = default(OrbShotInfo);
			try
			{
				AssetLoading instance = AssetLoading.Instance;
				GameObject obj = ((instance != null) ? instance.GetOrbPrefab(orbPrefabName) : null);
				ProjectileAttack obj2 = ((obj != null) ? obj.GetComponent<ProjectileAttack>() : null);
				object? obj3 = AccessTools.Field(typeof(ProjectileAttack), "_shotPrefab")?.GetValue(obj2);
				object? obj4 = ((obj3 is GameObject) ? obj3 : null);
				ShotBehavior val = ((obj4 != null) ? ((GameObject)obj4).GetComponent<ShotBehavior>() : null);
				if ((Object)(object)val != (Object)null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(ShotBehavior), "_shotType");
					FieldInfo fieldInfo2 = AccessTools.Field(typeof(ShotBehavior), "_enemiesToPierce");
					FieldInfo fieldInfo3 = AccessTools.Field(typeof(ShotBehavior), "_canAimUp");
					orbShotInfo.ShotType = (ShotType)(fieldInfo?.GetValue(val) ?? ((object)0));
					orbShotInfo.EnemiesToPierce = (int)(fieldInfo2?.GetValue(val) ?? ((object)0));
					orbShotInfo.CanAimUp = (bool)(fieldInfo3?.GetValue(val) ?? ((object)true));
					orbShotInfo.Valid = true;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopAttack] GetOrbShotInfo(" + orbPrefabName + ") failed: " + ex.Message));
				}
			}
			_orbShotInfoCache[orbPrefabName] = orbShotInfo;
			return orbShotInfo;
		}

		internal static List<Enemy> ResolveShotTargetsViaRaycast(BattleController bc, EnemyManager em, Enemy declaredTarget, string orbPrefabName, int pierceCount)
		{
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Invalid comparison between Unknown and I4
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ba: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: 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_00a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0109: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_0117: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_013c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)bc == (Object)null || (Object)(object)em == (Object)null || (Object)(object)declaredTarget == (Object)null)
			{
				return null;
			}
			OrbShotInfo orbShotInfo = GetOrbShotInfo(orbPrefabName);
			if (orbShotInfo.Valid && (int)orbShotInfo.ShotType == 1)
			{
				return null;
			}
			object? obj = AccessTools.Field(typeof(BattleController), "_playerTransform")?.GetValue(bc);
			Transform val = (Transform)((obj is Transform) ? obj : null);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			Vector3 val2 = (Vector3)(AccessTools.Field(typeof(BattleController), "_playerTransformOffset")?.GetValue(bc) ?? ((object)new Vector3(1f, 0.5f, 0f)));
			Vector2 val3 = Vector2.op_Implicit(val.position + val2);
			Vector2 val4 = Vector2.op_Implicit(((Component)declaredTarget).transform.position) - val3;
			Vector2 normalized = ((Vector2)(ref val4)).normalized;
			if (((Vector2)(ref normalized)).sqrMagnitude < 0.0001f)
			{
				return null;
			}
			Vector3 val5 = Vector3.Cross(Vector2.op_Implicit(normalized), Vector3.back);
			Vector2 val6 = Vector2.op_Implicit(((Vector3)(ref val5)).normalized);
			List<RaycastHit2D> list = new List<RaycastHit2D>();
			list.AddRange(Physics2D.RaycastAll(val3, normalized, 50f));
			list.AddRange(Physics2D.RaycastAll(val3 + val6 * 0.08f, normalized, 50f));
			list.AddRange(Physics2D.RaycastAll(val3 - val6 * 0.08f, normalized, 50f));
			bool flag = !orbShotInfo.Valid || orbShotInfo.CanAimUp;
			Dictionary<Enemy, float> byEnemy = new Dictionary<Enemy, float>();
			Enemy val7 = default(Enemy);
			foreach (RaycastHit2D item in list)
			{
				RaycastHit2D current = item;
				if (!((Object)(object)((RaycastHit2D)(ref current)).collider == (Object)null) && ((Component)((RaycastHit2D)(ref current)).collider).TryGetComponent<Enemy>(ref val7) && !((Object)(object)val7 == (Object)null) && !(val7.CurrentHealth <= 0f) && !byEnemy.ContainsKey(val7) && (flag ? (declaredTarget.IsFlying == val7.IsFlying) : (!val7.IsFlying)))
				{
					byEnemy[val7] = ((RaycastHit2D)(ref current)).distance;
				}
			}
			if (byEnemy.Count == 0)
			{
				return null;
			}
			List<Enemy> list2 = new List<Enemy>(byEnemy.Keys);
			list2.Sort((Enemy a, Enemy b) => byEnemy[a].CompareTo(byEnemy[b]));
			int num = Math.Max(1, pierceCount + 1);
			if (list2.Count > num)
			{
				list2.RemoveRange(num, list2.Count - num);
			}
			return list2;
		}

		internal static string SerializeRandomState(State state)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Type typeFromHandle = typeof(State);
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
				object obj = state;
				int num = (int)typeFromHandle.GetField("s0", bindingAttr).GetValue(obj);
				int num2 = (int)typeFromHandle.GetField("s1", bindingAttr).GetValue(obj);
				int num3 = (int)typeFromHandle.GetField("s2", bindingAttr).GetValue(obj);
				int num4 = (int)typeFromHandle.GetField("s3", bindingAttr).GetValue(obj);
				return $"{num},{num2},{num3},{num4}";
			}
			catch
			{
				return null;
			}
		}

		internal static State? DeserializeRandomState(string s)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (string.IsNullOrEmpty(s))
				{
					return null;
				}
				string[] array = s.Split(',');
				if (array.Length != 4)
				{
					return null;
				}
				Random.InitState(0);
				State state = Random.state;
				Type typeFromHandle = typeof(State);
				BindingFlags bindingAttr = BindingFlags.Instance | BindingFlags.NonPublic;
				object obj = state;
				typeFromHandle.GetField("s0", bindingAttr).SetValue(obj, int.Parse(array[0]));
				typeFromHandle.GetField("s1", bindingAttr).SetValue(obj, int.Parse(array[1]));
				typeFromHandle.GetField("s2", bindingAttr).SetValue(obj, int.Parse(array[2]));
				typeFromHandle.GetField("s3", bindingAttr).SetValue(obj, int.Parse(array[3]));
				return (State)obj;
			}
			catch
			{
				return null;
			}
		}

		internal static PostBattleCompleteEvent CaptureClientPostBattleState()
		{
			PostBattleCompleteEvent postBattleCompleteEvent = new PostBattleCompleteEvent();
			PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
			if ((Object)(object)val != (Object)null)
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(PlayerHealthController), "_maxPlayerHealth");
				object? obj = fieldInfo?.GetValue(val);
				FloatVariable val2 = (FloatVariable)((obj is FloatVariable) ? obj : null);
				object? obj2 = fieldInfo2?.GetValue(val);
				FloatVariable val3 = (FloatVariable)((obj2 is FloatVariable) ? obj2 : null);
				postBattleCompleteEvent.CurrentHealth = ((val2 != null) ? val2.Value : 0f);
				postBattleCompleteEvent.MaxHealth = ((val3 != null) ? val3.Value : 0f);
			}
			CurrencyManager instance = CurrencyManager.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				postBattleCompleteEvent.Gold = instance.GoldAmount;
			}
			List<GameObject> completeDeck = DeckManager.completeDeck;
			if (completeDeck != null)
			{
				foreach (GameObject item in completeDeck)
				{
					if (!((Object)(object)item == (Object)null))
					{
						Attack component = item.GetComponent<Attack>();
						postBattleCompleteEvent.CompleteDeck.Add(new PostBattleOrbEntry
						{
							PrefabName = ((Object)item).name,
							Level = (((Object)(object)component != (Object)null) ? component.Level : 0)
						});
					}
				}
			}
			postBattleCompleteEvent.ChosenRelicEffect = ClientChosenPostBattleRelicEffect;
			postBattleCompleteEvent.ChosenRelicName = ClientChosenPostBattleRelicName;
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)($"[ClientPatches] Captured post-battle state: HP={postBattleCompleteEvent.CurrentHealth}/{postBattleCompleteEvent.MaxHealth} Gold={postBattleCompleteEvent.Gold} " + string.Format("Deck={0} orbs, chosenRelic={1} ({2})", postBattleCompleteEvent.CompleteDeck.Count, postBattleCompleteEvent.ChosenRelicEffect, postBattleCompleteEvent.ChosenRelicName ?? "none")));
			}
			return postBattleCompleteEvent;
		}

		internal static void CaptureAndSendTextScenarioState()
		{
			//IL_01e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Expected I4, but got Unknown
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Expected I4, but got Unknown
			if (CoopRewardState.ClientTextScenarioChoiceSent)
			{
				return;
			}
			try
			{
				AllowTextScenarioLogic = false;
				CoopRewardState.ClientTextScenarioChoiceSent = true;
				TextScenarioCompleteEvent textScenarioCompleteEvent = new TextScenarioCompleteEvent();
				OrbIdentifier instance = null;
				MultiplayerPlugin.Services?.TryResolve<OrbIdentifier>(out instance);
				if (DeckManager.completeDeck != null)
				{
					foreach (GameObject item in DeckManager.completeDeck)
					{
						if (!((Object)(object)item == (Object)null))
						{
							Attack component = item.GetComponent<Attack>();
							string prefabName = ((Object)item).name.Replace("(Clone)", string.Empty).Trim();
							string text = instance?.GetGuid(item);
							textScenarioCompleteEvent.CompleteDeck.Add(new SerializedOrb
							{
								PrefabName = prefabName,
								Guid = (text ?? Guid.NewGuid().ToString()),
								Level = (component?.Level ?? 1)
							});
						}
					}
				}
				PlayerHealthController[] array = Resources.FindObjectsOfTypeAll<PlayerHealthController>();
				foreach (PlayerHealthController val in array)
				{
					if ((Object)(object)val != (Object)null)
					{
						textScenarioCompleteEvent.CurrentHealth = val.CurrentHealth;
						textScenarioCompleteEvent.MaxHealth = val.MaxHealth;
						break;
					}
				}
				CurrencyManager instance2 = CurrencyManager.Instance;
				textScenarioCompleteEvent.Gold = ((instance2 != null) ? instance2.GoldAmount : 0);
				RelicManager[] array2 = Resources.FindObjectsOfTypeAll<RelicManager>();
				FieldInfo fieldInfo = AccessTools.Field(typeof(RelicManager), "_ownedRelics");
				RelicManager[] array3 = array2;
				foreach (RelicManager val2 in array3)
				{
					if ((Object)(object)val2 == (Object)null || !(fieldInfo?.GetValue(val2) is Dictionary<RelicEffect, Relic> dictionary))
					{
						continue;
					}
					foreach (KeyValuePair<RelicEffect, Relic> item2 in dictionary)
					{
						Relic value = item2.Value;
						if (!((Object)(object)value == (Object)null))
						{
							textScenarioCompleteEvent.Relics.Add(new SerializedRelic
							{
								Effect = (int)value.effect,
								LocKey = value.locKey,
								Rarity = (int)value.globalRarity
							});
						}
					}
					break;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMessageSender>(out var instance3))
				{
					instance3.Send(textScenarioCompleteEvent);
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)($"[ClientPatch] Sent TextScenarioCompleteEvent: deck={textScenarioCompleteEvent.CompleteDeck.Count}, " + $"hp={textScenarioCompleteEvent.CurrentHealth}/{textScenarioCompleteEvent.MaxHealth}, gold={textScenarioCompleteEvent.Gold}, relics={textScenarioCompleteEvent.Relics.Count}"));
					}
				}
				CoopRewardState.WaitingForOtherPlayers = true;
				CoopRewardState.AllChoicesComplete = false;
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogError((object)("[ClientPatch] Failed to send TextScenarioCompleteEvent: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}

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

		internal static HashSet<int> GetOwnedEffects(RelicManager rm)
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected I4, but got Unknown
			HashSet<int> hashSet = new HashSet<int>();
			if ((Object)(object)rm == (Object)null)
			{
				return hashSet;
			}
			try
			{
				if (AccessTools.Field(typeof(RelicManager), "_ownedRelics")?.GetValue(rm) is Dictionary<RelicEffect, Relic> dictionary)
				{
					foreach (RelicEffect key in dictionary.Keys)
					{
						hashSet.Add((int)key);
					}
				}
			}
			catch
			{
			}
			return hashSet;
		}

		internal static Relic PickRandomLocalRelic(RelicRarity rarity, RelicManager rm, int slotIndex = -1)
		{
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Expected I4, but got Unknown
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Expected I4, but got Unknown
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected I4, but got Unknown
			try
			{
				HashSet<int> ownedEffects = GetOwnedEffects(rm);
				Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
				List<Relic> list = new List<Relic>();
				Relic[] array2 = array;
				foreach (Relic val in array2)
				{
					if (!((Object)(object)val == (Object)null) && val.globalRarity == rarity && !ownedEffects.Contains((int)val.effect))
					{
						list.Add(val);
					}
				}
				if (list.Count == 0)
				{
					array2 = array;
					foreach (Relic val2 in array2)
					{
						if (!((Object)(object)val2 == (Object)null) && !ownedEffects.Contains((int)val2.effect))
						{
							list.Add(val2);
						}
					}
				}
				if (list.Count == 0)
				{
					return null;
				}
				list.Sort((Relic a, Relic b) => string.CompareOrdinal((a != null) ? ((Object)a).name : null, (b != null) ? ((Object)b).name : null));
				int index = ((slotIndex < 0) ? Random.Range(0, list.Count) : new Random((StaticGameData.currentSeed ?? string.Empty).GetHashCode() ^ (slotIndex * 7919) ^ (rarity * 31) ^ (StaticGameData.totalFloorCount * 104729)).Next(0, list.Count));
				return list[index];
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[ClientPatch] PickRandomLocalRelic failed: " + ex.Message));
				}
				return null;
			}
		}

		internal static List<Relic> PickMultipleLocalRelics(RelicRarity rarity, int count, RelicManager rm, int slotIndex)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Expected I4, but got Unknown
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_0113: Unknown result type (might be due to invalid IL or missing references)
			//IL_0119: Expected I4, but got Unknown
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_009b: Expected I4, but got Unknown
			List<Relic> list = new List<Relic>();
			try
			{
				if (count <= 0)
				{
					return list;
				}
				HashSet<int> ownedEffects = GetOwnedEffects(rm);
				Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
				List<Relic> list2 = new List<Relic>();
				Relic[] array2 = array;
				foreach (Relic val in array2)
				{
					if (!((Object)(object)val == (Object)null) && val.globalRarity == rarity && !ownedEffects.Contains((int)val.effect))
					{
						list2.Add(val);
					}
				}
				if (list2.Count == 0)
				{
					array2 = array;
					foreach (Relic val2 in array2)
					{
						if (!((Object)(object)val2 == (Object)null) && !ownedEffects.Contains((int)val2.effect))
						{
							list2.Add(val2);
						}
					}
				}
				if (list2.Count == 0)
				{
					return list;
				}
				list2.Sort((Relic a, Relic b) => string.CompareOrdinal((a != null) ? ((Object)a).name : null, (b != null) ? ((Object)b).name : null));
				Random random = new Random((StaticGameData.currentSeed ?? string.Empty).GetHashCode() ^ (slotIndex * 7919) ^ (rarity * 31) ^ (StaticGameData.totalFloorCount * 104729));
				int num = Math.Min(count, list2.Count);
				for (int j = 0; j < num; j++)
				{
					int index = j + random.Next(0, list2.Count - j);
					Relic value = list2[j];
					list2[j] = list2[index];
					list2[index] = value;
					list.Add(list2[j]);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[ClientPatch] PickMultipleLocalRelics failed: " + ex.Message));
				}
			}
			return list;
		}

		internal static Relic FindRelicByName(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
			foreach (Relic val in array)
			{
				if ((Object)(object)val != (Object)null && ((Object)val).name == name)
				{
					return val;
				}
			}
			return null;
		}

		internal static List<GameObject> ResolveOrbPrefabsByName(List<string> names, DeckManager deckMgr)
		{
			List<GameObject> list = new List<GameObject>();
			List<GameObject>[] array = new List<GameObject>[3] { deckMgr.CommonOrbPool, deckMgr.UncommonOrbPool, deckMgr.RareOrbPool };
			foreach (string name in names)
			{
				GameObject val = null;
				List<GameObject>[] array2 = array;
				foreach (List<GameObject> list2 in array2)
				{
					if (list2 == null)
					{
						continue;
					}
					foreach (GameObject item in list2)
					{
						if ((Object)(object)item != (Object)null && ((Object)item).name == name)
						{
							val = item;
							break;
						}
					}
					if ((Object)(object)val != (Object)null)
					{
						break;
					}
				}
				if ((Object)(object)val == (Object)null)
				{
					Attack[] array3 = Resources.FindObjectsOfTypeAll<Attack>();
					foreach (Attack val2 in array3)
					{
						if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).gameObject == (Object)null) && ((Object)((Component)val2).gameObject).name == name)
						{
							val = ((Component)val2).gameObject;
							break;
						}
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					list.Add(val);
				}
			}
			return list;
		}

		internal static void DispatchPreTransition()
		{
			try
			{
				if (MultiplayerPlugin.Services != null && MultiplayerPlugin.Services.TryResolve<IGameEventRegistry>(out var instance))
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)"[SpiritOfRadia] Host: dispatching Step=1 (pre-transition)");
					}
					instance.Dispatch(new SpiritOfRadiaPhaseTransitionEvent
					{
						Step = 1
					});
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[SpiritOfRadia] DispatchPreTransition failed: " + ex.Message));
				}
			}
		}

		internal static void DispatchMainTransition()
		{
			try
			{
				if (MultiplayerPlugin.Services != null && MultiplayerPlugin.Services.TryResolve<IGameEventRegistry>(out var instance))
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)"[SpiritOfRadia] Host: dispatching Step=2 (main transition)");
					}
					instance.Dispatch(new SpiritOfRadiaPhaseTransitionEvent
					{
						Step = 2
					});
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[SpiritOfRadia] DispatchMainTransition failed: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class PachinkoBallPatches
	{
		private static bool _navBallBroadcastThisPhase;

		[HarmonyPatch(typeof(PachinkoBall), "Fire")]
		[HarmonyPrefix]
		public static bool PachinkoBall_Fire_Prefix(PachinkoBall __instance)
		{
			//IL_010f: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0181: Unknown result type (might be due to invalid IL or missing references)
			//IL_018c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			if (MultiplayerClientPatches.IsHosting && LobbyUI.GameStartReceived && !MultiplayerClientPatches.ExecutingPendingShot)
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<TurnManager>(out var instance) && instance.CurrentPlayerSlot > 0)
				{
					return false;
				}
			}
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				if (MultiplayerClientPatches.AllowPegMinigameLogic)
				{
					return true;
				}
				if (MultiplayerClientPatches.AllowNavigateLogic)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[ClientPatches] Nav Fire allowed: aim=({__instance.aimVector.x:F2},{__instance.aimVector.y:F2})");
					}
					return true;
				}
				if (LobbyUI.GameStartReceived && TurnChangeClientHandler.IsMyTurn && !MultiplayerClientPatches.ClientShotSentThisTurn)
				{
					Vector2 aimVector = __instance.aimVector;
					IServiceContainer services2 = MultiplayerPlugin.Services;
					if (services2 != null && services2.TryResolve<IMessageSender>(out var instance2))
					{
						string text = null;
						try
						{
							TargetingManager val = Object.FindObjectOfType<TargetingManager>();
							if ((Object)(object)((val != null) ? val.currentTarget : null) != (Object)null && services2.TryResolve<EnemyIdentifier>(out var instance3))
							{
								text = instance3.GetGuid(val.currentTarget);
							}
						}
						catch
						{
						}
						instance2.Send(new ShootRequestEvent
						{
							AimDirectionX = aimVector.x,
							AimDirectionY = aimVector.y,
							TargetEnemyGuid = text
						});
						MultiplayerClientPatches.ClientShotSentThisTurn = true;
						object? obj2 = AccessTools.Field(typeof(PachinkoBall), "_predictionManager")?.GetValue(__instance);
						PredictionManager val2 = (PredictionManager)((obj2 is PredictionManager) ? obj2 : null);
						try
						{
							if (val2 != null)
							{
								val2.PlayerFired();
							}
						}
						catch
						{
						}
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogInfo((object)string.Format("[ClientPatches] Fire intercepted → ShootRequest: aim=({0:F2},{1:F2}), target={2}", aimVector.x, aimVector.y, text ?? "auto"));
						}
					}
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PachinkoBall), "Fire")]
		[HarmonyPostfix]
		public static void PachinkoBall_Fire_Postfix(PachinkoBall __instance)
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.IsHosting || (Object)(object)__instance == (Object)null || __instance.IsDummy)
			{
				return;
			}
			if (CoopNavigateState.PhaseActive && !CoopNavigateState.Resolved && !_navBallBroadcastThisPhase)
			{
				try
				{
					IServiceContainer services = MultiplayerPlugin.Services;
					if (services != null && services.TryResolve<IGameEventRegistry>(out var instance))
					{
						Vector3 position = ((Component)__instance).transform.position;
						Vector2 aimVector = __instance.aimVector;
						instance.Dispatch(new NavBallShotEvent
						{
							Slot = 0,
							OriginX = position.x,
							OriginY = position.y,
							AimX = aimVector.x,
							AimY = aimVector.y
						});
						_navBallBroadcastThisPhase = true;
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)$"[ClientPatches] Host nav fire broadcast: aim=({aimVector.x:F2},{aimVector.y:F2})");
						}
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)("[ClientPatches] Host nav fire broadcast failed: " + ex.Message));
					}
				}
			}
			MultiplayerClientPatches._firedBallGO = ((Component)__instance).gameObject;
			MultiplayerClientPatches._firedBallTimer = 0f;
			MultiplayerClientPatches._firedBallLogCount = 0;
		}

		public static void ResetNavBallBroadcastLatch()
		{
			_navBallBroadcastThisPhase = false;
		}
	}
	[HarmonyPatch]
	internal static class SummoningCirclePachinkoBallFirePatches
	{
		[HarmonyPatch(typeof(SummoningCirclePachinkoBall), "Fire")]
		[HarmonyPrefix]
		public static bool Prefix(PachinkoBall __instance)
		{
			return PachinkoBallPatches.PachinkoBall_Fire_Prefix(__instance);
		}

		[HarmonyPatch(typeof(SummoningCirclePachinkoBall), "Fire")]
		[HarmonyPostfix]
		public static void Postfix(PachinkoBall __instance)
		{
			PachinkoBallPatches.PachinkoBall_Fire_Postfix(__instance);
		}
	}
	[HarmonyPatch]
	internal static class PegCoinOverlayPatches
	{
		[HarmonyPatch(typeof(PegCoinOverlay), "TriggerCoinCollected")]
		[HarmonyPostfix]
		public static void PegCoinOverlay_TriggerCoinCollected_GoldLog(PegCoinOverlay __instance)
		{
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Invalid comparison between Unknown and I4
			if (!MultiplayerClientPatches.IsHosting)
			{
				return;
			}
			try
			{
				if ((int)BattleController.CurrentBattleState != 3)
				{
					return;
				}
				object? obj = AccessTools.Field(typeof(PegCoinOverlay), "_peg")?.GetValue(__instance);
				Peg val = (Peg)((obj is Peg) ? obj : null);
				if (!((Object)(object)val == (Object)null) && !((Object)(object)val.relicManager == (Object)null) && val.relicManager.RelicEffectActive((RelicEffect)103))
				{
					string text = (((Object)(object)((Component)val).gameObject != (Object)null) ? ((Object)((Component)val).gameObject).name : "?");
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)("[Relic] GOLD_ADDS_TO_DAMAGE triggered on peg '" + text + "' (+1 peg tally)"));
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch]
	internal static class PegGridObscurerPatches
	{
		[HarmonyPatch(typeof(PegGridObscurer), "OnCollisionEnter2D")]
		[HarmonyPrefix]
		public static bool PegGridObscurer_OnCollisionEnter2D_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class PegManagerPatches
	{
		[HarmonyPatch(typeof(PegManager), "ShuffleSpecialPegs")]
		[HarmonyPrefix]
		public static bool PegManager_ShuffleSpecialPegs_Prefix(bool forceRefresh)
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatches] Blocked ShuffleSpecialPegs — host will send peg types");
				}
				return false;
			}
			if (MultiplayerClientPatches.IsHosting)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[PegShuffleHost] ShuffleSpecialPegs(forceRefresh={forceRefresh}) caller={MultiplayerClientPatches.DescribeShuffleCaller()}");
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(PegManager), "CreateSpecialPegs")]
		[HarmonyPrefix]
		public static bool PegManager_CreateSpecialPegs_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(PegManager), "ShuffleCritPegs")]
		[HarmonyPrefix]
		public static bool PegManager_ShuffleCritPegs_Prefix()
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return false;
			}
			if (MultiplayerClientPatches.IsHosting)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)("[PegShuffleHost] ShuffleCritPegs caller=" + MultiplayerClientPatches.DescribeShuffleCaller()));
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(PegManager), "CreateRefreshPegs")]
		[HarmonyPrefix]
		public static bool PegManager_CreateRefreshPegs_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(PegManager), "FailSafeCreateRefreshPegs")]
		[HarmonyPrefix]
		public static bool PegManager_FailSafeCreateRefreshPegs_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(PegManager), "ResetPegs")]
		[HarmonyPrefix]
		public static bool PegManager_ResetPegs_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(PegManager), "ApplyShieldToRegularPegs")]
		[HarmonyPrefix]
		public static bool PegManager_ApplyShieldToRegularPegs_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(PegManager), "ConvertPegsToBombs")]
		[HarmonyPrefix]
		public static bool PegManager_ConvertPegsToBombs_Prefix()
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatch] Blocked PegManager.ConvertPegsToBombs — host drives bomb placement");
				}
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class PegMinigameManagerPatches
	{
		[HarmonyPatch(typeof(PegMinigameManager), "CreateOrb")]
		[HarmonyPrefix]
		public static bool PegMinigameManager_CreateOrb_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowPegMinigameLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked PegMinigameManager.CreateOrb (spectating)");
			}
			return false;
		}

		[HarmonyPatch(typeof(PegMinigameManager), "PrepareNavigationOrbForFiring")]
		[HarmonyPrefix]
		public static bool PegMinigameManager_PrepareNavigationOrbForFiring_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowPegMinigameLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked PegMinigameManager.PrepareNavigationOrbForFiring (spectating)");
			}
			return false;
		}

		[HarmonyPatch(typeof(PegMinigameManager), "HandleRewardSlotTriggerActivated")]
		[HarmonyPrefix]
		public static bool PegMinigameManager_HandleRewardSlotTriggerActivated_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowPegMinigameLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked PegMinigameManager.HandleRewardSlotTriggerActivated (spectating)");
			}
			return false;
		}

		[HarmonyPatch(typeof(PegMinigameManager), "HandleNavigationSlotTriggerActivated")]
		[HarmonyPrefix]
		public static bool PegMinigameManager_HandleNavigationSlotTriggerActivated_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(PegMinigameManager), "FadeAndLoad")]
		[HarmonyPrefix]
		public static bool PegMinigameManager_FadeAndLoad_Prefix(PegMinigameManager __instance)
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatch] Blocked PegMinigameManager.FadeAndLoad on client");
				}
				return false;
			}
			if (MultiplayerClientPatches.IsHosting && CoopRewardState.PegMinigamePhaseActive)
			{
				if (!CoopRewardState.AllClientPegMinigameChoicesReceived)
				{
					CoopRewardState.PendingPegMinigameManager = __instance;
					CoopRewardState.WaitingForOtherPlayers = true;
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)("[CoopReward] PegMinigame: host waiting for clients before navigating " + $"({CoopRewardState.ClientPegMinigameChoicesReceived.Count}/{CoopRewardState.TotalPegMinigameClientsExpected})"));
					}
					return false;
				}
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)"[CoopReward] PegMinigame: all clients done, host proceeding with navigation");
				}
			}
			return true;
		}

		[HarmonyPatch(typeof(PegMinigameManager), "HandleUpgradeOptionClicked")]
		[HarmonyPrefix]
		public static void PegMinigameManager_HandleUpgradeOptionClicked_Prefix(UpgradeType type, int ____indexSelected, ref int __state)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Invalid comparison between Unknown and I4
			__state = ____indexSelected;
			if (____indexSelected >= 0 && (int)type != 2 && MultiplayerClientPatches.IsHosting && CoopRewardState.PegMinigamePhaseActive)
			{
				CoopRewardState.HostPegMinigameDone = true;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[CoopReward] PegMinigame: host finished reward selection");
				}
			}
		}

		[HarmonyPatch(typeof(PegMinigameManager), "HandleUpgradeOptionClicked")]
		[HarmonyPostfix]
		public static void PegMinigameManager_HandleUpgradeOptionClicked_Postfix(UpgradeType type, MapDataPegMinigame ____mapData, int __state)
		{
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between Unknown and I4
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Expected I4, but got Unknown
			if (__state < 0 || (int)type == 2)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null)
			{
				return;
			}
			if (MultiplayerClientPatches.ShouldSuppressClientLogic && MultiplayerClientPatches.AllowPegMinigameLogic)
			{
				try
				{
					PegMinigameCompleteEvent pegMinigameCompleteEvent = new PegMinigameCompleteEvent();
					if ((int)type == 7)
					{
						pegMinigameCompleteEvent.Skipped = true;
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)"[CoopReward] PegMinigame client: skipped reward");
						}
					}
					else if (____mapData?.Rewards != null && __state < ____mapData.Rewards.Count)
					{
						Reward val = ____mapData.Rewards[__state];
						OrbReward val2 = (OrbReward)(object)((val is OrbReward) ? val : null);
						if (val2 != null && (Object)(object)val2.Orb != (Object)null)
						{
							pegMinigameCompleteEvent.ChosenOrbPrefabName = ((Object)val2.Orb).name.Replace("(Clone)", string.Empty).Trim();
							pegMinigameCompleteEvent.OrbLevel = val2.Orb.GetComponent<Attack>()?.Level ?? 0;
							ManualLogSource logger2 = MultiplayerPlugin.Logger;
							if (logger2 != null)
							{
								logger2.LogInfo((object)$"[CoopReward] PegMinigame client: chose orb '{pegMinigameCompleteEvent.ChosenOrbPrefabName}' (lvl={pegMinigameCompleteEvent.OrbLevel})");
							}
						}
						else
						{
							RelicReward val3 = (RelicReward)(object)((val is RelicReward) ? val : null);
							if (val3 != null && (Object)(object)val3.Relic != (Object)null)
							{
								pegMinigameCompleteEvent.ChosenRelicEffect = (int)val3.Relic.effect;
								ManualLogSource logger3 = MultiplayerPlugin.Logger;
								if (logger3 != null)
								{
									logger3.LogInfo((object)("[CoopReward] PegMinigame client: chose relic '" + val3.Relic.locKey + "'"));
								}
							}
						}
					}
					if (services.TryResolve<IMessageSender>(out var instance))
					{
						instance.Send(pegMinigameCompleteEvent);
					}
					MultiplayerClientPatches.AllowPegMinigameLogic = false;
					CoopRewardState.ClientPegMinigameChoiceSent = true;
					CoopRewardState.WaitingForOtherPlayers = true;
					CoopRewardState.PegMinigamePhaseActive = true;
					CoopRewardState.AllChoicesComplete = false;
					return;
				}
				catch (Exception ex)
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogWarning((object)("[CoopReward] PegMinigame client completion failed: " + ex.Message));
					}
					return;
				}
			}
			if (!MultiplayerClientPatches.IsHosting || !CoopRewardState.PegMinigamePhaseActive)
			{
				return;
			}
			try
			{
				if (services.TryResolve<CoopStateManager>(out var instance2))
				{
					instance2.SaveActivePlayerState();
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogWarning((object)("[CoopReward] PegMinigame host save failed: " + ex2.Message));
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class PegPatches
	{
		[HarmonyPatch(typeof(Peg), "WaitAndConvertToBomb")]
		[HarmonyPrefix]
		public static bool Peg_WaitAndConvertToBomb_Prefix(ref IEnumerator __result)
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatch] Blocked Peg.WaitAndConvertToBomb — host drives bomb placement");
				}
				__result = MultiplayerClientPatches.EmptyEnumerator();
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class PlayButtonPatches
	{
		[HarmonyPatch(typeof(PlayButton), "SwitchToRunConfigCanvas")]
		[HarmonyPrefix]
		public static bool PlayButton_SwitchToRunConfigCanvas_Prefix(PlayButton __instance)
		{
			//IL_0040: Unknown result type (might be due to invalid IL or missing references)
			if (MultiplayerPlugin.Services == null)
			{
				return true;
			}
			if (!MultiplayerPlugin.Services.TryResolve<IMultiplayerMode>(out var instance))
			{
				return true;
			}
			if (!instance.IsHosting && !instance.IsSpectating)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatches] Skipping character select — class chosen in lobby");
			}
			MultiplayerClientPatches.SetStartingLoadoutFromClass(StaticGameData.chosenClass);
			__instance.ConfirmRunConfigAndStartGame();
			return false;
		}
	}
	[HarmonyPatch]
	internal static class PlayerHealthControllerPatches
	{
		[HarmonyPatch(typeof(PlayerHealthController), "Damage")]
		[HarmonyPrefix]
		public static bool PlayerHealthController_Damage_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowNativeRewardLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowShopLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked PlayerHealthController.Damage on client");
			}
			return false;
		}

		[HarmonyPatch(typeof(PlayerHealthController), "CheckForDeathAndUpdateBar")]
		[HarmonyPrefix]
		public static bool PlayerHealthController_CheckForDeathAndUpdateBar_Prefix(PlayerHealthController __instance)
		{
			if (!MultiplayerClientPatches.IsHosting || !LobbyUI.GameStartReceived)
			{
				return true;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<CoopStateManager>(out var instance))
			{
				return true;
			}
			if (instance.TotalPlayerCount < 2)
			{
				return true;
			}
			object obj = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth")?.GetValue(__instance);
			if (obj == null)
			{
				return true;
			}
			PropertyInfo property = obj.GetType().GetProperty("Value");
			if (property == null)
			{
				return true;
			}
			float num = (float)property.GetValue(obj);
			if (num > 0f)
			{
				return true;
			}
			if (!instance.AllPlayersDead)
			{
				try
				{
					MethodInfo method = obj.GetType().GetMethod("Set", new Type[1] { typeof(float) });
					if (method != null && num < 0f)
					{
						method.Invoke(obj, new object[1] { 0f });
					}
				}
				catch
				{
				}
				CoopPlayerState playerState = instance.GetPlayerState(instance.ActivePlayerSlot);
				if (playerState != null && playerState.CurrentHealth < 0f)
				{
					playerState.CurrentHealth = 0f;
				}
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[ClientPatches] Active player (slot {instance.ActivePlayerSlot}) died but other players alive — suppressing game over, clamped hp to 0");
				}
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(PlayerHealthController), "Heal")]
		[HarmonyPrefix]
		public static void PlayerHealthController_Heal_Prefix(PlayerHealthController __instance, ref object[] __state)
		{
			__state = null;
			if (!MultiplayerClientPatches.IsHosting)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<CoopStateManager>(out var instance) || instance.TotalPlayerCount < 2 || instance.ActivePlayerSlot == 0)
			{
				return;
			}
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerHealthController), "_damageFloatingTextPrefab");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(PlayerHealthController), "_healSFX");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(PlayerHealthController), "HealParticleAnim");
				__state = new object[6]
				{
					fieldInfo,
					fieldInfo?.GetValue(__instance),
					fieldInfo2,
					fieldInfo2?.GetValue(__instance),
					fieldInfo3,
					fieldInfo3?.GetValue(__instance)
				};
				fieldInfo?.SetValue(__instance, null);
				fieldInfo2?.SetValue(__instance, null);
				fieldInfo3?.SetValue(__instance, null);
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[ClientPatches] Heal VFX suppression failed: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(PlayerHealthController), "Heal")]
		[HarmonyPostfix]
		public static void PlayerHealthController_Heal_Postfix(PlayerHealthController __instance, object[] __state)
		{
			if (__state == null)
			{
				return;
			}
			try
			{
				FieldInfo fieldInfo = __state[0] as FieldInfo;
				object value = __state[1];
				FieldInfo fieldInfo2 = __state[2] as FieldInfo;
				object value2 = __state[3];
				FieldInfo obj = __state[4] as FieldInfo;
				object value3 = __state[5];
				fieldInfo?.SetValue(__instance, value);
				fieldInfo2?.SetValue(__instance, value2);
				obj?.SetValue(__instance, value3);
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[ClientPatches] Heal VFX restore failed: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(PlayerHealthController), "OnEnable")]
		[HarmonyPostfix]
		public static void PlayerHealthController_OnEnable_Postfix(PlayerHealthController __instance)
		{
			try
			{
				if (MultiplayerPlugin.Services != null && MultiplayerPlugin.Services.TryResolve<IMultiplayerMode>(out var instance) && (instance.IsHosting || instance.IsSpectating))
				{
					object? obj = AccessTools.Field(typeof(PlayerHealthController), "_healthText")?.GetValue(__instance);
					Component val = (Component)((obj is Component) ? obj : null);
					if (val != null && (Object)(object)val != (Object)null)
					{
						val.gameObject.SetActive(false);
					}
					object? obj2 = AccessTools.Field(typeof(PlayerHealthController), "_barScript")?.GetValue(__instance);
					Component val2 = (Component)((obj2 is Component) ? obj2 : null);
					if (val2 != null && (Object)(object)val2 != (Object)null)
					{
						val2.gameObject.SetActive(false);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[ClientPatch] Hide HP bar failed: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class PopulateSuggestionOrbsPatches
	{
		[HarmonyPatch(typeof(PopulateSuggestionOrbs), "GenerateAddableOrbs")]
		[HarmonyPrefix]
		public static bool PopulateSuggestionOrbs_GenerateAddableOrbs_CoopPerSlot_Prefix(PopulateSuggestionOrbs __instance, SeededBattleNodeData seededBattleData)
		{
			//IL_01c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0218: Unknown result type (might be due to invalid IL or missing references)
			//IL_0265: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null)
				{
					return true;
				}
				int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(services);
				if (localSlotIndex < 0)
				{
					return true;
				}
				if (!CoopRewardState.PerSlotOrbChoices.TryGetValue(localSlotIndex, out var value) || value == null || value.Count == 0)
				{
					return true;
				}
				UpgradeOption[] array = AccessTools.Field(typeof(PopulateSuggestionOrbs), "addOrbButtons")?.GetValue(__instance) as UpgradeOption[];
				Button[] array2 = AccessTools.Field(typeof(PopulateSuggestionOrbs), "potentialDownButtons")?.GetValue(__instance) as Button[];
				object? obj = AccessTools.Field(typeof(PopulateSuggestionOrbs), "continueButton")?.GetValue(__instance);
				Button selectOnUp = (Button)((obj is Button) ? obj : null);
				DeckManager deckManager = __instance.deckManager;
				RelicManager relicManager = __instance.relicManager;
				CruciballManager cruciballManager = __instance.cruciballManager;
				if (array == null || array.Length == 0 || (Object)(object)deckManager == (Object)null)
				{
					return true;
				}
				List<GameObject> list = MultiplayerClientPatches.ResolveOrbPrefabsByName(value, deckManager);
				if (list.Count == 0)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)string.Format("[CoopOrbReward] Could not resolve any orb prefabs from host list for slot {0} ({1})", localSlotIndex, string.Join(",", value)));
					}
					return true;
				}
				int num = Math.Min(list.Count, array.Length);
				Button selectOnDown = null;
				if (array2 != null)
				{
					Button[] array3 = array2;
					foreach (Button val in array3)
					{
						if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeInHierarchy)
						{
							selectOnDown = val;
							break;
						}
					}
				}
				for (int j = 0; j < array.Length; j++)
				{
					bool flag = j < num;
					((Component)array[j]).gameObject.SetActive(flag);
					if (!flag)
					{
						continue;
					}
					Button component = ((Component)array[j]).GetComponent<Button>();
					if (!((Object)(object)component == (Object)null))
					{
						Navigation navigation = ((Selectable)component).navigation;
						if (j > 0)
						{
							((Navigation)(ref navigation)).selectOnLeft = (Selectable)(object)((Component)array[j - 1]).GetComponent<Button>();
						}
						if (j + 1 < num && j < array.Length - 1)
						{
							((Navigation)(ref navigation)).selectOnRight = (Selectable)(object)((Component)array[j + 1]).GetComponent<Button>();
						}
						((Navigation)(ref navigation)).selectOnDown = (Selectable)(object)selectOnDown;
						((Navigation)(ref navigation)).selectOnUp = (Selectable)(object)selectOnUp;
						((Selectable)component).navigation = navigation;
					}
				}
				for (int k = 0; k < num; k++)
				{
					GameObject val2 = list[k];
					Attack component2 = val2.GetComponent<Attack>();
					if (component2 != null)
					{
						component2.SoftInit(deckManager, relicManager, cruciballManager, true);
					}
					UpgradeOption obj2 = array[k];
					obj2.SpecifiedOrb = val2;
					obj2.upgradeType = (UpgradeType)4;
				}
				try
				{
					object obj3 = AccessTools.Field(typeof(PopulateSuggestionOrbs), "_rewiredEventSystem")?.GetValue(__instance);
					if (obj3 != null)
					{
						object obj4 = ((obj3 is MonoBehaviour) ? obj3 : null);
						ControllerMenuHookup val3 = ((obj4 != null) ? ((Component)obj4).GetComponent<ControllerMenuHookup>() : null);
						if ((Object)(object)val3 != (Object)null)
						{
							val3.LastSelected = ((Component)array[0]).gameObject;
						}
					}
				}
				catch
				{
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)string.Format("[CoopOrbReward] Populated {0} per-slot orbs for slot {1}: {2}", num, localSlotIndex, string.Join(",", value)));
				}
				return false;
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[CoopOrbReward] GenerateAddableOrbs override failed, falling through: " + ex.Message));
				}
				return true;
			}
		}
	}
	[HarmonyPatch]
	internal static class PostBattleControllerPatches
	{
		[HarmonyPatch(typeof(PostBattleController), "StartNavigation")]
		[HarmonyPrefix]
		public static bool PostBattleController_StartNavigation_Prefix(PostBattleController __instance)
		{
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null)
			{
				return true;
			}
			if (MultiplayerClientPatches.IsHosting)
			{
				if (!CoopRewardState.HostRewardPhaseActive)
				{
					return true;
				}
				if (services.TryResolve<CoopStateManager>(out var instance))
				{
					instance.SaveActivePlayerState();
				}
				CoopRewardState.HostRewardsDone = true;
				CoopRewardState.PendingPostBattleController = __instance;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatches] Host finished post-battle rewards, checking if all clients done...");
				}
				if (CoopRewardState.AllClientRewardChoicesReceived)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)"[ClientPatches] All clients done — proceeding with navigation");
					}
					CoopRewardState.HostRewardPhaseActive = false;
					MultiplayerClientPatches.AllowNativeRewardLogic = false;
					if (services.TryResolve<CoopStateManager>(out var instance2))
					{
						instance2.ClearNegativeDebuffsFromAllPlayers();
					}
					if (services.TryResolve<IGameEventRegistry>(out var instance3))
					{
						instance3.Dispatch(new AllChoicesCompleteEvent
						{
							Phase = "post_battle"
						});
					}
					MapNode currentNode = StaticGameData.currentNode;
					int valueOrDefault = ((currentNode == null) ? null : currentNode.ChildNodes?.Length).GetValueOrDefault();
					CoopNavigateResolver.StartPhase("post_battle", valueOrDefault, CoopNavigateResolver.CaptureChildRoomTypes());
					return true;
				}
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)$"[ClientPatches] Waiting for clients: {CoopRewardState.ClientRewardChoicesReceived.Count}/{CoopRewardState.TotalRewardClientsExpected}");
				}
				CoopRewardState.WaitingForOtherPlayers = true;
				return false;
			}
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				if (CoopNavigateState.PhaseActive && MultiplayerClientPatches.AllowNavigateLogic)
				{
					return true;
				}
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogInfo((object)"[ClientPatches] Client finished post-battle rewards — sending results to host");
				}
				try
				{
					PostBattleCompleteEvent networkEvent = MultiplayerClientPatches.CaptureClientPostBattleState();
					if (services.TryResolve<IMessageSender>(out var instance4))
					{
						instance4.Send(networkEvent);
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger5 = MultiplayerPlugin.Logger;
					if (logger5 != null)
					{
						logger5.LogError((object)("[ClientPatches] Failed to send PostBattleCompleteEvent: " + ex.Message));
					}
				}
				MultiplayerClientPatches.AllowNativeRewardLogic = false;
				MultiplayerClientPatches.ClientChosenPostBattleRelicEffect = -1;
				MultiplayerClientPatches.ClientChosenPostBattleRelicName = null;
				CoopRewardState.PendingPostBattleRelicChoices = null;
				CoopRewardState.WaitingForOtherPlayers = true;
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class PredictionManagerPatches
	{
		[HarmonyPatch(typeof(PredictionManager), "UpdateAllPegsStatus")]
		[HarmonyPrefix]
		public static void PredictionManager_UpdateAllPegsStatus_Prefix(PredictionManager __instance)
		{
			try
			{
				if (AccessTools.Field(typeof(PredictionManager), "_allPegs")?.GetValue(__instance) is IDictionary<IDummyPeg, IDummyPeg> dictionary && dictionary.Count > 0)
				{
					List<IDummyPeg> list = null;
					foreach (KeyValuePair<IDummyPeg, IDummyPeg> item in dictionary)
					{
						if (IsDestroyed(item.Key) || IsDestroyed(item.Value))
						{
							(list ?? (list = new List<IDummyPeg>())).Add(item.Key);
						}
					}
					if (list != null)
					{
						foreach (IDummyPeg item2 in list)
						{
							dictionary.Remove(item2);
						}
					}
				}
				if (!(AccessTools.Field(typeof(PredictionManager), "_movingPegsEndOfTurn")?.GetValue(__instance) is IDictionary<IDummiableMovingPegEndOfTurn, IDummiableMovingPegEndOfTurn> dictionary2) || dictionary2.Count <= 0)
				{
					return;
				}
				List<IDummiableMovingPegEndOfTurn> list2 = null;
				foreach (KeyValuePair<IDummiableMovingPegEndOfTurn, IDummiableMovingPegEndOfTurn> item3 in dictionary2)
				{
					if (IsDestroyedMover(item3.Key) || IsDestroyedMover(item3.Value))
					{
						(list2 ?? (list2 = new List<IDummiableMovingPegEndOfTurn>())).Add(item3.Key);
					}
				}
				if (list2 == null)
				{
					return;
				}
				foreach (IDummiableMovingPegEndOfTurn item4 in list2)
				{
					dictionary2.Remove(item4);
				}
			}
			catch
			{
			}
		}

		private static bool IsDestroyed(IDummyPeg p)
		{
			if (p == null)
			{
				return true;
			}
			Object val = (Object)(object)((p is Object) ? p : null);
			if (val != null)
			{
				return val == (Object)null;
			}
			return false;
		}

		private static bool IsDestroyedMover(IDummiableMovingPegEndOfTurn p)
		{
			if (p == null)
			{
				return true;
			}
			Object val = (Object)(object)((p is Object) ? p : null);
			if (val != null)
			{
				return val == (Object)null;
			}
			return false;
		}

		[HarmonyPatch(typeof(PredictionManager), "Predict")]
		[HarmonyPrefix]
		public static bool PredictionManager_Predict_Prefix()
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Invalid comparison between Unknown and I4
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			if (!MultiplayerClientPatches.IsHosting)
			{
				return true;
			}
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (IsHostsTurn())
			{
				return true;
			}
			BattleState currentBattleState = BattleController.CurrentBattleState;
			if ((int)currentBattleState == 9 || (int)currentBattleState == 8 || (int)currentBattleState == 10)
			{
				return true;
			}
			return false;
		}

		[HarmonyPatch(typeof(PredictionManager), "SetLineRendererStatus")]
		[HarmonyPrefix]
		public static bool PredictionManager_SetLineRendererStatus_Prefix(bool status)
		{
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Invalid comparison between Unknown and I4
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Invalid comparison between Unknown and I4
			if (!status)
			{
				return true;
			}
			if (!MultiplayerClientPatches.IsHosting)
			{
				return true;
			}
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (IsHostsTurn())
			{
				return true;
			}
			BattleState currentBattleState = BattleController.CurrentBattleState;
			if ((int)currentBattleState == 9 || (int)currentBattleState == 8 || (int)currentBattleState == 10)
			{
				return true;
			}
			return false;
		}

		private static bool IsHostsTurn()
		{
			if (TurnChangeClientHandler.IsMyTurn)
			{
				return true;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null)
			{
				return false;
			}
			if (services.TryResolve<TurnManager>(out var instance) && instance.CurrentPlayerSlot == 0)
			{
				return true;
			}
			if (services.TryResolve<CoopStateManager>(out var instance2) && instance2.ActivePlayerSlot == 0)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class RandomPegFieldPatches
	{
		[HarmonyPatch(typeof(RandomPegField), "TurnComplete")]
		[HarmonyPrefix]
		public static bool RandomPegField_TurnComplete_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class RegularPegPatches
	{
		[HarmonyPatch(typeof(RegularPeg), "ConvertPegToType")]
		[HarmonyPrefix]
		public static void RegularPeg_ConvertPegToType_Prefix(RegularPeg __instance, PegType type, out string __state)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Invalid comparison between Unknown and I4
			__state = null;
			if ((int)type == 4 && MultiplayerPlugin.Services != null && MultiplayerPlugin.Services.TryResolve<PegIdentifier>(out var instance))
			{
				__state = instance.GetOrAssignGuid((Peg)(object)__instance);
			}
		}

		[HarmonyPatch(typeof(RegularPeg), "ConvertPegToType")]
		[HarmonyPostfix]
		public static void RegularPeg_ConvertPegToType_Postfix(RegularPeg __instance, PegType type, GameObject __result, string __state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if ((int)type != 4 || (Object)(object)__result == (Object)null || (Object)(object)__result == (Object)(object)((Component)__instance).gameObject || string.IsNullOrEmpty(__state) || MultiplayerPlugin.Services == null || !MultiplayerPlugin.Services.TryResolve<PegIdentifier>(out var instance))
			{
				return;
			}
			Peg component = __result.GetComponent<Peg>();
			if ((Object)(object)component == (Object)null)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[ClientPatch] ConvertPegToType(BOMB) returned GameObject without Peg component at " + $"pos=({((Component)__instance).transform.position.x:F2},{((Component)__instance).transform.position.y:F2}) oldGuid={__state}"));
				}
				return;
			}
			instance.Register(component, __state);
			ManualLogSource logger2 = MultiplayerPlugin.Logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)("[ClientPatch] Transferred peg GUID " + __state + " from RegularPeg to new Bomb at " + $"pos=({((Component)component).transform.position.x:F2},{((Component)component).transform.position.y:F2})"));
			}
		}
	}
	[HarmonyPatch]
	internal static class RelicManagerPatches
	{
		[HarmonyPatch(typeof(RelicManager), "AddRelic")]
		[HarmonyPostfix]
		public static void RelicManager_AddRelic_SharePostfix(Relic relic)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b3: Invalid comparison between I4 and Unknown
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Expected I4, but got Unknown
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Expected I4, but got Unknown
			//IL_0131: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.IsHosting)
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name != "TextScenario" || (Object)(object)relic == (Object)null || CoopRewardState.TextScenarioPhaseActive)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<CoopStateManager>(out var instance) || instance.TotalPlayerCount < 2)
			{
				return;
			}
			try
			{
				instance.SaveActivePlayerState();
				foreach (KeyValuePair<int, CoopPlayerState> playerState in instance.PlayerStates)
				{
					if (playerState.Key == instance.ActivePlayerSlot)
					{
						continue;
					}
					bool flag = false;
					foreach (SerializedRelic ownedRelic in playerState.Value.OwnedRelics)
					{
						if (ownedRelic.Effect == (int)relic.effect)
						{
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						playerState.Value.OwnedRelics.Add(new SerializedRelic
						{
							Effect = (int)relic.effect,
							LocKey = (relic.locKey ?? string.Empty),
							Rarity = (int)relic.globalRarity
						});
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)$"[CoopReward] TextScenario: added relic '{relic.locKey}' (effect={relic.effect}) to slot {playerState.Key}");
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[CoopReward] TextScenario relic sharing failed: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(RelicManager), "AddRelic")]
		[HarmonyPrefix]
		public static bool RelicManager_AddRelic_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowRelicSync)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowNativeRewardLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowShopLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTreasureLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowPegMinigameLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked RelicManager.AddRelic on client");
			}
			return false;
		}

		[HarmonyPatch(typeof(RelicManager), "RemoveRelic", new Type[] { typeof(Relic) })]
		[HarmonyPrefix]
		public static bool RelicManager_RemoveRelic_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowRelicSync)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked RelicManager.RemoveRelic on client");
			}
			return false;
		}

		[HarmonyPatch(typeof(RelicManager), "RemoveRelic", new Type[] { typeof(RelicEffect) })]
		[HarmonyPrefix]
		public static bool RelicManager_RemoveRelicByEffect_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowRelicSync)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked RelicManager.RemoveRelic(RelicEffect) on client");
			}
			return false;
		}
	}
	[HarmonyPatch(typeof(RunSummary), "OnEnable")]
	public static class RunSummaryOnEnablePatch
	{
		[HarmonyPrefix]
		public static void Prefix()
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				RunStats currentRunStats = StaticGameData.CurrentRunStats;
				if (currentRunStats == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[RunStatsSync] Host RunSummary opened but CurrentRunStats is null");
					}
					return;
				}
				List<PerPlayerStats> players = (RunStatsSnapshotClientHandler.LatestPerPlayerStats = BuildPerPlayerStats(services));
				RunStatsSnapshotEvent runStatsSnapshotEvent = BuildSnapshot(currentRunStats, players);
				if (services.TryResolve<IGameEventRegistry>(out var instance2))
				{
					instance2.Dispatch(runStatsSnapshotEvent);
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)($"[RunStatsSync] Host dispatched RunStatsSnapshot: won={runStatsSnapshotEvent.HasWon}, " + $"dmg={runStatsSnapshotEvent.TotalDamageDealt}, players={runStatsSnapshotEvent.Players.Count}"));
					}
				}
				try
				{
					if (services.TryResolve<CoopStateManager>(out var instance3) && instance3 != null)
					{
						IEnumerable<string> playerNames = from p in instance3.PlayerStates
							orderby p.Key
							select p.Value?.PlayerName ?? string.Empty;
						string seed = StaticGameData.currentSeed ?? string.Empty;
						bool flag = ContinueFiles.DeleteForRoster(playerNames, seed);
						ManualLogSource logger3 = MultiplayerPlugin.Logger;
						if (logger3 != null)
						{
							logger3.LogInfo((object)$"[ContinueSaver] run-end (won={runStatsSnapshotEvent.HasWon}): continue file deleted={flag}");
						}
					}
					ContinueSession.Clear();
				}
				catch (Exception ex)
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogWarning((object)("[ContinueSaver] run-end delete failed: " + ex.Message));
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogWarning((object)("[RunStatsSync] Host dispatch failed: " + ex2.Message));
				}
			}
		}

		private static List<PerPlayerStats> BuildPerPlayerStats(IServiceContainer services)
		{
			List<PerPlayerStats> list = new List<PerPlayerStats>();
			if (!services.TryResolve<CoopStateManager>(out var instance))
			{
				return list;
			}
			foreach (KeyValuePair<int, CoopPlayerState> item in instance.PlayerStates.OrderBy((KeyValuePair<int, CoopPlayerState> p) => p.Key))
			{
				CoopPlayerState value = item.Value;
				PerPlayerStats perPlayerStats = new PerPlayerStats
				{
					SlotIndex = value.SlotIndex,
					PlayerName = (string.IsNullOrEmpty(value.PlayerName) ? $"Player {value.SlotIndex + 1}" : value.PlayerName),
					DamageDealt = value.DamageDealt,
					DamageTaken = value.DamageTaken,
					ChosenClass = value.ChosenClass,
					FinalHp = Mathf.Max(0, Mathf.RoundToInt(value.CurrentHealth)),
					MaxHp = Mathf.Max(0, Mathf.RoundToInt(value.MaxHealth)),
					Gold = value.Gold,
					IsAlive = (value.CurrentHealth > 0f)
				};
				if (value.OwnedRelics != null)
				{
					foreach (SerializedRelic ownedRelic in value.OwnedRelics)
					{
						perPlayerStats.Relics.Add(ownedRelic.Effect);
					}
				}
				if (value.CompleteDeck != null)
				{
					foreach (SerializedOrb item2 in value.CompleteDeck)
					{
						perPlayerStats.Orbs.Add(new PerPlayerOrb
						{
							PrefabName = item2.PrefabName,
							Level = item2.Level
						});
					}
				}
				list.Add(perPlayerStats);
			}
			return list;
		}

		private static RunStatsSnapshotEvent BuildSnapshot(RunStats stats, List<PerPlayerStats> players)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected I4, but got Unknown
			//IL_0287: Unknown result type (might be due to invalid IL or missing references)
			//IL_028d: Invalid comparison between Unknown and I4
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a1: Invalid comparison between Unknown and I4
			//IL_02ab: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Expected I4, but got Unknown
			//IL_035c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0362: Invalid comparison between Unknown and I4
			//IL_0366: Unknown result type (might be due to invalid IL or missing references)
			//IL_0376: Invalid comparison between Unknown and I4
			//IL_0380: Unknown result type (might be due to invalid IL or missing references)
			//IL_0391: Expected I4, but got Unknown
			RunStatsSnapshotEvent runStatsSnapshotEvent = new RunStatsSnapshotEvent
			{
				HasWon = stats.hasWon,
				HasWonCore = stats.hasWonCore,
				IsCustomRun = stats.isCustomRun,
				VampireDealTaken = stats.vampireDealTaken,
				SelectedClass = (int)stats.selectedClass,
				CruciballLevel = stats.cruciballLevel,
				EndDateIso = stats.endDate.ToString("o"),
				Seed = (stats.seed ?? string.Empty),
				RunTimerElapsedMs = stats.runTimerElapsedMilliseconds + (stats.runTimerSw?.ElapsedMilliseconds ?? 0),
				FinalHp = stats.finalHp,
				MaxHp = stats.maxHp,
				TotalDamageDealt = stats.totalDamageDealt,
				CoinsEarned = stats.coinsEarned,
				PegsHit = stats.pegsHit,
				PegsHitRefresh = stats.pegsHitRefresh,
				PegsHitCrit = stats.pegsHitCrit,
				BombsThrown = stats.bombsThrown,
				BombsThrownRigged = stats.bombsThrownRigged,
				Players = players
			};
			if (stats.visitedRooms != null)
			{
				runStatsSnapshotEvent.VisitedRooms = stats.visitedRooms.Select((RoomType r) => (int)r).ToList();
			}
			if (stats.visitedBosses != null)
			{
				runStatsSnapshotEvent.VisitedBosses = stats.visitedBosses.Select((BossType b) => (int)b).ToList();
			}
			if (stats.relics != null)
			{
				runStatsSnapshotEvent.Relics = stats.relics.Select((RelicEffect r) => (int)r).ToList();
			}
			if (stats.challenges != null)
			{
				runStatsSnapshotEvent.Challenges = stats.challenges.Select((ChallengeEffect c) => (int)c).ToList();
			}
			int num = 0;
			foreach (object value3 in Enum.GetValues(typeof(StatusEffectType)))
			{
				if ((int)value3 > num)
				{
					num = (int)value3;
				}
			}
			runStatsSnapshotEvent.StatusEffectStacks = Enumerable.Repeat(0, num + 1).ToList();
			if (stats.stacksPerStatusEffect != null)
			{
				foreach (KeyValuePair<StatusEffectType, int> item in stats.stacksPerStatusEffect)
				{
					if ((int)item.Key >= 0 && (int)item.Key < runStatsSnapshotEvent.StatusEffectStacks.Count)
					{
						runStatsSnapshotEvent.StatusEffectStacks[(int)item.Key] = item.Value;
					}
				}
			}
			int num2 = 0;
			foreach (object value4 in Enum.GetValues(typeof(SlimeType)))
			{
				if ((int)value4 > num2)
				{
					num2 = (int)value4;
				}
			}
			runStatsSnapshotEvent.SlimePegCounts = Enumerable.Repeat(0, num2 + 1).ToList();
			if (stats.slimePegsPerSlimeType != null)
			{
				foreach (KeyValuePair<SlimeType, int> item2 in stats.slimePegsPerSlimeType)
				{
					if ((int)item2.Key >= 0 && (int)item2.Key < runStatsSnapshotEvent.SlimePegCounts.Count)
					{
						runStatsSnapshotEvent.SlimePegCounts[(int)item2.Key] = item2.Value;
					}
				}
			}
			if (stats.orbStats != null)
			{
				foreach (KeyValuePair<string, OrbPlayData> orbStat in stats.orbStats)
				{
					OrbPlayData value = orbStat.Value;
					runStatsSnapshotEvent.Orbs.Add(new OrbStatsEntry
					{
						Id = value.id,
						Name = value.name,
						DamageDealt = value.damageDealt,
						TimesFired = value.timesFired,
						TimesDiscarded = value.timesDiscarded,
						TimesRemoved = value.timesRemoved,
						Starting = value.starting,
						AmountInDeck = value.amountInDeck,
						LevelInstances = ((value.levelInstances != null) ? ((int[])value.levelInstances.Clone()) : new int[3])
					});
				}
			}
			if (stats.enemyData != null)
			{
				foreach (KeyValuePair<string, EnemyPlayData> enemyDatum in stats.enemyData)
				{
					EnemyPlayData value2 = enemyDatum.Value;
					runStatsSnapshotEvent.Enemies.Add(new EnemyStatsEntry
					{
						Name = value2.name,
						AmountFought = value2.amountFought,
						MeleeDamageReceived = value2.meleeDamageReceived,
						RangedDamageReceived = value2.rangedDamageReceived,
						DefeatedBy = value2.defeatedBy
					});
				}
			}
			return runStatsSnapshotEvent;
		}
	}
	[HarmonyPatch(typeof(RunStatisticsDetails), "Initialize")]
	public static class RunStatisticsDetailsInitializePatch
	{
		public static int CurrentPageIndex;

		[HarmonyPostfix]
		public static void Postfix(RunStatisticsDetails __instance, RunStats stats)
		{
			try
			{
				List<PerPlayerStats> latestPerPlayerStats = RunStatsSnapshotClientHandler.LatestPerPlayerStats;
				if (latestPerPlayerStats != null && latestPerPlayerStats.Count != 0)
				{
					List<PerPlayerStats> list = latestPerPlayerStats.OrderBy((PerPlayerStats p) => p.SlotIndex).ToList();
					if (CurrentPageIndex < 0)
					{
						CurrentPageIndex = 0;
					}
					if (CurrentPageIndex >= list.Count)
					{
						CurrentPageIndex = list.Count - 1;
					}
					PerPlayerStats player = list[CurrentPageIndex];
					RenderPerPlayerPage(__instance, stats, player, CurrentPageIndex, list.Count);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[RunStatsSync] Per-player page render failed: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}

		private static void RenderPerPlayerPage(RunStatisticsDetails inst, RunStats stats, PerPlayerStats player, int pageIndex, int pageCount)
		{
			object? obj = AccessTools.Field(typeof(RunStatisticsDetails), "headerText")?.GetValue(inst);
			TextMeshProUGUI val = (TextMeshProUGUI)((obj is TextMeshProUGUI) ? obj : null);
			if (val != null)
			{
				string text = FindClassLocKey(inst, player.ChosenClass);
				string text2 = ((!string.IsNullOrEmpty(text)) ? LocalizationManager.GetTranslation(text, true, 0, true, false, (GameObject)null, (string)null, true) : string.Empty);
				string text3 = (stats.hasWon ? LocalizationManager.GetTranslation("Menu/RunSummary/win_label", true, 0, true, false, (GameObject)null, (string)null, true) : (player.IsAlive ? LocalizationManager.GetTranslation("Menu/RunSummary/loss_label", true, 0, true, false, (GameObject)null, (string)null, true) : LocalizationManager.GetTranslation("Menu/RunSummary/loss_label", true, 0, true, false, (GameObject)null, (string)null, true)));
				string text4 = ((pageCount > 1) ? $"   ({pageIndex + 1}/{pageCount})" : string.Empty);
				((TMP_Text)val).text = player.PlayerName + " — " + text2 + " - " + text3 + text4;
			}
			object? obj2 = AccessTools.Field(typeof(RunStatisticsDetails), "statLinesParent")?.GetValue(inst);
			Transform val2 = (Transform)((obj2 is Transform) ? obj2 : null);
			if ((Object)(object)val2 != (Object)null)
			{
				ReplaceStatLineValue(val2, "Menu/RunSummary/final_hp", $"{player.FinalHp} / {player.MaxHp}");
				ReplaceStatLineValue(val2, "Menu/RunSummary/gold_obtained", $"{player.Gold}");
				RemoveStatLinesWithLabelPrefix(val2, "Damage done by ");
				RemoveStatLinesWithLabelPrefix(val2, "Damage taken by ");
				object? obj3 = AccessTools.Field(typeof(RunStatisticsDetails), "statLinesPrefab")?.GetValue(inst);
				GameObject val3 = (GameObject)((obj3 is GameObject) ? obj3 : null);
				if ((Object)(object)val3 != (Object)null)
				{
					StatsLine component = Object.Instantiate<GameObject>(val3, val2).GetComponent<StatsLine>();
					if (component != null)
					{
						component.Initialize("Damage done by " + player.PlayerName, player.DamageDealt.ToString());
					}
					StatsLine component2 = Object.Instantiate<GameObject>(val3, val2).GetComponent<StatsLine>();
					if (component2 != null)
					{
						component2.Initialize("Damage taken by " + player.PlayerName, player.DamageTaken.ToString());
					}
				}
				RestripeRows(val2);
			}
			object? obj4 = AccessTools.Field(typeof(RunStatisticsDetails), "orbsParent")?.GetValue(inst);
			Transform val4 = (Transform)((obj4 is Transform) ? obj4 : null);
			object? obj5 = AccessTools.Field(typeof(RunStatisticsDetails), "orbsCarousel")?.GetValue(inst);
			ImageCarousel val5 = (ImageCarousel)((obj5 is ImageCarousel) ? obj5 : null);
			object? obj6 = AccessTools.Field(typeof(RunStatisticsDetails), "loadoutOrbPrefab")?.GetValue(inst);
			GameObject val6 = (GameObject)((obj6 is GameObject) ? obj6 : null);
			if ((Object)(object)val4 != (Object)null && (Object)(object)val5 != (Object)null && (Object)(object)val6 != (Object)null)
			{
				for (int num = val4.childCount - 1; num >= 0; num--)
				{
					Object.Destroy((Object)(object)((Component)val4.GetChild(num)).gameObject);
				}
				val5.ClearElements();
				List<GameObject> list = new List<GameObject>();
				foreach (PerPlayerOrb orb in player.Orbs)
				{
					if (string.IsNullOrEmpty(orb.PrefabName))
					{
						continue;
					}
					AssetLoading instance = AssetLoading.Instance;
					GameObject val7 = ((instance != null) ? instance.GetOrbPrefab(orb.PrefabName) : null);
					if ((Object)(object)val7 == (Object)null)
					{
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogWarning((object)("[RunStatsSync] Orb prefab not found: " + orb.PrefabName));
						}
						continue;
					}
					LoadoutIcon component3 = Object.Instantiate<GameObject>(val6, val4).GetComponent<LoadoutIcon>();
					if (!((Object)(object)component3 == (Object)null))
					{
						component3.InitializeOrb(val7, Mathf.Clamp(orb.Level, 0, 2));
						ForceIconUnlocked(component3, val7, null);
						list.Add(((Component)component3).gameObject);
					}
				}
				val5.Initialize(list, false);
			}
			object? obj7 = AccessTools.Field(typeof(RunStatisticsDetails), "relicsParent")?.GetValue(inst);
			Transform val8 = (Transform)((obj7 is Transform) ? obj7 : null);
			object? obj8 = AccessTools.Field(typeof(RunStatisticsDetails), "relicsCarousel")?.GetValue(inst);
			ImageCarousel val9 = (ImageCarousel)((obj8 is ImageCarousel) ? obj8 : null);
			object? obj9 = AccessTools.Field(typeof(RunStatisticsDetails), "loadoutRelicsPrefab")?.GetValue(inst);
			GameObject val10 = (GameObject)((obj9 is GameObject) ? obj9 : null);
			object? obj10 = AccessTools.Field(typeof(RunStatisticsDetails), "relicManager")?.GetValue(inst);
			RelicManager val11 = (RelicManager)((obj10 is RelicManager) ? obj10 : null);
			if (!((Object)(object)val8 != (Object)null) || !((Object)(object)val9 != (Object)null) || !((Object)(object)val10 != (Object)null) || !((Object)(object)val11 != (Object)null))
			{
				return;
			}
			for (int num2 = val8.childCount - 1; num2 >= 0; num2--)
			{
				Object.Destroy((Object)(object)((Component)val8.GetChild(num2)).gameObject);
			}
			val9.ClearElements();
			List<GameObject> list2 = new List<GameObject>();
			foreach (int relic in player.Relics)
			{
				Relic relicForEffectFromAllData = val11.GetRelicForEffectFromAllData((RelicEffect)relic);
				if ((Object)(object)relicForEffectFromAllData == (Object)null)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)$"[RunStatsSync] Relic not found for effect: {(object)(RelicEffect)relic}");
					}
					continue;
				}
				LoadoutIcon component4 = Object.Instantiate<GameObject>(val10, val8).GetComponent<LoadoutIcon>();
				if (!((Object)(object)component4 == (Object)null))
				{
					component4.InitializeRelic(relicForEffectFromAllData);
					ForceIconUnlocked(component4, null, relicForEffectFromAllData);
					list2.Add(((Component)component4).gameObject);
				}
			}
			val9.Initialize(list2, false);
		}

		private static void ForceIconUnlocked(LoadoutIcon icon, GameObject orbPrefabOrNull, Relic relicOrNull)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				icon.isUnlocked = true;
				if (!((Object)(object)icon.image != (Object)null))
				{
					return;
				}
				if ((Object)(object)orbPrefabOrNull != (Object)null)
				{
					OrbVisuals orbVisuals = OrbUIUtils.GetOrbVisuals(orbPrefabOrNull);
					((Graphic)icon.image).color = orbVisuals.color;
				}
				else
				{
					((Graphic)icon.image).color = Color.white;
				}
				Component[] components = ((Component)icon.image).GetComponents<Component>();
				foreach (Component val in components)
				{
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					Type type = ((object)val).GetType();
					if (!(type.Name != "UIEffect"))
					{
						PropertyInfo property = type.GetProperty("colorFactor");
						if (property != null && property.CanWrite)
						{
							property.SetValue(val, 0f, null);
							break;
						}
						FieldInfo field = type.GetField("colorFactor");
						if (field != null)
						{
							field.SetValue(val, 0f);
							break;
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[RunStatsSync] ForceIconUnlocked failed: " + ex.Message));
				}
			}
		}

		private static string FindClassLocKey(RunStatisticsDetails inst, int chosenClass)
		{
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Invalid comparison between Unknown and I4
			try
			{
				ClassInfo[] classInfos = inst.classInfos;
				if (classInfos == null)
				{
					return null;
				}
				ClassInfo[] array = classInfos;
				foreach (ClassInfo val in array)
				{
					if ((int)val.characterClass == chosenClass)
					{
						return val.classNameLocKey;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static void ReplaceStatLineValue(Transform parent, string labelLocKey, string newValue)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Expected O, but got Unknown
			try
			{
				string translation = LocalizationManager.GetTranslation(labelLocKey, true, 0, true, false, (GameObject)null, (string)null, true);
				if (string.IsNullOrEmpty(translation))
				{
					return;
				}
				foreach (Transform item in parent)
				{
					Transform val = item;
					if (!((Object)(object)((Component)val).GetComponent<StatsLine>() == (Object)null))
					{
						TextMeshProUGUI[] componentsInChildren = ((Component)val).GetComponentsInChildren<TextMeshProUGUI>(true);
						if (componentsInChildren != null && componentsInChildren.Length >= 2 && ((TMP_Text)componentsInChildren[0]).text == translation)
						{
							((TMP_Text)componentsInChildren[1]).text = newValue;
							break;
						}
					}
				}
			}
			catch
			{
			}
		}

		private static void RemoveStatLinesWithLabelPrefix(Transform parent, string prefix)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			List<GameObject> list = new List<GameObject>();
			foreach (Transform item in parent)
			{
				Transform val = item;
				TextMeshProUGUI[] componentsInChildren = ((Component)val).GetComponentsInChildren<TextMeshProUGUI>(true);
				if (componentsInChildren != null && componentsInChildren.Length != 0 && ((TMP_Text)componentsInChildren[0]).text != null && ((TMP_Text)componentsInChildren[0]).text.StartsWith(prefix))
				{
					list.Add(((Component)val).gameObject);
				}
			}
			foreach (GameObject item2 in list)
			{
				Object.DestroyImmediate((Object)(object)item2);
			}
		}

		private static void RestripeRows(Transform parent)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			int num = 1;
			foreach (Transform item in parent)
			{
				Image componentInChildren = ((Component)item).GetComponentInChildren<Image>();
				if ((Object)(object)componentInChildren != (Object)null)
				{
					((Behaviour)componentInChildren).enabled = num != 0;
				}
				num = 1 - num;
			}
		}
	}
	[HarmonyPatch(typeof(RunSummary), "LoadMainMenu")]
	public static class RunSummaryLoadMainMenuPatch
	{
		[HarmonyPrefix]
		public static bool Prefix(RunSummary __instance)
		{
			try
			{
				List<PerPlayerStats> latestPerPlayerStats = RunStatsSnapshotClientHandler.LatestPerPlayerStats;
				if (latestPerPlayerStats == null || latestPerPlayerStats.Count <= 1)
				{
					return true;
				}
				int num = RunStatisticsDetailsInitializePatch.CurrentPageIndex + 1;
				if (num >= latestPerPlayerStats.Count)
				{
					RunStatisticsDetailsInitializePatch.CurrentPageIndex = 0;
					return true;
				}
				RunStatisticsDetailsInitializePatch.CurrentPageIndex = num;
				object? obj = AccessTools.Field(typeof(RunSummary), "runStatisticDetails")?.GetValue(__instance);
				RunStatisticsDetails val = (RunStatisticsDetails)((obj is RunStatisticsDetails) ? obj : null);
				RunStats currentRunStats = StaticGameData.CurrentRunStats;
				if ((Object)(object)val != (Object)null && currentRunStats != null)
				{
					val.Initialize(currentRunStats);
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[RunStatsSync] Advanced to player page {num + 1}/{latestPerPlayerStats.Count}");
					}
				}
				return false;
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[RunStatsSync] LoadMainMenu page advance failed: " + ex.Message));
				}
				return true;
			}
		}
	}
	[HarmonyPatch(typeof(RunSummary), "OnEnable")]
	public static class RunSummaryOnEnableResetPagePatch
	{
		[HarmonyPrefix]
		public static void Prefix()
		{
			RunStatisticsDetailsInitializePatch.CurrentPageIndex = 0;
		}
	}
	[HarmonyPatch]
	internal static class SaveManagerPatches
	{
		[HarmonyPatch(typeof(SaveManager), "SaveRun")]
		[HarmonyPrefix]
		public static bool SaveManager_SaveRun_Prefix()
		{
			return !MultiplayerClientPatches.ShouldSuppressClientLogic;
		}

		[HarmonyPatch(typeof(SaveManager), "SaveBase")]
		[HarmonyPrefix]
		public static bool SaveManager_SaveBase_Prefix()
		{
			return !MultiplayerClientPatches.ShouldSuppressClientLogic;
		}

		[HarmonyPatch(typeof(SaveManager), "RequestSave")]
		[HarmonyPrefix]
		public static bool SaveManager_RequestSave_Prefix()
		{
			return !MultiplayerClientPatches.ShouldSuppressClientLogic;
		}
	}
	[HarmonyPatch]
	internal static class ShopManagerPatches
	{
		[HarmonyPatch(typeof(ShopManager), "SetUpRelicOffer")]
		[HarmonyPrefix]
		public static bool ShopManager_SetUpRelicOffer_Prefix(ShopManager __instance)
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			try
			{
				ShopRelicSyncState.CurrentShopManager = __instance;
				ShopRelicSyncState.PopulateShopRelics(__instance, MultiplayerPlugin.Logger);
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[ShopRelicSync] Prefix failed: " + ex.Message));
				}
			}
			return false;
		}

		[HarmonyPatch(typeof(ShopManager), "CloseStore")]
		[HarmonyPostfix]
		public static void ShopManager_CloseStore_Postfix()
		{
			ShopRelicSyncState.CurrentShopManager = null;
			ShopRelicSyncState.LatestRelicEffects = null;
		}

		[HarmonyPatch(typeof(ShopManager), "PurchaseItem")]
		[HarmonyPostfix]
		public static void ShopManager_PurchaseItem_Postfix(IPurchasableItem item)
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Expected I4, but got O
			//IL_010e: Expected O, but got I4
			//IL_0109->IL0109: Incompatible stack types: O vs I4
			//IL_0102->IL0109: Incompatible stack types: I4 vs O
			//IL_0102->IL0109: Incompatible stack types: O vs I4
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic || !MultiplayerClientPatches.AllowShopLogic)
			{
				return;
			}
			try
			{
				ShopPurchase shopPurchase = new ShopPurchase();
				PurchasableOrb val = (PurchasableOrb)(object)((item is PurchasableOrb) ? item : null);
				if (val != null)
				{
					shopPurchase.Type = "orb";
					object? obj = AccessTools.Field(typeof(PurchasableOrb), "_orbPrefab")?.GetValue(val);
					GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
					shopPurchase.Name = ((val2 == null) ? null : ((Object)val2).name?.Replace("(Clone)", string.Empty).Trim()) ?? "unknown";
					shopPurchase.Cost = item.GetCost();
				}
				else
				{
					PurchasableRelic val3 = (PurchasableRelic)(object)((item is PurchasableRelic) ? item : null);
					if (val3 != null)
					{
						shopPurchase.Type = "relic";
						object? obj2 = AccessTools.Field(typeof(PurchasableRelic), "_relic")?.GetValue(val3);
						Relic val4 = (Relic)((obj2 is Relic) ? obj2 : null);
						shopPurchase.Name = val4?.locKey ?? "unknown";
						object obj3 = shopPurchase;
						int num;
						if ((Object)(object)val4 != (Object)null)
						{
							obj3 = val4.effect;
							num = (int)obj3;
						}
						else
						{
							num = -1;
							obj3 = num;
							num = (int)obj3;
						}
						((ShopPurchase)num).RelicEffect = (int)obj3;
						shopPurchase.Cost = item.GetCost();
					}
				}
				MultiplayerClientPatches.ClientShopPurchases.Add(shopPurchase);
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[ClientPatch] Tracked shop purchase: {shopPurchase.Type} '{shopPurchase.Name}' cost={shopPurchase.Cost}");
				}
				try
				{
					IServiceContainer services = MultiplayerPlugin.Services;
					if (services != null && services.TryResolve<IMessageSender>(out var instance))
					{
						instance.Send(new ShopPurchaseEvent
						{
							Type = shopPurchase.Type,
							Name = shopPurchase.Name,
							Cost = shopPurchase.Cost,
							RelicEffect = shopPurchase.RelicEffect
						});
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogInfo((object)$"[ClientPatch] Sent ShopPurchaseEvent: {shopPurchase.Type} '{shopPurchase.Name}' cost={shopPurchase.Cost}");
						}
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)("[ClientPatch] Failed to send ShopPurchaseEvent: " + ex.Message));
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("[ClientPatch] Failed to track shop purchase: " + ex2.Message));
				}
			}
		}

		[HarmonyPatch(typeof(ShopManager), "CloseStore")]
		[HarmonyPrefix]
		public static bool ShopManager_CloseStore_Prefix(ShopManager __instance)
		{
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				if (CoopRewardState.ClientShopChoiceSent)
				{
					return false;
				}
				try
				{
					MultiplayerClientPatches.AllowShopLogic = false;
					CurrencyManager instance = CurrencyManager.Instance;
					int num = ((instance != null) ? instance.GoldAmount : 0);
					int num2 = MultiplayerClientPatches.ClientShopStartGold - num;
					ShopCompleteEvent shopCompleteEvent = new ShopCompleteEvent
					{
						Purchases = new List<ShopPurchase>(MultiplayerClientPatches.ClientShopPurchases),
						GoldSpent = ((num2 > 0) ? num2 : 0),
						RemainingGold = num
					};
					IServiceContainer services = MultiplayerPlugin.Services;
					if (services != null && services.TryResolve<IMessageSender>(out var instance2))
					{
						instance2.Send(shopCompleteEvent);
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)$"[ClientPatch] Sent ShopCompleteEvent: {shopCompleteEvent.Purchases.Count} purchases, gold={shopCompleteEvent.RemainingGold}");
						}
					}
					MultiplayerClientPatches.ClientShopPurchases.Clear();
					CoopRewardState.ClientShopChoiceSent = true;
				}
				catch (Exception ex)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogError((object)("[ClientPatch] Failed to send ShopCompleteEvent: " + ex.Message));
					}
				}
				CoopRewardState.WaitingForOtherPlayers = true;
				CoopRewardState.ShopPhaseActive = true;
				CoopRewardState.AllChoicesComplete = false;
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)"[ClientPatch] Client finished shopping — waiting for other players");
				}
				return false;
			}
			if (MultiplayerClientPatches.IsHosting && CoopRewardState.ShopPhaseActive)
			{
				if (CoopRewardState.HostShopDone && !CoopRewardState.AllClientShopChoicesReceived)
				{
					return false;
				}
				CoopRewardState.HostShopDone = true;
				CoopRewardState.AllChoicesComplete = false;
				if (CoopRewardState.AllClientShopChoicesReceived)
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogInfo((object)"[ClientPatch] Host CloseStore — all clients done, proceeding");
					}
					CoopRewardState.ShopPhaseActive = false;
					CoopRewardState.WaitingForOtherPlayers = false;
					CoopRewardState.ShopCompletionProceeded = true;
					IServiceContainer services2 = MultiplayerPlugin.Services;
					if (services2 != null && services2.TryResolve<IGameEventRegistry>(out var instance3))
					{
						instance3.Dispatch(new AllChoicesCompleteEvent
						{
							Phase = "shop"
						});
					}
					return true;
				}
				CoopRewardState.PendingShopManager = __instance;
				CoopRewardState.WaitingForOtherPlayers = true;
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogInfo((object)"[ClientPatch] Host CloseStore — waiting for other players to finish shopping");
				}
				return false;
			}
			return true;
		}
	}
	public static class ShopRelicSyncState
	{
		public static List<int> LatestRelicEffects { get; set; }

		public static ShopManager CurrentShopManager { get; set; }

		public static void PopulateShopRelics(ShopManager sm, ManualLogSource log)
		{
			//IL_01ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0264: Expected O, but got Unknown
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)sm == (Object)null)
			{
				return;
			}
			List<int> latestRelicEffects = LatestRelicEffects;
			if (latestRelicEffects == null || latestRelicEffects.Count == 0)
			{
				if (log != null)
				{
					log.LogInfo((object)"[ShopRelicSync] No synced relic effects yet — deferring shop relic display");
				}
				return;
			}
			try
			{
				object? obj = AccessTools.Field(typeof(ShopManager), "relicManager")?.GetValue(sm);
				RelicManager val = (RelicManager)((obj is RelicManager) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					if (log != null)
					{
						log.LogWarning((object)"[ShopRelicSync] relicManager null on ShopManager");
					}
					return;
				}
				object? obj2 = AccessTools.Field(typeof(ShopManager), "purchasablePrefab")?.GetValue(sm);
				GameObject val2 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				if ((Object)(object)val2 == (Object)null)
				{
					if (log != null)
					{
						log.LogWarning((object)"[ShopRelicSync] purchasablePrefab null");
					}
					return;
				}
				object? obj3 = AccessTools.Field(typeof(ShopManager), "relicContainer")?.GetValue(sm);
				GameObject val3 = (GameObject)((obj3 is GameObject) ? obj3 : null);
				if ((Object)(object)val3 == (Object)null)
				{
					if (log != null)
					{
						log.LogWarning((object)"[ShopRelicSync] relicContainer null");
					}
					return;
				}
				Array array = AccessTools.Field(typeof(ShopManager), "_purchasableRelics")?.GetValue(sm) as Array;
				IList<ShopItem> list = AccessTools.Field(typeof(ShopManager), "relicItems")?.GetValue(sm) as IList<ShopItem>;
				object? obj4 = AccessTools.Field(typeof(ShopManager), "_playerHealthController")?.GetValue(sm);
				PlayerHealthController val4 = (PlayerHealthController)((obj4 is PlayerHealthController) ? obj4 : null);
				object? obj5 = AccessTools.Field(typeof(ShopManager), "_rewiredEventSystem")?.GetValue(sm);
				RewiredEventSystem val5 = (RewiredEventSystem)((obj5 is RewiredEventSystem) ? obj5 : null);
				DestroyExistingRelicItems(sm, array, list);
				Relic[] source = Resources.FindObjectsOfTypeAll<Relic>();
				int num = ((!val.WandOfGreedEffectActive()) ? 1 : 2);
				if ((Object)(object)MapController.instance != (Object)null && MapController.instance.Act == 4)
				{
					num *= 2;
				}
				int num2 = 0;
				for (int i = 0; i < latestRelicEffects.Count; i++)
				{
					RelicEffect effect = (RelicEffect)latestRelicEffects[i];
					Relic val6 = ((IEnumerable<Relic>)source).FirstOrDefault((Func<Relic, bool>)((Relic r) => r.effect == effect));
					if ((Object)(object)val6 == (Object)null)
					{
						if (log != null)
						{
							log.LogWarning((object)$"[ShopRelicSync] Relic asset not found for effect {effect}");
						}
						continue;
					}
					ShopItem component = Object.Instantiate<GameObject>(val2, val3.transform).GetComponent<ShopItem>();
					if ((Object)(object)component == (Object)null)
					{
						continue;
					}
					PurchasableRelic val7 = new PurchasableRelic(val6, val, num);
					component.Initialize((IPurchasableItem)(object)val7, sm, val4, val);
					if ((Object)(object)val5 != (Object)null)
					{
						ArrowSelection componentInChildren = ((Component)component).GetComponentInChildren<ArrowSelection>();
						if ((Object)(object)componentInChildren != (Object)null)
						{
							componentInChildren.rewiredEventSystem = val5;
						}
					}
					if (array != null && num2 < array.Length)
					{
						array.SetValue(val7, num2);
					}
					list?.Add(component);
					num2++;
				}
				if (log != null)
				{
					log.LogInfo((object)$"[ShopRelicSync] Populated {num2} shop relics from synced effects");
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[ShopRelicSync] PopulateShopRelics failed: " + ex.Message));
				}
			}
		}

		private static void DestroyExistingRelicItems(ShopManager sm, Array purchasable, IList<ShopItem> relicItems)
		{
			if (relicItems != null)
			{
				for (int num = relicItems.Count - 1; num >= 0; num--)
				{
					ShopItem val = relicItems[num];
					if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).gameObject != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)val).gameObject);
					}
				}
				relicItems.Clear();
			}
			if (purchasable != null)
			{
				for (int i = 0; i < purchasable.Length; i++)
				{
					purchasable.SetValue(null, i);
				}
			}
		}

		public static void RefreshDisplayedShopRelics(ManualLogSource log)
		{
			ShopManager currentShopManager = CurrentShopManager;
			if (!((Object)(object)currentShopManager == (Object)null))
			{
				PopulateShopRelics(currentShopManager, log);
			}
		}
	}
	[HarmonyPatch]
	internal static class SlimeBossPatches
	{
		[HarmonyPatch(typeof(SlimeBoss), "UpdatePachinkoPos")]
		[HarmonyPrefix]
		public static bool SlimeBoss_UpdatePachinkoPos_Prefix()
		{
			return !MultiplayerClientPatches.ShouldSuppressClientLogic;
		}
	}
	[HarmonyPatch]
	internal static class SpecialSlotControllerPatches
	{
		[HarmonyPatch(typeof(SpecialSlotController), "SlotActivated")]
		[HarmonyPrefix]
		public static bool SpecialSlotController_SlotActivated_Prefix(int index, BattleController ____battleController, int ____inhaleSlot)
		{
			if (!MultiplayerClientPatches.IsHosting)
			{
				return true;
			}
			if (!LobbyUI.GameStartReceived)
			{
				return true;
			}
			if (TurnChangeClientHandler.IsMyTurn)
			{
				return true;
			}
			if ((Object)(object)____battleController != (Object)null && !____battleController.IsNavigating() && index == ____inhaleSlot)
			{
				SpecialSlotController.OrbInhaled?.Invoke();
			}
			return false;
		}

		[HarmonyPatch(typeof(SpecialSlotController), "TurnComplete")]
		[HarmonyPrefix]
		public static bool SpecialSlotController_TurnComplete_Prefix()
		{
			return !MultiplayerClientPatches.ShouldSuppressClientLogic;
		}

		[HarmonyPatch(typeof(SpecialSlotController), "TurnComplete")]
		[HarmonyPostfix]
		public static void SpecialSlotController_TurnComplete_Postfix(SpecialSlotController __instance)
		{
			if (!MultiplayerClientPatches.IsHosting || (Object)(object)__instance == (Object)null || __instance.slotTriggers == null)
			{
				return;
			}
			try
			{
				SlotTrigger[] slotTriggers = __instance.slotTriggers;
				int num = slotTriggers.Length;
				float[] array = new float[num];
				bool[] array2 = new bool[num];
				bool[] array3 = new bool[num];
				FieldInfo fieldInfo = AccessTools.Field(typeof(SlotTrigger), "_isPortal");
				for (int i = 0; i < num; i++)
				{
					SlotTrigger val = slotTriggers[i];
					if ((Object)(object)val == (Object)null)
					{
						array[i] = 1f;
						continue;
					}
					array[i] = val.multiplier;
					array3[i] = val.damageOnEnter;
					array2[i] = fieldInfo != null && (bool)fieldInfo.GetValue(val);
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IGameEventRegistry>(out var instance))
				{
					instance.Dispatch(new SlotConfigEvent
					{
						Multipliers = array,
						PortalsOn = array2,
						FlamesOn = array3
					});
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[SlotConfig] capture failed: " + ex.Message));
				}
			}
		}

		public static void ReconfigurePortalsForActiveRelics(ManualLogSource log = null)
		{
			//IL_0150: Unknown result type (might be due to invalid IL or missing references)
			//IL_0155: Unknown result type (might be due to invalid IL or missing references)
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_01be: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				SpecialSlotController val = Object.FindObjectOfType<SpecialSlotController>();
				if ((Object)(object)val == (Object)null || val.slotTriggers == null || val.slotTriggers.Length == 0)
				{
					return;
				}
				RelicManager val2 = Resources.FindObjectsOfTypeAll<RelicManager>()?.FirstOrDefault();
				if ((Object)(object)val2 == (Object)null)
				{
					return;
				}
				bool flag = val2.RelicEffectActive((RelicEffect)87);
				if (!flag)
				{
					IServiceContainer services = MultiplayerPlugin.Services;
					if (services != null && services.TryResolve<CoopStateManager>(out var instance))
					{
						foreach (KeyValuePair<int, CoopPlayerState> playerState in instance.PlayerStates)
						{
							List<SerializedRelic> list = playerState.Value?.OwnedRelics;
							if (list == null)
							{
								continue;
							}
							foreach (SerializedRelic item in list)
							{
								if (item != null && item.Effect == 87)
								{
									flag = true;
									break;
								}
							}
							if (flag)
							{
								break;
							}
						}
					}
				}
				int[] array = AccessTools.Field(typeof(SpecialSlotController), "_slotMultipliersRelicAmounts")?.GetValue(val) as int[];
				Color val3 = (Color)(AccessTools.Field(typeof(SpecialSlotController), "bottomPortalColor")?.GetValue(val) ?? ((object)Color.magenta));
				SlotTrigger[] slotTriggers = val.slotTriggers;
				bool[] array2 = new bool[slotTriggers.Length];
				float[] array3 = new float[slotTriggers.Length];
				bool[] array4 = new bool[slotTriggers.Length];
				for (int i = 0; i < slotTriggers.Length; i++)
				{
					if ((Object)(object)slotTriggers[i] == (Object)null)
					{
						array3[i] = 1f;
						continue;
					}
					bool flag2 = flag && array != null && i < array.Length && array[i] == -1;
					slotTriggers[i].TogglePortal(flag2, val3);
					array2[i] = flag2;
					array3[i] = slotTriggers[i].multiplier;
					array4[i] = slotTriggers[i].damageOnEnter;
				}
				IServiceContainer services2 = MultiplayerPlugin.Services;
				if (services2 != null && services2.TryResolve<IGameEventRegistry>(out var instance2))
				{
					instance2.Dispatch(new SlotConfigEvent
					{
						Multipliers = array3,
						PortalsOn = array2,
						FlamesOn = array4
					});
				}
				if (log != null)
				{
					log.LogInfo((object)("[SlotConfig] Reconfigured portals for active relics: " + string.Format("SLOT_PORTAL={0}, portalSlots=[{1}]", flag, string.Join(",", array2))));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[SlotConfig] reconfigure failed: " + ex.Message));
				}
			}
		}

		[HarmonyPatch(typeof(SlotTrigger), "OnTriggerEnter2D")]
		[HarmonyPrefix]
		public static void SlotTrigger_OnTriggerEnter2D_Prefix(SlotTrigger __instance, Collider2D collision)
		{
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!MultiplayerClientPatches.IsHosting || !LobbyUI.GameStartReceived)
				{
					return;
				}
				PachinkoBall val = ((collision != null) ? ((Component)collision).GetComponent<PachinkoBall>() : null);
				if (!((Object)(object)val == (Object)null))
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(SlotTrigger), "_isPortal");
					FieldInfo fieldInfo2 = AccessTools.Field(typeof(SlotTrigger), "_portalUsageCount");
					bool flag = fieldInfo != null && (bool)(fieldInfo.GetValue(__instance) ?? ((object)false));
					int num = ((fieldInfo2 != null) ? ((int)(fieldInfo2.GetValue(__instance) ?? ((object)0))) : (-1));
					bool flag2 = BattleController.AwaitingShotCompletion();
					bool flag3 = flag2 && flag && num < 3;
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)($"[PortalDiag] slot={__instance.index} isPortal={flag} " + $"usage={num} awaiting={flag2} mult={__instance.multiplier} " + $"flame={__instance.damageOnEnter} ballPos={((Component)val).transform.position} " + $"willTeleport={flag3} myTurn={TurnChangeClientHandler.IsMyTurn}"));
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[PortalDiag] log failed: " + ex.Message));
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class SpeedupIndicatorPatches
	{
		[HarmonyPatch(typeof(SpeedupIndicator), "Start")]
		[HarmonyPostfix]
		public static void SpeedupIndicator_Start_Postfix(SpeedupIndicator __instance)
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return;
			}
			Image[] componentsInChildren = ((Component)__instance).GetComponentsInChildren<Image>(true);
			foreach (Image val in componentsInChildren)
			{
				if (!((Object)(object)((Component)val).gameObject == (Object)(object)((Component)__instance).gameObject) && !((Object)(object)((Component)val).GetComponentInChildren<TextMeshProUGUI>() == (Object)(object)__instance.Text))
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
		}
	}
	[HarmonyPatch]
	internal static class SpiritOfRadiaBossPatches
	{
		[HarmonyPatch(typeof(SpiritOfRadiaBoss), "StartPhase2Transition")]
		[HarmonyPrefix]
		public static bool SpiritOfRadiaBoss_StartPhase2Transition_Prefix(ref IEnumerator __result)
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[ClientPatch] Blocked SpiritOfRadiaBoss.StartPhase2Transition — host drives phase-2 state");
				}
				__result = MultiplayerClientPatches.EmptyEnumerator();
				return false;
			}
			return true;
		}

		[HarmonyPatch(typeof(SpiritOfRadiaBoss), "StartPhase2PreTransition")]
		[HarmonyPrefix]
		public static bool SpiritOfRadiaBoss_StartPhase2PreTransition_Prefix(ref IEnumerator __result)
		{
			if (MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				__result = MultiplayerClientPatches.EmptyEnumerator();
				return false;
			}
			return true;
		}
	}
	[HarmonyPatch]
	internal static class StandardUIResponseButtonPatches
	{
		[HarmonyPatch(typeof(StandardUIResponseButton), "OnClick")]
		[HarmonyPrefix]
		public static bool StandardUIResponseButton_OnClick_Prefix()
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] Blocked StandardUIResponseButton.OnClick (spectating)");
			}
			return false;
		}

		[HarmonyPatch(typeof(StandardUIResponseButton), "OnSelect")]
		[HarmonyPostfix]
		public static void StandardUIResponseButton_OnSelect_Postfix(StandardUIResponseButton __instance)
		{
			if (!MultiplayerClientPatches.IsHosting)
			{
				return;
			}
			try
			{
				StandardDialogueUI val = Object.FindObjectOfType<StandardDialogueUI>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				StandardUIMenuPanel val2 = val.conversationUIElements?.defaultMenuPanel;
				if (val2?.buttons == null)
				{
					return;
				}
				for (int i = 0; i < val2.buttons.Length; i++)
				{
					if ((Object)(object)val2.buttons[i] == (Object)(object)__instance)
					{
						TextScenarioHoverTracker.CurrentHoveredIndex = i;
						break;
					}
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch]
	internal static class StatusEffectIconManagerPatches
	{
		[HarmonyPatch(typeof(StatusEffectIconManager), "UpdateStatusEffects")]
		[HarmonyPrefix]
		public static bool StatusEffectIconManager_UpdateStatusEffects_Prefix()
		{
			if (!CoopStateManager.SuppressStatusEffectUI)
			{
				return true;
			}
			return false;
		}
	}
	[HarmonyPatch]
	internal static class SteamManagerPatches
	{
		[HarmonyPatch(typeof(SteamManager), "Awake")]
		[HarmonyPrefix]
		public static bool SteamManager_Awake_Prefix(SteamManager __instance)
		{
			if (Environment.GetEnvironmentVariable("SKIP_STEAM_INIT") != "1")
			{
				return true;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ClientPatch] SKIP_STEAM_INIT set, skipping SteamManager.Awake");
			}
			typeof(SteamManager).GetField("s_instance", BindingFlags.Static | BindingFlags.NonPublic)?.SetValue(null, __instance);
			Object.DontDestroyOnLoad((Object)(object)((Component)__instance).gameObject);
			return false;
		}
	}
	[HarmonyPatch]
	internal static class SummoningCirclePatches
	{
		[HarmonyPatch(typeof(PachinkoBall), "SpawnMultiballFromLocation")]
		[HarmonyPrefix]
		public static void PachinkoBall_SpawnMultiballFromLocation_Prefix(PachinkoBall __instance, GameObject multiballGameObject, out bool __state)
		{
			__state = false;
			if (MultiplayerClientPatches.IsHosting && __instance is SummoningCirclePachinkoBall && !((Object)(object)multiballGameObject == (Object)null) && !multiballGameObject.activeSelf)
			{
				multiballGameObject.SetActive(true);
				__state = true;
			}
		}

		[HarmonyPatch(typeof(PachinkoBall), "SpawnMultiballFromLocation")]
		[HarmonyPostfix]
		public static void PachinkoBall_SpawnMultiballFromLocation_Postfix(PachinkoBall __instance, GameObject multiballGameObject, GameObject __result, bool __state)
		{
			if (!MultiplayerClientPatches.IsHosting)
			{
				return;
			}
			if (!(__instance is SummoningCirclePachinkoBall))
			{
				if (__state && (Object)(object)multiballGameObject != (Object)null)
				{
					multiballGameObject.SetActive(false);
				}
				return;
			}
			if ((Object)(object)__result != (Object)null && !__result.activeSelf)
			{
				__result.SetActive(true);
			}
			if (__state && (Object)(object)multiballGameObject != (Object)null)
			{
				multiballGameObject.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(PachinkoBall), "SpawnMultiballFromLocation")]
		[HarmonyFinalizer]
		public static Exception PachinkoBall_SpawnMultiballFromLocation_Finalizer(PachinkoBall __instance, GameObject multiballGameObject, Exception __exception, bool __state)
		{
			if (__state && (Object)(object)multiballGameObject != (Object)null && multiballGameObject.activeSelf)
			{
				multiballGameObject.SetActive(false);
			}
			if (__exception == null || !MultiplayerClientPatches.IsHosting)
			{
				return __exception;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogError((object)("[SC] SpawnFromLocation THREW src='" + (((Object)(object)multiballGameObject != (Object)null) ? ((Object)multiballGameObject).name : "<null>") + "' caller=" + ((object)__instance)?.GetType().Name + ": " + __exception.GetType().Name + ": " + __exception.Message));
			}
			return null;
		}

		[HarmonyPatch(typeof(PredictionManager), "InitializePachinko")]
		[HarmonyPrefix]
		public static void PredictionManager_InitializePachinko_Prefix(GameObject subject, out bool __state)
		{
			__state = false;
			if (!((Object)(object)subject == (Object)null) && !subject.activeSelf)
			{
				subject.SetActive(true);
				__state = true;
			}
		}

		[HarmonyPatch(typeof(PredictionManager), "InitializePachinko")]
		[HarmonyPostfix]
		public static void PredictionManager_InitializePachinko_Postfix(GameObject subject, bool __state)
		{
			if (__state && (Object)(object)subject != (Object)null && subject.activeSelf)
			{
				subject.SetActive(false);
			}
		}

		[HarmonyPatch(typeof(PredictionManager), "InitializePachinko")]
		[HarmonyFinalizer]
		public static Exception PredictionManager_InitializePachinko_Finalizer(GameObject subject, Exception __exception, bool __state)
		{
			if (__state && (Object)(object)subject != (Object)null && subject.activeSelf)
			{
				subject.SetActive(false);
			}
			return __exception;
		}
	}
	[HarmonyPatch]
	internal static class TargetingManagerPatches
	{
		[HarmonyPatch(typeof(TargetingManager), "SetEnemyAsTarget")]
		[HarmonyPostfix]
		public static void TargetingManager_SetEnemyAsTarget_Postfix(Enemy enemy)
		{
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic || !LobbyUI.GameStartReceived || !TurnChangeClientHandler.IsMyTurn)
			{
				return;
			}
			try
			{
				string targetEnemyGuid = null;
				if ((Object)(object)enemy != (Object)null)
				{
					IServiceContainer services = MultiplayerPlugin.Services;
					if (services != null && services.TryResolve<EnemyIdentifier>(out var instance))
					{
						targetEnemyGuid = instance.GetGuid(enemy);
					}
				}
				IServiceContainer services2 = MultiplayerPlugin.Services;
				if (services2 != null && services2.TryResolve<IMessageSender>(out var instance2))
				{
					instance2.Send(new TargetSelectEvent
					{
						TargetEnemyGuid = targetEnemyGuid
					});
				}
			}
			catch
			{
			}
		}
	}
	[HarmonyPatch]
	internal static class TextScenarioInteractionsPatches
	{
		[HarmonyPatch(typeof(TextScenarioInteractions), "OfferRelic")]
		[HarmonyPrefix]
		public static bool TextScenarioInteractions_OfferRelic_ClientOverride_Prefix(TextScenarioInteractions __instance, RelicRarity rarity)
		{
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			if (!MultiplayerClientPatches.ShouldSuppressClientLogic)
			{
				return true;
			}
			if (!MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				return true;
			}
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(TextScenarioInteractions), "relicPanel");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(TextScenarioInteractions), "skipRelicButton");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(TextScenarioInteractions), "relicManager");
				object? obj = fieldInfo?.GetValue(__instance);
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				object? obj2 = fieldInfo2?.GetValue(__instance);
				Button val2 = (Button)((obj2 is Button) ? obj2 : null);
				object? obj3 = fieldInfo3?.GetValue(__instance);
				RelicManager rm = (RelicManager)((obj3 is RelicManager) ? obj3 : null);
				if ((Object)(object)val == (Object)null)
				{
					return true;
				}
				val.SetActive(true);
				int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(MultiplayerPlugin.Services);
				Relic val3 = MultiplayerClientPatches.PickRandomLocalRelic(rarity, rm, localSlotIndex);
				RelicIcon[] componentsInChildren = val.GetComponentsInChildren<RelicIcon>(true);
				for (int i = 0; i < componentsInChildren.Length; i++)
				{
					if (i == 0 && (Object)(object)val3 != (Object)null)
					{
						componentsInChildren[i].SetRelic(val3);
						((Component)((Component)componentsInChildren[i]).transform.parent).gameObject.SetActive(true);
					}
					else
					{
						((Component)((Component)componentsInChildren[i]).transform.parent).gameObject.SetActive(false);
					}
				}
				if (val2 != null)
				{
					((Component)val2).gameObject.SetActive(true);
				}
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)($"[ClientPatch] TextScenario OfferRelic slot={localSlotIndex} relic=" + string.Format("'{0}' rarity={1}", ((val3 != null) ? ((Object)val3).name : null) ?? "<none>", rarity)));
				}
				return false;
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[ClientPatch] OfferRelic client override failed, falling through: " + ex.Message));
				}
				return true;
			}
		}
	}
	[HarmonyPatch]
	internal static class TimescaleManagerPatches
	{
		[HarmonyPatch(typeof(TimescaleManager), "Update")]
		[HarmonyPrefix]
		public static bool TimescaleManager_Update_Prefix()
		{
			return !MultiplayerClientPatches.ShouldSuppressClientLogic;
		}

		[HarmonyPatch(typeof(TimescaleManager), "ManualSpeedupToggle")]
		[HarmonyPrefix]
		public static bool TimescaleManager_ManualSpeedupToggle_Prefix()
		{
			return !MultiplayerClientPatches.ShouldSuppressClientLogic;
		}
	}
	[HarmonyPatch]
	internal static class TutorialManagerPatches
	{
		[HarmonyPatch(typeof(TutorialManager), "ShouldPopupTutorial")]
		[HarmonyPrefix]
		public static bool TutorialManager_ShouldPopupTutorial_Prefix(ref bool __result)
		{
			if (MultiplayerPlugin.Services == null)
			{
				return true;
			}
			if (!MultiplayerPlugin.Services.TryResolve<IMultiplayerMode>(out var instance))
			{
				return true;
			}
			if (!instance.IsHosting && !instance.IsSpectating)
			{
				return true;
			}
			__result = false;
			return false;
		}
	}
}
namespace Multipeglin.Network
{
	public sealed class AppLevelRttProvider : IRttProvider
	{
		private const double PingIntervalSeconds = 5.0;

		private const int MaxRttSamples = 5;

		private readonly IMultiplayerMode _mode;

		private readonly ManualLogSource _log;

		private readonly Stopwatch _clock = Stopwatch.StartNew();

		private long _nextToken = 1L;

		private long _lastPingToken;

		private long _lastPingSentTicks;

		private double _lastSentSeconds = -5.0;

		private readonly int[] _samples = new int[5];

		private int _sampleCount;

		private int _sampleIndex;

		private int _smoothedMs;

		public int CurrentRttMs => _smoothedMs;

		public AppLevelRttProvider(IMultiplayerMode mode, ManualLogSource log)
		{
			_mode = mode;
			_log = log;
		}

		public void Tick()
		{
			if (_mode == null || !_mode.IsSpectating)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<INetworkTransport>(out var instance) && instance.IsConnected && services.TryResolve<IMessageSender>(out var instance2))
			{
				double totalSeconds = _clock.Elapsed.TotalSeconds;
				if (!(totalSeconds - _lastSentSeconds < 5.0))
				{
					_lastSentSeconds = totalSeconds;
					_lastPingToken = _nextToken++;
					_lastPingSentTicks = _clock.ElapsedTicks;
					instance2.Send(new PingEvent
					{
						Token = _lastPingToken
					});
				}
			}
		}

		public void OnPongReceived(long token)
		{
			if (token == _lastPingToken)
			{
				int num = (int)((_clock.ElapsedTicks - _lastPingSentTicks) * 1000 / Stopwatch.Frequency);
				if (num < 0)
				{
					num = 0;
				}
				_samples[_sampleIndex] = num;
				_sampleIndex = (_sampleIndex + 1) % 5;
				if (_sampleCount < 5)
				{
					_sampleCount++;
				}
				_smoothedMs = Median();
			}
		}

		private int Median()
		{
			int[] array = new int[_sampleCount];
			for (int i = 0; i < _sampleCount; i++)
			{
				array[i] = _samples[i];
			}
			Array.Sort(array);
			return array[_sampleCount / 2];
		}
	}
	public class HostRttTickerBehaviour : MonoBehaviour
	{
		private HostRttTracker _tracker;

		private void Update()
		{
			if (_tracker == null)
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<HostRttTracker>(out _tracker))
				{
					return;
				}
			}
			_tracker.Tick();
		}
	}
	public sealed class HostRttTracker
	{
		private const double ProbeIntervalSeconds = 5.0;

		private const double LogIntervalSeconds = 10.0;

		private readonly IMultiplayerMode _mode;

		private readonly ManualLogSource _log;

		private readonly Stopwatch _clock = Stopwatch.StartNew();

		private long _nextToken = 1L;

		private double _lastProbeAt = -5.0;

		private double _lastLogAt;

		private bool _loggedFirstTick;

		private int _probeCount;

		private int _pongCount;

		private readonly Dictionary<int, (long Token, long SentTicks)> _outstanding = new Dictionary<int, (long, long)>();

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

		public IReadOnlyDictionary<int, int> PerPeerRttMs => _latestRttMs;

		public HostRttTracker(IMultiplayerMode mode, ManualLogSource log)
		{
			_mode = mode;
			_log = log;
		}

		public void Tick()
		{
			if (_mode == null || !_mode.IsHosting)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<INetworkTransport>(out var instance) && services.TryResolve<INetworkSerializer>(out var instance2))
			{
				if (!_loggedFirstTick)
				{
					_loggedFirstTick = true;
					_log.LogInfo((object)$"[HostRtt] tracker armed (probe={5.0}s, log={10.0}s)");
				}
				double totalSeconds = _clock.Elapsed.TotalSeconds;
				if (totalSeconds - _lastProbeAt >= 5.0)
				{
					_lastProbeAt = totalSeconds;
					ProbeAllPeers(instance, instance2);
				}
				if (totalSeconds - _lastLogAt >= 10.0)
				{
					_lastLogAt = totalSeconds;
					LogPerPeerRtt(services);
				}
			}
		}

		private void ProbeAllPeers(INetworkTransport transport, INetworkSerializer serializer)
		{
			IReadOnlyList<int> connectedPeerIds = transport.ConnectedPeerIds;
			int num = 0;
			foreach (int item in connectedPeerIds)
			{
				long num2 = _nextToken++;
				_outstanding[item] = (num2, _clock.ElapsedTicks);
				byte[] data = serializer.Serialize(new HostPingEvent
				{
					Token = num2
				});
				transport.SendTo(item, data);
				num++;
			}
			_probeCount += num;
			if (num == 0)
			{
				_log.LogWarning((object)"[HostRtt] probe cycle: 0 connected peers");
			}
		}

		public void OnPongReceived(int peerId, long token)
		{
			if (!_outstanding.TryGetValue(peerId, out (long, long) value) || value.Item1 != token)
			{
				_log.LogWarning((object)$"[HostRtt] stale pong: peer={peerId} token={token}");
				return;
			}
			int num = (int)((_clock.ElapsedTicks - value.Item2) * 1000 / Stopwatch.Frequency);
			if (num < 0)
			{
				num = 0;
			}
			_latestRttMs[peerId] = num;
			_pongCount++;
		}

		private void LogPerPeerRtt(IServiceContainer services)
		{
			if (_latestRttMs.Count == 0)
			{
				_log.LogInfo((object)$"[HostRtt] no pongs received yet (probesSent={_probeCount}, pongsRecv={_pongCount})");
				return;
			}
			services.TryResolve<PlayerRegistry>(out var instance);
			StringBuilder stringBuilder = new StringBuilder();
			stringBuilder.Append("[HostRtt] per-peer round-trip:");
			foreach (KeyValuePair<int, int> latestRttM in _latestRttMs)
			{
				string arg = instance?.GetSlotByPeerId(latestRttM.Key)?.PlayerName ?? "?";
				stringBuilder.Append($" peer={latestRttM.Key}({arg}):{latestRttM.Value}ms");
			}
			stringBuilder.Append($" (probesSent={_probeCount}, pongsRecv={_pongCount})");
			_log.LogInfo((object)stringBuilder.ToString());
		}
	}
	public interface IMessageReceiver
	{
		void ProcessIncoming(int senderPeerId, byte[] data);
	}
	public interface IMessageSender
	{
		void Send<TNetworkEvent>(TNetworkEvent networkEvent) where TNetworkEvent : class;

		void SendTo<TNetworkEvent>(int peerId, TNetworkEvent networkEvent) where TNetworkEvent : class;
	}
	public interface INetworkTransport
	{
		bool IsHost { get; }

		bool IsConnected { get; }

		IReadOnlyList<int> ConnectedPeerIds { get; }

		event Action<int, byte[]> OnDataReceived;

		event Action<int> OnClientConnected;

		event Action<int> OnDisconnected;

		event Action<string> OnConnectionRejected;

		void StartHost(int port);

		void Connect(string address, int port);

		void Send(byte[] data);

		void SendTo(int peerId, byte[] data);

		void Broadcast(byte[] data);

		void PollEvents();

		void Stop();
	}
	public interface IRttProvider
	{
		int CurrentRttMs { get; }
	}
	public interface ISteamTransport : INetworkTransport
	{
		CSteamID HostedLobbyId { get; }

		event Action<CSteamID> OnIncomingInvite;

		void JoinSteamLobby(CSteamID lobbyId);

		void CloseLobbyOnStart();
	}
	public class LiteNetTransport : INetworkTransport, INetEventListener
	{
		private NetManager _netManager;

		private readonly ConcurrentDictionary<int, NetPeer> _peers = new ConcurrentDictionary<int, NetPeer>();

		public bool IsHost { get; private set; }

		public bool IsConnected => _peers.Count > 0;

		public IReadOnlyList<int> ConnectedPeerIds => _peers.Keys.ToList();

		public event Action<int, byte[]> OnDataReceived;

		public event Action<int> OnClientConnected;

		public event Action<int> OnDisconnected;

		public event Action<string> OnConnectionRejected;

		public void StartHost(int port)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			IsHost = true;
			_netManager = new NetManager((INetEventListener)(object)this, (PacketLayerBase)null)
			{
				AutoRecycle = true
			};
			_netManager.Start(port);
		}

		public void Connect(string address, int port)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Expected O, but got Unknown
			IsHost = false;
			_netManager = new NetManager((INetEventListener)(object)this, (PacketLayerBase)null)
			{
				AutoRecycle = true
			};
			_netManager.Start();
			_netManager.Connect(address, port, NetworkConfig.ConnectionKey);
		}

		public void Send(byte[] data)
		{
			Broadcast(data);
		}

		public void SendTo(int peerId, byte[] data)
		{
			if (_peers.TryGetValue(peerId, out var value))
			{
				value.Send(data, (DeliveryMethod)2);
			}
		}

		public void Broadcast(byte[] data)
		{
			foreach (NetPeer value in _peers.Values)
			{
				value.Send(data, (DeliveryMethod)2);
			}
		}

		public void PollEvents()
		{
			NetManager netManager = _netManager;
			if (netManager != null)
			{
				netManager.PollEvents(0);
			}
		}

		public void Stop()
		{
			NetManager netManager = _netManager;
			if (netManager != null)
			{
				netManager.Stop();
			}
			_peers.Clear();
		}

		public void OnPeerConnected(NetPeer peer)
		{
			_peers[peer.Id] = peer;
			this.OnClientConnected?.Invoke(peer.Id);
		}

		public void OnPeerDisconnected(NetPeer peer, DisconnectInfo disconnectInfo)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Invalid comparison between Unknown and I4
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			_peers.TryRemove(peer.Id, out var _);
			if (!IsHost && (int)disconnectInfo.Reason == 6)
			{
				string obj = "version";
				try
				{
					if (disconnectInfo.AdditionalData != null && ((NetDataReader)disconnectInfo.AdditionalData).AvailableBytes > 0)
					{
						obj = ((NetDataReader)disconnectInfo.AdditionalData).GetString();
					}
				}
				catch
				{
				}
				this.OnConnectionRejected?.Invoke(obj);
			}
			else
			{
				this.OnDisconnected?.Invoke(peer.Id);
			}
		}

		public void OnNetworkReceive(NetPeer peer, NetPacketReader reader, byte channelNumber, DeliveryMethod deliveryMethod)
		{
			byte[] array = new byte[((NetDataReader)reader).AvailableBytes];
			((NetDataReader)reader).GetBytes(array, array.Length);
			this.OnDataReceived?.Invoke(peer.Id, array);
		}

		public void OnConnectionRequest(ConnectionRequest request)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Expected O, but got Unknown
			string @string;
			try
			{
				@string = request.Data.GetString();
			}
			catch
			{
				request.Reject();
				return;
			}
			if (@string != NetworkConfig.ConnectionKey)
			{
				request.Reject();
			}
			else if (_peers.Count >= 3)
			{
				NetDataWriter val = new NetDataWriter();
				val.Put("full");
				request.Reject(val);
			}
			else
			{
				request.Accept();
			}
		}

		public void OnNetworkError(IPEndPoint endPoint, SocketError socketError)
		{
		}

		public void OnNetworkReceiveUnconnected(IPEndPoint remoteEndPoint, NetPacketReader reader, UnconnectedMessageType messageType)
		{
		}

		public void OnNetworkLatencyUpdate(NetPeer peer, int latency)
		{
		}
	}
	public class NetworkClient : IMessageReceiver
	{
		private readonly INetworkTransport _transport;

		private readonly IGameEventRegistry _eventRegistry;

		private readonly INetworkSerializer _serializer;

		public NetworkClient(INetworkTransport transport, IGameEventRegistry eventRegistry, INetworkSerializer serializer)
		{
			_transport = transport;
			_eventRegistry = eventRegistry;
			_serializer = serializer;
			_transport.OnDataReceived += ProcessIncoming;
		}

		public void ProcessIncoming(int senderPeerId, byte[] data)
		{
			var (typeId, jsonPayload) = _serializer.Deserialize(data);
			_eventRegistry.HandleIncoming(typeId, jsonPayload, senderPeerId);
		}
	}
	public static class NetworkConfig
	{
		public const int DefaultPort = 7777;

		public const int MaxClients = 3;

		public static string ConnectionKey => "Multipeglin_0.1.10";
	}
	public class NetworkHost : IMessageSender
	{
		private readonly INetworkTransport _transport;

		private readonly INetworkSerializer _serializer;

		public NetworkHost(INetworkTransport transport, INetworkSerializer serializer)
		{
			_transport = transport;
			_serializer = serializer;
		}

		public void Send<TNetworkEvent>(TNetworkEvent networkEvent) where TNetworkEvent : class
		{
			byte[] data = _serializer.Serialize(networkEvent);
			_transport.Broadcast(data);
		}

		public void SendTo<TNetworkEvent>(int peerId, TNetworkEvent networkEvent) where TNetworkEvent : class
		{
			byte[] data = _serializer.Serialize(networkEvent);
			_transport.SendTo(peerId, data);
		}
	}
	public class NetworkPollBehaviour : MonoBehaviour
	{
		private INetworkTransport _transport;

		public void Initialize(INetworkTransport transport)
		{
			_transport = transport;
		}

		private void Update()
		{
			_transport?.PollEvents();
		}
	}
	public class RttPingTicker : MonoBehaviour
	{
		private AppLevelRttProvider _provider;

		private void Update()
		{
			if (_provider == null)
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<AppLevelRttProvider>(out _provider))
				{
					return;
				}
			}
			_provider.Tick();
		}
	}
	public class SteamTransport : ISteamTransport, INetworkTransport
	{
		private const string KEY_MOD_VERSION = "mod_version";

		private const string KEY_GAME_VERSION = "game_version";

		private const string KEY_HOST_NAME = "host_name";

		private const string KEY_STATE = "state";

		private const byte HELLO_BYTE = 170;

		private const int HOST_PEER_ID = -1;

		private Callback<LobbyCreated_t> _cbLobbyCreated;

		private Callback<LobbyEnter_t> _cbLobbyEnter;

		private Callback<LobbyChatUpdate_t> _cbLobbyChat;

		private readonly Callback<GameLobbyJoinRequested_t> _cbJoinRequested;

		private Callback<P2PSessionRequest_t> _cbSessionRequest;

		private Callback<P2PSessionConnectFail_t> _cbSessionFail;

		private CSteamID _mySteamId;

		private CSteamID _lobbyId;

		private CSteamID _hostSteamId;

		private bool _isHost;

		private bool _started;

		private readonly Dictionary<CSteamID, int> _peerIdByCSteamId = new Dictionary<CSteamID, int>();

		private readonly Dictionary<int, CSteamID> _cSteamIdByPeerId = new Dictionary<int, CSteamID>();

		private int _nextPeerId = 1;

		private byte[] _recvBuffer = new byte[1200];

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public bool IsHost => _isHost;

		public bool IsConnected => _peerIdByCSteamId.Count > 0;

		public IReadOnlyList<int> ConnectedPeerIds => _peerIdByCSteamId.Values.ToList();

		public CSteamID HostedLobbyId => _lobbyId;

		public event Action<int, byte[]> OnDataReceived;

		public event Action<int> OnClientConnected;

		public event Action<int> OnDisconnected;

		public event Action<string> OnConnectionRejected;

		public event Action<CSteamID> OnIncomingInvite;

		public SteamTransport()
		{
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			if (!SteamManager.Initialized)
			{
				return;
			}
			try
			{
				_mySteamId = SteamUser.GetSteamID();
				_cbJoinRequested = Callback<GameLobbyJoinRequested_t>.Create((DispatchDelegate<GameLobbyJoinRequested_t>)OnGameLobbyJoinRequested);
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"[Steam] Transport constructed. SteamID={_mySteamId.m_SteamID}");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogError((object)$"[Steam] Transport ctor failed: {arg}");
				}
			}
		}

		public void StartHost(int port)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			_isHost = true;
			_started = true;
			EnsureSessionCallbacks();
			try
			{
				SteamMatchmaking.CreateLobby((ELobbyType)1, 4);
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"[Steam] CreateLobby requested (FriendsOnly, capacity {4})");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogError((object)$"[Steam] CreateLobby failed: {arg}");
				}
				this.OnConnectionRejected?.Invoke("steam-error");
			}
		}

		public void Connect(string address, int port)
		{
			throw new NotSupportedException("SteamTransport.Connect is not supported; use JoinSteamLobby(CSteamID).");
		}

		public void JoinSteamLobby(CSteamID lobbyId)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			_isHost = false;
			_started = true;
			EnsureSessionCallbacks();
			try
			{
				SteamMatchmaking.JoinLobby(lobbyId);
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)$"[Steam] JoinLobby requested for {lobbyId.m_SteamID}");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogError((object)$"[Steam] JoinLobby failed: {arg}");
				}
				this.OnConnectionRejected?.Invoke("steam-error");
			}
		}

		public void Send(byte[] data)
		{
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			CSteamID value;
			if (_isHost)
			{
				Broadcast(data);
			}
			else if (_cSteamIdByPeerId.TryGetValue(-1, out value))
			{
				SendP2P(value, data);
			}
		}

		public void SendTo(int peerId, byte[] data)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			if (_cSteamIdByPeerId.TryGetValue(peerId, out var value))
			{
				SendP2P(value, data);
			}
		}

		public void Broadcast(byte[] data)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			foreach (CSteamID value in _cSteamIdByPeerId.Values)
			{
				SendP2P(value, data);
			}
		}

		public void PollEvents()
		{
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			if (!_started)
			{
				return;
			}
			uint num = default(uint);
			uint num2 = default(uint);
			CSteamID sid = default(CSteamID);
			while (SteamNetworking.IsP2PPacketAvailable(ref num, 0))
			{
				if (num > _recvBuffer.Length)
				{
					_recvBuffer = new byte[num];
				}
				if (!SteamNetworking.ReadP2PPacket(_recvBuffer, num, ref num2, ref sid, 0))
				{
					break;
				}
				if (num2 == 1 && _recvBuffer[0] == 170)
				{
					GetOrAssignPeerId(sid);
					continue;
				}
				int orAssignPeerId = GetOrAssignPeerId(sid);
				byte[] array = new byte[num2];
				Buffer.BlockCopy(_recvBuffer, 0, array, 0, (int)num2);
				try
				{
					this.OnDataReceived?.Invoke(orAssignPeerId, array);
				}
				catch (Exception arg)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogError((object)$"[Steam] OnDataReceived handler threw: {arg}");
					}
				}
			}
		}

		public void Stop()
		{
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: 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_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if (!_started)
			{
				return;
			}
			_started = false;
			try
			{
				foreach (CSteamID value in _cSteamIdByPeerId.Values)
				{
					try
					{
						SteamNetworking.CloseP2PSessionWithUser(value);
					}
					catch
					{
					}
				}
				_peerIdByCSteamId.Clear();
				_cSteamIdByPeerId.Clear();
				_nextPeerId = 1;
				if (((CSteamID)(ref _lobbyId)).IsValid())
				{
					try
					{
						SteamMatchmaking.LeaveLobby(_lobbyId);
					}
					catch
					{
					}
				}
				_lobbyId = CSteamID.Nil;
				_hostSteamId = CSteamID.Nil;
				try
				{
					SteamFriends.SetRichPresence("connect", string.Empty);
				}
				catch
				{
				}
				DisposeSessionCallbacks();
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)"[Steam] Transport stopped");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogError((object)$"[Steam] Stop error: {arg}");
				}
			}
		}

		public void CloseLobbyOnStart()
		{
			//IL_0018: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			if (!_isHost || !((CSteamID)(ref _lobbyId)).IsValid())
			{
				return;
			}
			try
			{
				SteamMatchmaking.SetLobbyData(_lobbyId, "state", "closed");
				SteamMatchmaking.SetLobbyType(_lobbyId, (ELobbyType)0);
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)"[Steam] Lobby closed (state=closed, type=private)");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)("[Steam] CloseLobbyOnStart failed: " + ex.Message));
				}
			}
		}

		private void OnLobbyCreated(LobbyCreated_t evt)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			if ((int)evt.m_eResult != 1)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogError((object)$"[Steam] LobbyCreated failed: {evt.m_eResult}");
				}
				this.OnConnectionRejected?.Invoke($"steam-lobby-{evt.m_eResult}");
				return;
			}
			_lobbyId = new CSteamID(evt.m_ulSteamIDLobby);
			_hostSteamId = _mySteamId;
			try
			{
				SteamMatchmaking.SetLobbyData(_lobbyId, "mod_version", "0.1.10");
				SteamMatchmaking.SetLobbyData(_lobbyId, "game_version", Application.version ?? "unknown");
				SteamMatchmaking.SetLobbyData(_lobbyId, "host_name", SteamFriends.GetPersonaName());
				SteamMatchmaking.SetLobbyData(_lobbyId, "state", "open");
				SteamFriends.SetRichPresence("connect", $"+connect_lobby {_lobbyId.m_SteamID}");
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)$"[Steam] Lobby {_lobbyId.m_SteamID} created and advertised");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogWarning((object)("[Steam] SetLobbyData failed: " + ex.Message));
				}
			}
		}

		private void OnLobbyEnter(LobbyEnter_t evt)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0190: Unknown result type (might be due to invalid IL or missing references)
			//IL_0195: Unknown result type (might be due to invalid IL or missing references)
			//IL_019a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_022f: Unknown result type (might be due to invalid IL or missing references)
			//IL_023b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			CSteamID lobbyId = default(CSteamID);
			((CSteamID)(ref lobbyId))..ctor(evt.m_ulSteamIDLobby);
			if (evt.m_EChatRoomEnterResponse != 1)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)$"[Steam] LobbyEnter failed: response={evt.m_EChatRoomEnterResponse}");
				}
				this.OnConnectionRejected?.Invoke($"steam-enter-{evt.m_EChatRoomEnterResponse}");
			}
			else
			{
				if (_isHost)
				{
					return;
				}
				_lobbyId = lobbyId;
				string lobbyData = SteamMatchmaking.GetLobbyData(_lobbyId, "mod_version");
				string lobbyData2 = SteamMatchmaking.GetLobbyData(_lobbyId, "state");
				if (string.IsNullOrEmpty(lobbyData))
				{
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogWarning((object)"[Steam] Lobby has no mod_version metadata");
					}
					SteamMatchmaking.LeaveLobby(_lobbyId);
					_lobbyId = CSteamID.Nil;
					this.OnConnectionRejected?.Invoke("Lobby is not hosted by Multipeglin.");
					return;
				}
				if (lobbyData != "0.1.10")
				{
					ManualLogSource log3 = Log;
					if (log3 != null)
					{
						log3.LogWarning((object)("[Steam] Version mismatch: host=" + lobbyData + " local=0.1.10"));
					}
					SteamMatchmaking.LeaveLobby(_lobbyId);
					_lobbyId = CSteamID.Nil;
					this.OnConnectionRejected?.Invoke("Version mismatch: host v" + lobbyData + ", you v0.1.10");
					return;
				}
				if (lobbyData2 == "closed")
				{
					ManualLogSource log4 = Log;
					if (log4 != null)
					{
						log4.LogWarning((object)"[Steam] Lobby already closed");
					}
					SteamMatchmaking.LeaveLobby(_lobbyId);
					_lobbyId = CSteamID.Nil;
					this.OnConnectionRejected?.Invoke("Game already in progress");
					return;
				}
				_hostSteamId = SteamMatchmaking.GetLobbyOwner(_lobbyId);
				if (((CSteamID)(ref _hostSteamId)).IsValid() && !(_hostSteamId == _mySteamId))
				{
					_peerIdByCSteamId[_hostSteamId] = -1;
					_cSteamIdByPeerId[-1] = _hostSteamId;
					SendP2P(_hostSteamId, new byte[1] { 170 });
					ManualLogSource log5 = Log;
					if (log5 != null)
					{
						log5.LogInfo((object)$"[Steam] Lobby entered, host={_hostSteamId.m_SteamID}");
					}
					try
					{
						this.OnClientConnected?.Invoke(-1);
						return;
					}
					catch (Exception arg)
					{
						ManualLogSource log6 = Log;
						if (log6 != null)
						{
							log6.LogError((object)$"[Steam] OnClientConnected handler threw: {arg}");
						}
						return;
					}
				}
				ManualLogSource log7 = Log;
				if (log7 != null)
				{
					log7.LogWarning((object)$"[Steam] Invalid lobby owner: {_hostSteamId.m_SteamID}");
				}
				SteamMatchmaking.LeaveLobby(_lobbyId);
				_lobbyId = CSteamID.Nil;
				this.OnConnectionRejected?.Invoke("Could not resolve host.");
			}
		}

		private void OnLobbyChatUpdate(LobbyChatUpdate_t evt)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Invalid comparison between Unknown and I4
			//IL_003f: 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_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			if (!((CSteamID)(ref _lobbyId)).IsValid() || evt.m_ulSteamIDLobby != _lobbyId.m_SteamID)
			{
				return;
			}
			CSteamID val = default(CSteamID);
			((CSteamID)(ref val))..ctor(evt.m_ulSteamIDUserChanged);
			EChatMemberStateChange val2 = (EChatMemberStateChange)evt.m_rgfChatMemberStateChange;
			if ((val2 & 0x1E) > 0)
			{
				HandlePeerLeft(val);
			}
			else
			{
				if (!_isHost || (val2 & 1) == 0 || val == _mySteamId)
				{
					return;
				}
				int count = _peerIdByCSteamId.Count;
				if (count >= 3)
				{
					ManualLogSource log = Log;
					if (log != null)
					{
						log.LogWarning((object)$"[Steam] Lobby full — refusing {val.m_SteamID} ({count}/{3})");
					}
					try
					{
						SteamNetworking.CloseP2PSessionWithUser(val);
						return;
					}
					catch
					{
						return;
					}
				}
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)$"[Steam] Lobby member entered: {val.m_SteamID} ({count + 1}/{3})");
				}
			}
		}

		private void OnGameLobbyJoinRequested(GameLobbyJoinRequested_t evt)
		{
			//IL_0065: 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_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			if (!((CSteamID)(ref evt.m_steamIDLobby)).IsValid())
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)"[Steam] GameLobbyJoinRequested with invalid lobby id");
				}
				return;
			}
			if (_isHost)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogInfo((object)$"[Steam] Ignoring incoming invite to {evt.m_steamIDLobby.m_SteamID} — already hosting");
				}
				return;
			}
			ManualLogSource log3 = Log;
			if (log3 != null)
			{
				log3.LogInfo((object)$"[Steam] Incoming invite to lobby {evt.m_steamIDLobby.m_SteamID} — awaiting user confirmation");
			}
			try
			{
				this.OnIncomingInvite?.Invoke(evt.m_steamIDLobby);
			}
			catch (Exception arg)
			{
				ManualLogSource log4 = Log;
				if (log4 != null)
				{
					log4.LogError((object)$"[Steam] OnIncomingInvite handler threw: {arg}");
				}
			}
		}

		private void OnP2PSessionRequest(P2PSessionRequest_t evt)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: 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_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_008d: Unknown result type (might be due to invalid IL or missing references)
			CSteamID steamIDRemote = evt.m_steamIDRemote;
			if (!IsLobbyMember(steamIDRemote))
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)$"[Steam] Refusing P2P from non-member {steamIDRemote.m_SteamID}");
				}
				try
				{
					SteamNetworking.CloseP2PSessionWithUser(steamIDRemote);
					return;
				}
				catch
				{
					return;
				}
			}
			if (_isHost && !_peerIdByCSteamId.ContainsKey(steamIDRemote) && _peerIdByCSteamId.Count >= 3)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)$"[Steam] Refusing P2P from {steamIDRemote.m_SteamID}: lobby full");
				}
				try
				{
					SteamNetworking.CloseP2PSessionWithUser(steamIDRemote);
					return;
				}
				catch
				{
					return;
				}
			}
			if (!SteamNetworking.AcceptP2PSessionWithUser(steamIDRemote))
			{
				ManualLogSource log3 = Log;
				if (log3 != null)
				{
					log3.LogWarning((object)$"[Steam] AcceptP2PSessionWithUser({steamIDRemote.m_SteamID}) returned false");
				}
			}
			else
			{
				if (!_isHost || _peerIdByCSteamId.ContainsKey(steamIDRemote))
				{
					return;
				}
				int orAssignPeerId = GetOrAssignPeerId(steamIDRemote);
				ManualLogSource log4 = Log;
				if (log4 != null)
				{
					log4.LogInfo((object)$"[Steam] Accepted P2P session: {steamIDRemote.m_SteamID} -> peerId {orAssignPeerId}");
				}
				try
				{
					this.OnClientConnected?.Invoke(orAssignPeerId);
				}
				catch (Exception arg)
				{
					ManualLogSource log5 = Log;
					if (log5 != null)
					{
						log5.LogError((object)$"[Steam] OnClientConnected handler threw: {arg}");
					}
				}
			}
		}

		private void OnP2PSessionConnectFail(P2PSessionConnectFail_t evt)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			CSteamID steamIDRemote = evt.m_steamIDRemote;
			EP2PSessionError val = (EP2PSessionError)evt.m_eP2PSessionError;
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogWarning((object)$"[Steam] P2P session failed: {steamIDRemote.m_SteamID} error={val}");
			}
			HandlePeerLeft(steamIDRemote);
		}

		private void HandlePeerLeft(CSteamID sid)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_0024: Unknown result type (might be due to invalid IL or missing references)
			//IL_0012: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			if (!_peerIdByCSteamId.TryGetValue(sid, out var value))
			{
				return;
			}
			try
			{
				SteamNetworking.CloseP2PSessionWithUser(sid);
			}
			catch
			{
			}
			_peerIdByCSteamId.Remove(sid);
			_cSteamIdByPeerId.Remove(value);
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)$"[Steam] Peer left: {sid.m_SteamID} (peerId {value})");
			}
			try
			{
				this.OnDisconnected?.Invoke(value);
			}
			catch (Exception arg)
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogError((object)$"[Steam] OnDisconnected handler threw: {arg}");
				}
			}
		}

		private int GetOrAssignPeerId(CSteamID sid)
		{
			//IL_0006: 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_0038: Unknown result type (might be due to invalid IL or missing references)
			if (_peerIdByCSteamId.TryGetValue(sid, out var value))
			{
				return value;
			}
			value = _nextPeerId++;
			_peerIdByCSteamId[sid] = value;
			_cSteamIdByPeerId[value] = sid;
			return value;
		}

		private bool IsLobbyMember(CSteamID sid)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			if (!((CSteamID)(ref _lobbyId)).IsValid())
			{
				return false;
			}
			int numLobbyMembers = SteamMatchmaking.GetNumLobbyMembers(_lobbyId);
			for (int i = 0; i < numLobbyMembers; i++)
			{
				if (SteamMatchmaking.GetLobbyMemberByIndex(_lobbyId, i) == sid)
				{
					return true;
				}
			}
			return false;
		}

		private void SendP2P(CSteamID sid, byte[] data)
		{
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: Unknown result type (might be due to invalid IL or missing references)
			if (data.Length > 1100)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)$"[Steam] SendP2P {data.Length}B exceeds 1100B MTU hint");
				}
			}
			if (!SteamNetworking.SendP2PPacket(sid, data, (uint)data.Length, (EP2PSend)2, 0))
			{
				ManualLogSource log2 = Log;
				if (log2 != null)
				{
					log2.LogWarning((object)$"[Steam] SendP2PPacket to {sid.m_SteamID} returned false");
				}
			}
		}

		private void EnsureSessionCallbacks()
		{
			if (_cbLobbyCreated == null)
			{
				_cbLobbyCreated = Callback<LobbyCreated_t>.Create((DispatchDelegate<LobbyCreated_t>)OnLobbyCreated);
			}
			if (_cbLobbyEnter == null)
			{
				_cbLobbyEnter = Callback<LobbyEnter_t>.Create((DispatchDelegate<LobbyEnter_t>)OnLobbyEnter);
			}
			if (_cbLobbyChat == null)
			{
				_cbLobbyChat = Callback<LobbyChatUpdate_t>.Create((DispatchDelegate<LobbyChatUpdate_t>)OnLobbyChatUpdate);
			}
			if (_cbSessionRequest == null)
			{
				_cbSessionRequest = Callback<P2PSessionRequest_t>.Create((DispatchDelegate<P2PSessionRequest_t>)OnP2PSessionRequest);
			}
			if (_cbSessionFail == null)
			{
				_cbSessionFail = Callback<P2PSessionConnectFail_t>.Create((DispatchDelegate<P2PSessionConnectFail_t>)OnP2PSessionConnectFail);
			}
		}

		private void DisposeSessionCallbacks()
		{
			try
			{
				_cbLobbyCreated?.Dispose();
			}
			catch
			{
			}
			try
			{
				_cbLobbyEnter?.Dispose();
			}
			catch
			{
			}
			try
			{
				_cbLobbyChat?.Dispose();
			}
			catch
			{
			}
			try
			{
				_cbSessionRequest?.Dispose();
			}
			catch
			{
			}
			try
			{
				_cbSessionFail?.Dispose();
			}
			catch
			{
			}
			_cbLobbyCreated = null;
			_cbLobbyEnter = null;
			_cbLobbyChat = null;
			_cbSessionRequest = null;
			_cbSessionFail = null;
		}
	}
	public class TransportRouter : INetworkTransport, ISteamTransport
	{
		private readonly LiteNetTransport _lite;

		private SteamTransport _steam;

		private INetworkTransport _active;

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public bool HasSteam => _steam != null;

		public SteamTransport InnerSteam => _steam;

		public LiteNetTransport InnerLite => _lite;

		public bool ActiveIsSteam => _active == _steam;

		public bool IsHost => _active.IsHost;

		public bool IsConnected => _active.IsConnected;

		public IReadOnlyList<int> ConnectedPeerIds => _active.ConnectedPeerIds;

		public CSteamID HostedLobbyId => _steam?.HostedLobbyId ?? CSteamID.Nil;

		public event Action<int, byte[]> OnDataReceived;

		public event Action<int> OnClientConnected;

		public event Action<int> OnDisconnected;

		public event Action<string> OnConnectionRejected;

		public event Action<CSteamID> OnIncomingInvite
		{
			add
			{
				if (_steam != null)
				{
					_steam.OnIncomingInvite += value;
				}
			}
			remove
			{
				if (_steam != null)
				{
					_steam.OnIncomingInvite -= value;
				}
			}
		}

		public TransportRouter(LiteNetTransport lite, SteamTransport steam)
		{
			_lite = lite;
			_active = lite;
			_lite.OnDataReceived += delegate(int p, byte[] d)
			{
				this.OnDataReceived?.Invoke(p, d);
			};
			_lite.OnClientConnected += delegate(int p)
			{
				this.OnClientConnected?.Invoke(p);
			};
			_lite.OnDisconnected += delegate(int p)
			{
				this.OnDisconnected?.Invoke(p);
			};
			_lite.OnConnectionRejected += delegate(string r)
			{
				this.OnConnectionRejected?.Invoke(r);
			};
			if (steam != null)
			{
				AttachSteam(steam);
			}
		}

		public void AttachSteam(SteamTransport steam)
		{
			if (steam != null && _steam == null)
			{
				_steam = steam;
				_steam.OnDataReceived += delegate(int p, byte[] d)
				{
					this.OnDataReceived?.Invoke(p, d);
				};
				_steam.OnClientConnected += delegate(int p)
				{
					this.OnClientConnected?.Invoke(p);
				};
				_steam.OnDisconnected += delegate(int p)
				{
					this.OnDisconnected?.Invoke(p);
				};
				_steam.OnConnectionRejected += delegate(string r)
				{
					this.OnConnectionRejected?.Invoke(r);
				};
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)"[Router] Steam transport attached");
				}
			}
		}

		public void UseLite()
		{
			if (_active == _lite)
			{
				return;
			}
			try
			{
				_active?.Stop();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[Router] Prev transport stop failed: " + ex.Message));
				}
			}
			_active = _lite;
			ManualLogSource log2 = Log;
			if (log2 != null)
			{
				log2.LogInfo((object)"[Router] Active transport = LiteNet");
			}
		}

		public void UseSteam()
		{
			if (_steam == null || _active == _steam)
			{
				return;
			}
			try
			{
				_active?.Stop();
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[Router] Prev transport stop failed: " + ex.Message));
				}
			}
			_active = _steam;
			ManualLogSource log2 = Log;
			if (log2 != null)
			{
				log2.LogInfo((object)"[Router] Active transport = Steam");
			}
		}

		public void StartHost(int port)
		{
			_active.StartHost(port);
		}

		public void Connect(string address, int port)
		{
			_active.Connect(address, port);
		}

		public void Send(byte[] data)
		{
			_active.Send(data);
		}

		public void SendTo(int peerId, byte[] data)
		{
			_active.SendTo(peerId, data);
		}

		public void Broadcast(byte[] data)
		{
			_active.Broadcast(data);
		}

		public void Stop()
		{
			_active.Stop();
		}

		public void PollEvents()
		{
			_lite.PollEvents();
			_steam?.PollEvents();
		}

		public void JoinSteamLobby(CSteamID lobbyId)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			if (_steam == null)
			{
				this.OnConnectionRejected?.Invoke("Steam not available");
				return;
			}
			UseSteam();
			_steam.JoinSteamLobby(lobbyId);
		}

		public void CloseLobbyOnStart()
		{
			_steam?.CloseLobbyOnStart();
		}
	}
}
namespace Multipeglin.Network.Protocol
{
	public interface INetworkSerializer
	{
		byte[] Serialize<TNetworkEvent>(TNetworkEvent networkEvent) where TNetworkEvent : class;

		(string typeId, string jsonPayload) Deserialize(byte[] data);
	}
	public class JsonNetworkSerializer : INetworkSerializer
	{
		private const byte FrameRawJson = 0;

		private const byte FrameDeflateJson = 1;

		private const int CompressionThresholdBytes = 256;

		private readonly MessageTypeRegistry _typeRegistry;

		private long _sequence;

		public JsonNetworkSerializer(MessageTypeRegistry typeRegistry)
		{
			_typeRegistry = typeRegistry;
		}

		public byte[] Serialize<TNetworkEvent>(TNetworkEvent networkEvent) where TNetworkEvent : class
		{
			string typeId = _typeRegistry.GetTypeId<TNetworkEvent>();
			string payload = JsonConvert.SerializeObject((object)networkEvent);
			string s = JsonConvert.SerializeObject((object)new NetworkEnvelope
			{
				TypeId = typeId,
				Payload = payload,
				Sequence = Interlocked.Increment(ref _sequence),
				TimestampMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
			});
			return Frame(Encoding.UTF8.GetBytes(s));
		}

		public (string typeId, string jsonPayload) Deserialize(byte[] data)
		{
			string text = Unframe(data);
			NetworkEnvelope networkEnvelope = JsonConvert.DeserializeObject<NetworkEnvelope>(text);
			if (networkEnvelope == null || string.IsNullOrEmpty(networkEnvelope.TypeId))
			{
				throw new InvalidOperationException($"Malformed network envelope (json length={text.Length})");
			}
			return (networkEnvelope.TypeId, networkEnvelope.Payload);
		}

		private static byte[] Frame(byte[] raw)
		{
			if (raw.Length < 256)
			{
				byte[] array = new byte[raw.Length + 1];
				array[0] = 0;
				Buffer.BlockCopy(raw, 0, array, 1, raw.Length);
				return array;
			}
			byte[] array2;
			using (MemoryStream memoryStream = new MemoryStream())
			{
				using (DeflateStream deflateStream = new DeflateStream(memoryStream, CompressionLevel.Fastest, leaveOpen: true))
				{
					deflateStream.Write(raw, 0, raw.Length);
				}
				array2 = memoryStream.ToArray();
			}
			if (array2.Length + 1 >= raw.Length + 1)
			{
				byte[] array3 = new byte[raw.Length + 1];
				array3[0] = 0;
				Buffer.BlockCopy(raw, 0, array3, 1, raw.Length);
				return array3;
			}
			byte[] array4 = new byte[array2.Length + 1];
			array4[0] = 1;
			Buffer.BlockCopy(array2, 0, array4, 1, array2.Length);
			return array4;
		}

		private static string Unframe(byte[] data)
		{
			if (data == null || data.Length == 0)
			{
				throw new InvalidOperationException("Empty network frame");
			}
			switch (data[0])
			{
			case 0:
				return Encoding.UTF8.GetString(data, 1, data.Length - 1);
			case 1:
			{
				using MemoryStream stream = new MemoryStream(data, 1, data.Length - 1);
				using DeflateStream stream2 = new DeflateStream(stream, CompressionMode.Decompress);
				using StreamReader streamReader = new StreamReader(stream2, Encoding.UTF8);
				return streamReader.ReadToEnd();
			}
			default:
				throw new InvalidOperationException($"Unknown network frame header 0x{data[0]:X2} (length={data.Length})");
			}
		}
	}
	public class MessageTypeRegistry
	{
		private readonly Dictionary<string, Type> _idToType = new Dictionary<string, Type>();

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

		public void Register<T>()
		{
			Type typeFromHandle = typeof(T);
			string fullName = typeFromHandle.FullName;
			_idToType[fullName] = typeFromHandle;
			_typeToId[typeFromHandle] = fullName;
		}

		public string GetTypeId<T>()
		{
			return _typeToId[typeof(T)];
		}

		public string GetTypeId(Type type)
		{
			return _typeToId[type];
		}

		public Type GetType(string typeId)
		{
			return _idToType[typeId];
		}

		public bool TryGetType(string typeId, out Type type)
		{
			return _idToType.TryGetValue(typeId, out type);
		}
	}
	public class NetworkEnvelope
	{
		public string TypeId { get; set; }

		public string Payload { get; set; }

		public long Sequence { get; set; }

		public long TimestampMs { get; set; }
	}
}
namespace Multipeglin.Multiplayer
{
	public enum ClientMode
	{
		Mirror,
		Diagnostics
	}
	public interface IMultiplayerMode
	{
		bool IsSpectating { get; }

		bool IsHosting { get; }

		ClientMode ClientMode { get; }

		void EnableHosting();

		void EnableSpectating();

		void Disable();
	}
	public class MultiplayerInputSuppressor
	{
		private readonly ManualLogSource _log;

		private bool _inputSuppressed;

		public MultiplayerInputSuppressor(ManualLogSource log)
		{
			_log = log;
		}

		public void SuppressInput()
		{
			if (_inputSuppressed)
			{
				return;
			}
			if (!ReInput.isReady)
			{
				_log.LogWarning((object)"Rewired not ready, cannot suppress input");
				return;
			}
			Player player = ReInput.players.GetPlayer(0);
			if (player != null)
			{
				player.controllers.maps.SetAllMapsEnabled(false);
				_inputSuppressed = true;
				_log.LogInfo((object)"Multiplayer input suppressed via Rewired");
			}
		}

		public void RestoreInput()
		{
			if (_inputSuppressed && ReInput.isReady)
			{
				Player player = ReInput.players.GetPlayer(0);
				if (player != null)
				{
					player.controllers.maps.SetAllMapsEnabled(true);
					_inputSuppressed = false;
					_log.LogInfo((object)"Multiplayer input restored via Rewired");
				}
			}
		}
	}
	public class MultiplayerMode : IMultiplayerMode
	{
		public bool IsSpectating { get; private set; }

		public bool IsHosting { get; private set; }

		public ClientMode ClientMode { get; set; }

		public void EnableHosting()
		{
			IsHosting = true;
			IsSpectating = false;
		}

		public void EnableSpectating()
		{
			IsSpectating = true;
			IsHosting = false;
		}

		public void Disable()
		{
			IsHosting = false;
			IsSpectating = false;
			ClientMode = ClientMode.Mirror;
		}
	}
	public static class MultiplayerSession
	{
		private static bool _disconnecting;

		private static ManualLogSource Log => MultiplayerPlugin.Logger;

		public static void DisconnectAndReset(string reason = null)
		{
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			if (_disconnecting)
			{
				return;
			}
			_disconnecting = true;
			try
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogInfo((object)("[Session] DisconnectAndReset: " + (reason ?? "no reason")));
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null)
				{
					_disconnecting = false;
					return;
				}
				TrySendDisconnect(services, reason);
				if (services.TryResolve<INetworkTransport>(out var instance))
				{
					instance.Stop();
					ManualLogSource log2 = Log;
					if (log2 != null)
					{
						log2.LogInfo((object)"[Session] Transport stopped");
					}
				}
				if (services.TryResolve<IMultiplayerMode>(out var instance2))
				{
					instance2.Disable();
					ManualLogSource log3 = Log;
					if (log3 != null)
					{
						log3.LogInfo((object)"[Session] Mode disabled");
					}
				}
				RemotePeerInfo.Reset();
				ResetStaticState(services);
				if (services.TryResolve<PlayerRegistry>(out var instance3))
				{
					instance3.Clear();
				}
				if (services.TryResolve<CoopStateManager>(out var instance4))
				{
					instance4.Reset();
				}
				LobbyUI.Reset();
				EventFeed.Clear();
				RemoteCursorRenderer.Instance?.ClearAll();
				FileLogger.RoleTag = null;
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (name != "MainMenu")
				{
					ManualLogSource log4 = Log;
					if (log4 != null)
					{
						log4.LogInfo((object)("[Session] Loading MainMenu (was on '" + name + "')"));
					}
					try
					{
						PeglinSceneLoader instance5 = PeglinSceneLoader.Instance;
						if ((Object)(object)instance5 != (Object)null)
						{
							instance5.LoadScene((Scene)1, (LoadSceneMode)0, true, 0f);
						}
						else
						{
							SceneManager.LoadScene("MainMenu");
						}
					}
					catch (Exception ex)
					{
						ManualLogSource log5 = Log;
						if (log5 != null)
						{
							log5.LogWarning((object)("[Session] Failed to load MainMenu: " + ex.Message));
						}
						try
						{
							SceneManager.LoadScene("MainMenu");
						}
						catch
						{
						}
					}
				}
				ManualLogSource log6 = Log;
				if (log6 != null)
				{
					log6.LogInfo((object)"[Session] Disconnect complete");
				}
			}
			catch (Exception arg)
			{
				ManualLogSource log7 = Log;
				if (log7 != null)
				{
					log7.LogError((object)$"[Session] DisconnectAndReset failed: {arg}");
				}
			}
			finally
			{
				_disconnecting = false;
			}
		}

		private static void TrySendDisconnect(IServiceContainer services, string reason)
		{
			try
			{
				if (services.TryResolve<INetworkTransport>(out var instance) && instance.IsConnected && services.TryResolve<IGameEventRegistry>(out var instance2))
				{
					instance2.Dispatch(new DisconnectEvent
					{
						Reason = (reason ?? "Disconnected")
					});
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = Log;
				if (log != null)
				{
					log.LogWarning((object)("[Session] Failed to send disconnect event: " + ex.Message));
				}
			}
		}

		private static void ResetStaticState(IServiceContainer services)
		{
			MultiplayerClientPatches.CapturedPreMapGenRngState = null;
			MultiplayerClientPatches.PendingRngStateToRestore = null;
			MultiplayerClientPatches.PendingBattleRngState = null;
			MultiplayerClientPatches.MapControllerStartCompleted = false;
			MultiplayerClientPatches.AllowNextSceneLoad = false;
			MultiplayerClientPatches.AllowStatusEffectSync = false;
			MapStateApplier.ResetAllState();
			MapStateProvider.ResetCachedState();
			if (services.TryResolve<EnemyIdentifier>(out var instance))
			{
				instance.Clear();
			}
			if (services.TryResolve<PegIdentifier>(out var instance2))
			{
				instance2.Clear();
			}
			if (services.TryResolve<GameStateApplyService>(out var instance3))
			{
				instance3.Reset();
			}
			ManualLogSource log = Log;
			if (log != null)
			{
				log.LogInfo((object)"[Session] Static state reset");
			}
		}
	}
	public class PlayerRegistry
	{
		private readonly Dictionary<int, PlayerSlot> _slotsByPeerId = new Dictionary<int, PlayerSlot>();

		private readonly List<PlayerSlot> _allSlots = new List<PlayerSlot>();

		public PlayerSlot LocalSlot { get; set; }

		public int SlotCount => _allSlots.Count;

		public bool AllClientsReady => _allSlots.Where((PlayerSlot s) => !s.IsHost).All((PlayerSlot s) => s.IsReady);

		public PlayerSlot RegisterHost(string playerName, string gameVersion, string modVersion)
		{
			PlayerSlot playerSlot = new PlayerSlot
			{
				SlotIndex = 0,
				PeerId = -1,
				PlayerName = playerName,
				IsHost = true,
				ChosenClass = 0,
				IsReady = true,
				GameVersion = gameVersion,
				ModVersion = modVersion
			};
			_allSlots.Add(playerSlot);
			return playerSlot;
		}

		public PlayerSlot RegisterClient(int peerId, string playerName, string gameVersion, string modVersion)
		{
			PlayerSlot playerSlot = new PlayerSlot
			{
				SlotIndex = AllocateFreeSlotIndex(),
				PeerId = peerId,
				PlayerName = playerName,
				IsHost = false,
				ChosenClass = 0,
				IsReady = false,
				GameVersion = gameVersion,
				ModVersion = modVersion
			};
			_slotsByPeerId[peerId] = playerSlot;
			_allSlots.Add(playerSlot);
			return playerSlot;
		}

		public PlayerSlot RegisterClientWithSlot(int peerId, string playerName, int desiredSlotIndex, int chosenClass, string gameVersion, string modVersion)
		{
			if (desiredSlotIndex < 0)
			{
				return null;
			}
			if (new HashSet<int>(_allSlots.Select((PlayerSlot s) => s.SlotIndex)).Contains(desiredSlotIndex))
			{
				return null;
			}
			PlayerSlot playerSlot = new PlayerSlot
			{
				SlotIndex = desiredSlotIndex,
				PeerId = peerId,
				PlayerName = playerName,
				IsHost = false,
				ChosenClass = chosenClass,
				IsReady = false,
				GameVersion = gameVersion,
				ModVersion = modVersion
			};
			_slotsByPeerId[peerId] = playerSlot;
			_allSlots.Add(playerSlot);
			return playerSlot;
		}

		private int AllocateFreeSlotIndex()
		{
			HashSet<int> hashSet = new HashSet<int>(_allSlots.Select((PlayerSlot s) => s.SlotIndex));
			int i;
			for (i = 1; hashSet.Contains(i); i++)
			{
			}
			return i;
		}

		public PlayerSlot GetSlotByPeerId(int peerId)
		{
			if (peerId == -1)
			{
				return GetHostSlot();
			}
			if (!_slotsByPeerId.TryGetValue(peerId, out var value))
			{
				return null;
			}
			return value;
		}

		public PlayerSlot GetSlotByIndex(int index)
		{
			return _allSlots.FirstOrDefault((PlayerSlot s) => s.SlotIndex == index);
		}

		public PlayerSlot GetHostSlot()
		{
			return _allSlots.FirstOrDefault((PlayerSlot s) => s.IsHost);
		}

		public IReadOnlyList<PlayerSlot> GetAllSlots()
		{
			return _allSlots;
		}

		public void RemoveByPeerId(int peerId)
		{
			if (_slotsByPeerId.TryGetValue(peerId, out var value))
			{
				_slotsByPeerId.Remove(peerId);
				_allSlots.Remove(value);
			}
		}

		public void Clear()
		{
			_slotsByPeerId.Clear();
			_allSlots.Clear();
		}
	}
	public class PlayerSlot
	{
		public int SlotIndex { get; set; }

		public int PeerId { get; set; }

		public string PlayerName { get; set; }

		public bool IsHost { get; set; }

		public int ChosenClass { get; set; }

		public bool IsReady { get; set; }

		public string GameVersion { get; set; }

		public string ModVersion { get; set; }
	}
}
namespace Multipeglin.GameState
{
	public class BallPositionSync : MonoBehaviour
	{
		private IGameEventRegistry _registry;

		private IMultiplayerMode _mode;

		private INetworkTransport _transport;

		private TurnManager _turnManager;

		private float _lastAimSendTime;

		private const float AimSendInterval = 0.1f;

		private void Start()
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null)
			{
				services.TryResolve<IGameEventRegistry>(out _registry);
				services.TryResolve<IMultiplayerMode>(out _mode);
				services.TryResolve<INetworkTransport>(out _transport);
				services.TryResolve<TurnManager>(out _turnManager);
			}
		}

		private void Update()
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Invalid comparison between Unknown and I4
			//IL_005f: Invalid comparison between Unknown and I4
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			if (_registry == null || _mode == null || _transport == null || !_mode.IsHosting || !_transport.IsConnected)
			{
				return;
			}
			BattleState currentBattleState = BattleController.CurrentBattleState;
			bool flag = (int)currentBattleState == 9;
			PachinkoBall val = (flag ? FindActiveBall() : null);
			bool flag2 = (Object)(object)val != (Object)null && val.IsFiring();
			if (((int)currentBattleState != 2 && (!flag || flag2)) || (_turnManager != null && _turnManager.CurrentPlayerSlot > 0) || Time.time - _lastAimSendTime < 0.1f)
			{
				return;
			}
			_lastAimSendTime = Time.time;
			PachinkoBall val2 = FindActiveBall();
			if (!((Object)(object)val2 == (Object)null))
			{
				Vector2 aimVector = val2.aimVector;
				if (!(aimVector == Vector2.zero))
				{
					Vector3 position = ((Component)val2).transform.position;
					_registry.Dispatch(new AimUpdateEvent
					{
						AimX = aimVector.x,
						AimY = aimVector.y,
						SpawnX = position.x,
						SpawnY = position.y
					});
				}
			}
		}

		private static PachinkoBall FindActiveBall()
		{
			PachinkoBall[] array = Object.FindObjectsOfType<PachinkoBall>();
			foreach (PachinkoBall val in array)
			{
				if (!val.IsDummy)
				{
					return val;
				}
			}
			return null;
		}
	}
	public class ClientAimRenderer : MonoBehaviour
	{
		private GameObject _lineObject;

		private LineRenderer _lineRenderer;

		private bool _isVisible;

		private const float LineLength = 3f;

		public static ClientAimRenderer Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
			if ((Object)(object)_lineObject != (Object)null)
			{
				Object.Destroy((Object)(object)_lineObject);
			}
		}

		public void UpdateAim(float aimX, float aimY, float spawnX, float spawnY)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0049: 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_005e: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_lineObject == (Object)null)
			{
				CreateLine();
			}
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(spawnX, spawnY, -0.5f);
			Vector3 val2 = new Vector3(aimX, aimY, 0f);
			Vector3 normalized = ((Vector3)(ref val2)).normalized;
			Vector3 val3 = val + normalized * 3f;
			_lineRenderer.SetPosition(0, val);
			_lineRenderer.SetPosition(1, val3);
			if (!_isVisible)
			{
				_lineObject.SetActive(true);
				_isVisible = true;
			}
			ClientBallRenderer.Instance?.UpdateAimDirection(aimX, aimY);
			ClientBallRenderer.Instance?.UpdateSpawnPosition(spawnX, spawnY);
		}

		public void HideAim()
		{
			_isVisible = false;
			GameObject lineObject = _lineObject;
			if (lineObject != null)
			{
				lineObject.SetActive(false);
			}
		}

		private void CreateLine()
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			//IL_007a: 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_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Expected O, but got Unknown
			_lineObject = new GameObject("ClientAimLine")
			{
				hideFlags = (HideFlags)61
			};
			Object.DontDestroyOnLoad((Object)(object)_lineObject);
			_lineRenderer = _lineObject.AddComponent<LineRenderer>();
			_lineRenderer.positionCount = 2;
			_lineRenderer.startWidth = 0.08f;
			_lineRenderer.endWidth = 0.04f;
			_lineRenderer.startColor = new Color(1f, 1f, 1f, 0.8f);
			_lineRenderer.endColor = new Color(1f, 1f, 1f, 0.2f);
			((Renderer)_lineRenderer).sortingOrder = 99;
			((Renderer)_lineRenderer).material = new Material(Shader.Find("Sprites/Default"));
			_lineRenderer.useWorldSpace = true;
			_lineObject.SetActive(false);
		}
	}
	public class ClientAttackProjectile : MonoBehaviour
	{
		private struct ShotParams
		{
			public GameObject ShotPrefab;

			public Vector3 MinSize;

			public Vector3 MaxSize;

			public Vector3 StartupOffset;

			public float MinForce;

			public float MaxForce;

			public float ForcePerPeg;
		}

		[CompilerGenerated]
		private sealed class <LaunchProjectile>d__26 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ClientAttackProjectile <>4__this;

			public Vector3 playerGroundPos;

			public Enemy targetEnemy;

			private GameObject <go>5__2;

			private Vector3 <startPos>5__3;

			private Vector3 <endPos>5__4;

			private float <duration>5__5;

			private float <elapsed>5__6;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0039: Unknown result type (might be due to invalid IL or missing references)
				//IL_003e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0040: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_0105: Unknown result type (might be due to invalid IL or missing references)
				//IL_010f: Expected O, but got Unknown
				//IL_008a: Unknown result type (might be due to invalid IL or missing references)
				//IL_008f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0092: Unknown result type (might be due to invalid IL or missing references)
				//IL_0097: Unknown result type (might be due to invalid IL or missing references)
				//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_0145: Unknown result type (might be due to invalid IL or missing references)
				//IL_0313: Unknown result type (might be due to invalid IL or missing references)
				//IL_0319: Unknown result type (might be due to invalid IL or missing references)
				//IL_0320: Unknown result type (might be due to invalid IL or missing references)
				//IL_0197: Unknown result type (might be due to invalid IL or missing references)
				//IL_0198: Unknown result type (might be due to invalid IL or missing references)
				//IL_019c: Unknown result type (might be due to invalid IL or missing references)
				//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
				//IL_01d8: Unknown result type (might be due to invalid IL or missing references)
				//IL_01dd: Unknown result type (might be due to invalid IL or missing references)
				//IL_01ee: Unknown result type (might be due to invalid IL or missing references)
				//IL_0203: Unknown result type (might be due to invalid IL or missing references)
				//IL_0208: Unknown result type (might be due to invalid IL or missing references)
				//IL_0234: Unknown result type (might be due to invalid IL or missing references)
				//IL_023b: Unknown result type (might be due to invalid IL or missing references)
				//IL_024d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0252: Unknown result type (might be due to invalid IL or missing references)
				//IL_0258: Unknown result type (might be due to invalid IL or missing references)
				//IL_025e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0263: Unknown result type (might be due to invalid IL or missing references)
				//IL_0268: Unknown result type (might be due to invalid IL or missing references)
				//IL_026c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0271: Unknown result type (might be due to invalid IL or missing references)
				//IL_0223: Unknown result type (might be due to invalid IL or missing references)
				//IL_0228: Unknown result type (might be due to invalid IL or missing references)
				//IL_022c: Unknown result type (might be due to invalid IL or missing references)
				//IL_0231: Unknown result type (might be due to invalid IL or missing references)
				//IL_0294: Unknown result type (might be due to invalid IL or missing references)
				//IL_029a: Unknown result type (might be due to invalid IL or missing references)
				//IL_028c: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				ClientAttackProjectile clientAttackProjectile = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
				{
					<>1__state = -1;
					ShotParams? shotParams = TryGetShotParams(clientAttackProjectile._orbName, clientAttackProjectile._isCrit);
					Vector3 val = DefaultMinSize;
					Vector3 val2 = DefaultMaxSize;
					Vector3 val3 = DefaultStartupOffset;
					float num2 = 100f;
					float num3 = 900f;
					float num4 = 50f;
					if (shotParams.HasValue && (Object)(object)shotParams.Value.ShotPrefab != (Object)null)
					{
						ShotParams value = shotParams.Value;
						val = value.MinSize;
						val2 = value.MaxSize;
						num2 = value.MinForce;
						num3 = value.MaxForce;
						num4 = value.ForcePerPeg;
						if (((Vector3)(ref value.StartupOffset)).sqrMagnitude > 0.0001f)
						{
							val3 = value.StartupOffset;
						}
						<go>5__2 = Object.Instantiate<GameObject>(value.ShotPrefab);
						((Object)<go>5__2).name = "ClientProjectile";
						StripGameLogicComponents(<go>5__2);
					}
					else
					{
						<go>5__2 = new GameObject("ClientProjectile");
						SpriteRenderer val4 = <go>5__2.AddComponent<SpriteRenderer>();
						if (!TryCopyOrbSprite(val4, clientAttackProjectile._orbName) && !TryCopyFromBallRenderer(val4))
						{
							val4.sprite = CreateCircleSprite();
							val4.color = Color.yellow;
						}
						((Renderer)val4).sortingOrder = 150;
					}
					float num5 = Mathf.Clamp((float)clientAttackProjectile._numPegsHit * num4, num2, num3);
					float num6 = ((num3 > 0f) ? (Mathf.Abs(num5) / num3) : 0f);
					<go>5__2.transform.localScale = Vector3.Lerp(val, val2, num6);
					<startPos>5__3 = new Vector3(playerGroundPos.x + val3.x, playerGroundPos.y + val3.y, playerGroundPos.z);
					<go>5__2.transform.position = <startPos>5__3;
					Vector3 val5 = ((Component)targetEnemy).transform.position;
					Collider2D componentInChildren = ((Component)targetEnemy).GetComponentInChildren<Collider2D>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						Bounds bounds = componentInChildren.bounds;
						val5 = ((Bounds)(ref bounds)).center;
					}
					<endPos>5__4 = new Vector3(val5.x, val5.y, <startPos>5__3.z);
					Vector3 val6 = <endPos>5__4 - <startPos>5__3;
					Vector3 normalized = ((Vector3)(ref val6)).normalized;
					if (((Vector3)(ref normalized)).sqrMagnitude > 0.001f)
					{
						<go>5__2.transform.right = normalized;
					}
					float num7 = Vector3.Distance(<startPos>5__3, <endPos>5__4);
					float num8 = Mathf.Max(num5 * 0.02f, 5f);
					<duration>5__5 = Mathf.Clamp(num7 / num8, 0.15f, 0.6f);
					<elapsed>5__6 = 0f;
					break;
				}
				case 1:
					<>1__state = -1;
					break;
				}
				if (<elapsed>5__6 < <duration>5__5 && (Object)(object)targetEnemy != (Object)null)
				{
					<elapsed>5__6 += Time.deltaTime;
					float num9 = Mathf.Clamp01(<elapsed>5__6 / <duration>5__5);
					<go>5__2.transform.position = Vector3.Lerp(<startPos>5__3, <endPos>5__4, num9);
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				AttackManager.OnFireComplete?.Invoke();
				Object.Destroy((Object)(object)<go>5__2);
				clientAttackProjectile.IsAttacking = false;
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <WatchdogTimeout>d__24 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public ClientAttackProjectile <>4__this;

			private float <waited>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_0084: Unknown result type (might be due to invalid IL or missing references)
				//IL_008e: Expected O, but got Unknown
				//IL_008e: Unknown result type (might be due to invalid IL or missing references)
				//IL_0098: Expected O, but got Unknown
				int num = <>1__state;
				ClientAttackProjectile clientAttackProjectile = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<waited>5__2 = 0f;
					break;
				case 1:
					<>1__state = -1;
					break;
				}
				if (clientAttackProjectile._waitingForFire && <waited>5__2 < 1.5f)
				{
					<waited>5__2 += Time.deltaTime;
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (clientAttackProjectile._waitingForFire)
				{
					clientAttackProjectile._waitingForFire = false;
					PeglinBattleAnimationController.OnFirePoint = (FirePoint)Delegate.Remove((Delegate?)(object)PeglinBattleAnimationController.OnFirePoint, (Delegate?)new FirePoint(clientAttackProjectile.OnFirePoint));
					clientAttackProjectile.IsAttacking = false;
				}
				return false;
			}

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

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

		private string _targetEnemyGuid;

		private int _numPegsHit;

		private bool _isCrit;

		private string _orbName;

		private bool _waitingForFire;

		private const float DefaultMinForce = 100f;

		private const float DefaultMaxForce = 900f;

		private const float DefaultForcePerPeg = 50f;

		private static readonly Vector3 DefaultMinSize = new Vector3(0.2f, 0.2f, 1f);

		private static readonly Vector3 DefaultMaxSize = new Vector3(0.6f, 0.6f, 1f);

		private static readonly Vector3 DefaultStartupOffset = new Vector3(0f, 1.2f, 0f);

		private static readonly Dictionary<string, ShotParams?> _shotCache = new Dictionary<string, ShotParams?>();

		public static ClientAttackProjectile Instance { get; private set; }

		public bool IsAttacking { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void SetupAttack(string targetEnemyGuid, int numPegsHit = 0, bool isCrit = false, string orbName = null)
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Expected O, but got Unknown
			_targetEnemyGuid = targetEnemyGuid;
			_numPegsHit = numPegsHit;
			_isCrit = isCrit;
			_orbName = orbName;
			_waitingForFire = true;
			IsAttacking = true;
			PeglinBattleAnimationController.OnFirePoint = (FirePoint)Delegate.Combine((Delegate?)(object)PeglinBattleAnimationController.OnFirePoint, (Delegate?)new FirePoint(OnFirePoint));
			((MonoBehaviour)this).StartCoroutine(WatchdogTimeout());
		}

		[IteratorStateMachine(typeof(<WatchdogTimeout>d__24))]
		private IEnumerator WatchdogTimeout()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WatchdogTimeout>d__24(0)
			{
				<>4__this = this
			};
		}

		private void OnFirePoint()
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0026: Expected O, but got Unknown
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Expected O, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			if (!_waitingForFire)
			{
				return;
			}
			_waitingForFire = false;
			PeglinBattleAnimationController.OnFirePoint = (FirePoint)Delegate.Remove((Delegate?)(object)PeglinBattleAnimationController.OnFirePoint, (Delegate?)new FirePoint(OnFirePoint));
			if (string.IsNullOrEmpty(_targetEnemyGuid))
			{
				IsAttacking = false;
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			EnemyIdentifier instance;
			Enemy val = ((services != null && services.TryResolve<EnemyIdentifier>(out instance)) ? instance : null)?.Find(_targetEnemyGuid);
			if ((Object)(object)val == (Object)null)
			{
				IsAttacking = false;
				return;
			}
			BattleController val2 = Object.FindObjectOfType<BattleController>();
			if ((Object)(object)val2 == (Object)null)
			{
				IsAttacking = false;
				return;
			}
			object? obj = AccessTools.Field(typeof(BattleController), "_playerTransform")?.GetValue(val2);
			Transform val3 = (Transform)((obj is Transform) ? obj : null);
			if ((Object)(object)val3 == (Object)null)
			{
				IsAttacking = false;
			}
			else
			{
				((MonoBehaviour)this).StartCoroutine(LaunchProjectile(val3.position, val));
			}
		}

		[IteratorStateMachine(typeof(<LaunchProjectile>d__26))]
		private IEnumerator LaunchProjectile(Vector3 playerGroundPos, Enemy targetEnemy)
		{
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <LaunchProjectile>d__26(0)
			{
				<>4__this = this,
				playerGroundPos = playerGroundPos,
				targetEnemy = targetEnemy
			};
		}

		private static void StripGameLogicComponents(GameObject go)
		{
			ShotBehavior[] componentsInChildren = go.GetComponentsInChildren<ShotBehavior>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren[i]);
			}
			MonoBehaviour[] componentsInChildren2 = go.GetComponentsInChildren<MonoBehaviour>(true);
			foreach (MonoBehaviour val in componentsInChildren2)
			{
				if ((((object)val)?.GetType().Namespace ?? string.Empty).StartsWith("Battle.Attacks"))
				{
					Object.Destroy((Object)(object)val);
				}
			}
			Collider2D[] componentsInChildren3 = go.GetComponentsInChildren<Collider2D>(true);
			for (int i = 0; i < componentsInChildren3.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren3[i]);
			}
			Rigidbody2D[] componentsInChildren4 = go.GetComponentsInChildren<Rigidbody2D>(true);
			for (int i = 0; i < componentsInChildren4.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren4[i]);
			}
			AudioSource[] componentsInChildren5 = go.GetComponentsInChildren<AudioSource>(true);
			for (int i = 0; i < componentsInChildren5.Length; i++)
			{
				Object.Destroy((Object)(object)componentsInChildren5[i]);
			}
			SpriteRenderer[] componentsInChildren6 = go.GetComponentsInChildren<SpriteRenderer>(true);
			foreach (SpriteRenderer val2 in componentsInChildren6)
			{
				((Renderer)val2).enabled = true;
				if (((Renderer)val2).sortingOrder < 150)
				{
					((Renderer)val2).sortingOrder = 150;
				}
			}
		}

		private static ShotParams? TryGetShotParams(string orbName, bool isCrit)
		{
			//IL_01c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ca: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0201: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0238: Unknown result type (might be due to invalid IL or missing references)
			//IL_0229: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_0306: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(orbName))
			{
				return null;
			}
			string key = orbName.Replace("(Clone)", string.Empty).Trim() + (isCrit ? "#crit" : "#normal");
			if (_shotCache.TryGetValue(key, out var value))
			{
				return value;
			}
			ShotParams? shotParams = null;
			try
			{
				GameObject val = FindOrbPrefab(orbName);
				if ((Object)(object)val == (Object)null)
				{
					_shotCache[key] = null;
					return null;
				}
				ProjectileAttack component = val.GetComponent<ProjectileAttack>();
				if ((Object)(object)component == (Object)null)
				{
					_shotCache[key] = null;
					return null;
				}
				string text = (isCrit ? "_criticalShotPrefab" : "_shotPrefab");
				object? obj = AccessTools.Field(typeof(ProjectileAttack), text)?.GetValue(component);
				GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
				if ((Object)(object)val2 == (Object)null && isCrit)
				{
					object? obj2 = AccessTools.Field(typeof(ProjectileAttack), "_shotPrefab")?.GetValue(component);
					val2 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				}
				if ((Object)(object)val2 == (Object)null)
				{
					_shotCache[key] = null;
					return null;
				}
				ShotBehavior component2 = val2.GetComponent<ShotBehavior>();
				if ((Object)(object)component2 == (Object)null)
				{
					_shotCache[key] = null;
					return null;
				}
				Vector3 minSize = (Vector3)(AccessTools.Field(typeof(ShotBehavior), "_minSize")?.GetValue(component2) ?? ((object)DefaultMinSize));
				Vector3 maxSize = (Vector3)(AccessTools.Field(typeof(ShotBehavior), "_maxSize")?.GetValue(component2) ?? ((object)DefaultMaxSize));
				Vector3 startupOffset = (Vector3)(AccessTools.Field(typeof(ShotBehavior), "_startupOffset")?.GetValue(component2) ?? ((object)DefaultStartupOffset));
				float minForce = (float)(AccessTools.Field(typeof(ShotBehavior), "_minForce")?.GetValue(component2) ?? ((object)100f));
				float maxForce = (float)(AccessTools.Field(typeof(ShotBehavior), "_maxForce")?.GetValue(component2) ?? ((object)900f));
				float forcePerPeg = (float)(AccessTools.Field(typeof(ShotBehavior), "_forcePerPeg")?.GetValue(component2) ?? ((object)50f));
				ShotParams value2 = default(ShotParams);
				value2.ShotPrefab = val2;
				value2.MinSize = minSize;
				value2.MaxSize = maxSize;
				value2.StartupOffset = startupOffset;
				value2.MinForce = minForce;
				value2.MaxForce = maxForce;
				value2.ForcePerPeg = forcePerPeg;
				shotParams = value2;
			}
			catch
			{
				shotParams = null;
			}
			_shotCache[key] = shotParams;
			return shotParams;
		}

		private static GameObject FindOrbPrefab(string orbName)
		{
			string text = orbName.Replace("(Clone)", string.Empty).Trim();
			AssetLoading instance = AssetLoading.Instance;
			GameObject val = ((instance != null) ? instance.GetOrbPrefab(text) : null);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
			DeckManager val2 = ((array.Length != 0) ? array[0] : null);
			if (val2?.battleDeck != null)
			{
				foreach (GameObject item in val2.battleDeck)
				{
					if ((Object)(object)item != (Object)null && ((Object)item).name.Replace("(Clone)", string.Empty).Trim() == text)
					{
						return item;
					}
				}
			}
			return null;
		}

		private static bool TryCopyOrbSprite(SpriteRenderer sr, string orbName)
		{
			if (string.IsNullOrEmpty(orbName))
			{
				return false;
			}
			GameObject val = FindOrbPrefab(orbName);
			if ((Object)(object)val == (Object)null)
			{
				return false;
			}
			SpriteRenderer componentInChildren = val.GetComponentInChildren<SpriteRenderer>(true);
			if ((Object)(object)((componentInChildren != null) ? componentInChildren.sprite : null) == (Object)null)
			{
				return false;
			}
			sr.sprite = componentInChildren.sprite;
			if ((Object)(object)((Renderer)componentInChildren).sharedMaterial != (Object)null)
			{
				((Renderer)sr).material = ((Renderer)componentInChildren).sharedMaterial;
			}
			((Renderer)sr).sortingLayerID = ((Renderer)componentInChildren).sortingLayerID;
			return true;
		}

		private static bool TryCopyFromBallRenderer(SpriteRenderer sr)
		{
			ClientBallRenderer instance = ClientBallRenderer.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				return false;
			}
			object? obj = AccessTools.Field(typeof(ClientBallRenderer), "_ballRenderer")?.GetValue(instance);
			SpriteRenderer val = (SpriteRenderer)((obj is SpriteRenderer) ? obj : null);
			if ((Object)(object)((val != null) ? val.sprite : null) == (Object)null)
			{
				return false;
			}
			sr.sprite = val.sprite;
			if ((Object)(object)((Renderer)val).sharedMaterial != (Object)null)
			{
				((Renderer)sr).material = ((Renderer)val).sharedMaterial;
			}
			((Renderer)sr).sortingLayerID = ((Renderer)val).sortingLayerID;
			return true;
		}

		private static Sprite CreateCircleSprite()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			int num = 32;
			Texture2D val = new Texture2D(num, num, (TextureFormat)4, false);
			float num2 = (float)num / 2f;
			float num3 = num2 - 1f;
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num; j++)
				{
					val.SetPixel(j, i, (Vector2.Distance(new Vector2((float)j, (float)i), new Vector2(num2, num2)) <= num3) ? Color.white : Color.clear);
				}
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, (float)num, (float)num), new Vector2(0.5f, 0.5f), (float)num);
		}
	}
	public class ClientBallRenderer : MonoBehaviour
	{
		private struct HistoryEntry
		{
			public float Timestamp;

			public Vector2 Pos;

			public float ScaleX;

			public float ScaleY;
		}

		private class FlightVisual
		{
			public GameObject GameObject;

			public SpriteRenderer Renderer;

			public TrailRenderer Trail;

			public string OrbName;

			public readonly List<HistoryEntry> History = new List<HistoryEntry>();

			public bool Departing;
		}

		private GameObject _aimingBall;

		private SpriteRenderer _aimingRenderer;

		private Vector3 _spawnPos;

		private Vector2 _aimDirection;

		private bool _isAiming;

		private string _currentOrbName;

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

		private float _currentRenderDelay = 0.2f;

		private float _currentHistoryRetention = 0.5f;

		private const float HistoryGrace = 0.3f;

		private float _nextRttPollAt;

		private const float RttPollInterval = 1f;

		public static ClientBallRenderer Instance { get; private set; }

		public string CurrentOrbName => _currentOrbName;

		private void Awake()
		{
			Instance = this;
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void OnOrbDrawn(string orbName)
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0084: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
			EnsureAimingBall();
			_currentOrbName = orbName?.Replace("(Clone)", string.Empty).Trim();
			ApplyOrbSprite(_aimingRenderer, _aimingBall, orbName, 0.8f, wantTrail: false);
			BattleController val = Object.FindObjectOfType<BattleController>();
			Transform val2 = null;
			if ((Object)(object)val != (Object)null)
			{
				object? obj = AccessTools.Field(typeof(BattleController), "_playerTransform")?.GetValue(val);
				val2 = (Transform)((obj is Transform) ? obj : null);
				if ((Object)(object)val2 != (Object)null)
				{
					_spawnPos = val2.position;
					_aimingBall.transform.position = new Vector3(_spawnPos.x, _spawnPos.y, -1f);
				}
			}
			_isAiming = true;
			_aimingBall.SetActive(true);
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)($"[ClientBallRenderer] OnOrbDrawn '{orbName}' playerTransform={(Object)(object)val2 != (Object)null} " + $"pos=({_aimingBall.transform.position.x:F1},{_aimingBall.transform.position.y:F1})"));
			}
		}

		public void UpdateAimDirection(float aimX, float aimY)
		{
			//IL_0003: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			Vector2 val = new Vector2(aimX, aimY);
			_aimDirection = ((Vector2)(ref val)).normalized;
		}

		public void UpdateSpawnPosition(float spawnX, float spawnY)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			_spawnPos = new Vector3(spawnX, spawnY, 0f);
		}

		public void OnShotFired(float aimX, float aimY, string orbName = null)
		{
			GameObject aimingBall = _aimingBall;
			if (aimingBall != null)
			{
				aimingBall.SetActive(false);
			}
			_isAiming = false;
			foreach (FlightVisual value in _flightBalls.Values)
			{
				if ((Object)(object)value?.GameObject != (Object)null)
				{
					Object.Destroy((Object)(object)value.GameObject);
				}
			}
			_flightBalls.Clear();
		}

		public void ApplyBallSnapshot(BallStateSnapshot snap)
		{
			//IL_0171: 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)
			if (snap == null)
			{
				return;
			}
			if (snap.Balls != null && snap.Balls.Count > 0 && (Object)(object)_aimingBall != (Object)null && _aimingBall.activeSelf)
			{
				_aimingBall.SetActive(false);
				_isAiming = false;
			}
			float time = Time.time;
			HashSet<string> hashSet = new HashSet<string>();
			if (snap.Balls != null)
			{
				foreach (BallEntry ball in snap.Balls)
				{
					if (string.IsNullOrEmpty(ball.Guid))
					{
						continue;
					}
					hashSet.Add(ball.Guid);
					if (!_flightBalls.TryGetValue(ball.Guid, out var value))
					{
						value = SpawnFlightVisual(ball);
						_flightBalls[ball.Guid] = value;
					}
					else if (value.OrbName != ball.OrbName && !string.IsNullOrEmpty(ball.OrbName))
					{
						ApplyOrbSprite(value.Renderer, value.GameObject, ball.OrbName, 1f, wantTrail: true, value.Trail);
						value.OrbName = ball.OrbName;
					}
					if (value.Departing)
					{
						value.Departing = false;
						value.History.Clear();
						TrailRenderer trail = value.Trail;
						if (trail != null)
						{
							trail.Clear();
						}
					}
					value.History.Add(new HistoryEntry
					{
						Timestamp = time,
						Pos = new Vector2(ball.PosX, ball.PosY),
						ScaleX = ball.ScaleX,
						ScaleY = ball.ScaleY
					});
				}
			}
			foreach (KeyValuePair<string, FlightVisual> flightBall in _flightBalls)
			{
				if (!hashSet.Contains(flightBall.Key))
				{
					flightBall.Value.Departing = true;
				}
			}
		}

		private FlightVisual SpawnFlightVisual(BallEntry entry)
		{
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Expected O, but got Unknown
			//IL_008a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = new GameObject("ClientBall_" + entry.Guid)
			{
				hideFlags = (HideFlags)61
			};
			Object.DontDestroyOnLoad((Object)(object)val);
			SpriteRenderer val2 = val.AddComponent<SpriteRenderer>();
			((Renderer)val2).sortingOrder = 100;
			FlightVisual obj = new FlightVisual
			{
				GameObject = val,
				Renderer = val2,
				OrbName = entry.OrbName
			};
			ApplyOrbSprite(val2, val, entry.OrbName, 1f, wantTrail: true);
			obj.Trail = val.GetComponent<TrailRenderer>();
			val.transform.position = new Vector3(entry.PosX, entry.PosY, -1f);
			val.transform.localScale = new Vector3(entry.ScaleX, entry.ScaleY, 1f);
			TrailRenderer trail = obj.Trail;
			if (trail != null)
			{
				trail.Clear();
				return obj;
			}
			return obj;
		}

		private void ApplyOrbSprite(SpriteRenderer target, GameObject targetGO, string orbName, float scaleFactor, bool wantTrail, TrailRenderer existingTrail = null)
		{
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)target == (Object)null)
			{
				return;
			}
			try
			{
				GameObject val = FindOrbPrefab(orbName?.Replace("(Clone)", string.Empty).Trim());
				if ((Object)(object)val != (Object)null)
				{
					SpriteRenderer componentInChildren = val.GetComponentInChildren<SpriteRenderer>();
					if ((Object)(object)((componentInChildren != null) ? componentInChildren.sprite : null) != (Object)null)
					{
						target.sprite = componentInChildren.sprite;
						if ((Object)(object)((Renderer)componentInChildren).sharedMaterial != (Object)null)
						{
							((Renderer)target).material = ((Renderer)componentInChildren).sharedMaterial;
						}
						((Renderer)target).sortingLayerID = ((Renderer)componentInChildren).sortingLayerID;
						((Renderer)target).sortingOrder = 100;
						targetGO.transform.localScale = val.transform.localScale * scaleFactor;
					}
					if (wantTrail)
					{
						TrailRenderer componentInChildren2 = val.GetComponentInChildren<TrailRenderer>();
						CopyTrailSettings(existingTrail ?? targetGO.GetComponent<TrailRenderer>() ?? targetGO.AddComponent<TrailRenderer>(), componentInChildren2);
					}
				}
				else
				{
					target.sprite = CreateCircleSprite();
					targetGO.transform.localScale = Vector3.one * 0.5f;
					SpriteRenderer val2 = Object.FindObjectOfType<SpriteRenderer>();
					if ((Object)(object)((val2 != null) ? ((Renderer)val2).sharedMaterial : null) != (Object)null)
					{
						((Renderer)target).material = ((Renderer)val2).sharedMaterial;
						((Renderer)target).sortingLayerID = ((Renderer)val2).sortingLayerID;
					}
				}
			}
			catch
			{
			}
		}

		private static GameObject FindOrbPrefab(string cleanName)
		{
			if (string.IsNullOrEmpty(cleanName))
			{
				return null;
			}
			AssetLoading instance = AssetLoading.Instance;
			GameObject val = ((instance != null) ? instance.GetOrbPrefab(cleanName) : null);
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			if (cleanName == "NavigationOrb")
			{
				BattleController val2 = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val2 != (Object)null)
				{
					object? obj = AccessTools.Field(typeof(BattleController), "_navigationOrb")?.GetValue(val2);
					val = (GameObject)((obj is GameObject) ? obj : null);
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
			DeckManager val3 = ((array.Length != 0) ? array[0] : null);
			if (val3?.battleDeck != null)
			{
				foreach (GameObject item in val3.battleDeck)
				{
					if ((Object)(object)item != (Object)null && ((Object)item).name.Replace("(Clone)", string.Empty).Trim() == cleanName)
					{
						return item;
					}
				}
			}
			return null;
		}

		private static void CopyTrailSettings(TrailRenderer dst, TrailRenderer src)
		{
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_0089: Unknown result type (might be due to invalid IL or missing references)
			//IL_0095: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)dst == (Object)null)
			{
				return;
			}
			if ((Object)(object)src == (Object)null)
			{
				dst.emitting = true;
				return;
			}
			dst.time = src.time;
			dst.minVertexDistance = src.minVertexDistance;
			dst.widthCurve = src.widthCurve;
			dst.widthMultiplier = src.widthMultiplier;
			dst.colorGradient = src.colorGradient;
			dst.startColor = src.startColor;
			dst.endColor = src.endColor;
			dst.startWidth = src.startWidth;
			dst.endWidth = src.endWidth;
			dst.textureMode = src.textureMode;
			dst.alignment = src.alignment;
			dst.numCornerVertices = src.numCornerVertices;
			dst.numCapVertices = src.numCapVertices;
			((Renderer)dst).shadowCastingMode = ((Renderer)src).shadowCastingMode;
			((Renderer)dst).receiveShadows = ((Renderer)src).receiveShadows;
			((Renderer)dst).sortingLayerID = ((Renderer)src).sortingLayerID;
			((Renderer)dst).sortingOrder = ((Renderer)src).sortingOrder + 1;
			dst.autodestruct = false;
			dst.emitting = true;
			if ((Object)(object)((Renderer)src).sharedMaterial != (Object)null)
			{
				((Renderer)dst).sharedMaterial = ((Renderer)src).sharedMaterial;
			}
		}

		private void Update()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0317: Unknown result type (might be due to invalid IL or missing references)
			//IL_0323: Unknown result type (might be due to invalid IL or missing references)
			//IL_0332: 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)
			//IL_02b5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c8: Unknown result type (might be due to invalid IL or missing references)
			if (_isAiming && (Object)(object)_aimingBall != (Object)null && _aimingBall.activeSelf)
			{
				_aimingBall.transform.position = new Vector3(_spawnPos.x, _spawnPos.y, -0.5f);
				if (((Vector2)(ref _aimDirection)).sqrMagnitude > 0.01f)
				{
					float num = Mathf.Atan2(_aimDirection.y, _aimDirection.x) * 57.29578f;
					_aimingBall.transform.rotation = Quaternion.Euler(0f, 0f, num);
				}
			}
			if (_flightBalls.Count == 0)
			{
				return;
			}
			UpdateRenderDelayFromRtt();
			float num2 = Time.time - _currentRenderDelay;
			float num3 = num2 - _currentHistoryRetention;
			List<string> list = null;
			foreach (KeyValuePair<string, FlightVisual> flightBall in _flightBalls)
			{
				FlightVisual value = flightBall.Value;
				if ((Object)(object)value?.GameObject == (Object)null)
				{
					continue;
				}
				while (value.History.Count > 1 && value.History[0].Timestamp < num3 && value.History[1].Timestamp < num3)
				{
					value.History.RemoveAt(0);
				}
				if (value.History.Count == 0)
				{
					if (value.Departing)
					{
						(list ?? (list = new List<string>())).Add(flightBall.Key);
					}
					continue;
				}
				HistoryEntry historyEntry = value.History[value.History.Count - 1];
				HistoryEntry historyEntry2;
				if (num2 <= value.History[0].Timestamp)
				{
					historyEntry2 = value.History[0];
				}
				else if (num2 >= historyEntry.Timestamp)
				{
					historyEntry2 = historyEntry;
					if (value.Departing && num2 > historyEntry.Timestamp + 0.05f)
					{
						(list ?? (list = new List<string>())).Add(flightBall.Key);
					}
				}
				else
				{
					int i;
					for (i = 1; i < value.History.Count && value.History[i].Timestamp < num2; i++)
					{
					}
					HistoryEntry historyEntry3 = value.History[i - 1];
					HistoryEntry historyEntry4 = value.History[i];
					float num4 = historyEntry4.Timestamp - historyEntry3.Timestamp;
					float num5 = ((num4 > 1E-05f) ? ((num2 - historyEntry3.Timestamp) / num4) : 0f);
					HistoryEntry historyEntry5 = default(HistoryEntry);
					historyEntry5.Pos = Vector2.Lerp(historyEntry3.Pos, historyEntry4.Pos, num5);
					historyEntry5.ScaleX = Mathf.Lerp(historyEntry3.ScaleX, historyEntry4.ScaleX, num5);
					historyEntry5.ScaleY = Mathf.Lerp(historyEntry3.ScaleY, historyEntry4.ScaleY, num5);
					historyEntry2 = historyEntry5;
				}
				value.GameObject.transform.position = new Vector3(historyEntry2.Pos.x, historyEntry2.Pos.y, -1f);
				if (historyEntry2.ScaleX > 0f && historyEntry2.ScaleY > 0f)
				{
					value.GameObject.transform.localScale = new Vector3(historyEntry2.ScaleX, historyEntry2.ScaleY, 1f);
				}
			}
			if (list == null)
			{
				return;
			}
			foreach (string item in list)
			{
				if (_flightBalls.TryGetValue(item, out var value2) && (Object)(object)value2.GameObject != (Object)null)
				{
					Object.Destroy((Object)(object)value2.GameObject);
				}
				_flightBalls.Remove(item);
			}
		}

		private void UpdateRenderDelayFromRtt()
		{
			float time = Time.time;
			if (time < _nextRttPollAt)
			{
				return;
			}
			_nextRttPollAt = time + 1f;
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<IRttProvider>(out var instance))
			{
				return;
			}
			int currentRttMs = instance.CurrentRttMs;
			if (currentRttMs <= 0)
			{
				return;
			}
			float num = ((currentRttMs <= 100) ? 0.2f : ((currentRttMs > 200) ? 1f : 0.5f));
			if (!(Mathf.Abs(num - _currentRenderDelay) < 0.001f))
			{
				_currentRenderDelay = num;
				_currentHistoryRetention = num + 0.3f;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[ClientBallRenderer] RTT={currentRttMs}ms → renderDelay={num:F2}s, retention={_currentHistoryRetention:F2}s");
				}
			}
		}

		private void EnsureAimingBall()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Expected O, but got Unknown
			//IL_00a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)_aimingBall != (Object)null)
			{
				return;
			}
			_aimingBall = new GameObject("ClientBall_Aiming")
			{
				hideFlags = (HideFlags)61
			};
			Object.DontDestroyOnLoad((Object)(object)_aimingBall);
			_aimingRenderer = _aimingBall.AddComponent<SpriteRenderer>();
			((Renderer)_aimingRenderer).sortingOrder = 100;
			try
			{
				SpriteRenderer val = Object.FindObjectOfType<SpriteRenderer>();
				if ((Object)(object)((val != null) ? ((Renderer)val).sharedMaterial : null) != (Object)null)
				{
					((Renderer)_aimingRenderer).material = ((Renderer)val).sharedMaterial;
					((Renderer)_aimingRenderer).sortingLayerID = ((Renderer)val).sortingLayerID;
				}
			}
			catch
			{
			}
			_aimingRenderer.sprite = CreateCircleSprite();
			_aimingRenderer.color = Color.white;
			_aimingBall.transform.localScale = Vector3.one * 0.5f;
			_aimingBall.SetActive(false);
		}

		private static Sprite CreateCircleSprite()
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Expected O, but got Unknown
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			int num = 32;
			Texture2D val = new Texture2D(num, num, (TextureFormat)4, false);
			float num2 = (float)num / 2f;
			float num3 = num2 - 1f;
			for (int i = 0; i < num; i++)
			{
				for (int j = 0; j < num; j++)
				{
					float num4 = Vector2.Distance(new Vector2((float)j, (float)i), new Vector2(num2, num2));
					val.SetPixel(j, i, (num4 <= num3) ? Color.white : Color.clear);
				}
			}
			val.Apply();
			return Sprite.Create(val, new Rect(0f, 0f, (float)num, (float)num), new Vector2(0.5f, 0.5f), (float)num);
		}
	}
	public class CoopPlayerState
	{
		public int SlotIndex { get; set; }

		public string PlayerName { get; set; }

		public int ChosenClass { get; set; }

		public float CurrentHealth { get; set; }

		public float MaxHealth { get; set; }

		public int Gold { get; set; }

		public List<SerializedOrb> CompleteDeck { get; set; } = new List<SerializedOrb>();


		public List<SerializedOrb> BattleDeck { get; set; } = new List<SerializedOrb>();


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


		public string CurrentOrb { get; set; }

		public int CurrentOrbLevel { get; set; }

		public List<SerializedRelic> OwnedRelics { get; set; } = new List<SerializedRelic>();


		public Dictionary<int, int> RelicCountdowns { get; set; } = new Dictionary<int, int>();


		public Dictionary<int, int> RelicUsesPerShot { get; set; } = new Dictionary<int, int>();


		public Dictionary<int, int> RelicUsesPerBattle { get; set; } = new Dictionary<int, int>();


		public Dictionary<int, int> RelicUsesPerRun { get; set; } = new Dictionary<int, int>();


		public List<SerializedStatusEffect> StatusEffects { get; set; } = new List<SerializedStatusEffect>();


		public bool HasShotThisRound { get; set; }

		public long DamageDealt { get; set; }

		public long DamageTaken { get; set; }

		public bool IsInitialized { get; set; }
	}
	public class SerializedOrb
	{
		public string PrefabName { get; set; }

		public string Guid { get; set; }

		public int Level { get; set; }

		public int RemainingPersistence { get; set; } = -1;

	}
	public class SerializedRelic
	{
		public int Effect { get; set; }

		public string LocKey { get; set; }

		public int Rarity { get; set; }
	}
	public class SerializedStatusEffect
	{
		public int EffectType { get; set; }

		public int Intensity { get; set; }
	}
	public class CoopStateManager
	{
		private readonly ManualLogSource _log;

		private readonly PlayerRegistry _playerRegistry;

		private OrbIdentifier _orbId;

		private WeakReference _lastRebuildDim;

		private int _lastRebuildDisplayCount = -1;

		private string _lastRebuildSignature;

		private static readonly int[] BoardRelicEffects = new int[16]
		{
			64, 63, 98, 104, 36, 17, 18, 69, 82, 37,
			20, 21, 81, 140, 105, 101
		};

		private readonly List<RelicEffect> _navPhaseMergedEffects = new List<RelicEffect>();

		public Dictionary<int, CoopPlayerState> PlayerStates { get; } = new Dictionary<int, CoopPlayerState>();


		public int ActivePlayerSlot { get; internal set; } = -1;


		public int TotalPlayerCount => PlayerStates.Count;

		public static bool SuppressStatusEffectUI { get; set; }

		public static bool IsLoadingPlayerGold { get; private set; }

		public bool AnyPlayerDead => PlayerStates.Values.Any((CoopPlayerState s) => s.IsInitialized && s.CurrentHealth <= 0f);

		public bool AllPlayersDead => PlayerStates.Values.Where((CoopPlayerState s) => s.IsInitialized).All((CoopPlayerState s) => s.CurrentHealth <= 0f);

		public CoopStateManager(ManualLogSource log, PlayerRegistry playerRegistry)
		{
			_log = log;
			_playerRegistry = playerRegistry;
		}

		public void SetOrbIdentifier(OrbIdentifier orbId)
		{
			_orbId = orbId;
		}

		public void InitializePlayer(int slotIndex, int chosenClass, string playerName)
		{
			CoopPlayerState value = new CoopPlayerState
			{
				SlotIndex = slotIndex,
				PlayerName = playerName,
				ChosenClass = chosenClass,
				CurrentHealth = 0f,
				MaxHealth = 0f,
				Gold = 0,
				IsInitialized = false
			};
			PlayerStates[slotIndex] = value;
			_log.LogInfo((object)$"[CoopState] Initialized player slot {slotIndex}: {playerName}, class={chosenClass}");
		}

		public void CaptureInitialState(int slotIndex)
		{
			if (PlayerStates.TryGetValue(slotIndex, out var value))
			{
				SaveDeckState(value);
				SaveRelicState(value);
				SaveHealthState(value);
				SaveGoldState(value);
				SaveStatusEffects(value);
				value.IsInitialized = true;
				_log.LogInfo((object)($"[CoopState] Captured initial state for slot {slotIndex}: " + $"hp={value.CurrentHealth}/{value.MaxHealth}, deck={value.CompleteDeck.Count}, " + $"relics={value.OwnedRelics.Count}, statusEffects={value.StatusEffects.Count}"));
			}
		}

		public void SaveActivePlayerState()
		{
			if (ActivePlayerSlot >= 0 && PlayerStates.TryGetValue(ActivePlayerSlot, out var value))
			{
				SaveDeckState(value);
				SaveRelicState(value);
				SaveHealthState(value);
				SaveGoldState(value);
				SaveStatusEffects(value);
				_log.LogInfo((object)($"[CoopState] Saved slot {ActivePlayerSlot}: " + $"hp={value.CurrentHealth}/{value.MaxHealth}, deck={value.CompleteDeck.Count}, " + $"relics={value.OwnedRelics.Count}, statusEffects={value.StatusEffects.Count}"));
			}
		}

		public void LoadPlayerState(int slotIndex)
		{
			if (PlayerStates.TryGetValue(slotIndex, out var value))
			{
				LoadDeckState(value);
				LoadRelicState(value);
				LoadHealthState(value);
				LoadGoldState(value);
				LoadStatusEffects(value);
				ActivePlayerSlot = slotIndex;
				SpecialSlotControllerPatches.ReconfigurePortalsForActiveRelics(_log);
				_log.LogInfo((object)($"[CoopState] Loaded slot {slotIndex}: " + $"hp={value.CurrentHealth}/{value.MaxHealth}, deck={value.CompleteDeck.Count}, " + $"relics={value.OwnedRelics.Count}, statusEffects={value.StatusEffects.Count}"));
			}
		}

		public void SwapToPlayer(int slotIndex)
		{
			if (slotIndex != ActivePlayerSlot)
			{
				if (ActivePlayerSlot >= 0)
				{
					SaveActivePlayerState();
				}
				LoadPlayerState(slotIndex);
			}
		}

		public void SendTreasureRelicChoicesToClients()
		{
			//IL_0149: Unknown result type (might be due to invalid IL or missing references)
			//IL_0153: Expected I4, but got Unknown
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Expected I4, but got Unknown
			if (TotalPlayerCount < 2)
			{
				return;
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IGameEventRegistry>(out var instance))
				{
					return;
				}
				RelicManager val = Resources.FindObjectsOfTypeAll<RelicManager>()?.FirstOrDefault();
				if ((Object)(object)val == (Object)null)
				{
					_log.LogWarning((object)"[CoopState] TreasureRelics: RelicManager null");
					return;
				}
				CoopRewardState.HostRelicSelectionActive = true;
				CoopRewardState.HostHasChosenRelic = true;
				CoopRewardState.ClientRelicChoicesReceived.Clear();
				int num = 0;
				foreach (KeyValuePair<int, CoopPlayerState> playerState in PlayerStates)
				{
					if (playerState.Key == 0)
					{
						continue;
					}
					num++;
					Relic[] multipleRelicsOffOfQueue = val.GetMultipleRelicsOffOfQueue(3, (RelicRarity)1, false);
					List<RelicEntry> list = new List<RelicEntry>();
					Relic[] array = multipleRelicsOffOfQueue;
					foreach (Relic val2 in array)
					{
						string effectName = val2.locKey ?? "Unknown";
						try
						{
							string translation = LocalizationManager.GetTranslation("Relics/" + val2.locKey, true, 0, true, false, (GameObject)null, (string)null, true);
							if (!string.IsNullOrEmpty(translation))
							{
								effectName = translation;
							}
						}
						catch
						{
						}
						if (val2.locKey == null)
						{
							_ = string.Empty;
						}
						try
						{
							string translation2 = LocalizationManager.GetTranslation("Relics/" + val2.locKey + "_desc", true, 0, true, false, (GameObject)null, (string)null, true);
							string.IsNullOrEmpty(translation2);
						}
						catch
						{
						}
						list.Add(new RelicEntry
						{
							Effect = (int)val2.effect,
							EffectName = effectName,
							LocKey = val2.locKey,
							Rarity = (int)val2.globalRarity,
							IsEnabled = true
						});
					}
					instance.Dispatch(new RelicChoicesEvent
					{
						TargetSlotIndex = playerState.Key,
						Choices = list
					});
					_log.LogInfo((object)$"[CoopState] Treasure: sent {list.Count} relic choices to slot {playerState.Key}");
				}
				CoopRewardState.TotalClientsExpected = num;
				CoopRewardState.PendingGameInitInstance = null;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] SendTreasureRelicChoices failed: " + ex.Message));
			}
		}

		public void DistributeGoldToInactivePlayers(int amount)
		{
			if (amount <= 0)
			{
				return;
			}
			foreach (KeyValuePair<int, CoopPlayerState> playerState in PlayerStates)
			{
				if (playerState.Key != ActivePlayerSlot)
				{
					playerState.Value.Gold += amount;
				}
			}
			_log.LogInfo((object)$"[CoopState] Distributed +{amount} gold to {PlayerStates.Count - 1} inactive player(s)");
		}

		public void ApplyDamageToAll(float damage)
		{
			foreach (CoopPlayerState value in PlayerStates.Values)
			{
				value.CurrentHealth = Mathf.Max(0f, value.CurrentHealth - damage);
			}
		}

		public CoopPlayerState GetPlayerState(int slotIndex)
		{
			if (!PlayerStates.TryGetValue(slotIndex, out var value))
			{
				return null;
			}
			return value;
		}

		public void Reset()
		{
			PlayerStates.Clear();
			ActivePlayerSlot = -1;
		}

		private void SaveDeckState(CoopPlayerState state)
		{
			try
			{
				DeckManager val = Resources.FindObjectsOfTypeAll<DeckManager>()?.FirstOrDefault();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if (DeckManager.completeDeck != null && DeckManager.completeDeck.Count > 0)
				{
					bool flag = false;
					foreach (GameObject item in DeckManager.completeDeck)
					{
						if ((Object)(object)item != (Object)null)
						{
							flag = true;
							break;
						}
					}
					if (!flag && state.CompleteDeck.Count > 0)
					{
						_log.LogInfo((object)$"[CoopState] SaveDeckState: singleton orbs are destroyed, preserving {state.CompleteDeck.Count} existing orbs");
						return;
					}
				}
				int count = state.CompleteDeck.Count;
				int count2 = state.BattleDeck.Count;
				int count3 = state.ShuffledOrder.Count;
				state.CompleteDeck.Clear();
				if (DeckManager.completeDeck != null)
				{
					foreach (GameObject item2 in DeckManager.completeDeck)
					{
						if (!((Object)(object)item2 == (Object)null))
						{
							Attack component = item2.GetComponent<Attack>();
							PersistentOrb component2 = item2.GetComponent<PersistentOrb>();
							state.CompleteDeck.Add(new SerializedOrb
							{
								PrefabName = ((Object)item2).name.Replace("(Clone)", string.Empty).Trim(),
								Guid = _orbId?.GetGuid(item2),
								Level = (component?.Level ?? 0),
								RemainingPersistence = (((Object)(object)component2 != (Object)null) ? component2.remainingPersistence : (-1))
							});
						}
					}
				}
				state.BattleDeck.Clear();
				if (val.battleDeck != null)
				{
					foreach (GameObject item3 in val.battleDeck)
					{
						if (!((Object)(object)item3 == (Object)null))
						{
							Attack component3 = item3.GetComponent<Attack>();
							PersistentOrb component4 = item3.GetComponent<PersistentOrb>();
							state.BattleDeck.Add(new SerializedOrb
							{
								PrefabName = ((Object)item3).name.Replace("(Clone)", string.Empty).Trim(),
								Guid = _orbId?.GetGuid(item3),
								Level = (component3?.Level ?? 0),
								RemainingPersistence = (((Object)(object)component4 != (Object)null) ? component4.remainingPersistence : (-1))
							});
						}
					}
				}
				state.ShuffledOrder.Clear();
				if (val.shuffledDeck != null)
				{
					foreach (GameObject item4 in val.shuffledDeck)
					{
						if (!((Object)(object)item4 == (Object)null))
						{
							string text = _orbId?.GetGuid(item4);
							state.ShuffledOrder.Add(text ?? ((Object)item4).name.Replace("(Clone)", string.Empty).Trim());
						}
					}
				}
				state.CurrentOrb = string.Empty;
				if (count != state.CompleteDeck.Count || count2 != state.BattleDeck.Count || count3 != state.ShuffledOrder.Count)
				{
					_log.LogInfo((object)($"[CoopState] SaveDeckState slot {state.SlotIndex}: " + $"complete {count}->{state.CompleteDeck.Count}, " + $"battle {count2}->{state.BattleDeck.Count}, " + $"shuffled {count3}->{state.ShuffledOrder.Count}"));
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] SaveDeckState failed: " + ex.Message));
			}
		}

		private void LoadDeckState(CoopPlayerState state)
		{
			try
			{
				DeckManager val = Resources.FindObjectsOfTypeAll<DeckManager>()?.FirstOrDefault();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if (DeckManager.completeDeck == null)
				{
					DeckManager.completeDeck = new List<GameObject>();
				}
				foreach (GameObject item in DeckManager.completeDeck)
				{
					if ((Object)(object)item != (Object)null)
					{
						Object.Destroy((Object)(object)item);
					}
				}
				DeckManager.completeDeck.Clear();
				foreach (SerializedOrb item2 in state.CompleteDeck)
				{
					AssetLoading instance = AssetLoading.Instance;
					GameObject val2 = ((instance != null) ? instance.GetOrbPrefab(item2.PrefabName) : null);
					if ((Object)(object)val2 != (Object)null)
					{
						GameObject val3 = Object.Instantiate<GameObject>(val2);
						((Object)val3).name = item2.PrefabName;
						val3.SetActive(false);
						Object.DontDestroyOnLoad((Object)(object)val3);
						Attack component = val3.GetComponent<Attack>();
						if (component != null)
						{
							component.SetInstanceId();
						}
						if (!string.IsNullOrEmpty(item2.Guid) && _orbId != null)
						{
							_orbId.Register(val3, item2.Guid);
						}
						if (item2.RemainingPersistence >= 0)
						{
							PersistentOrb component2 = val3.GetComponent<PersistentOrb>();
							if ((Object)(object)component2 != (Object)null)
							{
								component2.remainingPersistence = item2.RemainingPersistence;
							}
						}
						DeckManager.completeDeck.Add(val3);
					}
					else
					{
						_log.LogWarning((object)("[CoopState] Orb prefab not found: '" + item2.PrefabName + "'"));
					}
				}
				if (val.battleDeck == null)
				{
					val.battleDeck = new List<GameObject>();
				}
				foreach (GameObject item3 in val.battleDeck)
				{
					if ((Object)(object)item3 != (Object)null)
					{
						Object.Destroy((Object)(object)item3);
					}
				}
				val.battleDeck.Clear();
				foreach (SerializedOrb item4 in state.BattleDeck)
				{
					AssetLoading instance2 = AssetLoading.Instance;
					GameObject val4 = ((instance2 != null) ? instance2.GetOrbPrefab(item4.PrefabName) : null);
					if (!((Object)(object)val4 != (Object)null))
					{
						continue;
					}
					GameObject val5 = Object.Instantiate<GameObject>(val4);
					((Object)val5).name = item4.PrefabName;
					val5.SetActive(false);
					Object.DontDestroyOnLoad((Object)(object)val5);
					Attack component3 = val5.GetComponent<Attack>();
					if (component3 != null)
					{
						component3.SetInstanceId();
					}
					if (!string.IsNullOrEmpty(item4.Guid) && _orbId != null)
					{
						_orbId.Register(val5, item4.Guid);
					}
					if (item4.RemainingPersistence >= 0)
					{
						PersistentOrb component4 = val5.GetComponent<PersistentOrb>();
						if ((Object)(object)component4 != (Object)null)
						{
							component4.remainingPersistence = item4.RemainingPersistence;
						}
					}
					val.battleDeck.Add(val5);
				}
				val.shuffledDeck.Clear();
				if (state.ShuffledOrder != null)
				{
					for (int num = state.ShuffledOrder.Count - 1; num >= 0; num--)
					{
						string text = state.ShuffledOrder[num];
						GameObject val6 = null;
						if (_orbId != null)
						{
							val6 = _orbId.Find(text);
						}
						if ((Object)(object)val6 == (Object)null)
						{
							_log.LogWarning((object)("[CoopState] LoadDeckState: GUID lookup failed for shuffledDeck entry '" + text + "', falling back to name matching"));
							string text2 = text.Replace("(Clone)", string.Empty).Trim();
							foreach (GameObject item5 in val.battleDeck)
							{
								if ((Object)(object)item5 != (Object)null && ((Object)item5).name.Replace("(Clone)", string.Empty).Trim() == text2)
								{
									val6 = item5;
									_log.LogWarning((object)("[CoopState] LoadDeckState: name fallback matched '" + text2 + "' for entry '" + text + "'"));
									break;
								}
							}
						}
						if ((Object)(object)val6 != (Object)null)
						{
							val.shuffledDeck.Push(val6);
						}
					}
				}
				_log.LogInfo((object)($"[CoopState] LoadDeckState for slot {state.SlotIndex}: " + $"complete={DeckManager.completeDeck.Count}, battle={val.battleDeck.Count}, " + $"shuffled={val.shuffledDeck.Count}"));
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] LoadDeckState failed: " + ex.Message));
			}
		}

		public void RebuildDeckInfoDisplay(DeckManager deckMgr = null)
		{
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_023d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_03de: Unknown result type (might be due to invalid IL or missing references)
			//IL_03ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0403: Unknown result type (might be due to invalid IL or missing references)
			//IL_0374: Unknown result type (might be due to invalid IL or missing references)
			//IL_0379: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0390: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a3: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)deckMgr == (Object)null)
				{
					deckMgr = Resources.FindObjectsOfTypeAll<DeckManager>()?.FirstOrDefault();
				}
				if ((Object)(object)deckMgr == (Object)null)
				{
					_log.LogWarning((object)"[CoopState] RebuildDeckInfoDisplay: DeckManager null");
					return;
				}
				DeckInfoManager val = Object.FindObjectOfType<DeckInfoManager>();
				if ((Object)(object)val == (Object)null)
				{
					_log.LogWarning((object)"[CoopState] RebuildDeckInfoDisplay: DeckInfoManager null");
				}
				else if (!(AccessTools.Field(typeof(DeckInfoManager), "_displayOrbs")?.GetValue(val) is Stack<GameObject> stack))
				{
					_log.LogWarning((object)"[CoopState] RebuildDeckInfoDisplay: _displayOrbs null");
				}
				else
				{
					if (deckMgr.shuffledDeck == null || deckMgr.shuffledDeck.Count == 0)
					{
						return;
					}
					string text = ComputeShuffledDeckSignature(deckMgr);
					if (_lastRebuildDim != null && _lastRebuildDim.IsAlive && _lastRebuildDim.Target == val && _lastRebuildSignature != null && _lastRebuildSignature == text && _lastRebuildDisplayCount == stack.Count && AllDisplayOrbsAlive(stack))
					{
						return;
					}
					foreach (GameObject item in stack)
					{
						if ((Object)(object)item != (Object)null)
						{
							Object.Destroy((Object)(object)item);
						}
					}
					stack.Clear();
					MethodInfo methodInfo = AccessTools.Method(typeof(DeckInfoManager), "CreatePreviewSprite", new Type[2]
					{
						typeof(GameObject),
						typeof(float)
					}, (Type[])null);
					if (methodInfo == null)
					{
						_log.LogWarning((object)"[CoopState] RebuildDeckInfoDisplay: CreatePreviewSprite method null");
						return;
					}
					object? obj = AccessTools.Field(typeof(DeckInfoManager), "_plungerParent")?.GetValue(val);
					Transform val2 = (Transform)((obj is Transform) ? obj : null);
					if ((Object)(object)val2 == (Object)null)
					{
						_log.LogWarning((object)"[CoopState] RebuildDeckInfoDisplay: _plungerParent null");
						return;
					}
					object? obj2 = AccessTools.Field(typeof(DeckInfoManager), "_plungerGraphic")?.GetValue(val);
					Transform val3 = (Transform)((obj2 is Transform) ? obj2 : null);
					FieldInfo fieldInfo = AccessTools.Field(typeof(DeckInfoManager), "_startingPlungerGraphicPosition");
					Vector3 val4 = (Vector3)((fieldInfo != null) ? ((Vector3)fieldInfo.GetValue(val)) : Vector3.zero);
					object? obj3 = AccessTools.Field(typeof(DeckInfoManager), "_topTransform")?.GetValue(val);
					Transform val5 = (Transform)((obj3 is Transform) ? obj3 : null);
					float num = 0.875f;
					float upcomingDisplayOrbFudgeFactor = val.upcomingDisplayOrbFudgeFactor;
					GameObject[] array = deckMgr.shuffledDeck.ToArray();
					float num2 = (float)array.Length * (0f - num);
					if ((Object)(object)val3 != (Object)null)
					{
						val3.localPosition = new Vector3(val4.x, num2 + val4.y);
					}
					int num3 = 0;
					for (int num4 = array.Length - 1; num4 >= 0; num4--)
					{
						if (!((Object)(object)array[num4] == (Object)null))
						{
							bool activeSelf = array[num4].activeSelf;
							if (!activeSelf)
							{
								array[num4].SetActive(true);
							}
							object? obj4 = methodInfo.Invoke(val, new object[2]
							{
								array[num4],
								(float)num4 * 0.01f
							});
							GameObject val6 = (GameObject)((obj4 is GameObject) ? obj4 : null);
							if (!activeSelf)
							{
								array[num4].SetActive(false);
							}
							if ((Object)(object)val6 != (Object)null)
							{
								val6.transform.parent = val2;
								SpriteRenderer component = val6.GetComponent<SpriteRenderer>();
								float num5;
								if (!((Object)(object)component != (Object)null))
								{
									num5 = 0f;
								}
								else
								{
									Bounds bounds = ((Renderer)component).bounds;
									num5 = ((Bounds)(ref bounds)).size.y;
								}
								float num6 = num5;
								val6.transform.localPosition = Vector3.up * (num2 + upcomingDisplayOrbFudgeFactor + num6 * 0.5f);
								num2 += num6;
								stack.Push(val6);
								num3++;
							}
						}
					}
					if ((Object)(object)val5 != (Object)null)
					{
						val2.position = new Vector3(val2.position.x, val5.position.y - num2, val2.position.z);
					}
					_lastRebuildDim = new WeakReference(val);
					_lastRebuildSignature = text;
					_lastRebuildDisplayCount = stack.Count;
					_log.LogInfo((object)$"[CoopState] RebuildDeckInfoDisplay: {num3}/{array.Length} display orbs from shuffledDeck yAccum={num2:F3}");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] RebuildDeckInfoDisplay failed: " + ex.Message));
			}
		}

		private static string ComputeShuffledDeckSignature(DeckManager deckMgr)
		{
			try
			{
				Stack<GameObject> stack = deckMgr?.shuffledDeck;
				if (stack == null)
				{
					return "<null>";
				}
				StringBuilder stringBuilder = new StringBuilder();
				foreach (GameObject item in stack)
				{
					if ((Object)(object)item == (Object)null)
					{
						stringBuilder.Append("<n>|");
					}
					else
					{
						stringBuilder.Append(((Object)item).GetInstanceID()).Append(':').Append(((Object)item).name)
							.Append('|');
					}
				}
				return stringBuilder.ToString();
			}
			catch
			{
				return null;
			}
		}

		private static bool AllDisplayOrbsAlive(Stack<GameObject> displayOrbs)
		{
			foreach (GameObject displayOrb in displayOrbs)
			{
				if ((Object)(object)displayOrb == (Object)null)
				{
					return false;
				}
			}
			return true;
		}

		private void SaveRelicState(CoopPlayerState state)
		{
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected I4, but got Unknown
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00de: Expected I4, but got O
			//IL_00e3: Expected O, but got I4
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Expected I4, but got Unknown
			//IL_00d9->IL00d9: Incompatible stack types: O vs I4
			//IL_00d4->IL00d9: Incompatible stack types: I4 vs O
			//IL_00d4->IL00d9: Incompatible stack types: O vs I4
			try
			{
				RelicManager val = Resources.FindObjectsOfTypeAll<RelicManager>()?.FirstOrDefault();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(RelicManager), "_ownedRelics");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(RelicManager), "_relicRemainingCountdowns");
				if (fieldInfo == null || !(fieldInfo.GetValue(val) is Dictionary<RelicEffect, Relic> dictionary))
				{
					return;
				}
				state.OwnedRelics.Clear();
				foreach (KeyValuePair<RelicEffect, Relic> item in dictionary)
				{
					object obj = state.OwnedRelics;
					object obj2 = new SerializedRelic
					{
						Effect = (int)item.Key,
						LocKey = (item.Value?.locKey ?? string.Empty)
					};
					obj2 = obj2;
					Relic value = item.Value;
					int num;
					if (value == null)
					{
						num = 0;
						obj = num;
						num = (int)obj;
					}
					else
					{
						obj = value.globalRarity;
						num = (int)obj;
					}
					((SerializedRelic)obj2).Rarity = (int)obj;
					((List<SerializedRelic>)num).Add((SerializedRelic)obj2);
				}
				state.RelicCountdowns.Clear();
				if (fieldInfo2?.GetValue(val) is Dictionary<RelicEffect, int> dictionary2)
				{
					foreach (KeyValuePair<RelicEffect, int> item2 in dictionary2)
					{
						state.RelicCountdowns[(int)item2.Key] = item2.Value;
					}
				}
				CopyDictToState(val, "_relicRemainingUsesPerShot", state.RelicUsesPerShot);
				CopyDictToState(val, "_relicRemainingUsesPerBattle", state.RelicUsesPerBattle);
				CopyDictToState(val, "_relicRemainingUsesPerRun", state.RelicUsesPerRun);
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] SaveRelicState failed: " + ex.Message));
			}
		}

		private void CopyDictToState(RelicManager rm, string fieldName, Dictionary<int, int> target)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0052: Expected I4, but got Unknown
			target.Clear();
			if (!(AccessTools.Field(typeof(RelicManager), fieldName)?.GetValue(rm) is Dictionary<RelicEffect, int> dictionary))
			{
				return;
			}
			foreach (KeyValuePair<RelicEffect, int> item in dictionary)
			{
				target[(int)item.Key] = item.Value;
			}
		}

		private void CopyStateToDict(RelicManager rm, string fieldName, Dictionary<int, int> source)
		{
			if (!(AccessTools.Field(typeof(RelicManager), fieldName)?.GetValue(rm) is Dictionary<RelicEffect, int> dictionary))
			{
				return;
			}
			foreach (KeyValuePair<int, int> item in source)
			{
				dictionary[(RelicEffect)item.Key] = item.Value;
			}
		}

		private void LoadRelicState(CoopPlayerState state)
		{
			//IL_0127: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RelicManager val = Resources.FindObjectsOfTypeAll<RelicManager>()?.FirstOrDefault();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(RelicManager), "_ownedRelics");
				if (fieldInfo != null)
				{
					(fieldInfo.GetValue(val) as Dictionary<RelicEffect, Relic>)?.Clear();
				}
				Relic[] source = Resources.FindObjectsOfTypeAll<Relic>();
				int num = 0;
				foreach (SerializedRelic entry in state.OwnedRelics)
				{
					RelicEffect effect = (RelicEffect)entry.Effect;
					if ((int)effect == 0)
					{
						continue;
					}
					Relic val2 = ((IEnumerable<Relic>)source).FirstOrDefault((Func<Relic, bool>)((Relic r) => r.effect == effect)) ?? ((IEnumerable<Relic>)source).FirstOrDefault((Func<Relic, bool>)((Relic r) => r.locKey == entry.LocKey));
					if ((Object)(object)val2 != (Object)null)
					{
						try
						{
							if (fieldInfo.GetValue(val) is Dictionary<RelicEffect, Relic> dictionary && !dictionary.ContainsKey(effect))
							{
								dictionary[effect] = val2;
								num++;
							}
						}
						catch (Exception ex)
						{
							_log.LogWarning((object)$"[CoopState] Direct relic add failed for {effect}: {ex.Message}");
						}
					}
					else
					{
						_log.LogWarning((object)$"[CoopState] Relic asset not found: effect={effect}, locKey={entry.LocKey}");
					}
				}
				if (state.RelicCountdowns.Count > 0 && AccessTools.Field(typeof(RelicManager), "_relicRemainingCountdowns")?.GetValue(val) is Dictionary<RelicEffect, int> dictionary2)
				{
					foreach (KeyValuePair<int, int> relicCountdown in state.RelicCountdowns)
					{
						dictionary2[(RelicEffect)relicCountdown.Key] = relicCountdown.Value;
					}
				}
				CopyStateToDict(val, "_relicRemainingUsesPerShot", state.RelicUsesPerShot);
				CopyStateToDict(val, "_relicRemainingUsesPerBattle", state.RelicUsesPerBattle);
				CopyStateToDict(val, "_relicRemainingUsesPerRun", state.RelicUsesPerRun);
				_log.LogInfo((object)$"[CoopState] LoadRelicState for slot {state.SlotIndex}: {num}/{state.OwnedRelics.Count} relics loaded");
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[CoopState] LoadRelicState failed: " + ex2.Message));
			}
		}

		public void MergeBoardRelics()
		{
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0111: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			if (TotalPlayerCount < 2)
			{
				return;
			}
			try
			{
				RelicManager val = Resources.FindObjectsOfTypeAll<RelicManager>()?.FirstOrDefault();
				if ((Object)(object)val == (Object)null || !(AccessTools.Field(typeof(RelicManager), "_ownedRelics")?.GetValue(val) is Dictionary<RelicEffect, Relic> dictionary))
				{
					return;
				}
				Relic[] source = Resources.FindObjectsOfTypeAll<Relic>();
				HashSet<int> hashSet = new HashSet<int>(BoardRelicEffects);
				int num = 0;
				foreach (KeyValuePair<int, CoopPlayerState> playerState in PlayerStates)
				{
					if (playerState.Key == ActivePlayerSlot)
					{
						continue;
					}
					foreach (SerializedRelic ownedRelic in playerState.Value.OwnedRelics)
					{
						if (!hashSet.Contains(ownedRelic.Effect))
						{
							continue;
						}
						RelicEffect effect = (RelicEffect)ownedRelic.Effect;
						if (!dictionary.ContainsKey(effect))
						{
							Relic val2 = ((IEnumerable<Relic>)source).FirstOrDefault((Func<Relic, bool>)((Relic r) => r.effect == effect));
							if ((Object)(object)val2 != (Object)null)
							{
								dictionary[effect] = val2;
								num++;
								_log.LogInfo((object)$"[CoopState] MergeBoardRelics: added {effect} from slot {playerState.Key}");
							}
						}
					}
				}
				if (num > 0)
				{
					_log.LogInfo((object)$"[CoopState] MergeBoardRelics: merged {num} board relics from non-active players");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] MergeBoardRelics failed: " + ex.Message));
			}
		}

		public void MergeAllRelicsForNavPhase()
		{
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			_navPhaseMergedEffects.Clear();
			if (TotalPlayerCount < 2)
			{
				return;
			}
			try
			{
				RelicManager val = Resources.FindObjectsOfTypeAll<RelicManager>()?.FirstOrDefault();
				if ((Object)(object)val == (Object)null || !(AccessTools.Field(typeof(RelicManager), "_ownedRelics")?.GetValue(val) is Dictionary<RelicEffect, Relic> dictionary))
				{
					return;
				}
				Relic[] source = Resources.FindObjectsOfTypeAll<Relic>();
				foreach (KeyValuePair<int, CoopPlayerState> playerState in PlayerStates)
				{
					if (playerState.Key == ActivePlayerSlot)
					{
						continue;
					}
					foreach (SerializedRelic entry in playerState.Value.OwnedRelics)
					{
						RelicEffect effect = (RelicEffect)entry.Effect;
						if ((int)effect != 0 && !dictionary.ContainsKey(effect))
						{
							Relic val2 = ((IEnumerable<Relic>)source).FirstOrDefault((Func<Relic, bool>)((Relic r) => r.effect == effect)) ?? ((IEnumerable<Relic>)source).FirstOrDefault((Func<Relic, bool>)((Relic r) => r.locKey == entry.LocKey));
							if (!((Object)(object)val2 == (Object)null))
							{
								dictionary[effect] = val2;
								_navPhaseMergedEffects.Add(effect);
							}
						}
					}
				}
				_log.LogInfo((object)$"[CoopState] MergeAllRelicsForNavPhase: merged {_navPhaseMergedEffects.Count} relics from non-active players");
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] MergeAllRelicsForNavPhase failed: " + ex.Message));
			}
		}

		public void UnmergeNavPhaseRelics()
		{
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			if (_navPhaseMergedEffects.Count == 0)
			{
				return;
			}
			try
			{
				RelicManager val = Resources.FindObjectsOfTypeAll<RelicManager>()?.FirstOrDefault();
				if ((Object)(object)val == (Object)null)
				{
					_navPhaseMergedEffects.Clear();
					return;
				}
				if (!(AccessTools.Field(typeof(RelicManager), "_ownedRelics")?.GetValue(val) is Dictionary<RelicEffect, Relic> dictionary))
				{
					_navPhaseMergedEffects.Clear();
					return;
				}
				int num = 0;
				foreach (RelicEffect navPhaseMergedEffect in _navPhaseMergedEffects)
				{
					if (dictionary.Remove(navPhaseMergedEffect))
					{
						num++;
					}
				}
				_log.LogInfo((object)$"[CoopState] UnmergeNavPhaseRelics: removed {num}/{_navPhaseMergedEffects.Count} merged relics");
				_navPhaseMergedEffects.Clear();
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] UnmergeNavPhaseRelics failed: " + ex.Message));
				_navPhaseMergedEffects.Clear();
			}
		}

		private void SaveHealthState(CoopPlayerState state)
		{
			try
			{
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val != (Object)null)
				{
					float currentHealth = state.CurrentHealth;
					float maxHealth = state.MaxHealth;
					state.CurrentHealth = Mathf.Max(0f, val.CurrentHealth);
					object obj = AccessTools.Field(typeof(PlayerHealthController), "_maxPlayerHealth")?.GetValue(val);
					if (obj != null)
					{
						PropertyInfo property = obj.GetType().GetProperty("Value");
						state.MaxHealth = ((property != null) ? ((float)property.GetValue(obj)) : 0f);
					}
					if (Mathf.Abs(currentHealth - state.CurrentHealth) > 0.1f || Mathf.Abs(maxHealth - state.MaxHealth) > 0.1f)
					{
						_log.LogInfo((object)$"[CoopState] SaveHealthState slot {state.SlotIndex}: hp={state.CurrentHealth}/{state.MaxHealth}");
					}
					return;
				}
				FloatVariable[] array = Resources.FindObjectsOfTypeAll<FloatVariable>();
				foreach (FloatVariable val2 in array)
				{
					if (((Object)val2).name == "PlayerHealth" || ((Object)val2).name == "playerHealth")
					{
						state.CurrentHealth = val2.Value;
					}
					else if (((Object)val2).name == "MaxPlayerHealth" || ((Object)val2).name == "maxPlayerHealth")
					{
						state.MaxHealth = val2.Value;
					}
				}
				if (state.CurrentHealth > 0f || state.MaxHealth > 0f)
				{
					_log.LogInfo((object)$"[CoopState] SaveHealthState via FloatVariable fallback: hp={state.CurrentHealth}/{state.MaxHealth}");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] SaveHealthState failed: " + ex.Message));
			}
		}

		private void LoadHealthState(CoopPlayerState state)
		{
			try
			{
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val != (Object)null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth");
					FieldInfo fieldInfo2 = AccessTools.Field(typeof(PlayerHealthController), "_maxPlayerHealth");
					object obj = fieldInfo?.GetValue(val);
					object obj2 = fieldInfo2?.GetValue(val);
					obj2?.GetType().GetMethod("Set", new Type[1] { typeof(float) })?.Invoke(obj2, new object[1] { state.MaxHealth });
					obj?.GetType().GetMethod("Set", new Type[1] { typeof(float) })?.Invoke(obj, new object[1] { state.CurrentHealth });
					return;
				}
				FloatVariable[] array = Resources.FindObjectsOfTypeAll<FloatVariable>();
				FloatVariable[] array2 = array;
				foreach (FloatVariable val2 in array2)
				{
					if (((Object)val2).name == "MaxPlayerHealth" || ((Object)val2).name == "maxPlayerHealth")
					{
						val2.Set(state.MaxHealth);
					}
				}
				array2 = array;
				foreach (FloatVariable val3 in array2)
				{
					if (((Object)val3).name == "PlayerHealth" || ((Object)val3).name == "playerHealth")
					{
						val3.Set(state.CurrentHealth);
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] LoadHealthState failed: " + ex.Message));
			}
		}

		private void SaveGoldState(CoopPlayerState state)
		{
			try
			{
				CurrencyManager instance = CurrencyManager.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					int gold = state.Gold;
					state.Gold = instance.GoldAmount;
					if (gold != state.Gold)
					{
						_log.LogInfo((object)$"[CoopState] SaveGoldState slot {state.SlotIndex}: gold {gold}->{state.Gold}");
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] SaveGoldState failed: " + ex.Message));
			}
		}

		private void LoadGoldState(CoopPlayerState state)
		{
			try
			{
				CurrencyManager instance = CurrencyManager.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				int goldAmount = instance.GoldAmount;
				int num = state.Gold - goldAmount;
				MultiplayerClientPatches.AllowCurrencySync = true;
				IsLoadingPlayerGold = true;
				try
				{
					if (num > 0)
					{
						instance.AddGold(num, true);
					}
					else if (num < 0)
					{
						instance.RemoveGold(-num, true, true);
					}
				}
				finally
				{
					IsLoadingPlayerGold = false;
					MultiplayerClientPatches.AllowCurrencySync = false;
				}
				_log.LogInfo((object)$"[CoopState] LoadGoldState slot {state.SlotIndex}: gold {goldAmount}->{state.Gold} (diff={num})");
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] LoadGoldState failed: " + ex.Message));
			}
		}

		public void ClearNegativeDebuffsFromAllPlayers()
		{
			foreach (KeyValuePair<int, CoopPlayerState> playerState in PlayerStates)
			{
				CoopPlayerState value = playerState.Value;
				if (value?.StatusEffects != null && value.StatusEffects.Count != 0)
				{
					int count = value.StatusEffects.Count;
					value.StatusEffects.RemoveAll((SerializedStatusEffect e) => IsDebuff(e.EffectType));
					int num = count - value.StatusEffects.Count;
					if (num > 0)
					{
						_log.LogInfo((object)$"[CoopState] ClearDebuffs slot {value.SlotIndex}: removed {num} debuff(s), {value.StatusEffects.Count} buff(s) preserved");
					}
				}
			}
		}

		private static bool IsDebuff(int effectType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			StatusEffectType val = (StatusEffectType)effectType;
			switch (((object)(StatusEffectType)(ref val)).ToString())
			{
			case "Stunned":
			case "Thorned":
			case "Poison":
			case "Slimed":
			case "Webbed":
			case "Blind":
			case "Confusion":
			case "Exploitaball":
			case "Transpherency":
			case "Spinfection":
				return true;
			default:
				return false;
			}
		}

		private void SaveStatusEffects(CoopPlayerState state)
		{
			try
			{
				PlayerStatusEffectController val = Object.FindObjectOfType<PlayerStatusEffectController>();
				if ((Object)(object)val == (Object)null)
				{
					_log.LogInfo((object)("[CoopState] SaveStatusEffects: PlayerStatusEffectController not found (non-battle scene), " + $"preserving {state.StatusEffects.Count} existing effects for slot {state.SlotIndex}"));
					return;
				}
				if (!(AccessTools.Field(typeof(PlayerStatusEffectController), "_statusEffects")?.GetValue(val) is IList list))
				{
					_log.LogInfo((object)$"[CoopState] SaveStatusEffects: _statusEffects list is null for slot {state.SlotIndex}");
					state.StatusEffects.Clear();
					return;
				}
				state.StatusEffects.Clear();
				foreach (object item in list)
				{
					FieldInfo fieldInfo = AccessTools.Field(item.GetType(), "EffectType");
					FieldInfo fieldInfo2 = AccessTools.Field(item.GetType(), "Intensity");
					if (!(fieldInfo == null))
					{
						object value = fieldInfo.GetValue(item);
						int num = (int)(fieldInfo2?.GetValue(item) ?? ((object)0));
						if (num > 0)
						{
							state.StatusEffects.Add(new SerializedStatusEffect
							{
								EffectType = (int)value,
								Intensity = num
							});
						}
					}
				}
				if (state.StatusEffects.Count > 0)
				{
					string arg = string.Join(", ", state.StatusEffects.ConvertAll((SerializedStatusEffect e) => $"{(object)(StatusEffectType)e.EffectType}={e.Intensity}"));
					_log.LogInfo((object)$"[CoopState] SaveStatusEffects slot {state.SlotIndex}: [{arg}]");
				}
				else
				{
					_log.LogInfo((object)$"[CoopState] SaveStatusEffects slot {state.SlotIndex}: no active effects");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopState] SaveStatusEffects failed: " + ex.Message));
			}
		}

		private void LoadStatusEffects(CoopPlayerState state)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Expected O, but got Unknown
			try
			{
				SuppressStatusEffectUI = state.SlotIndex != 0;
				PlayerStatusEffectController val = Object.FindObjectOfType<PlayerStatusEffectController>();
				if ((Object)(object)val == (Object)null)
				{
					_log.LogInfo((object)("[CoopState] LoadStatusEffects: PlayerStatusEffectController not found (non-battle scene), " + $"skipping load for slot {state.SlotIndex} ({state.StatusEffects.Count} saved effects)"));
					return;
				}
				if (!(AccessTools.Field(typeof(PlayerStatusEffectController), "_statusEffects")?.GetValue(val) is List<StatusEffect> list))
				{
					_log.LogWarning((object)$"[CoopState] LoadStatusEffects: _statusEffects list is null for slot {state.SlotIndex}");
					return;
				}
				list.Clear();
				foreach (SerializedStatusEffect statusEffect in state.StatusEffects)
				{
					StatusEffectType val2 = (StatusEffectType)statusEffect.EffectType;
					if ((int)val2 != 0 && statusEffect.Intensity > 0)
					{
						list.Add(new StatusEffect(val2, statusEffect.Intensity));
					}
				}
				if (state.SlotIndex == 0)
				{
					object? obj = AccessTools.Field(typeof(PlayerStatusEffectController), "_statusEffectUI")?.GetValue(val);
					StatusEffectIconManager val3 = (StatusEffectIconManager)((obj is StatusEffectIconManager) ? obj : null);
					if ((Object)(object)val3 != (Object)null)
					{
						try
						{
							val3.UpdateStatusEffects(list.ToArray());
						}
						catch (Exception ex)
						{
							_log.LogWarning((object)("[CoopState] LoadStatusEffects: UI update failed: " + ex.Message));
						}
					}
				}
				if (state.StatusEffects.Count > 0)
				{
					string arg = string.Join(", ", state.StatusEffects.ConvertAll((SerializedStatusEffect e) => $"{(object)(StatusEffectType)e.EffectType}={e.Intensity}"));
					_log.LogInfo((object)$"[CoopState] LoadStatusEffects slot {state.SlotIndex}: [{arg}]");
				}
				else
				{
					_log.LogInfo((object)$"[CoopState] LoadStatusEffects slot {state.SlotIndex}: no effects to restore");
				}
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[CoopState] LoadStatusEffects failed: " + ex2.Message));
			}
		}
	}
	public class CursorSync : MonoBehaviour
	{
		private const float SendInterval = 1f / 30f;

		private const float MinMoveDelta = 0.03f;

		private IMessageSender _sender;

		private IMultiplayerMode _mode;

		private PlayerRegistry _registry;

		private INetworkTransport _transport;

		private float _lastSendTime;

		private Vector2 _lastSentWorldPos;

		private bool _hasSent;

		private void Start()
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null)
			{
				services.TryResolve<IMessageSender>(out _sender);
				services.TryResolve<IMultiplayerMode>(out _mode);
				services.TryResolve<PlayerRegistry>(out _registry);
				services.TryResolve<INetworkTransport>(out _transport);
			}
		}

		private void Update()
		{
			//IL_0066: Unknown result type (might be due to invalid IL or missing references)
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00aa: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			if (_sender == null || _mode == null || _transport == null || !_transport.IsConnected || (!_mode.IsHosting && !_mode.IsSpectating) || Time.unscaledTime - _lastSendTime < 1f / 30f)
			{
				return;
			}
			Camera main = Camera.main;
			if ((Object)(object)main == (Object)null)
			{
				return;
			}
			Vector3 mousePosition = Input.mousePosition;
			if (mousePosition.x < 0f || mousePosition.y < 0f || mousePosition.x > (float)Screen.width || mousePosition.y > (float)Screen.height)
			{
				return;
			}
			Vector3 val = main.ScreenToWorldPoint(new Vector3(mousePosition.x, mousePosition.y, 0f - ((Component)main).transform.position.z));
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(val.x, val.y);
			if (_hasSent)
			{
				Vector2 val3 = val2 - _lastSentWorldPos;
				if (((Vector2)(ref val3)).sqrMagnitude < 0.0009f)
				{
					return;
				}
			}
			int num = LocalSlotIndex();
			if (num >= 0)
			{
				_sender.Send(new CursorPositionEvent
				{
					FromSlot = num,
					WorldX = val2.x,
					WorldY = val2.y
				});
				_lastSentWorldPos = val2;
				_lastSendTime = Time.unscaledTime;
				_hasSent = true;
			}
		}

		private int LocalSlotIndex()
		{
			if (_mode.IsHosting)
			{
				return 0;
			}
			return (_registry?.LocalSlot?.SlotIndex).GetValueOrDefault(-1);
		}
	}
	public class GameStateApplyService
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass28_0
		{
			public GameStateApplyService <>4__this;

			public FullGameStateSnapshot snapshot;

			internal void <ApplyPendingAfterDelay>b__0()
			{
				<>4__this._mapApplier.Apply(snapshot.Map);
			}
		}

		[CompilerGenerated]
		private sealed class <>c__DisplayClass29_0
		{
			public FullGameStateSnapshot pending;

			public GameStateApplyService <>4__this;

			internal void <ApplyAfterSceneLoad>b__1()
			{
				<>4__this._mapApplier.Apply(pending.Map);
			}
		}

		[CompilerGenerated]
		private sealed class <ApplyAfterSceneLoad>d__29 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public string sceneName;

			public GameStateApplyService <>4__this;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
				//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
				//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
				//IL_00b8: Expected O, but got Unknown
				int num = <>1__state;
				GameStateApplyService CS$<>8__locals0 = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 2;
					return true;
				case 2:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					if (sceneName == "Battle")
					{
						<>2__current = CS$<>8__locals0.WaitForEnemyCache();
						<>1__state = 4;
						return true;
					}
					goto IL_00a8;
				case 4:
					<>1__state = -1;
					goto IL_00a8;
				case 5:
					{
						<>1__state = -1;
						Scene activeScene = SceneManager.GetActiveScene();
						string name = ((Scene)(ref activeScene)).name;
						if (name != sceneName)
						{
							CS$<>8__locals0._log.LogWarning((object)("[ApplyService] Scene changed during delay: " + sceneName + " → " + name));
							return false;
						}
						CS$<>8__locals0._log.LogInfo((object)("[ApplyService] Post-scene-load apply for '" + sceneName + "' (no pending snapshot)"));
						if (CS$<>8__locals0._latestFullSnapshot != null)
						{
							CS$<>8__locals0.ApplyPlayerFromSnapshot(CS$<>8__locals0._latestFullSnapshot);
						}
						else if (CS$<>8__locals0._latestPlayer != null)
						{
							CS$<>8__locals0.SafeApply("Player", delegate
							{
								CS$<>8__locals0._playerApplier.Apply(CS$<>8__locals0._latestPlayer);
							});
						}
						if (CS$<>8__locals0._pendingSnapshot != null && string.Equals(CS$<>8__locals0._pendingSnapshotScene, name, StringComparison.OrdinalIgnoreCase))
						{
							<>c__DisplayClass29_0 CS$<>8__locals1 = new <>c__DisplayClass29_0
							{
								<>4__this = CS$<>8__locals0
							};
							CS$<>8__locals0._log.LogInfo((object)"[ApplyService] Pending snapshot arrived during wait — applying now");
							CS$<>8__locals1.pending = CS$<>8__locals0._pendingSnapshot;
							CS$<>8__locals0._pendingSnapshot = null;
							CS$<>8__locals0._pendingSnapshotScene = string.Empty;
							if (CS$<>8__locals1.pending.Map != null)
							{
								CS$<>8__locals0.SafeApply("Map(late-pending)", delegate
								{
									CS$<>8__locals1.<>4__this._mapApplier.Apply(CS$<>8__locals1.pending.Map);
								});
							}
							CS$<>8__locals0.ApplyNonMapState(CS$<>8__locals1.pending);
						}
						return false;
					}
					IL_00a8:
					<>2__current = (object)new WaitForSeconds(0.5f);
					<>1__state = 5;
					return true;
				}
			}

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

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

		[CompilerGenerated]
		private sealed class <ApplyPendingAfterDelay>d__28 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GameStateApplyService <>4__this;

			public FullGameStateSnapshot snapshot;

			public string sceneName;

			private <>c__DisplayClass28_0 <>8__1;

			private float <timeout>5__2;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00df: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e9: Expected O, but got Unknown
				//IL_0139: Unknown result type (might be due to invalid IL or missing references)
				//IL_013e: Unknown result type (might be due to invalid IL or missing references)
				int num = <>1__state;
				GameStateApplyService gameStateApplyService = <>4__this;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass28_0();
					<>8__1.<>4__this = <>4__this;
					<>8__1.snapshot = snapshot;
					<>2__current = null;
					<>1__state = 1;
					return true;
				case 1:
					<>1__state = -1;
					if (sceneName == "Battle")
					{
						<>2__current = null;
						<>1__state = 2;
						return true;
					}
					<timeout>5__2 = Time.time + 5f;
					goto IL_0125;
				case 2:
					<>1__state = -1;
					<>2__current = null;
					<>1__state = 3;
					return true;
				case 3:
					<>1__state = -1;
					<>2__current = gameStateApplyService.WaitForEnemyCache();
					<>1__state = 4;
					return true;
				case 4:
					<>1__state = -1;
					<>2__current = (object)new WaitForSeconds(0.3f);
					<>1__state = 5;
					return true;
				case 5:
					<>1__state = -1;
					break;
				case 6:
					{
						<>1__state = -1;
						goto IL_0125;
					}
					IL_0125:
					if (!MultiplayerClientPatches.MapControllerStartCompleted && Time.time < <timeout>5__2)
					{
						<>2__current = null;
						<>1__state = 6;
						return true;
					}
					break;
				}
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (name != sceneName)
				{
					gameStateApplyService._log.LogWarning((object)("[ApplyService] Scene changed during pending apply delay: " + sceneName + " → " + name));
					return false;
				}
				gameStateApplyService._log.LogInfo((object)("[ApplyService] Applying pending snapshot for '" + sceneName + "'"));
				DiagnosticLogger.DumpBattleState("CLIENT_BeforePending_" + sceneName);
				if (<>8__1.snapshot.Map != null)
				{
					gameStateApplyService._latestMap = <>8__1.snapshot.Map;
					gameStateApplyService.SafeApply("Map(pending)", delegate
					{
						<>8__1.<>4__this._mapApplier.Apply(<>8__1.snapshot.Map);
					});
				}
				gameStateApplyService.ApplyNonMapState(<>8__1.snapshot);
				DiagnosticLogger.DumpBattleState("CLIENT_AfterPending_" + sceneName);
				return false;
			}

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

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

		[CompilerGenerated]
		private sealed class <WaitForEnemyCache>d__30 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			public GameStateApplyService <>4__this;

			private int <waitFrames>5__2;

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

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

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

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

			private bool MoveNext()
			{
				int num = <>1__state;
				GameStateApplyService gameStateApplyService = <>4__this;
				Dictionary<string, GameObject> dictionary;
				switch (num)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					dictionary = AssetLoading.Instance?.EnemyPrefabs;
					<waitFrames>5__2 = 0;
					break;
				case 1:
					<>1__state = -1;
					<waitFrames>5__2++;
					dictionary = AssetLoading.Instance?.EnemyPrefabs;
					break;
				}
				if ((dictionary == null || dictionary.Count == 0) && <waitFrames>5__2 < 30)
				{
					<>2__current = null;
					<>1__state = 1;
					return true;
				}
				if (dictionary != null && dictionary.Count > 0)
				{
					gameStateApplyService._log.LogInfo((object)$"[ApplyService] Enemy prefab cache ready: {dictionary.Count} entries (waited {<waitFrames>5__2} frames)");
				}
				else
				{
					gameStateApplyService._log.LogWarning((object)$"[ApplyService] Enemy prefab cache still empty after {<waitFrames>5__2} frames");
				}
				return false;
			}

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

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

		private readonly ManualLogSource _log;

		private readonly MapStateApplier _mapApplier;

		private readonly PlayerStateApplier _playerApplier;

		private readonly EnemyStateApplier _enemyApplier;

		private readonly PegboardStateApplier _pegboardApplier;

		private readonly DeckStateApplier _deckApplier;

		private readonly RelicStateApplier _relicApplier;

		private readonly EnemyIdentifier _enemyId;

		private string _lastCoopDeckSig = string.Empty;

		private string _lastCoopRelicSig = string.Empty;

		private string _lastNonBattleSceneSig = string.Empty;

		private readonly PegIdentifier _pegId;

		private string _hostScene = string.Empty;

		private long _hostSceneTimestamp;

		private FullGameStateSnapshot _pendingSnapshot;

		private string _pendingSnapshotScene = string.Empty;

		private PlayerStateSnapshot _latestPlayer;

		private MapStateSnapshot _latestMap;

		private FullGameStateSnapshot _latestFullSnapshot;

		private string _lastApplyClientScene = string.Empty;

		private string _lastApplyHostScene = string.Empty;

		private bool _wasNavigating;

		private string _lastAppliedSubtitle;

		private List<string> _lastAppliedResponses;

		private int _lastAppliedHighlightIndex = -1;

		private bool _navigationTriggered;

		private string _lastNavOrbApplied;

		public DeckStateApplier DeckApplier => _deckApplier;

		public GameStateApplyService(ManualLogSource log, EnemyIdentifier enemyId, PegIdentifier pegId, OrbIdentifier orbId)
		{
			_log = log;
			_mapApplier = new MapStateApplier(log);
			_playerApplier = new PlayerStateApplier(log);
			_enemyApplier = new EnemyStateApplier(log, enemyId);
			_pegboardApplier = new PegboardStateApplier(log, pegId);
			_deckApplier = new DeckStateApplier(log, orbId);
			_relicApplier = new RelicStateApplier(log);
			_enemyId = enemyId;
			_pegId = pegId;
			SceneManager.sceneLoaded += OnSceneLoaded;
		}

		public void Reset()
		{
			_hostScene = string.Empty;
			_hostSceneTimestamp = 0L;
			_pendingSnapshot = null;
			_pendingSnapshotScene = string.Empty;
			_latestPlayer = null;
			_latestMap = null;
			_latestFullSnapshot = null;
			_navigationTriggered = false;
			_log.LogInfo((object)"[ApplyService] State reset");
		}

		private void OnSceneLoaded(Scene scene, LoadSceneMode mode)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			if ((int)mode != 0)
			{
				return;
			}
			_log.LogInfo((object)("[ApplyService] Scene loaded: '" + ((Scene)(ref scene)).name + "' — clearing GUID registries, hostScene='" + _hostScene + "'"));
			_enemyId.Clear();
			_pegId.Clear();
			MultiplayerClientPatches.MapControllerStartCompleted = false;
			TextScenarioHoverTracker.Reset();
			MultiplayerClientPatches.AllowTextScenarioNavigation = false;
			_wasNavigating = false;
			_lastAppliedHighlightIndex = -1;
			_lastAppliedSubtitle = null;
			_lastAppliedResponses = null;
			if (MirrorEventUI.IsActive)
			{
				MirrorEventUI.Hide();
			}
			MultiplayerClientPatches.AllowShopLogic = false;
			MultiplayerClientPatches.AllowTreasureLogic = false;
			MultiplayerClientPatches.AllowPegMinigameLogic = false;
			MultiplayerClientPatches.AllowTextScenarioLogic = false;
			MultiplayerClientPatches.ClientShopPurchases.Clear();
			CoopRewardState.ClientTreasureChoiceSent = false;
			CoopRewardState.ClientPegMinigameChoiceSent = false;
			CoopRewardState.ClientTextScenarioChoiceSent = false;
			CoopRewardState.PegMinigameAwaitingHostNavigation = false;
			if (CoopNavigateState.PhaseActive)
			{
				_log.LogInfo((object)$"[ApplyService] Clearing stale CoopNavigateState (phase='{CoopNavigateState.Source}', resolved={CoopNavigateState.Resolved}) on scene '{((Scene)(ref scene)).name}'");
				CoopNavigateState.Reset();
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			IMultiplayerMode instance = null;
			services?.TryResolve<IMultiplayerMode>(out instance);
			bool flag = instance?.IsHosting ?? false;
			bool flag2 = instance?.IsSpectating ?? false;
			if (((Scene)(ref scene)).name == "ShopScenario")
			{
				CoopRewardState.AllChoicesComplete = false;
				CoopRewardState.WaitingForOtherPlayers = false;
				CoopRewardState.ShopCompletionProceeded = false;
				CoopRewardState.ClientShopChoiceSent = false;
				CoopRewardState.ShopAwaitingHostNavigation = false;
				if (flag && services.TryResolve<CoopStateManager>(out var instance2))
				{
					CoopRewardState.ShopPhaseActive = true;
					CoopRewardState.HostShopDone = false;
					CoopRewardState.ClientShopChoicesReceived.Clear();
					CoopRewardState.TotalShopClientsExpected = instance2.TotalPlayerCount - 1;
					CoopRewardState.PendingShopManager = null;
					_log.LogInfo((object)$"[ApplyService] Shop phase initialized — expecting {instance2.TotalPlayerCount - 1} client(s)");
				}
				if (flag2)
				{
					CoopRewardState.ShopPhaseActive = true;
					MultiplayerClientPatches.AllowShopLogic = true;
					MultiplayerClientPatches.AllowCurrencySync = true;
					MultiplayerClientPatches.AllowRelicSync = true;
					CurrencyManager instance3 = CurrencyManager.Instance;
					MultiplayerClientPatches.ClientShopStartGold = ((instance3 != null) ? instance3.GoldAmount : 0);
					_log.LogInfo((object)"[ApplyService] Client shop mode enabled — AllowShopLogic=true");
				}
			}
			if (((Scene)(ref scene)).name == "PegMinigame")
			{
				if (flag && services.TryResolve<CoopStateManager>(out var instance4))
				{
					CoopRewardState.PegMinigamePhaseActive = true;
					CoopRewardState.HostPegMinigameDone = false;
					CoopRewardState.ClientPegMinigameChoicesReceived.Clear();
					CoopRewardState.TotalPegMinigameClientsExpected = instance4.TotalPlayerCount - 1;
					CoopRewardState.PendingPegMinigameManager = null;
					_log.LogInfo((object)$"[ApplyService] PegMinigame phase initialized — expecting {instance4.TotalPlayerCount - 1} client(s)");
				}
				if (flag2)
				{
					CoopRewardState.PegMinigamePhaseActive = true;
					MultiplayerClientPatches.AllowPegMinigameLogic = true;
					_log.LogInfo((object)"[ApplyService] Client PegMinigame mode enabled — AllowPegMinigameLogic=true");
				}
			}
			if (((Scene)(ref scene)).name == "Treasure")
			{
				CoopRewardState.TreasureAwaitingHostNavigation = false;
				if (flag && services.TryResolve<CoopStateManager>(out var instance5))
				{
					CoopRewardState.TreasurePhaseActive = true;
					CoopRewardState.HostTreasureDone = false;
					CoopRewardState.ClientTreasureChoicesReceived.Clear();
					CoopRewardState.TotalTreasureClientsExpected = instance5.TotalPlayerCount - 1;
					CoopRewardState.PendingChestController = null;
					_log.LogInfo((object)$"[ApplyService] Treasure phase initialized — expecting {instance5.TotalPlayerCount - 1} client(s)");
					BroadcastPerSlotTreasureRelics(services, instance5);
				}
				if (flag2)
				{
					CoopRewardState.TreasurePhaseActive = true;
					MultiplayerClientPatches.AllowTreasureLogic = true;
					MultiplayerClientPatches.AllowRelicSync = true;
					_log.LogInfo((object)"[ApplyService] Client treasure mode enabled — AllowTreasureLogic=true");
				}
			}
			if (((Scene)(ref scene)).name == "TextScenario")
			{
				CoopRewardState.ClientTextScenarioChoiceSent = false;
				CoopRewardState.TextScenarioAwaitingHostNavigation = false;
				if (flag && services.TryResolve<CoopStateManager>(out var instance6))
				{
					CoopRewardState.TextScenarioPhaseActive = true;
					CoopRewardState.HostTextScenarioDone = false;
					CoopRewardState.ClientTextScenarioChoicesReceived.Clear();
					CoopRewardState.TotalTextScenarioClientsExpected = instance6.TotalPlayerCount - 1;
					CoopRewardState.PendingDialogueSystemScenario = null;
					_log.LogInfo((object)$"[ApplyService] TextScenario phase initialized — expecting {instance6.TotalPlayerCount - 1} client(s)");
				}
				if (flag2)
				{
					CoopRewardState.TextScenarioPhaseActive = true;
					MultiplayerClientPatches.AllowTextScenarioLogic = true;
					MultiplayerClientPatches.AllowCurrencySync = true;
					MultiplayerClientPatches.AllowRelicSync = true;
					_log.LogInfo((object)"[ApplyService] Client TextScenario mode enabled — AllowTextScenarioLogic=true");
				}
			}
			if (_pendingSnapshot != null && string.Equals(_pendingSnapshotScene, ((Scene)(ref scene)).name, StringComparison.OrdinalIgnoreCase))
			{
				_log.LogInfo((object)("[ApplyService] Applying PENDING snapshot for '" + ((Scene)(ref scene)).name + "' (queued while transitioning)"));
				FullGameStateSnapshot pendingSnapshot = _pendingSnapshot;
				_pendingSnapshot = null;
				_pendingSnapshotScene = string.Empty;
				IServiceContainer services2 = MultiplayerPlugin.Services;
				MainThreadDispatcher instance7;
				MainThreadDispatcher obj = ((services2 != null && services2.TryResolve<MainThreadDispatcher>(out instance7)) ? instance7 : null);
				if (obj != null)
				{
					((MonoBehaviour)obj).StartCoroutine(ApplyPendingAfterDelay(((Scene)(ref scene)).name, pendingSnapshot));
				}
			}
			else
			{
				IServiceContainer services3 = MultiplayerPlugin.Services;
				MainThreadDispatcher instance8;
				MainThreadDispatcher obj2 = ((services3 != null && services3.TryResolve<MainThreadDispatcher>(out instance8)) ? instance8 : null);
				if (obj2 != null)
				{
					((MonoBehaviour)obj2).StartCoroutine(ApplyAfterSceneLoad(((Scene)(ref scene)).name));
				}
			}
		}

		public void ApplyAll(FullGameStateSnapshot snapshot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			string text = (_hostScene = snapshot.Map?.ActiveScene ?? string.Empty);
			_hostSceneTimestamp = snapshot.TimestampMs;
			_latestFullSnapshot = snapshot;
			if (!string.Equals(name, _lastApplyClientScene, StringComparison.OrdinalIgnoreCase) || !string.Equals(text, _lastApplyHostScene, StringComparison.OrdinalIgnoreCase))
			{
				_log.LogInfo((object)("[ApplyService] ApplyAll: clientScene='" + name + "', hostScene='" + text + "', " + $"enemies={(snapshot.Enemies?.Enemies?.Count).GetValueOrDefault()}, pegs={snapshot.Pegboard?.TotalPegCount ?? 0}"));
				_lastApplyClientScene = name;
				_lastApplyHostScene = text;
			}
			try
			{
				if (string.Equals(name, text, StringComparison.OrdinalIgnoreCase))
				{
					if (snapshot.Map != null)
					{
						_latestMap = snapshot.Map;
						_mapApplier.Apply(snapshot.Map);
					}
					ApplyNonMapState(snapshot);
					return;
				}
				if (IsEventScene(text))
				{
					_log.LogInfo((object)("[ApplyService] Host on event scene '" + text + "' — applying state without scene transition"));
					if (snapshot.Map != null)
					{
						_latestMap = snapshot.Map;
						_mapApplier.Apply(snapshot.Map);
					}
					ApplyNonMapState(snapshot);
					return;
				}
				if (IsClientInteractiveScene(name))
				{
					_log.LogInfo((object)("[ApplyService] Client on interactive scene '" + name + "' (host='" + text + "') — skipping scene transition"));
					if (!MultiplayerClientPatches.AllowTextScenarioLogic)
					{
						ApplyPlayerFromSnapshot(snapshot);
					}
					return;
				}
				_pendingSnapshot = snapshot;
				_pendingSnapshotScene = text;
				_log.LogInfo((object)("[ApplyService] Queued snapshot for '" + text + "' (client on '" + name + "')"));
				if (snapshot.Map != null)
				{
					_latestMap = snapshot.Map;
					_mapApplier.Apply(snapshot.Map);
				}
				ApplyPlayerFromSnapshot(snapshot);
			}
			catch (Exception ex)
			{
				_log.LogError((object)("[ApplyService] ApplyAll failed: " + ex.Message));
			}
		}

		public void ReapplyLastMapState()
		{
			if (_latestMap?.Nodes != null && _latestMap.Nodes.Count != 0)
			{
				_log.LogInfo((object)$"[ApplyService] Re-applying {_latestMap.Nodes.Count} map nodes after MapController.Start");
				_mapApplier.Apply(_latestMap);
			}
		}

		[IteratorStateMachine(typeof(<ApplyPendingAfterDelay>d__28))]
		private IEnumerator ApplyPendingAfterDelay(string sceneName, FullGameStateSnapshot snapshot)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyPendingAfterDelay>d__28(0)
			{
				<>4__this = this,
				sceneName = sceneName,
				snapshot = snapshot
			};
		}

		[IteratorStateMachine(typeof(<ApplyAfterSceneLoad>d__29))]
		private IEnumerator ApplyAfterSceneLoad(string sceneName)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <ApplyAfterSceneLoad>d__29(0)
			{
				<>4__this = this,
				sceneName = sceneName
			};
		}

		[IteratorStateMachine(typeof(<WaitForEnemyCache>d__30))]
		private IEnumerator WaitForEnemyCache()
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <WaitForEnemyCache>d__30(0)
			{
				<>4__this = this
			};
		}

		private void ApplyNonMapState(FullGameStateSnapshot snapshot)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			bool gameStartReceived = LobbyUI.GameStartReceived;
			if (gameStartReceived && CoopRewardState.ClientInNativeRewardPhase)
			{
				_log.LogInfo((object)"[ApplyService] Skipping player/deck sync — client in native reward phase");
				return;
			}
			if (gameStartReceived && MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				_log.LogInfo((object)"[ApplyService] Skipping player/deck sync — client in TextScenario dialogue");
				return;
			}
			if (gameStartReceived && snapshot.PlayerSummaries != null && snapshot.PlayerSummaries.Count > 0)
			{
				foreach (CoopPlayerSummary playerSummary in snapshot.PlayerSummaries)
				{
					if (playerSummary.SlotIndex == 0 && !string.IsNullOrEmpty(playerSummary.PlayerName))
					{
						MapStateApplier.HostPlayerName = playerSummary.PlayerName;
						break;
					}
				}
				int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(MultiplayerPlugin.Services);
				bool flag = false;
				foreach (CoopPlayerSummary playerSummary2 in snapshot.PlayerSummaries)
				{
					if (playerSummary2.SlotIndex == localSlotIndex)
					{
						PlayerStateSnapshot myPlayerState = new PlayerStateSnapshot
						{
							ActiveSlotIndex = localSlotIndex,
							CurrentHealth = playerSummary2.CurrentHealth,
							MaxHealth = playerSummary2.MaxHealth,
							Gold = playerSummary2.Gold
						};
						if (playerSummary2.StatusEffects != null && playerSummary2.StatusEffects.Count > 0)
						{
							myPlayerState.StatusEffects = playerSummary2.StatusEffects;
						}
						if (snapshot.Player != null)
						{
							myPlayerState.IsSpedUp = snapshot.Player.IsSpedUp;
							myPlayerState.SpeedupLevel = snapshot.Player.SpeedupLevel;
						}
						SafeApply("Player(coop)", delegate
						{
							_playerApplier.Apply(myPlayerState);
						});
						flag = true;
						break;
					}
				}
				if (!flag && snapshot.Player != null)
				{
					_log.LogWarning((object)$"[ApplyService] Coop: could not find slot {localSlotIndex} in PlayerSummaries, falling back to generic Player snapshot");
					SafeApply("Player", delegate
					{
						_playerApplier.Apply(snapshot.Player);
					});
				}
			}
			else if (snapshot.Player != null)
			{
				SafeApply("Player", delegate
				{
					_playerApplier.Apply(snapshot.Player);
				});
			}
			if (name == "Battle")
			{
				if (snapshot.Enemies != null)
				{
					SafeApply("Enemies", delegate
					{
						_enemyApplier.Apply(snapshot.Enemies);
					});
				}
				if (snapshot.Pegboard != null)
				{
					SafeApply("Pegboard", delegate
					{
						_pegboardApplier.Apply(snapshot.Pegboard);
					});
				}
				if (!gameStartReceived)
				{
					if (snapshot.Deck != null)
					{
						SafeApply("Deck", delegate
						{
							_deckApplier.Apply(snapshot.Deck);
						});
					}
					if (snapshot.Relics != null)
					{
						SafeApply("Relics", delegate
						{
							_relicApplier.Apply(snapshot.Relics);
						});
					}
				}
				else
				{
					DeckStateSnapshot myDeck = null;
					RelicStateSnapshot myRelics2 = null;
					int num = -1;
					if (snapshot.AllDecks != null)
					{
						IServiceContainer services = MultiplayerPlugin.Services;
						if (services != null && services.TryResolve<PlayerRegistry>(out var instance) && instance.LocalSlot != null)
						{
							num = instance.LocalSlot.SlotIndex;
							snapshot.AllDecks.TryGetValue(num, out myDeck);
							snapshot.AllRelics?.TryGetValue(num, out myRelics2);
						}
					}
					if (myDeck != null)
					{
						string text = $"{num}|{myDeck.CompleteDeck?.Count ?? 0}|{myDeck.ShuffledOrder?.Count ?? 0}|" + ((myDeck.CompleteDeck != null) ? string.Join(",", myDeck.CompleteDeck.Select((OrbEntry o) => o.Name)) : string.Empty);
						if (text != _lastCoopDeckSig)
						{
							_lastCoopDeckSig = text;
							string text2 = ((myDeck.CompleteDeck != null) ? string.Join(", ", myDeck.CompleteDeck.Select((OrbEntry o) => o.Name)) : "NULL");
							_log.LogInfo((object)$"[ApplyService] Coop deck for mySlot={num}: {myDeck.CompleteDeck?.Count ?? 0} orbs [{text2}] shuffled={myDeck.ShuffledOrder?.Count ?? 0}");
						}
						SafeApply("Deck(coop-own)", delegate
						{
							_deckApplier.Apply(myDeck);
						});
					}
					else if (snapshot.Deck != null)
					{
						_log.LogWarning((object)$"[ApplyService] Coop: AllDecks missing slot {num}, falling back to orb-only");
						SafeApply("Deck(coop-orb-only)", delegate
						{
							_deckApplier.ApplyActiveOrbOnly(snapshot.Deck);
						});
					}
					if (myRelics2 != null)
					{
						string text3 = $"{num}|{myRelics2.OwnedRelics?.Count ?? 0}";
						if (text3 != _lastCoopRelicSig)
						{
							_lastCoopRelicSig = text3;
							_log.LogInfo((object)$"[ApplyService] Coop relics for mySlot={num}: {myRelics2.OwnedRelics?.Count ?? 0} relics");
						}
						SafeApply("Relics(coop-own)", delegate
						{
							_relicApplier.Apply(myRelics2);
						});
					}
					else if (snapshot.Relics != null)
					{
						_log.LogWarning((object)$"[ApplyService] Coop: AllRelics missing slot {num}, falling back to active-slot relics");
						SafeApply("Relics(coop-fallback)", delegate
						{
							_relicApplier.Apply(snapshot.Relics);
						});
					}
					string text4 = snapshot.Deck?.CurrentOrb;
					if (!string.IsNullOrEmpty(text4) && text4.Contains("NavigationOrb"))
					{
						SafeApply("Deck(coop-nav-orb)", delegate
						{
							_deckApplier.ApplyActiveOrbOnly(snapshot.Deck);
						});
					}
				}
				if (gameStartReceived && snapshot.TotalPlayerCount >= 2)
				{
					try
					{
						int localSlotIndex2 = CoopSlotHelper.GetLocalSlotIndex(MultiplayerPlugin.Services);
						string text5 = snapshot.Enemies?.BattleStateName ?? string.Empty;
						bool flag2 = snapshot.ActivePlayerSlot == localSlotIndex2 && (text5 == "AWAITING_SHOT" || text5 == "SPAWNING");
						_ = TurnChangeClientHandler.LatestTurnState;
						bool isMyTurn = TurnChangeClientHandler.IsMyTurn;
						if (flag2 && !isMyTurn)
						{
							_log.LogInfo((object)$"[ApplyService] Heartbeat: fixing IsMyTurn=true (slot={localSlotIndex2}, battleState={text5}, activeSlot={snapshot.ActivePlayerSlot})");
							TurnChangeClientHandler.IsMyTurn = true;
							TurnChangeClientHandler.TurnMessage = "Your turn! Aim and shoot.";
							MultiplayerClientPatches.ClientShotSentThisTurn = false;
						}
						else if (!flag2 && isMyTurn && text5 != string.Empty && text5 != "SHOULD_SPAWN")
						{
							TurnChangeClientHandler.IsMyTurn = false;
							TurnChangeClientHandler.TurnMessage = string.Empty;
						}
					}
					catch (Exception ex)
					{
						_log.LogWarning((object)("[ApplyService] Heartbeat turn sync failed: " + ex.Message));
					}
				}
				VerifyConsistency(snapshot);
				TriggerNavigationIfNeeded(snapshot);
			}
			else
			{
				if (!gameStartReceived)
				{
					if (snapshot.Deck != null)
					{
						SafeApply("Deck", delegate
						{
							_deckApplier.Apply(snapshot.Deck);
						});
					}
					if (snapshot.Relics != null)
					{
						SafeApply("Relics", delegate
						{
							_relicApplier.Apply(snapshot.Relics);
						});
					}
				}
				else if (snapshot.AllRelics != null)
				{
					int num2 = -1;
					RelicStateSnapshot myRelics = null;
					IServiceContainer services2 = MultiplayerPlugin.Services;
					if (services2 != null && services2.TryResolve<PlayerRegistry>(out var instance2) && instance2.LocalSlot != null)
					{
						num2 = instance2.LocalSlot.SlotIndex;
						snapshot.AllRelics.TryGetValue(num2, out myRelics);
					}
					if (myRelics != null)
					{
						SafeApply("Relics(coop-own-nonbattle)", delegate
						{
							_relicApplier.Apply(myRelics);
						});
					}
				}
				string text6 = $"{name}|{gameStartReceived}";
				if (text6 != _lastNonBattleSceneSig)
				{
					_lastNonBattleSceneSig = text6;
					_log.LogInfo((object)("[ApplyService] Non-battle scene '" + name + "': applied player/deck/relics, skipped enemies/pegs" + (gameStartReceived ? " (coop: own relics applied)" : string.Empty)));
				}
			}
			ApplyTextScenarioState(snapshot);
		}

		private void ApplyTextScenarioState(FullGameStateSnapshot snapshot)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			TextScenarioStateSnapshot textScenario = snapshot.TextScenario;
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			if (textScenario == null || name != "TextScenario")
			{
				_wasNavigating = false;
				_lastAppliedSubtitle = null;
				_lastAppliedResponses = null;
				return;
			}
			if (textScenario.IsActive)
			{
				ApplyDialogueText(textScenario.SubtitleText, textScenario.Responses);
				ApplyResponseHighlight(textScenario.HighlightedIndex);
			}
			if (textScenario.IsNavigating && !_wasNavigating)
			{
				_log.LogInfo((object)"[ApplyService] TextScenario navigation started — activating nav controller on client");
				ActivateClientNavigation();
			}
			_wasNavigating = textScenario.IsNavigating;
		}

		private void ApplyDialogueText(string subtitleText, List<string> responses)
		{
			try
			{
				bool flag = subtitleText != _lastAppliedSubtitle;
				bool flag2 = !ResponsesEqual(responses, _lastAppliedResponses);
				bool flag3 = !flag && !flag2 && responses != null && responses.Count > 0 && LiveButtonsDifferFrom(responses);
				if (!flag && !flag2 && !flag3)
				{
					return;
				}
				StandardDialogueUI val = Object.FindObjectOfType<StandardDialogueUI>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if (flag && !string.IsNullOrEmpty(subtitleText))
				{
					StandardUISubtitlePanel val2 = val.conversationUIElements?.defaultNPCSubtitlePanel;
					if (val2?.subtitleText != null)
					{
						val2.subtitleText.text = subtitleText;
						_lastAppliedSubtitle = subtitleText;
					}
				}
				if (!(flag2 || flag3) || responses == null)
				{
					return;
				}
				StandardUIMenuPanel val3 = val.conversationUIElements?.defaultMenuPanel;
				if (val3?.buttons == null)
				{
					return;
				}
				for (int i = 0; i < val3.buttons.Length; i++)
				{
					StandardUIResponseButton val4 = val3.buttons[i];
					if (!((Object)(object)val4 == (Object)null))
					{
						if (i < responses.Count && !string.IsNullOrEmpty(responses[i]))
						{
							((Component)val4).gameObject.SetActive(true);
							val4.text = responses[i];
						}
						else if (((Component)val4).gameObject.activeInHierarchy && val4.isVisible)
						{
							((Component)val4).gameObject.SetActive(false);
						}
					}
				}
				_lastAppliedResponses = new List<string>(responses);
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[ApplyService] ApplyDialogueText failed: " + ex.Message));
			}
		}

		private static bool ResponsesEqual(List<string> a, List<string> b)
		{
			if (a == b)
			{
				return true;
			}
			if (a == null || b == null || a.Count != b.Count)
			{
				return false;
			}
			for (int i = 0; i < a.Count; i++)
			{
				if (!string.Equals(a[i], b[i], StringComparison.Ordinal))
				{
					return false;
				}
			}
			return true;
		}

		private static bool LiveButtonsDifferFrom(List<string> responses)
		{
			StandardUIMenuPanel val = Object.FindObjectOfType<StandardDialogueUI>()?.conversationUIElements?.defaultMenuPanel;
			if (val?.buttons == null)
			{
				return false;
			}
			int num = 0;
			for (int i = 0; i < val.buttons.Length; i++)
			{
				if (num >= responses.Count)
				{
					break;
				}
				StandardUIResponseButton val2 = val.buttons[i];
				if (!((Object)(object)val2 == (Object)null) && ((Component)val2).gameObject.activeInHierarchy && val2.isVisible)
				{
					if (!string.Equals(val2.text ?? string.Empty, responses[num] ?? string.Empty, StringComparison.Ordinal))
					{
						return true;
					}
					num++;
				}
			}
			return false;
		}

		private void ApplyResponseHighlight(int highlightedIndex)
		{
			if (highlightedIndex == _lastAppliedHighlightIndex)
			{
				return;
			}
			_lastAppliedHighlightIndex = highlightedIndex;
			try
			{
				StandardDialogueUI val = Object.FindObjectOfType<StandardDialogueUI>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				StandardUIMenuPanel val2 = val.conversationUIElements?.defaultMenuPanel;
				if (val2?.buttons == null)
				{
					return;
				}
				for (int i = 0; i < val2.buttons.Length; i++)
				{
					StandardUIResponseButton val3 = val2.buttons[i];
					if (!((Object)(object)val3 == (Object)null) && ((Component)val3).gameObject.activeInHierarchy && val3.isVisible && i == highlightedIndex && (Object)(object)val3.button != (Object)null)
					{
						EventSystem current = EventSystem.current;
						if (current != null)
						{
							current.SetSelectedGameObject(((Component)val3).gameObject);
						}
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[ApplyService] ApplyResponseHighlight failed: " + ex.Message));
			}
		}

		private void ActivateClientNavigation()
		{
			try
			{
				DialogueSystemScenario val = Object.FindObjectOfType<DialogueSystemScenario>();
				if ((Object)(object)val == (Object)null)
				{
					_log.LogWarning((object)"[ApplyService] DialogueSystemScenario not found for navigation activation");
					return;
				}
				object? obj = AccessTools.Field(typeof(DialogueSystemScenario), "mainTextAnimatorCanvas")?.GetValue(val);
				object? obj2 = ((obj is CanvasGroup) ? obj : null);
				if (obj2 != null)
				{
					((Component)obj2).gameObject.SetActive(false);
				}
				if (DialogueManager.isConversationActive)
				{
					DialogueManager.StopConversation();
					_log.LogInfo((object)"[ApplyService] Stopped client conversation for navigation phase");
				}
				object? obj3 = AccessTools.Field(typeof(DialogueSystemScenario), "navController")?.GetValue(val);
				GameObject val2 = (GameObject)((obj3 is GameObject) ? obj3 : null);
				if ((Object)(object)val2 != (Object)null)
				{
					val2.SetActive(true);
					_log.LogInfo((object)"[ApplyService] Activated TextScenario navController for spectating");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[ApplyService] ActivateClientNavigation failed: " + ex.Message));
			}
		}

		public void ApplyMapState(MapStateSnapshot snapshot)
		{
			_latestMap = snapshot;
			if (!string.IsNullOrEmpty(snapshot.ActiveScene))
			{
				_hostScene = snapshot.ActiveScene;
			}
			SafeApply("Map", delegate
			{
				_mapApplier.Apply(snapshot);
			});
		}

		public void ApplyPlayerState(PlayerStateSnapshot snapshot)
		{
			_latestPlayer = snapshot;
			bool gameStartReceived = LobbyUI.GameStartReceived;
			if (gameStartReceived && CoopRewardState.ClientInNativeRewardPhase)
			{
				_log.LogInfo((object)"[ApplyService] Skipping player delta — client in native reward phase");
				return;
			}
			if (gameStartReceived && MultiplayerClientPatches.AllowTextScenarioLogic)
			{
				_log.LogInfo((object)"[ApplyService] Skipping player delta — client in TextScenario dialogue");
				return;
			}
			SafeApply("Player", delegate
			{
				_playerApplier.Apply(snapshot);
			});
		}

		public void ApplyEnemyState(EnemyStateSnapshot snapshot)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name != "Battle")
			{
				_log.LogInfo((object)"[ApplyService] Buffered enemy state (not on Battle scene)");
				return;
			}
			SafeApply("Enemies", delegate
			{
				_enemyApplier.Apply(snapshot);
			});
		}

		public void ApplyPegboardState(PegboardStateSnapshot snapshot)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name != "Battle")
			{
				_log.LogInfo((object)"[ApplyService] Buffered pegboard state (not on Battle scene)");
				return;
			}
			SafeApply("Pegboard", delegate
			{
				_pegboardApplier.Apply(snapshot);
			});
		}

		public void ApplyDeckState(DeckStateSnapshot snapshot)
		{
			SafeApply("Deck", delegate
			{
				_deckApplier.Apply(snapshot);
			});
		}

		public void ApplyRelicState(RelicStateSnapshot snapshot)
		{
			SafeApply("Relics", delegate
			{
				_relicApplier.Apply(snapshot);
			});
		}

		private void VerifyConsistency(FullGameStateSnapshot snapshot)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012d: Invalid comparison between Unknown and I4
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Invalid comparison between Unknown and I4
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name != "Battle")
				{
					return;
				}
				if (snapshot.Enemies?.Enemies != null)
				{
					int valueOrDefault = (Object.FindObjectOfType<EnemyManager>()?.Enemies?.Count).GetValueOrDefault();
					int count = snapshot.Enemies.Enemies.Count;
					if (valueOrDefault != count)
					{
						_log.LogWarning((object)$"[Consistency] ENEMY COUNT MISMATCH: host={count}, client={valueOrDefault}");
						_enemyId.DumpState("ConsistencyCheck");
					}
				}
				if (snapshot.Pegboard?.Pegs == null)
				{
					return;
				}
				BattleController obj = Object.FindObjectOfType<BattleController>();
				PegManager val = ((obj != null) ? obj.pegManager : null);
				int num = 0;
				if (((val != null) ? val.allPegs : null) != null)
				{
					foreach (Peg allPeg in val.allPegs)
					{
						if ((Object)(object)allPeg == (Object)null || !((Component)allPeg).gameObject.activeInHierarchy || (int)allPeg.pegType == 32)
						{
							continue;
						}
						try
						{
							if (!allPeg.IsDisabled())
							{
								num++;
							}
						}
						catch
						{
						}
					}
				}
				if (AccessTools.Field(typeof(PegManager), "_bombs")?.GetValue(val) is List<Bomb> list)
				{
					foreach (Bomb item in list)
					{
						if ((Object)(object)item == (Object)null || !((Component)item).gameObject.activeInHierarchy || (int)((Peg)item).pegType == 32)
						{
							continue;
						}
						try
						{
							if (!((Peg)item).IsDisabled())
							{
								num++;
							}
						}
						catch
						{
						}
					}
				}
				int num2 = 0;
				foreach (PegEntry peg in snapshot.Pegboard.Pegs)
				{
					if (!peg.IsDestroyed && !peg.IsCleared && !peg.IsParentHidden)
					{
						num2++;
					}
				}
				if (Math.Abs(num - num2) > 5)
				{
					_log.LogWarning((object)$"[Consistency] PEG COUNT MISMATCH: host_active={num2}, client_active={num}");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[Consistency] Check failed: " + ex.Message));
			}
		}

		private static bool IsEventScene(string scene)
		{
			switch (scene)
			{
			default:
				return scene == "RunSummary";
			case "ForestWinScene":
			case "CastleWinScene":
			case "FinalWinScene":
			case "CoreWinScene":
				return true;
			}
		}

		private static bool IsClientInteractiveScene(string scene)
		{
			switch (scene)
			{
			default:
				return scene == "PegMinigame";
			case "ShopScenario":
			case "Treasure":
			case "TextScenario":
				return true;
			}
		}

		private void TriggerNavigationIfNeeded(FullGameStateSnapshot snapshot)
		{
			string text = snapshot.Enemies?.BattleStateName;
			if (!(text == "NAVIGATION") && !(text == "AWAITING_POST_BATTLE_CONTROLLER"))
			{
				_navigationTriggered = false;
				_lastNavOrbApplied = null;
				return;
			}
			try
			{
				if (!_navigationTriggered)
				{
					List<int> list = snapshot.Map?.NavChildNodeTypes;
					if (list != null && list.Count > 0)
					{
						MapStateSnapshot map = snapshot.Map;
						if (map != null && map.IsNavigating)
						{
							_mapApplier.ApplyNavigationSlots(list);
						}
					}
					try
					{
						BattleController val = Object.FindObjectOfType<BattleController>();
						if ((Object)(object)val != (Object)null)
						{
							val.PreparePegsForNavigation();
							val.RemoveClearedPegs();
						}
					}
					catch
					{
					}
					_navigationTriggered = true;
					_log.LogInfo((object)$"[ApplyService] Navigation triggered: {list?.Count ?? 0} child nodes");
				}
				string text2 = snapshot.Deck?.CurrentOrb;
				if (!string.IsNullOrEmpty(text2) && text2.Contains("NavigationOrb") && text2 != _lastNavOrbApplied)
				{
					ClientBallRenderer.Instance?.OnOrbDrawn(text2);
					_lastNavOrbApplied = text2;
					_log.LogInfo((object)("[ApplyService] NavigationOrb sprite applied: " + text2));
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[ApplyService] TriggerNavigation failed: " + ex.Message));
			}
		}

		private void ApplyPlayerFromSnapshot(FullGameStateSnapshot snapshot)
		{
			if (LobbyUI.GameStartReceived && snapshot.PlayerSummaries != null && snapshot.PlayerSummaries.Count > 0)
			{
				int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(MultiplayerPlugin.Services);
				foreach (CoopPlayerSummary playerSummary in snapshot.PlayerSummaries)
				{
					if (playerSummary.SlotIndex == localSlotIndex)
					{
						PlayerStateSnapshot myPlayerState = new PlayerStateSnapshot
						{
							ActiveSlotIndex = localSlotIndex,
							CurrentHealth = playerSummary.CurrentHealth,
							MaxHealth = playerSummary.MaxHealth,
							Gold = playerSummary.Gold
						};
						if (playerSummary.StatusEffects != null && playerSummary.StatusEffects.Count > 0)
						{
							myPlayerState.StatusEffects = playerSummary.StatusEffects;
						}
						if (snapshot.Player != null)
						{
							myPlayerState.IsSpedUp = snapshot.Player.IsSpedUp;
							myPlayerState.SpeedupLevel = snapshot.Player.SpeedupLevel;
						}
						SafeApply("Player(coop-xscene)", delegate
						{
							_playerApplier.Apply(myPlayerState);
						});
						return;
					}
				}
			}
			if (snapshot.Player != null)
			{
				SafeApply("Player", delegate
				{
					_playerApplier.Apply(snapshot.Player);
				});
			}
		}

		private void SafeApply(string name, Action action)
		{
			try
			{
				action();
			}
			catch (Exception ex)
			{
				_log.LogError((object)("[ApplyService] " + name + " failed: " + ex.Message));
			}
		}

		private void BroadcastPerSlotTreasureRelics(IServiceContainer svc, CoopStateManager coopMgr)
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0180: Unknown result type (might be due to invalid IL or missing references)
			//IL_0188: Unknown result type (might be due to invalid IL or missing references)
			//IL_0192: Expected I4, but got Unknown
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_029b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a2: Expected I4, but got Unknown
			//IL_01d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Expected I4, but got Unknown
			try
			{
				if (svc == null || coopMgr == null || !svc.TryResolve<IGameEventRegistry>(out var instance) || instance == null)
				{
					return;
				}
				Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
				if (array == null || array.Length == 0)
				{
					_log.LogWarning((object)"[ApplyService] BroadcastPerSlotTreasureRelics: no relics loaded");
					return;
				}
				MapData dataToLoad = StaticGameData.dataToLoad;
				MapDataTreasure val = (MapDataTreasure)(object)((dataToLoad is MapDataTreasure) ? dataToLoad : null);
				float num = (((Object)(object)val != (Object)null) ? val.rareChance : RelicManager.CHEST_RARE_CHANCE);
				CoopRewardState.PerSlotTreasureRelics.Clear();
				foreach (KeyValuePair<int, CoopPlayerState> playerState in coopMgr.PlayerStates)
				{
					int key = playerState.Key;
					CoopPlayerState value = playerState.Value;
					if (value == null)
					{
						continue;
					}
					Random random = new Random((StaticGameData.currentSeed ?? string.Empty).GetHashCode() ^ (key * 7919) ^ (StaticGameData.totalFloorCount * 104729));
					bool flag = SlotHasRelicEffect(value, (RelicEffect)119);
					float num2 = num + (flag ? 0.1f : 0f);
					RelicRarity val2 = (RelicRarity)((!(random.NextDouble() <= (double)num2)) ? 1 : 2);
					HashSet<int> hashSet = new HashSet<int>();
					if (value.OwnedRelics != null)
					{
						foreach (SerializedRelic ownedRelic in value.OwnedRelics)
						{
							if (ownedRelic != null)
							{
								hashSet.Add(ownedRelic.Effect);
							}
						}
					}
					List<Relic> list = new List<Relic>();
					Relic[] array2 = array;
					foreach (Relic val3 in array2)
					{
						if (!((Object)(object)val3 == (Object)null) && val3.globalRarity == val2 && !hashSet.Contains((int)val3.effect))
						{
							list.Add(val3);
						}
					}
					if (list.Count == 0)
					{
						array2 = array;
						foreach (Relic val4 in array2)
						{
							if (!((Object)(object)val4 == (Object)null) && !hashSet.Contains((int)val4.effect))
							{
								list.Add(val4);
							}
						}
					}
					if (list.Count != 0)
					{
						list.Sort((Relic a, Relic b) => string.CompareOrdinal((a != null) ? ((Object)a).name : null, (b != null) ? ((Object)b).name : null));
						Relic val5 = list[random.Next(0, list.Count)];
						CoopRewardState.PerSlotTreasureRelics[key] = ((Object)val5).name;
						_log.LogInfo((object)$"[ApplyService] Per-slot treasure relic slot={key} rarity={val2} relic='{((Object)val5).name}'");
						if (key != 0)
						{
							instance.Dispatch(new CoopTreasureRelicChoiceEvent
							{
								TargetSlotIndex = key,
								RelicName = ((Object)val5).name,
								Rarity = (int)val2
							});
						}
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[ApplyService] BroadcastPerSlotTreasureRelics failed: " + ex.Message));
			}
		}

		private static bool SlotHasRelicEffect(CoopPlayerState state, RelicEffect effect)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between I4 and Unknown
			if (state?.OwnedRelics == null)
			{
				return false;
			}
			foreach (SerializedRelic ownedRelic in state.OwnedRelics)
			{
				if (ownedRelic != null && ownedRelic.Effect == (int)effect)
				{
					return true;
				}
			}
			return false;
		}
	}
	public class GameStateSyncService : IGameStateSyncService
	{
		private readonly ManualLogSource _log;

		private readonly IGameEventRegistry _registry;

		private readonly IMultiplayerMode _mode;

		private readonly MapStateProvider _mapProvider;

		private readonly PlayerStateProvider _playerProvider;

		private readonly EnemyStateProvider _enemyProvider;

		private readonly PegboardStateProvider _pegboardProvider;

		private readonly DeckStateProvider _deckProvider;

		private readonly RelicStateProvider _relicProvider;

		private readonly CoopStateManager _coopStateManager;

		private readonly TextScenarioStateProvider _textScenarioProvider;

		private bool _mirrorEventDispatched;

		public GameStateSyncService(ManualLogSource log, IGameEventRegistry registry, IMultiplayerMode mode, EnemyIdentifier enemyId, PegIdentifier pegId, OrbIdentifier orbId, CoopStateManager coopStateManager = null)
		{
			_log = log;
			_registry = registry;
			_mode = mode;
			_mapProvider = new MapStateProvider(log);
			_playerProvider = new PlayerStateProvider(log);
			_enemyProvider = new EnemyStateProvider(log, enemyId);
			_pegboardProvider = new PegboardStateProvider(log, pegId);
			_deckProvider = new DeckStateProvider(log, orbId);
			_relicProvider = new RelicStateProvider(log);
			_textScenarioProvider = new TextScenarioStateProvider(log);
			_coopStateManager = coopStateManager;
		}

		public void SyncAll(string trigger = null)
		{
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			if (!_mode.IsHosting)
			{
				return;
			}
			string text = (string.IsNullOrEmpty(trigger) ? string.Empty : ("[" + trigger + "] "));
			try
			{
				int activeSlotIndex = _coopStateManager?.ActivePlayerSlot ?? 0;
				FullGameStateSnapshot fullGameStateSnapshot = new FullGameStateSnapshot
				{
					TimestampMs = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds(),
					Map = _mapProvider.Capture(),
					Player = _playerProvider.Capture(),
					Deck = _deckProvider.Capture(),
					Relics = _relicProvider.Capture(),
					Enemies = _enemyProvider.Capture(),
					Pegboard = _pegboardProvider.Capture(),
					TextScenario = _textScenarioProvider.Capture()
				};
				if (fullGameStateSnapshot.Player != null)
				{
					fullGameStateSnapshot.Player.ActiveSlotIndex = activeSlotIndex;
				}
				if (fullGameStateSnapshot.Deck != null)
				{
					fullGameStateSnapshot.Deck.ActiveSlotIndex = activeSlotIndex;
				}
				if (fullGameStateSnapshot.Relics != null)
				{
					fullGameStateSnapshot.Relics.ActiveSlotIndex = activeSlotIndex;
				}
				if (_coopStateManager != null && _coopStateManager.TotalPlayerCount > 0)
				{
					fullGameStateSnapshot.ActivePlayerSlot = _coopStateManager.ActivePlayerSlot;
					fullGameStateSnapshot.TotalPlayerCount = _coopStateManager.TotalPlayerCount;
					fullGameStateSnapshot.PlayerSummaries = new List<CoopPlayerSummary>();
					fullGameStateSnapshot.AllDecks = new Dictionary<int, DeckStateSnapshot>();
					fullGameStateSnapshot.AllRelics = new Dictionary<int, RelicStateSnapshot>();
					foreach (KeyValuePair<int, CoopPlayerState> playerState in _coopStateManager.PlayerStates)
					{
						CoopPlayerState value = playerState.Value;
						bool flag = playerState.Key == _coopStateManager.ActivePlayerSlot;
						CoopPlayerSummary coopPlayerSummary = new CoopPlayerSummary
						{
							SlotIndex = value.SlotIndex,
							PlayerName = value.PlayerName,
							ChosenClass = value.ChosenClass,
							CurrentHealth = ((!flag) ? value.CurrentHealth : (fullGameStateSnapshot.Player?.CurrentHealth ?? value.CurrentHealth)),
							MaxHealth = ((!flag) ? value.MaxHealth : (fullGameStateSnapshot.Player?.MaxHealth ?? value.MaxHealth)),
							Gold = ((!flag) ? value.Gold : (fullGameStateSnapshot.Player?.Gold ?? value.Gold)),
							HasShotThisRound = value.HasShotThisRound
						};
						if (flag && fullGameStateSnapshot.Player?.StatusEffects != null)
						{
							coopPlayerSummary.StatusEffects = fullGameStateSnapshot.Player.StatusEffects;
						}
						else if (value.StatusEffects != null)
						{
							coopPlayerSummary.StatusEffects = value.StatusEffects.ConvertAll(delegate(SerializedStatusEffect e)
							{
								//IL_0018: Unknown result type (might be due to invalid IL or missing references)
								StatusEffectEntry obj2 = new StatusEffectEntry
								{
									EffectType = e.EffectType
								};
								StatusEffectType val2 = (StatusEffectType)e.EffectType;
								obj2.EffectName = ((object)(StatusEffectType)(ref val2)).ToString();
								obj2.Intensity = e.Intensity;
								return obj2;
							});
						}
						fullGameStateSnapshot.PlayerSummaries.Add(coopPlayerSummary);
						if (flag)
						{
							fullGameStateSnapshot.AllDecks[playerState.Key] = fullGameStateSnapshot.Deck;
						}
						else
						{
							fullGameStateSnapshot.AllDecks[playerState.Key] = new DeckStateSnapshot
							{
								ActiveSlotIndex = playerState.Key,
								DeckSize = (value.CompleteDeck?.Count ?? 0),
								CompleteDeck = (value.CompleteDeck?.Select((SerializedOrb o) => new OrbEntry
								{
									Name = o.PrefabName,
									Guid = o.Guid,
									Level = o.Level
								}).ToList() ?? new List<OrbEntry>()),
								BattleDeck = (value.BattleDeck?.Select((SerializedOrb o) => new OrbEntry
								{
									Name = o.PrefabName,
									Guid = o.Guid,
									Level = o.Level
								}).ToList() ?? new List<OrbEntry>()),
								ShuffledOrder = (value.ShuffledOrder ?? new List<string>()),
								CurrentOrb = null,
								CurrentOrbLevel = 0
							};
						}
						if (flag)
						{
							fullGameStateSnapshot.AllRelics[playerState.Key] = fullGameStateSnapshot.Relics;
							continue;
						}
						RelicStateSnapshot relicStateSnapshot = new RelicStateSnapshot
						{
							ActiveSlotIndex = playerState.Key,
							TotalRelicCount = (value.OwnedRelics?.Count ?? 0)
						};
						if (value.OwnedRelics != null)
						{
							foreach (SerializedRelic ownedRelic in value.OwnedRelics)
							{
								int value2 = 0;
								int value3 = 0;
								int value4 = 0;
								int value5 = 0;
								value.RelicCountdowns?.TryGetValue(ownedRelic.Effect, out value2);
								value.RelicUsesPerShot?.TryGetValue(ownedRelic.Effect, out value3);
								value.RelicUsesPerBattle?.TryGetValue(ownedRelic.Effect, out value4);
								value.RelicUsesPerRun?.TryGetValue(ownedRelic.Effect, out value5);
								List<RelicEntry> ownedRelics = relicStateSnapshot.OwnedRelics;
								RelicEntry obj = new RelicEntry
								{
									Effect = ownedRelic.Effect
								};
								RelicEffect val = (RelicEffect)ownedRelic.Effect;
								obj.EffectName = ((object)(RelicEffect)(ref val)).ToString();
								obj.LocKey = ownedRelic.LocKey ?? string.Empty;
								obj.Rarity = ownedRelic.Rarity;
								obj.RemainingCountdown = value2;
								obj.RemainingUsesPerShot = value3;
								obj.RemainingUsesPerBattle = value4;
								obj.RemainingUsesPerRun = value5;
								obj.IsEnabled = true;
								ownedRelics.Add(obj);
							}
						}
						fullGameStateSnapshot.AllRelics[playerState.Key] = relicStateSnapshot;
					}
				}
				if (fullGameStateSnapshot.PlayerSummaries != null)
				{
					foreach (CoopPlayerSummary playerSummary in fullGameStateSnapshot.PlayerSummaries)
					{
						_log.LogInfo((object)$"{text}Player slot={playerSummary.SlotIndex} name={playerSummary.PlayerName} class={playerSummary.ChosenClass} hp={playerSummary.CurrentHealth}/{playerSummary.MaxHealth} gold={playerSummary.Gold} isHost={playerSummary.SlotIndex == 0}");
					}
				}
				if (fullGameStateSnapshot.AllDecks != null)
				{
					foreach (KeyValuePair<int, DeckStateSnapshot> allDeck in fullGameStateSnapshot.AllDecks)
					{
						List<OrbEntry> list = allDeck.Value?.CompleteDeck;
						string text2 = ((list != null) ? string.Join(", ", list.Select((OrbEntry o) => o.Name)) : "NULL");
						_log.LogInfo((object)$"{text}AllDecks[{allDeck.Key}]: {list?.Count ?? 0} orbs [{text2}] shuffled={(allDeck.Value?.ShuffledOrder?.Count).GetValueOrDefault()} active={allDeck.Key == fullGameStateSnapshot.ActivePlayerSlot}");
					}
				}
				TextScenarioStateSnapshot textScenario = fullGameStateSnapshot.TextScenario;
				if (textScenario != null && textScenario.IsMirrorEvent && !_mirrorEventDispatched)
				{
					_mirrorEventDispatched = true;
					_log.LogInfo((object)(text + "Mirror event detected — clients handle natively via AllowTextScenarioLogic"));
				}
				else
				{
					TextScenarioStateSnapshot textScenario2 = fullGameStateSnapshot.TextScenario;
					if (textScenario2 == null || !textScenario2.IsMirrorEvent)
					{
						_mirrorEventDispatched = false;
					}
				}
				_registry.Dispatch(fullGameStateSnapshot);
				_log.LogInfo((object)$"{text}SyncAll: sent full state (map={fullGameStateSnapshot.Map?.ActiveScene}, enemies={(fullGameStateSnapshot.Enemies?.Enemies?.Count).GetValueOrDefault()}, pegs={fullGameStateSnapshot.Pegboard?.TotalPegCount ?? 0}, players={fullGameStateSnapshot.TotalPlayerCount})");
				if (trigger == null || !trigger.StartsWith("HEARTBEAT"))
				{
					DiagnosticLogger.DumpBattleState("HOST_SyncAll");
				}
			}
			catch (Exception ex)
			{
				_log.LogError((object)(text + "SyncAll failed: " + ex.Message));
			}
		}

		public void SyncMap()
		{
			if (_mode.IsHosting)
			{
				MapStateSnapshot mapStateSnapshot = _mapProvider.Capture();
				if (mapStateSnapshot != null)
				{
					_registry.Dispatch(mapStateSnapshot);
				}
				_log.LogInfo((object)$"SyncMap: scene={mapStateSnapshot?.ActiveScene}, floor={mapStateSnapshot?.TotalFloorCount}");
			}
		}

		public void SyncPegboard()
		{
			if (_mode.IsHosting)
			{
				PegboardStateSnapshot pegboardStateSnapshot = _pegboardProvider.Capture();
				if (pegboardStateSnapshot != null)
				{
					_registry.Dispatch(pegboardStateSnapshot);
				}
				_log.LogInfo((object)$"SyncPegboard: {pegboardStateSnapshot?.TotalPegCount} pegs ({pegboardStateSnapshot?.CritPegCount} crit, {pegboardStateSnapshot?.BombPegCount} bomb, {pegboardStateSnapshot?.ResetPegCount} reset)");
			}
		}

		public void SyncEnemies()
		{
			if (_mode.IsHosting)
			{
				EnemyStateSnapshot enemyStateSnapshot = _enemyProvider.Capture();
				if (enemyStateSnapshot != null)
				{
					_registry.Dispatch(enemyStateSnapshot);
				}
				_log.LogInfo((object)$"SyncEnemies: {(enemyStateSnapshot?.Enemies?.Count).GetValueOrDefault()} enemies, battleState={enemyStateSnapshot?.BattleStateName}");
			}
		}

		public void SyncPlayer()
		{
			if (_mode.IsHosting)
			{
				PlayerStateSnapshot playerStateSnapshot = _playerProvider.Capture();
				if (playerStateSnapshot != null)
				{
					_registry.Dispatch(playerStateSnapshot);
				}
				_log.LogInfo((object)$"SyncPlayer: hp={playerStateSnapshot?.CurrentHealth}/{playerStateSnapshot?.MaxHealth}, gold={playerStateSnapshot?.Gold}, effects={(playerStateSnapshot?.StatusEffects?.Count).GetValueOrDefault()}");
			}
		}

		public void SyncDeck()
		{
			if (_mode.IsHosting)
			{
				DeckStateSnapshot deckStateSnapshot = _deckProvider.Capture();
				if (deckStateSnapshot != null)
				{
					_registry.Dispatch(deckStateSnapshot);
				}
				_log.LogInfo((object)$"SyncDeck: {deckStateSnapshot?.DeckSize} orbs in complete deck, {(deckStateSnapshot?.BattleDeck?.Count).GetValueOrDefault()} in battle deck");
			}
		}

		public void SyncRelics()
		{
			if (_mode.IsHosting)
			{
				RelicStateSnapshot relicStateSnapshot = _relicProvider.Capture();
				if (relicStateSnapshot != null)
				{
					_registry.Dispatch(relicStateSnapshot);
				}
				_log.LogInfo((object)$"SyncRelics: {relicStateSnapshot?.TotalRelicCount} relics");
			}
		}
	}
	public class HostBallSync : MonoBehaviour
	{
		private const float SendInterval = 0.05f;

		private float _lastSendTime;

		private bool _hadBallsLastTick;

		private IGameEventRegistry _registry;

		private IMultiplayerMode _mode;

		private BallIdentifier _ballId;

		private BallStateProvider _provider;

		private void Start()
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null)
			{
				services.TryResolve<IGameEventRegistry>(out _registry);
				services.TryResolve<IMultiplayerMode>(out _mode);
				services.TryResolve<BallIdentifier>(out _ballId);
				if (_ballId != null)
				{
					_provider = new BallStateProvider(MultiplayerPlugin.Logger, _ballId);
				}
			}
		}

		private void Update()
		{
			if (_registry == null || _mode == null || _provider == null)
			{
				Start();
				if (_registry == null || _mode == null || _provider == null)
				{
					return;
				}
			}
			if (_mode.IsHosting && !(Time.time - _lastSendTime < 0.05f))
			{
				_lastSendTime = Time.time;
				BallStateSnapshot ballStateSnapshot = _provider.Capture();
				bool flag = ballStateSnapshot.Balls.Count > 0;
				if (flag || _hadBallsLastTick)
				{
					_registry.Dispatch(ballStateSnapshot);
					_hadBallsLastTick = flag;
				}
				if (!flag)
				{
					_ballId.PruneDestroyed();
				}
			}
		}
	}
	public interface IGameStateApplier<TState> where TState : class
	{
		void Apply(TState snapshot);
	}
	public interface IGameStateProvider<TState> where TState : class
	{
		TState Capture();
	}
	public interface IGameStateSyncService
	{
		void SyncAll(string trigger = null);

		void SyncMap();

		void SyncPegboard();

		void SyncEnemies();

		void SyncPlayer();

		void SyncDeck();

		void SyncRelics();
	}
	public class RemoteCursorRenderer : MonoBehaviour
	{
		private class CursorVisual
		{
			public GameObject Root;

			public RectTransform Rect;

			public Vector2 TargetWorld;

			public Vector2 ScreenPos;

			public float LastUpdateTime;

			public bool Seeded;
		}

		private const float SmoothRate = 15f;

		private const float StaleTimeout = 5f;

		private const float Alpha = 0.5f;

		private const float HotspotX = 16f;

		private const float HotspotY = 4f;

		private readonly Dictionary<int, CursorVisual> _visuals = new Dictionary<int, CursorVisual>();

		private Canvas _canvas;

		private IMultiplayerMode _mode;

		public static RemoteCursorRenderer Instance { get; private set; }

		private void Awake()
		{
			Instance = this;
		}

		private void Start()
		{
			MultiplayerPlugin.Services?.TryResolve<IMultiplayerMode>(out _mode);
			EnsureCanvas();
		}

		private void OnDestroy()
		{
			if ((Object)(object)Instance == (Object)(object)this)
			{
				Instance = null;
			}
		}

		public void SetRemoteCursor(int slotIndex, float worldX, float worldY)
		{
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			if (!_visuals.TryGetValue(slotIndex, out var value))
			{
				value = CreateVisual(slotIndex);
				_visuals[slotIndex] = value;
			}
			value.TargetWorld = new Vector2(worldX, worldY);
			value.LastUpdateTime = Time.unscaledTime;
			if ((Object)(object)value.Root != (Object)null && !value.Root.activeSelf)
			{
				value.Root.SetActive(true);
			}
		}

		public void ClearAll()
		{
			foreach (CursorVisual value in _visuals.Values)
			{
				if ((Object)(object)value?.Root != (Object)null)
				{
					Object.Destroy((Object)(object)value.Root);
				}
			}
			_visuals.Clear();
		}

		private void Update()
		{
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fe: Unknown result type (might be due to invalid IL or missing references)
			//IL_0103: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: 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_017a: Unknown result type (might be due to invalid IL or missing references)
			//IL_017d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: 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_0162: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ab: Unknown result type (might be due to invalid IL or missing references)
			if (_mode == null || (!_mode.IsHosting && !_mode.IsSpectating))
			{
				if (_visuals.Count > 0)
				{
					ClearAll();
				}
				return;
			}
			Camera main = Camera.main;
			float unscaledTime = Time.unscaledTime;
			float num = 1f - Mathf.Exp(-15f * Time.unscaledDeltaTime);
			Vector2 val2 = default(Vector2);
			foreach (KeyValuePair<int, CursorVisual> visual in _visuals)
			{
				CursorVisual value = visual.Value;
				if ((Object)(object)value?.Root == (Object)null)
				{
					continue;
				}
				if (unscaledTime - value.LastUpdateTime > 5f)
				{
					if (value.Root.activeSelf)
					{
						value.Root.SetActive(false);
					}
				}
				else
				{
					if ((Object)(object)main == (Object)null)
					{
						continue;
					}
					Vector3 val = main.WorldToScreenPoint(new Vector3(value.TargetWorld.x, value.TargetWorld.y, 0f));
					if (val.z < 0f)
					{
						value.Root.SetActive(false);
						continue;
					}
					if (!value.Root.activeSelf)
					{
						value.Root.SetActive(true);
					}
					((Vector2)(ref val2))..ctor(val.x, val.y);
					if (!value.Seeded)
					{
						value.ScreenPos = val2;
						value.Seeded = true;
					}
					else
					{
						value.ScreenPos = Vector2.Lerp(value.ScreenPos, val2, num);
					}
					((Transform)value.Rect).position = new Vector3(value.ScreenPos.x, value.ScreenPos.y, 0f);
				}
			}
		}

		private void EnsureCanvas()
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Expected O, but got Unknown
			if (!((Object)(object)_canvas != (Object)null))
			{
				GameObject val = new GameObject("RemoteCursorCanvas")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)(object)val);
				val.transform.SetParent(((Component)this).transform, false);
				_canvas = val.AddComponent<Canvas>();
				_canvas.renderMode = (RenderMode)0;
				_canvas.sortingOrder = 32000;
				val.AddComponent<CanvasScaler>();
				((Behaviour)val.AddComponent<GraphicRaycaster>()).enabled = false;
			}
		}

		private CursorVisual CreateVisual(int slotIndex)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Expected O, but got Unknown
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0065: Unknown result type (might be due to invalid IL or missing references)
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0074: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Expected O, but got Unknown
			//IL_00af: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0183: Unknown result type (might be due to invalid IL or missing references)
			//IL_0199: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Unknown result type (might be due to invalid IL or missing references)
			//IL_014d: 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_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_0235: Unknown result type (might be due to invalid IL or missing references)
			//IL_0249: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			EnsureCanvas();
			GameObject val = new GameObject($"RemoteCursor_Slot{slotIndex}");
			val.transform.SetParent(((Component)_canvas).transform, false);
			RectTransform val2 = val.AddComponent<RectTransform>();
			val2.sizeDelta = new Vector2(32f, 32f);
			val2.pivot = new Vector2(0.5f, 0.5f);
			Color color = WithAlpha(SlotColor(slotIndex), 0.5f);
			Texture2D val3 = FindNormalCursorTexture();
			GameObject val4 = new GameObject("Icon");
			val4.transform.SetParent(val.transform, false);
			RectTransform val5 = val4.AddComponent<RectTransform>();
			val5.anchorMin = new Vector2(0.5f, 0.5f);
			val5.anchorMax = new Vector2(0.5f, 0.5f);
			val5.anchoredPosition = Vector2.zero;
			if ((Object)(object)val3 != (Object)null)
			{
				int width = ((Texture)val3).width;
				int height = ((Texture)val3).height;
				val5.sizeDelta = new Vector2((float)width, (float)height);
				val5.pivot = new Vector2(16f / (float)width, 1f - 4f / (float)height);
				Sprite sprite = Sprite.Create(val3, new Rect(0f, 0f, (float)width, (float)height), new Vector2(0.5f, 0.5f));
				Image obj = val4.AddComponent<Image>();
				obj.sprite = sprite;
				((Graphic)obj).color = color;
				((Graphic)obj).raycastTarget = false;
			}
			else
			{
				val5.sizeDelta = new Vector2(40f, 40f);
				val5.pivot = new Vector2(0f, 1f);
				((Transform)val5).localEulerAngles = new Vector3(0f, 0f, 45f);
				TextMeshProUGUI obj2 = val4.AddComponent<TextMeshProUGUI>();
				((TMP_Text)obj2).text = "◀";
				((TMP_Text)obj2).fontSize = 36f;
				((TMP_Text)obj2).alignment = (TextAlignmentOptions)514;
				((Graphic)obj2).raycastTarget = false;
				((Graphic)obj2).color = color;
			}
			GameObject val6 = new GameObject("Label");
			val6.transform.SetParent(val.transform, false);
			RectTransform obj3 = val6.AddComponent<RectTransform>();
			obj3.sizeDelta = new Vector2(40f, 24f);
			obj3.pivot = new Vector2(1f, 0.5f);
			obj3.anchoredPosition = new Vector2(-4f, -17f);
			TextMeshProUGUI obj4 = val6.AddComponent<TextMeshProUGUI>();
			((TMP_Text)obj4).text = (slotIndex + 1).ToString();
			((TMP_Text)obj4).fontSize = 22f;
			((TMP_Text)obj4).fontStyle = (FontStyles)1;
			((TMP_Text)obj4).alignment = (TextAlignmentOptions)4100;
			((Graphic)obj4).raycastTarget = false;
			((Graphic)obj4).color = color;
			((TMP_Text)obj4).outlineWidth = 0.2f;
			((TMP_Text)obj4).outlineColor = new Color32((byte)0, (byte)0, (byte)0, (byte)127);
			return new CursorVisual
			{
				Root = val,
				Rect = val2
			};
		}

		private static Texture2D FindNormalCursorTexture()
		{
			try
			{
				CursorManagement[] array = Resources.FindObjectsOfTypeAll<CursorManagement>();
				for (int i = 0; i < array.Length; i++)
				{
					Texture2D val = array[i]?.normalCursor;
					if ((Object)(object)val != (Object)null)
					{
						return val;
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static Color WithAlpha(Color c, float a)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			c.a = a;
			return c;
		}

		private static Color SlotColor(int slot)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: 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_0083: Unknown result type (might be due to invalid IL or missing references)
			//IL_0098: Unknown result type (might be due to invalid IL or missing references)
			return (Color)((slot % 6) switch
			{
				0 => new Color(1f, 1f, 1f), 
				1 => new Color(0.35f, 0.85f, 1f), 
				2 => new Color(1f, 0.7f, 0.3f), 
				3 => new Color(0.55f, 1f, 0.55f), 
				4 => new Color(1f, 0.55f, 0.85f), 
				_ => new Color(1f, 1f, 0.4f), 
			});
		}
	}
	public static class TextScenarioHoverTracker
	{
		public static int CurrentHoveredIndex = -1;

		public static bool IsNavigating;

		public static void Reset()
		{
			CurrentHoveredIndex = -1;
			IsNavigating = false;
		}
	}
	public enum TurnPhase
	{
		WAITING_FOR_PLAYERS,
		PLAYER_AIMING,
		SHOT_IN_FLIGHT,
		ALL_DONE,
		DAMAGE_PHASE
	}
	public class TurnManager
	{
		private readonly ManualLogSource _log;

		private readonly CoopStateManager _coopState;

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


		public int CurrentTurnIndex { get; private set; }

		public TurnPhase Phase { get; private set; }

		public int RoundNumber { get; private set; }

		public int CurrentPlayerSlot
		{
			get
			{
				if (TurnOrder.Count <= 0 || CurrentTurnIndex < 0 || CurrentTurnIndex >= TurnOrder.Count)
				{
					return -1;
				}
				return TurnOrder[CurrentTurnIndex];
			}
		}

		public bool AllPlayersHaveShot
		{
			get
			{
				if (TurnOrder.Count > 0)
				{
					return TurnOrder.All((int slot) => _coopState.GetPlayerState(slot)?.HasShotThisRound ?? false);
				}
				return false;
			}
		}

		public static TurnSnapshot LatestSnapshot { get; private set; }

		public TurnManager(ManualLogSource log, CoopStateManager coopState)
		{
			_log = log;
			_coopState = coopState;
		}

		public void BuildTurnOrder()
		{
			TurnOrder = _coopState.PlayerStates.Keys.OrderBy((int k) => k).ToList();
			_log.LogInfo((object)("[TurnManager] Built turn order: [" + string.Join(", ", TurnOrder) + "]"));
		}

		public void StartNewRound()
		{
			if (TurnOrder.Count == 0)
			{
				BuildTurnOrder();
			}
			RoundNumber++;
			CurrentTurnIndex = 0;
			foreach (int item in TurnOrder)
			{
				CoopPlayerState playerState = _coopState.GetPlayerState(item);
				if (playerState != null)
				{
					playerState.HasShotThisRound = false;
				}
			}
			while (CurrentTurnIndex < TurnOrder.Count)
			{
				CoopPlayerState playerState2 = _coopState.GetPlayerState(TurnOrder[CurrentTurnIndex]);
				if (playerState2 == null || !(playerState2.CurrentHealth <= 0f))
				{
					break;
				}
				_log.LogInfo((object)$"[TurnManager] Skipping dead player slot {TurnOrder[CurrentTurnIndex]} at round start");
				playerState2.HasShotThisRound = true;
				CurrentTurnIndex++;
			}
			if (CurrentTurnIndex >= TurnOrder.Count)
			{
				Phase = TurnPhase.ALL_DONE;
				UpdateSnapshot();
				_log.LogInfo((object)$"[TurnManager] Round {RoundNumber}: all players dead, skipping to ALL_DONE");
			}
			else
			{
				Phase = TurnPhase.PLAYER_AIMING;
				UpdateSnapshot();
				_log.LogInfo((object)$"[TurnManager] Round {RoundNumber} started. First turn: slot {CurrentPlayerSlot}");
			}
		}

		public void MarkShotFired()
		{
			int currentPlayerSlot = CurrentPlayerSlot;
			if (currentPlayerSlot >= 0)
			{
				CoopPlayerState playerState = _coopState.GetPlayerState(currentPlayerSlot);
				if (playerState != null)
				{
					playerState.HasShotThisRound = true;
				}
				Phase = TurnPhase.SHOT_IN_FLIGHT;
				UpdateSnapshot();
				_log.LogInfo((object)$"[TurnManager] Slot {currentPlayerSlot} shot fired, phase -> SHOT_IN_FLIGHT");
			}
		}

		public void AdvanceTurn()
		{
			CurrentTurnIndex++;
			while (CurrentTurnIndex < TurnOrder.Count)
			{
				CoopPlayerState playerState = _coopState.GetPlayerState(TurnOrder[CurrentTurnIndex]);
				if (playerState == null || !(playerState.CurrentHealth <= 0f))
				{
					break;
				}
				_log.LogInfo((object)$"[TurnManager] Skipping dead player slot {TurnOrder[CurrentTurnIndex]} (hp={playerState.CurrentHealth})");
				playerState.HasShotThisRound = true;
				CurrentTurnIndex++;
			}
			if (CurrentTurnIndex >= TurnOrder.Count)
			{
				Phase = TurnPhase.ALL_DONE;
				UpdateSnapshot();
				_log.LogInfo((object)"[TurnManager] All players have shot. Phase -> ALL_DONE");
			}
			else
			{
				Phase = TurnPhase.PLAYER_AIMING;
				UpdateSnapshot();
				_log.LogInfo((object)$"[TurnManager] Advanced to slot {CurrentPlayerSlot} (index {CurrentTurnIndex}/{TurnOrder.Count})");
			}
		}

		public void EnterDamagePhase()
		{
			Phase = TurnPhase.DAMAGE_PHASE;
			UpdateSnapshot();
			_log.LogInfo((object)"[TurnManager] Phase -> DAMAGE_PHASE");
		}

		public bool IsSlotsTurn(int slotIndex)
		{
			if (Phase == TurnPhase.PLAYER_AIMING)
			{
				return CurrentPlayerSlot == slotIndex;
			}
			return false;
		}

		public bool IsLocalPlayerTurn(bool isHost)
		{
			if (Phase != TurnPhase.PLAYER_AIMING)
			{
				return false;
			}
			if (isHost)
			{
				return CurrentPlayerSlot == 0;
			}
			return false;
		}

		public bool RemovePlayer(int slotIndex)
		{
			int currentTurnIndex = CurrentTurnIndex;
			TurnPhase phase = Phase;
			int count = TurnOrder.Count;
			int currentPlayerSlot = CurrentPlayerSlot;
			int num = TurnOrder.IndexOf(slotIndex);
			if (num < 0)
			{
				_log.LogInfo((object)string.Format("[TurnManager] RemovePlayer: slot {0} not in TurnOrder [{1}], no-op", slotIndex, string.Join(", ", TurnOrder)));
				return false;
			}
			bool flag = num == CurrentTurnIndex && (Phase == TurnPhase.PLAYER_AIMING || Phase == TurnPhase.SHOT_IN_FLIGHT);
			TurnOrder.RemoveAt(num);
			_log.LogInfo((object)($"[TurnManager] RemovePlayer: removed slot {slotIndex} (was at index {num}). " + $"Before: turnIdx={currentTurnIndex}, phase={phase}, count={count}, activeSlot={currentPlayerSlot}"));
			if (TurnOrder.Count == 0)
			{
				Phase = TurnPhase.ALL_DONE;
				CurrentTurnIndex = 0;
				UpdateSnapshot();
				_log.LogInfo((object)"[TurnManager] RemovePlayer: no players left, phase -> ALL_DONE");
				return flag;
			}
			if (flag)
			{
				if (CurrentTurnIndex >= TurnOrder.Count)
				{
					Phase = TurnPhase.ALL_DONE;
					UpdateSnapshot();
					_log.LogInfo((object)"[TurnManager] RemovePlayer: removed last-in-order player, phase -> ALL_DONE");
				}
				else
				{
					Phase = TurnPhase.PLAYER_AIMING;
					UpdateSnapshot();
					_log.LogInfo((object)$"[TurnManager] RemovePlayer: advancing to slot {CurrentPlayerSlot} (index {CurrentTurnIndex}/{TurnOrder.Count})");
				}
			}
			else if (num < CurrentTurnIndex)
			{
				CurrentTurnIndex--;
				UpdateSnapshot();
				_log.LogInfo((object)$"[TurnManager] RemovePlayer: adjusted CurrentTurnIndex {currentTurnIndex} -> {CurrentTurnIndex}");
			}
			else
			{
				UpdateSnapshot();
				_log.LogInfo((object)"[TurnManager] RemovePlayer: removed future-turn player, no index change");
			}
			_log.LogInfo((object)($"[TurnManager] RemovePlayer result: turnIdx={CurrentTurnIndex}, phase={Phase}, " + string.Format("count={0}, activeSlot={1}, order=[{2}]", TurnOrder.Count, CurrentPlayerSlot, string.Join(", ", TurnOrder))));
			return flag;
		}

		public void Reset()
		{
			TurnOrder.Clear();
			CurrentTurnIndex = 0;
			RoundNumber = 0;
			Phase = TurnPhase.WAITING_FOR_PLAYERS;
			UpdateSnapshot();
			_log.LogInfo((object)"[TurnManager] Reset");
		}

		public string GetCurrentPlayerName()
		{
			int currentPlayerSlot = CurrentPlayerSlot;
			if (currentPlayerSlot < 0)
			{
				return string.Empty;
			}
			return _coopState.GetPlayerState(currentPlayerSlot)?.PlayerName ?? $"Player {currentPlayerSlot}";
		}

		private void UpdateSnapshot()
		{
			LatestSnapshot = new TurnSnapshot
			{
				ActiveSlotIndex = CurrentPlayerSlot,
				ActivePlayerName = GetCurrentPlayerName(),
				Phase = Phase,
				RoundNumber = RoundNumber
			};
		}
	}
	public class TurnSnapshot
	{
		public int ActiveSlotIndex { get; set; } = -1;


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


		public TurnPhase Phase { get; set; }

		public int RoundNumber { get; set; }
	}
}
namespace Multipeglin.GameState.Snapshots
{
	public class BallStateSnapshot
	{
		public float Timestamp { get; set; }

		public List<BallEntry> Balls { get; set; } = new List<BallEntry>();

	}
	public class BallEntry
	{
		public string Guid { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }

		public float VelX { get; set; }

		public float VelY { get; set; }

		public string OrbName { get; set; }

		public float ScaleX { get; set; } = 1f;


		public float ScaleY { get; set; } = 1f;


		public bool IsPrimary { get; set; }
	}
	public class DeckStateSnapshot
	{
		public int ActiveSlotIndex { get; set; } = -1;


		public List<OrbEntry> CompleteDeck { get; set; } = new List<OrbEntry>();


		public List<OrbEntry> BattleDeck { get; set; } = new List<OrbEntry>();


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


		public string CurrentOrb { get; set; }

		public string CurrentOrbGuid { get; set; }

		public int CurrentOrbLevel { get; set; }

		public int DeckSize { get; set; }
	}
	public class OrbEntry
	{
		public string Guid { get; set; }

		public int DeckIndex { get; set; }

		public string Name { get; set; }

		public string LocName { get; set; }

		public int Level { get; set; }

		public int BaseDamage { get; set; }

		public int CritDamage { get; set; }
	}
	public class EnemyStateSnapshot
	{
		public List<EnemyEntry> Enemies { get; set; } = new List<EnemyEntry>();


		public int BattleState { get; set; }

		public string BattleStateName { get; set; }

		public int RoundCount { get; set; }

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


		public float BallSpawnX { get; set; }

		public float BallSpawnY { get; set; }
	}
	public class EnemyEntry
	{
		public string Id { get; set; }

		public string LocKey { get; set; }

		public string EnemyName { get; set; }

		public float CurrentHealth { get; set; }

		public float MaxHealth { get; set; }

		public float MeleeDamage { get; set; }

		public float RangedDamage { get; set; }

		public int ChargeTime { get; set; }

		public int CurrentCharge { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }

		public int SlotIndex { get; set; }

		public bool IsFlying { get; set; }

		public List<StatusEffectEntry> StatusEffects { get; set; } = new List<StatusEffectEntry>();


		public bool HasShield { get; set; }

		public float ShieldCurrentHealth { get; set; }

		public float ShieldMaxHealth { get; set; }

		public bool ShieldActive { get; set; }

		public bool IsC19Extra { get; set; }
	}
	public class FullGameStateSnapshot
	{
		public long TimestampMs { get; set; }

		public MapStateSnapshot Map { get; set; }

		public EnemyStateSnapshot Enemies { get; set; }

		public PegboardStateSnapshot Pegboard { get; set; }

		public PlayerStateSnapshot Player { get; set; }

		public DeckStateSnapshot Deck { get; set; }

		public RelicStateSnapshot Relics { get; set; }

		public int ActivePlayerSlot { get; set; }

		public int TotalPlayerCount { get; set; }

		public Dictionary<int, DeckStateSnapshot> AllDecks { get; set; }

		public Dictionary<int, RelicStateSnapshot> AllRelics { get; set; }

		public List<CoopPlayerSummary> PlayerSummaries { get; set; }

		public TextScenarioStateSnapshot TextScenario { get; set; }
	}
	public class CoopPlayerSummary
	{
		public int SlotIndex { get; set; }

		public string PlayerName { get; set; }

		public int ChosenClass { get; set; }

		public float CurrentHealth { get; set; }

		public float MaxHealth { get; set; }

		public int Gold { get; set; }

		public bool HasShotThisRound { get; set; }

		public List<StatusEffectEntry> StatusEffects { get; set; } = new List<StatusEffectEntry>();

	}
	public class MapStateSnapshot
	{
		public string CurrentSeed { get; set; }

		public int TotalFloorCount { get; set; }

		public int ChosenClass { get; set; }

		public string ChosenClassName { get; set; }

		public int CruciballLevel { get; set; }

		public string ActiveScene { get; set; }

		public int ChosenNextNodeIndex { get; set; }

		public bool HasReachedBoss { get; set; }

		public int MapFloorCount { get; set; }

		public string BattleDataName { get; set; }

		public string PegLayoutName { get; set; }

		public string RandomStateJson { get; set; }

		public string SeededNodeKind { get; set; }

		public int? SeededNodeInitSeed { get; set; }

		public int? SeededNodeTimesUsed { get; set; }

		public float? SeededTreasureRareRelicRoll { get; set; }

		public float? SeededTreasureMimicRoll { get; set; }

		public float? SeededShopRareRelicRoll { get; set; }

		public float? SeededShopRelicRoll { get; set; }

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

		public List<int> SeededShopOrbRarities { get; set; }

		public List<int> SeededShopRelicEffects { get; set; }

		public List<MapNodeEntry> Nodes { get; set; }

		public float? PlayerMapPosX { get; set; }

		public float? PlayerMapPosY { get; set; }

		public bool IsNavigating { get; set; }

		public List<int> NavChildNodeTypes { get; set; }
	}
	public class MapNodeEntry
	{
		public int Index { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }

		public int RoomType { get; set; }

		public string RoomTypeName { get; set; }

		public string MapDataName { get; set; }

		public int RoomState { get; set; }

		public string RoomStateName { get; set; }

		public int SelectedBossIndex { get; set; } = -1;

	}
	public class PegboardStateSnapshot
	{
		public List<PegEntry> Pegs { get; set; } = new List<PegEntry>();


		public List<VineEntry> Vines { get; set; } = new List<VineEntry>();


		public List<BlackHoleEntry> BlackHoles { get; set; } = new List<BlackHoleEntry>();


		public List<SplineGeneratorEntry> SplineGenerators { get; set; } = new List<SplineGeneratorEntry>();


		public ObscurerGridSnapshot ObscurerGrid { get; set; }

		public int TotalPegCount { get; set; }

		public int CritPegCount { get; set; }

		public int BombPegCount { get; set; }

		public int ResetPegCount { get; set; }

		public int BouncerPegCount { get; set; }
	}
	public class PegEntry
	{
		public string Guid { get; set; }

		public int Index { get; set; }

		public int PegType { get; set; }

		public string PegTypeName { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }

		public int SlimeType { get; set; }

		public bool IsDestroyed { get; set; }

		public bool IsParentHidden { get; set; }

		public int CoinCount { get; set; }

		public bool IsCleared { get; set; }

		public bool IsLongPegHit { get; set; }

		public bool WasPreviouslyCleared { get; set; }

		public int HitCount { get; set; }

		public bool IsBomb { get; set; }

		public bool IsBouncer { get; set; }

		public int BuffAmount { get; set; }

		public bool IsShielded { get; set; }

		public int ShieldHitCount { get; set; }

		public int ShieldHitLimit { get; set; }

		public float? LpmParentPosX { get; set; }

		public float? LpmParentPosY { get; set; }

		public string ParentName { get; set; }

		public float LocalPosX { get; set; }

		public float LocalPosY { get; set; }

		public int SiblingIndex { get; set; }

		public bool HasLpm { get; set; }

		public float RotZ { get; set; }
	}
	public class VineEntry
	{
		public string Peg1Guid { get; set; }

		public string Peg2Guid { get; set; }
	}
	public class SplineGeneratorEntry
	{
		public string HierarchyPath { get; set; }

		public float Phase { get; set; }

		public int NumPegs { get; set; }

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


		public float ParentPosX { get; set; }

		public float ParentPosY { get; set; }

		public bool HasParent { get; set; }
	}
	public class ObscurerGridSnapshot
	{
		public int Width { get; set; }

		public int Height { get; set; }

		public List<ObscurerCellEntry> RevealedCells { get; set; } = new List<ObscurerCellEntry>();

	}
	public class ObscurerCellEntry
	{
		public int X { get; set; }

		public int Y { get; set; }

		public int RevealedPegType { get; set; }
	}
	public class BlackHoleEntry
	{
		public int Index { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }
	}
	public class PlayerStateSnapshot
	{
		public int ActiveSlotIndex { get; set; } = -1;


		public float CurrentHealth { get; set; }

		public float MaxHealth { get; set; }

		public int Gold { get; set; }

		public List<StatusEffectEntry> StatusEffects { get; set; } = new List<StatusEffectEntry>();


		public bool IsSpedUp { get; set; }

		public float SpeedupLevel { get; set; } = 2f;

	}
	public class StatusEffectEntry
	{
		public int EffectType { get; set; }

		public string EffectName { get; set; }

		public int Intensity { get; set; }
	}
	public class RelicStateSnapshot
	{
		public int ActiveSlotIndex { get; set; } = -1;


		public List<RelicEntry> OwnedRelics { get; set; } = new List<RelicEntry>();


		public int TotalRelicCount { get; set; }
	}
	public class RelicEntry
	{
		public int Effect { get; set; }

		public string EffectName { get; set; }

		public string LocKey { get; set; }

		public int Rarity { get; set; }

		public int RemainingCountdown { get; set; }

		public int RemainingUsesPerShot { get; set; }

		public int RemainingUsesPerBattle { get; set; }

		public int RemainingUsesPerRun { get; set; }

		public bool IsEnabled { get; set; }
	}
	public class TextScenarioStateSnapshot
	{
		public bool IsActive { get; set; }

		public string SubtitleText { get; set; }

		public string SpeakerName { get; set; }

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


		public int HighlightedIndex { get; set; } = -1;


		public bool IsNavigating { get; set; }

		public bool IsMirrorEvent { get; set; }

		public string ScenarioName { get; set; }
	}
}
namespace Multipeglin.GameState.Providers
{
	public class BallStateProvider : IGameStateProvider<BallStateSnapshot>
	{
		private readonly ManualLogSource _log;

		private readonly BallIdentifier _ballId;

		public BallStateProvider(ManualLogSource log, BallIdentifier ballId)
		{
			_log = log;
			_ballId = ballId;
		}

		public BallStateSnapshot Capture()
		{
			//IL_0079: 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_0080: 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_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0132: Unknown result type (might be due to invalid IL or missing references)
			//IL_013f: Unknown result type (might be due to invalid IL or missing references)
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_017b: Unknown result type (might be due to invalid IL or missing references)
			BallStateSnapshot ballStateSnapshot = new BallStateSnapshot
			{
				Timestamp = Time.time
			};
			try
			{
				PachinkoBall[] array = Object.FindObjectsOfType<PachinkoBall>();
				if (array == null)
				{
					return ballStateSnapshot;
				}
				PachinkoBall[] array2 = array;
				foreach (PachinkoBall val in array2)
				{
					if ((Object)(object)val == (Object)null || val.IsDummy)
					{
						continue;
					}
					string name = ((Object)((Component)val).gameObject).name;
					if (string.IsNullOrEmpty(name) || !name.StartsWith("CoopTempOrb"))
					{
						Vector3 position = ((Component)val).transform.position;
						if ((!(position.x < -900f) || !(position.y < -900f)) && val.IsFiring())
						{
							string orAssignGuid = _ballId.GetOrAssignGuid(val);
							Rigidbody2D component = ((Component)val).GetComponent<Rigidbody2D>();
							Vector2 val2 = (((Object)(object)component != (Object)null) ? component.velocity : Vector2.zero);
							SpriteRenderer componentInChildren = ((Component)val).GetComponentInChildren<SpriteRenderer>();
							Vector3 val3 = ((!((Object)(object)componentInChildren != (Object)null)) ? ((Component)val).transform.localScale : ((Component)componentInChildren).transform.lossyScale);
							bool isPrimary = ((Component)val).gameObject == MultiplayerClientPatches.PrimaryBall;
							ballStateSnapshot.Balls.Add(new BallEntry
							{
								Guid = orAssignGuid,
								PosX = position.x,
								PosY = position.y,
								VelX = val2.x,
								VelY = val2.y,
								OrbName = name,
								ScaleX = val3.x,
								ScaleY = val3.y,
								IsPrimary = isPrimary
							});
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource log = _log;
				if (log != null)
				{
					log.LogWarning((object)("[BallProvider] Capture failed: " + ex.Message));
				}
			}
			return ballStateSnapshot;
		}
	}
	public class DeckStateProvider : IGameStateProvider<DeckStateSnapshot>
	{
		private readonly ManualLogSource _log;

		private readonly OrbIdentifier _orbId;

		private string _lastCaptureSig = string.Empty;

		public DeckStateProvider(ManualLogSource log, OrbIdentifier orbId)
		{
			_log = log;
			_orbId = orbId;
		}

		public DeckStateSnapshot Capture()
		{
			try
			{
				DeckStateSnapshot deckStateSnapshot = new DeckStateSnapshot();
				DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
				DeckManager val = ((array.Length != 0) ? array[0] : null);
				if ((Object)(object)val == (Object)null)
				{
					return deckStateSnapshot;
				}
				List<GameObject> completeDeck = DeckManager.completeDeck;
				if (completeDeck != null)
				{
					for (int i = 0; i < completeDeck.Count; i++)
					{
						GameObject val2 = completeDeck[i];
						if (!((Object)(object)val2 == (Object)null))
						{
							OrbEntry orbEntry = CreateOrbEntry(val2);
							orbEntry.Guid = _orbId.GetOrAssignGuid(val2);
							orbEntry.DeckIndex = i;
							deckStateSnapshot.CompleteDeck.Add(orbEntry);
						}
					}
				}
				List<GameObject> battleDeck = val.battleDeck;
				if (battleDeck != null)
				{
					for (int j = 0; j < battleDeck.Count; j++)
					{
						GameObject val3 = battleDeck[j];
						if (!((Object)(object)val3 == (Object)null))
						{
							OrbEntry orbEntry2 = CreateOrbEntry(val3);
							orbEntry2.Guid = _orbId.GetOrAssignGuid(val3);
							orbEntry2.DeckIndex = j;
							deckStateSnapshot.BattleDeck.Add(orbEntry2);
						}
					}
				}
				if (val.shuffledDeck == null)
				{
					deckStateSnapshot.ShuffledOrder = null;
				}
				else if (val.shuffledDeck.Count > 0)
				{
					foreach (GameObject item in val.shuffledDeck)
					{
						if ((Object)(object)item != (Object)null)
						{
							deckStateSnapshot.ShuffledOrder.Add(_orbId.GetOrAssignGuid(item));
						}
					}
				}
				deckStateSnapshot.DeckSize = deckStateSnapshot.CompleteDeck.Count;
				try
				{
					BattleController val4 = Object.FindObjectOfType<BattleController>();
					if ((Object)(object)((val4 != null) ? val4.activePachinkoBall : null) != (Object)null)
					{
						deckStateSnapshot.CurrentOrb = ((Object)val4.activePachinkoBall).name;
						deckStateSnapshot.CurrentOrbGuid = _orbId.GetGuid(val4.activePachinkoBall);
						deckStateSnapshot.CurrentOrbLevel = val4.activePachinkoBall.GetComponent<Attack>()?.Level ?? 1;
					}
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[DeckProvider] Failed to capture active orb: " + ex.Message));
				}
				string text = $"{deckStateSnapshot.CompleteDeck.Count}|{deckStateSnapshot.BattleDeck.Count}|{deckStateSnapshot.ShuffledOrder?.Count ?? 0}|{_orbId.Count}|{deckStateSnapshot.CurrentOrb}";
				if (text != _lastCaptureSig)
				{
					_lastCaptureSig = text;
					_log.LogInfo((object)string.Format("[DeckProvider] Captured {0} complete, {1} battle, {2} shuffled orbs ({3} in registry) activeOrb={4}", deckStateSnapshot.CompleteDeck.Count, deckStateSnapshot.BattleDeck.Count, deckStateSnapshot.ShuffledOrder?.Count ?? 0, _orbId.Count, deckStateSnapshot.CurrentOrb ?? "none"));
				}
				return deckStateSnapshot;
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("DeckStateProvider.Capture failed: " + ex2.Message));
				return null;
			}
		}

		private static OrbEntry CreateOrbEntry(GameObject go)
		{
			Attack component = go.GetComponent<Attack>();
			return new OrbEntry
			{
				Name = ((Object)go).name,
				LocName = (component?.locNameString ?? ((Object)go).name),
				Level = (component?.Level ?? (-1)),
				BaseDamage = (component?.DamagePerPeg ?? 0),
				CritDamage = (component?.CritDamagePerPeg ?? 0)
			};
		}
	}
	public class EnemyStateProvider : IGameStateProvider<EnemyStateSnapshot>
	{
		private readonly ManualLogSource _log;

		private readonly EnemyIdentifier _enemyId;

		public EnemyStateProvider(ManualLogSource log, EnemyIdentifier enemyId)
		{
			_log = log;
			_enemyId = enemyId;
		}

		public EnemyStateSnapshot Capture()
		{
			//IL_015e: 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)
			try
			{
				EnemyStateSnapshot enemyStateSnapshot = new EnemyStateSnapshot();
				BattleController val = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val != (Object)null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(BattleController), "_battleState");
					if (fieldInfo != null)
					{
						object value = fieldInfo.GetValue(null);
						enemyStateSnapshot.BattleState = (int)value;
						enemyStateSnapshot.BattleStateName = value.ToString();
					}
					enemyStateSnapshot.BallSpawnX = val.pachinkoBallSpawnLocation.x;
					enemyStateSnapshot.BallSpawnY = val.pachinkoBallSpawnLocation.y;
				}
				EnemyManager val2 = Object.FindObjectOfType<EnemyManager>();
				if ((Object)(object)val2 != (Object)null && AccessTools.Field(typeof(EnemyManager), "Enemies")?.GetValue(val2) is List<Enemy> list)
				{
					for (int i = 0; i < list.Count; i++)
					{
						Enemy val3 = list[i];
						if ((Object)(object)val3 == (Object)null)
						{
							continue;
						}
						string orAssignGuid = _enemyId.GetOrAssignGuid(val3);
						EnemyEntry enemyEntry = new EnemyEntry
						{
							Id = orAssignGuid,
							LocKey = (val3.locKey ?? ((Object)((Component)val3).gameObject).name),
							EnemyName = ((Object)((Component)val3).gameObject).name,
							CurrentHealth = val3.CurrentHealth,
							MeleeDamage = val3.DamagePerMeleeAttack,
							RangedDamage = val3.DamagePerRangedAttack,
							SlotIndex = i,
							PosX = ((Component)val3).transform.position.x,
							PosY = ((Component)val3).transform.position.y,
							IsFlying = val3.IsFlying
						};
						FieldInfo fieldInfo2 = AccessTools.Field(typeof(Enemy), "_maxHealth");
						if (fieldInfo2 != null)
						{
							enemyEntry.MaxHealth = (float)fieldInfo2.GetValue(val3);
						}
						enemyEntry.CurrentCharge = val3.currentChargeTime;
						FieldInfo fieldInfo3 = AccessTools.Field(typeof(Enemy), "AttackChargeLength");
						if (fieldInfo3 != null)
						{
							enemyEntry.ChargeTime = (int)fieldInfo3.GetValue(val3);
						}
						try
						{
							UpdateSlider healthBarBarSprite = val3.HealthBarBarSprite;
							if ((Object)(object)healthBarBarSprite != (Object)null)
							{
								FieldInfo fieldInfo4 = AccessTools.Field(typeof(UpdateSlider), "_background");
								FieldInfo fieldInfo5 = AccessTools.Field(typeof(UpdateSlider), "_c19Background");
								object? obj = fieldInfo4?.GetValue(healthBarBarSprite);
								Image val4 = (Image)((obj is Image) ? obj : null);
								object? obj2 = fieldInfo5?.GetValue(healthBarBarSprite);
								Sprite val5 = (Sprite)((obj2 is Sprite) ? obj2 : null);
								if ((Object)(object)val4 != (Object)null && (Object)(object)val5 != (Object)null && (Object)(object)val4.sprite == (Object)(object)val5)
								{
									enemyEntry.IsC19Extra = true;
								}
							}
						}
						catch
						{
						}
						try
						{
							ShieldEnemy val6 = (ShieldEnemy)(object)((val3 is ShieldEnemy) ? val3 : null);
							if (val6 != null && (Object)(object)val6.shield != (Object)null)
							{
								BarricadeEnemy shield = val6.shield;
								enemyEntry.HasShield = true;
								enemyEntry.ShieldCurrentHealth = ((Enemy)shield).CurrentHealth;
								FieldInfo fieldInfo6 = AccessTools.Field(typeof(Enemy), "_maxHealth");
								if (fieldInfo6 != null)
								{
									enemyEntry.ShieldMaxHealth = (float)fieldInfo6.GetValue(shield);
								}
								enemyEntry.ShieldActive = ((Component)shield).gameObject.activeInHierarchy;
							}
						}
						catch
						{
						}
						try
						{
							if (AccessTools.Field(typeof(Enemy), "_statusEffects")?.GetValue(val3) is IList list2)
							{
								enemyEntry.StatusEffects = new List<StatusEffectEntry>();
								foreach (object item in list2)
								{
									FieldInfo fieldInfo7 = AccessTools.Field(item.GetType(), "EffectType");
									FieldInfo fieldInfo8 = AccessTools.Field(item.GetType(), "Intensity");
									if (fieldInfo7 != null)
									{
										object value2 = fieldInfo7.GetValue(item);
										enemyEntry.StatusEffects.Add(new StatusEffectEntry
										{
											EffectType = (int)value2,
											EffectName = value2.ToString(),
											Intensity = (int)(fieldInfo8?.GetValue(item) ?? ((object)0))
										});
									}
								}
							}
						}
						catch
						{
						}
						enemyStateSnapshot.Enemies.Add(enemyEntry);
						List<StatusEffectEntry> statusEffects = enemyEntry.StatusEffects;
						string text = ((statusEffects != null && statusEffects.Count > 0) ? string.Join(",", enemyEntry.StatusEffects.ConvertAll((StatusEffectEntry e) => $"{e.EffectName}={e.Intensity}")) : "none");
						string text2 = (enemyEntry.HasShield ? string.Format(" shield={0:F0}/{1:F0}{2}", enemyEntry.ShieldCurrentHealth, enemyEntry.ShieldMaxHealth, enemyEntry.ShieldActive ? string.Empty : " (dead)") : string.Empty);
						_log.LogInfo((object)("[EnemyProvider] Captured enemy: guid=" + orAssignGuid + " loc=" + enemyEntry.LocKey + " name=" + enemyEntry.EnemyName + " " + $"hp={enemyEntry.CurrentHealth}/{enemyEntry.MaxHealth} pos=({enemyEntry.PosX:F1},{enemyEntry.PosY:F1}) slot={i} effects=[{text}]{text2}"));
					}
				}
				EnemyInfoManager val7 = Object.FindObjectOfType<EnemyInfoManager>();
				if ((Object)(object)val7 != (Object)null)
				{
					if (AccessTools.Field(typeof(EnemyInfoManager), "_enemyInfoElements")?.GetValue(val7) is Queue<EnemyInfoElement> queue && queue.Count > 0)
					{
						foreach (EnemyInfoElement item2 in queue)
						{
							if (!((Object)(object)item2 == (Object)null))
							{
								object? obj6 = AccessTools.Field(typeof(EnemyInfoElement), "_enemy")?.GetValue(item2);
								Enemy val8 = (Enemy)((obj6 is Enemy) ? obj6 : null);
								if ((Object)(object)val8 != (Object)null)
								{
									enemyStateSnapshot.UpcomingEnemyNames.Add(((Object)((Component)val8).gameObject).name);
								}
							}
						}
					}
					_log.LogInfo((object)$"[EnemyProvider] Upcoming enemies: {enemyStateSnapshot.UpcomingEnemyNames.Count}");
				}
				return enemyStateSnapshot;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("EnemyStateProvider.Capture failed: " + ex.Message));
				return null;
			}
		}
	}
	public class MapStateProvider : IGameStateProvider<MapStateSnapshot>
	{
		private readonly ManualLogSource _log;

		private static readonly HashSet<string> MapScenes = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "ForestMap", "CastleMap", "MinesMap", "CoreMap" };

		private static List<int> _cachedShopRelicEffects;

		private static bool _inShopScenario;

		private static List<int> _cachedNavChildTypes;

		private static bool _wasNavigating;

		public MapStateProvider(ManualLogSource log)
		{
			_log = log;
		}

		public MapStateSnapshot Capture()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Expected I4, but got Unknown
			//IL_0182: 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)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (name != "ShopScenario" && _inShopScenario)
				{
					_cachedShopRelicEffects = null;
					_inShopScenario = false;
				}
				MapStateSnapshot obj = new MapStateSnapshot
				{
					CurrentSeed = (StaticGameData.currentSeed ?? string.Empty),
					TotalFloorCount = StaticGameData.totalFloorCount,
					ChosenClass = (int)StaticGameData.chosenClass,
					ChosenClassName = ((object)(Class)(ref StaticGameData.chosenClass)).ToString(),
					ActiveScene = name,
					ChosenNextNodeIndex = StaticGameData.chosenNextNodeIndex,
					HasReachedBoss = StaticGameData.hasReachedBoss,
					RandomStateJson = MultiplayerClientPatches.CapturedPreMapGenRngState
				};
				MapData dataToLoad = StaticGameData.dataToLoad;
				MapData obj2 = ((dataToLoad is MapDataBattle) ? dataToLoad : null);
				obj.BattleDataName = ((obj2 != null) ? ((Object)obj2).name : null);
				MapData dataToLoad2 = StaticGameData.dataToLoad;
				MapData obj3 = ((dataToLoad2 is MapDataBattle) ? dataToLoad2 : null);
				object pegLayoutName;
				if (obj3 == null)
				{
					pegLayoutName = null;
				}
				else
				{
					PegLayout pegLayout = ((MapDataBattle)obj3).pegLayout;
					pegLayoutName = ((pegLayout != null) ? ((Object)pegLayout).name : null);
				}
				obj.PegLayoutName = (string)pegLayoutName;
				MapStateSnapshot mapStateSnapshot = obj;
				CaptureSeededNodeData(mapStateSnapshot);
				if (MapScenes.Contains(name))
				{
					mapStateSnapshot.Nodes = CaptureMapNodes();
					try
					{
						MapController val = Object.FindObjectOfType<MapController>();
						if ((Object)(object)val != (Object)null)
						{
							FieldInfo fieldInfo = AccessTools.Field(typeof(MapController), "floorCount");
							if (fieldInfo != null)
							{
								mapStateSnapshot.MapFloorCount = (int)fieldInfo.GetValue(val);
							}
							object? obj4 = AccessTools.Field(typeof(MapController), "_player")?.GetValue(val);
							GameObject val2 = (GameObject)((obj4 is GameObject) ? obj4 : null);
							if ((Object)(object)val2 != (Object)null)
							{
								mapStateSnapshot.PlayerMapPosX = val2.transform.position.x;
								mapStateSnapshot.PlayerMapPosY = val2.transform.position.y;
							}
						}
					}
					catch
					{
					}
				}
				if (name == "Battle")
				{
					CaptureNavigationState(mapStateSnapshot);
				}
				return mapStateSnapshot;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("MapStateProvider.Capture failed: " + ex.Message));
				return null;
			}
		}

		private void CaptureSeededNodeData(MapStateSnapshot snapshot)
		{
			//IL_00fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Expected I4, but got Unknown
			try
			{
				SeededMapNodeData seededNodeData = StaticGameData.seededNodeData;
				if (seededNodeData == null)
				{
					return;
				}
				SeededTextScenarioNodeData val = (SeededTextScenarioNodeData)(object)((seededNodeData is SeededTextScenarioNodeData) ? seededNodeData : null);
				if (val != null)
				{
					snapshot.SeededNodeKind = "text_scenario";
					if (val.randomState != null)
					{
						snapshot.SeededNodeInitSeed = val.randomState.initializationSeed;
						snapshot.SeededNodeTimesUsed = val.randomState.timesUsed;
					}
					return;
				}
				SeededTreasureNodeData val2 = (SeededTreasureNodeData)(object)((seededNodeData is SeededTreasureNodeData) ? seededNodeData : null);
				if (val2 != null)
				{
					snapshot.SeededNodeKind = "treasure";
					snapshot.SeededTreasureRareRelicRoll = val2.rareRelicChanceRoll;
					snapshot.SeededTreasureMimicRoll = val2.mimicChallengeChanceRoll;
					return;
				}
				SeededShopNodeData val3 = (SeededShopNodeData)(object)((seededNodeData is SeededShopNodeData) ? seededNodeData : null);
				if (val3 == null)
				{
					return;
				}
				snapshot.SeededNodeKind = "shop";
				snapshot.SeededShopRareRelicRoll = val3.rareRelicChanceRoll;
				snapshot.SeededShopRelicRoll = val3.shopRelicChanceRoll;
				if (val3.shopOrbs != null)
				{
					List<string> list = new List<string>();
					List<int> list2 = new List<int>();
					SeededOrbAndRarity[] shopOrbs = val3.shopOrbs;
					foreach (SeededOrbAndRarity val4 in shopOrbs)
					{
						list.Add(((Object)(object)val4.orb != (Object)null) ? ((Object)val4.orb).name : string.Empty);
						list2.Add((int)val4.orbRarity);
					}
					snapshot.SeededShopOrbNames = list;
					snapshot.SeededShopOrbRarities = list2;
				}
				CaptureShopRelicEffects(snapshot);
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[MapProvider] CaptureSeededNodeData failed: " + ex.Message));
			}
		}

		private void CaptureShopRelicEffects(MapStateSnapshot snapshot)
		{
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Expected I4, but got Unknown
			try
			{
				_inShopScenario = true;
				if (_cachedShopRelicEffects != null && _cachedShopRelicEffects.Count > 0)
				{
					snapshot.SeededShopRelicEffects = _cachedShopRelicEffects;
					return;
				}
				ShopManager val = Object.FindObjectOfType<ShopManager>();
				if ((Object)(object)val == (Object)null || !(AccessTools.Field(typeof(ShopManager), "_purchasableRelics")?.GetValue(val) is Array array))
				{
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(PurchasableRelic), "_relic");
				if (fieldInfo == null)
				{
					return;
				}
				List<int> list = new List<int>();
				bool flag = false;
				for (int i = 0; i < array.Length; i++)
				{
					object? value = array.GetValue(i);
					PurchasableRelic val2 = (PurchasableRelic)((value is PurchasableRelic) ? value : null);
					if (val2 != null)
					{
						object? value2 = fieldInfo.GetValue(val2);
						Relic val3 = (Relic)((value2 is Relic) ? value2 : null);
						if ((Object)(object)val3 != (Object)null)
						{
							list.Add((int)val3.effect);
						}
						else
						{
							flag = true;
						}
					}
					else
					{
						flag = true;
					}
				}
				if (list.Count > 0)
				{
					snapshot.SeededShopRelicEffects = list;
					if (!flag && list.Count == array.Length)
					{
						_cachedShopRelicEffects = list;
						_log.LogInfo((object)$"[MapProvider] Cached initial shop relic offering: {list.Count} relics");
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[MapProvider] CaptureShopRelicEffects failed: " + ex.Message));
			}
		}

		public static void ResetCachedState()
		{
			_cachedNavChildTypes = null;
			_wasNavigating = false;
			_cachedShopRelicEffects = null;
			_inShopScenario = false;
		}

		private void CaptureNavigationState(MapStateSnapshot snapshot)
		{
			//IL_0039: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Invalid comparison between Unknown and I4
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0046: Invalid comparison between Unknown and I4
			//IL_00bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Expected I4, but got O
			//IL_00c5: Expected O, but got I4
			//IL_00c0->IL00c0: Incompatible stack types: O vs I4
			//IL_00b9->IL00c0: Incompatible stack types: I4 vs O
			//IL_00b9->IL00c0: Incompatible stack types: O vs I4
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(BattleController), "_battleState");
				BattleController val = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val == (Object)null || fieldInfo == null)
				{
					return;
				}
				BattleState val2 = (BattleState)fieldInfo.GetValue(val);
				if ((int)val2 != 8 && (int)val2 != 9)
				{
					if (_wasNavigating)
					{
						_cachedNavChildTypes = null;
						_wasNavigating = false;
					}
					return;
				}
				if (_cachedNavChildTypes == null && (Object)(object)StaticGameData.currentNode != (Object)null)
				{
					MapNode[] childNodes = StaticGameData.currentNode.ChildNodes;
					if (childNodes != null && childNodes.Length != 0)
					{
						_cachedNavChildTypes = new List<int>();
						MapNode[] array = childNodes;
						foreach (MapNode val3 in array)
						{
							object obj = _cachedNavChildTypes;
							int num;
							if (!((Object)(object)val3 != (Object)null))
							{
								num = 0;
								obj = num;
								num = (int)obj;
							}
							else
							{
								obj = val3.RoomType;
								num = (int)obj;
							}
							((List<int>)num).Add((int)obj);
						}
						_log.LogInfo((object)$"[MapProvider] Cached {_cachedNavChildTypes.Count} nav child types");
					}
				}
				if (_cachedNavChildTypes != null && _cachedNavChildTypes.Count > 0)
				{
					snapshot.IsNavigating = true;
					snapshot.NavChildNodeTypes = _cachedNavChildTypes;
					_wasNavigating = true;
				}
			}
			catch
			{
			}
		}

		private List<MapNodeEntry> CaptureMapNodes()
		{
			//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected I4, but got Unknown
			List<MapNodeEntry> list = new List<MapNodeEntry>();
			try
			{
				MapController val = Object.FindObjectOfType<MapController>();
				if ((Object)(object)val == (Object)null)
				{
					return list;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(MapController), "_nodes");
				if (fieldInfo == null)
				{
					return list;
				}
				if (!(fieldInfo.GetValue(val) is MapNode[] array))
				{
					return list;
				}
				for (int i = 0; i < array.Length; i++)
				{
					MapNode val2 = array[i];
					if (!((Object)(object)val2 == (Object)null))
					{
						object obj = AccessTools.Field(typeof(MapNode), "_roomStatus")?.GetValue(val2);
						object obj2 = AccessTools.Field(typeof(MapNode), "_selectedBossIndex")?.GetValue(val2);
						MapNodeEntry obj3 = new MapNodeEntry
						{
							Index = i,
							PosX = ((Component)val2).transform.position.x,
							PosY = ((Component)val2).transform.position.y,
							RoomType = (int)val2.RoomType,
							RoomTypeName = ((object)(RoomType)(ref val2.RoomType)).ToString()
						};
						MapData mapData = val2.MapData;
						obj3.MapDataName = ((mapData != null) ? ((Object)mapData).name : null);
						obj3.RoomState = ((obj != null) ? ((int)obj) : (-1));
						obj3.RoomStateName = obj?.ToString() ?? "?";
						obj3.SelectedBossIndex = ((obj2 != null) ? ((int)obj2) : (-1));
						list.Add(obj3);
					}
				}
				Dictionary<int, int> dictionary = new Dictionary<int, int>();
				Dictionary<int, int> dictionary2 = new Dictionary<int, int>();
				int num = 0;
				foreach (MapNodeEntry item in list)
				{
					dictionary[item.RoomType] = ((!dictionary.TryGetValue(item.RoomType, out var value)) ? 1 : (value + 1));
					dictionary2[item.RoomState] = ((!dictionary2.TryGetValue(item.RoomState, out var value2)) ? 1 : (value2 + 1));
					if (item.RoomType == 0 || item.RoomState == 0)
					{
						num++;
					}
				}
				string text = string.Join(", ", dictionary.Select((KeyValuePair<int, int> kv) => $"{(object)(RoomType)kv.Key}={kv.Value}"));
				string text2 = string.Join(", ", dictionary2.Select(delegate(KeyValuePair<int, int> kv)
				{
					//IL_001d: Unknown result type (might be due to invalid IL or missing references)
					object arg;
					if (kv.Key < 0)
					{
						arg = "?";
					}
					else
					{
						RoomState val3 = (RoomState)kv.Key;
						arg = ((object)(RoomState)(ref val3)).ToString();
					}
					return $"{arg}={kv.Value}";
				}));
				_log.LogInfo((object)$"[MapProvider] Captured {list.Count} map nodes — types[{text}] states[{text2}] noneOrHidden={num}");
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[MapProvider] CaptureMapNodes failed: " + ex.Message));
			}
			return list;
		}
	}
	public class PegboardStateProvider : IGameStateProvider<PegboardStateSnapshot>
	{
		private readonly ManualLogSource _log;

		private readonly PegIdentifier _pegId;

		private (int total, int crit, int bomb, int reset, int bouncer, int registry, int bombsListCount, int allPegsBombCount, int blackHoles, int splineGens) _lastCaptureSig;

		private static FieldInfo _obscurerGridField;

		private static FieldInfo _obscurerWidthField;

		private static FieldInfo _obscurerHeightField;

		private (int w, int h, int revealedCount) _lastObscurerCaptureSig = (-1, -1, -1);

		private static readonly Dictionary<int, string> _hierarchyPathCache = new Dictionary<int, string>(256);

		private static readonly Dictionary<int, bool> _movingAncestorCache = new Dictionary<int, bool>(256);

		[ThreadStatic]
		private static List<string> _hierarchyPathBuf;

		public PegboardStateProvider(ManualLogSource log, PegIdentifier pegId)
		{
			_log = log;
			_pegId = pegId;
		}

		public PegboardStateSnapshot Capture()
		{
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ef: Expected I4, but got Unknown
			//IL_0424: Unknown result type (might be due to invalid IL or missing references)
			//IL_043b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0452: Unknown result type (might be due to invalid IL or missing references)
			//IL_0464: Unknown result type (might be due to invalid IL or missing references)
			//IL_046e: Expected I4, but got Unknown
			//IL_0243: Unknown result type (might be due to invalid IL or missing references)
			//IL_0646: Unknown result type (might be due to invalid IL or missing references)
			//IL_065d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0674: Unknown result type (might be due to invalid IL or missing references)
			//IL_0686: Unknown result type (might be due to invalid IL or missing references)
			//IL_0690: Expected I4, but got Unknown
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0352: Expected I4, but got Unknown
			//IL_055e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0565: Expected I4, but got Unknown
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Expected I4, but got Unknown
			try
			{
				PegboardStateSnapshot pegboardStateSnapshot = new PegboardStateSnapshot();
				BattleController obj = Object.FindObjectOfType<BattleController>();
				PegManager val = ((obj != null) ? obj.pegManager : null);
				if (val == null || val.allPegs == null)
				{
					_log.LogInfo((object)"[PegProvider] No PegManager or allPegs list found");
					return pegboardStateSnapshot;
				}
				List<Peg> allPegs = val.allPegs;
				int num = 0;
				for (int i = 0; i < allPegs.Count; i++)
				{
					Peg val2 = allPegs[i];
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					bool flag = val2 is Bomb;
					if (flag)
					{
						num++;
					}
					string orAssignGuid = _pegId.GetOrAssignGuid(val2);
					int num2 = (int)val2.pegType;
					bool isParentHidden = ((Component)val2).gameObject.activeSelf && !((Component)val2).gameObject.activeInHierarchy;
					bool flag2 = !((Component)val2).gameObject.activeInHierarchy || (num2 & 0x20) != 0;
					bool flag3 = false;
					bool wasPreviouslyCleared = false;
					bool isLongPegHit = false;
					if (!flag2)
					{
						try
						{
							flag3 = val2.IsDisabled();
						}
						catch
						{
						}
						if (!flag3 && val2 is LongPeg)
						{
							try
							{
								isLongPegHit = (bool)(AccessTools.Field(typeof(LongPeg), "_hit")?.GetValue(val2) ?? ((object)false));
							}
							catch
							{
							}
						}
						try
						{
							wasPreviouslyCleared = (bool)(AccessTools.Field(typeof(Peg), "_cleared")?.GetValue(val2) ?? ((object)false));
						}
						catch
						{
						}
					}
					PegEntry pegEntry = new PegEntry
					{
						Guid = orAssignGuid,
						Index = i,
						PegType = num2,
						PegTypeName = ((object)(PegType)(ref val2.pegType)).ToString(),
						PosX = ((Component)val2).transform.position.x,
						PosY = ((Component)val2).transform.position.y,
						RotZ = ((Component)val2).transform.localEulerAngles.z,
						SlimeType = (int)val2.slimeType,
						IsDestroyed = flag2,
						IsParentHidden = isParentHidden,
						IsCleared = flag3,
						IsLongPegHit = isLongPegHit,
						WasPreviouslyCleared = wasPreviouslyCleared,
						CoinCount = val2.NumCoins(),
						BuffAmount = val2.buffAmount,
						IsBomb = flag,
						HitCount = (flag ? ((Bomb)val2).HitCount : 0)
					};
					CaptureShieldState(val2, pegEntry);
					CaptureLpmParentPos(val2, pegEntry);
					CaptureStructKey(val2, pegEntry);
					pegboardStateSnapshot.Pegs.Add(pegEntry);
					if (((Component)val2).gameObject.activeInHierarchy && !flag2)
					{
						if (flag)
						{
							pegboardStateSnapshot.BombPegCount++;
						}
						else if (((uint)num2 & 2u) != 0)
						{
							pegboardStateSnapshot.CritPegCount++;
						}
						else if (((uint)num2 & 8u) != 0)
						{
							pegboardStateSnapshot.ResetPegCount++;
						}
					}
				}
				List<Bomb> list = AccessTools.Field(typeof(PegManager), "_bombs")?.GetValue(val) as List<Bomb>;
				if (list != null)
				{
					for (int j = 0; j < list.Count; j++)
					{
						Bomb val3 = list[j];
						if ((Object)(object)val3 == (Object)null)
						{
							continue;
						}
						string orAssignGuid2 = _pegId.GetOrAssignGuid((Peg)(object)val3);
						int num3 = (int)((Peg)val3).pegType;
						bool isParentHidden2 = ((Component)val3).gameObject.activeSelf && !((Component)val3).gameObject.activeInHierarchy;
						bool flag4 = !((Component)val3).gameObject.activeInHierarchy || (num3 & 0x20) != 0;
						bool isCleared = false;
						bool wasPreviouslyCleared2 = false;
						if (!flag4)
						{
							try
							{
								isCleared = ((Peg)val3).IsDisabled();
							}
							catch
							{
							}
							try
							{
								wasPreviouslyCleared2 = (bool)(AccessTools.Field(typeof(Peg), "_cleared")?.GetValue(val3) ?? ((object)false));
							}
							catch
							{
							}
						}
						PegEntry pegEntry2 = new PegEntry
						{
							Guid = orAssignGuid2,
							Index = allPegs.Count + j,
							PegType = num3,
							PegTypeName = ((object)(PegType)(ref ((Peg)val3).pegType)).ToString(),
							PosX = ((Component)val3).transform.position.x,
							PosY = ((Component)val3).transform.position.y,
							RotZ = ((Component)val3).transform.localEulerAngles.z,
							SlimeType = (int)((Peg)val3).slimeType,
							IsDestroyed = flag4,
							IsParentHidden = isParentHidden2,
							IsCleared = isCleared,
							WasPreviouslyCleared = wasPreviouslyCleared2,
							CoinCount = ((Peg)val3).NumCoins(),
							HitCount = val3.HitCount,
							IsBomb = true,
							BuffAmount = ((Peg)val3).buffAmount
						};
						CaptureShieldState((Peg)(object)val3, pegEntry2);
						CaptureLpmParentPos((Peg)(object)val3, pegEntry2);
						CaptureStructKey((Peg)(object)val3, pegEntry2);
						pegboardStateSnapshot.Pegs.Add(pegEntry2);
						if (((Component)val3).gameObject.activeInHierarchy && !flag4)
						{
							pegboardStateSnapshot.BombPegCount++;
						}
					}
				}
				List<BouncerPeg> bouncerPegs = val.bouncerPegs;
				if (bouncerPegs != null)
				{
					for (int k = 0; k < bouncerPegs.Count; k++)
					{
						BouncerPeg val4 = bouncerPegs[k];
						if ((Object)(object)val4 == (Object)null)
						{
							continue;
						}
						string orAssignGuid3 = _pegId.GetOrAssignGuid((Peg)(object)val4);
						int num4 = (int)((Peg)val4).pegType;
						bool isParentHidden3 = ((Component)val4).gameObject.activeSelf && !((Component)val4).gameObject.activeInHierarchy;
						bool flag5 = !((Component)val4).gameObject.activeInHierarchy || (num4 & 0x20) != 0;
						bool isCleared2 = false;
						bool wasPreviouslyCleared3 = false;
						if (!flag5)
						{
							try
							{
								isCleared2 = ((Peg)val4).IsDisabled();
							}
							catch
							{
							}
							try
							{
								wasPreviouslyCleared3 = (bool)(AccessTools.Field(typeof(Peg), "_cleared")?.GetValue(val4) ?? ((object)false));
							}
							catch
							{
							}
						}
						PegEntry pegEntry3 = new PegEntry
						{
							Guid = orAssignGuid3,
							Index = allPegs.Count + (list?.Count ?? 0) + k,
							PegType = num4,
							PegTypeName = ((object)(PegType)(ref ((Peg)val4).pegType)).ToString(),
							PosX = ((Component)val4).transform.position.x,
							PosY = ((Component)val4).transform.position.y,
							RotZ = ((Component)val4).transform.localEulerAngles.z,
							SlimeType = (int)((Peg)val4).slimeType,
							IsDestroyed = flag5,
							IsParentHidden = isParentHidden3,
							IsCleared = isCleared2,
							WasPreviouslyCleared = wasPreviouslyCleared3,
							CoinCount = ((Peg)val4).NumCoins(),
							IsBouncer = true,
							BuffAmount = ((Peg)val4).buffAmount
						};
						CaptureShieldState((Peg)(object)val4, pegEntry3);
						CaptureLpmParentPos((Peg)(object)val4, pegEntry3);
						CaptureStructKey((Peg)(object)val4, pegEntry3);
						pegboardStateSnapshot.Pegs.Add(pegEntry3);
						if (((Component)val4).gameObject.activeInHierarchy && !flag5)
						{
							pegboardStateSnapshot.BouncerPegCount++;
						}
					}
				}
				pegboardStateSnapshot.TotalPegCount = pegboardStateSnapshot.Pegs.Count;
				try
				{
					if (AccessTools.Field(typeof(PegManager), "_vines")?.GetValue(val) is List<PegBoardBramballVine> list2 && list2.Count > 0)
					{
						FieldInfo fieldInfo = AccessTools.Field(typeof(PegBoardBramballVine), "_peg1");
						FieldInfo fieldInfo2 = AccessTools.Field(typeof(PegBoardBramballVine), "_peg2");
						foreach (PegBoardBramballVine item in list2)
						{
							if ((Object)(object)item == (Object)null)
							{
								continue;
							}
							object? obj9 = fieldInfo?.GetValue(item);
							Peg val5 = (Peg)((obj9 is Peg) ? obj9 : null);
							object? obj10 = fieldInfo2?.GetValue(item);
							Peg val6 = (Peg)((obj10 is Peg) ? obj10 : null);
							if (!((Object)(object)val5 == (Object)null) && !((Object)(object)val6 == (Object)null))
							{
								string guid = _pegId.GetGuid(val5);
								string guid2 = _pegId.GetGuid(val6);
								if (guid != null && guid2 != null)
								{
									pegboardStateSnapshot.Vines.Add(new VineEntry
									{
										Peg1Guid = guid,
										Peg2Guid = guid2
									});
								}
							}
						}
						_log.LogInfo((object)$"[PegProvider] Captured {pegboardStateSnapshot.Vines.Count} bramball vines from {list2.Count} in _vines list");
					}
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[PegProvider] Failed to capture vines: " + ex.Message));
				}
				CaptureBlackHoles(pegboardStateSnapshot);
				CaptureSplineGenerators(pegboardStateSnapshot);
				CaptureObscurerGrid(pegboardStateSnapshot);
				int num5 = list?.Count ?? (-1);
				(int, int, int, int, int, int, int, int, int, int) lastCaptureSig = (pegboardStateSnapshot.TotalPegCount, pegboardStateSnapshot.CritPegCount, pegboardStateSnapshot.BombPegCount, pegboardStateSnapshot.ResetPegCount, pegboardStateSnapshot.BouncerPegCount, _pegId.Count, num5, num, pegboardStateSnapshot.BlackHoles.Count, pegboardStateSnapshot.SplineGenerators.Count);
				if (!lastCaptureSig.Equals(_lastCaptureSig))
				{
					_lastCaptureSig = lastCaptureSig;
					_log.LogInfo((object)($"[PegProvider] Captured {pegboardStateSnapshot.TotalPegCount} pegs from PegManager " + $"(crit={pegboardStateSnapshot.CritPegCount}, bomb={pegboardStateSnapshot.BombPegCount}, reset={pegboardStateSnapshot.ResetPegCount}, " + $"bouncer={pegboardStateSnapshot.BouncerPegCount}, registry={_pegId.Count}, " + $"_bombs={num5}, allPegsBombs={num}, " + $"blackHoles={pegboardStateSnapshot.BlackHoles.Count}, splineGens={pegboardStateSnapshot.SplineGenerators.Count})"));
				}
				return pegboardStateSnapshot;
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("PegboardStateProvider.Capture failed: " + ex2.Message));
				return null;
			}
		}

		private static void CaptureShieldState(Peg peg, PegEntry entry)
		{
			try
			{
				if (peg.shielded)
				{
					entry.IsShielded = true;
					object? obj = AccessTools.Field(typeof(Peg), "PegShieldOverlayInstance")?.GetValue(peg);
					PegShieldOverlay val = (PegShieldOverlay)((obj is PegShieldOverlay) ? obj : null);
					if ((Object)(object)val != (Object)null)
					{
						entry.ShieldHitCount = val.hitCount;
						entry.ShieldHitLimit = val.hitLimit;
					}
				}
			}
			catch
			{
			}
		}

		private static void CaptureLpmParentPos(Peg peg, PegEntry entry)
		{
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_009d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				LinearPegMovement component = ((Component)peg).GetComponent<LinearPegMovement>();
				if ((Object)(object)component == (Object)null && (Object)(object)((Component)peg).transform.parent != (Object)null)
				{
					component = ((Component)((Component)peg).transform.parent).GetComponent<LinearPegMovement>();
				}
				if ((Object)(object)component == (Object)null)
				{
					Transform parent = ((Component)peg).transform.parent;
					if ((Object)(object)((parent != null) ? parent.parent : null) != (Object)null)
					{
						component = ((Component)((Component)peg).transform.parent.parent).GetComponent<LinearPegMovement>();
					}
				}
				if ((Object)(object)component != (Object)null)
				{
					entry.LpmParentPosX = ((Component)component).transform.position.x;
					entry.LpmParentPosY = ((Component)component).transform.position.y;
				}
			}
			catch
			{
			}
		}

		private static void CaptureStructKey(Peg peg, PegEntry entry)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Transform parent = ((Component)peg).transform.parent;
				entry.ParentName = ParentChainKey(parent);
				Vector3 localPosition = ((Component)peg).transform.localPosition;
				entry.LocalPosX = localPosition.x;
				entry.LocalPosY = localPosition.y;
				entry.SiblingIndex = ((Component)peg).transform.GetSiblingIndex();
				entry.HasLpm = HasMovingAncestor(((Component)peg).transform);
			}
			catch
			{
			}
		}

		private void CaptureBlackHoles(PegboardStateSnapshot snapshot)
		{
			//IL_002d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_0048: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				PegboardBlackHole[] array = Resources.FindObjectsOfTypeAll<PegboardBlackHole>();
				int num = 0;
				foreach (PegboardBlackHole val in array)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
					{
						Scene scene = ((Component)val).gameObject.scene;
						if (((Scene)(ref scene)).name != null)
						{
							Vector3 position = ((Component)val).transform.position;
							snapshot.BlackHoles.Add(new BlackHoleEntry
							{
								Index = num,
								PosX = position.x,
								PosY = position.y
							});
							num++;
						}
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[PegProvider] Failed to capture black holes: " + ex.Message));
			}
		}

		private void CaptureSplineGenerators(PegboardStateSnapshot snapshot)
		{
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(PegSplineFollow), "_pegSplineDistances");
				if (fieldInfo == null)
				{
					return;
				}
				PegSplineFollow[] array = Object.FindObjectsOfType<PegSplineFollow>();
				foreach (PegSplineFollow val in array)
				{
					if (!((Object)(object)val == (Object)null) && fieldInfo.GetValue(val) is List<float> list && list.Count != 0)
					{
						Transform parent = ((Component)val).transform.parent;
						SplineGeneratorEntry splineGeneratorEntry = new SplineGeneratorEntry
						{
							HierarchyPath = HierarchyPath(((Component)val).transform),
							Phase = list[0],
							NumPegs = list.Count
						};
						splineGeneratorEntry.Distances.Capacity = list.Count;
						for (int j = 0; j < list.Count; j++)
						{
							splineGeneratorEntry.Distances.Add(list[j]);
						}
						if ((Object)(object)parent != (Object)null)
						{
							Vector3 position = parent.position;
							splineGeneratorEntry.ParentPosX = position.x;
							splineGeneratorEntry.ParentPosY = position.y;
							splineGeneratorEntry.HasParent = true;
						}
						snapshot.SplineGenerators.Add(splineGeneratorEntry);
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[PegProvider] Failed to capture spline generators: " + ex.Message));
			}
		}

		private void CaptureObscurerGrid(PegboardStateSnapshot snapshot)
		{
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0163: Expected I4, but got Unknown
			try
			{
				RandomObscuredPegGrid val = FindLiveObscurerGrid();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if ((object)_obscurerGridField == null)
				{
					_obscurerGridField = AccessTools.Field(typeof(RandomObscuredPegGrid), "_pegGrid");
				}
				if ((object)_obscurerWidthField == null)
				{
					_obscurerWidthField = AccessTools.Field(typeof(RandomObscuredPegGrid), "_gridWidth");
				}
				if ((object)_obscurerHeightField == null)
				{
					_obscurerHeightField = AccessTools.Field(typeof(RandomObscuredPegGrid), "_gridHeight");
				}
				if (_obscurerGridField == null || _obscurerWidthField == null || _obscurerHeightField == null || !(_obscurerGridField.GetValue(val) is PegGridObscurer[,] array))
				{
					return;
				}
				int num = (int)(_obscurerWidthField.GetValue(val) ?? ((object)0));
				int num2 = (int)(_obscurerHeightField.GetValue(val) ?? ((object)0));
				if (num <= 0 || num2 <= 0)
				{
					return;
				}
				ObscurerGridSnapshot obscurerGridSnapshot = new ObscurerGridSnapshot
				{
					Width = num,
					Height = num2
				};
				for (int i = 0; i < num; i++)
				{
					for (int j = 0; j < num2; j++)
					{
						PegGridObscurer val2 = array[i, j];
						if (!((Object)(object)val2 == (Object)null) && val2.isRevealed)
						{
							obscurerGridSnapshot.RevealedCells.Add(new ObscurerCellEntry
							{
								X = i,
								Y = j,
								RevealedPegType = (int)val2.revealedPegType
							});
						}
					}
				}
				snapshot.ObscurerGrid = obscurerGridSnapshot;
				(int, int, int) lastObscurerCaptureSig = (num, num2, obscurerGridSnapshot.RevealedCells.Count);
				if (!lastObscurerCaptureSig.Equals(_lastObscurerCaptureSig))
				{
					_lastObscurerCaptureSig = lastObscurerCaptureSig;
					_log.LogInfo((object)$"[PegProvider] Captured obscurer grid {num}x{num2} ({obscurerGridSnapshot.RevealedCells.Count} revealed)");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[PegProvider] Failed to capture obscurer grid: " + ex.Message));
			}
		}

		private static RandomObscuredPegGrid FindLiveObscurerGrid()
		{
			RandomObscuredPegGrid[] array = Object.FindObjectsOfType<RandomObscuredPegGrid>(true);
			foreach (RandomObscuredPegGrid val in array)
			{
				if ((Object)(object)val != (Object)null && !((NonDummyPegboardBehaviour)val).isDummy)
				{
					return val;
				}
			}
			return null;
		}

		public static string ParentChainKey(Transform parent)
		{
			if ((Object)(object)parent == (Object)null)
			{
				return string.Empty;
			}
			return HierarchyPath(parent);
		}

		public static void ClearHierarchyCaches()
		{
			_hierarchyPathCache.Clear();
			_movingAncestorCache.Clear();
		}

		private static string HierarchyPath(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return string.Empty;
			}
			int instanceID = ((Object)t).GetInstanceID();
			if (_hierarchyPathCache.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			List<string> list = _hierarchyPathBuf ?? (_hierarchyPathBuf = new List<string>(8));
			list.Clear();
			Transform val = t;
			while ((Object)(object)val != (Object)null)
			{
				list.Add(((Object)val).name);
				val = val.parent;
			}
			list.Reverse();
			string text = string.Join("/", list);
			_hierarchyPathCache[instanceID] = text;
			return text;
		}

		private static bool HasMovingAncestor(Transform t)
		{
			if ((Object)(object)t == (Object)null)
			{
				return false;
			}
			int instanceID = ((Object)t).GetInstanceID();
			if (_movingAncestorCache.TryGetValue(instanceID, out var value))
			{
				return value;
			}
			bool flag = false;
			Transform val = t;
			while ((Object)(object)val != (Object)null)
			{
				if ((Object)(object)((Component)val).GetComponent<LinearPegMovement>() != (Object)null || (Object)(object)((Component)val).GetComponent<PegSplineFollow>() != (Object)null || (Object)(object)((Component)val).GetComponent<RotatingPegCircle>() != (Object)null || (Object)(object)((Component)val).GetComponent<PegMoveAndReturn>() != (Object)null || (Object)(object)((Component)val).GetComponent<PegSquareMovement>() != (Object)null || (Object)(object)((Component)val).GetComponent<PegTeleport>() != (Object)null || (Object)(object)((Component)val).GetComponent<SimpleMovablePeg>() != (Object)null || (Object)(object)((Component)val).GetComponent<FireworkMovement>() != (Object)null)
				{
					flag = true;
					break;
				}
				val = val.parent;
			}
			_movingAncestorCache[instanceID] = flag;
			return flag;
		}
	}
	public class PlayerStateProvider : IGameStateProvider<PlayerStateSnapshot>
	{
		private readonly ManualLogSource _log;

		public PlayerStateProvider(ManualLogSource log)
		{
			_log = log;
		}

		public PlayerStateSnapshot Capture()
		{
			try
			{
				PlayerStateSnapshot playerStateSnapshot = new PlayerStateSnapshot();
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val != (Object)null)
				{
					playerStateSnapshot.CurrentHealth = Mathf.Max(0f, val.CurrentHealth);
					object obj = AccessTools.Field(typeof(PlayerHealthController), "_maxPlayerHealth")?.GetValue(val);
					if (obj != null)
					{
						playerStateSnapshot.MaxHealth = (float)(AccessTools.Property(obj.GetType(), "Value")?.GetValue(obj) ?? ((object)0f));
					}
				}
				try
				{
					Type typeFromHandle = typeof(CurrencyManager);
					object obj2 = AccessTools.Property(typeFromHandle, "Instance")?.GetValue(null);
					if (obj2 != null)
					{
						playerStateSnapshot.Gold = (int)(AccessTools.Property(typeFromHandle, "GoldAmount")?.GetValue(obj2) ?? ((object)0));
					}
				}
				catch
				{
				}
				PlayerStatusEffectController val2 = Object.FindObjectOfType<PlayerStatusEffectController>();
				if ((Object)(object)val2 != (Object)null)
				{
					try
					{
						if (AccessTools.Field(typeof(PlayerStatusEffectController), "_statusEffects")?.GetValue(val2) is IList list)
						{
							foreach (object item in list)
							{
								FieldInfo fieldInfo = AccessTools.Field(item.GetType(), "EffectType");
								FieldInfo fieldInfo2 = AccessTools.Field(item.GetType(), "Intensity");
								if (fieldInfo != null)
								{
									object value = fieldInfo.GetValue(item);
									playerStateSnapshot.StatusEffects.Add(new StatusEffectEntry
									{
										EffectType = (int)value,
										EffectName = value.ToString(),
										Intensity = (int)(fieldInfo2?.GetValue(item) ?? ((object)0))
									});
								}
							}
						}
					}
					catch
					{
					}
				}
				try
				{
					TimescaleManager val3 = Object.FindObjectOfType<TimescaleManager>();
					if ((Object)(object)val3 != (Object)null)
					{
						playerStateSnapshot.IsSpedUp = (bool)(AccessTools.Property(typeof(TimescaleManager), "isSpedUp")?.GetValue(val3) ?? ((object)false));
					}
					if ((Object)(object)SettingsManager.Instance != (Object)null)
					{
						playerStateSnapshot.SpeedupLevel = SettingsManager.Instance.SpeedupLevel;
					}
				}
				catch
				{
				}
				return playerStateSnapshot;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("PlayerStateProvider.Capture failed: " + ex.Message));
				return null;
			}
		}
	}
	public class RelicStateProvider : IGameStateProvider<RelicStateSnapshot>
	{
		private readonly ManualLogSource _log;

		public RelicStateProvider(ManualLogSource log)
		{
			_log = log;
		}

		public RelicStateSnapshot Capture()
		{
			//IL_0146: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01aa: Expected I4, but got Unknown
			//IL_01ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RelicStateSnapshot relicStateSnapshot = new RelicStateSnapshot();
				RelicManager[] array = Resources.FindObjectsOfTypeAll<RelicManager>();
				RelicManager val = ((array.Length != 0) ? array[0] : null);
				if ((Object)(object)val == (Object)null)
				{
					return relicStateSnapshot;
				}
				if (!(AccessTools.Field(typeof(RelicManager), "_ownedRelics")?.GetValue(val) is IDictionary<RelicEffect, Relic> dictionary))
				{
					return relicStateSnapshot;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(RelicManager), "_relicRemainingCountdowns");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(RelicManager), "_relicRemainingUsesPerShot");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(RelicManager), "_relicRemainingUsesPerBattle");
				FieldInfo fieldInfo4 = AccessTools.Field(typeof(RelicManager), "_relicRemainingUsesPerRun");
				IDictionary<RelicEffect, int> dictionary2 = fieldInfo?.GetValue(val) as IDictionary<RelicEffect, int>;
				IDictionary<RelicEffect, int> dictionary3 = fieldInfo2?.GetValue(val) as IDictionary<RelicEffect, int>;
				IDictionary<RelicEffect, int> dictionary4 = fieldInfo3?.GetValue(val) as IDictionary<RelicEffect, int>;
				IDictionary<RelicEffect, int> dictionary5 = fieldInfo4?.GetValue(val) as IDictionary<RelicEffect, int>;
				foreach (KeyValuePair<RelicEffect, Relic> item in dictionary)
				{
					Relic value = item.Value;
					if (!((Object)(object)value == (Object)null))
					{
						int value2 = 0;
						int value3 = 0;
						int value4 = 0;
						int value5 = 0;
						dictionary2?.TryGetValue(item.Key, out value2);
						dictionary3?.TryGetValue(item.Key, out value3);
						dictionary4?.TryGetValue(item.Key, out value4);
						dictionary5?.TryGetValue(item.Key, out value5);
						List<RelicEntry> ownedRelics = relicStateSnapshot.OwnedRelics;
						RelicEntry obj = new RelicEntry
						{
							Effect = (int)item.Key
						};
						RelicEffect key = item.Key;
						obj.EffectName = ((object)(RelicEffect)(ref key)).ToString();
						obj.LocKey = value.locKey ?? string.Empty;
						obj.Rarity = 0;
						obj.RemainingCountdown = value2;
						obj.RemainingUsesPerShot = value3;
						obj.RemainingUsesPerBattle = value4;
						obj.RemainingUsesPerRun = value5;
						obj.IsEnabled = true;
						ownedRelics.Add(obj);
					}
				}
				relicStateSnapshot.TotalRelicCount = relicStateSnapshot.OwnedRelics.Count;
				return relicStateSnapshot;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("RelicStateProvider.Capture failed: " + ex.Message));
				return null;
			}
		}
	}
	public class TextScenarioStateProvider
	{
		private readonly ManualLogSource _log;

		public TextScenarioStateProvider(ManualLogSource log)
		{
			_log = log;
		}

		public TextScenarioStateSnapshot Capture()
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0005: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name != "TextScenario")
				{
					return null;
				}
				TextScenarioStateSnapshot textScenarioStateSnapshot = new TextScenarioStateSnapshot
				{
					IsActive = DialogueManager.isConversationActive,
					IsNavigating = TextScenarioHoverTracker.IsNavigating,
					HighlightedIndex = TextScenarioHoverTracker.CurrentHoveredIndex
				};
				DialogueSystemScenario val = Object.FindObjectOfType<DialogueSystemScenario>();
				if ((Object)(object)val != (Object)null)
				{
					object? obj = AccessTools.Field(typeof(DialogueSystemScenario), "_activeMapData")?.GetValue(val);
					MapDataScenario val2 = (MapDataScenario)((obj is MapDataScenario) ? obj : null);
					if ((Object)(object)val2 != (Object)null)
					{
						textScenarioStateSnapshot.ScenarioName = val2.scenarioName;
						textScenarioStateSnapshot.IsMirrorEvent = IsMirrorScenario(val2.scenarioName);
					}
				}
				if (textScenarioStateSnapshot.IsActive)
				{
					CaptureDialogueState(textScenarioStateSnapshot);
				}
				return textScenarioStateSnapshot;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[TextScenarioProvider] Capture failed: " + ex.Message));
				return null;
			}
		}

		private void CaptureDialogueState(TextScenarioStateSnapshot snapshot)
		{
			try
			{
				StandardDialogueUI val = Object.FindObjectOfType<StandardDialogueUI>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				StandardUIDialogueControls conversationUIElements = val.conversationUIElements;
				if (conversationUIElements == null)
				{
					return;
				}
				StandardUISubtitlePanel defaultNPCSubtitlePanel = conversationUIElements.defaultNPCSubtitlePanel;
				if ((Object)(object)defaultNPCSubtitlePanel != (Object)null)
				{
					Subtitle currentSubtitle = defaultNPCSubtitlePanel.currentSubtitle;
					if (currentSubtitle != null)
					{
						FormattedText formattedText = currentSubtitle.formattedText;
						snapshot.SubtitleText = ((formattedText != null) ? formattedText.text : null) ?? string.Empty;
						snapshot.SpeakerName = defaultNPCSubtitlePanel.portraitActorName ?? string.Empty;
					}
					else
					{
						UITextField subtitleText = defaultNPCSubtitlePanel.subtitleText;
						snapshot.SubtitleText = ((subtitleText != null) ? subtitleText.text : null) ?? string.Empty;
						UITextField portraitName = defaultNPCSubtitlePanel.portraitName;
						snapshot.SpeakerName = ((portraitName != null) ? portraitName.text : null) ?? string.Empty;
					}
				}
				StandardUIMenuPanel defaultMenuPanel = conversationUIElements.defaultMenuPanel;
				if (defaultMenuPanel?.buttons == null)
				{
					return;
				}
				snapshot.Responses = new List<string>();
				StandardUIResponseButton[] buttons = defaultMenuPanel.buttons;
				foreach (StandardUIResponseButton val2 in buttons)
				{
					if ((Object)(object)val2 != (Object)null && ((Component)val2).gameObject.activeInHierarchy && val2.isVisible)
					{
						snapshot.Responses.Add(val2.text ?? string.Empty);
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[TextScenarioProvider] CaptureDialogueState failed: " + ex.Message));
			}
		}

		private static bool IsMirrorScenario(string scenarioName)
		{
			if (string.IsNullOrEmpty(scenarioName))
			{
				return false;
			}
			return scenarioName.IndexOf("Mirror", StringComparison.OrdinalIgnoreCase) >= 0;
		}
	}
}
namespace Multipeglin.GameState.Appliers
{
	public class DeckStateApplier : IGameStateApplier<DeckStateSnapshot>
	{
		private readonly ManualLogSource _log;

		private readonly OrbIdentifier _orbId;

		public DeckStateApplier(ManualLogSource log, OrbIdentifier orbId)
		{
			_log = log;
			_orbId = orbId;
		}

		public void Apply(DeckStateSnapshot snapshot)
		{
			//IL_052a: Unknown result type (might be due to invalid IL or missing references)
			//IL_052f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_0455: Unknown result type (might be due to invalid IL or missing references)
			//IL_045a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0468: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
				DeckManager val = ((array.Length != 0) ? array[0] : null);
				if ((Object)(object)val == (Object)null)
				{
					_log.LogWarning((object)"[DeckApplier] DeckManager not found");
					return;
				}
				bool flag = false;
				if (snapshot.CompleteDeck != null && snapshot.CompleteDeck.Count > 0)
				{
					flag |= SyncCompleteDeck(val, snapshot.CompleteDeck);
				}
				if (snapshot.BattleDeck != null && snapshot.BattleDeck.Count > 0)
				{
					flag |= SyncBattleDeck(val, snapshot.BattleDeck);
				}
				if (flag)
				{
					_log.LogInfo((object)($"[DeckApplier] Deck sync: completeDeck={DeckManager.completeDeck?.Count ?? 0}, " + $"battleDeck={val.battleDeck?.Count ?? 0}, shuffledDeck={val.shuffledDeck?.Count ?? 0}"));
				}
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name == "Battle" && val.battleDeck != null && val.battleDeck.Count > 0)
				{
					try
					{
						bool flag2 = true;
						if (flag2 && snapshot.ShuffledOrder != null && snapshot.ShuffledOrder.Count > 0)
						{
							val.shuffledDeck.Clear();
							for (int num = snapshot.ShuffledOrder.Count - 1; num >= 0; num--)
							{
								string text = snapshot.ShuffledOrder[num];
								if (string.IsNullOrEmpty(snapshot.CurrentOrbGuid) || !(text == snapshot.CurrentOrbGuid))
								{
									GameObject val2 = null;
									if (text.Length == 12 && IsHexString(text))
									{
										val2 = _orbId.Find(text);
									}
									if ((Object)(object)val2 == (Object)null)
									{
										string text2 = text.Replace("(Clone)", string.Empty).Trim();
										for (int i = 0; i < val.battleDeck.Count; i++)
										{
											if ((Object)(object)val.battleDeck[i] != (Object)null && ((Object)val.battleDeck[i]).name.Replace("(Clone)", string.Empty).Trim() == text2)
											{
												val2 = val.battleDeck[i];
												break;
											}
										}
									}
									if ((Object)(object)val2 != (Object)null)
									{
										val.shuffledDeck.Push(val2);
									}
								}
							}
						}
						else if (flag2 && snapshot.ShuffledOrder == null)
						{
							val.shuffledDeck.Clear();
							for (int num2 = val.battleDeck.Count - 1; num2 >= 0; num2--)
							{
								if ((Object)(object)val.battleDeck[num2] != (Object)null)
								{
									val.shuffledDeck.Push(val.battleDeck[num2]);
								}
							}
						}
						else if (flag2 && snapshot.ShuffledOrder != null && snapshot.ShuffledOrder.Count == 0)
						{
							val.shuffledDeck.Clear();
						}
						if (snapshot.ShuffledOrder != null && snapshot.ShuffledOrder.Count > 0)
						{
							int count = snapshot.ShuffledOrder.Count;
							int num3 = 0;
							Stack<GameObject> stack = null;
							try
							{
								DeckInfoManager val3 = Object.FindObjectOfType<DeckInfoManager>();
								if ((Object)(object)val3 != (Object)null)
								{
									stack = AccessTools.Field(typeof(DeckInfoManager), "_displayOrbs")?.GetValue(val3) as Stack<GameObject>;
								}
							}
							catch (Exception ex)
							{
								_log.LogWarning((object)("[DeckApplier] Failed to get _displayOrbs: " + ex.Message));
							}
							while (val.shuffledDeck.Count > count && val.shuffledDeck.Count > 0)
							{
								val.shuffledDeck.Pop();
								if (stack != null && stack.Count > 0)
								{
									GameObject val4 = stack.Pop();
									if ((Object)(object)val4 != (Object)null)
									{
										Object.Destroy((Object)(object)val4);
									}
								}
								num3++;
							}
							if (num3 > 0)
							{
								_log.LogInfo((object)$"[DeckApplier] Trimmed {num3} orbs from shuffledDeck+displayOrbs to match host count {count}");
								try
								{
									DeckInfoManager val5 = Object.FindObjectOfType<DeckInfoManager>();
									if ((Object)(object)val5 != (Object)null)
									{
										object? obj = AccessTools.Field(typeof(DeckInfoManager), "_plungerParent")?.GetValue(val5);
										Transform val6 = (Transform)((obj is Transform) ? obj : null);
										if ((Object)(object)val6 != (Object)null)
										{
											val6.position += Vector3.up * ((float)num3 * 0.875f);
											_log.LogInfo((object)$"[DeckApplier] Moved plunger parent up by {(float)num3 * 0.875f:F3} to fill gap");
										}
									}
								}
								catch (Exception ex2)
								{
									_log.LogWarning((object)("[DeckApplier] Failed to adjust plunger position: " + ex2.Message));
								}
							}
						}
						try
						{
							IServiceContainer services = MultiplayerPlugin.Services;
							if (services != null && services.TryResolve<CoopStateManager>(out var instance))
							{
								instance.RebuildDeckInfoDisplay(val);
							}
						}
						catch (Exception ex3)
						{
							_log.LogWarning((object)("[DeckApplier] RebuildDeckInfoDisplay call failed: " + ex3.Message));
						}
					}
					catch (Exception ex4)
					{
						_log.LogWarning((object)("[DeckApplier] Deck display trigger failed: " + ex4.Message + "\n" + ex4.StackTrace));
					}
				}
				activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				if (!string.IsNullOrEmpty(snapshot.CurrentOrb) && name == "Battle")
				{
					EnsureDeckUIShowsActiveOrb(val, snapshot.CurrentOrb);
					EnsureAimerOrbShown(snapshot.CurrentOrb);
				}
				else if (name == "Battle")
				{
					ClearActiveOrbDisplay();
				}
				VerifyDeckState(val, snapshot);
			}
			catch (Exception ex5)
			{
				_log.LogError((object)("[DeckApplier] Apply failed: " + ex5.Message + "\n" + ex5.StackTrace));
			}
		}

		public void ApplyActiveOrbOnly(DeckStateSnapshot snapshot)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			if (snapshot == null || string.IsNullOrEmpty(snapshot.CurrentOrb))
			{
				return;
			}
			Scene activeScene = SceneManager.GetActiveScene();
			if (((Scene)(ref activeScene)).name != "Battle")
			{
				return;
			}
			try
			{
				EnsureAimerOrbShown(snapshot.CurrentOrb);
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[DeckApplier] ApplyActiveOrbOnly failed: " + ex.Message));
			}
		}

		public void ClearActiveOrbDisplay()
		{
			try
			{
				DeckInfoManager val = Object.FindObjectOfType<DeckInfoManager>();
				if (!((Object)(object)val == (Object)null))
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(DeckInfoManager), "_currentOrb");
					object? obj = fieldInfo?.GetValue(val);
					GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
					if ((Object)(object)val2 != (Object)null)
					{
						Object.Destroy((Object)(object)val2);
						fieldInfo.SetValue(val, null);
					}
					AccessTools.Field(typeof(DeckInfoManager), "_nextOrb")?.SetValue(val, null);
					DeckInfoManager.populatingDisplayOrb = false;
					DeckInfoManager.animating = false;
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[DeckApplier] ClearActiveOrbDisplay failed: " + ex.Message));
			}
		}

		public void RefreshActiveOrbDisplay(string activeOrbName)
		{
			if (string.IsNullOrEmpty(activeOrbName))
			{
				ClearActiveOrbDisplay();
				return;
			}
			DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
			DeckManager val = ((array.Length != 0) ? array[0] : null);
			if (!((Object)(object)val == (Object)null))
			{
				EnsureDeckUIShowsActiveOrb(val, activeOrbName);
			}
		}

		private void EnsureDeckUIShowsActiveOrb(DeckManager dm, string activeOrbName)
		{
			//IL_028e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0298: Unknown result type (might be due to invalid IL or missing references)
			//IL_027d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0400: Unknown result type (might be due to invalid IL or missing references)
			//IL_0429: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				DeckInfoManager val = Object.FindObjectOfType<DeckInfoManager>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(DeckInfoManager), "_currentOrb");
				object? obj = fieldInfo?.GetValue(val);
				GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
				if ((Object)(object)val2 != (Object)null)
				{
					Object.Destroy((Object)(object)val2);
					fieldInfo.SetValue(val, null);
				}
				if (DeckInfoManager.animating)
				{
					object? obj2 = AccessTools.Field(typeof(DeckInfoManager), "_plungerParent")?.GetValue(val);
					Transform val3 = (Transform)((obj2 is Transform) ? obj2 : null);
					if ((Object)(object)val3 != (Object)null)
					{
						int num = 0;
						while (DeckInfoManager.animating && num++ < 5)
						{
							DOTween.Complete((object)val3, true);
						}
					}
				}
				string text = activeOrbName.Replace("(Clone)", string.Empty).Trim();
				GameObject val4 = null;
				if (dm.battleDeck != null)
				{
					foreach (GameObject item in dm.battleDeck)
					{
						if ((Object)(object)item != (Object)null && ((Object)item).name.Replace("(Clone)", string.Empty).Trim() == text)
						{
							val4 = item;
							break;
						}
					}
				}
				if ((Object)(object)val4 == (Object)null)
				{
					AssetLoading instance = AssetLoading.Instance;
					val4 = ((instance != null) ? instance.GetOrbPrefab(text) : null);
				}
				if ((Object)(object)val4 == (Object)null)
				{
					_log.LogWarning((object)("[DeckApplier] Cannot find orb '" + text + "' for active display"));
					return;
				}
				MethodInfo methodInfo = AccessTools.Method(typeof(DeckInfoManager), "CreatePreviewSprite", new Type[2]
				{
					typeof(GameObject),
					typeof(float)
				}, (Type[])null);
				if (methodInfo == null)
				{
					_log.LogWarning((object)"[DeckApplier] CreatePreviewSprite method not found");
					return;
				}
				bool activeSelf = val4.activeSelf;
				if (!activeSelf)
				{
					val4.SetActive(true);
				}
				object? obj3 = methodInfo.Invoke(val, new object[2] { val4, 0f });
				GameObject val5 = (GameObject)((obj3 is GameObject) ? obj3 : null);
				if (!activeSelf)
				{
					val4.SetActive(false);
				}
				if ((Object)(object)val5 == (Object)null)
				{
					_log.LogWarning((object)"[DeckApplier] CreatePreviewSprite returned null for active orb");
					return;
				}
				val5.transform.SetParent((Transform)null);
				object? obj4 = AccessTools.Field(typeof(DeckInfoManager), "_currentOrbDisplayPos")?.GetValue(val);
				Transform val6 = (Transform)((obj4 is Transform) ? obj4 : null);
				if ((Object)(object)val6 != (Object)null)
				{
					val5.transform.position = val6.position;
				}
				val5.transform.localScale = Vector3.one * 0.85f;
				UpcomingOrbDisplay componentInChildren = val5.GetComponentInChildren<UpcomingOrbDisplay>();
				int num2 = 0;
				if ((Object)(object)((componentInChildren != null) ? componentInChildren.attack : null) != (Object)null)
				{
					num2 = Mathf.Clamp(componentInChildren.attack.Level - 1, 0, 2);
				}
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(DeckInfoManager), "_currentOrbLevelRingRenderer");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(DeckInfoManager), "_orbLevelDisplaySprites");
				object? obj5 = fieldInfo2?.GetValue(val);
				SpriteRenderer val7 = (SpriteRenderer)((obj5 is SpriteRenderer) ? obj5 : null);
				Sprite[] array = fieldInfo3?.GetValue(val) as Sprite[];
				if ((Object)(object)val7 != (Object)null && array != null && num2 < array.Length)
				{
					val7.sprite = array[num2];
				}
				if ((Object)(object)((componentInChildren != null) ? componentInChildren.mainOrbLevelFrameMask : null) != (Object)null)
				{
					componentInChildren.mainOrbLevelFrameMask.SetActive(true);
				}
				val5.SetActive(true);
				fieldInfo?.SetValue(val, val5);
				AccessTools.Field(typeof(DeckInfoManager), "_nextOrb")?.SetValue(val, null);
				OrbInfoEvent onActiveOrbScaleStarted = DeckInfoManager.onActiveOrbScaleStarted;
				if (onActiveOrbScaleStarted != null)
				{
					onActiveOrbScaleStarted.Invoke(val5);
				}
				DeckInfoAnim onActiveOrbScaleCompleted = DeckInfoManager.onActiveOrbScaleCompleted;
				if (onActiveOrbScaleCompleted != null)
				{
					onActiveOrbScaleCompleted.Invoke();
				}
				DeckInfoManager.populatingDisplayOrb = false;
				DeckInfoManager.animating = false;
				_log.LogInfo((object)$"[DeckApplier] Set active orb in deck UI: '{activeOrbName}' at ({((val6 != null) ? new float?(val6.position.x) : null):F1},{((val6 != null) ? new float?(val6.position.y) : null):F1}), displayOrbs remaining: {val.displayOrbs?.Count ?? 0}");
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[DeckApplier] EnsureDeckUIShowsActiveOrb failed: " + ex.Message));
			}
		}

		private void EnsureAimerOrbShown(string activeOrbName)
		{
			//IL_0110: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: 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_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0182: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: 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)
			try
			{
				ClientBallRenderer instance = ClientBallRenderer.Instance;
				if ((Object)(object)instance == (Object)null)
				{
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(ClientBallRenderer), "_isAiming");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(ClientBallRenderer), "_isActive");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(ClientBallRenderer), "_ballObject");
				FieldInfo fieldInfo4 = AccessTools.Field(typeof(ClientBallRenderer), "_ballRenderer");
				FieldInfo fieldInfo5 = AccessTools.Field(typeof(ClientBallRenderer), "_renderCopied");
				bool flag = (bool)(fieldInfo?.GetValue(instance) ?? ((object)false));
				bool flag2 = (bool)(fieldInfo2?.GetValue(instance) ?? ((object)false));
				object? obj = fieldInfo3?.GetValue(instance);
				object? obj2 = ((obj is GameObject) ? obj : null);
				object? obj3 = fieldInfo4?.GetValue(instance);
				SpriteRenderer val = (SpriteRenderer)((obj3 is SpriteRenderer) ? obj3 : null);
				bool flag3 = (bool)(fieldInfo5?.GetValue(instance) ?? ((object)false));
				Vector3 val2 = ((obj2 != null) ? ((GameObject)obj2).transform.position : Vector3.zero);
				Vector3 val3 = ((obj2 != null) ? ((GameObject)obj2).transform.localScale : Vector3.zero);
				ManualLogSource log = _log;
				string[] obj4 = new string[5]
				{
					$"[DeckApplier] AimerOrb: aiming={flag} active={flag2} ",
					$"pos=({val2.x:F1},{val2.y:F1},{val2.z:F1}) scale=({val3.x:F2},{val3.y:F2}) ",
					$"sprite={(Object)(object)((val != null) ? val.sprite : null) != (Object)null} enabled={((val != null) ? new bool?(((Renderer)val).enabled) : null)} color={((val != null) ? new Color?(val.color) : null)} ",
					null,
					null
				};
				object obj5;
				if (val == null)
				{
					obj5 = null;
				}
				else
				{
					Material material = ((Renderer)val).material;
					obj5 = ((material != null) ? ((Object)material).name : null);
				}
				if (obj5 == null)
				{
					obj5 = "NULL";
				}
				obj4[3] = $"material={obj5} layer={((val != null) ? ((Renderer)val).sortingLayerName : null)} order={((val != null) ? new int?(((Renderer)val).sortingOrder) : null)} ";
				obj4[4] = $"renderCopied={flag3}";
				log.LogInfo((object)string.Concat(obj4));
				if (flag || flag2)
				{
					string text = activeOrbName?.Replace("(Clone)", string.Empty).Trim();
					string currentOrbName = instance.CurrentOrbName;
					if (!string.IsNullOrEmpty(text) && currentOrbName != text)
					{
						_log.LogInfo((object)("[DeckApplier] Aimer orb stale: displayed='" + currentOrbName + "' host='" + text + "', refreshing"));
						instance.OnOrbDrawn(activeOrbName);
					}
				}
				else
				{
					instance.OnOrbDrawn(activeOrbName);
					_log.LogInfo((object)("[DeckApplier] Triggered aimer orb display for '" + activeOrbName + "'"));
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[DeckApplier] EnsureAimerOrbShown failed: " + ex.Message));
			}
		}

		private bool SyncCompleteDeck(DeckManager dm, List<OrbEntry> hostDeck)
		{
			List<GameObject> completeDeck = DeckManager.completeDeck;
			if (completeDeck == null)
			{
				DeckManager.completeDeck = new List<GameObject>();
				completeDeck = DeckManager.completeDeck;
			}
			if (completeDeck.Count == hostDeck.Count)
			{
				bool flag = true;
				for (int i = 0; i < hostDeck.Count; i++)
				{
					if (i >= completeDeck.Count || (Object)(object)completeDeck[i] == (Object)null)
					{
						flag = false;
						break;
					}
					if ((completeDeck[i].GetComponent<Attack>()?.locNameString ?? ((Object)completeDeck[i]).name) != hostDeck[i].LocName && ((Object)completeDeck[i]).name != hostDeck[i].Name)
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return false;
				}
			}
			int num = 0;
			List<GameObject> list = new List<GameObject>();
			foreach (OrbEntry item in hostDeck)
			{
				try
				{
					AssetLoading instance = AssetLoading.Instance;
					GameObject val = ((instance != null) ? instance.GetOrbPrefab(item.Name) : null);
					if ((Object)(object)val != (Object)null)
					{
						GameObject val2 = Object.Instantiate<GameObject>(val);
						((Object)val2).name = item.Name;
						val2.SetActive(false);
						Object.DontDestroyOnLoad((Object)(object)val2);
						list.Add(val2);
						num++;
					}
					else
					{
						_log.LogWarning((object)("[DeckApplier] Orb prefab not found: '" + item.Name + "'"));
					}
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[DeckApplier] Failed to load orb '" + item.Name + "': " + ex.Message));
				}
			}
			foreach (GameObject item2 in completeDeck)
			{
				if ((Object)(object)item2 != (Object)null)
				{
					Object.Destroy((Object)(object)item2);
				}
			}
			completeDeck.Clear();
			completeDeck.AddRange(list);
			_log.LogInfo((object)$"[DeckApplier] Rebuilt complete deck: {num}/{hostDeck.Count} orbs loaded");
			return true;
		}

		private bool SyncBattleDeck(DeckManager dm, List<OrbEntry> hostBattleDeck)
		{
			if (dm.battleDeck == null)
			{
				dm.battleDeck = new List<GameObject>();
			}
			if (dm.battleDeck.Count == hostBattleDeck.Count)
			{
				bool flag = true;
				for (int i = 0; i < hostBattleDeck.Count; i++)
				{
					string guid = hostBattleDeck[i].Guid;
					if (!string.IsNullOrEmpty(guid) && _orbId.GetGuid(dm.battleDeck[i]) != guid)
					{
						flag = false;
						break;
					}
				}
				if (flag)
				{
					return false;
				}
			}
			int num = 0;
			List<GameObject> list = new List<GameObject>();
			foreach (OrbEntry item in hostBattleDeck)
			{
				try
				{
					AssetLoading instance = AssetLoading.Instance;
					GameObject val = ((instance != null) ? instance.GetOrbPrefab(item.Name) : null);
					if ((Object)(object)val != (Object)null)
					{
						GameObject val2 = Object.Instantiate<GameObject>(val);
						((Object)val2).name = item.Name;
						val2.SetActive(false);
						Object.DontDestroyOnLoad((Object)(object)val2);
						list.Add(val2);
						num++;
						if (!string.IsNullOrEmpty(item.Guid))
						{
							_orbId.Register(val2, item.Guid);
						}
					}
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[DeckApplier] Failed to load battle orb: " + ex.Message));
				}
			}
			foreach (GameObject item2 in dm.battleDeck)
			{
				if ((Object)(object)item2 != (Object)null)
				{
					Object.Destroy((Object)(object)item2);
				}
			}
			dm.battleDeck.Clear();
			dm.battleDeck.AddRange(list);
			_log.LogInfo((object)$"[DeckApplier] Rebuilt battle deck: {num}/{hostBattleDeck.Count} orbs");
			return true;
		}

		private void LogActualDeckState(DeckManager dm)
		{
			try
			{
				List<GameObject> completeDeck = DeckManager.completeDeck;
				List<GameObject> battleDeck = dm.battleDeck;
				Stack<GameObject> shuffledDeck = dm.shuffledDeck;
				_log.LogInfo((object)($"[DeckApplier] CLIENT ACTUAL: complete={completeDeck?.Count ?? 0}, " + $"battle={battleDeck?.Count ?? 0}, shuffled={shuffledDeck?.Count ?? 0}"));
				if (completeDeck != null)
				{
					for (int i = 0; i < completeDeck.Count; i++)
					{
						GameObject val = completeDeck[i];
						Attack val2 = ((val != null) ? val.GetComponent<Attack>() : null);
						_log.LogInfo((object)string.Format("[DeckApplier]   complete[{0}]: {1} loc={2}", i, ((val != null) ? ((Object)val).name : null) ?? "NULL", val2?.locNameString ?? "?"));
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[DeckApplier] LogActualDeckState failed: " + ex.Message));
			}
		}

		private void VerifyDeckState(DeckManager dm, DeckStateSnapshot snapshot)
		{
			try
			{
				bool flag = true;
				int num = DeckManager.completeDeck?.Count ?? 0;
				int num2 = snapshot.CompleteDeck?.Count ?? 0;
				if (num2 > 0 && num != num2)
				{
					_log.LogWarning((object)$"[Verify] MISMATCH completeDeck: actual={num} expected={num2}");
					flag = false;
				}
				int num3 = dm.battleDeck?.Count ?? 0;
				int num4 = snapshot.BattleDeck?.Count ?? 0;
				if (num4 > 0 && num3 != num4)
				{
					_log.LogWarning((object)$"[Verify] MISMATCH battleDeck: actual={num3} expected={num4}");
					flag = false;
				}
				int num5 = dm.shuffledDeck?.Count ?? 0;
				int num6 = snapshot.ShuffledOrder?.Count ?? 0;
				if (snapshot.ShuffledOrder != null && num5 != num6)
				{
					_log.LogWarning((object)$"[Verify] MISMATCH shuffledDeck: actual={num5} expected={num6}");
					flag = false;
				}
				try
				{
					DeckInfoManager val = Object.FindObjectOfType<DeckInfoManager>();
					if ((Object)(object)val != (Object)null && val.displayOrbs != null && num5 > 0)
					{
						int count = val.displayOrbs.Count;
						int num7 = num5;
						if (count != num7)
						{
							_log.LogWarning((object)$"[Verify] MISMATCH displayOrbs: actual={count} expected={num7} (shuffled={num5})");
							flag = false;
						}
					}
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[DeckApplier] VerifyDeckState failed: " + ex.Message));
				}
				if (!flag)
				{
					LogActualDeckState(dm);
				}
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[Verify] DeckState verification failed: " + ex2.Message));
			}
		}

		private static bool IsHexString(string s)
		{
			foreach (char c in s)
			{
				if ((c < '0' || c > '9') && (c < 'a' || c > 'f') && (c < 'A' || c > 'F'))
				{
					return false;
				}
			}
			return true;
		}
	}
	public class EnemyStateApplier : IGameStateApplier<EnemyStateSnapshot>
	{
		private readonly ManualLogSource _log;

		private readonly EnemyIdentifier _enemyId;

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

		private List<string> _lastSyncedUpcoming;

		public EnemyStateApplier(ManualLogSource log, EnemyIdentifier enemyId)
		{
			_log = log;
			_enemyId = enemyId;
		}

		public void Apply(EnemyStateSnapshot snapshot)
		{
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			//IL_018e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a7: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (snapshot.BattleStateName == "AWAITING_POST_BATTLE_CONTROLLER")
				{
					MapStateApplier.ClientWaitingMessage = "Waiting for other players...";
				}
				if (snapshot.BallSpawnX != 0f || snapshot.BallSpawnY != 0f)
				{
					BattleController val = Object.FindObjectOfType<BattleController>();
					if ((Object)(object)val != (Object)null)
					{
						val.pachinkoBallSpawnLocation = new Vector2(snapshot.BallSpawnX, snapshot.BallSpawnY);
					}
				}
				if (snapshot.Enemies == null || snapshot.Enemies.Count == 0)
				{
					_log.LogInfo((object)"[EnemyApplier] No enemies in snapshot.");
					return;
				}
				EnsureEnemyPrefabsLoaded();
				EnemyManager val2 = Object.FindObjectOfType<EnemyManager>();
				if ((Object)(object)val2 == (Object)null)
				{
					_log.LogInfo((object)("[EnemyApplier] No EnemyManager in scene (battle=" + snapshot.BattleStateName + ")"));
					return;
				}
				List<Enemy> list = val2.Enemies?.Where((Enemy e) => (Object)(object)e != (Object)null).ToList() ?? new List<Enemy>();
				HashSet<Enemy> hashSet = new HashSet<Enemy>();
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				foreach (EnemyEntry enemy in snapshot.Enemies)
				{
					Enemy val3 = FindByGuid(enemy.Id);
					if (!((Object)(object)val3 != (Object)null) || hashSet.Contains(val3))
					{
						val3 = FindBestMatch(list, enemy, hashSet);
						if ((Object)(object)val3 != (Object)null)
						{
							_log.LogInfo((object)$"[EnemyApplier] First-bind match: '{val3.locKey}' at ({((Component)val3).transform.position.x:F1},{((Component)val3).transform.position.y:F1}) → guid={enemy.Id}");
						}
					}
					string text;
					string text2;
					int num4;
					int num5;
					if ((Object)(object)val3 != (Object)null)
					{
						text = ((Object)((Component)val3).gameObject).name.Replace("(Clone)", string.Empty).Trim();
						text2 = (enemy.EnemyName ?? string.Empty).Replace("(Clone)", string.Empty).Trim();
						if (!string.IsNullOrEmpty(text2))
						{
							num4 = ((text != text2) ? 1 : 0);
							if (num4 != 0 && !_missingPrefabs.Contains(text2))
							{
								num5 = (((Object)(object)FindEnemyPrefab(text2) != (Object)null) ? 1 : 0);
								goto IL_0258;
							}
						}
						else
						{
							num4 = 0;
						}
						num5 = 0;
						goto IL_0258;
					}
					Enemy val4 = TrySpawnEnemy(enemy, val2);
					if ((Object)(object)val4 != (Object)null)
					{
						num2++;
						_enemyId.Register(val4, enemy.Id);
						SyncStatusEffects(val4, enemy);
						ApplyC19Extra(val4, enemy);
					}
					else
					{
						_log.LogWarning((object)("[EnemyApplier] Cannot spawn '" + (enemy.EnemyName ?? enemy.LocKey) + "' (guid=" + enemy.Id + ") — not in prefab cache"));
					}
					continue;
					IL_0258:
					bool flag = (byte)num5 != 0;
					if (((uint)num4 & (flag ? 1u : 0u)) != 0)
					{
						_log.LogInfo((object)("[EnemyApplier] Enemy type changed: '" + text + "' → '" + text2 + "', replacing"));
						_enemyId.Unregister(val3);
						val2.RemoveEnemy(val3);
						Object.Destroy((Object)(object)((Component)val3).gameObject);
						hashSet.Add(val3);
						num3++;
						Enemy val5 = TrySpawnEnemy(enemy, val2);
						if ((Object)(object)val5 != (Object)null)
						{
							num2++;
							_enemyId.Register(val5, enemy.Id);
							SyncStatusEffects(val5, enemy);
							SyncShield(val5, enemy);
							ApplyC19Extra(val5, enemy);
						}
					}
					else
					{
						SetMaxHealth(val3, enemy.MaxHealth);
						val3.CurrentHealth = enemy.CurrentHealth;
						ApplyPosition(val3, enemy, firstBind: false);
						ForceUpdateHealthBar(val3);
						SyncStatusEffects(val3, enemy);
						SyncShield(val3, enemy);
						ApplyC19Extra(val3, enemy);
						hashSet.Add(val3);
						num++;
						_enemyId.Register(val3, enemy.Id);
					}
				}
				foreach (Enemy item in list)
				{
					if (!hashSet.Contains(item))
					{
						string text3 = _enemyId.GetGuid(item) ?? "?";
						_log.LogInfo((object)("[EnemyApplier] Destroying extra client enemy '" + item.locKey + "' (guid=" + text3 + ")"));
						_enemyId.Unregister(item);
						val2.RemoveEnemy(item);
						Object.Destroy((Object)(object)((Component)item).gameObject);
						num3++;
					}
				}
				if (num2 > 0 || num3 > 0)
				{
					_log.LogInfo((object)($"[EnemyApplier] RESULT: Updated={num}, Created={num2}, Destroyed={num3} " + $"(host={snapshot.Enemies.Count}, client_before={list.Count}, battle={snapshot.BattleStateName})"));
				}
				VerifyEnemyState(snapshot);
				SyncUpcomingEnemies(snapshot.UpcomingEnemyNames);
			}
			catch (Exception ex)
			{
				_log.LogError((object)("[EnemyApplier] Apply failed: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void VerifyEnemyState(EnemyStateSnapshot snapshot)
		{
			try
			{
				int num = 0;
				foreach (EnemyEntry enemy in snapshot.Enemies)
				{
					if (num >= 3)
					{
						break;
					}
					Enemy val = FindByGuid(enemy.Id);
					if (!((Object)(object)val == (Object)null))
					{
						num++;
						float currentHealth = val.CurrentHealth;
						if (Math.Abs(currentHealth - enemy.CurrentHealth) > 0.1f)
						{
							_log.LogWarning((object)$"[Verify] MISMATCH enemy '{enemy.LocKey}' (guid={enemy.Id}) health: actual={currentHealth:F1} expected={enemy.CurrentHealth:F1}");
						}
						FieldInfo fieldInfo = AccessTools.Field(typeof(Enemy), "_maxHealth");
						float num2 = ((fieldInfo != null) ? ((float)fieldInfo.GetValue(val)) : (-1f));
						if (enemy.MaxHealth > 0f && Math.Abs(num2 - enemy.MaxHealth) > 0.1f)
						{
							_log.LogWarning((object)$"[Verify] MISMATCH enemy '{enemy.LocKey}' (guid={enemy.Id}) maxHealth: actual={num2:F1} expected={enemy.MaxHealth:F1}");
						}
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[Verify] EnemyState verification failed: " + ex.Message));
			}
		}

		private void SyncUpcomingEnemies(List<string> hostNames)
		{
			//IL_03cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e4: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				EnemyInfoManager val = Object.FindObjectOfType<EnemyInfoManager>();
				if ((Object)(object)val == (Object)null || !(AccessTools.Field(typeof(EnemyInfoManager), "_enemyInfoElements")?.GetValue(val) is Queue<EnemyInfoElement> queue))
				{
					return;
				}
				int num = hostNames?.Count ?? 0;
				if (_lastSyncedUpcoming != null && hostNames != null && _lastSyncedUpcoming.Count == hostNames.Count && _lastSyncedUpcoming.SequenceEqual(hostNames) && queue.Count == num)
				{
					return;
				}
				int count = queue.Count;
				while (queue.Count > 0)
				{
					EnemyInfoElement val2 = queue.Dequeue();
					if ((Object)(object)val2 != (Object)null)
					{
						Object.Destroy((Object)(object)((Component)val2).gameObject);
					}
				}
				(AccessTools.Field(typeof(EnemyInfoManager), "_upcomingSpawns")?.GetValue(val) as IList)?.Clear();
				if (hostNames == null || hostNames.Count == 0)
				{
					try
					{
						object? obj = AccessTools.Field(typeof(EnemyInfoManager), "_scrollAnim")?.GetValue(val);
						object? obj2 = ((obj is Animator) ? obj : null);
						if (obj2 != null)
						{
							((Animator)obj2).SetTrigger(Animator.StringToHash("RollUp"));
						}
					}
					catch
					{
					}
					if (count > 0)
					{
						_log.LogInfo((object)$"[EnemyApplier] Upcoming sync: cleared {count} → 0");
					}
					return;
				}
				Dictionary<string, GameObject> dictionary = AssetLoading.Instance?.EnemyPrefabs;
				object? obj4 = AccessTools.Field(typeof(EnemyInfoManager), "_enemyInfoContainer")?.GetValue(val);
				Transform val3 = (Transform)((obj4 is Transform) ? obj4 : null);
				object? obj5 = AccessTools.Field(typeof(EnemyInfoManager), "_enemyInfoElementPrefab")?.GetValue(val);
				EnemyInfoElement val4 = (EnemyInfoElement)((obj5 is EnemyInfoElement) ? obj5 : null);
				if (dictionary == null || (Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
				{
					return;
				}
				int num2 = 0;
				foreach (string hostName in hostNames)
				{
					GameObject val5 = null;
					foreach (KeyValuePair<string, GameObject> item in dictionary)
					{
						if ((Object)(object)item.Value != (Object)null && ((Object)item.Value).name == hostName)
						{
							val5 = item.Value;
							break;
						}
					}
					if ((Object)(object)val5 == (Object)null)
					{
						foreach (KeyValuePair<string, GameObject> item2 in dictionary)
						{
							if ((Object)(object)item2.Value != (Object)null && hostName.Contains(((Object)item2.Value).name))
							{
								val5 = item2.Value;
								break;
							}
						}
					}
					Enemy val6 = ((val5 != null) ? val5.GetComponent<Enemy>() : null);
					if (!((Object)(object)val6 == (Object)null))
					{
						EnemyInfoElement component = Object.Instantiate<GameObject>(((Component)val4).gameObject, val3).GetComponent<EnemyInfoElement>();
						component.SetEnemy(val6);
						queue.Enqueue(component);
						num2++;
					}
				}
				if (num2 > 0)
				{
					try
					{
						object? obj6 = AccessTools.Field(typeof(EnemyInfoManager), "_scrollAnim")?.GetValue(val);
						object? obj7 = ((obj6 is Animator) ? obj6 : null);
						if (obj7 != null)
						{
							((Animator)obj7).SetTrigger(Animator.StringToHash("RollDown"));
						}
						object? obj8 = AccessTools.Field(typeof(EnemyInfoManager), "_mask")?.GetValue(val);
						Mask val7 = (Mask)((obj8 is Mask) ? obj8 : null);
						if ((Object)(object)val7 != (Object)null)
						{
							float y = (float)(AccessTools.Field(typeof(EnemyInfoManager), "_maskFullHeight")?.GetValue(val) ?? ((object)6.195f));
							Vector2 sizeDelta = val7.rectTransform.sizeDelta;
							sizeDelta.y = y;
							val7.rectTransform.sizeDelta = sizeDelta;
						}
					}
					catch
					{
					}
				}
				object? obj10 = AccessTools.Field(typeof(EnemyInfoManager), "_moreUpcomingEnemiesIndicator")?.GetValue(val);
				object? obj11 = ((obj10 is TMP_Text) ? obj10 : null);
				if (obj11 != null)
				{
					((Component)obj11).gameObject.SetActive(false);
				}
				_lastSyncedUpcoming = ((hostNames != null) ? new List<string>(hostNames) : null);
				_log.LogInfo((object)string.Format("[EnemyApplier] Upcoming sync: rebuilt {0} → {1} (host={2}, names={3})", count, num2, hostNames.Count, string.Join(",", hostNames)));
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[EnemyApplier] SyncUpcomingEnemies failed: " + ex.Message));
			}
		}

		private void EnsureEnemyPrefabsLoaded()
		{
			//IL_00d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fc: Unknown result type (might be due to invalid IL or missing references)
			Dictionary<string, GameObject> dictionary = AssetLoading.Instance?.EnemyPrefabs;
			if (dictionary != null && dictionary.Count > 0)
			{
				return;
			}
			MapData dataToLoad = StaticGameData.dataToLoad;
			MapDataBattle val = (MapDataBattle)(object)((dataToLoad is MapDataBattle) ? dataToLoad : null);
			if ((Object)(object)val == (Object)null)
			{
				_log.LogWarning((object)"[EnemyApplier] Cannot load enemy prefabs — no MapDataBattle in dataToLoad");
				return;
			}
			int num = 0;
			if (dictionary == null)
			{
				_log.LogWarning((object)"[EnemyApplier] AssetLoading.Instance.EnemyPrefabs is null!");
				return;
			}
			if (val.starterSpawns != null)
			{
				foreach (StarterSpawn starterSpawn in val.starterSpawns)
				{
					try
					{
						if (starterSpawn?.spawnData?.enemyAssetReference == null)
						{
							continue;
						}
						string text = ((AssetReference)starterSpawn.spawnData.enemyAssetReference).RuntimeKey.ToString();
						if (!dictionary.ContainsKey(text))
						{
							GameObject val2 = ((AssetReference)starterSpawn.spawnData.enemyAssetReference).LoadAssetAsync<GameObject>().WaitForCompletion();
							if ((Object)(object)val2 != (Object)null)
							{
								dictionary[text] = val2;
								num++;
								_log.LogInfo((object)("[EnemyApplier] Loaded enemy prefab: key=" + text + " name=" + ((Object)val2).name));
							}
						}
					}
					catch (Exception ex)
					{
						_log.LogWarning((object)("[EnemyApplier] Failed to load starter spawn prefab: " + ex.Message));
					}
				}
			}
			if (val.waveGroups != null)
			{
				WaveGroup[] waveGroups = val.waveGroups;
				foreach (WaveGroup val3 in waveGroups)
				{
					if (val3?.waveData == null)
					{
						continue;
					}
					WaveData[] waveData = val3.waveData;
					foreach (WaveData val4 in waveData)
					{
						try
						{
							if (val4?.spawnData?.enemyAssetReference == null)
							{
								continue;
							}
							string text2 = ((AssetReference)val4.spawnData.enemyAssetReference).RuntimeKey.ToString();
							if (!dictionary.ContainsKey(text2))
							{
								GameObject val5 = ((AssetReference)val4.spawnData.enemyAssetReference).LoadAssetAsync<GameObject>().WaitForCompletion();
								if ((Object)(object)val5 != (Object)null)
								{
									dictionary[text2] = val5;
									num++;
									_log.LogInfo((object)("[EnemyApplier] Loaded wave enemy prefab: key=" + text2 + " name=" + ((Object)val5).name));
								}
							}
						}
						catch (Exception ex2)
						{
							_log.LogWarning((object)("[EnemyApplier] Failed to load wave prefab: " + ex2.Message));
						}
					}
				}
			}
			_log.LogInfo((object)$"[EnemyApplier] Loaded {num} enemy prefabs from MapDataBattle (cache now has {dictionary.Count} entries)");
		}

		private Enemy FindByGuid(string guid)
		{
			if (string.IsNullOrEmpty(guid))
			{
				return null;
			}
			return _enemyId.Find(guid);
		}

		private static Enemy FindBestMatch(List<Enemy> liveEnemies, EnemyEntry entry, HashSet<Enemy> alreadyMatched)
		{
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			Enemy val = null;
			float num = float.MaxValue;
			foreach (Enemy liveEnemy in liveEnemies)
			{
				if (!((Object)(object)liveEnemy == (Object)null) && !alreadyMatched.Contains(liveEnemy) && !(liveEnemy.locKey != entry.LocKey))
				{
					float num2 = ((Component)liveEnemy).transform.position.x - entry.PosX;
					float num3 = ((Component)liveEnemy).transform.position.y - entry.PosY;
					float num4 = num2 * num2 + num3 * num3;
					if (num4 < num)
					{
						num = num4;
						val = liveEnemy;
					}
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				return val;
			}
			foreach (Enemy liveEnemy2 in liveEnemies)
			{
				if (!((Object)(object)liveEnemy2 == (Object)null) && !alreadyMatched.Contains(liveEnemy2))
				{
					float num5 = ((Component)liveEnemy2).transform.position.x - entry.PosX;
					float num6 = ((Component)liveEnemy2).transform.position.y - entry.PosY;
					float num7 = num5 * num5 + num6 * num6;
					if (num7 < 0.25f && num7 < num)
					{
						num = num7;
						val = liveEnemy2;
					}
				}
			}
			return val;
		}

		private Enemy TrySpawnEnemy(EnemyEntry entry, EnemyManager em)
		{
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = FindEnemyPrefab(entry.EnemyName ?? entry.LocKey);
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				Vector3 val2 = default(Vector3);
				((Vector3)(ref val2))..ctor(entry.PosX, entry.PosY, 0f);
				GameObject val3 = Object.Instantiate<GameObject>(val, val2, Quaternion.identity, ((Component)em).transform);
				Enemy componentInChildren = val3.GetComponentInChildren<Enemy>();
				if ((Object)(object)componentInChildren == (Object)null)
				{
					Object.Destroy((Object)(object)val3);
					return null;
				}
				try
				{
					StatusEffectData[] array = Resources.FindObjectsOfTypeAll<StatusEffectData>();
					StatusEffectData val4 = ((array.Length != 0) ? array[0] : null);
					RelicManager[] array2 = Resources.FindObjectsOfTypeAll<RelicManager>();
					RelicManager val5 = ((array2.Length != 0) ? array2[0] : null);
					componentInChildren.Initialize(val4, em, val5, ((Object)val).name);
					_log.LogInfo((object)("[EnemyApplier] Initialized enemy '" + ((Object)val).name + "' (HP bar setup)"));
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[EnemyApplier] Enemy.Initialize failed: " + ex.Message));
				}
				try
				{
					em.AddEnemy(componentInChildren, entry.SlotIndex, entry.IsFlying);
				}
				catch (Exception ex2)
				{
					_log.LogWarning((object)("[EnemyApplier] AddEnemy failed (EnemyManager may not be initialized): " + ex2.Message));
					try
					{
						List<Enemy> list = AccessTools.Field(typeof(EnemyManager), "Enemies")?.GetValue(em) as List<Enemy>;
						if (list == null)
						{
							list = new List<Enemy>();
							AccessTools.Field(typeof(EnemyManager), "Enemies")?.SetValue(em, list);
						}
						if (!list.Contains(componentInChildren))
						{
							list.Add(componentInChildren);
						}
					}
					catch
					{
					}
				}
				SetMaxHealth(componentInChildren, entry.MaxHealth);
				componentInChildren.CurrentHealth = entry.CurrentHealth;
				ForceUpdateHealthBar(componentInChildren);
				_log.LogInfo((object)$"[EnemyApplier] Spawned '{entry.EnemyName}' at ({entry.PosX:F1},{entry.PosY:F1}) slot={entry.SlotIndex} guid={entry.Id} hp={componentInChildren.CurrentHealth}/{entry.MaxHealth}");
				return componentInChildren;
			}
			catch (Exception ex3)
			{
				_log.LogWarning((object)("[EnemyApplier] TrySpawnEnemy failed for '" + entry.EnemyName + "': " + ex3.Message + "\n" + ex3.StackTrace));
				return null;
			}
		}

		private GameObject FindEnemyPrefab(string name)
		{
			//IL_015a: Unknown result type (might be due to invalid IL or missing references)
			//IL_015f: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			string text = name.Replace("(Clone)", string.Empty).Trim();
			if (_missingPrefabs.Contains(text))
			{
				return null;
			}
			Dictionary<string, GameObject> dictionary = AssetLoading.Instance?.EnemyPrefabs;
			if (dictionary != null && dictionary.Count > 0)
			{
				foreach (KeyValuePair<string, GameObject> item in dictionary)
				{
					if ((Object)(object)item.Value != (Object)null && ((Object)item.Value).name == text)
					{
						return item.Value;
					}
				}
				foreach (KeyValuePair<string, GameObject> item2 in dictionary)
				{
					if ((Object)(object)item2.Value != (Object)null && (((Object)item2.Value).name.Contains(text) || text.Contains(((Object)item2.Value).name)))
					{
						return item2.Value;
					}
				}
			}
			Enemy[] array = Resources.FindObjectsOfTypeAll<Enemy>();
			Enemy[] array2 = array;
			Scene scene;
			foreach (Enemy val in array2)
			{
				if ((Object)(object)val != (Object)null && ((Object)((Component)val).gameObject).name == text)
				{
					scene = ((Component)val).gameObject.scene;
					if (((Scene)(ref scene)).name == null)
					{
						return ((Component)val).gameObject;
					}
				}
			}
			array2 = array;
			foreach (Enemy val2 in array2)
			{
				if ((Object)(object)val2 != (Object)null)
				{
					scene = ((Component)val2).gameObject.scene;
					if (((Scene)(ref scene)).name == null && (((Object)((Component)val2).gameObject).name.Contains(text) || text.Contains(((Object)((Component)val2).gameObject).name)))
					{
						return ((Component)val2).gameObject;
					}
				}
			}
			_missingPrefabs.Add(text);
			_log.LogWarning((object)$"[EnemyApplier] No prefab found for '{text}' (cache={dictionary?.Count ?? (-1)}, resources={array.Length}) — caching as missing");
			return null;
		}

		private static void ApplyPosition(Enemy enemy, EnemyEntry entry, bool firstBind)
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_011b: Unknown result type (might be due to invalid IL or missing references)
			//IL_011f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0130: Unknown result type (might be due to invalid IL or missing references)
			Vector3 position = ((Component)enemy).transform.position;
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(entry.PosX, entry.PosY, position.z);
			float num = Mathf.Abs(val.x - position.x);
			float num2 = Mathf.Abs(val.y - position.y);
			if (firstBind || !(num > 0.05f) || !(num < 8f) || !(num2 < 0.5f))
			{
				((Component)enemy).transform.position = val;
				return;
			}
			string text = "coopEnemyMove_" + (entry.Id ?? ((Object)enemy).GetInstanceID().ToString());
			DOTween.Kill((object)text, false);
			StartWalkAnim(enemy);
			float num3 = Mathf.Clamp(num / 4f, 0.4f, 1.2f);
			Enemy enemyRef = enemy;
			TweenerCore<Vector3, Vector3, VectorOptions> obj = TweenSettingsExtensions.SetEase<TweenerCore<Vector3, Vector3, VectorOptions>>(ShortcutExtensions.DOMoveX(((Component)enemy).transform, val.x, num3, false), (Ease)4);
			TweenSettingsExtensions.SetId<TweenerCore<Vector3, Vector3, VectorOptions>>(obj, text);
			((Tween)obj).onComplete = (TweenCallback)delegate
			{
				StopWalkAnim(enemyRef);
			};
			if (num2 > 0.01f)
			{
				Vector3 position2 = ((Component)enemy).transform.position;
				position2.y = val.y;
				((Component)enemy).transform.position = position2;
			}
		}

		private static void StartWalkAnim(Enemy enemy)
		{
			//IL_009e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a4: Invalid comparison between Unknown and I4
			try
			{
				if (!(enemy is WalkEnemy))
				{
					return;
				}
				object? obj = AccessTools.Field(typeof(Enemy), "_anim")?.GetValue(enemy);
				Animator val = (Animator)((obj is Animator) ? obj : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val.runtimeAnimatorController == (Object)null)
				{
					return;
				}
				string text = (AccessTools.Field(typeof(WalkEnemy), "_moveAnimName")?.GetValue(enemy) as string) ?? "Running";
				AnimatorControllerParameter[] parameters = val.parameters;
				foreach (AnimatorControllerParameter val2 in parameters)
				{
					if (val2.name == text && (int)val2.type == 4)
					{
						val.SetBool(text, true);
						break;
					}
				}
			}
			catch
			{
			}
		}

		private static void StopWalkAnim(Enemy enemy)
		{
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b2: Invalid comparison between Unknown and I4
			try
			{
				if ((Object)(object)enemy == (Object)null || !(enemy is WalkEnemy))
				{
					return;
				}
				object? obj = AccessTools.Field(typeof(Enemy), "_anim")?.GetValue(enemy);
				Animator val = (Animator)((obj is Animator) ? obj : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val.runtimeAnimatorController == (Object)null)
				{
					return;
				}
				string text = (AccessTools.Field(typeof(WalkEnemy), "_moveAnimName")?.GetValue(enemy) as string) ?? "Running";
				AnimatorControllerParameter[] parameters = val.parameters;
				foreach (AnimatorControllerParameter val2 in parameters)
				{
					if (val2.name == text && (int)val2.type == 4)
					{
						val.SetBool(text, false);
						break;
					}
				}
			}
			catch
			{
			}
		}

		private static void SetMaxHealth(Enemy enemy, float maxHealth)
		{
			if (!(maxHealth <= 0f))
			{
				AccessTools.Field(typeof(Enemy), "_maxHealth")?.SetValue(enemy, maxHealth);
			}
		}

		private void SyncShield(Enemy enemy, EnemyEntry entry)
		{
			try
			{
				if (!entry.HasShield)
				{
					return;
				}
				ShieldEnemy val = (ShieldEnemy)(object)((enemy is ShieldEnemy) ? enemy : null);
				if (val == null)
				{
					return;
				}
				BarricadeEnemy shield = val.shield;
				if ((Object)(object)shield == (Object)null)
				{
					return;
				}
				GameObject gameObject = ((Component)shield).gameObject;
				bool activeInHierarchy = gameObject.activeInHierarchy;
				if (!entry.ShieldActive)
				{
					if (activeInHierarchy)
					{
						((Enemy)shield).CurrentHealth = 0f;
						ForceUpdateHealthBar((Enemy)(object)shield);
						gameObject.SetActive(false);
						_log.LogInfo((object)("[EnemyApplier] Shield KILLED on '" + enemy.locKey + "' (guid=" + entry.Id + ")"));
					}
					return;
				}
				if (!activeInHierarchy)
				{
					gameObject.SetActive(true);
					_log.LogInfo((object)("[EnemyApplier] Shield RESURRECTED on '" + enemy.locKey + "' (guid=" + entry.Id + ")"));
				}
				SetMaxHealth((Enemy)(object)shield, entry.ShieldMaxHealth);
				if (Math.Abs(((Enemy)shield).CurrentHealth - entry.ShieldCurrentHealth) > 0.01f)
				{
					((Enemy)shield).CurrentHealth = entry.ShieldCurrentHealth;
					ForceUpdateHealthBar((Enemy)(object)shield);
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[EnemyApplier] SyncShield failed for '" + enemy?.locKey + "': " + ex.Message));
			}
		}

		private void ApplyC19Extra(Enemy enemy, EnemyEntry entry)
		{
			try
			{
				if (!entry.IsC19Extra)
				{
					return;
				}
				UpdateSlider val = enemy?.HealthBarBarSprite;
				if (!((Object)(object)val == (Object)null))
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(UpdateSlider), "_background");
					FieldInfo fieldInfo2 = AccessTools.Field(typeof(UpdateSlider), "_c19Background");
					object? obj = fieldInfo?.GetValue(val);
					Image val2 = (Image)((obj is Image) ? obj : null);
					object? obj2 = fieldInfo2?.GetValue(val);
					Sprite val3 = (Sprite)((obj2 is Sprite) ? obj2 : null);
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val3 == (Object)null) && !((Object)(object)val2.sprite == (Object)(object)val3))
					{
						val.SetIsC19ExtraEnemy();
						_log.LogInfo((object)("[EnemyApplier] Applied c19 HP bar to '" + enemy.locKey + "' (guid=" + entry.Id + ")"));
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[EnemyApplier] ApplyC19Extra failed for '" + enemy?.locKey + "': " + ex.Message));
			}
		}

		private static void ForceUpdateHealthBar(Enemy enemy)
		{
			try
			{
				AccessTools.Method(typeof(Enemy), "UpdateHealthBar", (Type[])null, (Type[])null)?.Invoke(enemy, null);
			}
			catch
			{
			}
		}

		private void SyncStatusEffects(Enemy enemy, EnemyEntry entry)
		{
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected I4, but got Unknown
			//IL_0082: Unknown result type (might be due to invalid IL or missing references)
			//IL_0085: Unknown result type (might be due to invalid IL or missing references)
			//IL_019c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_0211: Expected I4, but got Unknown
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_023a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Expected O, but got Unknown
			try
			{
				if (!(AccessTools.Field(typeof(Enemy), "_statusEffects")?.GetValue(enemy) is List<StatusEffect> list))
				{
					return;
				}
				object? obj = AccessTools.Field(typeof(Enemy), "_statusEffectUI")?.GetValue(enemy);
				StatusEffectIconManager val = (StatusEffectIconManager)((obj is StatusEffectIconManager) ? obj : null);
				Dictionary<StatusEffectType, int> dictionary = new Dictionary<StatusEffectType, int>();
				if (entry.StatusEffects != null)
				{
					foreach (StatusEffectEntry statusEffect in entry.StatusEffects)
					{
						StatusEffectType key = (StatusEffectType)statusEffect.EffectType;
						dictionary[key] = statusEffect.Intensity;
					}
				}
				for (int num = list.Count - 1; num >= 0; num--)
				{
					if (!dictionary.ContainsKey(list[num].EffectType))
					{
						_log.LogInfo((object)$"[EnemyApplier] StatusSync REMOVING '{enemy.locKey}': {list[num].EffectType}({(int)list[num].EffectType})={list[num].Intensity}");
						StatusEffect val2 = list[num];
						val2.Intensity = 0;
						try
						{
							if (val != null)
							{
								val.UpdateStatusEffect(val2);
							}
						}
						catch
						{
						}
						list.RemoveAt(num);
					}
				}
				foreach (KeyValuePair<StatusEffectType, int> item in dictionary)
				{
					bool flag = false;
					foreach (StatusEffect item2 in list)
					{
						if (item2.EffectType == item.Key)
						{
							item2.Intensity = item.Value;
							flag = true;
							break;
						}
					}
					if (!flag)
					{
						_log.LogInfo((object)$"[EnemyApplier] StatusSync ADDING '{enemy.locKey}': {item.Key}({(int)item.Key})={item.Value}");
						list.Add(new StatusEffect(item.Key, item.Value));
					}
				}
				if ((Object)(object)val != (Object)null && (Object)(object)val.EffectData == (Object)null)
				{
					StatusEffectData[] array = Resources.FindObjectsOfTypeAll<StatusEffectData>();
					if (array.Length != 0)
					{
						val.EffectData = array[0];
						_log.LogInfo((object)("[EnemyApplier] StatusSync set EffectData for '" + enemy.locKey + "' from Resources"));
					}
				}
				if ((Object)(object)val != (Object)null && (Object)(object)val.EffectData != (Object)null)
				{
					try
					{
						val.UpdateStatusEffects(enemy.StatusEffects);
						return;
					}
					catch
					{
						return;
					}
				}
				if ((Object)(object)val != (Object)null)
				{
					_log.LogWarning((object)("[EnemyApplier] StatusSync UI has null EffectData for '" + enemy.locKey + "' — icons won't render"));
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[EnemyApplier] SyncStatusEffects failed for '" + enemy.locKey + "': " + ex.Message));
			}
		}
	}
	public class LpmBombFollower : MonoBehaviour
	{
		public Transform LpmParent;

		public Vector3 LocalOffset;

		private Rigidbody2D _rb;

		private void Awake()
		{
			_rb = ((Component)this).GetComponent<Rigidbody2D>();
		}

		private void LateUpdate()
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_008b: 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_0057: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0073: Invalid comparison between Unknown and I4
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)LpmParent == (Object)null)
			{
				return;
			}
			Vector3 val = LpmParent.position + LocalOffset;
			val.z = ((Component)this).transform.position.z;
			if ((Object)(object)_rb != (Object)null)
			{
				_rb.position = new Vector2(val.x, val.y);
				if ((int)_rb.bodyType != 2)
				{
					_rb.velocity = Vector2.zero;
				}
			}
			((Component)this).transform.position = val;
		}
	}
	public class MapStateApplier : IGameStateApplier<MapStateSnapshot>
	{
		private class CachedMapState
		{
			public List<MapNodeEntry> Nodes;

			public float? PlayerPosX;

			public float? PlayerPosY;
		}

		private readonly ManualLogSource _log;

		private static readonly HashSet<string> MapScenes = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "ForestMap", "CastleMap", "MinesMap", "CoreMap" };

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

		private static readonly Dictionary<string, CachedMapState> _mapStateCache = new Dictionary<string, CachedMapState>(StringComparer.OrdinalIgnoreCase);

		private static readonly Dictionary<string, Scene> SceneNameToEnum = new Dictionary<string, Scene>(StringComparer.OrdinalIgnoreCase)
		{
			{
				"Battle",
				(Scene)9
			},
			{
				"MainMenu",
				(Scene)1
			},
			{
				"PostMainMenu",
				(Scene)2
			},
			{
				"ForestMap",
				(Scene)3
			},
			{
				"ForestWinScene",
				(Scene)4
			},
			{
				"CastleMap",
				(Scene)5
			},
			{
				"CastleWinScene",
				(Scene)6
			},
			{
				"MinesMap",
				(Scene)7
			},
			{
				"FinalWinScene",
				(Scene)8
			},
			{
				"CoreMap",
				(Scene)15
			},
			{
				"CoreWinScene",
				(Scene)16
			},
			{
				"Treasure",
				(Scene)11
			},
			{
				"TextScenario",
				(Scene)10
			},
			{
				"PegMinigame",
				(Scene)12
			},
			{
				"ShopScenario",
				(Scene)13
			},
			{
				"RunSummary",
				(Scene)14
			}
		};

		private static string _lastRequestedScene;

		private static float _lastRequestTime;

		private string _lastStaticGameDataSig = string.Empty;

		private static bool _navigationSlotsConfigured;

		private static int _lastNavigationHash;

		public static string ClientWaitingMessage { get; set; }

		public static string HostPlayerName { get; set; }

		public static string AwaitingHostSceneConfirmation { get; set; }

		public static MapDataBattle TryGetCachedBattle(string name)
		{
			if (string.IsNullOrEmpty(name))
			{
				return null;
			}
			_battleCache.TryGetValue(name, out var value);
			return value;
		}

		public MapStateApplier(ManualLogSource log)
		{
			_log = log;
		}

		public void Apply(MapStateSnapshot snapshot)
		{
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0244: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				ApplyStaticGameData(snapshot);
				if (snapshot.MapFloorCount > 0)
				{
					try
					{
						MapController val = Object.FindObjectOfType<MapController>();
						if ((Object)(object)val != (Object)null)
						{
							FieldInfo fieldInfo = AccessTools.Field(typeof(MapController), "floorCount");
							if (fieldInfo != null)
							{
								int num = (int)fieldInfo.GetValue(val);
								if (num != snapshot.MapFloorCount)
								{
									fieldInfo.SetValue(val, snapshot.MapFloorCount);
									_log.LogInfo((object)$"[MapApplier] Set MapController.floorCount: {num} → {snapshot.MapFloorCount}");
								}
							}
						}
					}
					catch
					{
					}
				}
				if (!string.IsNullOrEmpty(snapshot.RandomStateJson))
				{
					MultiplayerClientPatches.PendingRngStateToRestore = snapshot.RandomStateJson;
				}
				ApplySeededNodeData(snapshot);
				if (snapshot.ActiveScene == "PostMainMenu")
				{
					if (!LobbyUI.GameStartReceived)
					{
						ClientWaitingMessage = "Host is selecting starting relic...";
						_log.LogInfo((object)"[MapApplier] Host is on PostMainMenu — showing waiting message");
						return;
					}
					_log.LogInfo((object)"[MapApplier] Coop mode: allowing client to follow to PostMainMenu");
				}
				if (snapshot.ActiveScene == "MainMenu")
				{
					ClientWaitingMessage = "Waiting for other players to start game...";
					_log.LogInfo((object)"[MapApplier] Host is on MainMenu — showing waiting message");
					return;
				}
				if (snapshot.ActiveScene == "Treasure")
				{
					_log.LogInfo((object)"[MapApplier] Host is on Treasure — client follows for native relic UI");
				}
				if (snapshot.ActiveScene == "TextScenario")
				{
					ClientWaitingMessage = "Host is completing event...";
					_log.LogInfo((object)"[MapApplier] Host is on TextScenario — client spectating");
				}
				if (snapshot.ActiveScene == "ShopScenario")
				{
					_log.LogInfo((object)"[MapApplier] Host is on ShopScenario — client follows for interactive shopping");
				}
				if (snapshot.ActiveScene == "PegMinigame")
				{
					_log.LogInfo((object)"[MapApplier] Host is on PegMinigame — client plays independently");
				}
				if (snapshot.ActiveScene == "ForestWinScene" || snapshot.ActiveScene == "CastleWinScene" || snapshot.ActiveScene == "FinalWinScene" || snapshot.ActiveScene == "CoreWinScene")
				{
					ClientWaitingMessage = "Act complete! Waiting for other players...";
					_log.LogInfo((object)("[MapApplier] Host is on win scene '" + snapshot.ActiveScene + "' — showing waiting message"));
					return;
				}
				ClientWaitingMessage = null;
				Scene activeScene = SceneManager.GetActiveScene();
				string name = ((Scene)(ref activeScene)).name;
				string activeScene2 = snapshot.ActiveScene;
				if (string.Equals(name, activeScene2, StringComparison.OrdinalIgnoreCase))
				{
					if (!string.IsNullOrEmpty(AwaitingHostSceneConfirmation) && string.Equals(name, AwaitingHostSceneConfirmation, StringComparison.OrdinalIgnoreCase))
					{
						_log.LogInfo((object)("[MapApplier] Host confirmed '" + name + "' — cleared AwaitingHostSceneConfirmation"));
						AwaitingHostSceneConfirmation = null;
					}
					if (MapScenes.Contains(name) && snapshot.Nodes != null && snapshot.Nodes.Count > 0)
					{
						ApplyMapNodes(snapshot.Nodes, snapshot.PlayerMapPosX, snapshot.PlayerMapPosY);
					}
					return;
				}
				if (!string.IsNullOrEmpty(AwaitingHostSceneConfirmation) && string.Equals(name, AwaitingHostSceneConfirmation, StringComparison.OrdinalIgnoreCase) && MapScenes.Contains(activeScene2))
				{
					_log.LogInfo((object)("[MapApplier] Ignoring stale map sync '" + activeScene2 + "' — awaiting host '" + AwaitingHostSceneConfirmation + "' confirmation"));
					return;
				}
				if (MapScenes.Contains(activeScene2) && snapshot.PlayerMapPosX.HasValue && snapshot.PlayerMapPosY.HasValue && snapshot.Nodes != null && snapshot.Nodes.Count > 0)
				{
					_mapStateCache[activeScene2] = new CachedMapState
					{
						Nodes = snapshot.Nodes,
						PlayerPosX = snapshot.PlayerMapPosX,
						PlayerPosY = snapshot.PlayerMapPosY
					};
					_log.LogInfo((object)("[MapApplier] Pre-seeded cache for '" + activeScene2 + "' " + $"(playerPos={snapshot.PlayerMapPosX.Value:F1},{snapshot.PlayerMapPosY.Value:F1}, {snapshot.Nodes.Count} nodes)"));
				}
				_log.LogInfo((object)("[MapApplier] Scene change: '" + name + "' -> '" + activeScene2 + "', loading..."));
				LoadTargetScene(activeScene2);
			}
			catch (Exception ex)
			{
				_log.LogError((object)("[MapApplier] Apply failed: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void ApplySeededNodeData(MapStateSnapshot snapshot)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Expected O, but got Unknown
			//IL_0125: Unknown result type (might be due to invalid IL or missing references)
			//IL_012b: Expected O, but got Unknown
			//IL_01a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ad: Expected O, but got Unknown
			//IL_00cb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d5: Expected O, but got Unknown
			//IL_0291: Unknown result type (might be due to invalid IL or missing references)
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (string.IsNullOrEmpty(snapshot.SeededNodeKind))
				{
					StaticGameData.seededNodeData = null;
				}
				else if (snapshot.SeededNodeKind == "text_scenario")
				{
					SeededMapNodeData seededNodeData = StaticGameData.seededNodeData;
					SeededTextScenarioNodeData val = (SeededTextScenarioNodeData)(object)((seededNodeData is SeededTextScenarioNodeData) ? seededNodeData : null);
					if (val == null)
					{
						val = (SeededTextScenarioNodeData)(object)(StaticGameData.seededNodeData = (SeededMapNodeData)new SeededTextScenarioNodeData());
					}
					if (snapshot.SeededNodeInitSeed.HasValue && snapshot.SeededNodeTimesUsed.HasValue && (val.randomState == null || val.randomState.initializationSeed != snapshot.SeededNodeInitSeed.Value || val.randomState.timesUsed != snapshot.SeededNodeTimesUsed.Value))
					{
						val.randomState = new SerializableRandomState(snapshot.SeededNodeInitSeed.Value, snapshot.SeededNodeTimesUsed.Value);
						_log.LogInfo((object)$"[MapApplier] Synced SeededTextScenarioNodeData: initSeed={snapshot.SeededNodeInitSeed}, timesUsed={snapshot.SeededNodeTimesUsed}");
					}
				}
				else if (snapshot.SeededNodeKind == "treasure")
				{
					SeededMapNodeData seededNodeData2 = StaticGameData.seededNodeData;
					SeededTreasureNodeData val2 = (SeededTreasureNodeData)(object)((seededNodeData2 is SeededTreasureNodeData) ? seededNodeData2 : null);
					if (val2 == null)
					{
						val2 = (SeededTreasureNodeData)(object)(StaticGameData.seededNodeData = (SeededMapNodeData)new SeededTreasureNodeData());
					}
					if (snapshot.SeededTreasureRareRelicRoll.HasValue)
					{
						val2.rareRelicChanceRoll = snapshot.SeededTreasureRareRelicRoll.Value;
					}
					if (snapshot.SeededTreasureMimicRoll.HasValue)
					{
						val2.mimicChallengeChanceRoll = snapshot.SeededTreasureMimicRoll.Value;
					}
				}
				else
				{
					if (!(snapshot.SeededNodeKind == "shop"))
					{
						return;
					}
					SeededMapNodeData seededNodeData3 = StaticGameData.seededNodeData;
					SeededShopNodeData val3 = (SeededShopNodeData)(object)((seededNodeData3 is SeededShopNodeData) ? seededNodeData3 : null);
					if (val3 == null)
					{
						val3 = (SeededShopNodeData)(object)(StaticGameData.seededNodeData = (SeededMapNodeData)new SeededShopNodeData());
					}
					if (snapshot.SeededShopRareRelicRoll.HasValue)
					{
						val3.rareRelicChanceRoll = snapshot.SeededShopRareRelicRoll.Value;
					}
					if (snapshot.SeededShopRelicRoll.HasValue)
					{
						val3.shopRelicChanceRoll = snapshot.SeededShopRelicRoll.Value;
					}
					if (snapshot.SeededShopOrbNames != null && snapshot.SeededShopOrbRarities != null && snapshot.SeededShopOrbNames.Count == snapshot.SeededShopOrbRarities.Count)
					{
						DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
						DeckManager val4 = ((array.Length != 0) ? array[0] : null);
						if ((Object)(object)val4 != (Object)null)
						{
							SeededOrbAndRarity[] array2 = (SeededOrbAndRarity[])(object)new SeededOrbAndRarity[snapshot.SeededShopOrbNames.Count];
							for (int i = 0; i < array2.Length; i++)
							{
								GameObject orbPrefabFromName = val4.GetOrbPrefabFromName(snapshot.SeededShopOrbNames[i]);
								array2[i] = new SeededOrbAndRarity(orbPrefabFromName, (OrbRarity)snapshot.SeededShopOrbRarities[i]);
							}
							val3.shopOrbs = array2;
							_log.LogInfo((object)($"[MapApplier] Synced SeededShopNodeData: rareRoll={val3.rareRelicChanceRoll:F3}, " + $"shopRoll={val3.shopRelicChanceRoll:F3}, orbs={array2.Length}"));
						}
						else
						{
							_log.LogWarning((object)"[MapApplier] DeckManager not found — cannot resolve shop orbs");
						}
					}
					if (snapshot.SeededShopRelicEffects == null || snapshot.SeededShopRelicEffects.Count <= 0)
					{
						return;
					}
					List<int> latestRelicEffects = ShopRelicSyncState.LatestRelicEffects;
					ShopRelicSyncState.LatestRelicEffects = snapshot.SeededShopRelicEffects;
					bool flag = latestRelicEffects == null || latestRelicEffects.Count != snapshot.SeededShopRelicEffects.Count;
					if (!flag && latestRelicEffects != null)
					{
						for (int j = 0; j < latestRelicEffects.Count; j++)
						{
							if (latestRelicEffects[j] != snapshot.SeededShopRelicEffects[j])
							{
								flag = true;
								break;
							}
						}
					}
					if (flag)
					{
						_log.LogInfo((object)("[MapApplier] Shop relic effects updated: [" + string.Join(",", snapshot.SeededShopRelicEffects) + "]"));
						ShopRelicSyncState.RefreshDisplayedShopRelics(_log);
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[MapApplier] ApplySeededNodeData failed: " + ex.Message));
			}
		}

		private void ApplyStaticGameData(MapStateSnapshot snapshot)
		{
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			CacheMapBattlesFromController();
			string text = (StaticGameData.currentSeed = snapshot.CurrentSeed ?? string.Empty);
			StaticGameData.seedSet = true;
			StaticGameData.totalFloorCount = snapshot.TotalFloorCount;
			StaticGameData.chosenNextNodeIndex = snapshot.ChosenNextNodeIndex;
			StaticGameData.hasReachedBoss = snapshot.HasReachedBoss;
			if (!string.IsNullOrEmpty(snapshot.BattleDataName))
			{
				MapData dataToLoad = StaticGameData.dataToLoad;
				MapDataBattle val = (MapDataBattle)(object)((dataToLoad is MapDataBattle) ? dataToLoad : null);
				if ((Object)(object)val == (Object)null || ((Object)val).name != snapshot.BattleDataName)
				{
					MapDataBattle[] array = Resources.FindObjectsOfTypeAll<MapDataBattle>();
					MapDataBattle val2 = ((IEnumerable<MapDataBattle>)array).FirstOrDefault((Func<MapDataBattle, bool>)((MapDataBattle b) => ((Object)b).name == snapshot.BattleDataName));
					if ((Object)(object)val2 == (Object)null && _battleCache.TryGetValue(snapshot.BattleDataName, out var value) && (Object)(object)value != (Object)null)
					{
						val2 = value;
						_log.LogInfo((object)("[MapApplier] Resolved '" + ((Object)val2).name + "' via cross-scene battle cache"));
					}
					if ((Object)(object)val2 == (Object)null)
					{
						val2 = TryLoadBattleFromAddressables(snapshot.BattleDataName);
					}
					if ((Object)(object)val2 != (Object)null)
					{
						BattleVisualAssigner.Assign(val2, _log, "MapApplier");
						if ((Object)(object)((MapData)val2).background == (Object)null && (Object)(object)val != (Object)null)
						{
							((MapData)val2).background = ((MapData)val).background;
						}
						if ((Object)(object)((MapData)val2).pegboardFrame == (Object)null && (Object)(object)val != (Object)null)
						{
							((MapData)val2).pegboardFrame = ((MapData)val).pegboardFrame;
						}
						StaticGameData.dataToLoad = (MapData)(object)val2;
						ManualLogSource log = _log;
						string[] obj = new string[9]
						{
							"[MapApplier] Set dataToLoad to '",
							((Object)val2).name,
							"' (pegLayout=",
							null,
							null,
							null,
							null,
							null,
							null
						};
						PegLayout pegLayout = val2.pegLayout;
						obj[3] = ((pegLayout != null) ? ((Object)pegLayout).name : null);
						obj[4] = ", pegboardFrame=";
						GameObject pegboardFrame = ((MapData)val2).pegboardFrame;
						obj[5] = ((pegboardFrame != null) ? ((Object)pegboardFrame).name : null) ?? "NULL";
						obj[6] = ", background=";
						GameObject background = ((MapData)val2).background;
						obj[7] = ((background != null) ? ((Object)background).name : null) ?? "NULL";
						obj[8] = ")";
						log.LogInfo((object)string.Concat(obj));
					}
					else
					{
						_log.LogWarning((object)$"[MapApplier] MapDataBattle '{snapshot.BattleDataName}' not found in {array.Length} loaded assets or Addressables");
					}
				}
			}
			string text2 = $"{text}|{snapshot.TotalFloorCount}|{StaticGameData.chosenClass}|{snapshot.ChosenNextNodeIndex}|{snapshot.BattleDataName}";
			if (text2 != _lastStaticGameDataSig)
			{
				_lastStaticGameDataSig = text2;
				_log.LogInfo((object)$"[MapApplier] StaticGameData: seed={text}, floor={snapshot.TotalFloorCount}, class={StaticGameData.chosenClass}, node={snapshot.ChosenNextNodeIndex}, battle={snapshot.BattleDataName}");
			}
		}

		private void CacheMapBattlesFromController()
		{
			try
			{
				MapController val = Object.FindObjectOfType<MapController>();
				if (!((Object)(object)val == (Object)null))
				{
					Add(AccessTools.Field(typeof(MapController), "_potentialEasyBattles")?.GetValue(val) as IList);
					Add(AccessTools.Field(typeof(MapController), "_potentialRandomBattles")?.GetValue(val) as IList);
					Add(AccessTools.Field(typeof(MapController), "_potentialEliteBattles")?.GetValue(val) as IList);
					object? obj = AccessTools.Field(typeof(MapController), "_mimicBatteData")?.GetValue(val);
					MapDataBattle val2 = (MapDataBattle)((obj is MapDataBattle) ? obj : null);
					if ((Object)(object)val2 != (Object)null && !string.IsNullOrEmpty(((Object)val2).name))
					{
						_battleCache[((Object)val2).name] = val2;
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[MapApplier] CacheMapBattlesFromController failed: " + ex.Message));
			}
			static void Add(IList list)
			{
				if (list == null)
				{
					return;
				}
				foreach (object item in list)
				{
					MapDataBattle val3 = (MapDataBattle)((item is MapDataBattle) ? item : null);
					if (val3 != null && !string.IsNullOrEmpty(((Object)val3).name))
					{
						_battleCache[((Object)val3).name] = val3;
					}
				}
			}
		}

		private MapDataBattle TryLoadBattleFromAddressables(string battleName)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0010: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f2: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0054: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				IList<IResourceLocation> list = Addressables.LoadResourceLocationsAsync((object)typeof(MapDataBattle), (Type)null).WaitForCompletion();
				if (list != null)
				{
					foreach (IResourceLocation item in list)
					{
						if (item.PrimaryKey.Contains(battleName) || item.InternalId.Contains(battleName))
						{
							MapDataBattle val = Addressables.LoadAssetAsync<MapDataBattle>(item).WaitForCompletion();
							if ((Object)(object)val != (Object)null)
							{
								_log.LogInfo((object)("[MapApplier] Loaded '" + ((Object)val).name + "' via Addressables (key=" + item.PrimaryKey + ")"));
								return val;
							}
						}
					}
					_log.LogInfo((object)$"[MapApplier] Addressables: searched {list.Count} locations, no match for '{battleName}'");
				}
				try
				{
					MapDataBattle val2 = Addressables.LoadAssetAsync<MapDataBattle>((object)battleName).WaitForCompletion();
					if ((Object)(object)val2 != (Object)null)
					{
						_log.LogInfo((object)("[MapApplier] Loaded '" + ((Object)val2).name + "' via Addressables direct key"));
						return val2;
					}
				}
				catch
				{
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[MapApplier] Addressables lookup failed for '" + battleName + "': " + ex.Message));
			}
			return null;
		}

		private void LoadTargetScene(string targetSceneName)
		{
			//IL_006f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Unknown result type (might be due to invalid IL or missing references)
			if (targetSceneName == _lastRequestedScene && Time.time - _lastRequestTime < 5f)
			{
				_log.LogInfo((object)("[MapApplier] Debounced duplicate load: " + targetSceneName));
				return;
			}
			_lastRequestedScene = targetSceneName;
			_lastRequestTime = Time.time;
			PeglinSceneLoader instance = PeglinSceneLoader.Instance;
			if ((Object)(object)instance != (Object)null && SceneNameToEnum.TryGetValue(targetSceneName, out var value))
			{
				_log.LogInfo((object)$"[MapApplier] Using PeglinSceneLoader.LoadScene({value})");
				MultiplayerClientPatches.AllowNextSceneLoad = true;
				instance.LoadScene(value, (LoadSceneMode)0, false, 0.5f);
			}
			else
			{
				_log.LogWarning((object)("[MapApplier] PeglinSceneLoader unavailable or unknown scene '" + targetSceneName + "', falling back to SceneManager"));
				SceneManager.LoadScene(targetSceneName);
			}
		}

		public static void ResetNavigationState()
		{
			_navigationSlotsConfigured = false;
			_lastNavigationHash = 0;
		}

		public static void ResetAllState()
		{
			ClientWaitingMessage = null;
			AwaitingHostSceneConfirmation = null;
			_lastRequestedScene = null;
			_lastRequestTime = 0f;
			_mapStateCache.Clear();
			ResetNavigationState();
		}

		public static void ApplyCachedOnAwake(MapController mc, ManualLogSource log)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0107: Unknown result type (might be due to invalid IL or missing references)
			//IL_020f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0214: Unknown result type (might be due to invalid IL or missing references)
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0241: Unknown result type (might be due to invalid IL or missing references)
			//IL_0263: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0126: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_012f: Unknown result type (might be due to invalid IL or missing references)
			//IL_013b: Unknown result type (might be due to invalid IL or missing references)
			//IL_013d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0133: Unknown result type (might be due to invalid IL or missing references)
			//IL_0135: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_02af: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)mc == (Object)null)
				{
					return;
				}
				Scene scene = ((Component)mc).gameObject.scene;
				string name = ((Scene)(ref scene)).name;
				if (!_mapStateCache.TryGetValue(name, out var value) || value == null || !(AccessTools.Field(typeof(MapController), "_nodes")?.GetValue(mc) is MapNode[] array) || array.Length == 0)
				{
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(MapNode), "_roomStatus");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(MapNode), "_selectedBossIndex");
				int num = 0;
				foreach (MapNodeEntry node in value.Nodes)
				{
					if (node.Index < 0 || node.Index >= array.Length)
					{
						continue;
					}
					MapNode val = array[node.Index];
					if ((Object)(object)val == (Object)null)
					{
						continue;
					}
					RoomType val2 = (RoomType)node.RoomType;
					RoomState val3 = (RoomState)((node.RoomState >= 0) ? node.RoomState : 4);
					RoomState val4 = (RoomState)(fieldInfo?.GetValue(val) ?? ((object)(RoomState)4));
					if (val.RoomType == val2 && val4 == val3)
					{
						continue;
					}
					val.RoomType = val2;
					if (node.SelectedBossIndex >= 0 && fieldInfo2 != null)
					{
						fieldInfo2.SetValue(val, node.SelectedBossIndex);
					}
					try
					{
						val.SetActiveState(val3, false, true);
						if ((int)val.RoomType != 0)
						{
							val.GenerateIcon(-1f);
						}
					}
					catch
					{
					}
					num++;
				}
				if (value.PlayerPosX.HasValue && value.PlayerPosY.HasValue)
				{
					object? obj2 = AccessTools.Field(typeof(MapController), "_player")?.GetValue(mc);
					GameObject val5 = (GameObject)((obj2 is GameObject) ? obj2 : null);
					if ((Object)(object)val5 != (Object)null)
					{
						Vector3 position = val5.transform.position;
						Vector3 val6 = default(Vector3);
						((Vector3)(ref val6))..ctor(value.PlayerPosX.Value, value.PlayerPosY.Value, position.z);
						val5.transform.position = val6;
						AccessTools.Field(typeof(MapController), "_playerInitialPosition")?.SetValue(mc, val6);
						FieldInfo fieldInfo3 = AccessTools.Field(typeof(MapController), "_previousNode");
						MapNode val7 = null;
						float num2 = float.MaxValue;
						MapNode[] array2 = array;
						foreach (MapNode val8 in array2)
						{
							if (!((Object)(object)val8 == (Object)null))
							{
								float num3 = Vector3.SqrMagnitude(((Component)val8).transform.position - val6);
								if (num3 < num2)
								{
									num2 = num3;
									val7 = val8;
								}
							}
						}
						if ((Object)(object)val7 != (Object)null)
						{
							fieldInfo3?.SetValue(mc, val7);
						}
					}
				}
				if (log != null)
				{
					log.LogInfo((object)($"[MapApplier] Awake: pre-applied {num} cached node changes for '{name}' " + "(playerPos=" + (value.PlayerPosX?.ToString("F1") ?? "?") + "," + (value.PlayerPosY?.ToString("F1") ?? "?") + ")"));
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[MapApplier] ApplyCachedOnAwake failed: " + ex.Message));
				}
			}
		}

		public void ApplyNavigationSlots(List<int> childNodeTypes)
		{
			//IL_01f3: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0171: Unknown result type (might be due to invalid IL or missing references)
			//IL_0191: Unknown result type (might be due to invalid IL or missing references)
			//IL_0231: Unknown result type (might be due to invalid IL or missing references)
			//IL_021c: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d5: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bd: 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_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_028b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02bb: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
			if (childNodeTypes == null || childNodeTypes.Count == 0)
			{
				return;
			}
			int num = childNodeTypes.Count;
			foreach (int childNodeType in childNodeTypes)
			{
				num = num * 31 + childNodeType;
			}
			if (_navigationSlotsConfigured && num == _lastNavigationHash)
			{
				return;
			}
			try
			{
				PostBattleController[] array = Resources.FindObjectsOfTypeAll<PostBattleController>();
				PostBattleController val = ((array.Length != 0) ? array[0] : null);
				if ((Object)(object)val == (Object)null)
				{
					_log.LogWarning((object)"[MapApplier] No PostBattleController in scene for navigation slots");
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(PostBattleController), "_leftSlotManager");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(PostBattleController), "_centerSlotManager");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(PostBattleController), "_rightSlotManager");
				object? obj = fieldInfo?.GetValue(val);
				SlotManager val2 = (SlotManager)((obj is SlotManager) ? obj : null);
				object? obj2 = fieldInfo2?.GetValue(val);
				SlotManager val3 = (SlotManager)((obj2 is SlotManager) ? obj2 : null);
				object? obj3 = fieldInfo3?.GetValue(val);
				SlotManager val4 = (SlotManager)((obj3 is SlotManager) ? obj3 : null);
				if ((Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null || (Object)(object)val4 == (Object)null)
				{
					_log.LogWarning((object)"[MapApplier] Could not find SlotManagers");
					return;
				}
				int count = childNodeTypes.Count;
				if (count == 1)
				{
					int num2 = childNodeTypes[0];
					Color colorForNodeType = MapNode.GetColorForNodeType((RoomType)num2);
					Sprite val5 = GetIconForRoomType((RoomType)num2);
					((Component)val2).gameObject.SetActive(true);
					val2.ConfigureHalfNavigation(colorForNodeType, 0.2f, 0.8f);
					((Component)val4).gameObject.SetActive(true);
					val4.ConfigureHalfNavigation(colorForNodeType, 0.2f, 0.8f);
					((Component)val3).gameObject.SetActive(true);
					if ((Object)(object)val5 != (Object)null)
					{
						val3.ConfigureForNavigation(val5, colorForNodeType, 0.2f, 0.8f);
					}
					else
					{
						val3.ConfigureHalfNavigation(colorForNodeType, 0.2f, 0.8f);
					}
				}
				else
				{
					int num3 = childNodeTypes[0];
					Color colorForNodeType2 = MapNode.GetColorForNodeType((RoomType)num3);
					Sprite val6 = GetIconForRoomType((RoomType)num3);
					((Component)val2).gameObject.SetActive(true);
					if ((Object)(object)val6 != (Object)null)
					{
						val2.ConfigureForNavigation(val6, colorForNodeType2, 0.2f, 0.8f);
					}
					else
					{
						val2.ConfigureHalfNavigation(colorForNodeType2, 0.2f, 0.8f);
					}
					int num4 = childNodeTypes[count - 1];
					Color colorForNodeType3 = MapNode.GetColorForNodeType((RoomType)num4);
					Sprite val7 = GetIconForRoomType((RoomType)num4);
					((Component)val4).gameObject.SetActive(true);
					if ((Object)(object)val7 != (Object)null)
					{
						val4.ConfigureForNavigation(val7, colorForNodeType3, 0.2f, 0.8f);
					}
					else
					{
						val4.ConfigureHalfNavigation(colorForNodeType3, 0.2f, 0.8f);
					}
					((Component)val3).gameObject.SetActive(true);
					if (count > 2)
					{
						int num5 = childNodeTypes[1];
						Color colorForNodeType4 = MapNode.GetColorForNodeType((RoomType)num5);
						Sprite val8 = GetIconForRoomType((RoomType)num5);
						if ((Object)(object)val8 != (Object)null)
						{
							val3.ConfigureForNavigation(val8, colorForNodeType4, 0.2f, 0.8f);
						}
						else
						{
							val3.ConfigureHalfNavigation(colorForNodeType4, 0.2f, 0.8f);
						}
					}
					else
					{
						val3.ConfigureDudNavigation();
					}
				}
				_navigationSlotsConfigured = true;
				_lastNavigationHash = num;
				_log.LogInfo((object)($"[MapApplier] Navigation slots configured: {count} child nodes " + "(" + string.Join(",", childNodeTypes.ConvertAll(delegate(int t)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					RoomType val10 = (RoomType)t;
					return ((object)(RoomType)(ref val10)).ToString();
				})) + ")"));
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[MapApplier] ApplyNavigationSlots failed: " + ex.Message));
			}
			static Sprite GetIconForRoomType(RoomType rt)
			{
				//IL_0018: Unknown result type (might be due to invalid IL or missing references)
				//IL_001d: Unknown result type (might be due to invalid IL or missing references)
				try
				{
					MapNode[] array2 = Resources.FindObjectsOfTypeAll<MapNode>();
					foreach (MapNode val9 in array2)
					{
						if ((Object)(object)val9 != (Object)null && val9.RoomType == rt)
						{
							Sprite activeIcon = val9.activeIcon;
							if ((Object)(object)activeIcon != (Object)null)
							{
								return activeIcon;
							}
						}
					}
				}
				catch
				{
				}
				return null;
			}
		}

		private void ApplyMapNodes(List<MapNodeEntry> hostNodes, float? hostPlayerX = null, float? hostPlayerY = null)
		{
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			//IL_0251: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Unknown result type (might be due to invalid IL or missing references)
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0226: Unknown result type (might be due to invalid IL or missing references)
			//IL_022b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
			//IL_010a: Unknown result type (might be due to invalid IL or missing references)
			//IL_037d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_0124: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: 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_0164: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_0185: Unknown result type (might be due to invalid IL or missing references)
			//IL_0187: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MapController val = Object.FindObjectOfType<MapController>();
				if ((Object)(object)val == (Object)null)
				{
					_log.LogWarning((object)"[MapApplier] No MapController found for node sync");
					return;
				}
				if (!(AccessTools.Field(typeof(MapController), "_nodes")?.GetValue(val) is MapNode[] array))
				{
					_log.LogWarning((object)"[MapApplier] Could not access client map nodes");
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(MapNode), "_selectedBossIndex");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(MapNode), "_roomStatus");
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				foreach (MapNodeEntry hostNode in hostNodes)
				{
					if (hostNode.Index < 0 || hostNode.Index >= array.Length)
					{
						num2++;
						continue;
					}
					MapNode val2 = array[hostNode.Index];
					if ((Object)(object)val2 == (Object)null)
					{
						num2++;
						continue;
					}
					RoomType val3 = (RoomType)hostNode.RoomType;
					RoomState val4 = (RoomState)((hostNode.RoomState >= 0) ? hostNode.RoomState : 4);
					RoomState val5 = (RoomState)(fieldInfo2?.GetValue(val2) ?? ((object)(RoomState)4));
					bool flag = hostNode.SelectedBossIndex < 0 || fieldInfo == null || (int)fieldInfo.GetValue(val2) == hostNode.SelectedBossIndex;
					if (val2.RoomType == val3 && val5 == val4 && flag)
					{
						num3++;
						num++;
						continue;
					}
					val2.RoomType = val3;
					if (hostNode.SelectedBossIndex >= 0 && fieldInfo != null)
					{
						fieldInfo.SetValue(val2, hostNode.SelectedBossIndex);
					}
					try
					{
						val2.SetActiveState(val4, false, true);
						if ((int)val2.RoomType != 0)
						{
							val2.GenerateIcon(-1f);
						}
					}
					catch (Exception ex)
					{
						_log.LogWarning((object)($"[MapApplier] SetActiveState failed for node {hostNode.Index} " + $"(type={val3}, state={val4}): {ex.Message}"));
					}
					if (num < 3 || val2.RoomType != val3)
					{
						_log.LogInfo((object)$"[MapApplier] Node {hostNode.Index}: set={val3}, actual={val2.RoomType}, state={val4}");
					}
					num++;
				}
				Dictionary<int, int> dictionary = new Dictionary<int, int>();
				foreach (MapNodeEntry hostNode2 in hostNodes)
				{
					dictionary[hostNode2.RoomType] = ((!dictionary.TryGetValue(hostNode2.RoomType, out var value)) ? 1 : (value + 1));
				}
				string arg = string.Join(", ", dictionary.Select((KeyValuePair<int, int> kv) => $"{(object)(RoomType)kv.Key}={kv.Value}"));
				_log.LogInfo((object)($"[MapApplier] Applied {num} node types ({num3} unchanged) from host, {num2} skipped " + $"(host={hostNodes.Count}, client={array.Length}) hostTypes[{arg}]"));
				if (num > 0)
				{
					Scene activeScene = SceneManager.GetActiveScene();
					string name = ((Scene)(ref activeScene)).name;
					if (MapScenes.Contains(name))
					{
						_mapStateCache[name] = new CachedMapState
						{
							Nodes = hostNodes,
							PlayerPosX = hostPlayerX,
							PlayerPosY = hostPlayerY
						};
					}
				}
				MovePlayerToCurrentNode(val, array, hostNodes, hostPlayerX, hostPlayerY);
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[MapApplier] ApplyMapNodes failed: " + ex2.Message));
			}
		}

		private void MovePlayerToCurrentNode(MapController mc, MapNode[] clientNodes, List<MapNodeEntry> hostNodes, float? hostPlayerX, float? hostPlayerY)
		{
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			//IL_0115: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Unknown result type (might be due to invalid IL or missing references)
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				object? obj = AccessTools.Field(typeof(MapController), "_player")?.GetValue(mc);
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				Vector3 position = default(Vector3);
				if (hostPlayerX.HasValue && hostPlayerY.HasValue)
				{
					((Vector3)(ref position))..ctor(hostPlayerX.Value, hostPlayerY.Value, val.transform.position.z);
				}
				else
				{
					MapNode val2 = null;
					foreach (MapNodeEntry hostNode in hostNodes)
					{
						if (hostNode.RoomState == 2 && hostNode.Index >= 0 && hostNode.Index < clientNodes.Length)
						{
							val2 = clientNodes[hostNode.Index];
							break;
						}
					}
					if ((Object)(object)val2 == (Object)null)
					{
						return;
					}
					position = ((Component)val2).transform.position;
				}
				if (Vector3.Distance(val.transform.position, position) > 0.1f)
				{
					val.transform.position = position;
					_log.LogInfo((object)$"[MapApplier] Moved player to ({position.x:F1},{position.y:F1})");
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(MapController), "_previousNode");
				MapNode val3 = null;
				float num = float.MaxValue;
				foreach (MapNode val4 in clientNodes)
				{
					if (!((Object)(object)val4 == (Object)null))
					{
						float num2 = Vector3.SqrMagnitude(((Component)val4).transform.position - position);
						if (num2 < num)
						{
							num = num2;
							val3 = val4;
						}
					}
				}
				if ((Object)(object)val3 != (Object)null)
				{
					fieldInfo?.SetValue(mc, val3);
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[MapApplier] MovePlayerToCurrentNode failed: " + ex.Message));
			}
		}
	}
	public class PegboardStateApplier : IGameStateApplier<PegboardStateSnapshot>
	{
		private class StructIndex
		{
			public Dictionary<string, List<Peg>> ByPos = new Dictionary<string, List<Peg>>(StringComparer.Ordinal);

			public Dictionary<string, List<Peg>> BySibling = new Dictionary<string, List<Peg>>(StringComparer.Ordinal);
		}

		private readonly ManualLogSource _log;

		private readonly PegIdentifier _pegId;

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

		private readonly Dictionary<int, GameObject> _clientBlackHoles = new Dictionary<int, GameObject>();

		private readonly HashSet<Transform> _syncedMovementParents = new HashSet<Transform>();

		private GameObject _cachedBombPrefab;

		private static readonly StructIndex _emptyStructIndex = new StructIndex();

		private static FieldInfo _splineDistancesField;

		private static readonly Dictionary<string, PegSplineFollow> _splineGeneratorCache = new Dictionary<string, PegSplineFollow>(StringComparer.Ordinal);

		private static readonly HashSet<string> _loggedSplineMissPaths = new HashSet<string>(StringComparer.Ordinal);

		private static readonly HashSet<string> _loggedSplineMismatchPaths = new HashSet<string>(StringComparer.Ordinal);

		[ThreadStatic]
		private static List<string> _hierarchyPathBuf;

		private static FieldInfo _obscurerGridField;

		private static FieldInfo _obscurerWidthField;

		private static FieldInfo _obscurerHeightField;

		private (int w, int h, int revealedCount) _lastObscurerSig = (-1, -1, -1);

		public PegboardStateApplier(ManualLogSource log, PegIdentifier pegId)
		{
			_log = log;
			_pegId = pegId;
		}

		private static string VineKey(string guid1, string guid2)
		{
			if (string.Compare(guid1, guid2, StringComparison.Ordinal) >= 0)
			{
				return guid2 + "|" + guid1;
			}
			return guid1 + "|" + guid2;
		}

		public void Apply(PegboardStateSnapshot snapshot)
		{
			//IL_0b65: Unknown result type (might be due to invalid IL or missing references)
			//IL_0b6f: Unknown result type (might be due to invalid IL or missing references)
			//IL_112b: Unknown result type (might be due to invalid IL or missing references)
			//IL_1141: Unknown result type (might be due to invalid IL or missing references)
			//IL_1164: Unknown result type (might be due to invalid IL or missing references)
			//IL_054f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0563: Unknown result type (might be due to invalid IL or missing references)
			//IL_0566: Invalid comparison between Unknown and I4
			//IL_04fd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0513: Unknown result type (might be due to invalid IL or missing references)
			//IL_028f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a5: Unknown result type (might be due to invalid IL or missing references)
			//IL_07d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_07ed: Unknown result type (might be due to invalid IL or missing references)
			//IL_08a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_08be: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				_syncedMovementParents.Clear();
				if (snapshot.Pegs == null || snapshot.Pegs.Count == 0)
				{
					_log.LogInfo((object)"[PegboardApplier] No pegs in snapshot.");
					return;
				}
				BattleController val = Object.FindObjectOfType<BattleController>();
				PegManager val2 = ((val != null) ? val.pegManager : null);
				if (val2 == null || val2.allPegs == null)
				{
					_log.LogInfo((object)$"[PegboardApplier] No PegManager in scene. Snapshot has {snapshot.TotalPegCount} pegs.");
					return;
				}
				List<Peg> allPegs = val2.allPegs;
				List<Bomb> list = AccessTools.Field(typeof(PegManager), "_bombs")?.GetValue(val2) as List<Bomb>;
				List<BouncerPeg> bouncerPegs = val2.bouncerPegs;
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				int typeChanged = 0;
				int destroyed = 0;
				int reactivated = 0;
				int cleared = 0;
				int num5 = 0;
				int num6 = 0;
				int num7 = 0;
				HashSet<Peg> hashSet = new HashSet<Peg>();
				List<PegEntry> list2 = new List<PegEntry>();
				int pegsCount = allPegs?.Count ?? 0;
				int bombsCount = list?.Count ?? 0;
				_ = bouncerPegs?.Count;
				StructIndex index = (AllPegsHaveGuids(allPegs, list, bouncerPegs) ? _emptyStructIndex : BuildStructIndex(allPegs, list, bouncerPegs));
				foreach (PegEntry peg in snapshot.Pegs)
				{
					Peg val3 = null;
					Peg val4 = ResolveByStructKey(index, peg);
					if ((Object)(object)val4 != (Object)null && !hashSet.Contains(val4) && string.IsNullOrEmpty(_pegId.GetGuid(val4)) && TypeMatches(val4, peg))
					{
						val3 = val4;
						num7++;
						if (peg.PegType != 0 || peg.IsBomb || peg.IsBouncer || peg.HasLpm)
						{
							string text = (peg.HasLpm ? $"sibling#{peg.SiblingIndex}" : $"lp({peg.LocalPosX:F2},{peg.LocalPosY:F2})");
							_log.LogInfo((object)("[PegboardApplier] STRUCT BIND: key=(" + peg.ParentName + "|" + text + ") " + $"guid={peg.Guid} type={peg.PegTypeName} lpm={peg.HasLpm} " + $"hostPos=({peg.PosX:F1},{peg.PosY:F1}) " + $"clientPos=({((Component)val4).transform.position.x:F1},{((Component)val4).transform.position.y:F1})"));
						}
					}
					if ((Object)(object)val3 == (Object)null && string.IsNullOrEmpty(peg.ParentName))
					{
						Peg val5 = ResolveByIndex(peg.Index, pegsCount, bombsCount, allPegs, list, bouncerPegs);
						if ((Object)(object)val5 != (Object)null && !hashSet.Contains(val5) && string.IsNullOrEmpty(_pegId.GetGuid(val5)) && TypeMatches(val5, peg) && IndexBindPositionSane(val5, peg))
						{
							val3 = val5;
							num++;
						}
					}
					if ((Object)(object)val3 == (Object)null && !string.IsNullOrEmpty(peg.Guid))
					{
						val3 = _pegId.Find(peg.Guid);
						if ((Object)(object)val3 != (Object)null)
						{
							bool flag = val3 is Bomb;
							bool flag2 = val3 is BouncerPeg;
							if (peg.IsBomb != flag || peg.IsBouncer != flag2)
							{
								_log.LogWarning((object)("[PegboardApplier] GUID type mismatch: " + peg.Guid + " " + $"entry(bomb={peg.IsBomb},bouncer={peg.IsBouncer}) " + "peg(" + ((object)val3).GetType().Name + ") — re-matching by position"));
								num6++;
								val3 = null;
							}
							else
							{
								num2++;
							}
						}
					}
					if ((Object)(object)val3 == (Object)null)
					{
						val3 = (peg.IsBomb ? FindClosestUnmatched(peg, null, list, null, hashSet, 3f) : ((!peg.IsBouncer) ? FindClosestUnmatched(peg, allPegs, null, null, hashSet, 1f) : FindClosestUnmatched(peg, null, null, bouncerPegs, hashSet, 3f)));
						if ((Object)(object)val3 != (Object)null)
						{
							num3++;
							_log.LogWarning((object)($"[PegboardApplier] POS BIND (idx fallback): idx={peg.Index} guid={peg.Guid} " + $"type={peg.PegTypeName} hostPos=({peg.PosX:F1},{peg.PosY:F1}) " + $"clientPos=({((Component)val3).transform.position.x:F1},{((Component)val3).transform.position.y:F1})"));
						}
					}
					if ((Object)(object)val3 != (Object)null)
					{
						hashSet.Add(val3);
						PegType val6 = (PegType)peg.PegType;
						if (val3 is Bomb && !peg.IsBomb && (int)val6 != 4)
						{
							_log.LogWarning((object)("[PegboardApplier] BOMB DEACTIVATED: " + peg.Guid + " client is Bomb but host says " + peg.PegTypeName));
							((Component)val3).gameObject.SetActive(false);
						}
						else
						{
							ApplyPegState(val3, peg, list, ref typeChanged, ref destroyed, ref reactivated, ref cleared);
						}
						if (peg.IsBomb && val3 is Bomb)
						{
							try
							{
								val3.IsDisabled();
							}
							catch
							{
							}
						}
						SyncPegPosition(val3, peg);
					}
					else
					{
						list2.Add(peg);
					}
				}
				if (list2.Count > 0)
				{
					List<Peg> list3 = new List<Peg>();
					List<Peg> list4 = new List<Peg>();
					List<Peg> list5 = new List<Peg>();
					foreach (Peg item in allPegs)
					{
						if ((Object)(object)item != (Object)null && !hashSet.Contains(item))
						{
							list3.Add(item);
						}
					}
					if (list != null)
					{
						foreach (Bomb item2 in list)
						{
							if ((Object)(object)item2 != (Object)null && !hashSet.Contains((Peg)(object)item2))
							{
								list4.Add((Peg)(object)item2);
							}
						}
					}
					if (bouncerPegs != null)
					{
						foreach (BouncerPeg item3 in bouncerPegs)
						{
							if ((Object)(object)item3 != (Object)null && !hashSet.Contains((Peg)(object)item3))
							{
								list5.Add((Peg)(object)item3);
							}
						}
					}
					Peg val7 = null;
					if (allPegs.Count > 0)
					{
						val7 = allPegs[0];
					}
					foreach (PegEntry item4 in list2)
					{
						Peg val8 = null;
						List<Peg> list6 = (item4.IsBomb ? list4 : (item4.IsBouncer ? list5 : list3));
						if (list6.Count > 0)
						{
							val8 = list6[list6.Count - 1];
							list6.RemoveAt(list6.Count - 1);
							num4++;
						}
						else if (item4.IsBomb && list3.Count > 0)
						{
							int num8 = -1;
							float num9 = float.MaxValue;
							for (int i = 0; i < list3.Count; i++)
							{
								Peg val9 = list3[i];
								if (!((Object)(object)val9 == (Object)null))
								{
									float num10 = ((Component)val9).transform.position.x - item4.PosX;
									float num11 = ((Component)val9).transform.position.y - item4.PosY;
									float num12 = num10 * num10 + num11 * num11;
									if (num12 < num9)
									{
										num9 = num12;
										num8 = i;
									}
								}
							}
							if (num8 >= 0)
							{
								val8 = list3[num8];
								list3.RemoveAt(num8);
								num4++;
								_log.LogInfo((object)("[PegboardApplier] BOMB FROM REGULAR: guid=" + item4.Guid + " " + $"hostPos=({item4.PosX:F1},{item4.PosY:F1}) " + $"converting regular peg at ({((Component)val8).transform.position.x:F1},{((Component)val8).transform.position.y:F1}) to bomb"));
							}
							else
							{
								val8 = SynthesizeBomb(item4, allPegs, list);
								if ((Object)(object)val8 == (Object)null)
								{
									num5++;
									_log.LogWarning((object)("[PegboardApplier] MISSED unmatched entry guid=" + item4.Guid + " " + $"hostPos=({item4.PosX:F1},{item4.PosY:F1}) bomb={item4.IsBomb} bouncer={item4.IsBouncer} " + "— bomb synthesis failed"));
									continue;
								}
								num4++;
							}
						}
						else if (item4.IsBomb)
						{
							val8 = SynthesizeBomb(item4, allPegs, list);
							if ((Object)(object)val8 == (Object)null)
							{
								num5++;
								_log.LogWarning((object)("[PegboardApplier] MISSED unmatched entry guid=" + item4.Guid + " " + $"hostPos=({item4.PosX:F1},{item4.PosY:F1}) bomb={item4.IsBomb} bouncer={item4.IsBouncer} " + "— bomb synthesis failed"));
								continue;
							}
							num4++;
						}
						else
						{
							if (item4.IsBomb || item4.IsBouncer || !((Object)(object)val7 != (Object)null))
							{
								num5++;
								_log.LogWarning((object)("[PegboardApplier] MISSED unmatched entry guid=" + item4.Guid + " " + $"hostPos=({item4.PosX:F1},{item4.PosY:F1}) bomb={item4.IsBomb} bouncer={item4.IsBouncer} " + "— no same-type client peg available"));
								continue;
							}
							Peg obj2 = Object.Instantiate<Peg>(val7, ((Component)val7).transform.parent);
							((Component)obj2).gameObject.SetActive(true);
							val8 = obj2;
							try
							{
								val2.AddPeg(val8);
							}
							catch
							{
								allPegs.Add(val8);
							}
							num4++;
						}
						((Component)val8).transform.position = new Vector3(item4.PosX, item4.PosY, ((Component)val8).transform.position.z);
						hashSet.Add(val8);
						ApplyPegState(val8, item4, list, ref typeChanged, ref destroyed, ref reactivated, ref cleared);
						SyncPegPosition(val8, item4);
						if (item4.IsBomb && !string.IsNullOrEmpty(item4.Guid))
						{
							Peg val10 = _pegId.Find(item4.Guid);
							if ((Object)(object)val10 != (Object)null && (Object)(object)val10 != (Object)(object)val8)
							{
								hashSet.Add(val10);
							}
						}
					}
				}
				HashSet<Transform> hashSet2 = new HashSet<Transform>();
				foreach (Peg item5 in hashSet)
				{
					if ((Object)(object)item5 != (Object)null)
					{
						Transform parent = ((Component)item5).transform.parent;
						while ((Object)(object)parent != (Object)null)
						{
							hashSet2.Add(parent);
							parent = parent.parent;
						}
					}
				}
				int num13 = 0;
				foreach (Peg item6 in allPegs)
				{
					if ((Object)(object)item6 != (Object)null && ((Component)item6).gameObject.activeSelf && !hashSet.Contains(item6) && !hashSet2.Contains(((Component)item6).transform))
					{
						((Component)item6).gameObject.SetActive(false);
						num13++;
					}
				}
				int num14 = 0;
				if (list != null)
				{
					for (int num15 = list.Count - 1; num15 >= 0; num15--)
					{
						Bomb val11 = list[num15];
						if ((Object)(object)val11 == (Object)null)
						{
							list.RemoveAt(num15);
						}
						else if (!hashSet.Contains((Peg)(object)val11) && !hashSet2.Contains(((Component)val11).transform))
						{
							string guid = _pegId.GetGuid((Peg)(object)val11);
							if (!string.IsNullOrEmpty(guid))
							{
								try
								{
									IDictionary dictionary = AccessTools.Field(typeof(PegIdentifier), "_guidToPeg")?.GetValue(_pegId) as IDictionary;
									IDictionary obj4 = AccessTools.Field(typeof(PegIdentifier), "_pegToGuid")?.GetValue(_pegId) as IDictionary;
									dictionary?.Remove(guid);
									obj4?.Remove(val11);
								}
								catch
								{
								}
							}
							list.RemoveAt(num15);
							try
							{
								Object.Destroy((Object)(object)((Component)val11).gameObject);
							}
							catch
							{
							}
							num14++;
							num13++;
						}
					}
				}
				if (num14 > 0)
				{
					_log.LogWarning((object)$"[PegboardApplier] Purged {num14} stale client bombs (not in host snapshot)");
				}
				if (bouncerPegs != null)
				{
					foreach (BouncerPeg item7 in bouncerPegs)
					{
						if ((Object)(object)item7 != (Object)null && ((Component)item7).gameObject.activeSelf && !hashSet.Contains((Peg)(object)item7) && !hashSet2.Contains(((Component)item7).transform))
						{
							((Component)item7).gameObject.SetActive(false);
							num13++;
						}
					}
				}
				int num16 = allPegs.Count + (list?.Count ?? 0) + (bouncerPegs?.Count ?? 0);
				if (num4 + typeChanged + destroyed + reactivated + cleared + num5 + num6 + num13 > 0)
				{
					_log.LogInfo((object)($"[PegboardApplier] StructMatched={num7}, IdxMatched={num}, GUIDMatched={num2}, PosMatched={num3}, " + $"Repositioned={num4}, TypeChanged={typeChanged}, Destroyed={destroyed}, " + $"Reactivated={reactivated}, Cleared={cleared}, Missed={num5}, GUIDTypeInvalid={num6}, " + $"ExtrasRemoved={num13} " + $"(host={snapshot.TotalPegCount}, client={num16}, " + $"crit={snapshot.CritPegCount}, bomb={snapshot.BombPegCount}, " + $"reset={snapshot.ResetPegCount}, bouncer={snapshot.BouncerPegCount}, " + $"registry={_pegId.Count})"));
				}
				SyncVines(snapshot, val);
				SyncBlackHoles(snapshot);
				SyncSplineGenerators(snapshot);
				SyncObscurerGrid(snapshot);
				int bombPegCount = snapshot.BombPegCount;
				int num17 = 0;
				if (list != null)
				{
					for (int j = 0; j < list.Count; j++)
					{
						Bomb val12 = list[j];
						if ((Object)(object)val12 != (Object)null && ((Component)val12).gameObject.activeInHierarchy)
						{
							num17++;
						}
					}
				}
				if (num17 == bombPegCount)
				{
					return;
				}
				LogActualPegState(allPegs, list, bouncerPegs);
				if (list == null)
				{
					return;
				}
				for (int k = 0; k < list.Count; k++)
				{
					Bomb val13 = list[k];
					if ((Object)(object)val13 == (Object)null)
					{
						_log.LogInfo((object)$"[PegboardApplier] CLIENT_BOMB[{k}] NULL");
						continue;
					}
					bool flag3 = false;
					try
					{
						flag3 = ((Peg)val13).IsDisabled();
					}
					catch
					{
					}
					string arg = _pegId.GetGuid((Peg)(object)val13) ?? "none";
					_log.LogInfo((object)($"[PegboardApplier] CLIENT_BOMB[{k}] guid={arg} " + $"pos=({((Component)val13).transform.position.x:F1},{((Component)val13).transform.position.y:F1}) " + $"type={((Peg)val13).pegType} active={((Component)val13).gameObject.activeSelf} disabled={flag3} hits={val13.HitCount}"));
				}
			}
			catch (Exception ex)
			{
				_log.LogError((object)("[PegboardApplier] Apply failed: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		public void ResetMovementParentTracking()
		{
			_syncedMovementParents.Clear();
		}

		private void SyncPegPosition(Peg originalPeg, PegEntry entry)
		{
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0242: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c4: 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_01c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d2: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01de: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_0310: Unknown result type (might be due to invalid IL or missing references)
			//IL_0315: Unknown result type (might be due to invalid IL or missing references)
			//IL_0316: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02fc: Invalid comparison between Unknown and I4
			//IL_02a7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_0268: Unknown result type (might be due to invalid IL or missing references)
			//IL_0274: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Invalid comparison between Unknown and I4
			//IL_0222: Unknown result type (might be due to invalid IL or missing references)
			//IL_0207: Unknown result type (might be due to invalid IL or missing references)
			//IL_020e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0215: Unknown result type (might be due to invalid IL or missing references)
			//IL_0173: Unknown result type (might be due to invalid IL or missing references)
			//IL_0339: Unknown result type (might be due to invalid IL or missing references)
			//IL_033f: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0300: Unknown result type (might be due to invalid IL or missing references)
			//IL_027e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0196: Unknown result type (might be due to invalid IL or missing references)
			//IL_019d: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a4: Unknown result type (might be due to invalid IL or missing references)
			Peg val = ((!string.IsNullOrEmpty(entry.Guid)) ? _pegId.Find(entry.Guid) : null) ?? originalPeg;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(entry.PosX, entry.PosY, ((Component)val).transform.position.z);
			LinearPegMovement component = ((Component)val).GetComponent<LinearPegMovement>();
			if ((Object)(object)component == (Object)null && (Object)(object)((Component)val).transform.parent != (Object)null)
			{
				component = ((Component)((Component)val).transform.parent).GetComponent<LinearPegMovement>();
			}
			if ((Object)(object)component == (Object)null)
			{
				Transform parent = ((Component)val).transform.parent;
				if ((Object)(object)((parent != null) ? parent.parent : null) != (Object)null)
				{
					component = ((Component)((Component)val).transform.parent.parent).GetComponent<LinearPegMovement>();
				}
			}
			if ((Object)(object)component == (Object)null && entry.LpmParentPosX.HasValue)
			{
				Transform parent2 = ((Component)val).transform.parent;
				while ((Object)(object)parent2 != (Object)null && (Object)(object)component == (Object)null)
				{
					component = ((Component)parent2).GetComponent<LinearPegMovement>();
					parent2 = parent2.parent;
				}
			}
			if ((Object)(object)component != (Object)null)
			{
				Transform transform = ((Component)component).transform;
				if (!_syncedMovementParents.Add(transform))
				{
					return;
				}
				if (entry.LpmParentPosX.HasValue && entry.LpmParentPosY.HasValue)
				{
					Vector3 val3 = default(Vector3);
					((Vector3)(ref val3))..ctor(entry.LpmParentPosX.Value, entry.LpmParentPosY.Value, transform.position.z);
					Rigidbody2D component2 = ((Component)component).GetComponent<Rigidbody2D>();
					if ((Object)(object)component2 != (Object)null)
					{
						component2.position = new Vector2(val3.x, val3.y);
					}
					else
					{
						transform.position = val3;
					}
					return;
				}
				Vector3 position = ((Component)val).transform.position;
				Vector3 val4 = val2 - position;
				Vector3 val5 = transform.position + val4;
				val5.z = transform.position.z;
				Rigidbody2D component3 = ((Component)component).GetComponent<Rigidbody2D>();
				if ((Object)(object)component3 != (Object)null)
				{
					component3.position = new Vector2(val5.x, val5.y);
				}
				else
				{
					transform.position = val5;
				}
				return;
			}
			if ((Object)(object)val != (Object)(object)originalPeg && (Object)(object)originalPeg != (Object)null)
			{
				((Component)originalPeg).transform.position = val2;
				Rigidbody2D component4 = ((Component)originalPeg).GetComponent<Rigidbody2D>();
				if ((Object)(object)component4 != (Object)null)
				{
					component4.position = new Vector2(entry.PosX, entry.PosY);
					if ((int)component4.bodyType != 2)
					{
						component4.velocity = Vector2.zero;
					}
				}
			}
			if (!(val is Bomb) && HasMovementComponent(val))
			{
				((Component)val).transform.position = Vector3.Lerp(((Component)val).transform.position, val2, 0.15f);
			}
			else
			{
				((Component)val).transform.position = val2;
				Rigidbody2D component5 = ((Component)val).GetComponent<Rigidbody2D>();
				if ((Object)(object)component5 != (Object)null)
				{
					component5.position = new Vector2(entry.PosX, entry.PosY);
					if ((int)component5.bodyType != 2)
					{
						component5.velocity = Vector2.zero;
					}
				}
			}
			Vector3 localEulerAngles = ((Component)val).transform.localEulerAngles;
			if (Mathf.Abs(Mathf.DeltaAngle(localEulerAngles.z, entry.RotZ)) > 0.1f)
			{
				((Component)val).transform.localEulerAngles = new Vector3(localEulerAngles.x, localEulerAngles.y, entry.RotZ);
			}
		}

		private Peg SynthesizeBomb(PegEntry entry, List<Peg> clientPegs, List<Bomb> clientBombs)
		{
			//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_0292: Unknown result type (might be due to invalid IL or missing references)
			//IL_0297: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)_cachedBombPrefab == (Object)null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(RegularPeg), "_bombPrefab");
					if (fieldInfo != null)
					{
						foreach (Peg clientPeg in clientPegs)
						{
							RegularPeg val = (RegularPeg)(object)((clientPeg is RegularPeg) ? clientPeg : null);
							if (val != null)
							{
								object? value = fieldInfo.GetValue(val);
								GameObject val2 = (GameObject)((value is GameObject) ? value : null);
								if ((Object)(object)val2 != (Object)null)
								{
									_cachedBombPrefab = val2;
									break;
								}
							}
						}
					}
				}
				if ((Object)(object)_cachedBombPrefab == (Object)null)
				{
					return null;
				}
				Transform val3 = null;
				bool flag = false;
				if (entry.HasLpm && entry.LpmParentPosX.HasValue && entry.LpmParentPosY.HasValue)
				{
					LinearPegMovement[] array = Object.FindObjectsOfType<LinearPegMovement>();
					float num = 0.25f;
					LinearPegMovement[] array2 = array;
					foreach (LinearPegMovement val4 in array2)
					{
						if (!((Object)(object)val4 == (Object)null))
						{
							Vector3 position = ((Component)val4).transform.position;
							float num2 = position.x - entry.LpmParentPosX.Value;
							float num3 = position.y - entry.LpmParentPosY.Value;
							float num4 = num2 * num2 + num3 * num3;
							if (num4 < num)
							{
								num = num4;
								val3 = ((Component)val4).transform;
							}
						}
					}
					if ((Object)(object)val3 != (Object)null)
					{
						flag = true;
					}
				}
				if ((Object)(object)val3 == (Object)null)
				{
					foreach (Peg clientPeg2 in clientPegs)
					{
						if ((Object)(object)clientPeg2 != (Object)null && (Object)(object)((Component)clientPeg2).transform.parent != (Object)null)
						{
							val3 = ((Component)clientPeg2).transform.parent;
							break;
						}
					}
				}
				Vector3 val5 = default(Vector3);
				((Vector3)(ref val5))..ctor(entry.PosX, entry.PosY, 0f);
				GameObject val6 = Object.Instantiate<GameObject>(_cachedBombPrefab, val5, Quaternion.identity, val3);
				val6.SetActive(true);
				Bomb component = val6.GetComponent<Bomb>();
				if ((Object)(object)component == (Object)null)
				{
					Object.Destroy((Object)(object)val6);
					return null;
				}
				_pegId.Register((Peg)(object)component, entry.Guid);
				if (clientBombs != null && !clientBombs.Contains(component))
				{
					clientBombs.Add(component);
				}
				if (flag)
				{
					LpmBombFollower obj = val6.GetComponent<LpmBombFollower>() ?? val6.AddComponent<LpmBombFollower>();
					obj.LpmParent = val3;
					obj.LocalOffset = new Vector3(entry.PosX - entry.LpmParentPosX.Value, entry.PosY - entry.LpmParentPosY.Value, 0f);
				}
				_log.LogInfo((object)("[PegboardApplier] BOMB SYNTHESIZED: guid=" + entry.Guid + " " + $"pos=({entry.PosX:F1},{entry.PosY:F1}) from _bombPrefab " + $"underLpm={flag}"));
				return (Peg)(object)component;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[PegboardApplier] SynthesizeBomb failed: " + ex.Message));
				return null;
			}
		}

		private bool AllPegsHaveGuids(List<Peg> clientPegs, List<Bomb> clientBombs, List<BouncerPeg> clientBouncers)
		{
			if (clientPegs != null)
			{
				foreach (Peg clientPeg in clientPegs)
				{
					if ((Object)(object)clientPeg != (Object)null && string.IsNullOrEmpty(_pegId.GetGuid(clientPeg)))
					{
						return false;
					}
				}
			}
			if (clientBombs != null)
			{
				foreach (Bomb clientBomb in clientBombs)
				{
					if ((Object)(object)clientBomb != (Object)null && string.IsNullOrEmpty(_pegId.GetGuid((Peg)(object)clientBomb)))
					{
						return false;
					}
				}
			}
			if (clientBouncers != null)
			{
				foreach (BouncerPeg clientBouncer in clientBouncers)
				{
					if ((Object)(object)clientBouncer != (Object)null && string.IsNullOrEmpty(_pegId.GetGuid((Peg)(object)clientBouncer)))
					{
						return false;
					}
				}
			}
			return true;
		}

		private static StructIndex BuildStructIndex(List<Peg> clientPegs, List<Bomb> clientBombs, List<BouncerPeg> clientBouncers)
		{
			StructIndex index = new StructIndex();
			if (clientPegs != null)
			{
				foreach (Peg clientPeg in clientPegs)
				{
					Add(clientPeg);
				}
			}
			if (clientBombs != null)
			{
				foreach (Bomb clientBomb in clientBombs)
				{
					Add((Peg)(object)clientBomb);
				}
			}
			if (clientBouncers != null)
			{
				foreach (BouncerPeg clientBouncer in clientBouncers)
				{
					Add((Peg)(object)clientBouncer);
				}
			}
			return index;
			void Add(Peg p)
			{
				//IL_0033: Unknown result type (might be due to invalid IL or missing references)
				//IL_0038: Unknown result type (might be due to invalid IL or missing references)
				//IL_0045: Unknown result type (might be due to invalid IL or missing references)
				//IL_004b: Unknown result type (might be due to invalid IL or missing references)
				if (!((Object)(object)p == (Object)null))
				{
					Transform parent = ((Component)p).transform.parent;
					string parentName = (((Object)(object)parent != (Object)null) ? BuildHierarchyPath(parent) : string.Empty);
					Vector3 localPosition = ((Component)p).transform.localPosition;
					AddTo(index.ByPos, MakePosStructKey(parentName, localPosition.x, localPosition.y), p);
					AddTo(index.BySibling, MakeSiblingStructKey(parentName, ((Component)p).transform.GetSiblingIndex()), p);
				}
			}
			static void AddTo(Dictionary<string, List<Peg>> dict, string key, Peg p)
			{
				if (!dict.TryGetValue(key, out var value))
				{
					value = (dict[key] = new List<Peg>());
				}
				value.Add(p);
			}
		}

		private static string MakePosStructKey(string parentName, float lx, float ly)
		{
			return $"{parentName}|{lx:F3}|{ly:F3}";
		}

		private static string MakeSiblingStructKey(string parentName, int siblingIndex)
		{
			return $"{parentName}|#{siblingIndex}";
		}

		private static Peg ResolveByStructKey(StructIndex index, PegEntry entry)
		{
			if (index == null || string.IsNullOrEmpty(entry.ParentName))
			{
				return null;
			}
			Peg val = null;
			if (entry.HasLpm)
			{
				val = PopFromIndex(index.BySibling, MakeSiblingStructKey(entry.ParentName, entry.SiblingIndex));
				if ((Object)(object)val == (Object)null)
				{
					val = PopPosMatchingEntry(index.ByPos, MakePosStructKey(entry.ParentName, entry.LocalPosX, entry.LocalPosY), entry);
				}
			}
			else
			{
				val = PopPosMatchingEntry(index.ByPos, MakePosStructKey(entry.ParentName, entry.LocalPosX, entry.LocalPosY), entry);
				if ((Object)(object)val == (Object)null && entry.SiblingIndex >= 0)
				{
					val = PopFromIndex(index.BySibling, MakeSiblingStructKey(entry.ParentName, entry.SiblingIndex));
				}
			}
			if ((Object)(object)val != (Object)null)
			{
				RemovePegFromAllLists(index, val);
			}
			return val;
		}

		private static Peg PopFromIndex(Dictionary<string, List<Peg>> dict, string key)
		{
			if (!dict.TryGetValue(key, out var value) || value.Count == 0)
			{
				return null;
			}
			Peg result = value[value.Count - 1];
			value.RemoveAt(value.Count - 1);
			return result;
		}

		private static Peg PopPosMatchingEntry(Dictionary<string, List<Peg>> dict, string key, PegEntry entry)
		{
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			if (!dict.TryGetValue(key, out var value) || value.Count == 0)
			{
				return null;
			}
			if (value.Count == 1)
			{
				Peg result = value[0];
				value.RemoveAt(0);
				return result;
			}
			int num = -1;
			float num2 = float.MaxValue;
			for (int i = 0; i < value.Count; i++)
			{
				Peg val = value[i];
				if (!((Object)(object)val == (Object)null))
				{
					float num3 = ((Component)val).transform.position.x - entry.PosX;
					float num4 = ((Component)val).transform.position.y - entry.PosY;
					float num5 = num3 * num3 + num4 * num4;
					if (num5 < num2)
					{
						num2 = num5;
						num = i;
					}
				}
			}
			if (num < 0 || num2 > 2.25f)
			{
				return null;
			}
			Peg result2 = value[num];
			value.RemoveAt(num);
			return result2;
		}

		private static void RemovePegFromAllLists(StructIndex index, Peg peg)
		{
			foreach (List<Peg> value in index.ByPos.Values)
			{
				value.Remove(peg);
			}
			foreach (List<Peg> value2 in index.BySibling.Values)
			{
				value2.Remove(peg);
			}
		}

		private static bool IndexBindPositionSane(Peg indexCandidate, PegEntry entry)
		{
			//IL_0006: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			float num = ((Component)indexCandidate).transform.position.x - entry.PosX;
			float num2 = ((Component)indexCandidate).transform.position.y - entry.PosY;
			if (num * num + num2 * num2 <= 2.25f)
			{
				return true;
			}
			bool num3 = Math.Abs(entry.PosX) < 0.5f && Math.Abs(entry.PosY - 1.4f) < 0.5f;
			float x = ((Component)indexCandidate).transform.position.x;
			float y = ((Component)indexCandidate).transform.position.y;
			bool flag = Math.Abs(x) < 0.5f && Math.Abs(y - 1.4f) < 0.5f;
			return num3 && flag;
		}

		private static Peg ResolveByIndex(int index, int pegsCount, int bombsCount, List<Peg> clientPegs, List<Bomb> clientBombs, List<BouncerPeg> clientBouncers)
		{
			if (index < 0)
			{
				return null;
			}
			if (index < pegsCount)
			{
				return clientPegs[index];
			}
			int num = index - pegsCount;
			if (num < bombsCount)
			{
				return (Peg)(object)clientBombs[num];
			}
			int num2 = num - bombsCount;
			if (clientBouncers != null && num2 < clientBouncers.Count)
			{
				return (Peg)(object)clientBouncers[num2];
			}
			return null;
		}

		private static bool TypeMatches(Peg peg, PegEntry entry)
		{
			bool num = peg is Bomb;
			bool flag = peg is BouncerPeg;
			if (num == entry.IsBomb)
			{
				return flag == entry.IsBouncer;
			}
			return false;
		}

		private Peg FindClosestUnmatched(PegEntry entry, List<Peg> clientPegs, List<Bomb> clientBombs, List<BouncerPeg> clientBouncers, HashSet<Peg> matched, float maxDist)
		{
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_016c: Unknown result type (might be due to invalid IL or missing references)
			Peg result = null;
			float num = maxDist * maxDist;
			if (clientPegs != null)
			{
				foreach (Peg clientPeg in clientPegs)
				{
					if (!((Object)(object)clientPeg == (Object)null) && !matched.Contains(clientPeg))
					{
						float num2 = ((Component)clientPeg).transform.position.x - entry.PosX;
						float num3 = ((Component)clientPeg).transform.position.y - entry.PosY;
						float num4 = num2 * num2 + num3 * num3;
						if (num4 < num)
						{
							num = num4;
							result = clientPeg;
						}
					}
				}
			}
			if (clientBombs != null)
			{
				foreach (Bomb clientBomb in clientBombs)
				{
					if (!((Object)(object)clientBomb == (Object)null) && !matched.Contains((Peg)(object)clientBomb))
					{
						float num5 = ((Component)clientBomb).transform.position.x - entry.PosX;
						float num6 = ((Component)clientBomb).transform.position.y - entry.PosY;
						float num7 = num5 * num5 + num6 * num6;
						if (num7 < num)
						{
							num = num7;
							result = (Peg)(object)clientBomb;
						}
					}
				}
			}
			if (clientBouncers != null)
			{
				foreach (BouncerPeg clientBouncer in clientBouncers)
				{
					if (!((Object)(object)clientBouncer == (Object)null) && !matched.Contains((Peg)(object)clientBouncer))
					{
						float num8 = ((Component)clientBouncer).transform.position.x - entry.PosX;
						float num9 = ((Component)clientBouncer).transform.position.y - entry.PosY;
						float num10 = num8 * num8 + num9 * num9;
						if (num10 < num)
						{
							num = num10;
							result = (Peg)(object)clientBouncer;
						}
					}
				}
			}
			return result;
		}

		private void ApplyPegState(Peg peg, PegEntry entry, List<Bomb> clientBombs, ref int typeChanged, ref int destroyed, ref int reactivated, ref int cleared)
		{
			//IL_041a: Unknown result type (might be due to invalid IL or missing references)
			//IL_041c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0342: Unknown result type (might be due to invalid IL or missing references)
			//IL_0382: Unknown result type (might be due to invalid IL or missing references)
			//IL_0385: Unknown result type (might be due to invalid IL or missing references)
			//IL_038a: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Invalid comparison between Unknown and I4
			//IL_0392: Unknown result type (might be due to invalid IL or missing references)
			//IL_0435: Unknown result type (might be due to invalid IL or missing references)
			//IL_040f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0411: Unknown result type (might be due to invalid IL or missing references)
			//IL_039d: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a9: Invalid comparison between Unknown and I4
			//IL_04e5: Unknown result type (might be due to invalid IL or missing references)
			//IL_04e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_04ef: Unknown result type (might be due to invalid IL or missing references)
			//IL_0137: Unknown result type (might be due to invalid IL or missing references)
			//IL_013e: Invalid comparison between Unknown and I4
			//IL_04fc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0184: Unknown result type (might be due to invalid IL or missing references)
			//IL_018b: Invalid comparison between Unknown and I4
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ee: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f2: Invalid comparison between Unknown and I4
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f7: Unknown result type (might be due to invalid IL or missing references)
			if (!string.IsNullOrEmpty(entry.Guid))
			{
				_pegId.Register(peg, entry.Guid);
			}
			bool flag = false;
			try
			{
				flag = peg.IsDisabled();
			}
			catch
			{
			}
			if (entry.IsCleared && !flag)
			{
				try
				{
					LongPeg val = (LongPeg)(object)((peg is LongPeg) ? peg : null);
					if (val != null)
					{
						LongPegVisualHelper.ApplyHitVisual(val);
						try
						{
							((Peg)val).RemoveIfCleared();
						}
						catch
						{
						}
						try
						{
							if (!((Peg)val).IsDisabled())
							{
								val.SetActiveStatus(false);
							}
						}
						catch
						{
						}
					}
					else
					{
						PopPegVisualOnly(peg);
					}
					cleared++;
				}
				catch
				{
				}
			}
			if (entry.IsParentHidden)
			{
				if (((Component)peg).gameObject.activeInHierarchy || ((Component)peg).gameObject.activeSelf)
				{
					((Component)peg).gameObject.SetActive(false);
				}
				return;
			}
			if (entry.IsDestroyed)
			{
				if ((int)peg.pegType == 32)
				{
					return;
				}
				if (((Component)peg).gameObject.activeSelf)
				{
					try
					{
						peg.DestroyPeg(peg.pegType);
					}
					catch
					{
						((Component)peg).gameObject.SetActive(false);
					}
				}
				else
				{
					peg.pegType = (PegType)32;
				}
				destroyed++;
				return;
			}
			if (!entry.IsCleared && !entry.IsDestroyed)
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Peg), "_cleared");
				if (!((Component)peg).gameObject.activeSelf || (int)peg.pegType == 32 || flag)
				{
					DOTween.Kill((object)((Component)peg).gameObject, false);
					EnsureParentChainActive(((Component)peg).gameObject);
					fieldInfo?.SetValue(peg, entry.WasPreviouslyCleared);
					((Component)peg).gameObject.SetActive(true);
					if ((int)peg.pegType == 32)
					{
						peg.pegType = (PegType)1;
					}
					try
					{
						peg.Reset(false);
					}
					catch
					{
					}
					ForceRendererVisible(peg);
					reactivated++;
				}
				else if ((bool)(fieldInfo?.GetValue(peg) ?? ((object)false)) != entry.WasPreviouslyCleared)
				{
					fieldInfo?.SetValue(peg, entry.WasPreviouslyCleared);
					try
					{
						peg.Reset(false);
					}
					catch
					{
					}
				}
			}
			LongPeg val2 = (LongPeg)(object)((peg is LongPeg) ? peg : null);
			if (val2 != null && !entry.IsCleared && !entry.IsDestroyed)
			{
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(LongPeg), "_hit");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(LongPeg), "_beingHit");
				bool flag2 = (bool)(fieldInfo2?.GetValue(peg) ?? ((object)false));
				bool flag3 = (bool)(fieldInfo3?.GetValue(peg) ?? ((object)false));
				if (entry.IsLongPegHit)
				{
					if (!flag2)
					{
						LongPegVisualHelper.ApplyHitVisual(val2);
						_log.LogInfo((object)("[PegboardApplier] LongPeg gray-state recovered (missed event): " + $"guid={entry.Guid} at ({entry.PosX:F1},{entry.PosY:F1})"));
					}
				}
				else if (flag2 || flag3)
				{
					PegType val3 = (PegType)entry.PegType;
					if ((int)val3 != 32)
					{
						peg.pegType = val3;
					}
					try
					{
						val2.HardReset();
					}
					catch
					{
					}
					_log.LogInfo((object)("[PegboardApplier] LongPeg hit-state normalized: guid=" + entry.Guid + " " + $"wasHit={flag2} wasBeingHit={flag3} → {val3} at " + $"({entry.PosX:F1},{entry.PosY:F1})"));
				}
			}
			PegType val4 = (PegType)entry.PegType;
			if (peg.pegType != val4)
			{
				try
				{
					if (peg.SupportsPegType(val4, (SlimeType)0))
					{
						GameObject val5 = peg.ConvertPegToType(val4);
						if ((int)val4 == 4 && (Object)(object)val5 != (Object)null && (Object)(object)val5 != (Object)(object)((Component)peg).gameObject)
						{
							Bomb component = val5.GetComponent<Bomb>();
							if ((Object)(object)component != (Object)null)
							{
								if (!string.IsNullOrEmpty(entry.Guid))
								{
									_pegId.Register((Peg)(object)component, entry.Guid);
								}
								if (clientBombs != null && !clientBombs.Contains(component))
								{
									clientBombs.Add(component);
								}
							}
						}
					}
					else
					{
						peg.pegType = val4;
					}
				}
				catch
				{
					peg.pegType = val4;
				}
				typeChanged++;
			}
			if (!entry.IsCleared)
			{
				ForceSpecialPegSpriteIfNeeded(peg, val4);
			}
			if (entry.WasPreviouslyCleared && !entry.IsCleared && !entry.IsDestroyed && entry.PegType == 1 && peg is RegularPeg)
			{
				FieldInfo fieldInfo4 = AccessTools.Field(typeof(RegularPeg), "_renderer");
				FieldInfo fieldInfo5 = AccessTools.Field(typeof(RegularPeg), "_previouslyClearedSprite");
				object? obj10 = fieldInfo4?.GetValue(peg);
				SpriteRenderer val6 = (SpriteRenderer)((obj10 is SpriteRenderer) ? obj10 : null);
				object? obj11 = fieldInfo5?.GetValue(peg);
				Sprite val7 = (Sprite)((obj11 is Sprite) ? obj11 : null);
				if ((Object)(object)val6 != (Object)null && (Object)(object)val7 != (Object)null)
				{
					val6.sprite = val7;
				}
			}
			SlimeType val8 = (SlimeType)entry.SlimeType;
			if (peg.slimeType != val8)
			{
				try
				{
					if ((int)val8 == 0)
					{
						peg.RemoveSlime(true);
					}
					else
					{
						peg.ApplySlimeToPeg(val8);
					}
				}
				catch
				{
				}
			}
			int num = peg.NumCoins();
			if (num < entry.CoinCount)
			{
				for (int i = num; i < entry.CoinCount; i++)
				{
					try
					{
						peg.AddCoin(false);
					}
					catch
					{
					}
				}
			}
			else if (num > entry.CoinCount && num > 0)
			{
				try
				{
					object? obj14 = AccessTools.Field(typeof(Peg), "PegCoinOverlayInstance")?.GetValue(peg);
					PegCoinOverlay val9 = (PegCoinOverlay)((obj14 is PegCoinOverlay) ? obj14 : null);
					if ((Object)(object)val9 != (Object)null)
					{
						int num2 = num - entry.CoinCount;
						val9.CollectCoins(num2);
					}
				}
				catch
				{
				}
			}
			if (peg.buffAmount != entry.BuffAmount)
			{
				int num3 = entry.BuffAmount - peg.buffAmount;
				if (num3 != 0)
				{
					try
					{
						peg.AddBuff(num3);
					}
					catch
					{
					}
				}
			}
			if (entry.IsBomb)
			{
				Bomb val10 = (Bomb)(object)((peg is Bomb) ? peg : null);
				if (val10 != null && val10.HitCount != entry.HitCount)
				{
					val10.HitCount = entry.HitCount;
					try
					{
						Animator component2 = ((Component)val10).GetComponent<Animator>();
						if (component2 != null)
						{
							component2.SetInteger("NumHits", entry.HitCount);
						}
					}
					catch
					{
					}
				}
			}
			SyncShieldState(peg, entry);
		}

		private void SyncShieldState(Peg peg, PegEntry entry)
		{
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Peg), "PegShieldOverlayInstance");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(Peg), "_shielded");
				object? obj = fieldInfo?.GetValue(peg);
				PegShieldOverlay val = (PegShieldOverlay)((obj is PegShieldOverlay) ? obj : null);
				if (entry.IsShielded)
				{
					if (!peg.shielded)
					{
						try
						{
							peg.ApplyShielding(false, false);
						}
						catch
						{
						}
						object? obj3 = fieldInfo?.GetValue(peg);
						val = (PegShieldOverlay)((obj3 is PegShieldOverlay) ? obj3 : null);
					}
					if (!((Object)(object)val != (Object)null))
					{
						return;
					}
					val.hitCount = entry.ShieldHitCount;
					val.hitLimit = entry.ShieldHitLimit;
					try
					{
						Animator component = ((Component)val).GetComponent<Animator>();
						if (component != null)
						{
							component.SetInteger(Animator.StringToHash("HitCount"), entry.ShieldHitCount);
						}
						SpriteRenderer component2 = ((Component)val).GetComponent<SpriteRenderer>();
						if ((Object)(object)component2 != (Object)null)
						{
							((Renderer)component2).enabled = entry.ShieldHitCount < entry.ShieldHitLimit;
						}
						return;
					}
					catch
					{
						return;
					}
				}
				if (peg.shielded)
				{
					if ((Object)(object)val != (Object)null)
					{
						val.hitCount = val.hitLimit;
						((Component)val).gameObject.SetActive(false);
					}
					fieldInfo2?.SetValue(peg, false);
				}
			}
			catch
			{
			}
		}

		private static bool HasMovementComponent(Peg peg)
		{
			if ((Object)(object)peg == (Object)null)
			{
				return false;
			}
			GameObject gameObject = ((Component)peg).gameObject;
			if ((Object)(object)gameObject.GetComponent<LinearPegMovement>() != (Object)null)
			{
				return true;
			}
			if ((Object)(object)gameObject.transform.parent != (Object)null && (Object)(object)((Component)gameObject.transform.parent).GetComponent<LinearPegMovement>() != (Object)null)
			{
				return true;
			}
			if (!((Object)(object)gameObject.GetComponent<PegMoveAndReturn>() != (Object)null) && !((Object)(object)gameObject.GetComponent<PegSquareMovement>() != (Object)null) && !((Object)(object)gameObject.GetComponent<PegSplineFollow>() != (Object)null))
			{
				return (Object)(object)gameObject.GetComponentInParent<RotatingPegCircle>() != (Object)null;
			}
			return true;
		}

		private void EnsureParentChainActive(GameObject go)
		{
			//IL_0032: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			Transform parent = go.transform.parent;
			while ((Object)(object)parent != (Object)null)
			{
				if (!((Component)parent).gameObject.activeSelf)
				{
					_log.LogInfo((object)$"[PegboardApplier] Activating inactive parent '{((Object)parent).name}' for peg at ({go.transform.position.x:F1},{go.transform.position.y:F1})");
					((Component)parent).gameObject.SetActive(true);
				}
				parent = parent.parent;
			}
		}

		private static void PopPegVisualOnly(Peg peg)
		{
			try
			{
				try
				{
					object? obj = AccessTools.Field(typeof(Peg), "PegCoinOverlayInstance")?.GetValue(peg);
					PegCoinOverlay val = (PegCoinOverlay)((obj is PegCoinOverlay) ? obj : null);
					if ((Object)(object)val != (Object)null && val.NumCoins > 0)
					{
						val.CollectCoins(-1);
					}
				}
				catch
				{
				}
				AccessTools.Field(typeof(Peg), "_cleared")?.SetValue(peg, true);
				if (peg is RegularPeg)
				{
					AccessTools.Method(typeof(RegularPeg), "DisableRegularColliders", (Type[])null, (Type[])null)?.Invoke(peg, null);
					AccessTools.Method(typeof(RegularPeg), "PlayDestructionAnimation", (Type[])null, (Type[])null)?.Invoke(peg, null);
				}
				else
				{
					((Component)peg).gameObject.SetActive(false);
				}
			}
			catch
			{
			}
		}

		private void ForceSpecialPegSpriteIfNeeded(Peg peg, PegType targetType)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Invalid comparison between Unknown and I4
			//IL_0004: Unknown result type (might be due to invalid IL or missing references)
			//IL_0006: Invalid comparison between Unknown and I4
			//IL_00eb: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ed: Invalid comparison between Unknown and I4
			//IL_004a: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Invalid comparison between Unknown and I4
			if ((int)targetType != 2 && (int)targetType != 8)
			{
				return;
			}
			try
			{
				if (peg is RegularPeg)
				{
					object? obj = AccessTools.Field(typeof(RegularPeg), "_renderer")?.GetValue(peg);
					SpriteRenderer val = (SpriteRenderer)((obj is SpriteRenderer) ? obj : null);
					if ((Object)(object)val == (Object)null)
					{
						return;
					}
					string text = (((int)targetType == 2) ? "_critSprite" : "_resetSprite");
					object? obj2 = AccessTools.Field(typeof(RegularPeg), text)?.GetValue(peg);
					Sprite val2 = (Sprite)((obj2 is Sprite) ? obj2 : null);
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)val.sprite == (Object)(object)val2))
					{
						val.sprite = val2;
						object? obj3 = AccessTools.Field(typeof(RegularPeg), "_specialPegCollider")?.GetValue(peg);
						Collider2D val3 = (Collider2D)((obj3 is Collider2D) ? obj3 : null);
						if ((Object)(object)val3 != (Object)null)
						{
							((Behaviour)val3).enabled = true;
						}
					}
				}
				else
				{
					if (!(peg is LongPeg))
					{
						return;
					}
					string text2 = (((int)targetType == 2) ? "_critSprite" : "_resetSprite");
					object? obj4 = AccessTools.Field(typeof(LongPeg), text2)?.GetValue(peg);
					Sprite val4 = (Sprite)((obj4 is Sprite) ? obj4 : null);
					if ((Object)(object)val4 == (Object)null)
					{
						return;
					}
					object? obj5 = AccessTools.Field(typeof(LongPeg), "_resetOrCritSprite")?.GetValue(peg);
					SpriteRenderer val5 = (SpriteRenderer)((obj5 is SpriteRenderer) ? obj5 : null);
					if (!((Object)(object)val5 == (Object)null) && !((Object)(object)val5.sprite == (Object)(object)val4))
					{
						val5.sprite = val4;
						((Renderer)val5).enabled = true;
						object? obj6 = AccessTools.Field(typeof(LongPeg), "_resetAndCritSpriteHolder")?.GetValue(peg);
						object? obj7 = ((obj6 is GameObject) ? obj6 : null);
						if (obj7 != null)
						{
							((GameObject)obj7).SetActive(true);
						}
					}
				}
			}
			catch
			{
			}
		}

		private void ForceRendererVisible(Peg peg)
		{
			//IL_0123: Unknown result type (might be due to invalid IL or missing references)
			//IL_0128: Unknown result type (might be due to invalid IL or missing references)
			//IL_012a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0041: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_013a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0141: Unknown result type (might be due to invalid IL or missing references)
			//IL_0148: Unknown result type (might be due to invalid IL or missing references)
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_006a: 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_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ea: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f0: Unknown result type (might be due to invalid IL or missing references)
			//IL_00fb: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (peg is RegularPeg)
				{
					object? obj = AccessTools.Field(typeof(RegularPeg), "_renderer")?.GetValue(peg);
					SpriteRenderer val = (SpriteRenderer)((obj is SpriteRenderer) ? obj : null);
					if ((Object)(object)val != (Object)null)
					{
						Color color = val.color;
						if (color.a < 1f)
						{
							val.color = new Color(color.r, color.g, color.b, 1f);
						}
					}
				}
				else if (peg is LongPeg)
				{
					object? obj2 = AccessTools.Field(typeof(LongPeg), "_renderer")?.GetValue(peg);
					MeshRenderer val2 = (MeshRenderer)((obj2 is MeshRenderer) ? obj2 : null);
					if ((Object)(object)((val2 != null) ? ((Renderer)val2).material : null) != (Object)null)
					{
						Color color2 = ((Renderer)val2).material.color;
						if (color2.a < 1f)
						{
							((Renderer)val2).material.color = new Color(color2.r, color2.g, color2.b, 1f);
						}
					}
				}
				else
				{
					if (!(peg is BouncerPeg))
					{
						return;
					}
					SpriteRenderer componentInChildren = ((Component)peg).GetComponentInChildren<SpriteRenderer>();
					if ((Object)(object)componentInChildren != (Object)null)
					{
						Color color3 = componentInChildren.color;
						if (color3.a < 1f)
						{
							componentInChildren.color = new Color(color3.r, color3.g, color3.b, 1f);
						}
					}
				}
			}
			catch
			{
			}
		}

		private void LogActualPegState(List<Peg> pegs, List<Bomb> bombs, List<BouncerPeg> bouncers)
		{
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected I4, but got Unknown
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Invalid comparison between Unknown and I4
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Invalid comparison between Unknown and I4
			//IL_0142: Unknown result type (might be due to invalid IL or missing references)
			//IL_0149: Invalid comparison between Unknown and I4
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			int num5 = 0;
			int num6 = 0;
			foreach (Peg peg in pegs)
			{
				if ((Object)(object)peg == (Object)null || !((Component)peg).gameObject.activeSelf || (int)peg.pegType == 32)
				{
					continue;
				}
				bool flag = false;
				try
				{
					flag = peg.IsDisabled();
				}
				catch
				{
				}
				if (!flag)
				{
					num++;
					int num7 = (int)peg.pegType;
					if (((uint)num7 & 2u) != 0)
					{
						num2++;
					}
					else if (((uint)num7 & 8u) != 0)
					{
						num4++;
					}
					else if (((uint)num7 & (true ? 1u : 0u)) != 0)
					{
						num5++;
					}
				}
			}
			if (bombs != null)
			{
				foreach (Bomb bomb in bombs)
				{
					if (!((Object)(object)bomb == (Object)null) && ((Component)bomb).gameObject.activeSelf && (int)((Peg)bomb).pegType != 32)
					{
						bool flag2 = false;
						try
						{
							flag2 = ((Peg)bomb).IsDisabled();
						}
						catch
						{
						}
						if (!flag2)
						{
							num++;
							num3++;
						}
					}
				}
			}
			if (bouncers != null)
			{
				foreach (BouncerPeg bouncer in bouncers)
				{
					if (!((Object)(object)bouncer == (Object)null) && ((Component)bouncer).gameObject.activeSelf && (int)((Peg)bouncer).pegType != 32)
					{
						bool flag3 = false;
						try
						{
							flag3 = ((Peg)bouncer).IsDisabled();
						}
						catch
						{
						}
						if (!flag3)
						{
							num++;
							num6++;
						}
					}
				}
			}
			_log.LogInfo((object)($"[PegboardApplier] CLIENT ACTUAL: {num} active pegs " + $"(regular={num5}, crit={num2}, bomb={num3}, reset={num4}, bouncer={num6})"));
		}

		private void SyncVines(PegboardStateSnapshot snapshot, BattleController bc)
		{
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e3: 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_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0203: 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_028c: 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_0290: Unknown result type (might be due to invalid IL or missing references)
			//IL_029a: 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_02a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			//IL_022a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				List<string> list = new List<string>();
				foreach (KeyValuePair<string, GameObject> clientVine in _clientVines)
				{
					if ((Object)(object)clientVine.Value == (Object)null)
					{
						list.Add(clientVine.Key);
					}
				}
				foreach (string item in list)
				{
					_clientVines.Remove(item);
				}
				HashSet<string> hashSet = new HashSet<string>();
				if (snapshot.Vines != null && snapshot.Vines.Count > 0 && (Object)(object)bc != (Object)null)
				{
					foreach (VineEntry vine in snapshot.Vines)
					{
						if (string.IsNullOrEmpty(vine.Peg1Guid) || string.IsNullOrEmpty(vine.Peg2Guid))
						{
							continue;
						}
						string text = VineKey(vine.Peg1Guid, vine.Peg2Guid);
						hashSet.Add(text);
						if (_clientVines.ContainsKey(text))
						{
							continue;
						}
						Peg val = _pegId.Find(vine.Peg1Guid);
						Peg val2 = _pegId.Find(vine.Peg2Guid);
						if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
						{
							_log.LogWarning((object)("[PegboardApplier] Vine peg not found: " + $"peg1={vine.Peg1Guid}({(Object)(object)val != (Object)null}) peg2={vine.Peg2Guid}({(Object)(object)val2 != (Object)null})"));
							continue;
						}
						try
						{
							GameObject val3 = bc.CreateBramballVine();
							LineRenderer component = val3.GetComponent<LineRenderer>();
							Vector3 val4 = ((val is LongPeg) ? val.GetCenterOfPeg() : ((Component)val).transform.position);
							Vector3 val5 = ((val2 is LongPeg) ? val2.GetCenterOfPeg() : ((Component)val2).transform.position);
							if ((Object)(object)component != (Object)null)
							{
								component.SetPosition(0, val4);
								component.SetPosition(1, val5);
								PegBoardBramballVine component2 = val3.GetComponent<PegBoardBramballVine>();
								if ((Object)(object)component2 != (Object)null && component2.vineMaterials != null && component2.vineMaterials.Count > 0)
								{
									int index = Random.Range(0, component2.vineMaterials.Count);
									((Renderer)component).material = component2.vineMaterials[index];
								}
							}
							val3.transform.position = (val4 + val5) / 2f;
							Vector3 val6 = val5 - val4;
							val3.transform.eulerAngles = new Vector3(0f, 0f, Vector3.SignedAngle(Vector3.up, val6, Vector3.forward));
							Collider2D[] componentsInChildren = val3.GetComponentsInChildren<Collider2D>(true);
							for (int i = 0; i < componentsInChildren.Length; i++)
							{
								((Behaviour)componentsInChildren[i]).enabled = false;
							}
							_clientVines[text] = val3;
							_log.LogInfo((object)("[PegboardApplier] Created vine between " + vine.Peg1Guid + " and " + vine.Peg2Guid));
						}
						catch (Exception ex)
						{
							_log.LogWarning((object)("[PegboardApplier] Failed to create vine: " + ex.Message));
						}
					}
				}
				List<string> list2 = new List<string>();
				foreach (KeyValuePair<string, GameObject> clientVine2 in _clientVines)
				{
					if (!hashSet.Contains(clientVine2.Key))
					{
						if ((Object)(object)clientVine2.Value != (Object)null)
						{
							Object.Destroy((Object)(object)clientVine2.Value);
						}
						list2.Add(clientVine2.Key);
					}
				}
				foreach (string item2 in list2)
				{
					_clientVines.Remove(item2);
				}
				if ((snapshot.Vines?.Count ?? 0) > 0 || _clientVines.Count > 0)
				{
					_log.LogInfo((object)($"[PegboardApplier] Vine sync: host={snapshot.Vines?.Count ?? 0} " + $"client={_clientVines.Count} removed={list2.Count}"));
				}
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[PegboardApplier] SyncVines failed: " + ex2.Message));
			}
		}

		private void SyncBlackHoles(PegboardStateSnapshot snapshot)
		{
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01db: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				List<BlackHoleEntry> blackHoles = snapshot.BlackHoles;
				int num = blackHoles?.Count ?? 0;
				List<int> list = new List<int>();
				foreach (KeyValuePair<int, GameObject> clientBlackHole in _clientBlackHoles)
				{
					if ((Object)(object)clientBlackHole.Value == (Object)null)
					{
						list.Add(clientBlackHole.Key);
					}
				}
				foreach (int item in list)
				{
					_clientBlackHoles.Remove(item);
				}
				if (_clientBlackHoles.Count > num)
				{
					List<int> list2 = new List<int>();
					foreach (KeyValuePair<int, GameObject> clientBlackHole2 in _clientBlackHoles)
					{
						if (clientBlackHole2.Key >= num)
						{
							list2.Add(clientBlackHole2.Key);
						}
					}
					foreach (int item2 in list2)
					{
						if (_clientBlackHoles.TryGetValue(item2, out var value) && (Object)(object)value != (Object)null)
						{
							Object.Destroy((Object)(object)value);
						}
						_clientBlackHoles.Remove(item2);
					}
				}
				if (num == 0)
				{
					return;
				}
				GameObject val = null;
				for (int i = 0; i < num; i++)
				{
					BlackHoleEntry blackHoleEntry = blackHoles[i];
					if (blackHoleEntry == null)
					{
						continue;
					}
					if (!_clientBlackHoles.TryGetValue(blackHoleEntry.Index, out var value2) || (Object)(object)value2 == (Object)null)
					{
						if ((Object)(object)val == (Object)null)
						{
							val = FindBlackHolePrefab();
							if ((Object)(object)val == (Object)null)
							{
								break;
							}
						}
						value2 = Object.Instantiate<GameObject>(val, new Vector3(blackHoleEntry.PosX, blackHoleEntry.PosY, 0f), Quaternion.identity);
						((Object)value2).name = $"ClientBlackHole_{blackHoleEntry.Index}";
						PegboardBlackHole component = value2.GetComponent<PegboardBlackHole>();
						if (component != null)
						{
							component.SetDummy(true);
						}
						_clientBlackHoles[blackHoleEntry.Index] = value2;
					}
					else
					{
						value2.transform.position = new Vector3(blackHoleEntry.PosX, blackHoleEntry.PosY, 0f);
						if (!value2.activeSelf)
						{
							value2.SetActive(true);
						}
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[PegboardApplier] SyncBlackHoles failed: " + ex.Message));
			}
		}

		private void SyncSplineGenerators(PegboardStateSnapshot snapshot)
		{
			//IL_02e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_02f5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0304: Unknown result type (might be due to invalid IL or missing references)
			//IL_032d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0334: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				List<SplineGeneratorEntry> splineGenerators = snapshot.SplineGenerators;
				if (splineGenerators == null || splineGenerators.Count == 0)
				{
					return;
				}
				if (_splineDistancesField == null)
				{
					_splineDistancesField = AccessTools.Field(typeof(PegSplineFollow), "_pegSplineDistances");
					if (_splineDistancesField == null)
					{
						return;
					}
				}
				bool flag = false;
				foreach (KeyValuePair<string, PegSplineFollow> item in _splineGeneratorCache)
				{
					if ((Object)(object)item.Value == (Object)null)
					{
						flag = true;
						break;
					}
				}
				if (flag || _splineGeneratorCache.Count == 0)
				{
					_splineGeneratorCache.Clear();
					PegSplineFollow[] array = Object.FindObjectsOfType<PegSplineFollow>();
					foreach (PegSplineFollow val in array)
					{
						if (!((Object)(object)val == (Object)null))
						{
							_splineGeneratorCache[BuildHierarchyPath(((Component)val).transform)] = val;
						}
					}
				}
				int num = 0;
				int num2 = 0;
				int num3 = 0;
				int num4 = 0;
				int num5 = 0;
				for (int j = 0; j < splineGenerators.Count; j++)
				{
					SplineGeneratorEntry splineGeneratorEntry = splineGenerators[j];
					if (splineGeneratorEntry == null || string.IsNullOrEmpty(splineGeneratorEntry.HierarchyPath))
					{
						num2++;
						continue;
					}
					if (!_splineGeneratorCache.TryGetValue(splineGeneratorEntry.HierarchyPath, out var value) || (Object)(object)value == (Object)null)
					{
						num3++;
						if (_loggedSplineMissPaths.Add(splineGeneratorEntry.HierarchyPath))
						{
							_log.LogWarning((object)("[PegboardApplier] Spline generator MISS path=" + splineGeneratorEntry.HierarchyPath));
						}
						continue;
					}
					if (!(_splineDistancesField.GetValue(value) is List<float> list) || list.Count == 0)
					{
						num4++;
						continue;
					}
					if (list.Count != splineGeneratorEntry.NumPegs)
					{
						num5++;
						if (_loggedSplineMismatchPaths.Add(splineGeneratorEntry.HierarchyPath))
						{
							_log.LogWarning((object)$"[PegboardApplier] Spline NumPegs mismatch path={splineGeneratorEntry.HierarchyPath} client={list.Count} host={splineGeneratorEntry.NumPegs}");
						}
						continue;
					}
					if (splineGeneratorEntry.Distances != null && splineGeneratorEntry.Distances.Count == list.Count)
					{
						for (int k = 0; k < list.Count; k++)
						{
							list[k] = splineGeneratorEntry.Distances[k];
						}
					}
					else
					{
						float num6 = splineGeneratorEntry.Phase - list[0];
						if (Math.Abs(num6) >= 0.001f)
						{
							for (int l = 0; l < list.Count; l++)
							{
								list[l] += num6;
							}
						}
					}
					num++;
					if (splineGeneratorEntry.HasParent && (Object)(object)((Component)value).transform.parent != (Object)null)
					{
						Transform parent = ((Component)value).transform.parent;
						Vector3 position = parent.position;
						float num7 = splineGeneratorEntry.ParentPosX - position.x;
						float num8 = splineGeneratorEntry.ParentPosY - position.y;
						if (num7 * num7 + num8 * num8 > 0.0001f)
						{
							parent.position = new Vector3(splineGeneratorEntry.ParentPosX, splineGeneratorEntry.ParentPosY, position.z);
						}
					}
				}
				if (splineGenerators.Count > 0 && (num3 > 0 || num4 > 0 || num5 > 0))
				{
					_log.LogWarning((object)($"[PegboardApplier] SplineSync synced={num}/{splineGenerators.Count} " + $"(noCache={num3}, noDistances={num4}, countMismatch={num5})"));
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[PegboardApplier] SyncSplineGenerators failed: " + ex.Message));
			}
		}

		private static string BuildHierarchyPath(Transform t)
		{
			List<string> list = _hierarchyPathBuf ?? (_hierarchyPathBuf = new List<string>(8));
			list.Clear();
			Transform val = t;
			while ((Object)(object)val != (Object)null)
			{
				list.Add(((Object)val).name);
				val = val.parent;
			}
			list.Reverse();
			return string.Join("/", list);
		}

		private static GameObject FindBlackHolePrefab()
		{
			AddBlackHoles[] array = Resources.FindObjectsOfTypeAll<AddBlackHoles>();
			for (int i = 0; i < array.Length; i++)
			{
				GameObject val = array[i]?.blackHolePrefab;
				if ((Object)(object)val != (Object)null)
				{
					return val;
				}
			}
			return null;
		}

		private void SyncObscurerGrid(PegboardStateSnapshot snapshot)
		{
			//IL_02a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ab: Invalid comparison between Unknown and I4
			try
			{
				ObscurerGridSnapshot obscurerGrid = snapshot.ObscurerGrid;
				if (obscurerGrid == null)
				{
					return;
				}
				RandomObscuredPegGrid val = FindLiveObscurerGrid();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if ((object)_obscurerGridField == null)
				{
					_obscurerGridField = AccessTools.Field(typeof(RandomObscuredPegGrid), "_pegGrid");
				}
				if ((object)_obscurerWidthField == null)
				{
					_obscurerWidthField = AccessTools.Field(typeof(RandomObscuredPegGrid), "_gridWidth");
				}
				if ((object)_obscurerHeightField == null)
				{
					_obscurerHeightField = AccessTools.Field(typeof(RandomObscuredPegGrid), "_gridHeight");
				}
				if (_obscurerGridField == null || _obscurerWidthField == null || _obscurerHeightField == null || !(_obscurerGridField.GetValue(val) is PegGridObscurer[,] array))
				{
					return;
				}
				int num = (int)(_obscurerWidthField.GetValue(val) ?? ((object)0));
				int num2 = (int)(_obscurerHeightField.GetValue(val) ?? ((object)0));
				if (num <= 0 || num2 <= 0 || num != obscurerGrid.Width || num2 != obscurerGrid.Height)
				{
					return;
				}
				Dictionary<int, int> dictionary = new Dictionary<int, int>(obscurerGrid.RevealedCells.Count);
				for (int i = 0; i < obscurerGrid.RevealedCells.Count; i++)
				{
					ObscurerCellEntry obscurerCellEntry = obscurerGrid.RevealedCells[i];
					if (obscurerCellEntry != null && obscurerCellEntry.X >= 0 && obscurerCellEntry.X < num && obscurerCellEntry.Y >= 0 && obscurerCellEntry.Y < num2)
					{
						dictionary[obscurerCellEntry.X * 1000 + obscurerCellEntry.Y] = obscurerCellEntry.RevealedPegType;
					}
				}
				int num3 = 0;
				int num4 = 0;
				int num5 = 0;
				for (int j = 0; j < num; j++)
				{
					for (int k = 0; k < num2; k++)
					{
						PegGridObscurer val2 = array[j, k];
						if ((Object)(object)val2 == (Object)null)
						{
							continue;
						}
						int value;
						bool flag = dictionary.TryGetValue(j * 1000 + k, out value);
						bool isRevealed = val2.isRevealed;
						if (flag && !isRevealed)
						{
							try
							{
								val2.RevealCell();
								num3++;
								ApplyObscurerColor(val, val2, value);
							}
							catch (Exception ex)
							{
								_log.LogWarning((object)$"[PegboardApplier] obscurer reveal ({j},{k}) failed: {ex.Message}");
							}
						}
						else if (!flag && isRevealed)
						{
							try
							{
								val2.ResetCell();
								num4++;
							}
							catch (Exception ex2)
							{
								_log.LogWarning((object)$"[PegboardApplier] obscurer reset ({j},{k}) failed: {ex2.Message}");
							}
						}
						else if (flag && isRevealed && (int)val2.revealedPegType != value)
						{
							try
							{
								ApplyObscurerColor(val, val2, value);
								num5++;
							}
							catch (Exception ex3)
							{
								_log.LogWarning((object)$"[PegboardApplier] obscurer recolor ({j},{k}) failed: {ex3.Message}");
							}
						}
					}
				}
				(int, int, int) lastObscurerSig = (num, num2, obscurerGrid.RevealedCells.Count);
				if (!lastObscurerSig.Equals(_lastObscurerSig) || num3 > 0 || num4 > 0 || num5 > 0)
				{
					_lastObscurerSig = lastObscurerSig;
					_log.LogInfo((object)($"[PegboardApplier] Obscurer grid {num}x{num2} hostRevealed={obscurerGrid.RevealedCells.Count} " + $"applied: revealed+={num3} hidden+={num4} recolored+={num5}"));
				}
			}
			catch (Exception ex4)
			{
				_log.LogWarning((object)("[PegboardApplier] SyncObscurerGrid failed: " + ex4.Message));
			}
		}

		private static RandomObscuredPegGrid FindLiveObscurerGrid()
		{
			RandomObscuredPegGrid[] array = Object.FindObjectsOfType<RandomObscuredPegGrid>(true);
			foreach (RandomObscuredPegGrid val in array)
			{
				if ((Object)(object)val != (Object)null && !((NonDummyPegboardBehaviour)val).isDummy)
				{
					return val;
				}
			}
			return null;
		}

		private static void ApplyObscurerColor(RandomObscuredPegGrid grid, PegGridObscurer cell, int rawPegType)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected I4, but got Unknown
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0043: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0031: Unknown result type (might be due to invalid IL or missing references)
			//IL_0035: Unknown result type (might be due to invalid IL or missing references)
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_005f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0061: Unknown result type (might be due to invalid IL or missing references)
			//IL_0062: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			CellPegType val = (CellPegType)rawPegType;
			cell.SetRevealedCellColour(val, (Color)((int)val switch
			{
				5 => grid.adjacentRefreshColor, 
				3 => grid.adjacentRiggedColor, 
				4 => grid.adjacentCritColor, 
				2 => grid.adjacentBombColor, 
				1 => grid.adjacentPegColor, 
				0 => grid.nothingAdjacentColor, 
				_ => Color.white, 
			}));
		}
	}
	public class PlayerStateApplier : IGameStateApplier<PlayerStateSnapshot>
	{
		private readonly ManualLogSource _log;

		private bool _warnedNoHealthCtrl;

		private string _lastStatusEffectsSig = string.Empty;

		public PlayerStateApplier(ManualLogSource log)
		{
			_log = log;
		}

		public void Apply(PlayerStateSnapshot snapshot)
		{
			try
			{
				ApplyHealth(snapshot);
				ApplyGold(snapshot);
				ApplySpeedup(snapshot);
				ApplyStatusEffects(snapshot);
				VerifyPlayerState(snapshot);
			}
			catch (Exception ex)
			{
				_log.LogError((object)("[PlayerApplier] Apply failed: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void ApplyHealth(PlayerStateSnapshot snapshot)
		{
			PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
			if ((Object)(object)val == (Object)null)
			{
				if (!_warnedNoHealthCtrl)
				{
					_warnedNoHealthCtrl = true;
					_log.LogWarning((object)"[PlayerApplier] PlayerHealthController not found in scene.");
				}
				return;
			}
			_warnedNoHealthCtrl = false;
			FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth");
			FieldInfo fieldInfo2 = AccessTools.Field(typeof(PlayerHealthController), "_maxPlayerHealth");
			if (fieldInfo == null || fieldInfo2 == null)
			{
				_log.LogWarning((object)"[PlayerApplier] Could not find _playerHealth or _maxPlayerHealth fields.");
				return;
			}
			object? value = fieldInfo.GetValue(val);
			FloatVariable val2 = (FloatVariable)((value is FloatVariable) ? value : null);
			object? value2 = fieldInfo2.GetValue(val);
			object? obj = ((value2 is FloatVariable) ? value2 : null);
			float num = ((val2 != null) ? val2.Value : 0f);
			if (obj != null)
			{
				((FloatVariable)obj).Set(snapshot.MaxHealth);
			}
			if (val2 != null)
			{
				val2.Set(snapshot.CurrentHealth);
			}
			if (Math.Abs(num - snapshot.CurrentHealth) > 0.1f)
			{
				try
				{
					AccessTools.Method(typeof(PlayerHealthController), "UpdateHealthBar", (Type[])null, (Type[])null)?.Invoke(val, null);
				}
				catch
				{
				}
			}
			if (Math.Abs(num - snapshot.CurrentHealth) > 0.1f)
			{
				_log.LogInfo((object)$"[PlayerApplier] Health set to {snapshot.CurrentHealth}/{snapshot.MaxHealth}");
			}
		}

		private void ApplyGold(PlayerStateSnapshot snapshot)
		{
			CurrencyManager instance = CurrencyManager.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				_log.LogWarning((object)"[PlayerApplier] CurrencyManager.Instance is null.");
				return;
			}
			int goldAmount = instance.GoldAmount;
			int num = snapshot.Gold - goldAmount;
			MultiplayerClientPatches.AllowCurrencySync = true;
			try
			{
				if (num > 0)
				{
					instance.AddGold(num, true);
				}
				else if (num < 0)
				{
					instance.RemoveGold(-num, true, true);
				}
			}
			finally
			{
				MultiplayerClientPatches.AllowCurrencySync = false;
			}
			if (num != 0)
			{
				_log.LogInfo((object)$"[PlayerApplier] Gold set to {snapshot.Gold} (was {goldAmount}, diff={num})");
			}
		}

		private void ApplySpeedup(PlayerStateSnapshot snapshot)
		{
			try
			{
				TimescaleManager instance = TimescaleManager.Instance;
				if (!((Object)(object)instance == (Object)null) && instance.isSpedUp != snapshot.IsSpedUp)
				{
					instance.isSpedUp = snapshot.IsSpedUp;
					Time.timeScale = (snapshot.IsSpedUp ? snapshot.SpeedupLevel : 1f);
				}
			}
			catch
			{
			}
		}

		private void ApplyStatusEffects(PlayerStateSnapshot snapshot)
		{
			//IL_007f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0081: Unknown result type (might be due to invalid IL or missing references)
			//IL_0090: Unknown result type (might be due to invalid IL or missing references)
			//IL_0099: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a3: Expected O, but got Unknown
			try
			{
				PlayerStatusEffectController val = Object.FindObjectOfType<PlayerStatusEffectController>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				if (!(AccessTools.Field(typeof(PlayerStatusEffectController), "_statusEffects")?.GetValue(val) is List<StatusEffect> list))
				{
					_log.LogWarning((object)"[PlayerApplier] _statusEffects list is null; cannot apply status effects");
					return;
				}
				list.Clear();
				if (snapshot.StatusEffects != null)
				{
					foreach (StatusEffectEntry statusEffect in snapshot.StatusEffects)
					{
						StatusEffectType val2 = (StatusEffectType)statusEffect.EffectType;
						if ((int)val2 != 0 && statusEffect.Intensity > 0)
						{
							list.Add(new StatusEffect(val2, statusEffect.Intensity));
						}
					}
				}
				object? obj = AccessTools.Field(typeof(PlayerStatusEffectController), "_statusEffectUI")?.GetValue(val);
				StatusEffectIconManager val3 = (StatusEffectIconManager)((obj is StatusEffectIconManager) ? obj : null);
				if ((Object)(object)val3 != (Object)null)
				{
					try
					{
						val3.UpdateStatusEffects(list.ToArray());
					}
					catch (Exception ex)
					{
						_log.LogWarning((object)("[PlayerApplier] Status effect UI update failed: " + ex.Message));
					}
				}
				if (list.Count > 0)
				{
					string text = string.Join(",", snapshot.StatusEffects.ConvertAll((StatusEffectEntry e) => $"{e.EffectType}={e.Intensity}"));
					if (text != _lastStatusEffectsSig)
					{
						_lastStatusEffectsSig = text;
						string arg = string.Join(", ", snapshot.StatusEffects.ConvertAll((StatusEffectEntry e) => $"{(object)(StatusEffectType)e.EffectType}={e.Intensity}"));
						_log.LogInfo((object)$"[PlayerApplier] Status effects applied ({list.Count}): [{arg}]");
					}
				}
				else
				{
					_lastStatusEffectsSig = string.Empty;
				}
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[PlayerApplier] ApplyStatusEffects failed: " + ex2.Message));
			}
		}

		private void VerifyPlayerState(PlayerStateSnapshot snapshot)
		{
			try
			{
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val != (Object)null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth");
					FieldInfo fieldInfo2 = AccessTools.Field(typeof(PlayerHealthController), "_maxPlayerHealth");
					object? obj = fieldInfo?.GetValue(val);
					FloatVariable val2 = (FloatVariable)((obj is FloatVariable) ? obj : null);
					object? obj2 = fieldInfo2?.GetValue(val);
					object? obj3 = ((obj2 is FloatVariable) ? obj2 : null);
					float num = ((val2 != null) ? val2.Value : (-1f));
					float num2 = ((obj3 != null) ? ((FloatVariable)obj3).Value : (-1f));
					if (Math.Abs(num - snapshot.CurrentHealth) > 0.1f)
					{
						_log.LogWarning((object)$"[Verify] MISMATCH health: actual={num:F1} expected={snapshot.CurrentHealth:F1}");
					}
					if (Math.Abs(num2 - snapshot.MaxHealth) > 0.1f)
					{
						_log.LogWarning((object)$"[Verify] MISMATCH maxHealth: actual={num2:F1} expected={snapshot.MaxHealth:F1}");
					}
				}
				CurrencyManager instance = CurrencyManager.Instance;
				if ((Object)(object)instance != (Object)null)
				{
					int goldAmount = instance.GoldAmount;
					if (goldAmount != snapshot.Gold)
					{
						_log.LogWarning((object)$"[Verify] MISMATCH gold: actual={goldAmount} expected={snapshot.Gold}");
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[Verify] PlayerState verification failed: " + ex.Message));
			}
		}
	}
	public class RelicStateApplier : IGameStateApplier<RelicStateSnapshot>
	{
		private readonly ManualLogSource _log;

		public RelicStateApplier(ManualLogSource log)
		{
			_log = log;
		}

		public void Apply(RelicStateSnapshot snapshot)
		{
			//IL_00df: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02be: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d9: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RelicManager[] array = Resources.FindObjectsOfTypeAll<RelicManager>();
				RelicManager val = ((array.Length != 0) ? array[0] : null);
				if ((Object)(object)val == (Object)null)
				{
					_log.LogWarning((object)"[RelicApplier] RelicManager not found");
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(RelicManager), "_ownedRelics");
				Dictionary<RelicEffect, Relic> dictionary = fieldInfo?.GetValue(val) as Dictionary<RelicEffect, Relic>;
				if (dictionary == null)
				{
					val.Reset();
					dictionary = fieldInfo?.GetValue(val) as Dictionary<RelicEffect, Relic>;
					if (dictionary == null)
					{
						_log.LogWarning((object)"[RelicApplier] Cannot access _ownedRelics after Reset");
						return;
					}
				}
				Relic[] array2 = Resources.FindObjectsOfTypeAll<Relic>();
				int num = 0;
				int num2 = 0;
				if (snapshot.OwnedRelics != null)
				{
					foreach (RelicEntry entry in snapshot.OwnedRelics)
					{
						RelicEffect effect = (RelicEffect)entry.Effect;
						if (dictionary.ContainsKey(effect))
						{
							num2++;
							continue;
						}
						Relic val2 = ((IEnumerable<Relic>)array2).FirstOrDefault((Func<Relic, bool>)((Relic r) => r.effect == effect)) ?? ((IEnumerable<Relic>)array2).FirstOrDefault((Func<Relic, bool>)((Relic r) => r.locKey == entry.LocKey));
						if ((Object)(object)val2 != (Object)null)
						{
							MultiplayerClientPatches.AllowRelicSync = true;
							try
							{
								val.AddRelic(val2);
								num++;
								_log.LogInfo((object)("[RelicApplier] Added relic: " + entry.EffectName + " (loc=" + entry.LocKey + ")"));
							}
							catch (Exception ex)
							{
								_log.LogWarning((object)("[RelicApplier] AddRelic failed for " + entry.EffectName + ": " + ex.Message));
							}
							finally
							{
								MultiplayerClientPatches.AllowRelicSync = false;
							}
						}
						else
						{
							_log.LogWarning((object)$"[RelicApplier] Relic asset not found: effect={entry.Effect} loc={entry.LocKey} (searched {array2.Length} assets)");
						}
					}
				}
				if (!LobbyUI.GameStartReceived)
				{
					HashSet<RelicEffect> hostEffects = new HashSet<RelicEffect>();
					if (snapshot.OwnedRelics != null)
					{
						foreach (RelicEntry ownedRelic in snapshot.OwnedRelics)
						{
							hostEffects.Add((RelicEffect)ownedRelic.Effect);
						}
					}
					foreach (RelicEffect item in dictionary.Keys.Where((RelicEffect k) => !hostEffects.Contains(k)).ToList())
					{
						dictionary.Remove(item);
						_log.LogInfo((object)$"[RelicApplier] Removed extra relic: {item}");
					}
				}
				if (num > 0)
				{
					_log.LogInfo((object)$"[RelicApplier] Result: added={num}, alreadyOwned={num2}, total={dictionary.Count}");
				}
				ApplyCountdowns(val, snapshot);
				VerifyRelicState(dictionary, snapshot);
				RefreshRelicUI(dictionary);
				if (num > 0)
				{
					ReinitOrbDamageDisplays(val);
				}
			}
			catch (Exception ex2)
			{
				_log.LogError((object)("[RelicApplier] Apply failed: " + ex2.Message + "\n" + ex2.StackTrace));
			}
		}

		private void ApplyCountdowns(RelicManager rm, RelicStateSnapshot snapshot)
		{
			//IL_01bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_01fa: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e2: Unknown result type (might be due to invalid IL or missing references)
			//IL_021d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0205: Unknown result type (might be due to invalid IL or missing references)
			//IL_0159: Unknown result type (might be due to invalid IL or missing references)
			//IL_0247: Unknown result type (might be due to invalid IL or missing references)
			//IL_0228: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (snapshot.OwnedRelics == null)
				{
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(RelicManager), "_relicRemainingCountdowns");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(RelicManager), "_relicRemainingUsesPerShot");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(RelicManager), "_relicRemainingUsesPerBattle");
				FieldInfo fieldInfo4 = AccessTools.Field(typeof(RelicManager), "_relicRemainingUsesPerRun");
				IDictionary<RelicEffect, int> dictionary = fieldInfo?.GetValue(rm) as IDictionary<RelicEffect, int>;
				IDictionary<RelicEffect, int> dictionary2 = fieldInfo2?.GetValue(rm) as IDictionary<RelicEffect, int>;
				IDictionary<RelicEffect, int> dictionary3 = fieldInfo3?.GetValue(rm) as IDictionary<RelicEffect, int>;
				IDictionary<RelicEffect, int> dictionary4 = fieldInfo4?.GetValue(rm) as IDictionary<RelicEffect, int>;
				IDictionary<RelicEffect, int> dictionary5 = AccessTools.Field(typeof(RelicManager), "relicUsesPerBattleCounts")?.GetValue(null) as IDictionary<RelicEffect, int>;
				Dictionary<RelicEffect, int> relicCountdownValues = RelicManager.relicCountdownValues;
				Dictionary<RelicEffect, int> relicUsesPerShotCounts = RelicManager.relicUsesPerShotCounts;
				Dictionary<RelicEffect, int> relicUsesPerRunCounts = RelicManager.relicUsesPerRunCounts;
				IDictionary<RelicEffect, Relic> dictionary6 = AccessTools.Field(typeof(RelicManager), "_ownedRelics")?.GetValue(rm) as IDictionary<RelicEffect, Relic>;
				int num = 0;
				foreach (RelicEntry ownedRelic in snapshot.OwnedRelics)
				{
					RelicEffect val = (RelicEffect)ownedRelic.Effect;
					if (dictionary6 == null || !dictionary6.ContainsKey(val))
					{
						continue;
					}
					bool flag = false;
					if (relicCountdownValues != null && relicCountdownValues.ContainsKey(val))
					{
						try
						{
							MethodInfo methodInfo = AccessTools.Method(typeof(RelicManager), "SetRemainingCountdownForRelic", (Type[])null, (Type[])null);
							if (methodInfo != null)
							{
								methodInfo.Invoke(rm, new object[2] { val, ownedRelic.RemainingCountdown });
								flag = true;
							}
						}
						catch
						{
						}
						if (!flag && dictionary != null)
						{
							dictionary[val] = ownedRelic.RemainingCountdown;
							flag = true;
						}
					}
					if (dictionary2 != null && relicUsesPerShotCounts != null && relicUsesPerShotCounts.ContainsKey(val))
					{
						dictionary2[val] = ownedRelic.RemainingUsesPerShot;
					}
					if (dictionary3 != null && dictionary5 != null && dictionary5.ContainsKey(val))
					{
						dictionary3[val] = ownedRelic.RemainingUsesPerBattle;
					}
					if (dictionary4 != null && relicUsesPerRunCounts != null && relicUsesPerRunCounts.ContainsKey(val))
					{
						dictionary4[val] = ownedRelic.RemainingUsesPerRun;
					}
					if (!flag)
					{
						continue;
					}
					try
					{
						CountdownRelicEvent onCountdownDecremented = RelicManager.OnCountdownDecremented;
						if (onCountdownDecremented != null)
						{
							onCountdownDecremented.Invoke(dictionary6[val], ownedRelic.RemainingCountdown);
						}
					}
					catch
					{
					}
					num++;
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[RelicApplier] ApplyCountdowns failed: " + ex.Message));
			}
		}

		private void VerifyRelicState(Dictionary<RelicEffect, Relic> owned, RelicStateSnapshot snapshot)
		{
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ae: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c5: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Unknown result type (might be due to invalid IL or missing references)
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_0108: Unknown result type (might be due to invalid IL or missing references)
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				int num = owned?.Count ?? 0;
				int num2 = snapshot.OwnedRelics?.Count ?? 0;
				if (num == num2)
				{
					return;
				}
				_log.LogWarning((object)$"[Verify] MISMATCH relics: actual={num} expected={num2}");
				if (snapshot.OwnedRelics == null || owned == null)
				{
					return;
				}
				HashSet<RelicEffect> hashSet = new HashSet<RelicEffect>();
				foreach (RelicEntry ownedRelic in snapshot.OwnedRelics)
				{
					hashSet.Add((RelicEffect)ownedRelic.Effect);
				}
				foreach (RelicEffect item in hashSet)
				{
					if (!owned.ContainsKey(item))
					{
						_log.LogWarning((object)$"[Verify]   MISSING relic: {item}");
					}
				}
				foreach (RelicEffect key in owned.Keys)
				{
					if (!hashSet.Contains(key))
					{
						_log.LogWarning((object)$"[Verify]   EXTRA relic: {key}");
					}
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[Verify] RelicState verification failed: " + ex.Message));
			}
		}

		private void RefreshRelicUI(Dictionary<RelicEffect, Relic> owned)
		{
			//IL_005a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				RelicUI val = Object.FindObjectOfType<RelicUI>();
				if ((Object)(object)val == (Object)null || !(AccessTools.Field(typeof(RelicUI), "icons")?.GetValue(val) is Dictionary<RelicEffect, RelicIcon> dictionary))
				{
					return;
				}
				int num = 0;
				foreach (KeyValuePair<RelicEffect, Relic> item in owned)
				{
					if (!dictionary.ContainsKey(item.Key) && (Object)(object)item.Value != (Object)null)
					{
						RelicManagement onRelicAdded = RelicManager.OnRelicAdded;
						if (onRelicAdded != null)
						{
							onRelicAdded.Invoke(item.Value);
						}
						num++;
					}
				}
				if (num > 0)
				{
					_log.LogInfo((object)$"[RelicApplier] Refreshed {num} relic icons in UI");
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[RelicApplier] RefreshRelicUI failed: " + ex.Message));
			}
		}

		private void ReinitOrbDamageDisplays(RelicManager rm)
		{
			try
			{
				DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
				DeckManager val = ((array.Length != 0) ? array[0] : null);
				CruciballManager[] array2 = Resources.FindObjectsOfTypeAll<CruciballManager>();
				CruciballManager val2 = ((array2.Length != 0) ? array2[0] : null);
				Attack[] array3 = Object.FindObjectsOfType<Attack>(true);
				int num = 0;
				Attack[] array4 = array3;
				foreach (Attack val3 in array4)
				{
					try
					{
						val3.SoftInit(val, rm, val2, true);
						num++;
					}
					catch
					{
					}
				}
				if (DeckManager.completeDeck != null)
				{
					foreach (GameObject item in DeckManager.completeDeck)
					{
						if ((Object)(object)item == (Object)null)
						{
							continue;
						}
						Attack component = item.GetComponent<Attack>();
						if ((Object)(object)component != (Object)null)
						{
							try
							{
								component.SoftInit(val, rm, val2, true);
								num++;
							}
							catch
							{
							}
						}
					}
				}
				_log.LogInfo((object)$"[RelicApplier] Re-initialized {num} Attack components with relic modifiers");
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[RelicApplier] ReinitOrbDamageDisplays failed: " + ex.Message));
			}
		}
	}
}
namespace Multipeglin.Events
{
	public class GameEventRegistry : IGameEventRegistry
	{
		private readonly INetworkSerializer _serializer;

		private readonly INetworkTransport _transport;

		private readonly MessageTypeRegistry _typeRegistry;

		private readonly ManualLogSource _log;

		private readonly Dictionary<Type, Action<object>> _serverDispatchers = new Dictionary<Type, Action<object>>();

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

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

		public IReadOnlyCollection<string> RegisteredTypeIds => _clientDispatchers.Keys.ToList();

		public IReadOnlyCollection<string> UnhandledTypeIds => _unhandledTypeIds;

		public int CurrentSenderPeerId { get; private set; } = -1;


		public GameEventRegistry(INetworkSerializer serializer, INetworkTransport transport, MessageTypeRegistry typeRegistry, ManualLogSource log)
		{
			_serializer = serializer;
			_transport = transport;
			_typeRegistry = typeRegistry;
			_log = log;
		}

		public void Register<TNetworkEvent>(IServerHandler<TNetworkEvent> serverHandler, IClientHandler<TNetworkEvent> clientHandler) where TNetworkEvent : class
		{
			_typeRegistry.Register<TNetworkEvent>();
			string typeId = _typeRegistry.GetTypeId<TNetworkEvent>();
			_serverDispatchers[typeof(TNetworkEvent)] = delegate(object obj)
			{
				TNetworkEvent networkEvent = (TNetworkEvent)obj;
				TNetworkEvent val2 = serverHandler.Handle(networkEvent);
				if (val2 != null)
				{
					byte[] data = _serializer.Serialize(val2);
					_transport.Broadcast(data);
				}
			};
			_clientDispatchers[typeId] = delegate(string jsonPayload)
			{
				if (string.IsNullOrEmpty(jsonPayload))
				{
					_log.LogWarning((object)("Received empty payload for " + typeId + ", skipping"));
				}
				else
				{
					TNetworkEvent val = JsonConvert.DeserializeObject<TNetworkEvent>(jsonPayload);
					if (val == null)
					{
						_log.LogWarning((object)("Failed to deserialize " + typeId + " payload, skipping"));
					}
					else
					{
						clientHandler.Handle(val);
					}
				}
			};
		}

		public void Dispatch<TNetworkEvent>(TNetworkEvent networkEvent) where TNetworkEvent : class
		{
			Type typeFromHandle = typeof(TNetworkEvent);
			if (_serverDispatchers.TryGetValue(typeFromHandle, out var value))
			{
				try
				{
					value(networkEvent);
					return;
				}
				catch (Exception arg)
				{
					_log.LogError((object)$"Error dispatching {typeFromHandle.Name}: {arg}");
					return;
				}
			}
			_log.LogWarning((object)("No server dispatcher registered for " + typeFromHandle.Name));
		}

		public void HandleIncoming(string typeId, string jsonPayload, int senderPeerId)
		{
			EventFeed.Add(typeId, jsonPayload ?? string.Empty);
			int currentSenderPeerId = CurrentSenderPeerId;
			CurrentSenderPeerId = senderPeerId;
			try
			{
				if (_clientDispatchers.TryGetValue(typeId, out var value))
				{
					try
					{
						value(jsonPayload);
						return;
					}
					catch (Exception arg)
					{
						_log.LogError((object)$"Error handling incoming {typeId}: {arg}");
						return;
					}
				}
				if (_unhandledTypeIds.Add(typeId))
				{
					_log.LogWarning((object)("UNHANDLED EVENT from remote: '" + typeId + "' (no client handler registered)"));
					_log.LogWarning((object)("  This may be from a newer mod version. Payload preview: " + Truncate(jsonPayload, 200)));
				}
				else
				{
					_log.LogDebug((object)("Unhandled event (repeated): '" + typeId + "'"));
				}
			}
			finally
			{
				CurrentSenderPeerId = currentSenderPeerId;
			}
		}

		private static string Truncate(string s, int maxLen)
		{
			if (string.IsNullOrEmpty(s))
			{
				return "(empty)";
			}
			if (s.Length > maxLen)
			{
				return s.Substring(0, maxLen) + "...";
			}
			return s;
		}
	}
	public interface IClientHandler<in TNetworkEvent> where TNetworkEvent : class
	{
		void Handle(TNetworkEvent networkEvent);
	}
	public interface IGameEventRegistry
	{
		int CurrentSenderPeerId { get; }

		void Register<TNetworkEvent>(IServerHandler<TNetworkEvent> serverHandler, IClientHandler<TNetworkEvent> clientHandler) where TNetworkEvent : class;

		void Dispatch<TNetworkEvent>(TNetworkEvent networkEvent) where TNetworkEvent : class;

		void HandleIncoming(string typeId, string jsonPayload, int senderPeerId);
	}
	public interface IServerHandler<TNetworkEvent> where TNetworkEvent : class
	{
		TNetworkEvent Handle(TNetworkEvent networkEvent);
	}
}
namespace Multipeglin.Events.Subscriptions
{
	public sealed class BallSubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly ManualLogSource _log;

		private static bool IsHosting
		{
			get
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return instance.IsHosting;
				}
				return false;
			}
		}

		public BallSubscriptions(IGameEventRegistry registry, ManualLogSource log)
		{
			_registry = registry;
			_log = log;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			PachinkoBall.OnShotFired = (PachinkoBallFired)Delegate.Combine((Delegate?)(object)PachinkoBall.OnShotFired, (Delegate?)new PachinkoBallFired(OnShotFired));
			PachinkoBall.OnPachinkoBallWallBounce = (PachinkoBallWallBounce)Delegate.Combine((Delegate?)(object)PachinkoBall.OnPachinkoBallWallBounce, (Delegate?)new PachinkoBallWallBounce(OnWallBounce));
			_log.LogInfo((object)"BallSubscriptions registered");
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			PachinkoBall.OnShotFired = (PachinkoBallFired)Delegate.Remove((Delegate?)(object)PachinkoBall.OnShotFired, (Delegate?)new PachinkoBallFired(OnShotFired));
			PachinkoBall.OnPachinkoBallWallBounce = (PachinkoBallWallBounce)Delegate.Remove((Delegate?)(object)PachinkoBall.OnPachinkoBallWallBounce, (Delegate?)new PachinkoBallWallBounce(OnWallBounce));
		}

		private void OnShotFired(Vector2 aimVector)
		{
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00da: Unknown result type (might be due to invalid IL or missing references)
			//IL_0112: Unknown result type (might be due to invalid IL or missing references)
			//IL_011e: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHosting)
			{
				return;
			}
			string text = null;
			float num = 0f;
			float num2 = 0f;
			try
			{
				PachinkoBall[] array = Object.FindObjectsOfType<PachinkoBall>();
				foreach (PachinkoBall val in array)
				{
					if ((Object)(object)val != (Object)null && !val.IsDummy)
					{
						text = ((Object)((Component)val).gameObject).name;
						break;
					}
				}
				BattleController val2 = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val2 != (Object)null)
				{
					object? obj = AccessTools.Field(typeof(BattleController), "_playerTransform")?.GetValue(val2);
					Transform val3 = (Transform)((obj is Transform) ? obj : null);
					if ((Object)(object)val3 != (Object)null)
					{
						num = val3.position.x;
						num2 = val3.position.y;
					}
				}
			}
			catch
			{
			}
			_log.LogInfo((object)$"[BallSub] ShotFired: aim=({aimVector.x:F2},{aimVector.y:F2}), orb={text}, spawn=({num:F1},{num2:F1})");
			_registry.Dispatch(new ShotFiredEvent
			{
				AimX = aimVector.x,
				AimY = aimVector.y,
				OrbName = text,
				SpawnX = num,
				SpawnY = num2
			});
		}

		private void OnWallBounce(Vector3 pos)
		{
			//IL_0014: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			if (IsHosting)
			{
				_registry.Dispatch(new BallWallBounceEvent
				{
					PosX = pos.x,
					PosY = pos.y,
					PosZ = pos.z
				});
			}
		}
	}
	public sealed class BattleEventSubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly IMultiplayerMode _multiplayerMode;

		private static readonly FieldInfo _bombsRegularField = AccessTools.Field(typeof(BattleController), "_bombsToThrowRegular");

		private static readonly FieldInfo _bombsRiggedField = AccessTools.Field(typeof(BattleController), "_bombsToThrowRigged");

		public BattleEventSubscriptions(IGameEventRegistry registry, IMultiplayerMode multiplayerMode)
		{
			_registry = registry;
			_multiplayerMode = multiplayerMode;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			BattleController.OnBattleStarted = (BattleEvent)Delegate.Combine((Delegate?)(object)BattleController.OnBattleStarted, (Delegate?)new BattleEvent(OnBattleStarted));
			BattleController.OnBattleEnded = (BattleEvent)Delegate.Combine((Delegate?)(object)BattleController.OnBattleEnded, (Delegate?)new BattleEvent(OnBattleEnded));
			BattleController.OnVictory = (Action)Delegate.Combine(BattleController.OnVictory, new Action(OnVictory));
			BattleController.OnAttackStarted = (Action)Delegate.Combine(BattleController.OnAttackStarted, new Action(OnAttackStarted));
			BattleController.OnTurnComplete = (Action)Delegate.Combine(BattleController.OnTurnComplete, new Action(OnTurnComplete));
			BattleController.OnShotComplete = (ShotComplete)Delegate.Combine((Delegate?)(object)BattleController.OnShotComplete, (Delegate?)new ShotComplete(OnShotComplete));
			BattleController.OnRoundCountIncremented = (RoundCountIncremented)Delegate.Combine((Delegate?)(object)BattleController.OnRoundCountIncremented, (Delegate?)new RoundCountIncremented(OnRoundIncremented));
			BattleController.OnReloadStarted = (ReloadStarted)Delegate.Combine((Delegate?)(object)BattleController.OnReloadStarted, (Delegate?)new ReloadStarted(OnReloadStarted));
			BattleController.onCriticalHitActivated = (CriticalHitActivated)Delegate.Combine((Delegate?)(object)BattleController.onCriticalHitActivated, (Delegate?)new CriticalHitActivated(OnCritActivated));
			BattleController.onCriticalHitDeactivated = (CriticalHitActivated)Delegate.Combine((Delegate?)(object)BattleController.onCriticalHitDeactivated, (Delegate?)new CriticalHitActivated(OnCritDeactivated));
			BattleController.OnBombThrown = (Action)Delegate.Combine(BattleController.OnBombThrown, new Action(OnBombThrown));
			BattleController.OnBombDetonated = (Action)Delegate.Combine(BattleController.OnBombDetonated, new Action(OnBombDetonated));
			BattleController.OnOrbDiscarded = (Action)Delegate.Combine(BattleController.OnOrbDiscarded, new Action(OnOrbDiscarded));
			BattleController.OnStartedAwaitingShot = (BattleEvent)Delegate.Combine((Delegate?)(object)BattleController.OnStartedAwaitingShot, (Delegate?)new BattleEvent(OnAwaitingShot));
			BattleController.OnShotTimeout = (ShotTimeoutEvent)Delegate.Combine((Delegate?)(object)BattleController.OnShotTimeout, (Delegate?)new ShotTimeoutEvent(OnShotTimeout));
			PlayerHealthController.OnHealthDepleted = (HealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnHealthDepleted, (Delegate?)new HealthEvent(OnDefeat));
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			BattleController.OnBattleStarted = (BattleEvent)Delegate.Remove((Delegate?)(object)BattleController.OnBattleStarted, (Delegate?)new BattleEvent(OnBattleStarted));
			BattleController.OnBattleEnded = (BattleEvent)Delegate.Remove((Delegate?)(object)BattleController.OnBattleEnded, (Delegate?)new BattleEvent(OnBattleEnded));
			BattleController.OnVictory = (Action)Delegate.Remove(BattleController.OnVictory, new Action(OnVictory));
			BattleController.OnAttackStarted = (Action)Delegate.Remove(BattleController.OnAttackStarted, new Action(OnAttackStarted));
			BattleController.OnTurnComplete = (Action)Delegate.Remove(BattleController.OnTurnComplete, new Action(OnTurnComplete));
			BattleController.OnShotComplete = (ShotComplete)Delegate.Remove((Delegate?)(object)BattleController.OnShotComplete, (Delegate?)new ShotComplete(OnShotComplete));
			BattleController.OnRoundCountIncremented = (RoundCountIncremented)Delegate.Remove((Delegate?)(object)BattleController.OnRoundCountIncremented, (Delegate?)new RoundCountIncremented(OnRoundIncremented));
			BattleController.OnReloadStarted = (ReloadStarted)Delegate.Remove((Delegate?)(object)BattleController.OnReloadStarted, (Delegate?)new ReloadStarted(OnReloadStarted));
			BattleController.onCriticalHitActivated = (CriticalHitActivated)Delegate.Remove((Delegate?)(object)BattleController.onCriticalHitActivated, (Delegate?)new CriticalHitActivated(OnCritActivated));
			BattleController.onCriticalHitDeactivated = (CriticalHitActivated)Delegate.Remove((Delegate?)(object)BattleController.onCriticalHitDeactivated, (Delegate?)new CriticalHitActivated(OnCritDeactivated));
			BattleController.OnBombThrown = (Action)Delegate.Remove(BattleController.OnBombThrown, new Action(OnBombThrown));
			BattleController.OnBombDetonated = (Action)Delegate.Remove(BattleController.OnBombDetonated, new Action(OnBombDetonated));
			BattleController.OnOrbDiscarded = (Action)Delegate.Remove(BattleController.OnOrbDiscarded, new Action(OnOrbDiscarded));
			BattleController.OnStartedAwaitingShot = (BattleEvent)Delegate.Remove((Delegate?)(object)BattleController.OnStartedAwaitingShot, (Delegate?)new BattleEvent(OnAwaitingShot));
			BattleController.OnShotTimeout = (ShotTimeoutEvent)Delegate.Remove((Delegate?)(object)BattleController.OnShotTimeout, (Delegate?)new ShotTimeoutEvent(OnShotTimeout));
			PlayerHealthController.OnHealthDepleted = (HealthEvent)Delegate.Remove((Delegate?)(object)PlayerHealthController.OnHealthDepleted, (Delegate?)new HealthEvent(OnDefeat));
		}

		private void OnBattleStarted()
		{
			PegboardStateProvider.ClearHierarchyCaches();
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new BattleStartedEvent());
			}
		}

		private void OnBattleEnded()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new BattleEndedEvent());
			}
		}

		private void OnVictory()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new VictoryEvent());
			}
		}

		private void OnAttackStarted()
		{
			if (_multiplayerMode.IsHosting && !MultiplayerClientPatches.SuppressOnAttackStartedDispatch)
			{
				_registry.Dispatch(new AttackStartedEvent
				{
					AnimTrigger = (MultiplayerClientPatches.LastAttackAnimTrigger ?? "attack"),
					TargetEnemyGuid = MultiplayerClientPatches.LastAttackTargetGuid,
					NumPegsHit = MultiplayerClientPatches.LastAttackNumPegsHit,
					IsCrit = MultiplayerClientPatches.LastAttackIsCrit,
					OrbName = MultiplayerClientPatches.LastAttackOrbName
				});
			}
		}

		private void OnTurnComplete()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new TurnCompleteEvent());
			}
		}

		private void OnShotComplete()
		{
			if (!_multiplayerMode.IsHosting)
			{
				return;
			}
			try
			{
				BattleController obj = Object.FindObjectOfType<BattleController>();
				PegManager val = ((obj != null) ? obj.pegManager : null);
				if (((val != null) ? val.allPegs : null) != null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(LongPeg), "_hit");
					foreach (Peg allPeg in val.allPegs)
					{
						LongPeg val2 = (LongPeg)(object)((allPeg is LongPeg) ? allPeg : null);
						if (val2 != null && ((Component)val2).gameObject.activeSelf && (bool)(fieldInfo?.GetValue(val2) ?? ((object)false)) && !((Peg)val2).IsDisabled())
						{
							val2.SetActiveStatus(false);
						}
					}
				}
			}
			catch
			{
			}
			_registry.Dispatch(new ShotCompleteEvent());
		}

		private void OnRoundIncremented(int roundCount)
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new RoundIncrementedEvent
				{
					RoundCount = roundCount
				});
			}
		}

		private void OnReloadStarted()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new ReloadStartedEvent());
			}
		}

		private void OnCritActivated()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new CritActivatedEvent());
			}
		}

		private void OnCritDeactivated()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new CritDeactivatedEvent());
			}
		}

		private void OnBombThrown()
		{
			if (!_multiplayerMode.IsHosting)
			{
				return;
			}
			int regularCount = 0;
			int riggedCount = 0;
			try
			{
				BattleController val = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val != (Object)null)
				{
					regularCount = (int)(_bombsRegularField?.GetValue(val) ?? ((object)0));
					riggedCount = (int)(_bombsRiggedField?.GetValue(val) ?? ((object)0));
				}
			}
			catch
			{
			}
			_registry.Dispatch(new BombThrownEvent
			{
				RegularCount = regularCount,
				RiggedCount = riggedCount
			});
		}

		private void OnBombDetonated()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new BombDetonatedEvent());
			}
		}

		private void OnOrbDiscarded()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new OrbDiscardedEvent());
			}
		}

		private void OnAwaitingShot()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new AwaitingShotEvent());
			}
		}

		private void OnShotTimeout()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new ShotTimeoutEvent());
			}
		}

		private void OnDefeat()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new DefeatEvent());
			}
		}
	}
	public sealed class CoopSubscriptions
	{
		[Serializable]
		[CompilerGenerated]
		private sealed class <>c
		{
			public static readonly <>c <>9 = new <>c();

			public static BallDrawn <>9__44_0;

			public static Shuffled <>9__44_1;

			public static PersistBallUsed <>9__44_2;

			public static BallDrawn <>9__46_0;

			public static Shuffled <>9__46_1;

			public static PersistBallUsed <>9__46_2;

			public static BallDrawn <>9__53_0;

			public static Shuffled <>9__53_1;

			public static PersistBallUsed <>9__53_2;

			internal void <SwapAndRedrawForRoundStart>b__44_0(GameObject _)
			{
			}

			internal void <SwapAndRedrawForRoundStart>b__44_1(int _)
			{
			}

			internal void <SwapAndRedrawForRoundStart>b__44_2()
			{
			}

			internal void <OnShotComplete>b__46_0(GameObject _)
			{
			}

			internal void <OnShotComplete>b__46_1(int _)
			{
			}

			internal void <OnShotComplete>b__46_2()
			{
			}

			internal void <HandlePlayerDisconnect>b__53_0(GameObject _)
			{
			}

			internal void <HandlePlayerDisconnect>b__53_1(int _)
			{
			}

			internal void <HandlePlayerDisconnect>b__53_2()
			{
			}
		}

		private readonly IMultiplayerMode _mode;

		private readonly CoopStateManager _coopStateManager;

		private readonly TurnManager _turnManager;

		private readonly IGameStateSyncService _syncService;

		private readonly ManualLogSource _log;

		private readonly IBattleControllerUpdateManager _bcUpdater;

		private readonly ICoopDeckManager _deckMgr;

		private readonly IOrbStatusEffectApplier _orbApplier;

		private readonly IBuffApplier _buffApplier;

		private readonly Dictionary<int, ShotDamageData> _accumulatedShotData = new Dictionary<int, ShotDamageData>();

		private float _healthBeforeAttack;

		private float _damageDistributedSinceAttackStart;

		private bool _victoryHandledThisBattle;

		private const RelicEffect RELIC_ADDITIONAL_ORB_RELIC_OPTIONS = 60;

		private const RelicEffect RELIC_ADDITIONAL_PEGLIN_CHOICES = 97;

		internal static string LastPendingShotTargetGuid { get; set; }

		internal static int HighWaterPegTally { get; set; }

		internal static long HighWaterDamage { get; set; }

		internal static int MultiballSpawnCount { get; set; }

		internal static CoopSubscriptions Instance { get; private set; }

		public CoopSubscriptions(IMultiplayerMode mode, CoopStateManager coopStateManager, TurnManager turnManager, IGameStateSyncService syncService, IBattleControllerUpdateManager bcUpdater, ICoopDeckManager deckMgr, IOrbStatusEffectApplier orbApplier, IBuffApplier buffApplier, ManualLogSource log)
		{
			_mode = mode;
			_coopStateManager = coopStateManager;
			_turnManager = turnManager;
			_syncService = syncService;
			_bcUpdater = bcUpdater;
			_deckMgr = deckMgr;
			_orbApplier = orbApplier;
			_buffApplier = buffApplier;
			_log = log;
			Instance = this;
		}

		public void Subscribe()
		{
			//IL_0052: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			//IL_005c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0066: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_007c: Expected O, but got Unknown
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0086: Expected O, but got Unknown
			//IL_0092: Unknown result type (might be due to invalid IL or missing references)
			//IL_009c: Expected O, but got Unknown
			//IL_009c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a6: Expected O, but got Unknown
			Unsubscribe();
			BattleController.OnAttackStarted = (Action)Delegate.Combine(BattleController.OnAttackStarted, new Action(OnAttackStarted));
			BattleController.OnTurnComplete = (Action)Delegate.Combine(BattleController.OnTurnComplete, new Action(OnTurnComplete));
			BattleController.OnBattleStarted = (BattleEvent)Delegate.Combine((Delegate?)(object)BattleController.OnBattleStarted, (Delegate?)new BattleEvent(OnBattleStarted));
			BattleController.OnStartedAwaitingShot = (BattleEvent)Delegate.Combine((Delegate?)(object)BattleController.OnStartedAwaitingShot, (Delegate?)new BattleEvent(OnAwaitingShot));
			BattleController.OnShotComplete = (ShotComplete)Delegate.Combine((Delegate?)(object)BattleController.OnShotComplete, (Delegate?)new ShotComplete(OnShotComplete));
			BattleController.OnVictory = (Action)Delegate.Combine(BattleController.OnVictory, new Action(OnVictory));
			_log.LogInfo((object)$"CoopSubscriptions registered (with turn system) — TotalPlayerCount={_coopStateManager.TotalPlayerCount}, IsHosting={_mode.IsHosting}");
		}

		public void Unsubscribe()
		{
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			BattleController.OnAttackStarted = (Action)Delegate.Remove(BattleController.OnAttackStarted, new Action(OnAttackStarted));
			BattleController.OnTurnComplete = (Action)Delegate.Remove(BattleController.OnTurnComplete, new Action(OnTurnComplete));
			BattleController.OnBattleStarted = (BattleEvent)Delegate.Remove((Delegate?)(object)BattleController.OnBattleStarted, (Delegate?)new BattleEvent(OnBattleStarted));
			BattleController.OnStartedAwaitingShot = (BattleEvent)Delegate.Remove((Delegate?)(object)BattleController.OnStartedAwaitingShot, (Delegate?)new BattleEvent(OnAwaitingShot));
			BattleController.OnShotComplete = (ShotComplete)Delegate.Remove((Delegate?)(object)BattleController.OnShotComplete, (Delegate?)new ShotComplete(OnShotComplete));
			BattleController.OnVictory = (Action)Delegate.Remove(BattleController.OnVictory, new Action(OnVictory));
		}

		private void OnAttackStarted()
		{
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2)
			{
				return;
			}
			try
			{
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val == (Object)null)
				{
					_healthBeforeAttack = 0f;
					_damageDistributedSinceAttackStart = 0f;
				}
				else
				{
					_healthBeforeAttack = val.CurrentHealth;
					_damageDistributedSinceAttackStart = 0f;
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopSubs] OnAttackStarted failed: " + ex.Message));
				_healthBeforeAttack = 0f;
				_damageDistributedSinceAttackStart = 0f;
			}
		}

		public void DistributeDamageToNonActive(float rawDamage, string source)
		{
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2 || rawDamage <= 0f)
			{
				return;
			}
			int activePlayerSlot = _coopStateManager.ActivePlayerSlot;
			foreach (CoopPlayerState value in _coopStateManager.PlayerStates.Values)
			{
				if (value.SlotIndex != activePlayerSlot)
				{
					float currentHealth = value.CurrentHealth;
					float num = _buffApplier.ApplyDefensiveBuffs(value, rawDamage);
					value.CurrentHealth = Mathf.Max(0f, value.CurrentHealth - num);
					float num2 = currentHealth - value.CurrentHealth;
					if (num2 > 0f)
					{
						value.DamageTaken += (long)num2;
					}
					_log.LogInfo((object)($"[CoopSubs] DistributeDamage({source}) slot {value.SlotIndex} ({value.PlayerName}): " + $"hp {currentHealth} -> {value.CurrentHealth} (raw={rawDamage}, after buffs={num})"));
				}
			}
		}

		public void HandleImmediateDamage(float amount)
		{
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2 || amount <= 0f)
			{
				return;
			}
			DistributeDamageToNonActive(amount, "OnPlayerDamaged");
			_damageDistributedSinceAttackStart += amount;
			int activePlayerSlot = _coopStateManager.ActivePlayerSlot;
			if (activePlayerSlot < 0)
			{
				return;
			}
			CoopPlayerState playerState = _coopStateManager.GetPlayerState(activePlayerSlot);
			if (playerState != null)
			{
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val != (Object)null)
				{
					playerState.CurrentHealth = Mathf.Max(0f, val.CurrentHealth);
				}
				if (amount > 0f)
				{
					playerState.DamageTaken += (long)amount;
				}
			}
		}

		public void HandleImmediateHeal(float amount)
		{
			if (!_mode.IsHosting || amount <= 0f)
			{
				return;
			}
			int activePlayerSlot = _coopStateManager.ActivePlayerSlot;
			if (activePlayerSlot < 0)
			{
				return;
			}
			CoopPlayerState playerState = _coopStateManager.GetPlayerState(activePlayerSlot);
			if (playerState != null)
			{
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val != (Object)null)
				{
					playerState.CurrentHealth = Mathf.Min(playerState.MaxHealth, val.CurrentHealth);
				}
			}
		}

		private void ApplyImmediateHeal(int shooterSlot, long healAmount, string orbPrefabName, string targetGuid)
		{
			CoopPlayerState playerState = _coopStateManager.GetPlayerState(shooterSlot);
			if (playerState == null)
			{
				return;
			}
			float currentHealth = playerState.CurrentHealth;
			float num = Mathf.Min(playerState.MaxHealth, currentHealth + (float)healAmount);
			float num2 = num - currentHealth;
			if (num2 <= 0f)
			{
				_log.LogInfo((object)$"[CoopSubs] Heal slot {shooterSlot}: already at full hp ({currentHealth}/{playerState.MaxHealth}), no heal applied");
				return;
			}
			playerState.CurrentHealth = num;
			if (_coopStateManager.ActivePlayerSlot == shooterSlot)
			{
				try
				{
					PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
					if ((Object)(object)val != (Object)null)
					{
						object? obj = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth")?.GetValue(val);
						object? obj2 = ((obj is FloatVariable) ? obj : null);
						if (obj2 != null)
						{
							((FloatVariable)obj2).Set(num);
						}
					}
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[CoopSubs] Heal: failed to push hp to PHC: " + ex.Message));
				}
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				((services != null && services.TryResolve<IGameEventRegistry>(out var instance)) ? instance : null)?.Dispatch(new PlayerHealedEvent
				{
					Amount = num2,
					RemainingHealth = num,
					TargetSlotIndex = shooterSlot
				});
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[CoopSubs] Heal dispatch failed: " + ex2.Message));
			}
			try
			{
				AssetLoading instance2 = AssetLoading.Instance;
				GameObject obj3 = ((instance2 != null) ? instance2.GetOrbPrefab(orbPrefabName) : null);
				HealAction val2 = ((obj3 != null) ? obj3.GetComponent<HealAction>() : null);
				if ((Object)(object)val2 == (Object)null)
				{
					_log.LogInfo((object)$"[CoopSubs] Heal slot {shooterSlot}: +{num2} hp -> {num}/{playerState.MaxHealth}");
					return;
				}
				EnemyManager val3 = Object.FindObjectOfType<EnemyManager>();
				if ((Object)(object)val3 == (Object)null)
				{
					return;
				}
				if (val2.damageTargetedEnemyMultiplier > 0f)
				{
					int num3 = Mathf.RoundToInt(num2 * val2.damageTargetedEnemyMultiplier);
					if (num3 > 0)
					{
						Enemy val4 = null;
						IServiceContainer services2 = MultiplayerPlugin.Services;
						if (!string.IsNullOrEmpty(targetGuid) && services2 != null && services2.TryResolve<EnemyIdentifier>(out var instance3))
						{
							val4 = instance3.Find(targetGuid);
						}
						if ((Object)(object)val4 == (Object)null || val4.CurrentHealth <= 0f)
						{
							val4 = val3.GetFarthestEnemyFromPlayer();
						}
						if ((Object)(object)val4 != (Object)null && val4.CurrentHealth > 0f)
						{
							EnemySubscriptions.DamageAttributionSlotOverride = shooterSlot;
							try
							{
								val4.Damage((long)num3, false, 0.25f, 1f, false, (EnemyDamageSource)2, true, false);
							}
							finally
							{
								EnemySubscriptions.DamageAttributionSlotOverride = -1;
							}
						}
					}
				}
				else if (val2.damageAllEnemiesMultiplier > 0f)
				{
					int num4 = Mathf.RoundToInt(num2 * val2.damageAllEnemiesMultiplier);
					if (num4 > 0)
					{
						EnemySubscriptions.DamageAttributionSlotOverride = shooterSlot;
						try
						{
							foreach (Enemy enemy in val3.Enemies)
							{
								if ((Object)(object)enemy != (Object)null && enemy.CurrentHealth > 0f)
								{
									enemy.Damage((long)num4, false, 0.25f, 1f, false, (EnemyDamageSource)3, true, false);
								}
							}
						}
						finally
						{
							EnemySubscriptions.DamageAttributionSlotOverride = -1;
						}
					}
				}
				_log.LogInfo((object)($"[CoopSubs] Heal slot {shooterSlot}: +{num2} hp -> {num}/{playerState.MaxHealth} " + $"(orb={orbPrefabName}, targetMult={val2.damageTargetedEnemyMultiplier}, allMult={val2.damageAllEnemiesMultiplier})"));
			}
			catch (Exception ex3)
			{
				_log.LogWarning((object)("[CoopSubs] Heal secondary damage failed: " + ex3.Message));
			}
		}

		private void OnTurnComplete()
		{
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2)
			{
				return;
			}
			try
			{
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val != (Object)null)
				{
					float currentHealth = val.CurrentHealth;
					float num = _healthBeforeAttack - currentHealth - _damageDistributedSinceAttackStart;
					if (num > 0f)
					{
						_coopStateManager.SaveActivePlayerState();
						DistributeDamageToNonActive(num, "OnTurnComplete-residual");
						_damageDistributedSinceAttackStart += num;
					}
					_healthBeforeAttack = currentHealth;
					_damageDistributedSinceAttackStart = 0f;
					if (_coopStateManager.AllPlayersDead)
					{
						_log.LogWarning((object)"[CoopSubs] All co-op players have died! Triggering defeat.");
						val.CheckForDeathAndUpdateBar();
					}
					else if (_coopStateManager.AnyPlayerDead)
					{
						_log.LogInfo((object)"[CoopSubs] Some players dead, but not all — battle continues. Dead players will skip turns.");
					}
				}
				if (_turnManager.Phase == TurnPhase.ALL_DONE)
				{
					int num2 = 0;
					foreach (int item in _turnManager.TurnOrder)
					{
						CoopPlayerState playerState = _coopStateManager.GetPlayerState(item);
						if (playerState != null && playerState.CurrentHealth > 0f)
						{
							num2 = item;
							break;
						}
					}
					_coopStateManager.SwapToPlayer(num2);
					_coopStateManager.RebuildDeckInfoDisplay();
					_log.LogInfo((object)$"[CoopSubs] Post-attack: swapped to slot {num2} for next round's DrawBall");
				}
				_orbApplier.CleanupTempOrb();
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopSubs] OnTurnComplete failed: " + ex.Message + "\n" + ex.StackTrace));
			}
		}

		private void OnBattleStarted()
		{
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2)
			{
				return;
			}
			_accumulatedShotData.Clear();
			PendingDamageOverlay.ClearAll();
			_victoryHandledThisBattle = false;
			_turnManager.BuildTurnOrder();
			_turnManager.StartNewRound();
			BroadcastTurnChange();
			_log.LogInfo((object)$"[CoopSubs] Battle started — turn order built, round 1 started, slot {_turnManager.CurrentPlayerSlot} is up");
			try
			{
				if (_coopStateManager.ActivePlayerSlot != 0)
				{
					_log.LogWarning((object)$"[CoopSubs] Battle init: ActivePlayerSlot was {_coopStateManager.ActivePlayerSlot}, forcing swap to host (slot 0)");
					_coopStateManager.SwapToPlayer(0);
				}
				_coopStateManager.SaveActivePlayerState();
				_log.LogInfo((object)"[CoopSubs] Battle init: saved host (slot 0) state from singletons");
				foreach (KeyValuePair<int, CoopPlayerState> playerState in _coopStateManager.PlayerStates)
				{
					if (playerState.Key != 0)
					{
						CoopPlayerState value = playerState.Value;
						if (value.CompleteDeck.Count > 0)
						{
							value.BattleDeck.Clear();
							value.ShuffledOrder?.Clear();
							_log.LogInfo((object)$"[CoopSubs] Battle init: slot {playerState.Key} — rebuilding deck from completeDeck ({value.CompleteDeck.Count})");
							_coopStateManager.SwapToPlayer(playerState.Key);
							_deckMgr.EnsureBattleDeckPopulated($"battle init slot {playerState.Key}");
							_deckMgr.ApplyNonHostStartingBonuses(playerState.Key);
							_coopStateManager.SaveActivePlayerState();
						}
					}
				}
				if (_coopStateManager.ActivePlayerSlot != 0)
				{
					_coopStateManager.SwapToPlayer(0);
					_log.LogInfo((object)"[CoopSubs] Battle init: swapped back to host (slot 0)");
				}
				try
				{
					_syncService.SyncAll("BattleInit-DeckPopulated");
					_log.LogInfo((object)"[CoopSubs] Battle init: sent immediate SyncAll with populated decks");
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[CoopSubs] Battle init SyncAll failed: " + ex.Message));
				}
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[CoopSubs] Battle init state capture failed: " + ex2.Message + "\n" + ex2.StackTrace));
			}
		}

		private void OnAwaitingShot()
		{
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2)
			{
				return;
			}
			if (_turnManager.Phase == TurnPhase.ALL_DONE || _turnManager.Phase == TurnPhase.DAMAGE_PHASE)
			{
				_accumulatedShotData.Clear();
				PendingDamageOverlay.ClearAll();
				BattleController battleController = _bcUpdater.GetBattleController();
				if ((Object)(object)battleController != (Object)null)
				{
					_bcUpdater.ResetShotTallies(battleController);
				}
				try
				{
					IServiceContainer services = MultiplayerPlugin.Services;
					if (services != null && services.TryResolve<IGameEventRegistry>(out var instance))
					{
						instance.Dispatch(new PendingDamagePreviewEvent());
					}
				}
				catch
				{
				}
				_turnManager.StartNewRound();
				_log.LogInfo((object)$"[CoopSubs] New round {_turnManager.RoundNumber} started, slot {_turnManager.CurrentPlayerSlot}");
				if (_turnManager.Phase == TurnPhase.PLAYER_AIMING && _turnManager.CurrentPlayerSlot != _coopStateManager.ActivePlayerSlot)
				{
					SwapAndRedrawForRoundStart($"round {_turnManager.RoundNumber} start, slot 0 dead");
				}
			}
			BroadcastTurnChange();
			SkipActiveSlotIfDead("OnAwaitingShot");
		}

		private void SwapAndRedrawForRoundStart(string context)
		{
			//IL_00a4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00af: Expected O, but got Unknown
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f7: Expected O, but got Unknown
			BattleController battleController = _bcUpdater.GetBattleController();
			try
			{
				if ((Object)(object)battleController != (Object)null)
				{
					_bcUpdater.DestroyActivePachinkoBall(battleController);
					_bcUpdater.SetRemainingPachinkoBalls(battleController, 0);
					_bcUpdater.ResetShotTallies(battleController);
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopSubs] SwapAndRedraw (" + context + "): pre-swap cleanup failed: " + ex.Message));
			}
			_coopStateManager.SwapToPlayer(_turnManager.CurrentPlayerSlot);
			BallDrawn val = null;
			Shuffled val2 = null;
			PersistBallUsed val3 = null;
			try
			{
				val = DeckManager.onBallUsed;
				val2 = DeckManager.onDeckShuffled;
				val3 = DeckManager.onPersistBallUsed;
				object obj = <>c.<>9__44_0;
				if (obj == null)
				{
					BallDrawn val4 = delegate
					{
					};
					<>c.<>9__44_0 = val4;
					obj = (object)val4;
				}
				DeckManager.onBallUsed = (BallDrawn)obj;
				object obj2 = <>c.<>9__44_1;
				if (obj2 == null)
				{
					Shuffled val5 = delegate
					{
					};
					<>c.<>9__44_1 = val5;
					obj2 = (object)val5;
				}
				DeckManager.onDeckShuffled = (Shuffled)obj2;
				object obj3 = <>c.<>9__44_2;
				if (obj3 == null)
				{
					PersistBallUsed val6 = delegate
					{
					};
					<>c.<>9__44_2 = val6;
					obj3 = (object)val6;
				}
				DeckManager.onPersistBallUsed = (PersistBallUsed)obj3;
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[CoopSubs] SwapAndRedraw (" + context + "): callback disconnect failed: " + ex2.Message));
			}
			if (!_deckMgr.EnsureBattleDeckPopulated(context + " swap"))
			{
				_log.LogWarning((object)("[CoopSubs] SwapAndRedraw (" + context + "): EnsureBattleDeckPopulated failed — deck may be empty"));
			}
			_coopStateManager.RebuildDeckInfoDisplay();
			try
			{
				_bcUpdater.SetBattleState((BattleState)2);
				if ((Object)(object)battleController != (Object)null)
				{
					_bcUpdater.InvokeDrawBall(battleController);
					_log.LogInfo((object)$"[CoopSubs] SwapAndRedraw ({context}): DrawBall invoked for slot {_turnManager.CurrentPlayerSlot}");
				}
			}
			catch (Exception ex3)
			{
				_log.LogWarning((object)("[CoopSubs] SwapAndRedraw (" + context + "): DrawBall failed: " + (ex3.InnerException?.Message ?? ex3.Message)));
			}
			finally
			{
				try
				{
					if (val != null)
					{
						DeckManager.onBallUsed = val;
					}
					if (val2 != null)
					{
						DeckManager.onDeckShuffled = val2;
					}
					if (val3 != null)
					{
						DeckManager.onPersistBallUsed = val3;
					}
				}
				catch (Exception ex4)
				{
					_log.LogWarning((object)("[CoopSubs] SwapAndRedraw (" + context + "): callback restore failed: " + ex4.Message));
				}
			}
			try
			{
				_syncService.SyncAll(context ?? "");
			}
			catch (Exception ex5)
			{
				_log.LogWarning((object)("[CoopSubs] SwapAndRedraw (" + context + "): SyncAll failed: " + ex5.Message));
			}
		}

		private void SkipActiveSlotIfDead(string reason)
		{
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2)
			{
				return;
			}
			int num = 0;
			while (_turnManager.Phase == TurnPhase.PLAYER_AIMING && num++ < 16)
			{
				int currentPlayerSlot = _turnManager.CurrentPlayerSlot;
				if (currentPlayerSlot >= 0)
				{
					CoopPlayerState playerState = _coopStateManager.GetPlayerState(currentPlayerSlot);
					if (playerState != null && playerState.IsInitialized && !(playerState.CurrentHealth > 0f))
					{
						_log.LogInfo((object)$"[CoopSubs] Auto-skip dead slot {currentPlayerSlot} (hp=0) source={reason}");
						SkipCurrentTurn(currentPlayerSlot, "auto-skip dead (" + reason + ")");
						continue;
					}
					break;
				}
				break;
			}
		}

		private void OnShotComplete()
		{
			//IL_0579: Unknown result type (might be due to invalid IL or missing references)
			//IL_057e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0584: Expected O, but got Unknown
			//IL_059d: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a2: Unknown result type (might be due to invalid IL or missing references)
			//IL_05a8: Expected O, but got Unknown
			//IL_05c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_05c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_05cc: Expected O, but got Unknown
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2)
			{
				return;
			}
			if (_turnManager.Phase == TurnPhase.ALL_DONE)
			{
				_log.LogInfo((object)"[CoopSubs] OnShotComplete re-entry in ALL_DONE (bomb ball) — skipping");
				return;
			}
			int activePlayerSlot = _coopStateManager.ActivePlayerSlot;
			BattleController battleController = _bcUpdater.GetBattleController();
			if ((Object)(object)battleController != (Object)null)
			{
				int num = _bcUpdater.GetPegMultiplierDamageTally(battleController);
				int criticalHitCount = _bcUpdater.GetCriticalHitCount();
				int numPegsHit = _bcUpdater.GetNumPegsHit(battleController);
				int cactusDamageTally = _bcUpdater.GetCactusDamageTally(battleController);
				float damageMultiplier = _bcUpdater.GetDamageMultiplier(battleController);
				long damageBonus = _bcUpdater.GetDamageBonus(battleController);
				AttackManager attackManager = _bcUpdater.GetAttackManager(battleController);
				long num2 = 0L;
				bool flag = false;
				bool flag2 = false;
				List<(StatusEffectType, int)> list = null;
				string text = null;
				bool flag3 = false;
				bool hasTargetedSplash = false;
				bool hasTargetedHitAll = false;
				RelicManager[] array = Resources.FindObjectsOfTypeAll<RelicManager>();
				RelicManager val = ((array != null && array.Length != 0) ? array[0] : null);
				if ((Object)(object)val != (Object)null)
				{
					flag3 = val.RelicEffectActive((RelicEffect)179);
					hasTargetedSplash = val.RelicEffectActive((RelicEffect)134);
					hasTargetedHitAll = val.RelicEffectActive((RelicEffect)162);
				}
				if ((Object)(object)attackManager != (Object)null)
				{
					num2 = attackManager.GetCurrentDamage(num, damageMultiplier, damageBonus, criticalHitCount, false);
					int highWaterPegTally = HighWaterPegTally;
					long highWaterDamage = HighWaterDamage;
					if (highWaterDamage > num2)
					{
						_log.LogWarning((object)("[CoopSubs] Damage capture below HWM — using HWM. " + $"captured={num2} (pegTally={num}), " + $"hwm={highWaterDamage} (pegTally={highWaterPegTally}), " + $"multiballSpawns={MultiballSpawnCount}, slot={activePlayerSlot}"));
						num2 = highWaterDamage;
						if (num == 0 && highWaterPegTally > 0)
						{
							num = highWaterPegTally;
						}
					}
					flag2 = attackManager.isHeal;
					if (flag3 && !flag2 && num2 > 0)
					{
						long num3 = num2 % 2;
						num2 = num2 / 2 + num3;
					}
					Attack currentAttack = _bcUpdater.GetCurrentAttack(attackManager);
					if (currentAttack is SimpleAttack)
					{
						flag = true;
					}
					if ((Object)(object)currentAttack != (Object)null)
					{
						list = _orbApplier.CaptureOrbStatusEffects(currentAttack, criticalHitCount);
					}
					if ((Object)(object)currentAttack != (Object)null)
					{
						_orbApplier.ApplySelfPostAttackBuffs(currentAttack, criticalHitCount, activePlayerSlot);
					}
					try
					{
						GameObject activePachinkoBall = _bcUpdater.GetActivePachinkoBall(battleController);
						if ((Object)(object)activePachinkoBall != (Object)null)
						{
							text = ((Object)activePachinkoBall).name.Replace("(Clone)", string.Empty).Trim();
						}
						else
						{
							_log.LogWarning((object)$"[CoopSubs] _activePachinkoBall was null at shot capture for slot {activePlayerSlot}");
						}
					}
					catch (Exception ex)
					{
						_log.LogWarning((object)("[CoopSubs] Failed to capture orb name: " + ex.Message));
					}
				}
				string text2 = null;
				if (activePlayerSlot == 0)
				{
					TargetingManager val2 = Object.FindObjectOfType<TargetingManager>();
					if ((Object)(object)((val2 != null) ? val2.currentTarget : null) != (Object)null)
					{
						IServiceContainer services = MultiplayerPlugin.Services;
						if (services != null && services.TryResolve<EnemyIdentifier>(out var instance))
						{
							text2 = instance.GetGuid(val2.currentTarget);
						}
					}
				}
				else
				{
					text2 = LastPendingShotTargetGuid;
					LastPendingShotTargetGuid = null;
				}
				string text3 = null;
				if (_coopStateManager.PlayerStates.TryGetValue(activePlayerSlot, out var value))
				{
					text3 = value.PlayerName;
				}
				_accumulatedShotData[activePlayerSlot] = new ShotDamageData
				{
					PegMultiplierDamageTally = num,
					CriticalHitCount = criticalHitCount,
					NumPegsHit = numPegsHit,
					CactusDamageTally = cactusDamageTally,
					DamageMultiplier = damageMultiplier,
					DamageBonus = damageBonus,
					PrecomputedDamage = num2,
					TargetEnemyGuid = text2,
					IsAoE = flag,
					IsHeal = flag2,
					PlayerName = (text3 ?? $"Slot {activePlayerSlot}"),
					StatusEffectsToApply = list,
					OrbPrefabName = text,
					HasReverseShot = (flag3 && !flag2 && num2 > 0),
					HasTargetedSplash = hasTargetedSplash,
					HasTargetedHitAll = hasTargetedHitAll
				};
				_log.LogInfo((object)($"[CoopSubs] Saved shot data for slot {activePlayerSlot}: " + $"pegTally={num}, crits={criticalHitCount}, pegsHit={numPegsHit}, " + string.Format("damage={0}, target={1}, isAoE={2}, ", num2, text2 ?? "auto", flag) + string.Format("statusEffects={0}, orb={1}, ", list?.Count ?? 0, text ?? "NONE") + $"multiballSpawns={MultiballSpawnCount}, hwmTally={HighWaterPegTally}, hwmDmg={HighWaterDamage}"));
				if (flag2 && num2 > 0)
				{
					ApplyImmediateHeal(activePlayerSlot, num2, text, text2);
					_accumulatedShotData[activePlayerSlot].IsHeal = false;
					_accumulatedShotData[activePlayerSlot].PrecomputedDamage = 0L;
				}
			}
			_turnManager.MarkShotFired();
			_coopStateManager.SaveActivePlayerState();
			_turnManager.AdvanceTurn();
			if (_turnManager.Phase == TurnPhase.PLAYER_AIMING && _turnManager.CurrentPlayerSlot >= 0)
			{
				if ((Object)(object)battleController != (Object)null)
				{
					_bcUpdater.ResetShotTallies(battleController);
				}
				_coopStateManager.SwapToPlayer(_turnManager.CurrentPlayerSlot);
				BallDrawn val3 = null;
				Shuffled val4 = null;
				PersistBallUsed val5 = null;
				try
				{
					val3 = DeckManager.onBallUsed;
					val4 = DeckManager.onDeckShuffled;
					val5 = DeckManager.onPersistBallUsed;
					object obj = <>c.<>9__46_0;
					if (obj == null)
					{
						BallDrawn val6 = delegate
						{
						};
						<>c.<>9__46_0 = val6;
						obj = (object)val6;
					}
					DeckManager.onBallUsed = (BallDrawn)obj;
					object obj2 = <>c.<>9__46_1;
					if (obj2 == null)
					{
						Shuffled val7 = delegate
						{
						};
						<>c.<>9__46_1 = val7;
						obj2 = (object)val7;
					}
					DeckManager.onDeckShuffled = (Shuffled)obj2;
					object obj3 = <>c.<>9__46_2;
					if (obj3 == null)
					{
						PersistBallUsed val8 = delegate
						{
						};
						<>c.<>9__46_2 = val8;
						obj3 = (object)val8;
					}
					DeckManager.onPersistBallUsed = (PersistBallUsed)obj3;
				}
				catch (Exception ex2)
				{
					_log.LogWarning((object)("[CoopSubs] Failed to disconnect DeckManager callbacks: " + ex2.Message));
				}
				if (!_deckMgr.EnsureBattleDeckPopulated("shot complete swap"))
				{
					_log.LogWarning((object)"[CoopSubs] EnsureBattleDeckPopulated failed after shot complete swap — deck may be empty");
				}
				_bcUpdater.SetBattleState((BattleState)2);
				try
				{
					if ((Object)(object)battleController != (Object)null)
					{
						_bcUpdater.InvokeDrawBall(battleController);
						_log.LogInfo((object)$"[CoopSubs] Manually called DrawBall for slot {_turnManager.CurrentPlayerSlot}");
					}
				}
				catch (Exception ex3)
				{
					_log.LogWarning((object)("[CoopSubs] DrawBall call failed: " + (ex3.InnerException?.Message ?? ex3.Message) + "\n" + (ex3.InnerException?.StackTrace ?? ex3.StackTrace)));
				}
				finally
				{
					try
					{
						if (val3 != null)
						{
							DeckManager.onBallUsed = val3;
						}
						if (val4 != null)
						{
							DeckManager.onDeckShuffled = val4;
						}
						if (val5 != null)
						{
							DeckManager.onPersistBallUsed = val5;
						}
					}
					catch (Exception ex4)
					{
						_log.LogWarning((object)("[CoopSubs] Failed to restore DeckManager callbacks: " + ex4.Message));
					}
				}
				BroadcastTurnChange();
				try
				{
					_syncService.SyncAll("TurnSwap");
				}
				catch (Exception ex5)
				{
					_log.LogWarning((object)("[CoopSubs] TurnSwap SyncAll failed: " + ex5.Message));
				}
				_log.LogInfo((object)($"[CoopSubs] Swapped to player slot {_turnManager.CurrentPlayerSlot}, " + "redirected BattleState -> AWAITING_SHOT"));
			}
			else if (_turnManager.Phase == TurnPhase.ALL_DONE)
			{
				if (_accumulatedShotData.TryGetValue(0, out var value2) && (Object)(object)battleController != (Object)null)
				{
					_bcUpdater.WriteShotTallies(battleController, value2.PegMultiplierDamageTally, value2.CriticalHitCount, value2.NumPegsHit, value2.CactusDamageTally, value2.DamageMultiplier, value2.DamageBonus);
					_log.LogInfo((object)($"[CoopSubs] Host (slot 0) damage: pegTally={value2.PegMultiplierDamageTally}, " + $"crits={value2.CriticalHitCount}, pegsHit={value2.NumPegsHit}, " + $"dmgMult={value2.DamageMultiplier}, dmgBonus={value2.DamageBonus}"));
				}
				else if ((Object)(object)battleController != (Object)null)
				{
					_bcUpdater.SetPegMultiplierDamageTally(battleController, 0);
					_bcUpdater.SetCriticalHitCount(0);
					_bcUpdater.SetNumPegsHit(battleController, 0);
					_bcUpdater.SetCactusDamageTally(battleController, 0);
					_log.LogWarning((object)"[CoopSubs] Host slot 0 not found in accumulated shot data!");
				}
				if (_accumulatedShotData.TryGetValue(0, out var value3) && !string.IsNullOrEmpty(value3.TargetEnemyGuid))
				{
					try
					{
						IServiceContainer services2 = MultiplayerPlugin.Services;
						if (services2 != null && services2.TryResolve<EnemyIdentifier>(out var instance2))
						{
							Enemy val9 = instance2.Find(value3.TargetEnemyGuid);
							if ((Object)(object)val9 != (Object)null)
							{
								TargetingManager obj4 = Object.FindObjectOfType<TargetingManager>();
								if (obj4 != null)
								{
									obj4.SetEnemyAsTarget(val9, true);
								}
							}
						}
					}
					catch (Exception ex6)
					{
						_log.LogWarning((object)("[CoopSubs] Failed to set host target: " + ex6.Message));
					}
				}
				if (_coopStateManager.ActivePlayerSlot != 0)
				{
					_coopStateManager.SwapToPlayer(0);
					_log.LogInfo((object)"[CoopSubs] ALL_DONE: swapped to host (slot 0) for attack phase");
				}
				if (_accumulatedShotData.TryGetValue(0, out var value4) && !string.IsNullOrEmpty(value4.OrbPrefabName) && (Object)(object)battleController != (Object)null)
				{
					try
					{
						AssetLoading instance3 = AssetLoading.Instance;
						GameObject val10 = ((instance3 != null) ? instance3.GetOrbPrefab(value4.OrbPrefabName) : null);
						if ((Object)(object)val10 != (Object)null)
						{
							_orbApplier.RestoreAttackFromPrefab(battleController, val10, "host");
						}
						else
						{
							_log.LogWarning((object)("[CoopSubs] ALL_DONE: AssetLoading.GetOrbPrefab returned null for '" + value4.OrbPrefabName + "'"));
						}
					}
					catch (Exception ex7)
					{
						_log.LogWarning((object)("[CoopSubs] Failed to restore host Attack: " + ex7.Message));
					}
				}
				else if ((Object)(object)battleController != (Object)null)
				{
					_log.LogWarning((object)("[CoopSubs] ALL_DONE: Cannot restore host Attack — " + $"hasSlot0={_accumulatedShotData.ContainsKey(0)}, " + "orbName=" + (_accumulatedShotData.TryGetValue(0, out var value5) ? (value5.OrbPrefabName ?? "null") : "N/A")));
				}
				BroadcastTurnChange();
				_log.LogInfo((object)$"[CoopSubs] All players shot — per-player targeting active. Phase={_turnManager.Phase}");
			}
			else
			{
				BroadcastTurnChange();
				_log.LogInfo((object)$"[CoopSubs] Shot complete — Phase={_turnManager.Phase}, slot={_turnManager.CurrentPlayerSlot}");
			}
		}

		public void SkipCurrentTurn(int requestingSlot, string source)
		{
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2)
			{
				return;
			}
			int activePlayerSlot = _coopStateManager.ActivePlayerSlot;
			if (requestingSlot != activePlayerSlot)
			{
				_log.LogWarning((object)$"[CoopSubs] SkipCurrentTurn denied — requester {requestingSlot} is not active slot {activePlayerSlot} (source={source})");
				return;
			}
			if (_turnManager.Phase != TurnPhase.PLAYER_AIMING)
			{
				_log.LogWarning((object)$"[CoopSubs] SkipCurrentTurn denied — Phase is {_turnManager.Phase}, not PLAYER_AIMING (source={source})");
				return;
			}
			_log.LogInfo((object)$"[CoopSubs] SkipCurrentTurn source={source}, slot={activePlayerSlot}");
			BattleController battleController = _bcUpdater.GetBattleController();
			if ((Object)(object)battleController != (Object)null)
			{
				try
				{
					_bcUpdater.ResetShotTallies(battleController);
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[CoopSubs] Skip: tally reset failed: " + ex.Message));
				}
				try
				{
					_bcUpdater.DestroyActivePachinkoBall(battleController);
					_bcUpdater.SetRemainingPachinkoBalls(battleController, 0);
				}
				catch (Exception ex2)
				{
					_log.LogWarning((object)("[CoopSubs] Skip: clear ball failed: " + ex2.Message));
				}
			}
			OnShotComplete();
			if (_turnManager.Phase != TurnPhase.ALL_DONE)
			{
				return;
			}
			try
			{
				_bcUpdater.SetBattleState((BattleState)13);
				_log.LogInfo((object)"[CoopSubs] Skip: forced BattleState -> PRE_ATTACK_SPAWN_CHECK");
			}
			catch (Exception ex3)
			{
				_log.LogWarning((object)("[CoopSubs] Skip: state transition failed: " + ex3.Message));
			}
		}

		private void OnVictory()
		{
			if (!_mode.IsHosting || _coopStateManager.TotalPlayerCount < 2 || _victoryHandledThisBattle)
			{
				return;
			}
			_victoryHandledThisBattle = true;
			try
			{
				if (_coopStateManager.ActivePlayerSlot != 0)
				{
					_coopStateManager.SwapToPlayer(0);
					_log.LogInfo((object)"[CoopSubs] OnVictory: swapped to host (slot 0) before reward selection");
				}
				_coopStateManager.SaveActivePlayerState();
				foreach (KeyValuePair<int, CoopPlayerState> playerState in _coopStateManager.PlayerStates)
				{
					CoopPlayerState value = playerState.Value;
					if (value.IsInitialized && value.CurrentHealth <= 0f)
					{
						value.CurrentHealth = 1f;
						_log.LogInfo((object)$"[CoopSubs] OnVictory: revived dead player slot {playerState.Key} '{value.PlayerName}' with 1 HP");
					}
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IGameEventRegistry>(out var instance))
				{
					return;
				}
				CoopRewardState.PendingSentRewardChoices.Clear();
				CoopRewardState.ClientRewardChoicesReceived.Clear();
				CoopRewardState.HostRewardPhaseActive = true;
				CoopRewardState.HostRewardsDone = false;
				CoopRewardState.PendingPostBattleController = null;
				int num = 0;
				foreach (KeyValuePair<int, CoopPlayerState> playerState2 in _coopStateManager.PlayerStates)
				{
					if (playerState2.Key != 0)
					{
						num++;
					}
				}
				CoopRewardState.TotalRewardClientsExpected = num;
				try
				{
					GenerateAndBroadcastPerSlotOrbChoices(instance);
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[CoopSubs] OnVictory per-slot orb generation failed: " + ex.Message));
				}
				instance.Dispatch(new PostBattleStartEvent());
				_log.LogInfo((object)$"[CoopSubs] Sent PostBattleStartEvent, expecting {num} client(s) to complete rewards");
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)("[CoopSubs] OnVictory reward distribution failed: " + ex2.Message));
			}
		}

		private void GenerateAndBroadcastPerSlotOrbChoices(IGameEventRegistry registry)
		{
			DeckManager val = Resources.FindObjectsOfTypeAll<DeckManager>().FirstOrDefault();
			if ((Object)(object)val == (Object)null)
			{
				_log.LogWarning((object)"[CoopSubs] GenerateAndBroadcastPerSlotOrbChoices: no DeckManager found");
				return;
			}
			List<GameObject> commonOrbPool = val.CommonOrbPool;
			List<GameObject> uncommonOrbPool = val.UncommonOrbPool;
			List<GameObject> rareOrbPool = val.RareOrbPool;
			if (commonOrbPool == null || commonOrbPool.Count == 0)
			{
				_log.LogWarning((object)"[CoopSubs] GenerateAndBroadcastPerSlotOrbChoices: empty CommonOrbPool");
				return;
			}
			CoopRewardState.PerSlotOrbChoices.Clear();
			foreach (KeyValuePair<int, CoopPlayerState> playerState in _coopStateManager.PlayerStates)
			{
				int key = playerState.Key;
				CoopPlayerState value = playerState.Value;
				if (value == null || !value.IsInitialized)
				{
					continue;
				}
				int num = 3;
				if (SlotHasRelic(value, (RelicEffect)60))
				{
					num++;
				}
				if (SlotHasRelic(value, (RelicEffect)97))
				{
					num++;
				}
				List<string> list = new List<string>();
				int num2 = 0;
				while (list.Count < num && num2++ < 200)
				{
					float value2 = Random.value;
					List<GameObject> list2 = ((value2 <= 0.6f) ? commonOrbPool : ((value2 <= 0.9f && uncommonOrbPool != null && uncommonOrbPool.Count > 0) ? uncommonOrbPool : ((rareOrbPool == null || rareOrbPool.Count <= 0) ? commonOrbPool : rareOrbPool)));
					GameObject val2 = list2[Random.Range(0, list2.Count)];
					if ((Object)(object)val2 == (Object)null)
					{
						continue;
					}
					if (Random.value < (float)(StaticGameData.totalFloorCount - 5) / 100f)
					{
						Attack component = val2.GetComponent<Attack>();
						if ((Object)(object)component != (Object)null && (Object)(object)component.NextLevelPrefab != (Object)null)
						{
							val2 = component.NextLevelPrefab;
							if (Random.value < (float)(StaticGameData.totalFloorCount - 5) / 200f)
							{
								Attack component2 = val2.GetComponent<Attack>();
								if ((Object)(object)component2 != (Object)null && (Object)(object)component2.NextLevelPrefab != (Object)null)
								{
									val2 = component2.NextLevelPrefab;
								}
							}
						}
					}
					if (!list.Contains(((Object)val2).name))
					{
						list.Add(((Object)val2).name);
					}
				}
				CoopRewardState.PerSlotOrbChoices[key] = list;
				_log.LogInfo((object)string.Format("[CoopSubs] Per-slot orb roll slot={0} count={1}: {2}", key, list.Count, string.Join(",", list)));
				if (key != 0)
				{
					registry.Dispatch(new CoopOrbRewardChoicesEvent
					{
						TargetSlotIndex = key,
						OrbPrefabNames = list
					});
				}
			}
		}

		private static bool SlotHasRelic(CoopPlayerState state, RelicEffect effect)
		{
			//IL_002f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0030: Invalid comparison between I4 and Unknown
			if (state?.OwnedRelics == null)
			{
				return false;
			}
			foreach (SerializedRelic ownedRelic in state.OwnedRelics)
			{
				if (ownedRelic != null && ownedRelic.Effect == (int)effect)
				{
					return true;
				}
			}
			return false;
		}

		public void HandlePlayerDisconnect(int slotIndex, string playerName)
		{
			//IL_022e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0233: Unknown result type (might be due to invalid IL or missing references)
			//IL_0239: Expected O, but got Unknown
			//IL_0252: Unknown result type (might be due to invalid IL or missing references)
			//IL_0257: Unknown result type (might be due to invalid IL or missing references)
			//IL_025d: Expected O, but got Unknown
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_027b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0281: Expected O, but got Unknown
			if (!_mode.IsHosting)
			{
				return;
			}
			_log.LogInfo((object)($"[CoopSubs] HandlePlayerDisconnect: slot {slotIndex} ({playerName}) — " + $"turnPhase={_turnManager.Phase}, activeSlot={_turnManager.CurrentPlayerSlot}, " + $"totalPlayers={_coopStateManager.TotalPlayerCount}"));
			_accumulatedShotData.Remove(slotIndex);
			if (_coopStateManager.PlayerStates.ContainsKey(slotIndex))
			{
				_coopStateManager.PlayerStates.Remove(slotIndex);
				_log.LogInfo((object)$"[CoopSubs] Removed slot {slotIndex} from CoopStateManager. Remaining players: {_coopStateManager.TotalPlayerCount}");
			}
			bool num = _turnManager.RemovePlayer(slotIndex);
			if (_coopStateManager.TotalPlayerCount <= 1)
			{
				_log.LogInfo((object)"[CoopSubs] All non-host players disconnected. Host continues solo.");
			}
			if (!num)
			{
				BroadcastTurnChange();
				_log.LogInfo((object)$"[CoopSubs] Disconnect handled (not their turn). Current turn: slot {_turnManager.CurrentPlayerSlot}");
			}
			else if (_turnManager.Phase == TurnPhase.ALL_DONE)
			{
				BattleController battleController = _bcUpdater.GetBattleController();
				if (_accumulatedShotData.TryGetValue(0, out var value) && (Object)(object)battleController != (Object)null)
				{
					_bcUpdater.SetPegMultiplierDamageTally(battleController, value.PegMultiplierDamageTally);
					_bcUpdater.SetCriticalHitCount(value.CriticalHitCount);
					_bcUpdater.SetNumPegsHit(battleController, value.NumPegsHit);
					_bcUpdater.SetCactusDamageTally(battleController, value.CactusDamageTally);
				}
				if (_coopStateManager.ActivePlayerSlot != 0)
				{
					_coopStateManager.SwapToPlayer(0);
				}
				BroadcastTurnChange();
				_log.LogInfo((object)"[CoopSubs] Disconnect during turn: all remaining players done, per-player resolution active");
			}
			else if (_turnManager.Phase == TurnPhase.PLAYER_AIMING)
			{
				int currentPlayerSlot = _turnManager.CurrentPlayerSlot;
				_coopStateManager.SwapToPlayer(currentPlayerSlot);
				BallDrawn val = null;
				Shuffled val2 = null;
				PersistBallUsed val3 = null;
				try
				{
					val = DeckManager.onBallUsed;
					val2 = DeckManager.onDeckShuffled;
					val3 = DeckManager.onPersistBallUsed;
					object obj = <>c.<>9__53_0;
					if (obj == null)
					{
						BallDrawn val4 = delegate
						{
						};
						<>c.<>9__53_0 = val4;
						obj = (object)val4;
					}
					DeckManager.onBallUsed = (BallDrawn)obj;
					object obj2 = <>c.<>9__53_1;
					if (obj2 == null)
					{
						Shuffled val5 = delegate
						{
						};
						<>c.<>9__53_1 = val5;
						obj2 = (object)val5;
					}
					DeckManager.onDeckShuffled = (Shuffled)obj2;
					object obj3 = <>c.<>9__53_2;
					if (obj3 == null)
					{
						PersistBallUsed val6 = delegate
						{
						};
						<>c.<>9__53_2 = val6;
						obj3 = (object)val6;
					}
					DeckManager.onPersistBallUsed = (PersistBallUsed)obj3;
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[CoopSubs] Disconnect: failed to save DeckManager callbacks: " + ex.Message));
				}
				_deckMgr.EnsureBattleDeckPopulated("disconnect swap");
				_bcUpdater.SetBattleState((BattleState)2);
				BattleController battleController2 = _bcUpdater.GetBattleController();
				try
				{
					if ((Object)(object)battleController2 != (Object)null)
					{
						_bcUpdater.InvokeDrawBall(battleController2);
						_log.LogInfo((object)$"[CoopSubs] Disconnect: called DrawBall for next player slot {currentPlayerSlot}");
					}
				}
				catch (Exception ex2)
				{
					_log.LogWarning((object)("[CoopSubs] Disconnect DrawBall failed: " + (ex2.InnerException?.Message ?? ex2.Message)));
				}
				finally
				{
					try
					{
						if (val != null)
						{
							DeckManager.onBallUsed = val;
						}
						if (val2 != null)
						{
							DeckManager.onDeckShuffled = val2;
						}
						if (val3 != null)
						{
							DeckManager.onPersistBallUsed = val3;
						}
					}
					catch (Exception ex3)
					{
						_log.LogWarning((object)("[CoopSubs] Disconnect: failed to restore DeckManager callbacks: " + ex3.Message));
					}
				}
				BroadcastTurnChange();
				try
				{
					_syncService.SyncAll("DisconnectTurnSwap");
				}
				catch (Exception ex4)
				{
					_log.LogWarning((object)("[CoopSubs] Disconnect SyncAll failed: " + ex4.Message));
				}
				_log.LogInfo((object)($"[CoopSubs] Disconnect during turn: swapped to slot {currentPlayerSlot}, " + "redirected BattleState -> AWAITING_SHOT"));
			}
			else
			{
				BroadcastTurnChange();
				_log.LogInfo((object)$"[CoopSubs] Disconnect handled in phase {_turnManager.Phase}");
			}
		}

		internal static List<PlayerAttackData> ConsumeNonHostShotData()
		{
			CoopSubscriptions instance = Instance;
			if (instance == null)
			{
				return null;
			}
			List<PlayerAttackData> list = new List<PlayerAttackData>();
			foreach (KeyValuePair<int, ShotDamageData> accumulatedShotDatum in instance._accumulatedShotData)
			{
				ShotDamageData value = accumulatedShotDatum.Value;
				list.Add(new PlayerAttackData
				{
					SlotIndex = accumulatedShotDatum.Key,
					PlayerName = value.PlayerName,
					Damage = value.PrecomputedDamage,
					TargetEnemyGuid = value.TargetEnemyGuid,
					IsAoE = value.IsAoE,
					IsHeal = value.IsHeal,
					StatusEffectsToApply = value.StatusEffectsToApply,
					NumPegsHit = value.NumPegsHit,
					CriticalHitCount = value.CriticalHitCount,
					OrbPrefabName = value.OrbPrefabName,
					HasReverseShot = value.HasReverseShot,
					HasTargetedSplash = value.HasTargetedSplash,
					HasTargetedHitAll = value.HasTargetedHitAll
				});
			}
			instance._accumulatedShotData.Clear();
			return list;
		}

		internal static List<PendingDamagePreviewEvent.DamageEntry> GetAccumulatedDamageEntries()
		{
			CoopSubscriptions instance = Instance;
			if (instance == null)
			{
				return null;
			}
			List<PendingDamagePreviewEvent.DamageEntry> list = new List<PendingDamagePreviewEvent.DamageEntry>();
			foreach (KeyValuePair<int, ShotDamageData> accumulatedShotDatum in instance._accumulatedShotData)
			{
				ShotDamageData value = accumulatedShotDatum.Value;
				if (!value.IsHeal && value.PrecomputedDamage > 0)
				{
					list.Add(new PendingDamagePreviewEvent.DamageEntry
					{
						SlotIndex = accumulatedShotDatum.Key,
						PlayerName = value.PlayerName,
						Damage = value.PrecomputedDamage,
						TargetEnemyGuid = value.TargetEnemyGuid,
						IsAoE = value.IsAoE
					});
				}
			}
			return list;
		}

		internal static void CleanupTempOrb()
		{
			Instance?._orbApplier?.CleanupTempOrb();
		}

		private void BroadcastTurnChange()
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IGameEventRegistry>(out var instance))
				{
					instance.Dispatch(new TurnChangeEvent
					{
						ActiveSlotIndex = _turnManager.CurrentPlayerSlot,
						ActivePlayerName = _turnManager.GetCurrentPlayerName(),
						TurnPhase = _turnManager.Phase.ToString(),
						RoundNumber = _turnManager.RoundNumber
					});
				}
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopSubs] BroadcastTurnChange failed: " + ex.Message));
			}
		}
	}
	public sealed class CurrencySubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly ManualLogSource _log;

		private readonly CoopStateManager _coopStateManager;

		private static bool IsHosting
		{
			get
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return instance.IsHosting;
				}
				return false;
			}
		}

		private bool IsCoop
		{
			get
			{
				if (_coopStateManager != null)
				{
					return _coopStateManager.TotalPlayerCount > 1;
				}
				return false;
			}
		}

		public CurrencySubscriptions(IGameEventRegistry registry, ManualLogSource log, CoopStateManager coopStateManager = null)
		{
			_registry = registry;
			_log = log;
			_coopStateManager = coopStateManager;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			CurrencyManager.OnGoldAdded = (CurrencyEvent)Delegate.Combine((Delegate?)(object)CurrencyManager.OnGoldAdded, (Delegate?)new CurrencyEvent(OnGoldAdded));
			CurrencyManager.OnGoldRemoved = (CurrencyEvent)Delegate.Combine((Delegate?)(object)CurrencyManager.OnGoldRemoved, (Delegate?)new CurrencyEvent(OnGoldRemoved));
			_log.LogInfo((object)"CurrencySubscriptions registered");
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			CurrencyManager.OnGoldAdded = (CurrencyEvent)Delegate.Remove((Delegate?)(object)CurrencyManager.OnGoldAdded, (Delegate?)new CurrencyEvent(OnGoldAdded));
			CurrencyManager.OnGoldRemoved = (CurrencyEvent)Delegate.Remove((Delegate?)(object)CurrencyManager.OnGoldRemoved, (Delegate?)new CurrencyEvent(OnGoldRemoved));
		}

		private void OnGoldAdded(int originalAmount, int currencyChange, bool silent)
		{
			if (IsHosting)
			{
				if (IsCoop && currencyChange > 0 && !CoopStateManager.IsLoadingPlayerGold)
				{
					_coopStateManager.DistributeGoldToInactivePlayers(currencyChange);
				}
				if (!IsCoop)
				{
					_registry.Dispatch(new GoldChangedEvent
					{
						PreviousAmount = originalAmount,
						NewAmount = originalAmount + currencyChange,
						Delta = currencyChange,
						IsGain = true
					});
				}
			}
		}

		private void OnGoldRemoved(int originalAmount, int currencyChange, bool silent)
		{
			if (IsHosting && !IsCoop)
			{
				_registry.Dispatch(new GoldChangedEvent
				{
					PreviousAmount = originalAmount,
					NewAmount = originalAmount - currencyChange,
					Delta = -currencyChange,
					IsGain = false
				});
			}
		}
	}
	public sealed class DeckSubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly OrbIdentifier _orbIdentifier;

		private readonly ManualLogSource _log;

		private static bool IsHosting
		{
			get
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return instance.IsHosting;
				}
				return false;
			}
		}

		public DeckSubscriptions(IGameEventRegistry registry, OrbIdentifier orbIdentifier, ManualLogSource log)
		{
			_registry = registry;
			_orbIdentifier = orbIdentifier;
			_log = log;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			DeckManager.onBallDrawn = (BallDrawn)Delegate.Combine((Delegate?)(object)DeckManager.onBallDrawn, (Delegate?)new BallDrawn(OnBallDrawn));
			DeckManager.onBallUsed = (BallDrawn)Delegate.Combine((Delegate?)(object)DeckManager.onBallUsed, (Delegate?)new BallDrawn(OnBallUsed));
			DeckManager.onBallUpgraded = (BallUpgraded)Delegate.Combine((Delegate?)(object)DeckManager.onBallUpgraded, (Delegate?)new BallUpgraded(OnBallUpgraded));
			DeckManager.onDeckShuffled = (Shuffled)Delegate.Combine((Delegate?)(object)DeckManager.onDeckShuffled, (Delegate?)new Shuffled(OnDeckShuffled));
			_log.LogInfo((object)"DeckSubscriptions registered");
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			DeckManager.onBallDrawn = (BallDrawn)Delegate.Remove((Delegate?)(object)DeckManager.onBallDrawn, (Delegate?)new BallDrawn(OnBallDrawn));
			DeckManager.onBallUsed = (BallDrawn)Delegate.Remove((Delegate?)(object)DeckManager.onBallUsed, (Delegate?)new BallDrawn(OnBallUsed));
			DeckManager.onBallUpgraded = (BallUpgraded)Delegate.Remove((Delegate?)(object)DeckManager.onBallUpgraded, (Delegate?)new BallUpgraded(OnBallUpgraded));
			DeckManager.onDeckShuffled = (Shuffled)Delegate.Remove((Delegate?)(object)DeckManager.onDeckShuffled, (Delegate?)new Shuffled(OnDeckShuffled));
		}

		private void OnBallDrawn(GameObject ball)
		{
			if (IsHosting)
			{
				_registry.Dispatch(new BallDrawnEvent
				{
					OrbName = _orbIdentifier.GetId(ball),
					Level = _orbIdentifier.GetLevel(ball)
				});
			}
		}

		private void OnBallUsed(GameObject ball)
		{
			if (IsHosting)
			{
				_registry.Dispatch(new BallUsedEvent
				{
					OrbName = _orbIdentifier.GetId(ball)
				});
			}
		}

		private void OnBallUpgraded(GameObject previous, GameObject post)
		{
			if (IsHosting)
			{
				_registry.Dispatch(new BallUpgradedEvent
				{
					PreviousOrbName = _orbIdentifier.GetId(previous),
					NewOrbName = _orbIdentifier.GetId(post),
					NewLevel = _orbIdentifier.GetLevel(post)
				});
			}
		}

		private void OnDeckShuffled(int deckSize)
		{
			if (IsHosting)
			{
				_registry.Dispatch(new DeckShuffledEvent
				{
					DeckSize = deckSize
				});
			}
		}
	}
	public sealed class EnemySubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly EnemyIdentifier _enemyIdentifier;

		private readonly ManualLogSource _log;

		private readonly CoopStateManager _coopStateManager;

		public static int DamageAttributionSlotOverride = -1;

		private static bool IsHosting
		{
			get
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return instance.IsHosting;
				}
				return false;
			}
		}

		private int PlayerCount => _coopStateManager?.TotalPlayerCount ?? 1;

		public EnemySubscriptions(IGameEventRegistry registry, EnemyIdentifier enemyIdentifier, ManualLogSource log, CoopStateManager coopStateManager = null)
		{
			_registry = registry;
			_enemyIdentifier = enemyIdentifier;
			_log = log;
			_coopStateManager = coopStateManager;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			Enemy.OnEnemySpawned = (EnemySpawned)Delegate.Combine((Delegate?)(object)Enemy.OnEnemySpawned, (Delegate?)new EnemySpawned(OnEnemySpawned));
			Enemy.OnEnemyDamaged = (EnemyDamaged)Delegate.Combine((Delegate?)(object)Enemy.OnEnemyDamaged, (Delegate?)new EnemyDamaged(OnEnemyDamaged));
			Enemy.OnEnemyDestroyed = (EnemyDestroyed)Delegate.Combine((Delegate?)(object)Enemy.OnEnemyDestroyed, (Delegate?)new EnemyDestroyed(OnEnemyDestroyed));
			Enemy.OnEnemyKilled = (EnemyDataEvent)Delegate.Combine((Delegate?)(object)Enemy.OnEnemyKilled, (Delegate?)new EnemyDataEvent(OnEnemyKilled));
			Enemy.OnEnemyAttack = (EnemyAttacked)Delegate.Combine((Delegate?)(object)Enemy.OnEnemyAttack, (Delegate?)new EnemyAttacked(OnEnemyAttack));
			_log.LogInfo((object)"EnemySubscriptions registered");
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			Enemy.OnEnemySpawned = (EnemySpawned)Delegate.Remove((Delegate?)(object)Enemy.OnEnemySpawned, (Delegate?)new EnemySpawned(OnEnemySpawned));
			Enemy.OnEnemyDamaged = (EnemyDamaged)Delegate.Remove((Delegate?)(object)Enemy.OnEnemyDamaged, (Delegate?)new EnemyDamaged(OnEnemyDamaged));
			Enemy.OnEnemyDestroyed = (EnemyDestroyed)Delegate.Remove((Delegate?)(object)Enemy.OnEnemyDestroyed, (Delegate?)new EnemyDestroyed(OnEnemyDestroyed));
			Enemy.OnEnemyKilled = (EnemyDataEvent)Delegate.Remove((Delegate?)(object)Enemy.OnEnemyKilled, (Delegate?)new EnemyDataEvent(OnEnemyKilled));
			Enemy.OnEnemyAttack = (EnemyAttacked)Delegate.Remove((Delegate?)(object)Enemy.OnEnemyAttack, (Delegate?)new EnemyAttacked(OnEnemyAttack));
		}

		private void OnEnemySpawned(Enemy enemy)
		{
			if (IsHosting)
			{
				ApplyCoopScaling(enemy);
				_registry.Dispatch(new EnemySpawnedEvent
				{
					EnemyId = _enemyIdentifier.GetId(enemy),
					LocKey = enemy.locKey,
					CurrentHealth = enemy.CurrentHealth,
					MaxHealth = enemy.maxHealth,
					SlotIndex = -1,
					MeleeDamage = enemy.DamagePerMeleeAttack,
					RangedDamage = enemy.DamagePerRangedAttack
				});
			}
		}

		private void ApplyCoopScaling(Enemy enemy)
		{
			int playerCount = PlayerCount;
			float num = ((playerCount <= 1) ? 1f : (playerCount switch
			{
				2 => 1.75f, 
				3 => 2.25f, 
				_ => 2.5f, 
			}));
			float num2 = num;
			if (num2 == 1f)
			{
				return;
			}
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(Enemy), "_maxHealth");
				float maxHealth = enemy.maxHealth;
				float num3 = maxHealth * num2;
				fieldInfo?.SetValue(enemy, num3);
				enemy.CurrentHealth = num3;
				_log.LogInfo((object)$"[EnemyScale] {((Object)enemy).name} players={playerCount} hp {maxHealth:F0}->{num3:F0}");
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[EnemyScale] failed to scale " + ((enemy != null) ? ((Object)enemy).name : null) + ": " + ex.Message));
			}
		}

		private void OnEnemyDamaged(Enemy enemy, long damage, EnemyDamageSource source)
		{
			//IL_0073: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Expected I4, but got Unknown
			if (!IsHosting)
			{
				return;
			}
			if (damage > 0 && _coopStateManager != null)
			{
				int slotIndex = ((DamageAttributionSlotOverride >= 0) ? DamageAttributionSlotOverride : _coopStateManager.ActivePlayerSlot);
				CoopPlayerState playerState = _coopStateManager.GetPlayerState(slotIndex);
				if (playerState != null)
				{
					playerState.DamageDealt += damage;
				}
			}
			_registry.Dispatch(new EnemyDamagedEvent
			{
				EnemyId = _enemyIdentifier.GetId(enemy),
				Damage = damage,
				DamageSource = (int)source,
				RemainingHealth = enemy.CurrentHealth
			});
		}

		private void OnEnemyDestroyed(Enemy enemy)
		{
			if (IsHosting)
			{
				_registry.Dispatch(new EnemyDestroyedEvent
				{
					EnemyId = _enemyIdentifier.GetId(enemy)
				});
			}
		}

		private void OnEnemyKilled(string locKey)
		{
			if (!IsHosting)
			{
				return;
			}
			string text = string.Empty;
			Enemy[] array = Object.FindObjectsOfType<Enemy>();
			foreach (Enemy val in array)
			{
				if ((Object)(object)val != (Object)null && val.locKey == locKey && val.CurrentHealth <= 0f)
				{
					text = _enemyIdentifier.GetOrAssignGuid(val);
					break;
				}
			}
			_log.LogInfo((object)("[EnemySub] EnemyKilled: loc=" + locKey + " guid=" + text));
			_registry.Dispatch(new EnemyKilledEvent
			{
				EnemyId = text,
				LocKey = locKey
			});
		}

		private void OnEnemyAttack(float damage, bool melee, Enemy enemy, DamageSource source, bool forceMaxHPDamage)
		{
			//IL_0034: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Expected I4, but got Unknown
			if (IsHosting)
			{
				_registry.Dispatch(new EnemyAttackEvent
				{
					EnemyId = _enemyIdentifier.GetId(enemy),
					Damage = damage,
					IsMelee = melee,
					DamageSource = (int)source
				});
			}
		}
	}
	public sealed class HealthSubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly ManualLogSource _log;

		private readonly CoopStateManager _coopStateManager;

		private static bool IsHosting
		{
			get
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return instance.IsHosting;
				}
				return false;
			}
		}

		public HealthSubscriptions(IGameEventRegistry registry, ManualLogSource log, CoopStateManager coopStateManager = null)
		{
			_registry = registry;
			_log = log;
			_coopStateManager = coopStateManager;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			PlayerHealthController.OnPlayerDamaged = (PlayerHealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnPlayerDamaged, (Delegate?)new PlayerHealthEvent(OnPlayerDamaged));
			PlayerHealthController.OnPlayerHealed = (PlayerHealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnPlayerHealed, (Delegate?)new PlayerHealthEvent(OnPlayerHealed));
			PlayerHealthController.OnArmourHit = (PlayerHealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnArmourHit, (Delegate?)new PlayerHealthEvent(OnArmourHit));
			PlayerHealthController.OnDodge = (PlayerHealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnDodge, (Delegate?)new PlayerHealthEvent(OnDodge));
			PlayerHealthController.OnHealthDepleted = (HealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnHealthDepleted, (Delegate?)new HealthEvent(OnHealthDepleted));
			PlayerHealthController.OnPlayerMaxHealthChanged = (PlayerHealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnPlayerMaxHealthChanged, (Delegate?)new PlayerHealthEvent(OnMaxHealthChanged));
			_log.LogInfo((object)"HealthSubscriptions registered");
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b6: Expected O, but got Unknown
			//IL_00b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c0: Expected O, but got Unknown
			PlayerHealthController.OnPlayerDamaged = (PlayerHealthEvent)Delegate.Remove((Delegate?)(object)PlayerHealthController.OnPlayerDamaged, (Delegate?)new PlayerHealthEvent(OnPlayerDamaged));
			PlayerHealthController.OnPlayerHealed = (PlayerHealthEvent)Delegate.Remove((Delegate?)(object)PlayerHealthController.OnPlayerHealed, (Delegate?)new PlayerHealthEvent(OnPlayerHealed));
			PlayerHealthController.OnArmourHit = (PlayerHealthEvent)Delegate.Remove((Delegate?)(object)PlayerHealthController.OnArmourHit, (Delegate?)new PlayerHealthEvent(OnArmourHit));
			PlayerHealthController.OnDodge = (PlayerHealthEvent)Delegate.Remove((Delegate?)(object)PlayerHealthController.OnDodge, (Delegate?)new PlayerHealthEvent(OnDodge));
			PlayerHealthController.OnHealthDepleted = (HealthEvent)Delegate.Remove((Delegate?)(object)PlayerHealthController.OnHealthDepleted, (Delegate?)new HealthEvent(OnHealthDepleted));
			PlayerHealthController.OnPlayerMaxHealthChanged = (PlayerHealthEvent)Delegate.Remove((Delegate?)(object)PlayerHealthController.OnPlayerMaxHealthChanged, (Delegate?)new PlayerHealthEvent(OnMaxHealthChanged));
		}

		private void OnPlayerDamaged(float amount)
		{
			if (IsHosting)
			{
				CoopSubscriptions.Instance?.HandleImmediateDamage(amount);
				_registry.Dispatch(new PlayerDamagedEvent
				{
					Damage = amount,
					RemainingHealth = GetCurrentHealth(),
					MaxHealth = GetMaxHealth()
				});
			}
		}

		private void OnPlayerHealed(float amount)
		{
			if (IsHosting)
			{
				CoopSubscriptions.Instance?.HandleImmediateHeal(amount);
				_registry.Dispatch(new PlayerHealedEvent
				{
					Amount = amount,
					RemainingHealth = GetCurrentHealth(),
					TargetSlotIndex = (_coopStateManager?.ActivePlayerSlot ?? (-1))
				});
			}
		}

		private void OnArmourHit(float amount)
		{
			if (IsHosting)
			{
				_registry.Dispatch(new ArmourHitEvent
				{
					Damage = amount
				});
			}
		}

		private void OnDodge(float info)
		{
			if (IsHosting)
			{
				_registry.Dispatch(new DodgeEvent
				{
					DodgeInfo = info
				});
			}
		}

		private void OnHealthDepleted()
		{
			if (IsHosting)
			{
				_registry.Dispatch(new HealthDepletedEvent());
			}
		}

		private void OnMaxHealthChanged(float newMax)
		{
			if (IsHosting)
			{
				_registry.Dispatch(new MaxHealthChangedEvent
				{
					NewMaxHealth = newMax
				});
			}
		}

		private static float GetCurrentHealth()
		{
			PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
			if (!((Object)(object)val != (Object)null))
			{
				return 0f;
			}
			return val.CurrentHealth;
		}

		private static float GetMaxHealth()
		{
			PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
			if (!((Object)(object)val != (Object)null))
			{
				return 0f;
			}
			return val.MaxHealth;
		}
	}
	public sealed class MapSubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly ManualLogSource _log;

		private static bool IsHosting
		{
			get
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return instance.IsHosting;
				}
				return false;
			}
		}

		public MapSubscriptions(IGameEventRegistry registry, ManualLogSource log)
		{
			_registry = registry;
			_log = log;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			MapController.OnNodeSelectionEvent = (NodeSelectionEvent)Delegate.Combine((Delegate?)(object)MapController.OnNodeSelectionEvent, (Delegate?)new NodeSelectionEvent(OnNodeSelected));
			_log.LogInfo((object)"MapSubscriptions registered");
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			MapController.OnNodeSelectionEvent = (NodeSelectionEvent)Delegate.Remove((Delegate?)(object)MapController.OnNodeSelectionEvent, (Delegate?)new NodeSelectionEvent(OnNodeSelected));
		}

		private void OnNodeSelected(string mapName, int floor, int cruciballLevel)
		{
			if (!IsHosting)
			{
				return;
			}
			try
			{
				_registry.Dispatch(new NodeSelectedEvent
				{
					MapName = mapName,
					Floor = floor,
					CruciballLevel = cruciballLevel
				});
			}
			catch (Exception arg)
			{
				_log.LogWarning((object)$"MapSubscriptions: NodeSelectedEvent dispatch threw: {arg}");
			}
		}
	}
	public sealed class PegSubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly ManualLogSource _log;

		private static bool IsHosting
		{
			get
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return instance.IsHosting;
				}
				return false;
			}
		}

		public PegSubscriptions(IGameEventRegistry registry, ManualLogSource log)
		{
			_registry = registry;
			_log = log;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			Peg.OnPegHit = (PegHitEvent)Delegate.Combine((Delegate?)(object)Peg.OnPegHit, (Delegate?)new PegHitEvent(OnPegHit));
			Peg.OnPegActivated = (PegHitEvent)Delegate.Combine((Delegate?)(object)Peg.OnPegActivated, (Delegate?)new PegHitEvent(OnPegActivated));
			Peg.OnPegDestroyed = (PegDestroyed)Delegate.Combine((Delegate?)(object)Peg.OnPegDestroyed, (Delegate?)new PegDestroyed(OnPegDestroyed));
			_log.LogInfo((object)"PegSubscriptions registered");
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			Peg.OnPegHit = (PegHitEvent)Delegate.Remove((Delegate?)(object)Peg.OnPegHit, (Delegate?)new PegHitEvent(OnPegHit));
			Peg.OnPegActivated = (PegHitEvent)Delegate.Remove((Delegate?)(object)Peg.OnPegActivated, (Delegate?)new PegHitEvent(OnPegActivated));
			Peg.OnPegDestroyed = (PegDestroyed)Delegate.Remove((Delegate?)(object)Peg.OnPegDestroyed, (Delegate?)new PegDestroyed(OnPegDestroyed));
		}

		private void OnPegHit(PegType pegType, Peg peg)
		{
			//IL_0105: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Expected I4, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0118: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Unknown result type (might be due to invalid IL or missing references)
			if (!IsHosting)
			{
				return;
			}
			Vector3 val = (((Object)(object)peg != (Object)null) ? ((Component)peg).transform.position : Vector3.zero);
			IServiceContainer services = MultiplayerPlugin.Services;
			PegIdentifier instance;
			PegIdentifier pegIdentifier = ((services != null && services.TryResolve<PegIdentifier>(out instance)) ? instance : null);
			int hitCount = -1;
			int coinCount = -1;
			int shieldHitCount = -1;
			int shieldHitLimit = -1;
			if ((Object)(object)peg != (Object)null)
			{
				try
				{
					Bomb val2 = (Bomb)(object)((peg is Bomb) ? peg : null);
					if (val2 != null)
					{
						hitCount = val2.HitCount;
					}
				}
				catch
				{
				}
				try
				{
					object? obj2 = AccessTools.Field(typeof(Peg), "PegCoinOverlayInstance")?.GetValue(peg);
					PegCoinOverlay val3 = (PegCoinOverlay)((obj2 is PegCoinOverlay) ? obj2 : null);
					if ((Object)(object)val3 != (Object)null)
					{
						coinCount = val3.NumCoins;
					}
				}
				catch
				{
				}
				try
				{
					object? obj4 = AccessTools.Field(typeof(Peg), "PegShieldOverlayInstance")?.GetValue(peg);
					PegShieldOverlay val4 = (PegShieldOverlay)((obj4 is PegShieldOverlay) ? obj4 : null);
					if ((Object)(object)val4 != (Object)null)
					{
						shieldHitCount = val4.hitCount;
						shieldHitLimit = val4.hitLimit;
					}
				}
				catch
				{
				}
			}
			_registry.Dispatch(new PegHitEvent
			{
				PegType = (int)pegType,
				PosX = val.x,
				PosY = val.y,
				PegGuid = pegIdentifier?.GetGuid(peg),
				HitCount = hitCount,
				CoinCount = coinCount,
				ShieldHitCount = shieldHitCount,
				ShieldHitLimit = shieldHitLimit
			});
		}

		private void OnPegActivated(PegType pegType, Peg peg)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0050: Expected I4, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (IsHosting)
			{
				Vector3 val = (((Object)(object)peg != (Object)null) ? ((Component)peg).transform.position : Vector3.zero);
				IServiceContainer services = MultiplayerPlugin.Services;
				PegIdentifier instance;
				PegIdentifier pegIdentifier = ((services != null && services.TryResolve<PegIdentifier>(out instance)) ? instance : null);
				_registry.Dispatch(new PegActivatedEvent
				{
					PegType = (int)pegType,
					PosX = val.x,
					PosY = val.y,
					PegGuid = pegIdentifier?.GetGuid(peg)
				});
			}
		}

		private void OnPegDestroyed(PegType pegType, Peg peg)
		{
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: 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_0050: Expected I4, but got Unknown
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			if (IsHosting)
			{
				Vector3 val = (((Object)(object)peg != (Object)null) ? ((Component)peg).transform.position : Vector3.zero);
				IServiceContainer services = MultiplayerPlugin.Services;
				PegIdentifier instance;
				PegIdentifier pegIdentifier = ((services != null && services.TryResolve<PegIdentifier>(out instance)) ? instance : null);
				_registry.Dispatch(new PegDestroyedEvent
				{
					PegType = (int)pegType,
					PosX = val.x,
					PosY = val.y,
					PegGuid = pegIdentifier?.GetGuid(peg)
				});
			}
		}
	}
	public sealed class RelicSubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly ManualLogSource _log;

		private static bool IsHosting
		{
			get
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance))
				{
					return instance.IsHosting;
				}
				return false;
			}
		}

		public RelicSubscriptions(IGameEventRegistry registry, ManualLogSource log)
		{
			_registry = registry;
			_log = log;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			RelicManager.OnRelicAdded = (RelicManagement)Delegate.Combine((Delegate?)(object)RelicManager.OnRelicAdded, (Delegate?)new RelicManagement(OnRelicAdded));
			RelicManager.OnRelicRemoved = (RelicManagement)Delegate.Combine((Delegate?)(object)RelicManager.OnRelicRemoved, (Delegate?)new RelicManagement(OnRelicRemoved));
			RelicManager.OnRelicUsed = (RelicManagement)Delegate.Combine((Delegate?)(object)RelicManager.OnRelicUsed, (Delegate?)new RelicManagement(OnRelicUsed));
			_log.LogInfo((object)"RelicSubscriptions registered");
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_004c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Expected O, but got Unknown
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Expected O, but got Unknown
			RelicManager.OnRelicAdded = (RelicManagement)Delegate.Remove((Delegate?)(object)RelicManager.OnRelicAdded, (Delegate?)new RelicManagement(OnRelicAdded));
			RelicManager.OnRelicRemoved = (RelicManagement)Delegate.Remove((Delegate?)(object)RelicManager.OnRelicRemoved, (Delegate?)new RelicManagement(OnRelicRemoved));
			RelicManager.OnRelicUsed = (RelicManagement)Delegate.Remove((Delegate?)(object)RelicManager.OnRelicUsed, (Delegate?)new RelicManagement(OnRelicUsed));
		}

		private void OnRelicAdded(Relic relic)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected I4, but got Unknown
			if (IsHosting)
			{
				_registry.Dispatch(new RelicAddedEvent
				{
					RelicEffect = (int)relic.effect,
					RelicName = relic.locKey
				});
			}
		}

		private void OnRelicRemoved(Relic relic)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected I4, but got Unknown
			if (IsHosting)
			{
				_registry.Dispatch(new RelicRemovedEvent
				{
					RelicEffect = (int)relic.effect
				});
			}
		}

		private void OnRelicUsed(Relic relic)
		{
			//IL_0015: Unknown result type (might be due to invalid IL or missing references)
			//IL_001f: Expected I4, but got Unknown
			if (IsHosting)
			{
				_registry.Dispatch(new RelicUsedEvent
				{
					RelicEffect = (int)relic.effect
				});
			}
		}
	}
	public sealed class StateSyncSubscriptions
	{
		private readonly IGameStateSyncService _sync;

		private readonly IMultiplayerMode _mode;

		private readonly ManualLogSource _log;

		public StateSyncSubscriptions(IGameStateSyncService sync, IMultiplayerMode mode, ManualLogSource log)
		{
			_sync = sync;
			_mode = mode;
			_log = log;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Expected O, but got Unknown
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0040: Expected O, but got Unknown
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0076: Expected O, but got Unknown
			//IL_0076: Unknown result type (might be due to invalid IL or missing references)
			//IL_0080: Expected O, but got Unknown
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0096: Expected O, but got Unknown
			//IL_0096: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a0: Expected O, but got Unknown
			//IL_00cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d6: Expected O, but got Unknown
			//IL_00d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e0: Expected O, but got Unknown
			//IL_00ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f6: Expected O, but got Unknown
			//IL_00f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0100: Expected O, but got Unknown
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0116: Expected O, but got Unknown
			//IL_0116: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Expected O, but got Unknown
			//IL_012c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Expected O, but got Unknown
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_0140: Expected O, but got Unknown
			//IL_014c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0156: Expected O, but got Unknown
			//IL_0156: Unknown result type (might be due to invalid IL or missing references)
			//IL_0160: Expected O, but got Unknown
			//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Expected O, but got Unknown
			//IL_01b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01c0: Expected O, but got Unknown
			//IL_01cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Expected O, but got Unknown
			//IL_01d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_01e0: Expected O, but got Unknown
			//IL_01ec: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f6: Expected O, but got Unknown
			//IL_01f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_0200: Expected O, but got Unknown
			//IL_020c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0216: Expected O, but got Unknown
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Expected O, but got Unknown
			//IL_024c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0256: Expected O, but got Unknown
			//IL_0256: Unknown result type (might be due to invalid IL or missing references)
			//IL_0260: Expected O, but got Unknown
			//IL_026c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0276: Expected O, but got Unknown
			//IL_0276: Unknown result type (might be due to invalid IL or missing references)
			//IL_0280: Expected O, but got Unknown
			//IL_02ac: Unknown result type (might be due to invalid IL or missing references)
			//IL_02b6: Expected O, but got Unknown
			//IL_02b6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c0: Expected O, but got Unknown
			//IL_02cc: Unknown result type (might be due to invalid IL or missing references)
			//IL_02d6: Expected O, but got Unknown
			//IL_02d6: Unknown result type (might be due to invalid IL or missing references)
			//IL_02e0: Expected O, but got Unknown
			BattleController.OnBattleStarted = (BattleEvent)Delegate.Combine((Delegate?)(object)BattleController.OnBattleStarted, (Delegate?)(BattleEvent)delegate
			{
				SafeSync("BattleStarted", delegate
				{
					_sync.SyncAll("BattleStarted");
				});
			});
			BattleController.OnRoundCountIncremented = (RoundCountIncremented)Delegate.Combine((Delegate?)(object)BattleController.OnRoundCountIncremented, (Delegate?)(RoundCountIncremented)delegate
			{
				SafeSync("RoundIncremented", delegate
				{
					_sync.SyncAll("RoundIncremented");
				});
			});
			BattleController.OnTurnComplete = (Action)Delegate.Combine(BattleController.OnTurnComplete, (Action)delegate
			{
				SafeSync("TurnComplete", delegate
				{
					_sync.SyncEnemies();
					_sync.SyncPlayer();
				});
			});
			BattleController.OnReloadStarted = (ReloadStarted)Delegate.Combine((Delegate?)(object)BattleController.OnReloadStarted, (Delegate?)(ReloadStarted)delegate
			{
				SafeSync("ReloadStarted", delegate
				{
					_sync.SyncPegboard();
					_sync.SyncEnemies();
					_sync.SyncPlayer();
				});
			});
			BattleController.OnPreRefreshActivated = (PreRefreshActivated)Delegate.Combine((Delegate?)(object)BattleController.OnPreRefreshActivated, (Delegate?)(PreRefreshActivated)delegate
			{
				SafeSync("PreRefresh", delegate
				{
					_sync.SyncPegboard();
				});
			});
			BattleController.OnAttackStarted = (Action)Delegate.Combine(BattleController.OnAttackStarted, (Action)delegate
			{
				SafeSync("AttackStarted", delegate
				{
					_sync.SyncEnemies();
					_sync.SyncPlayer();
				});
			});
			PlayerHealthController.OnPlayerDamaged = (PlayerHealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnPlayerDamaged, (Delegate?)(PlayerHealthEvent)delegate
			{
				SafeSync("PlayerDamaged", delegate
				{
					_sync.SyncPlayer();
				});
			});
			PlayerHealthController.OnPlayerHealed = (PlayerHealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnPlayerHealed, (Delegate?)(PlayerHealthEvent)delegate
			{
				SafeSync("PlayerHealed", delegate
				{
					_sync.SyncPlayer();
				});
			});
			PlayerHealthController.OnPlayerMaxHealthChanged = (PlayerHealthEvent)Delegate.Combine((Delegate?)(object)PlayerHealthController.OnPlayerMaxHealthChanged, (Delegate?)(PlayerHealthEvent)delegate
			{
				SafeSync("PlayerMaxHealthChanged", delegate
				{
					_sync.SyncPlayer();
				});
			});
			BattleController.OnShotComplete = (ShotComplete)Delegate.Combine((Delegate?)(object)BattleController.OnShotComplete, (Delegate?)(ShotComplete)delegate
			{
				SafeSync("ShotComplete", delegate
				{
					_sync.SyncPegboard();
					_sync.SyncEnemies();
					_sync.SyncDeck();
				});
			});
			Peg.OnPegDestroyed = (PegDestroyed)Delegate.Combine((Delegate?)(object)Peg.OnPegDestroyed, (Delegate?)(PegDestroyed)delegate
			{
				SafeSync("PegDestroyed", delegate
				{
					_sync.SyncPegboard();
				});
			});
			BattleController.OnBombDetonated = (Action)Delegate.Combine(BattleController.OnBombDetonated, (Action)delegate
			{
				SafeSync("BombDetonated", delegate
				{
					_sync.SyncPegboard();
				});
			});
			BattleController.OnBombThrown = (Action)Delegate.Combine(BattleController.OnBombThrown, (Action)delegate
			{
				SafeSync("BombThrown", delegate
				{
					_sync.SyncPegboard();
				});
			});
			BattleController.onCriticalHitActivated = (CriticalHitActivated)Delegate.Combine((Delegate?)(object)BattleController.onCriticalHitActivated, (Delegate?)(CriticalHitActivated)delegate
			{
				SafeSync("CritActivated", delegate
				{
					_sync.SyncPegboard();
				});
			});
			BattleController.onCriticalHitDeactivated = (CriticalHitActivated)Delegate.Combine((Delegate?)(object)BattleController.onCriticalHitDeactivated, (Delegate?)(CriticalHitActivated)delegate
			{
				SafeSync("CritDeactivated", delegate
				{
					_sync.SyncPegboard();
				});
			});
			BattleController.onRefreshPotionActivated = (RefreshPotionActivated)Delegate.Combine((Delegate?)(object)BattleController.onRefreshPotionActivated, (Delegate?)(RefreshPotionActivated)delegate
			{
				SafeSync("RefreshPotion", delegate
				{
					_sync.SyncPegboard();
				});
			});
			DeckManager.onBallUsed = (BallDrawn)Delegate.Combine((Delegate?)(object)DeckManager.onBallUsed, (Delegate?)(BallDrawn)delegate
			{
				SafeSync("BallUsed", delegate
				{
					_sync.SyncDeck();
				});
			});
			BattleController.OnVictory = (Action)Delegate.Combine(BattleController.OnVictory, (Action)delegate
			{
				SafeSync("Victory", delegate
				{
					_sync.SyncAll("Victory");
				});
			});
			MapController.OnNodeSelectionEvent = (NodeSelectionEvent)Delegate.Combine((Delegate?)(object)MapController.OnNodeSelectionEvent, (Delegate?)(NodeSelectionEvent)delegate
			{
				SafeSync("NodeSelected", delegate
				{
					_sync.SyncMap();
				});
			});
			DeckManager.onDeckShuffled = (Shuffled)Delegate.Combine((Delegate?)(object)DeckManager.onDeckShuffled, (Delegate?)(Shuffled)delegate
			{
				SafeSync("DeckShuffled", delegate
				{
					_sync.SyncDeck();
				});
			});
			DeckManager.onDeckSizeChanged = (Action)Delegate.Combine(DeckManager.onDeckSizeChanged, (Action)delegate
			{
				SafeSync("DeckSizeChanged", delegate
				{
					_sync.SyncDeck();
				});
			});
			RelicManager.OnRelicAdded = (RelicManagement)Delegate.Combine((Delegate?)(object)RelicManager.OnRelicAdded, (Delegate?)(RelicManagement)delegate
			{
				SafeSync("RelicAdded", delegate
				{
					_sync.SyncRelics();
				});
			});
			RelicManager.OnRelicRemoved = (RelicManagement)Delegate.Combine((Delegate?)(object)RelicManager.OnRelicRemoved, (Delegate?)(RelicManagement)delegate
			{
				SafeSync("RelicRemoved", delegate
				{
					_sync.SyncRelics();
				});
			});
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode loadMode)
			{
				//IL_000e: Unknown result type (might be due to invalid IL or missing references)
				//IL_000f: Unknown result type (might be due to invalid IL or missing references)
				//IL_0014: Unknown result type (might be due to invalid IL or missing references)
				if ((int)loadMode == 0)
				{
					SafeSync("SceneLoaded:" + ((Scene)(ref scene)).name, delegate
					{
						_sync.SyncAll("SceneLoaded:" + ((Scene)(ref scene)).name);
					});
				}
			};
			_log.LogInfo((object)"StateSyncSubscriptions registered (event-driven sync + self-contained heartbeat in MainThreadDispatcher)");
		}

		private void SafeSync(string trigger, Action action)
		{
			if (!_mode.IsHosting)
			{
				return;
			}
			try
			{
				action();
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("StateSync[" + trigger + "] failed: " + ex.Message));
			}
		}
	}
	public sealed class StatusEffectEventSubscriptions
	{
		private readonly IGameEventRegistry _registry;

		private readonly IMultiplayerMode _multiplayerMode;

		public StatusEffectEventSubscriptions(IGameEventRegistry registry, IMultiplayerMode multiplayerMode)
		{
			_registry = registry;
			_multiplayerMode = multiplayerMode;
		}

		public void Subscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			PlayerStatusEffectController.OnPlayerStatusEffectsUpdated = (PlayerStatusEffectsUpdated)Delegate.Combine((Delegate?)(object)PlayerStatusEffectController.OnPlayerStatusEffectsUpdated, (Delegate?)new PlayerStatusEffectsUpdated(OnStatusUpdated));
		}

		public void Unsubscribe()
		{
			//IL_000c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0016: Expected O, but got Unknown
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_0020: Expected O, but got Unknown
			PlayerStatusEffectController.OnPlayerStatusEffectsUpdated = (PlayerStatusEffectsUpdated)Delegate.Remove((Delegate?)(object)PlayerStatusEffectController.OnPlayerStatusEffectsUpdated, (Delegate?)new PlayerStatusEffectsUpdated(OnStatusUpdated));
		}

		private void OnStatusUpdated()
		{
			if (_multiplayerMode.IsHosting)
			{
				_registry.Dispatch(new StatusEffectsUpdatedEvent());
			}
		}
	}
}
namespace Multipeglin.Events.Subscriptions.Coop
{
	internal sealed class BattleControllerUpdateManager : IBattleControllerUpdateManager
	{
		private static readonly FieldInfo PegTallyField = AccessTools.Field(typeof(BattleController), "_pegMultiplierDamageTally");

		private static readonly FieldInfo CritField = AccessTools.Field(typeof(BattleController), "_criticalHitCount");

		private static readonly FieldInfo NumPegsField = AccessTools.Field(typeof(BattleController), "_numPegsHit");

		private static readonly FieldInfo CactusField = AccessTools.Field(typeof(BattleController), "_cactusDamageTally");

		private static readonly FieldInfo DamageMultField = AccessTools.Field(typeof(BattleController), "_damageMultiplier");

		private static readonly FieldInfo DamageBonusField = AccessTools.Field(typeof(BattleController), "_damageBonus");

		private static readonly FieldInfo ActiveBallField = AccessTools.Field(typeof(BattleController), "_activePachinkoBall");

		private static readonly FieldInfo RemainingBallsField = AccessTools.Field(typeof(BattleController), "_remainingPachinkoBalls");

		private static readonly FieldInfo AttackManagerField = AccessTools.Field(typeof(BattleController), "_attackManager");

		private static readonly FieldInfo DeckManagerField = AccessTools.Field(typeof(BattleController), "_deckManager");

		private static readonly FieldInfo RelicManagerField = AccessTools.Field(typeof(BattleController), "_relicManager");

		private static readonly FieldInfo CruciballManagerField = AccessTools.Field(typeof(BattleController), "_cruciballManager");

		private static readonly FieldInfo PlayerHealthField = AccessTools.Field(typeof(BattleController), "_playerHealthController");

		private static readonly FieldInfo PlayerStatusField = AccessTools.Field(typeof(BattleController), "_playerStatusEffectController");

		private static readonly FieldInfo PlayerTransformField = AccessTools.Field(typeof(BattleController), "_playerTransform");

		private static readonly FieldInfo AttackManagerAttackField = AccessTools.Field(typeof(AttackManager), "_attack");

		private static readonly MethodInfo DrawBallMethod = AccessTools.Method(typeof(BattleController), "DrawBall", (Type[])null, (Type[])null);

		public BattleController GetBattleController()
		{
			return Object.FindObjectOfType<BattleController>();
		}

		public int GetPegMultiplierDamageTally(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null) || !(PegTallyField != null))
			{
				return 0;
			}
			return (int)PegTallyField.GetValue(bc);
		}

		public int GetCriticalHitCount()
		{
			if (!(CritField != null))
			{
				return 0;
			}
			return (int)CritField.GetValue(null);
		}

		public int GetNumPegsHit(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null) || !(NumPegsField != null))
			{
				return 0;
			}
			return (int)NumPegsField.GetValue(bc);
		}

		public int GetCactusDamageTally(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null) || !(CactusField != null))
			{
				return 0;
			}
			return (int)CactusField.GetValue(bc);
		}

		public float GetDamageMultiplier(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null) || !(DamageMultField != null))
			{
				return 1f;
			}
			return (float)DamageMultField.GetValue(bc);
		}

		public long GetDamageBonus(BattleController bc)
		{
			return ((Object)(object)bc != (Object)null && DamageBonusField != null) ? ((int)DamageBonusField.GetValue(bc)) : 0;
		}

		public void SetPegMultiplierDamageTally(BattleController bc, int value)
		{
			PegTallyField?.SetValue(bc, value);
		}

		public void SetCriticalHitCount(int value)
		{
			CritField?.SetValue(null, value);
		}

		public void SetNumPegsHit(BattleController bc, int value)
		{
			NumPegsField?.SetValue(bc, value);
		}

		public void SetCactusDamageTally(BattleController bc, int value)
		{
			CactusField?.SetValue(bc, value);
		}

		public void SetDamageMultiplier(BattleController bc, float value)
		{
			DamageMultField?.SetValue(bc, value);
		}

		public void SetDamageBonus(BattleController bc, long value)
		{
			DamageBonusField?.SetValue(bc, (int)value);
		}

		public void ResetShotTallies(BattleController bc)
		{
			if (!((Object)(object)bc == (Object)null))
			{
				PegTallyField?.SetValue(bc, 0);
				CritField?.SetValue(null, 0);
				NumPegsField?.SetValue(bc, 0);
				CactusField?.SetValue(bc, 0);
				DamageMultField?.SetValue(bc, 1f);
				DamageBonusField?.SetValue(bc, 0);
			}
		}

		public void WriteShotTallies(BattleController bc, int pegTally, int crits, int numPegs, int cactus, float dmgMult, long dmgBonus)
		{
			if (!((Object)(object)bc == (Object)null))
			{
				PegTallyField?.SetValue(bc, pegTally);
				CritField?.SetValue(null, crits);
				NumPegsField?.SetValue(bc, numPegs);
				CactusField?.SetValue(bc, cactus);
				DamageMultField?.SetValue(bc, dmgMult);
				DamageBonusField?.SetValue(bc, (int)dmgBonus);
			}
		}

		public GameObject GetActivePachinkoBall(BattleController bc)
		{
			if ((Object)(object)bc == (Object)null)
			{
				return null;
			}
			object? obj = ActiveBallField?.GetValue(bc);
			return (GameObject)((obj is GameObject) ? obj : null);
		}

		public void DestroyActivePachinkoBall(BattleController bc)
		{
			if (!((Object)(object)bc == (Object)null) && !(ActiveBallField == null))
			{
				object? value = ActiveBallField.GetValue(bc);
				GameObject val = (GameObject)((value is GameObject) ? value : null);
				if (val != null)
				{
					Object.Destroy((Object)(object)val);
				}
				ActiveBallField.SetValue(bc, null);
			}
		}

		public void SetRemainingPachinkoBalls(BattleController bc, int value)
		{
			RemainingBallsField?.SetValue(bc, value);
		}

		public AttackManager GetAttackManager(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null))
			{
				return null;
			}
			object? obj = AttackManagerField?.GetValue(bc);
			return (AttackManager)((obj is AttackManager) ? obj : null);
		}

		public Attack GetCurrentAttack(AttackManager am)
		{
			if (!((Object)(object)am != (Object)null))
			{
				return null;
			}
			object? obj = AttackManagerAttackField?.GetValue(am);
			return (Attack)((obj is Attack) ? obj : null);
		}

		public void SetCurrentAttack(AttackManager am, Attack attack)
		{
			if (!((Object)(object)am == (Object)null))
			{
				AttackManagerAttackField?.SetValue(am, attack);
			}
		}

		public DeckManager GetDeckManager(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null))
			{
				return null;
			}
			object? obj = DeckManagerField?.GetValue(bc);
			return (DeckManager)((obj is DeckManager) ? obj : null);
		}

		public RelicManager GetRelicManager(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null))
			{
				return null;
			}
			object? obj = RelicManagerField?.GetValue(bc);
			return (RelicManager)((obj is RelicManager) ? obj : null);
		}

		public CruciballManager GetCruciballManager(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null))
			{
				return null;
			}
			object? obj = CruciballManagerField?.GetValue(bc);
			return (CruciballManager)((obj is CruciballManager) ? obj : null);
		}

		public PlayerHealthController GetPlayerHealthController(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null))
			{
				return null;
			}
			object? obj = PlayerHealthField?.GetValue(bc);
			return (PlayerHealthController)((obj is PlayerHealthController) ? obj : null);
		}

		public PlayerStatusEffectController GetPlayerStatusEffectController(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null))
			{
				return null;
			}
			object? obj = PlayerStatusField?.GetValue(bc);
			return (PlayerStatusEffectController)((obj is PlayerStatusEffectController) ? obj : null);
		}

		public Transform GetPlayerTransform(BattleController bc)
		{
			if (!((Object)(object)bc != (Object)null))
			{
				return null;
			}
			object? obj = PlayerTransformField?.GetValue(bc);
			return (Transform)((obj is Transform) ? obj : null);
		}

		public void SetBattleState(BattleState state)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			BattleController.CurrentBattleState = state;
		}

		public void InvokeDrawBall(BattleController bc)
		{
			if (!((Object)(object)bc == (Object)null) && !(DrawBallMethod == null))
			{
				DrawBallMethod.Invoke(bc, null);
			}
		}
	}
	internal sealed class BuffApplier : IBuffApplier
	{
		private readonly ManualLogSource _log;

		public BuffApplier(ManualLogSource log)
		{
			_log = log;
		}

		public float ApplyDefensiveBuffs(CoopPlayerState state, float rawDamage)
		{
			float num = rawDamage;
			int effectIntensity = GetEffectIntensity(state, 30);
			int effectIntensity2 = GetEffectIntensity(state, 31);
			int effectIntensity3 = GetEffectIntensity(state, 12);
			if (effectIntensity > 0 && num > 0f)
			{
				float num2 = (float)effectIntensity * StatusEffectData.BALLUSION_EVASION_PER_STACK;
				float value = Random.value;
				if (value < num2)
				{
					float num3 = StatusEffectData.BALLUSION_REDUCTION_PERCENTAGE;
					if (HasRelic(state, (RelicEffect)145) || HasRelic(state, (RelicEffect)202))
					{
						num3 -= 0.1f;
					}
					if (HasRelic(state, (RelicEffect)146))
					{
						num3 *= 2f;
					}
					float num4 = Mathf.Clamp(1f - num3, 0f, 1f);
					int num5 = Mathf.RoundToInt((float)effectIntensity * num4);
					SetEffectIntensity(state, 30, num5);
					_log.LogInfo((object)$"[CoopSubs] Slot {state.SlotIndex} DODGED (Ballusion {effectIntensity}->{num5}, roll={value:F3} < {num2:F3})");
					num = 0f;
				}
			}
			if (effectIntensity2 > 0 && num > 0f)
			{
				num = Mathf.Min(num, (float)effectIntensity2);
			}
			if (effectIntensity3 > 0 && num > 0f)
			{
				float num6 = effectIntensity3;
				if (num6 >= num)
				{
					num6 -= num;
					num = 0f;
				}
				else
				{
					num -= num6;
					num6 = 0f;
				}
				SetEffectIntensity(state, 12, Mathf.RoundToInt(num6));
				_log.LogInfo((object)$"[CoopSubs] Slot {state.SlotIndex} Ballwark absorbed: {effectIntensity3}->{Mathf.RoundToInt(num6)}");
			}
			return Mathf.Max(0f, num);
		}

		private static int GetEffectIntensity(CoopPlayerState state, int effectType)
		{
			foreach (SerializedStatusEffect statusEffect in state.StatusEffects)
			{
				if (statusEffect.EffectType == effectType)
				{
					return statusEffect.Intensity;
				}
			}
			return 0;
		}

		private static void SetEffectIntensity(CoopPlayerState state, int effectType, int intensity)
		{
			for (int i = 0; i < state.StatusEffects.Count; i++)
			{
				if (state.StatusEffects[i].EffectType == effectType)
				{
					if (intensity <= 0)
					{
						state.StatusEffects.RemoveAt(i);
					}
					else
					{
						state.StatusEffects[i].Intensity = intensity;
					}
					return;
				}
			}
			if (intensity > 0)
			{
				state.StatusEffects.Add(new SerializedStatusEffect
				{
					EffectType = effectType,
					Intensity = intensity
				});
			}
		}

		private static bool HasRelic(CoopPlayerState state, RelicEffect effect)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Expected I4, but got Unknown
			int num = (int)effect;
			foreach (SerializedRelic ownedRelic in state.OwnedRelics)
			{
				if (ownedRelic.Effect == num)
				{
					return true;
				}
			}
			return false;
		}
	}
	internal sealed class CoopDeckManager : ICoopDeckManager
	{
		private readonly ManualLogSource _log;

		public CoopDeckManager(ManualLogSource log)
		{
			_log = log;
		}

		public bool EnsureBattleDeckPopulated(string context)
		{
			try
			{
				DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
				if (array == null || array.Length == 0)
				{
					return false;
				}
				DeckManager val = array[0];
				bool flag = val.battleDeck != null && val.battleDeck.Count > 0;
				bool flag2 = val.shuffledDeck != null && val.shuffledDeck.Count > 0;
				if (flag && flag2)
				{
					return true;
				}
				if (flag && !flag2)
				{
					_log.LogInfo((object)$"[CoopSubs] {context}: battleDeck has {val.battleDeck.Count} orbs but shuffledDeck empty — re-shuffling");
					val.ShuffleBattleDeck();
				}
				else if (!flag && DeckManager.completeDeck != null && DeckManager.completeDeck.Count > 0)
				{
					_log.LogInfo((object)$"[CoopSubs] {context}: battleDeck empty, initializing from completeDeck ({DeckManager.completeDeck.Count} orbs)");
					MethodInfo methodInfo = AccessTools.Method(typeof(DeckManager), "ShuffleCompleteDeck", new Type[1] { typeof(bool) }, (Type[])null);
					if (methodInfo != null)
					{
						methodInfo.Invoke(val, new object[1] { true });
						_log.LogInfo((object)$"[CoopSubs] {context}: after ShuffleCompleteDeck(true): battleDeck={val.battleDeck?.Count ?? 0}, shuffledDeck={val.shuffledDeck?.Count ?? 0}");
					}
					else
					{
						_log.LogWarning((object)("[CoopSubs] " + context + ": ShuffleCompleteDeck not found, manually copying completeDeck to battleDeck"));
						if (val.battleDeck == null)
						{
							val.battleDeck = new List<GameObject>();
						}
						foreach (GameObject item in DeckManager.completeDeck)
						{
							if ((Object)(object)item != (Object)null)
							{
								GameObject val2 = Object.Instantiate<GameObject>(item);
								((Object)val2).name = ((Object)item).name;
								val2.SetActive(false);
								val.battleDeck.Add(val2);
							}
						}
						val.ShuffleBattleDeck();
						_log.LogInfo((object)$"[CoopSubs] {context}: after fallback shuffle: battleDeck={val.battleDeck?.Count ?? 0}, shuffledDeck={val.shuffledDeck?.Count ?? 0}");
					}
				}
				return val.battleDeck != null && val.battleDeck.Count > 0 && val.shuffledDeck != null && val.shuffledDeck.Count > 0;
			}
			catch (Exception ex)
			{
				_log.LogWarning((object)("[CoopSubs] EnsureBattleDeckPopulated (" + context + ") failed: " + ex.Message));
				return false;
			}
		}

		public void ApplyNonHostStartingBonuses(int slot)
		{
			try
			{
				RelicManager val = Resources.FindObjectsOfTypeAll<RelicManager>()?.FirstOrDefault();
				if ((Object)(object)val != (Object)null)
				{
					try
					{
						val.ResetBattleRelics();
					}
					catch (Exception ex)
					{
						_log.LogWarning((object)$"[CoopSubs] ResetBattleRelics for slot {slot} failed: {ex.Message}");
					}
				}
				PlayerStatusEffectController val2 = Object.FindObjectOfType<PlayerStatusEffectController>();
				if ((Object)(object)val2 == (Object)null)
				{
					_log.LogWarning((object)$"[CoopSubs] ApplyNonHostStartingBonuses: PlayerStatusEffectController not found for slot {slot}");
					return;
				}
				val2.ApplyStartingBonuses();
				_log.LogInfo((object)$"[CoopSubs] Applied starting bonuses for slot {slot}");
			}
			catch (Exception ex2)
			{
				_log.LogWarning((object)$"[CoopSubs] ApplyNonHostStartingBonuses for slot {slot} failed: {ex2.Message}");
			}
		}
	}
	public interface IBattleControllerUpdateManager
	{
		BattleController GetBattleController();

		int GetPegMultiplierDamageTally(BattleController bc);

		int GetCriticalHitCount();

		int GetNumPegsHit(BattleController bc);

		int GetCactusDamageTally(BattleController bc);

		float GetDamageMultiplier(BattleController bc);

		long GetDamageBonus(BattleController bc);

		void SetPegMultiplierDamageTally(BattleController bc, int value);

		void SetCriticalHitCount(int value);

		void SetNumPegsHit(BattleController bc, int value);

		void SetCactusDamageTally(BattleController bc, int value);

		void SetDamageMultiplier(BattleController bc, float value);

		void SetDamageBonus(BattleController bc, long value);

		void ResetShotTallies(BattleController bc);

		void WriteShotTallies(BattleController bc, int pegTally, int crits, int numPegs, int cactus, float dmgMult, long dmgBonus);

		GameObject GetActivePachinkoBall(BattleController bc);

		void DestroyActivePachinkoBall(BattleController bc);

		void SetRemainingPachinkoBalls(BattleController bc, int value);

		AttackManager GetAttackManager(BattleController bc);

		Attack GetCurrentAttack(AttackManager am);

		void SetCurrentAttack(AttackManager am, Attack attack);

		DeckManager GetDeckManager(BattleController bc);

		RelicManager GetRelicManager(BattleController bc);

		CruciballManager GetCruciballManager(BattleController bc);

		PlayerHealthController GetPlayerHealthController(BattleController bc);

		PlayerStatusEffectController GetPlayerStatusEffectController(BattleController bc);

		Transform GetPlayerTransform(BattleController bc);

		void SetBattleState(BattleState state);

		void InvokeDrawBall(BattleController bc);
	}
	public interface IBuffApplier
	{
		float ApplyDefensiveBuffs(CoopPlayerState state, float rawDamage);
	}
	public interface ICoopDeckManager
	{
		bool EnsureBattleDeckPopulated(string context);

		void ApplyNonHostStartingBonuses(int slot);
	}
	public interface IOrbStatusEffectApplier
	{
		List<(StatusEffectType Type, int Intensity)> CaptureOrbStatusEffects(Attack attack, int critCount);

		void ApplySelfPostAttackBuffs(Attack attack, int critCount, int slotIndex);

		void RestoreAttackFromPrefab(BattleController bc, GameObject orbPrefab, string label);

		void CleanupTempOrb();
	}
	internal sealed class OrbStatusEffectApplier : IOrbStatusEffectApplier
	{
		private readonly IBattleControllerUpdateManager _bcUpdater;

		private readonly ManualLogSource _log;

		private GameObject _tempOrbInstance;

		public OrbStatusEffectApplier(IBattleControllerUpdateManager bcUpdater, ManualLogSource log)
		{
			_bcUpdater = bcUpdater;
			_log = log;
		}

		public List<(StatusEffectType Type, int Intensity)> CaptureOrbStatusEffects(Attack attack, int critCount)
		{
			//IL_0026: 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_002f: Unknown result type (might be due to invalid IL or missing references)
			List<(StatusEffectType, int)> list = new List<(StatusEffectType, int)>();
			try
			{
				try
				{
					List<StatusEffect> statusEffects = attack.GetStatusEffects(critCount);
					if (statusEffects != null)
					{
						foreach (StatusEffect item in statusEffects)
						{
							if (item != null && (int)item.EffectType != 0)
							{
								list.Add((item.EffectType, item.Intensity));
							}
						}
					}
				}
				catch (Exception ex)
				{
					ManualLogSource log = _log;
					if (log != null)
					{
						log.LogWarning((object)("[CoopSubs] attack.GetStatusEffects failed: " + ex.Message));
					}
				}
				AddStatusEffectOnHit[] components = ((Component)attack).GetComponents<AddStatusEffectOnHit>();
				foreach (AddStatusEffectOnHit val in components)
				{
					int num = val.intensity;
					if (val.isCritThresholdCumulative && val.critCountThreshold > 0)
					{
						num += critCount / val.critCountThreshold * val.critAddIntensity;
					}
					else if (val.critCountThreshold <= critCount)
					{
						num += val.critAddIntensity;
					}
					list.Add((val.type, num));
				}
				AddRandomStatusEffectOnHit[] components2 = ((Component)attack).GetComponents<AddRandomStatusEffectOnHit>();
				for (int i = 0; i < components2.Length; i++)
				{
					_ = components2[i];
					int num2 = Random.Range(0, AddRandomStatusEffectOnHit.RoundreloquencePotentialEffects.Length);
					list.Add((AddRandomStatusEffectOnHit.RoundreloquencePotentialEffects[num2], AddRandomStatusEffectOnHit.RoundreloquenceEffectIntensity[num2]));
				}
				if (list.Count > 0)
				{
					ManualLogSource log2 = _log;
					if (log2 != null)
					{
						log2.LogInfo((object)($"[CoopSubs] Captured {list.Count} status effect(s) from orb " + "(" + ((object)attack).GetType().Name + "): " + string.Join(", ", list.Select(((StatusEffectType, int) e) => $"{e.Item1}({e.Item2})"))));
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource log3 = _log;
				if (log3 != null)
				{
					log3.LogWarning((object)("[CoopSubs] CaptureOrbStatusEffects failed: " + ex2.Message));
				}
			}
			if (list.Count <= 0)
			{
				return null;
			}
			return list;
		}

		public void ApplySelfPostAttackBuffs(Attack attack, int critCount, int slotIndex)
		{
			try
			{
				PlayerStatusEffectController val = Object.FindObjectOfType<PlayerStatusEffectController>();
				if ((Object)(object)val == (Object)null)
				{
					return;
				}
				int num = 0;
				int num2 = 0;
				GrantStatusAfterAttack[] components = ((Component)attack).GetComponents<GrantStatusAfterAttack>();
				foreach (GrantStatusAfterAttack val2 in components)
				{
					try
					{
						val2.HandleAttackFinished(val);
						num++;
					}
					catch (Exception ex)
					{
						ManualLogSource log = _log;
						if (log != null)
						{
							log.LogWarning((object)("[CoopSubs] GrantStatusAfterAttack.HandleAttackFinished failed: " + ex.Message));
						}
					}
				}
				GrantStatusAfterAttackPerShieldPeg[] components2 = ((Component)attack).GetComponents<GrantStatusAfterAttackPerShieldPeg>();
				foreach (GrantStatusAfterAttackPerShieldPeg val3 in components2)
				{
					try
					{
						val3.HandleAttackFinished(val);
						num2++;
					}
					catch (Exception ex2)
					{
						ManualLogSource log2 = _log;
						if (log2 != null)
						{
							log2.LogWarning((object)("[CoopSubs] GrantStatusAfterAttackPerShieldPeg.HandleAttackFinished failed: " + ex2.Message));
						}
					}
				}
				if (num > 0 || num2 > 0)
				{
					ManualLogSource log3 = _log;
					if (log3 != null)
					{
						log3.LogInfo((object)($"[CoopSubs] Applied self-buffs for slot {slotIndex}: " + $"GrantStatusAfterAttack={num}, GrantStatusAfterAttackPerShieldPeg={num2}, crits={critCount}"));
					}
				}
			}
			catch (Exception ex3)
			{
				ManualLogSource log4 = _log;
				if (log4 != null)
				{
					log4.LogWarning((object)("[CoopSubs] ApplySelfPostAttackBuffs failed: " + ex3.Message));
				}
			}
		}

		public void RestoreAttackFromPrefab(BattleController bc, GameObject orbPrefab, string label)
		{
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_010b: Unknown result type (might be due to invalid IL or missing references)
			//IL_010e: Unknown result type (might be due to invalid IL or missing references)
			//IL_01a5: Unknown result type (might be due to invalid IL or missing references)
			CleanupTempOrb();
			_tempOrbInstance = Object.Instantiate<GameObject>(orbPrefab, new Vector3(-999f, -999f, 0f), Quaternion.identity);
			((Object)_tempOrbInstance).name = "CoopTempOrb_" + label;
			Attack component = _tempOrbInstance.GetComponent<Attack>();
			if ((Object)(object)component == (Object)null)
			{
				ManualLogSource log = _log;
				if (log != null)
				{
					log.LogWarning((object)("[CoopSubs] Prefab '" + ((Object)orbPrefab).name + "' has no Attack component!"));
				}
				Object.Destroy((Object)(object)_tempOrbInstance);
				_tempOrbInstance = null;
				return;
			}
			AttackManager attackManager = _bcUpdater.GetAttackManager(bc);
			DeckManager deckManager = _bcUpdater.GetDeckManager(bc);
			RelicManager relicManager = _bcUpdater.GetRelicManager(bc);
			CruciballManager cruciballManager = _bcUpdater.GetCruciballManager(bc);
			PlayerHealthController playerHealthController = _bcUpdater.GetPlayerHealthController(bc);
			PlayerStatusEffectController playerStatusEffectController = _bcUpdater.GetPlayerStatusEffectController(bc);
			Transform playerTransform = _bcUpdater.GetPlayerTransform(bc);
			Vector2 val = (((Object)(object)playerTransform != (Object)null) ? Vector2.op_Implicit(playerTransform.position) : Vector2.zero);
			component.Initialize(val, attackManager, relicManager, deckManager, cruciballManager, playerHealthController, playerStatusEffectController);
			if (deckManager?.battleDeck != null)
			{
				foreach (GameObject item in deckManager.battleDeck)
				{
					if ((Object)(object)item != (Object)null)
					{
						Attack component2 = item.GetComponent<Attack>();
						if ((Object)(object)component2 != (Object)null && component2.locNameString == component.locNameString)
						{
							component.CloneInstanceId(component2);
							component.CheckUniqueBuff(string.Empty);
							break;
						}
					}
				}
			}
			component.CalculateStaticDamageBuffs(true);
			if ((Object)(object)attackManager != (Object)null)
			{
				_bcUpdater.SetCurrentAttack(attackManager, component);
				attackManager.isHeal = component is HealAction;
			}
			ManualLogSource log2 = _log;
			if (log2 != null)
			{
				log2.LogInfo((object)("[CoopSubs] Restored " + label + " Attack from prefab: " + ((Object)orbPrefab).name));
			}
		}

		public void CleanupTempOrb()
		{
			if ((Object)(object)_tempOrbInstance != (Object)null)
			{
				Object.Destroy((Object)(object)_tempOrbInstance);
				_tempOrbInstance = null;
			}
		}
	}
	public class PlayerAttackData
	{
		public int SlotIndex;

		public string PlayerName;

		public long Damage;

		public string TargetEnemyGuid;

		public bool IsAoE;

		public bool IsHeal;

		public List<(StatusEffectType Type, int Intensity)> StatusEffectsToApply;

		public int NumPegsHit;

		public int CriticalHitCount;

		public string OrbPrefabName;

		public bool HasReverseShot;

		public bool HasTargetedSplash;

		public bool HasTargetedHitAll;
	}
	internal sealed class ShotDamageData
	{
		public int PegMultiplierDamageTally;

		public int CriticalHitCount;

		public int NumPegsHit;

		public int CactusDamageTally;

		public float DamageMultiplier;

		public long DamageBonus;

		public long PrecomputedDamage;

		public string TargetEnemyGuid;

		public bool IsAoE;

		public bool IsHeal;

		public string PlayerName;

		public List<(StatusEffectType Type, int Intensity)> StatusEffectsToApply;

		public string OrbPrefabName;

		public bool HasReverseShot;

		public bool HasTargetedSplash;

		public bool HasTargetedHitAll;
	}
}
namespace Multipeglin.Events.Network
{
	public sealed class DisconnectEvent
	{
		public string Reason { get; set; }
	}
	public sealed class HandshakeEvent
	{
		public string PlayerName { get; set; }

		public string ModVersion { get; set; }

		public string CompiledGameVersion { get; set; }

		public string RuntimeGameVersion { get; set; }

		public bool IsHost { get; set; }

		public int RegisteredHandlerCount { get; set; }
	}
	public class HostPingEvent
	{
		public long Token { get; set; }
	}
	public class HostPongEvent
	{
		public long Token { get; set; }
	}
	public class PingEvent
	{
		public long Token { get; set; }
	}
	public class PongEvent
	{
		public long Token { get; set; }
	}
	public sealed class UnknownEvent
	{
		public string OriginalTypeId { get; set; }

		public string RawPayload { get; set; }
	}
}
namespace Multipeglin.Events.Network.StatusEffect
{
	public class StatusEffectsUpdatedEvent
	{
		public class StatusEffectInfo
		{
			public int EffectType { get; set; }

			public int Intensity { get; set; }
		}

		public List<StatusEffectInfo> Effects { get; set; }
	}
}
namespace Multipeglin.Events.Network.Scenarios
{
	public class MirrorEventCompleteEvent
	{
		public string Action { get; set; }

		public string RemovedOrbName { get; set; }

		public string RemovedOrbGuid { get; set; }
	}
	public class MirrorEventStartEvent
	{
		public string ScenarioName { get; set; }
	}
	public class PegMinigameCompleteEvent
	{
		public string ChosenOrbPrefabName { get; set; }

		public int OrbLevel { get; set; }

		public int ChosenRelicEffect { get; set; } = -1;


		public bool Skipped { get; set; }
	}
	public class ShopCompleteEvent
	{
		public List<ShopPurchase> Purchases { get; set; } = new List<ShopPurchase>();


		public int GoldSpent { get; set; }

		public int RemainingGold { get; set; }
	}
	public class ShopPurchase
	{
		public string Type { get; set; }

		public string Name { get; set; }

		public int Cost { get; set; }

		public int RelicEffect { get; set; } = -1;

	}
	public class ShopPurchaseEvent
	{
		public string Type { get; set; }

		public string Name { get; set; }

		public int Cost { get; set; }

		public int RelicEffect { get; set; } = -1;

	}
	public class TextScenarioCompleteEvent
	{
		public List<SerializedOrb> CompleteDeck { get; set; } = new List<SerializedOrb>();


		public float CurrentHealth { get; set; }

		public float MaxHealth { get; set; }

		public int Gold { get; set; }

		public List<SerializedRelic> Relics { get; set; } = new List<SerializedRelic>();

	}
	public class TreasureCompleteEvent
	{
		public int ChosenRelicEffect { get; set; } = -1;


		public string ChosenRelicName { get; set; }
	}
}
namespace Multipeglin.Events.Network.Relic
{
	public class RelicAddedEvent
	{
		public int RelicEffect { get; set; }

		public string RelicName { get; set; }
	}
	public class RelicRemovedEvent
	{
		public int RelicEffect { get; set; }
	}
	public class RelicUsedEvent
	{
		public int RelicEffect { get; set; }
	}
}
namespace Multipeglin.Events.Network.Peg
{
	public class PegActivatedEvent
	{
		public int PegType { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }

		public string PegGuid { get; set; }
	}
	public class PegDestroyedEvent
	{
		public int PegType { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }

		public string PegGuid { get; set; }
	}
	public class PegHitEvent
	{
		public int PegType { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }

		public string PegGuid { get; set; }

		public int HitCount { get; set; } = -1;


		public int CoinCount { get; set; } = -1;


		public int ShieldHitCount { get; set; } = -1;


		public int ShieldHitLimit { get; set; } = -1;

	}
}
namespace Multipeglin.Events.Network.Map
{
	public class NodeActivatedEvent
	{
		public float PosX { get; set; }

		public float PosY { get; set; }

		public string BattleName { get; set; }

		public string RngState { get; set; }

		public string MapDataName { get; set; }
	}
	public class NodeSelectedEvent
	{
		public string MapName { get; set; }

		public int Floor { get; set; }

		public int CruciballLevel { get; set; }
	}
}
namespace Multipeglin.Events.Network.Lobby
{
	public class ClassSelectEvent
	{
		public int ChosenClass { get; set; }
	}
	public class GameStartEvent
	{
		public List<LobbyPlayerEntry> FinalPlayers { get; set; } = new List<LobbyPlayerEntry>();


		public int CruciballLevel { get; set; }

		public bool IsContinue { get; set; }
	}
	public class LobbyPlayerEntry
	{
		public int SlotIndex { get; set; }

		public string PlayerName { get; set; }

		public int ChosenClass { get; set; }

		public string ChosenClassName { get; set; }

		public bool IsReady { get; set; }

		public bool IsHost { get; set; }

		public string GameVersion { get; set; }

		public string ModVersion { get; set; }

		public bool IsMissing { get; set; }
	}
	public class LobbyStateEvent
	{
		public List<LobbyPlayerEntry> Players { get; set; } = new List<LobbyPlayerEntry>();


		public int CruciballLevel { get; set; }

		public bool IsContinue { get; set; }
	}
	public class ReadyEvent
	{
		public bool IsReady { get; set; }
	}
}
namespace Multipeglin.Events.Network.Health
{
	public class ArmourHitEvent
	{
		public float Damage { get; set; }
	}
	public class DodgeEvent
	{
		public float DodgeInfo { get; set; }
	}
	public class HealthDepletedEvent
	{
	}
	public class MaxHealthChangedEvent
	{
		public float NewMaxHealth { get; set; }
	}
	public class PlayerDamagedEvent
	{
		public float Damage { get; set; }

		public float RemainingHealth { get; set; }

		public float MaxHealth { get; set; }
	}
	public class PlayerHealedEvent
	{
		public float Amount { get; set; }

		public float RemainingHealth { get; set; }

		public int TargetSlotIndex { get; set; } = -1;

	}
}
namespace Multipeglin.Events.Network.Enemy
{
	public class EnemyAttackEvent
	{
		public string EnemyId { get; set; }

		public float Damage { get; set; }

		public bool IsMelee { get; set; }

		public int DamageSource { get; set; }
	}
	public class EnemyDamagedEvent
	{
		public string EnemyId { get; set; }

		public long Damage { get; set; }

		public int DamageSource { get; set; }

		public float RemainingHealth { get; set; }
	}
	public class EnemyDestroyedEvent
	{
		public string EnemyId { get; set; }
	}
	public class EnemyKilledEvent
	{
		public string EnemyId { get; set; }

		public string LocKey { get; set; }
	}
	public class EnemyMovedEvent
	{
		public string EnemyId { get; set; }

		public int FromSlot { get; set; }

		public int ToSlot { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }
	}
	public class EnemySpawnedEvent
	{
		public string EnemyId { get; set; }

		public string LocKey { get; set; }

		public float CurrentHealth { get; set; }

		public float MaxHealth { get; set; }

		public int SlotIndex { get; set; }

		public float MeleeDamage { get; set; }

		public float RangedDamage { get; set; }
	}
}
namespace Multipeglin.Events.Network.Deck
{
	public class BallDrawnEvent
	{
		public string OrbName { get; set; }

		public int Level { get; set; }
	}
	public class BallUpgradedEvent
	{
		public string PreviousOrbName { get; set; }

		public string NewOrbName { get; set; }

		public int NewLevel { get; set; }
	}
	public class BallUsedEvent
	{
		public string OrbName { get; set; }
	}
	public class DeckShuffledEvent
	{
		public int DeckSize { get; set; }
	}
}
namespace Multipeglin.Events.Network.Cursor
{
	public class CursorPositionEvent
	{
		public int FromSlot { get; set; }

		public float WorldX { get; set; }

		public float WorldY { get; set; }
	}
}
namespace Multipeglin.Events.Network.Currency
{
	public class GoldChangedEvent
	{
		public int PreviousAmount { get; set; }

		public int NewAmount { get; set; }

		public int Delta { get; set; }

		public bool IsGain { get; set; }
	}
}
namespace Multipeglin.Events.Network.Coop
{
	public class AllChoicesCompleteEvent
	{
		public string Phase { get; set; }
	}
	public class CoopOrbRewardChoicesEvent
	{
		public int TargetSlotIndex { get; set; }

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

	}
	public class CoopTreasureRelicChoiceEvent
	{
		public int TargetSlotIndex { get; set; }

		public string RelicName { get; set; }

		public int Rarity { get; set; }
	}
	public class NavBallShotEvent
	{
		public int Slot { get; set; }

		public float OriginX { get; set; }

		public float OriginY { get; set; }

		public float AimX { get; set; }

		public float AimY { get; set; }
	}
	public class NavigatePhaseStartEvent
	{
		public string Source { get; set; }

		public int ChildNodeCount { get; set; }

		public int[] ChildRoomTypes { get; set; }
	}
	public class NavigateResolvedEvent
	{
		public int ChosenChildIndex { get; set; }

		public List<int> VoteCounts { get; set; }
	}
	public class NavigateVoteEvent
	{
		public int ChildIndex { get; set; }
	}
	public class NavigateVoteUpdateEvent
	{
		public List<int> VoteCounts { get; set; }
	}
	public class OrbDiscardRequestEvent
	{
	}
	public class PendingDamagePreviewEvent
	{
		public class DamageEntry
		{
			public int SlotIndex { get; set; }

			public string PlayerName { get; set; }

			public long Damage { get; set; }

			public string TargetEnemyGuid { get; set; }

			public bool IsAoE { get; set; }
		}

		public List<DamageEntry> Entries { get; set; } = new List<DamageEntry>();

	}
	public class PostBattleBossHealEvent
	{
		public class Entry
		{
			public int SlotIndex { get; set; }

			public float NewCurrentHealth { get; set; }

			public float MaxHealth { get; set; }

			public float HealedAmount { get; set; }
		}

		public List<Entry> Entries { get; set; } = new List<Entry>();

	}
	public class PostBattleCompleteEvent
	{
		public float CurrentHealth { get; set; }

		public float MaxHealth { get; set; }

		public int Gold { get; set; }

		public List<PostBattleOrbEntry> CompleteDeck { get; set; } = new List<PostBattleOrbEntry>();


		public int ChosenRelicEffect { get; set; } = -1;


		public string ChosenRelicName { get; set; }
	}
	public class PostBattleOrbEntry
	{
		public string PrefabName { get; set; }

		public int Level { get; set; }
	}
	public class PostBattleGoldSpentEvent
	{
		public int Amount { get; set; }

		public float CurrentHealth { get; set; }

		public float MaxHealth { get; set; }
	}
	public class PostBattleRelicChoicesEvent
	{
		public List<RelicChoiceEntry> Choices { get; set; } = new List<RelicChoiceEntry>();

	}
	public class RelicChoiceEntry
	{
		public int Effect { get; set; }

		public string LocKey { get; set; }
	}
	public class PostBattleStartEvent
	{
	}
	public class RelicChoiceEvent
	{
		public int ChosenRelicEffect { get; set; }
	}
	public class RelicChoicesEvent
	{
		public int TargetSlotIndex { get; set; }

		public List<RelicEntry> Choices { get; set; } = new List<RelicEntry>();

	}
	public class RewardChoiceEvent
	{
		public int ChosenOptionIndex { get; set; }
	}
	public class RewardChoicesEvent
	{
		public int TargetSlotIndex { get; set; }

		public List<RewardOption> Options { get; set; } = new List<RewardOption>();

	}
	public class RewardOption
	{
		public int OptionIndex { get; set; }

		public string Type { get; set; }

		public string DisplayName { get; set; }

		public string Description { get; set; }

		public int RelicEffect { get; set; }

		public int GoldReward { get; set; }
	}
	public class RunStatsSnapshotEvent
	{
		public bool HasWon { get; set; }

		public bool HasWonCore { get; set; }

		public bool IsCustomRun { get; set; }

		public bool VampireDealTaken { get; set; }

		public int SelectedClass { get; set; }

		public int CruciballLevel { get; set; }

		public string EndDateIso { get; set; }

		public string Seed { get; set; }

		public long RunTimerElapsedMs { get; set; }

		public int FinalHp { get; set; }

		public int MaxHp { get; set; }

		public int TotalDamageDealt { get; set; }

		public int CoinsEarned { get; set; }

		public int PegsHit { get; set; }

		public int PegsHitRefresh { get; set; }

		public int PegsHitCrit { get; set; }

		public int BombsThrown { get; set; }

		public int BombsThrownRigged { get; set; }

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


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


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


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


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


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


		public List<OrbStatsEntry> Orbs { get; set; } = new List<OrbStatsEntry>();


		public List<EnemyStatsEntry> Enemies { get; set; } = new List<EnemyStatsEntry>();


		public List<PerPlayerStats> Players { get; set; } = new List<PerPlayerStats>();

	}
	public class OrbStatsEntry
	{
		public string Id { get; set; }

		public string Name { get; set; }

		public int DamageDealt { get; set; }

		public int TimesFired { get; set; }

		public int TimesDiscarded { get; set; }

		public int TimesRemoved { get; set; }

		public bool Starting { get; set; }

		public int AmountInDeck { get; set; }

		public int[] LevelInstances { get; set; } = new int[3];

	}
	public class EnemyStatsEntry
	{
		public string Name { get; set; }

		public int AmountFought { get; set; }

		public int MeleeDamageReceived { get; set; }

		public int RangedDamageReceived { get; set; }

		public bool DefeatedBy { get; set; }
	}
	public class PerPlayerStats
	{
		public int SlotIndex { get; set; }

		public string PlayerName { get; set; }

		public long DamageDealt { get; set; }

		public long DamageTaken { get; set; }

		public int ChosenClass { get; set; }

		public int FinalHp { get; set; }

		public int MaxHp { get; set; }

		public int Gold { get; set; }

		public bool IsAlive { get; set; }

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


		public List<PerPlayerOrb> Orbs { get; set; } = new List<PerPlayerOrb>();

	}
	public class PerPlayerOrb
	{
		public string PrefabName { get; set; }

		public int Level { get; set; }
	}
	public class ShootRequestEvent
	{
		public float AimDirectionX { get; set; }

		public float AimDirectionY { get; set; }

		public string TargetEnemyGuid { get; set; }
	}
	public class SkipTurnRequestEvent
	{
	}
	public class SlotConfigEvent
	{
		public float[] Multipliers { get; set; }

		public bool[] PortalsOn { get; set; }

		public bool[] FlamesOn { get; set; }
	}
	public class TargetSelectEvent
	{
		public string TargetEnemyGuid { get; set; }
	}
	public class TurnChangeEvent
	{
		public int ActiveSlotIndex { get; set; }

		public string ActivePlayerName { get; set; }

		public string TurnPhase { get; set; }

		public int RoundNumber { get; set; }
	}
}
namespace Multipeglin.Events.Network.Battle
{
	public class AnimationSyncEvent
	{
		public string EntityGuid { get; set; }

		public string ParamType { get; set; }

		public string ParamName { get; set; }

		public int Value { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }
	}
	public class AttackStartedEvent
	{
		public string AnimTrigger { get; set; }

		public string TargetEnemyGuid { get; set; }

		public int NumPegsHit { get; set; }

		public bool IsCrit { get; set; }

		public string OrbName { get; set; }

		public int SlotIndex { get; set; }
	}
	public class AwaitingShotEvent
	{
	}
	public class BattleEndedEvent
	{
	}
	public class BattleStartedEvent
	{
	}
	public class BombDetonatedEvent
	{
	}
	public class BombThrownEvent
	{
		public int RegularCount;

		public int RiggedCount;
	}
	public class CritActivatedEvent
	{
	}
	public class CritDeactivatedEvent
	{
	}
	public class DamageTextEvent
	{
		public string Text { get; set; }

		public float PosX { get; set; }

		public float PosY { get; set; }

		public float R { get; set; }

		public float G { get; set; }

		public float B { get; set; }

		public float A { get; set; }

		public float Scale { get; set; } = 1f;

	}
	public class DefeatEvent
	{
	}
	public class OrbDiscardedEvent
	{
	}
	public class ReloadStartedEvent
	{
	}
	public class RoundIncrementedEvent
	{
		public int RoundCount { get; set; }
	}
	public class ShotCompleteEvent
	{
	}
	public class ShotTimeoutEvent
	{
	}
	public class SpiritOfRadiaPhaseTransitionEvent
	{
		public int Step;
	}
	public class TurnCompleteEvent
	{
	}
	public class VictoryEvent
	{
	}
}
namespace Multipeglin.Events.Network.Ball
{
	public class AimUpdateEvent
	{
		public float AimX { get; set; }

		public float AimY { get; set; }

		public float SpawnX { get; set; }

		public float SpawnY { get; set; }
	}
	public class BallWallBounceEvent
	{
		public float PosX { get; set; }

		public float PosY { get; set; }

		public float PosZ { get; set; }
	}
	public class ShotFiredEvent
	{
		public float AimX { get; set; }

		public float AimY { get; set; }

		public string OrbName { get; set; }

		public float SpawnX { get; set; }

		public float SpawnY { get; set; }
	}
}
namespace Multipeglin.Events.Handlers
{
	public sealed class DisconnectClientHandler : IClientHandler<DisconnectEvent>
	{
		public void Handle(DisconnectEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)("[Disconnect] Received disconnect from remote: " + (networkEvent.Reason ?? "no reason")));
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting)
			{
				return;
			}
			MainThreadDispatcher instance2 = MainThreadDispatcher.Instance;
			if ((Object)(object)instance2 != (Object)null)
			{
				instance2.Enqueue(delegate
				{
					MultiplayerSession.DisconnectAndReset("Remote disconnected");
				});
			}
			else
			{
				MultiplayerSession.DisconnectAndReset("Remote disconnected");
			}
		}
	}
	public sealed class DisconnectServerHandler : IServerHandler<DisconnectEvent>
	{
		public DisconnectEvent Handle(DisconnectEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class HandshakeClientHandler : IClientHandler<HandshakeEvent>
	{
		public void Handle(HandshakeEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			logger.LogInfo((object)("Received handshake from " + (networkEvent.IsHost ? "HOST" : "CLIENT") + " '" + networkEvent.PlayerName + "':"));
			logger.LogInfo((object)("  Mod version: " + networkEvent.ModVersion));
			logger.LogInfo((object)("  Compiled for Peglin: " + networkEvent.CompiledGameVersion));
			logger.LogInfo((object)("  Running Peglin: " + networkEvent.RuntimeGameVersion));
			logger.LogInfo((object)$"  Registered handlers: {networkEvent.RegisteredHandlerCount}");
			string text = "0.1.10";
			string text2 = Application.version ?? "unknown";
			if (networkEvent.ModVersion != text)
			{
				logger.LogWarning((object)("MOD VERSION MISMATCH: remote=" + networkEvent.ModVersion + " local=" + text));
			}
			if (networkEvent.RuntimeGameVersion != text2)
			{
				logger.LogWarning((object)("GAME VERSION MISMATCH: remote=" + networkEvent.RuntimeGameVersion + " local=" + text2));
			}
			RemotePeerInfo.PlayerName = networkEvent.PlayerName ?? "Unknown";
			RemotePeerInfo.ModVersion = networkEvent.ModVersion;
			RemotePeerInfo.GameVersion = networkEvent.RuntimeGameVersion;
			RemotePeerInfo.IsHost = networkEvent.IsHost;
			RemotePeerInfo.HandlerCount = networkEvent.RegisteredHandlerCount;
			RemotePeerInfo.Received = true;
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting || networkEvent.IsHost || !services.TryResolve<PlayerRegistry>(out var instance2))
			{
				return;
			}
			IGameEventRegistry instance3;
			int valueOrDefault = ((!services.TryResolve<IGameEventRegistry>(out instance3)) ? null : (instance3 as GameEventRegistry)?.CurrentSenderPeerId).GetValueOrDefault(-1);
			if (instance2.GetSlotByPeerId(valueOrDefault) == null)
			{
				string text3 = networkEvent.PlayerName ?? "Unknown";
				if (ContinueSession.IsActive)
				{
					int slotForPlayer = ContinueSession.GetSlotForPlayer(text3);
					if (slotForPlayer < 0)
					{
						logger.LogWarning((object)("[Lobby] Continue: rejecting '" + text3 + "' — not in saved roster"));
						return;
					}
					int classForPlayer = ContinueSession.GetClassForPlayer(text3);
					PlayerSlot playerSlot = instance2.RegisterClientWithSlot(valueOrDefault, text3, slotForPlayer, classForPlayer, networkEvent.RuntimeGameVersion ?? "unknown", networkEvent.ModVersion ?? "unknown");
					if (playerSlot == null)
					{
						logger.LogWarning((object)$"[Lobby] Continue: rejecting '{text3}' — saved slot {slotForPlayer} occupied or invalid");
						return;
					}
					logger.LogInfo((object)$"[Lobby] Continue: registered '{text3}' into saved slot {playerSlot.SlotIndex} class={classForPlayer} (peerId={valueOrDefault}, joinOrder={instance2.SlotCount - 1})");
				}
				else
				{
					PlayerSlot playerSlot2 = instance2.RegisterClient(valueOrDefault, text3, networkEvent.RuntimeGameVersion ?? "unknown", networkEvent.ModVersion ?? "unknown");
					logger.LogInfo((object)$"[Lobby] Registered client '{text3}' as slot {playerSlot2.SlotIndex} (peerId={valueOrDefault})");
				}
			}
			if (services.TryResolve<IGameEventRegistry>(out var instance4))
			{
				LobbyHelper.BroadcastLobbyState(instance2, instance4);
			}
		}
	}
	public static class RemotePeerInfo
	{
		public static bool Received;

		public static string PlayerName = string.Empty;

		public static string ModVersion = string.Empty;

		public static string GameVersion = string.Empty;

		public static bool IsHost;

		public static int HandlerCount;

		public static void Reset()
		{
			Received = false;
			PlayerName = string.Empty;
			ModVersion = string.Empty;
			GameVersion = string.Empty;
			IsHost = false;
			HandlerCount = 0;
		}
	}
	public sealed class HandshakeServerHandler : IServerHandler<HandshakeEvent>
	{
		public HandshakeEvent Handle(HandshakeEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class HostPingClientHandler : IClientHandler<HostPingEvent>
	{
		public void Handle(HostPingEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<IMessageSender>(out var instance))
			{
				instance.Send(new HostPongEvent
				{
					Token = networkEvent.Token
				});
			}
		}
	}
	public sealed class HostPingNoopServerHandler : IServerHandler<HostPingEvent>
	{
		public HostPingEvent Handle(HostPingEvent networkEvent)
		{
			return null;
		}
	}
	public sealed class HostPongClientHandler : IClientHandler<HostPongEvent>
	{
		public void Handle(HostPongEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<HostRttTracker>(out var instance) && services.TryResolve<GameEventRegistry>(out var instance2))
			{
				instance.OnPongReceived(instance2.CurrentSenderPeerId, networkEvent.Token);
			}
		}
	}
	public sealed class HostPongServerHandler : IServerHandler<HostPongEvent>
	{
		public HostPongEvent Handle(HostPongEvent networkEvent)
		{
			return null;
		}
	}
	public sealed class PingClientHandler : IClientHandler<PingEvent>
	{
		public void Handle(PingEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<GameEventRegistry>(out var instance) && services.TryResolve<INetworkTransport>(out var instance2) && services.TryResolve<INetworkSerializer>(out var instance3))
			{
				int currentSenderPeerId = instance.CurrentSenderPeerId;
				PongEvent networkEvent2 = new PongEvent
				{
					Token = networkEvent.Token
				};
				byte[] data = instance3.Serialize(networkEvent2);
				instance2.SendTo(currentSenderPeerId, data);
			}
		}
	}
	public sealed class PingServerHandler : IServerHandler<PingEvent>
	{
		public PingEvent Handle(PingEvent networkEvent)
		{
			return null;
		}
	}
	public sealed class PongClientHandler : IClientHandler<PongEvent>
	{
		public void Handle(PongEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<AppLevelRttProvider>(out var instance))
			{
				instance.OnPongReceived(networkEvent.Token);
			}
		}
	}
	public sealed class PongServerHandler : IServerHandler<PongEvent>
	{
		public PongEvent Handle(PongEvent networkEvent)
		{
			return null;
		}
	}
}
namespace Multipeglin.Events.Handlers.StatusEffect
{
	public sealed class StatusEffectsUpdatedClientHandler : IClientHandler<StatusEffectsUpdatedEvent>
	{
		public void Handle(StatusEffectsUpdatedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Status effects updated ({networkEvent.Effects?.Count ?? 0} effects)");
				PlayerStatusEffectsUpdated onPlayerStatusEffectsUpdated = PlayerStatusEffectController.OnPlayerStatusEffectsUpdated;
				if (onPlayerStatusEffectsUpdated != null)
				{
					onPlayerStatusEffectsUpdated.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("StatusEffectsUpdated handler failed: " + ex.Message));
			}
		}
	}
	public sealed class StatusEffectsUpdatedServerHandler : IServerHandler<StatusEffectsUpdatedEvent>
	{
		public StatusEffectsUpdatedEvent Handle(StatusEffectsUpdatedEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.State
{
	public sealed class DeckStateSnapshotClientHandler : IClientHandler<DeckStateSnapshot>
	{
		public void Handle(DeckStateSnapshot e)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			try
			{
				if (!LobbyUI.GameStartReceived)
				{
					IMultiplayerMode obj = MultiplayerPlugin.Services?.Resolve<IMultiplayerMode>();
					if (obj != null && obj.ClientMode == ClientMode.Mirror)
					{
						(MultiplayerPlugin.Services?.Resolve<GameStateApplyService>())?.ApplyDeckState(e);
					}
					else if (logger != null)
					{
						logger.LogInfo((object)"[StateSync] DeckState received (diagnostics mode)");
					}
				}
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("DeckStateSnapshotClientHandler: " + ex.Message));
				}
			}
		}
	}
	public sealed class DeckStateSnapshotServerHandler : IServerHandler<DeckStateSnapshot>
	{
		public DeckStateSnapshot Handle(DeckStateSnapshot e)
		{
			return e;
		}
	}
	public sealed class EnemyStateSnapshotClientHandler : IClientHandler<EnemyStateSnapshot>
	{
		public void Handle(EnemyStateSnapshot e)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			try
			{
				IMultiplayerMode obj = MultiplayerPlugin.Services?.Resolve<IMultiplayerMode>();
				if (obj != null && obj.ClientMode == ClientMode.Mirror)
				{
					(MultiplayerPlugin.Services?.Resolve<GameStateApplyService>())?.ApplyEnemyState(e);
				}
				else if (logger != null)
				{
					logger.LogInfo((object)"[StateSync] EnemyState received (diagnostics mode)");
				}
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("EnemyStateSnapshotClientHandler: " + ex.Message));
				}
			}
		}
	}
	public sealed class EnemyStateSnapshotServerHandler : IServerHandler<EnemyStateSnapshot>
	{
		public EnemyStateSnapshot Handle(EnemyStateSnapshot e)
		{
			return e;
		}
	}
	public sealed class FullGameStateClientHandler : IClientHandler<FullGameStateSnapshot>
	{
		public void Handle(FullGameStateSnapshot e)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			try
			{
				if (e.PlayerSummaries != null)
				{
					CoopPlayerVisuals.LatestPlayerSummaries = e.PlayerSummaries;
				}
				CoopPlayerVisuals.LatestActiveSlot = e.ActivePlayerSlot;
				IMultiplayerMode obj = MultiplayerPlugin.Services?.Resolve<IMultiplayerMode>();
				if (obj != null && obj.ClientMode == ClientMode.Mirror)
				{
					GameStateApplyService gameStateApplyService = MultiplayerPlugin.Services?.Resolve<GameStateApplyService>();
					if (gameStateApplyService != null)
					{
						gameStateApplyService.ApplyAll(e);
						return;
					}
				}
				if (logger != null)
				{
					logger.LogInfo((object)"=== FULL GAME STATE RECEIVED ===");
				}
				if (e.Map != null && logger != null)
				{
					logger.LogInfo((object)$"  Map: scene={e.Map.ActiveScene}, floor={e.Map.TotalFloorCount}, class={e.Map.ChosenClassName}, seed={e.Map.CurrentSeed}");
				}
				if (e.Player != null && logger != null)
				{
					logger.LogInfo((object)$"  Player: hp={e.Player.CurrentHealth}/{e.Player.MaxHealth}, gold={e.Player.Gold}, effects={e.Player.StatusEffects?.Count ?? 0}");
				}
				if (e.Deck != null && logger != null)
				{
					logger.LogInfo((object)$"  Deck: {e.Deck.DeckSize} orbs total");
				}
				if (e.Relics != null && logger != null)
				{
					logger.LogInfo((object)$"  Relics: {e.Relics.TotalRelicCount} owned");
				}
				if (e.Enemies != null && logger != null)
				{
					logger.LogInfo((object)$"  Battle: state={e.Enemies.BattleStateName}, {e.Enemies.Enemies?.Count ?? 0} enemies");
				}
				if (e.Pegboard != null && logger != null)
				{
					logger.LogInfo((object)$"  Pegboard: {e.Pegboard.TotalPegCount} pegs");
				}
				if (e.PlayerSummaries != null && logger != null)
				{
					logger.LogInfo((object)$"  CoopPlayers: {e.PlayerSummaries.Count} players, activeSlot={e.ActivePlayerSlot}");
				}
				if (logger != null)
				{
					logger.LogInfo((object)"================================");
				}
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("FullGameStateClientHandler: " + ex.Message));
				}
			}
		}
	}
	public sealed class FullGameStateServerHandler : IServerHandler<FullGameStateSnapshot>
	{
		public FullGameStateSnapshot Handle(FullGameStateSnapshot e)
		{
			return e;
		}
	}
	public sealed class MapStateSnapshotClientHandler : IClientHandler<MapStateSnapshot>
	{
		public void Handle(MapStateSnapshot e)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			try
			{
				IMultiplayerMode obj = MultiplayerPlugin.Services?.Resolve<IMultiplayerMode>();
				if (obj != null && obj.ClientMode == ClientMode.Mirror)
				{
					(MultiplayerPlugin.Services?.Resolve<GameStateApplyService>())?.ApplyMapState(e);
				}
				else if (logger != null)
				{
					logger.LogInfo((object)"[StateSync] MapState received (diagnostics mode)");
				}
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("MapStateSnapshotClientHandler: " + ex.Message));
				}
			}
		}
	}
	public sealed class MapStateSnapshotServerHandler : IServerHandler<MapStateSnapshot>
	{
		public MapStateSnapshot Handle(MapStateSnapshot e)
		{
			return e;
		}
	}
	public sealed class PegboardStateSnapshotClientHandler : IClientHandler<PegboardStateSnapshot>
	{
		public void Handle(PegboardStateSnapshot e)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			try
			{
				IMultiplayerMode obj = MultiplayerPlugin.Services?.Resolve<IMultiplayerMode>();
				if (obj != null && obj.ClientMode == ClientMode.Mirror)
				{
					(MultiplayerPlugin.Services?.Resolve<GameStateApplyService>())?.ApplyPegboardState(e);
				}
				else if (logger != null)
				{
					logger.LogInfo((object)"[StateSync] PegboardState received (diagnostics mode)");
				}
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("PegboardStateSnapshotClientHandler: " + ex.Message));
				}
			}
		}
	}
	public sealed class PegboardStateSnapshotServerHandler : IServerHandler<PegboardStateSnapshot>
	{
		public PegboardStateSnapshot Handle(PegboardStateSnapshot e)
		{
			return e;
		}
	}
	public sealed class PlayerStateSnapshotClientHandler : IClientHandler<PlayerStateSnapshot>
	{
		public void Handle(PlayerStateSnapshot e)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			try
			{
				IMultiplayerMode obj = MultiplayerPlugin.Services?.Resolve<IMultiplayerMode>();
				if (obj != null && obj.ClientMode == ClientMode.Mirror)
				{
					(MultiplayerPlugin.Services?.Resolve<GameStateApplyService>())?.ApplyPlayerState(e);
				}
				else if (logger != null)
				{
					logger.LogInfo((object)"[StateSync] PlayerState received (diagnostics mode)");
				}
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("PlayerStateSnapshotClientHandler: " + ex.Message));
				}
			}
		}
	}
	public sealed class PlayerStateSnapshotServerHandler : IServerHandler<PlayerStateSnapshot>
	{
		public PlayerStateSnapshot Handle(PlayerStateSnapshot e)
		{
			return e;
		}
	}
	public sealed class RelicStateSnapshotClientHandler : IClientHandler<RelicStateSnapshot>
	{
		public void Handle(RelicStateSnapshot e)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			try
			{
				if (!LobbyUI.GameStartReceived)
				{
					IMultiplayerMode obj = MultiplayerPlugin.Services?.Resolve<IMultiplayerMode>();
					if (obj != null && obj.ClientMode == ClientMode.Mirror)
					{
						(MultiplayerPlugin.Services?.Resolve<GameStateApplyService>())?.ApplyRelicState(e);
					}
					else if (logger != null)
					{
						logger.LogInfo((object)"[StateSync] RelicState received (diagnostics mode)");
					}
				}
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("RelicStateSnapshotClientHandler: " + ex.Message));
				}
			}
		}
	}
	public sealed class RelicStateSnapshotServerHandler : IServerHandler<RelicStateSnapshot>
	{
		public RelicStateSnapshot Handle(RelicStateSnapshot e)
		{
			return e;
		}
	}
}
namespace Multipeglin.Events.Handlers.Scenarios
{
	public sealed class MirrorEventCompleteClientHandler : IClientHandler<MirrorEventCompleteEvent>
	{
		public void Handle(MirrorEventCompleteEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[MirrorEventComplete] From unknown peer {num}");
					}
					return;
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[MirrorEventComplete] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}) chose: action={e.Action}");
				}
				if (!services.TryResolve<CoopStateManager>(out var instance4))
				{
					return;
				}
				CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
				if (playerState == null)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)$"[MirrorEventComplete] No CoopPlayerState for slot {slotByPeerId.SlotIndex}");
					}
				}
				else if (e.Action == "remove_one")
				{
					HandleRemoveOne(playerState, e);
				}
				else if (e.Action == "remove_all")
				{
					HandleRemoveAll(playerState);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("[MirrorEventComplete] Handler failed: " + ex.Message));
				}
			}
		}

		private void HandleRemoveOne(CoopPlayerState playerState, MirrorEventCompleteEvent e)
		{
			bool flag = false;
			if (!string.IsNullOrEmpty(e.RemovedOrbGuid))
			{
				int num = playerState.CompleteDeck.FindIndex((SerializedOrb o) => o.Guid == e.RemovedOrbGuid);
				if (num >= 0)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)("[MirrorEventComplete] Removed orb by GUID: " + playerState.CompleteDeck[num].PrefabName + " (" + e.RemovedOrbGuid + ")"));
					}
					playerState.CompleteDeck.RemoveAt(num);
					flag = true;
				}
			}
			if (!flag && !string.IsNullOrEmpty(e.RemovedOrbName))
			{
				int num2 = playerState.CompleteDeck.FindIndex((SerializedOrb o) => o.PrefabName == e.RemovedOrbName);
				if (num2 >= 0)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)("[MirrorEventComplete] Removed orb by name: " + e.RemovedOrbName));
					}
					playerState.CompleteDeck.RemoveAt(num2);
					flag = true;
				}
			}
			if (!flag)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[MirrorEventComplete] Could not find orb to remove: name='" + e.RemovedOrbName + "', guid='" + e.RemovedOrbGuid + "'"));
				}
			}
			ManualLogSource logger4 = MultiplayerPlugin.Logger;
			if (logger4 != null)
			{
				logger4.LogInfo((object)$"[MirrorEventComplete] Deck now has {playerState.CompleteDeck.Count} orbs");
			}
		}

		private void HandleRemoveAll(CoopPlayerState playerState)
		{
			int num = 0;
			for (int num2 = playerState.CompleteDeck.Count - 1; num2 >= 0; num2--)
			{
				if (!IsCannotBeRemoved(playerState.CompleteDeck[num2].PrefabName))
				{
					playerState.CompleteDeck.RemoveAt(num2);
					num++;
				}
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)$"[MirrorEventComplete] Removed {num} orbs from deck");
			}
			AddMirrorReplacementOrbs(playerState);
		}

		private void AddMirrorReplacementOrbs(CoopPlayerState playerState)
		{
			try
			{
				OrbPool[] array = Resources.FindObjectsOfTypeAll<OrbPool>();
				OrbPool val = null;
				OrbPool[] array2 = array;
				foreach (OrbPool val2 in array2)
				{
					if (((Object)val2).name != null && (((Object)val2).name.IndexOf("orboros", StringComparison.OrdinalIgnoreCase) >= 0 || ((Object)val2).name.IndexOf("mirror", StringComparison.OrdinalIgnoreCase) >= 0))
					{
						val = val2;
						break;
					}
				}
				if ((Object)(object)val != (Object)null && val.AvailableOrbs != null)
				{
					GameObject[] availableOrbs = val.AvailableOrbs;
					foreach (GameObject val3 in availableOrbs)
					{
						if (!((Object)(object)val3 == (Object)null))
						{
							Attack component = val3.GetComponent<Attack>();
							playerState.CompleteDeck.Add(new SerializedOrb
							{
								PrefabName = ((Object)val3).name,
								Guid = Guid.NewGuid().ToString(),
								Level = (component?.Level ?? 1)
							});
						}
					}
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[MirrorEventComplete] Added {val.AvailableOrbs.Length} replacement orbs from pool '{((Object)val).name}'");
					}
				}
				else
				{
					List<GameObject> completeDeck = DeckManager.completeDeck;
					if (completeDeck != null)
					{
						foreach (GameObject item in completeDeck)
						{
							if (!((Object)(object)item == (Object)null))
							{
								Attack component2 = item.GetComponent<Attack>();
								string prefabName = ((Object)item).name.Replace("(Clone)", string.Empty).Trim();
								if (playerState.CompleteDeck.All((SerializedOrb o) => o.PrefabName != prefabName))
								{
									playerState.CompleteDeck.Add(new SerializedOrb
									{
										PrefabName = prefabName,
										Guid = Guid.NewGuid().ToString(),
										Level = (component2?.Level ?? 1)
									});
								}
							}
						}
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogInfo((object)"[MirrorEventComplete] Used host's current deck as fallback for replacement orbs");
						}
					}
					else
					{
						ManualLogSource logger3 = MultiplayerPlugin.Logger;
						if (logger3 != null)
						{
							logger3.LogWarning((object)"[MirrorEventComplete] Could not find mirror OrbPool or host deck for replacement orbs");
						}
					}
				}
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogInfo((object)$"[MirrorEventComplete] Final deck has {playerState.CompleteDeck.Count} orbs");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogWarning((object)("[MirrorEventComplete] AddMirrorReplacementOrbs failed: " + ex.Message));
				}
			}
		}

		private static bool IsCannotBeRemoved(string prefabName)
		{
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Attack[] array = Resources.FindObjectsOfTypeAll<Attack>();
				foreach (Attack val in array)
				{
					if (((Object)((Component)val).gameObject).name == prefabName)
					{
						Scene scene = ((Component)val).gameObject.scene;
						if (((Scene)(ref scene)).name == null)
						{
							return (Object)(object)((Component)val).GetComponent<CannotBeRemoved>() != (Object)null;
						}
					}
				}
			}
			catch
			{
			}
			return false;
		}
	}
	public sealed class MirrorEventCompleteServerHandler : IServerHandler<MirrorEventCompleteEvent>
	{
		public MirrorEventCompleteEvent Handle(MirrorEventCompleteEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[MirrorEventCompleteServer] Received — suppressing rebroadcast");
			}
			return null;
		}
	}
	public sealed class MirrorEventStartClientHandler : IClientHandler<MirrorEventStartEvent>
	{
		public void Handle(MirrorEventStartEvent e)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)("[MirrorEventStart] Received mirror event start — scenario='" + e.ScenarioName + "' (no-op, native dialogue handles this)"));
			}
		}
	}
	public sealed class MirrorEventStartServerHandler : IServerHandler<MirrorEventStartEvent>
	{
		public MirrorEventStartEvent Handle(MirrorEventStartEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class PegMinigameCompleteClientHandler : IClientHandler<PegMinigameCompleteEvent>
	{
		public void Handle(PegMinigameCompleteEvent e)
		{
			//IL_01e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_01ec: Invalid comparison between Unknown and I4
			//IL_0216: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Expected I4, but got Unknown
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[PegMinigameComplete] From unknown peer {num}");
					}
				}
				else
				{
					if (!services.TryResolve<CoopStateManager>(out var instance4))
					{
						return;
					}
					CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
					if (playerState == null)
					{
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogWarning((object)$"[PegMinigameComplete] No CoopPlayerState for slot {slotByPeerId.SlotIndex}");
						}
						return;
					}
					if (e.Skipped)
					{
						ManualLogSource logger3 = MultiplayerPlugin.Logger;
						if (logger3 != null)
						{
							logger3.LogInfo((object)$"[PegMinigameComplete] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}) skipped PegMinigame reward");
						}
					}
					else if (!string.IsNullOrEmpty(e.ChosenOrbPrefabName))
					{
						playerState.CompleteDeck.Add(new SerializedOrb
						{
							PrefabName = e.ChosenOrbPrefabName,
							Guid = Guid.NewGuid().ToString(),
							Level = e.OrbLevel
						});
						ManualLogSource logger4 = MultiplayerPlugin.Logger;
						if (logger4 != null)
						{
							logger4.LogInfo((object)$"[PegMinigameComplete] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}) chose orb '{e.ChosenOrbPrefabName}' (lvl={e.OrbLevel})");
						}
					}
					else if (e.ChosenRelicEffect >= 0)
					{
						Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
						foreach (Relic val in array)
						{
							if ((int)val.effect == e.ChosenRelicEffect)
							{
								playerState.OwnedRelics.Add(new SerializedRelic
								{
									Effect = e.ChosenRelicEffect,
									LocKey = val.locKey,
									Rarity = (int)val.globalRarity
								});
								ManualLogSource logger5 = MultiplayerPlugin.Logger;
								if (logger5 != null)
								{
									logger5.LogInfo((object)$"[PegMinigameComplete] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}) chose relic '{val.locKey}'");
								}
								break;
							}
						}
					}
					CoopRewardState.ClientPegMinigameChoicesReceived.Add(slotByPeerId.SlotIndex);
					ManualLogSource logger6 = MultiplayerPlugin.Logger;
					if (logger6 != null)
					{
						logger6.LogInfo((object)($"[PegMinigameComplete] Completion: {CoopRewardState.ClientPegMinigameChoicesReceived.Count}/{CoopRewardState.TotalPegMinigameClientsExpected}" + $" hostDone={CoopRewardState.HostPegMinigameDone}"));
					}
					if (!CoopRewardState.HostPegMinigameDone || !CoopRewardState.AllClientPegMinigameChoicesReceived)
					{
						return;
					}
					ManualLogSource logger7 = MultiplayerPlugin.Logger;
					if (logger7 != null)
					{
						logger7.LogInfo((object)"[PegMinigameComplete] All players finished PegMinigame — proceeding");
					}
					CoopRewardState.WaitingForOtherPlayers = false;
					CoopRewardState.PegMinigamePhaseActive = false;
					if (services.TryResolve<IGameEventRegistry>(out var instance5))
					{
						instance5.Dispatch(new AllChoicesCompleteEvent
						{
							Phase = "peg_minigame"
						});
					}
					PegMinigameManager pendingPegMinigameManager = CoopRewardState.PendingPegMinigameManager;
					if ((Object)(object)pendingPegMinigameManager != (Object)null)
					{
						CoopRewardState.PendingPegMinigameManager = null;
						ManualLogSource logger8 = MultiplayerPlugin.Logger;
						if (logger8 != null)
						{
							logger8.LogInfo((object)"[PegMinigameComplete] Resuming host PegMinigameManager navigation");
						}
						pendingPegMinigameManager.FadeAndLoad((Scene)0, -1f);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger9 = MultiplayerPlugin.Logger;
				if (logger9 != null)
				{
					logger9.LogWarning((object)("[PegMinigameComplete] Handler failed: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}
	}
	public sealed class PegMinigameCompleteServerHandler : IServerHandler<PegMinigameCompleteEvent>
	{
		public PegMinigameCompleteEvent Handle(PegMinigameCompleteEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[PegMinigameCompleteServer] Received — suppressing rebroadcast");
			}
			return null;
		}
	}
	public sealed class ShopCompleteClientHandler : IClientHandler<ShopCompleteEvent>
	{
		public void Handle(ShopCompleteEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[ShopComplete] From unknown peer {num}");
					}
					return;
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)($"[ShopComplete] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}): " + $"{e.Purchases?.Count ?? 0} purchases, goldSpent={e.GoldSpent}, remaining={e.RemainingGold}"));
				}
				if (!services.TryResolve<CoopStateManager>(out var instance4))
				{
					return;
				}
				CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
				if (playerState == null)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)$"[ShopComplete] No CoopPlayerState for slot {slotByPeerId.SlotIndex}");
					}
					return;
				}
				if (e.RemainingGold > 0 || playerState.Gold != e.RemainingGold)
				{
					playerState.Gold = e.RemainingGold;
				}
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogInfo((object)($"[ShopComplete] Finalized slot {slotByPeerId.SlotIndex}: deck={playerState.CompleteDeck.Count}, " + $"relics={playerState.OwnedRelics.Count}, gold={playerState.Gold} (e.RemainingGold={e.RemainingGold})"));
				}
				CoopRewardState.ClientShopChoicesReceived.Add(slotByPeerId.SlotIndex);
				if (!CoopRewardState.HostShopDone || !CoopRewardState.AllClientShopChoicesReceived || CoopRewardState.ShopCompletionProceeded)
				{
					return;
				}
				CoopRewardState.ShopCompletionProceeded = true;
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogInfo((object)"[ShopComplete] All players finished shopping — proceeding");
				}
				CoopRewardState.WaitingForOtherPlayers = false;
				CoopRewardState.ShopPhaseActive = false;
				if (services.TryResolve<IGameEventRegistry>(out var instance5))
				{
					instance5.Dispatch(new AllChoicesCompleteEvent
					{
						Phase = "shop"
					});
				}
				object pendingShopManager = CoopRewardState.PendingShopManager;
				ShopManager val = (ShopManager)((pendingShopManager is ShopManager) ? pendingShopManager : null);
				if (val != null)
				{
					CoopRewardState.PendingShopManager = null;
					ManualLogSource logger6 = MultiplayerPlugin.Logger;
					if (logger6 != null)
					{
						logger6.LogInfo((object)"[ShopComplete] Resuming host CloseStore");
					}
					val.CloseStore();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger7 = MultiplayerPlugin.Logger;
				if (logger7 != null)
				{
					logger7.LogWarning((object)("[ShopComplete] Handler failed: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}

		private void ApplyOrbPurchase(CoopPlayerState playerState, ShopPurchase purchase)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_001e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Attack[] array = Resources.FindObjectsOfTypeAll<Attack>();
				foreach (Attack val in array)
				{
					GameObject gameObject = ((Component)val).gameObject;
					Scene scene = gameObject.scene;
					if (((Scene)(ref scene)).name == null && ((Object)gameObject).name == purchase.Name)
					{
						playerState.CompleteDeck.Add(new SerializedOrb
						{
							PrefabName = purchase.Name,
							Guid = Guid.NewGuid().ToString(),
							Level = val.Level
						});
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)("[ShopComplete] Added orb '" + purchase.Name + "' to deck"));
						}
						return;
					}
				}
				playerState.CompleteDeck.Add(new SerializedOrb
				{
					PrefabName = purchase.Name,
					Guid = Guid.NewGuid().ToString(),
					Level = 1
				});
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)("[ShopComplete] Added orb '" + purchase.Name + "' (fallback, level=1)"));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[ShopComplete] ApplyOrbPurchase failed: " + ex.Message));
				}
			}
		}

		private void ApplyRelicPurchase(CoopPlayerState playerState, ShopPurchase purchase)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected I4, but got Unknown
			try
			{
				if (purchase.RelicEffect < 0)
				{
					return;
				}
				Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
				foreach (Relic val in array)
				{
					if ((int)val.effect == purchase.RelicEffect)
					{
						playerState.OwnedRelics.Add(new SerializedRelic
						{
							Effect = purchase.RelicEffect,
							LocKey = val.locKey,
							Rarity = (int)val.globalRarity
						});
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)$"[ShopComplete] Added relic '{val.locKey}' (effect={purchase.RelicEffect}) to player state");
						}
						return;
					}
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)$"[ShopComplete] Relic with effect={purchase.RelicEffect} not found");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[ShopComplete] ApplyRelicPurchase failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class ShopCompleteServerHandler : IServerHandler<ShopCompleteEvent>
	{
		public ShopCompleteEvent Handle(ShopCompleteEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[ShopCompleteServer] Received — suppressing rebroadcast");
			}
			return null;
		}
	}
	public sealed class ShopPurchaseClientHandler : IClientHandler<ShopPurchaseEvent>
	{
		public void Handle(ShopPurchaseEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[ShopPurchase] From unknown peer {num}");
					}
				}
				else
				{
					if (!services.TryResolve<CoopStateManager>(out var instance4))
					{
						return;
					}
					CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
					if (playerState == null)
					{
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogWarning((object)$"[ShopPurchase] No CoopPlayerState for slot {slotByPeerId.SlotIndex}");
						}
						return;
					}
					int gold = playerState.Gold;
					playerState.Gold = Math.Max(0, playerState.Gold - e.Cost);
					if (e.Type == "orb")
					{
						ApplyOrbPurchase(playerState, e);
					}
					else if (e.Type == "relic")
					{
						ApplyRelicPurchase(playerState, e);
					}
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogInfo((object)($"[ShopPurchase] Slot {slotByPeerId.SlotIndex} ({slotByPeerId.PlayerName}) bought {e.Type} '{e.Name}' " + $"for {e.Cost} gold ({gold} -> {playerState.Gold}), " + $"deck={playerState.CompleteDeck.Count}, relics={playerState.OwnedRelics.Count}"));
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("[ShopPurchase] Handler failed: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}

		private void ApplyOrbPurchase(CoopPlayerState playerState, ShopPurchaseEvent purchase)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				Attack[] array = Resources.FindObjectsOfTypeAll<Attack>();
				foreach (Attack val in array)
				{
					GameObject gameObject = ((Component)val).gameObject;
					Scene scene = gameObject.scene;
					if (((Scene)(ref scene)).name == null && ((Object)gameObject).name == purchase.Name)
					{
						playerState.CompleteDeck.Add(new SerializedOrb
						{
							PrefabName = purchase.Name,
							Guid = Guid.NewGuid().ToString(),
							Level = val.Level
						});
						return;
					}
				}
				playerState.CompleteDeck.Add(new SerializedOrb
				{
					PrefabName = purchase.Name,
					Guid = Guid.NewGuid().ToString(),
					Level = 1
				});
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[ShopPurchase] ApplyOrbPurchase failed: " + ex.Message));
				}
			}
		}

		private void ApplyRelicPurchase(CoopPlayerState playerState, ShopPurchaseEvent purchase)
		{
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Invalid comparison between Unknown and I4
			//IL_004f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0059: Expected I4, but got Unknown
			try
			{
				if (purchase.RelicEffect < 0)
				{
					return;
				}
				Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
				foreach (Relic val in array)
				{
					if ((int)val.effect == purchase.RelicEffect)
					{
						playerState.OwnedRelics.Add(new SerializedRelic
						{
							Effect = purchase.RelicEffect,
							LocKey = val.locKey,
							Rarity = (int)val.globalRarity
						});
						return;
					}
				}
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"[ShopPurchase] Relic with effect={purchase.RelicEffect} not found");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[ShopPurchase] ApplyRelicPurchase failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class ShopPurchaseServerHandler : IServerHandler<ShopPurchaseEvent>
	{
		public ShopPurchaseEvent Handle(ShopPurchaseEvent networkEvent)
		{
			return null;
		}
	}
	public sealed class TextScenarioCompleteClientHandler : IClientHandler<TextScenarioCompleteEvent>
	{
		public void Handle(TextScenarioCompleteEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[TextScenarioComplete] From unknown peer {num}");
					}
					return;
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)($"[TextScenarioComplete] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}): " + $"deck={e.CompleteDeck?.Count ?? 0}, hp={e.CurrentHealth}/{e.MaxHealth}, " + $"gold={e.Gold}, relics={e.Relics?.Count ?? 0}"));
				}
				if (!services.TryResolve<CoopStateManager>(out var instance4))
				{
					return;
				}
				CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
				if (playerState == null)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)$"[TextScenarioComplete] No CoopPlayerState for slot {slotByPeerId.SlotIndex}");
					}
					return;
				}
				if (e.CompleteDeck != null)
				{
					playerState.CompleteDeck = e.CompleteDeck.ToList();
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogInfo((object)("[TextScenarioComplete] Deck updated: " + string.Join(", ", playerState.CompleteDeck.Select((SerializedOrb o) => $"{o.PrefabName}(L{o.Level})"))));
					}
				}
				playerState.CurrentHealth = e.CurrentHealth;
				playerState.MaxHealth = e.MaxHealth;
				playerState.Gold = e.Gold;
				if (e.Relics != null)
				{
					playerState.OwnedRelics = e.Relics.ToList();
					ManualLogSource logger5 = MultiplayerPlugin.Logger;
					if (logger5 != null)
					{
						logger5.LogInfo((object)("[TextScenarioComplete] Relics updated: " + string.Join(", ", playerState.OwnedRelics.Select((SerializedRelic r) => r.LocKey))));
					}
				}
				CoopRewardState.ClientTextScenarioChoicesReceived.Add(slotByPeerId.SlotIndex);
				ManualLogSource logger6 = MultiplayerPlugin.Logger;
				if (logger6 != null)
				{
					logger6.LogInfo((object)($"[TextScenarioComplete] Slot {slotByPeerId.SlotIndex} done " + $"({CoopRewardState.ClientTextScenarioChoicesReceived.Count}/{CoopRewardState.TotalTextScenarioClientsExpected} clients)"));
				}
				if (!CoopRewardState.HostTextScenarioDone || !CoopRewardState.AllClientTextScenarioChoicesReceived)
				{
					return;
				}
				ManualLogSource logger7 = MultiplayerPlugin.Logger;
				if (logger7 != null)
				{
					logger7.LogInfo((object)"[TextScenarioComplete] All players finished TextScenario — proceeding");
				}
				CoopRewardState.WaitingForOtherPlayers = false;
				CoopRewardState.TextScenarioPhaseActive = false;
				if (services.TryResolve<IGameEventRegistry>(out var instance5))
				{
					instance5.Dispatch(new AllChoicesCompleteEvent
					{
						Phase = "text_scenario"
					});
				}
				object pendingDialogueSystemScenario = CoopRewardState.PendingDialogueSystemScenario;
				DialogueSystemScenario val = (DialogueSystemScenario)((pendingDialogueSystemScenario is DialogueSystemScenario) ? pendingDialogueSystemScenario : null);
				if (val != null)
				{
					CoopRewardState.PendingDialogueSystemScenario = null;
					ManualLogSource logger8 = MultiplayerPlugin.Logger;
					if (logger8 != null)
					{
						logger8.LogInfo((object)"[TextScenarioComplete] Resuming host StartNavigation");
					}
					val.ConversationEnded();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger9 = MultiplayerPlugin.Logger;
				if (logger9 != null)
				{
					logger9.LogWarning((object)("[TextScenarioComplete] Handler failed: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}
	}
	public sealed class TextScenarioCompleteServerHandler : IServerHandler<TextScenarioCompleteEvent>
	{
		public TextScenarioCompleteEvent Handle(TextScenarioCompleteEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[TextScenarioCompleteServer] Received — suppressing rebroadcast");
			}
			return null;
		}
	}
	public sealed class TreasureCompleteClientHandler : IClientHandler<TreasureCompleteEvent>
	{
		public void Handle(TreasureCompleteEvent e)
		{
			//IL_011c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Invalid comparison between Unknown and I4
			//IL_0151: Unknown result type (might be due to invalid IL or missing references)
			//IL_015b: Expected I4, but got Unknown
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[TreasureComplete] From unknown peer {num}");
					}
					return;
				}
				if (e.ChosenRelicEffect >= 0)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)($"[TreasureComplete] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}) chose relic: " + $"effect={e.ChosenRelicEffect}, name='{e.ChosenRelicName}'"));
					}
					if (services.TryResolve<CoopStateManager>(out var instance4))
					{
						CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
						if (playerState != null)
						{
							Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
							foreach (Relic val in array)
							{
								if ((int)val.effect == e.ChosenRelicEffect)
								{
									playerState.OwnedRelics.Add(new SerializedRelic
									{
										Effect = e.ChosenRelicEffect,
										LocKey = val.locKey,
										Rarity = (int)val.globalRarity
									});
									ManualLogSource logger3 = MultiplayerPlugin.Logger;
									if (logger3 != null)
									{
										logger3.LogInfo((object)$"[TreasureComplete] Added relic '{val.locKey}' to slot {slotByPeerId.SlotIndex}");
									}
									break;
								}
							}
						}
					}
				}
				else
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogInfo((object)$"[TreasureComplete] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}) skipped treasure relic");
					}
				}
				CoopRewardState.ClientTreasureChoicesReceived.Add(slotByPeerId.SlotIndex);
				if (!CoopRewardState.HostTreasureDone || !CoopRewardState.AllClientTreasureChoicesReceived)
				{
					return;
				}
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogInfo((object)"[TreasureComplete] All players finished treasure — proceeding");
				}
				CoopRewardState.WaitingForOtherPlayers = false;
				CoopRewardState.TreasurePhaseActive = false;
				if (services.TryResolve<IGameEventRegistry>(out var instance5))
				{
					instance5.Dispatch(new AllChoicesCompleteEvent
					{
						Phase = "treasure"
					});
				}
				ChestScenarioController pendingChestController = CoopRewardState.PendingChestController;
				if ((Object)(object)pendingChestController != (Object)null)
				{
					CoopRewardState.PendingChestController = null;
					ManualLogSource logger6 = MultiplayerPlugin.Logger;
					if (logger6 != null)
					{
						logger6.LogInfo((object)"[TreasureComplete] Resuming host ChestScenarioController.Skip");
					}
					pendingChestController.Skip();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger7 = MultiplayerPlugin.Logger;
				if (logger7 != null)
				{
					logger7.LogWarning((object)("[TreasureComplete] Handler failed: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}
	}
	public sealed class TreasureCompleteServerHandler : IServerHandler<TreasureCompleteEvent>
	{
		public TreasureCompleteEvent Handle(TreasureCompleteEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[TreasureCompleteServer] Received — suppressing rebroadcast");
			}
			return null;
		}
	}
}
namespace Multipeglin.Events.Handlers.Relic
{
	public sealed class RelicAddedClientHandler : IClientHandler<RelicAddedEvent>
	{
		public void Handle(RelicAddedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Relic added {networkEvent.RelicName} (effect {networkEvent.RelicEffect})");
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("RelicAdded handler failed: " + ex.Message));
			}
		}
	}
	public sealed class RelicAddedServerHandler : IServerHandler<RelicAddedEvent>
	{
		public RelicAddedEvent Handle(RelicAddedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class RelicRemovedClientHandler : IClientHandler<RelicRemovedEvent>
	{
		public void Handle(RelicRemovedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Relic removed (effect {networkEvent.RelicEffect})");
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("RelicRemoved handler failed: " + ex.Message));
			}
		}
	}
	public sealed class RelicRemovedServerHandler : IServerHandler<RelicRemovedEvent>
	{
		public RelicRemovedEvent Handle(RelicRemovedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class RelicUsedClientHandler : IClientHandler<RelicUsedEvent>
	{
		public void Handle(RelicUsedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Relic used (effect {networkEvent.RelicEffect})");
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("RelicUsed handler failed: " + ex.Message));
			}
		}
	}
	public sealed class RelicUsedServerHandler : IServerHandler<RelicUsedEvent>
	{
		public RelicUsedEvent Handle(RelicUsedEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.Peg
{
	public sealed class PegActivatedClientHandler : IClientHandler<PegActivatedEvent>
	{
		public void Handle(PegActivatedEvent networkEvent)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				Peg val = null;
				if (!string.IsNullOrEmpty(networkEvent.PegGuid))
				{
					IServiceContainer services2 = MultiplayerPlugin.Services;
					val = ((services2 != null && services2.TryResolve<PegIdentifier>(out var instance2)) ? instance2 : null)?.Find(networkEvent.PegGuid);
				}
				if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeSelf || val is Bomb || val is BouncerPeg)
				{
					return;
				}
				LongPeg val2 = (LongPeg)(object)((val is LongPeg) ? val : null);
				if (val2 != null)
				{
					LongPegVisualHelper.ApplyHitVisual(val2);
					return;
				}
				try
				{
					try
					{
						object? obj = AccessTools.Field(typeof(Peg), "PegCoinOverlayInstance")?.GetValue(val);
						PegCoinOverlay val3 = (PegCoinOverlay)((obj is PegCoinOverlay) ? obj : null);
						if ((Object)(object)val3 != (Object)null && val3.NumCoins > 0)
						{
							val3.CollectCoins(-1);
						}
					}
					catch
					{
					}
					AccessTools.Field(typeof(Peg), "_cleared")?.SetValue(val, true);
					if (val is RegularPeg)
					{
						AccessTools.Method(typeof(RegularPeg), "DisableRegularColliders", (Type[])null, (Type[])null)?.Invoke(val, null);
					}
					if (val is RegularPeg)
					{
						AccessTools.Method(typeof(RegularPeg), "PlayDestructionAnimation", (Type[])null, (Type[])null)?.Invoke(val, null);
					}
					else
					{
						((Component)val).gameObject.SetActive(false);
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)("[PegActivated] Visual pop failed: " + ex.Message));
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("PegActivated handler failed: " + ex2.Message));
				}
			}
		}
	}
	public sealed class PegActivatedServerHandler : IServerHandler<PegActivatedEvent>
	{
		public PegActivatedEvent Handle(PegActivatedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class PegDestroyedClientHandler : IClientHandler<PegDestroyedEvent>
	{
		public void Handle(PegDestroyedEvent networkEvent)
		{
			//IL_007c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: Invalid comparison between Unknown and I4
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				Peg val = null;
				if (!string.IsNullOrEmpty(networkEvent.PegGuid))
				{
					IServiceContainer services2 = MultiplayerPlugin.Services;
					val = ((services2 != null && services2.TryResolve<PegIdentifier>(out var instance2)) ? instance2 : null)?.Find(networkEvent.PegGuid);
				}
				if (!((Object)(object)val != (Object)null) || !((Component)val).gameObject.activeSelf || (int)val.pegType == 32)
				{
					return;
				}
				try
				{
					val.DestroyPeg(val.pegType);
				}
				catch
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("PegDestroyed handler failed: " + ex.Message));
			}
		}
	}
	public sealed class PegDestroyedServerHandler : IServerHandler<PegDestroyedEvent>
	{
		public PegDestroyedEvent Handle(PegDestroyedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class PegHitClientHandler : IClientHandler<PegHitEvent>
	{
		public void Handle(PegHitEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating || string.IsNullOrEmpty(e.PegGuid))
				{
					return;
				}
				IServiceContainer services2 = MultiplayerPlugin.Services;
				PegIdentifier instance2;
				Peg val = ((services2 != null && services2.TryResolve<PegIdentifier>(out instance2)) ? instance2 : null)?.Find(e.PegGuid);
				if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeSelf)
				{
					return;
				}
				if (e.HitCount >= 0)
				{
					Bomb val2 = (Bomb)(object)((val is Bomb) ? val : null);
					if (val2 != null && val2.HitCount != e.HitCount)
					{
						val2.HitCount = e.HitCount;
						try
						{
							Animator component = ((Component)val2).GetComponent<Animator>();
							if (component != null)
							{
								component.SetInteger("NumHits", e.HitCount);
							}
						}
						catch
						{
						}
					}
				}
				if (e.CoinCount >= 0)
				{
					try
					{
						object? obj2 = AccessTools.Field(typeof(Peg), "PegCoinOverlayInstance")?.GetValue(val);
						PegCoinOverlay val3 = (PegCoinOverlay)((obj2 is PegCoinOverlay) ? obj2 : null);
						if ((Object)(object)val3 != (Object)null && val3.NumCoins > e.CoinCount)
						{
							val3.CollectCoins(val3.NumCoins - e.CoinCount);
						}
					}
					catch
					{
					}
				}
				if (e.ShieldHitCount < 0 || e.ShieldHitLimit <= 0)
				{
					return;
				}
				try
				{
					object? obj4 = AccessTools.Field(typeof(Peg), "PegShieldOverlayInstance")?.GetValue(val);
					PegShieldOverlay val4 = (PegShieldOverlay)((obj4 is PegShieldOverlay) ? obj4 : null);
					if (!((Object)(object)val4 != (Object)null) || val4.hitCount == e.ShieldHitCount)
					{
						return;
					}
					val4.hitCount = e.ShieldHitCount;
					val4.hitLimit = e.ShieldHitLimit;
					try
					{
						Animator component2 = ((Component)val4).GetComponent<Animator>();
						if (component2 != null)
						{
							component2.SetInteger(Animator.StringToHash("HitCount"), e.ShieldHitCount);
						}
						SpriteRenderer component3 = ((Component)val4).GetComponent<SpriteRenderer>();
						if ((Object)(object)component3 != (Object)null)
						{
							((Renderer)component3).enabled = e.ShieldHitCount < e.ShieldHitLimit;
						}
					}
					catch
					{
					}
				}
				catch
				{
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("PegHit handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class PegHitServerHandler : IServerHandler<PegHitEvent>
	{
		public PegHitEvent Handle(PegHitEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.Map
{
	public sealed class NodeActivatedClientHandler : IClientHandler<NodeActivatedEvent>
	{
		public void Handle(NodeActivatedEvent e)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			try
			{
				IMultiplayerMode multiplayerMode = MultiplayerPlugin.Services?.Resolve<IMultiplayerMode>();
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				if (logger != null)
				{
					logger.LogInfo((object)$"[NodeActivated] Host battle={e.BattleName} at ({e.PosX:F1},{e.PosY:F1})");
				}
				if (!string.IsNullOrEmpty(e.RngState))
				{
					MultiplayerClientPatches.PendingBattleRngState = e.RngState;
					if (logger != null)
					{
						logger.LogInfo((object)"[NodeActivated] Stored host RNG state for pegboard sync");
					}
				}
				if (string.IsNullOrEmpty(e.BattleName) && !string.IsNullOrEmpty(e.MapDataName))
				{
					MapDataPegMinigame val = FindPegMinigameData(e.MapDataName, logger);
					if ((Object)(object)val != (Object)null)
					{
						if (logger != null)
						{
							logger.LogInfo((object)("[NodeActivated] PegMinigame node — loading scene for spectating (asset=" + e.MapDataName + ")"));
						}
						PegMinigameVisualAssigner.Assign(val, logger, "NodeActivated");
						StaticGameData.dataToLoad = (MapData)(object)val;
						MapStateApplier.AwaitingHostSceneConfirmation = "PegMinigame";
						MultiplayerClientPatches.AllowNextSceneLoad = true;
						MultiplayerClientPatches.AllowPegMinigameLogic = true;
						CoopRewardState.PegMinigamePhaseActive = true;
						CoopRewardState.ClientPegMinigameChoiceSent = false;
						CoopRewardState.PegMinigameAwaitingHostNavigation = false;
						PeglinSceneLoader instance = PeglinSceneLoader.Instance;
						if (instance != null)
						{
							instance.LoadScene((Scene)12, (LoadSceneMode)0, false, 0.5f);
						}
						return;
					}
					MapDataScenario val2 = FindTextScenarioData(e.MapDataName, logger);
					if ((Object)(object)val2 != (Object)null)
					{
						if (logger != null)
						{
							logger.LogInfo((object)("[NodeActivated] TextScenario node — loading scene for spectating (asset=" + e.MapDataName + ")"));
						}
						ScenarioVisualAssigner.Assign((MapData)(object)val2, logger, "NodeActivated");
						StaticGameData.dataToLoad = (MapData)(object)val2;
						TextScenarioHoverTracker.Reset();
						MapStateApplier.AwaitingHostSceneConfirmation = "TextScenario";
						MultiplayerClientPatches.AllowNextSceneLoad = true;
						PeglinSceneLoader instance2 = PeglinSceneLoader.Instance;
						if (instance2 != null)
						{
							instance2.LoadScene((Scene)10, (LoadSceneMode)0, false, 0.5f);
						}
						return;
					}
					MapDataShop val3 = FindShopData(e.MapDataName, logger);
					if ((Object)(object)val3 != (Object)null)
					{
						if (logger != null)
						{
							logger.LogInfo((object)("[NodeActivated] ShopScenario node — loading scene for interactive shopping (asset=" + e.MapDataName + ")"));
						}
						ScenarioVisualAssigner.Assign((MapData)(object)val3, logger, "NodeActivated");
						StaticGameData.dataToLoad = (MapData)(object)val3;
						MapStateApplier.AwaitingHostSceneConfirmation = "ShopScenario";
						MultiplayerClientPatches.AllowNextSceneLoad = true;
						PeglinSceneLoader instance3 = PeglinSceneLoader.Instance;
						if (instance3 != null)
						{
							instance3.LoadScene((Scene)13, (LoadSceneMode)0, false, 0.5f);
						}
						return;
					}
					MapDataTreasure val4 = FindTreasureData(e.MapDataName, logger);
					if ((Object)(object)val4 != (Object)null)
					{
						if (logger != null)
						{
							logger.LogInfo((object)("[NodeActivated] Treasure node — loading scene for native relic selection (asset=" + e.MapDataName + ")"));
						}
						ScenarioVisualAssigner.Assign((MapData)(object)val4, logger, "NodeActivated");
						StaticGameData.dataToLoad = (MapData)(object)val4;
						MapStateApplier.AwaitingHostSceneConfirmation = "Treasure";
						MultiplayerClientPatches.AllowNextSceneLoad = true;
						PeglinSceneLoader instance4 = PeglinSceneLoader.Instance;
						if (instance4 != null)
						{
							instance4.LoadScene((Scene)11, (LoadSceneMode)0, false, 0.5f);
						}
						return;
					}
				}
				if (string.IsNullOrEmpty(e.BattleName))
				{
					if (logger != null)
					{
						logger.LogInfo((object)"[NodeActivated] Non-battle node — MapStateApplier will handle scene transition");
					}
					return;
				}
				MapDataBattle[] array = Resources.FindObjectsOfTypeAll<MapDataBattle>();
				MapDataBattle val5 = ((IEnumerable<MapDataBattle>)array).FirstOrDefault((Func<MapDataBattle, bool>)((MapDataBattle b) => ((Object)b).name == e.BattleName)) ?? MapStateApplier.TryGetCachedBattle(e.BattleName);
				if ((Object)(object)val5 == (Object)null)
				{
					if (logger != null)
					{
						logger.LogWarning((object)$"[NodeActivated] MapDataBattle '{e.BattleName}' not found in {array.Length} loaded assets");
					}
					return;
				}
				AssignBattleVisuals(val5, logger);
				if (logger != null)
				{
					string[] obj = new string[10]
					{
						"[NodeActivated] Found MapDataBattle '",
						((Object)val5).name,
						"', pegLayout=",
						null,
						null,
						null,
						null,
						null,
						null,
						null
					};
					PegLayout pegLayout = val5.pegLayout;
					obj[3] = ((pegLayout != null) ? ((Object)pegLayout).name : null);
					obj[4] = ", ";
					object arg = val5.starterSpawns?.Count ?? (-1);
					WaveGroup[] waveGroups = val5.waveGroups;
					obj[5] = $"starterSpawns={arg}, waves={((waveGroups != null) ? waveGroups.Length : (-1))}, ";
					obj[6] = "background=";
					GameObject background = ((MapData)val5).background;
					obj[7] = ((background != null) ? ((Object)background).name : null) ?? "NULL";
					obj[8] = ", pegboardFrame=";
					GameObject pegboardFrame = ((MapData)val5).pegboardFrame;
					obj[9] = ((pegboardFrame != null) ? ((Object)pegboardFrame).name : null) ?? "NULL";
					logger.LogInfo((object)string.Concat(obj));
				}
				StaticGameData.dataToLoad = (MapData)(object)val5;
				MapStateApplier.AwaitingHostSceneConfirmation = "Battle";
				PeglinSceneLoader instance5 = PeglinSceneLoader.Instance;
				if ((Object)(object)instance5 != (Object)null)
				{
					if (logger != null)
					{
						logger.LogInfo((object)"[NodeActivated] Loading Battle scene with correct battle data");
					}
					MultiplayerClientPatches.AllowNextSceneLoad = true;
					instance5.LoadScene((Scene)9, (LoadSceneMode)0, false, 0.5f);
				}
				else
				{
					if (logger != null)
					{
						logger.LogWarning((object)"[NodeActivated] PeglinSceneLoader.Instance is null, using SceneManager fallback");
					}
					SceneManager.LoadScene("Battle");
				}
			}
			catch (Exception ex)
			{
				if (logger != null)
				{
					logger.LogError((object)("[NodeActivated] Failed: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}

		private static MapDataPegMinigame FindPegMinigameData(string assetName, ManualLogSource log)
		{
			try
			{
				MapDataPegMinigame[] array = Resources.FindObjectsOfTypeAll<MapDataPegMinigame>();
				foreach (MapDataPegMinigame val in array)
				{
					if (((Object)val).name == assetName)
					{
						return val;
					}
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[NodeActivated] FindPegMinigameData failed: " + ex.Message));
				}
			}
			return null;
		}

		private static MapDataScenario FindTextScenarioData(string assetName, ManualLogSource log)
		{
			try
			{
				MapDataScenario[] array = Resources.FindObjectsOfTypeAll<MapDataScenario>();
				MapDataScenario[] array2 = array;
				foreach (MapDataScenario val in array2)
				{
					if (((Object)val).name == assetName)
					{
						return val;
					}
				}
				if (log != null)
				{
					log.LogWarning((object)$"[NodeActivated] MapDataScenario '{assetName}' not found in {array.Length} loaded assets");
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[NodeActivated] FindTextScenarioData failed: " + ex.Message));
				}
			}
			return null;
		}

		private static MapDataShop FindShopData(string assetName, ManualLogSource log)
		{
			try
			{
				MapDataShop[] array = Resources.FindObjectsOfTypeAll<MapDataShop>();
				foreach (MapDataShop val in array)
				{
					if (((Object)val).name == assetName)
					{
						return val;
					}
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[NodeActivated] FindShopData failed: " + ex.Message));
				}
			}
			return null;
		}

		private static MapDataTreasure FindTreasureData(string assetName, ManualLogSource log)
		{
			try
			{
				MapDataTreasure[] array = Resources.FindObjectsOfTypeAll<MapDataTreasure>();
				foreach (MapDataTreasure val in array)
				{
					if (((Object)val).name == assetName)
					{
						return val;
					}
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[NodeActivated] FindTreasureData failed: " + ex.Message));
				}
			}
			return null;
		}

		private static void AssignBattleVisuals(MapDataBattle battle, ManualLogSource log)
		{
			BattleVisualAssigner.Assign(battle, log, "NodeActivated");
		}
	}
	internal static class PegMinigameVisualAssigner
	{
		public static void Assign(MapDataPegMinigame data, ManualLogSource log, string tag)
		{
			try
			{
				MapController instance = MapController.instance;
				if ((Object)(object)instance == (Object)null)
				{
					if (log != null)
					{
						log.LogWarning((object)("[" + tag + "] MapController.instance is null — cannot assign PegMinigame visuals"));
					}
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(MapController), "backgroundData");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(MapController), "backgroundIndex");
				Array array = fieldInfo?.GetValue(instance) as Array;
				int num = ((fieldInfo2 != null) ? ((int)fieldInfo2.GetValue(instance)) : 0);
				if (array != null && num >= 0 && num < array.Length)
				{
					object value = array.GetValue(num);
					if (value != null)
					{
						object? obj = value.GetType().GetField("Background")?.GetValue(value);
						GameObject val = (GameObject)(((obj is GameObject) ? obj : null) ?? ((object)/*isinst with value type is only supported in some contexts*/));
						if ((Object)(object)val != (Object)null)
						{
							((MapData)data).background = val;
							if (log != null)
							{
								log.LogInfo((object)("[" + tag + "] Assigned PegMinigame background: " + ((Object)val).name));
							}
						}
					}
				}
				GameObject[] array2 = AccessTools.Field(typeof(MapController), "pegMinigamePegboardFrame")?.GetValue(instance) as GameObject[];
				if (array2 != null && num >= 0 && num < array2.Length)
				{
					((MapData)data).pegboardFrame = array2[num];
					if (log != null)
					{
						GameObject obj2 = array2[num];
						log.LogInfo((object)("[" + tag + "] Assigned PegMinigame pegboardFrame: " + (((obj2 != null) ? ((Object)obj2).name : null) ?? "NULL")));
					}
				}
				else if (array2 != null && array2.Length != 0)
				{
					((MapData)data).pegboardFrame = array2[0];
					if (log != null)
					{
						GameObject obj3 = array2[0];
						log.LogInfo((object)("[" + tag + "] Assigned PegMinigame pegboardFrame (fallback idx 0): " + (((obj3 != null) ? ((Object)obj3).name : null) ?? "NULL")));
					}
				}
				if (!((Object)(object)data.bouncerPrefab == (Object)null) || array == null || num < 0 || num >= array.Length)
				{
					return;
				}
				object value2 = array.GetValue(num);
				if (value2 == null)
				{
					return;
				}
				object? obj4 = value2.GetType().GetField("BouncerPrefab")?.GetValue(value2);
				GameObject val2 = (GameObject)(((obj4 is GameObject) ? obj4 : null) ?? ((object)/*isinst with value type is only supported in some contexts*/));
				if ((Object)(object)val2 != (Object)null)
				{
					data.bouncerPrefab = val2;
					if (log != null)
					{
						log.LogInfo((object)("[" + tag + "] Assigned PegMinigame bouncerPrefab: " + ((Object)val2).name));
					}
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[" + tag + "] PegMinigameVisualAssigner.Assign failed: " + ex.Message));
				}
			}
		}
	}
	internal static class BattleVisualAssigner
	{
		public static void Assign(MapDataBattle battle, ManualLogSource log, string tag)
		{
			try
			{
				MapController instance = MapController.instance;
				if ((Object)(object)instance == (Object)null)
				{
					if (log != null)
					{
						log.LogWarning((object)("[" + tag + "] MapController.instance is null — cannot assign battle visuals"));
					}
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(MapController), "backgroundData");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(MapController), "backgroundIndex");
				Array array = fieldInfo?.GetValue(instance) as Array;
				int num = ((fieldInfo2 != null) ? ((int)fieldInfo2.GetValue(instance)) : 0);
				if (array != null && num >= 0 && num < array.Length)
				{
					object value = array.GetValue(num);
					if (value != null)
					{
						object? obj = value.GetType().GetField("Background")?.GetValue(value);
						GameObject val = (GameObject)(((obj is GameObject) ? obj : null) ?? ((object)/*isinst with value type is only supported in some contexts*/));
						if ((Object)(object)val != (Object)null)
						{
							((MapData)battle).background = val;
							if (log != null)
							{
								log.LogInfo((object)("[" + tag + "] Assigned background: " + ((Object)val).name));
							}
						}
					}
				}
				GameObject[] array2 = AccessTools.Field(typeof(MapController), "battlePegboardFrame")?.GetValue(instance) as GameObject[];
				if (array2 != null && num >= 0 && num < array2.Length)
				{
					((MapData)battle).pegboardFrame = array2[num];
					if (log != null)
					{
						GameObject obj2 = array2[num];
						log.LogInfo((object)("[" + tag + "] Assigned pegboardFrame: " + (((obj2 != null) ? ((Object)obj2).name : null) ?? "NULL")));
					}
				}
				else if (array2 != null && array2.Length != 0)
				{
					((MapData)battle).pegboardFrame = array2[0];
					if (log != null)
					{
						GameObject obj3 = array2[0];
						log.LogInfo((object)("[" + tag + "] Assigned pegboardFrame (fallback idx 0): " + (((obj3 != null) ? ((Object)obj3).name : null) ?? "NULL")));
					}
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[" + tag + "] AssignBattleVisuals failed: " + ex.Message));
				}
			}
		}
	}
	internal static class ScenarioVisualAssigner
	{
		public static void Assign(MapData md, ManualLogSource log, string tag)
		{
			try
			{
				if ((Object)(object)md == (Object)null)
				{
					return;
				}
				MapController instance = MapController.instance;
				if ((Object)(object)instance == (Object)null)
				{
					if (log != null)
					{
						log.LogWarning((object)("[" + tag + "] MapController.instance is null — cannot assign scenario visuals"));
					}
					return;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(MapController), "backgroundData");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(MapController), "backgroundIndex");
				Array array = fieldInfo?.GetValue(instance) as Array;
				int num = ((fieldInfo2 != null) ? ((int)fieldInfo2.GetValue(instance)) : 0);
				if (array != null && num >= 0 && num < array.Length)
				{
					object value = array.GetValue(num);
					if (value != null)
					{
						object? obj = value.GetType().GetField("Background")?.GetValue(value);
						GameObject val = (GameObject)(((obj is GameObject) ? obj : null) ?? ((object)/*isinst with value type is only supported in some contexts*/));
						if ((Object)(object)val != (Object)null)
						{
							md.background = val;
							if (log != null)
							{
								log.LogInfo((object)("[" + tag + "] Assigned scenario background (" + ((object)md).GetType().Name + "): " + ((Object)val).name));
							}
						}
					}
				}
				if (AccessTools.Field(typeof(MapController), "scenarioPegboardFrame")?.GetValue(instance) is GameObject[] array2 && array2.Length != 0)
				{
					int num2 = ((num >= 0 && num < array2.Length) ? num : 0);
					md.pegboardFrame = array2[num2];
					if (log != null)
					{
						GameObject obj2 = array2[num2];
						log.LogInfo((object)("[" + tag + "] Assigned scenario pegboardFrame: " + (((obj2 != null) ? ((Object)obj2).name : null) ?? "NULL")));
					}
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[" + tag + "] ScenarioVisualAssigner.Assign failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class NodeActivatedServerHandler : IServerHandler<NodeActivatedEvent>
	{
		public NodeActivatedEvent Handle(NodeActivatedEvent e)
		{
			return e;
		}
	}
	public sealed class NodeSelectedClientHandler : IClientHandler<NodeSelectedEvent>
	{
		public void Handle(NodeSelectedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Map node selected - {networkEvent.MapName} floor {networkEvent.Floor} (cruciball {networkEvent.CruciballLevel})");
				NodeSelectionEvent onNodeSelectionEvent = MapController.OnNodeSelectionEvent;
				if (onNodeSelectionEvent != null)
				{
					onNodeSelectionEvent.Invoke(networkEvent.MapName, networkEvent.Floor, networkEvent.CruciballLevel);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("NodeSelected handler failed: " + ex.Message));
			}
		}
	}
	public sealed class NodeSelectedServerHandler : IServerHandler<NodeSelectedEvent>
	{
		public NodeSelectedEvent Handle(NodeSelectedEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.Lobby
{
	public sealed class ClassSelectClientHandler : IClientHandler<ClassSelectEvent>
	{
		public void Handle(ClassSelectEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting || !services.TryResolve<PlayerRegistry>(out var instance2) || !services.TryResolve<IGameEventRegistry>(out var instance3))
			{
				return;
			}
			int num = (instance3 as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
			PlayerSlot slotByPeerId = instance2.GetSlotByPeerId(num);
			if (slotByPeerId == null)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"[ClassSelect] No slot for peer {num}");
				}
				return;
			}
			if (ContinueSession.IsActive)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[ClassSelect] Ignoring class change from {slotByPeerId.PlayerName} (continue lobby — class locked at {slotByPeerId.ChosenClass})");
				}
				return;
			}
			slotByPeerId.ChosenClass = networkEvent.ChosenClass;
			ManualLogSource logger3 = MultiplayerPlugin.Logger;
			if (logger3 != null)
			{
				logger3.LogInfo((object)$"[ClassSelect] {slotByPeerId.PlayerName} chose class {networkEvent.ChosenClass}");
			}
			LobbyHelper.BroadcastLobbyState(instance2, instance3);
		}
	}
	public sealed class ClassSelectServerHandler : IServerHandler<ClassSelectEvent>
	{
		public ClassSelectEvent Handle(ClassSelectEvent networkEvent)
		{
			return null;
		}
	}
	public sealed class GameStartClientHandler : IClientHandler<GameStartEvent>
	{
		public void Handle(GameStartEvent networkEvent)
		{
			//IL_0104: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[GameStart] Received game start with {networkEvent.FinalPlayers?.Count ?? 0} players");
				}
				if (networkEvent.FinalPlayers != null)
				{
					string localName = MultiplayerUI.LocalPlayerName;
					LobbyPlayerEntry lobbyPlayerEntry = null;
					if (!string.IsNullOrEmpty(localName))
					{
						lobbyPlayerEntry = networkEvent.FinalPlayers.FirstOrDefault((LobbyPlayerEntry p) => !p.IsHost && p.PlayerName == localName);
					}
					if (lobbyPlayerEntry == null)
					{
						lobbyPlayerEntry = networkEvent.FinalPlayers.FirstOrDefault((LobbyPlayerEntry p) => !p.IsHost);
						if (lobbyPlayerEntry != null)
						{
							ManualLogSource logger2 = MultiplayerPlugin.Logger;
							if (logger2 != null)
							{
								logger2.LogWarning((object)$"[GameStart] Could not match local name '{localName}' to any non-host entry; falling back to first non-host (slot {lobbyPlayerEntry.SlotIndex}). This will misroute events with 3+ players.");
							}
						}
					}
					if (lobbyPlayerEntry != null)
					{
						int chosenClass = lobbyPlayerEntry.ChosenClass;
						StaticGameData.chosenClass = (Class)chosenClass;
						ManualLogSource logger3 = MultiplayerPlugin.Logger;
						if (logger3 != null)
						{
							logger3.LogInfo((object)$"[GameStart] Set client class to {lobbyPlayerEntry.ChosenClassName} ({lobbyPlayerEntry.ChosenClass})");
						}
						MultiplayerClientPatches.SetStartingLoadoutFromClass((Class)chosenClass);
						MultiplayerClientPatches.SetCruciballManagerClass((Class)chosenClass);
						MultiplayerClientPatches.SetCruciballManagerLevel(networkEvent.CruciballLevel);
						MultiplayerClientPatches.SetRelicManagerClass((Class)chosenClass);
					}
					IServiceContainer services2 = MultiplayerPlugin.Services;
					if (services2 != null && services2.TryResolve<PlayerRegistry>(out var instance2) && lobbyPlayerEntry != null)
					{
						PlayerSlot obj = instance2.GetSlotByIndex(lobbyPlayerEntry.SlotIndex) ?? new PlayerSlot
						{
							SlotIndex = lobbyPlayerEntry.SlotIndex,
							PeerId = -1,
							PlayerName = lobbyPlayerEntry.PlayerName,
							IsHost = false,
							ChosenClass = lobbyPlayerEntry.ChosenClass,
							IsReady = true
						};
						PlayerSlot playerSlot2 = (instance2.LocalSlot = obj);
						ManualLogSource logger4 = MultiplayerPlugin.Logger;
						if (logger4 != null)
						{
							logger4.LogInfo((object)$"[GameStart] Set LocalSlot: index={playerSlot2.SlotIndex}, name={playerSlot2.PlayerName}");
						}
					}
				}
				LobbyUI.OnGameStartReceived(networkEvent);
			}
			catch (Exception ex)
			{
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogWarning((object)("[GameStart] Handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class GameStartServerHandler : IServerHandler<GameStartEvent>
	{
		public GameStartEvent Handle(GameStartEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public static class LobbyHelper
	{
		private static readonly string[] ClassNames = new string[4] { "Peglin", "Balladin", "Roundrel", "Spinventor" };

		public static string GetClassName(int classIndex)
		{
			if (classIndex >= 0 && classIndex < ClassNames.Length)
			{
				return ClassNames[classIndex];
			}
			return $"Unknown({classIndex})";
		}

		public static void BroadcastLobbyState(PlayerRegistry registry, IGameEventRegistry eventRegistry)
		{
			List<LobbyPlayerEntry> present = (from s in registry.GetAllSlots()
				select new LobbyPlayerEntry
				{
					SlotIndex = s.SlotIndex,
					PlayerName = s.PlayerName,
					ChosenClass = s.ChosenClass,
					ChosenClassName = GetClassName(s.ChosenClass),
					IsReady = s.IsReady,
					IsHost = s.IsHost,
					GameVersion = s.GameVersion,
					ModVersion = s.ModVersion
				}).ToList();
			LobbyStateEvent networkEvent = new LobbyStateEvent
			{
				Players = BuildOrderedRoster(present),
				CruciballLevel = LobbyUI.HostCruciballLevel,
				IsContinue = ContinueSession.IsActive
			};
			eventRegistry.Dispatch(networkEvent);
		}

		public static List<LobbyPlayerEntry> BuildOrderedRoster(List<LobbyPlayerEntry> present)
		{
			if (!ContinueSession.IsActive || ContinueSession.ActiveSave?.Players == null)
			{
				return present;
			}
			Dictionary<string, LobbyPlayerEntry> dictionary = new Dictionary<string, LobbyPlayerEntry>(StringComparer.OrdinalIgnoreCase);
			foreach (LobbyPlayerEntry item in present)
			{
				string key = ContinueFiles.Sanitize(item.PlayerName ?? string.Empty);
				if (!dictionary.ContainsKey(key))
				{
					dictionary[key] = item;
				}
			}
			List<LobbyPlayerEntry> list = new List<LobbyPlayerEntry>();
			foreach (ContinuePlayer item2 in ContinueSession.ActiveSave.Players.OrderBy((ContinuePlayer p) => p.SlotIndex))
			{
				string key2 = ContinueFiles.Sanitize(item2.PlayerName ?? string.Empty);
				if (dictionary.TryGetValue(key2, out var value))
				{
					value.IsMissing = false;
					list.Add(value);
					continue;
				}
				list.Add(new LobbyPlayerEntry
				{
					SlotIndex = item2.SlotIndex,
					PlayerName = item2.PlayerName,
					ChosenClass = item2.ChosenClass,
					ChosenClassName = GetClassName(item2.ChosenClass),
					IsReady = false,
					IsHost = (item2.SlotIndex == 0),
					GameVersion = string.Empty,
					ModVersion = string.Empty,
					IsMissing = true
				});
			}
			return list;
		}
	}
	public sealed class LobbyStateClientHandler : IClientHandler<LobbyStateEvent>
	{
		public void Handle(LobbyStateEvent networkEvent)
		{
			LobbyUI.ApplyLobbyState(networkEvent);
		}
	}
	public sealed class LobbyStateServerHandler : IServerHandler<LobbyStateEvent>
	{
		public LobbyStateEvent Handle(LobbyStateEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class ReadyClientHandler : IClientHandler<ReadyEvent>
	{
		public void Handle(ReadyEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting || !services.TryResolve<PlayerRegistry>(out var instance2) || !services.TryResolve<IGameEventRegistry>(out var instance3))
			{
				return;
			}
			int peerId = (instance3 as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
			PlayerSlot slotByPeerId = instance2.GetSlotByPeerId(peerId);
			if (slotByPeerId != null)
			{
				slotByPeerId.IsReady = networkEvent.IsReady;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)("[Ready] " + slotByPeerId.PlayerName + " is " + (networkEvent.IsReady ? "READY" : "NOT READY")));
				}
				LobbyHelper.BroadcastLobbyState(instance2, instance3);
			}
		}
	}
	public sealed class ReadyServerHandler : IServerHandler<ReadyEvent>
	{
		public ReadyEvent Handle(ReadyEvent networkEvent)
		{
			return null;
		}
	}
}
namespace Multipeglin.Events.Handlers.Health
{
	public sealed class ArmourHitClientHandler : IClientHandler<ArmourHitEvent>
	{
		public void Handle(ArmourHitEvent networkEvent)
		{
			try
			{
				PlayerHealthEvent onArmourHit = PlayerHealthController.OnArmourHit;
				if (onArmourHit != null)
				{
					onArmourHit.Invoke(networkEvent.Damage);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("ArmourHit handler failed: " + ex.Message));
			}
		}
	}
	public sealed class ArmourHitServerHandler : IServerHandler<ArmourHitEvent>
	{
		public ArmourHitEvent Handle(ArmourHitEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class DodgeClientHandler : IClientHandler<DodgeEvent>
	{
		public void Handle(DodgeEvent networkEvent)
		{
			try
			{
				PlayerHealthEvent onDodge = PlayerHealthController.OnDodge;
				if (onDodge != null)
				{
					onDodge.Invoke(networkEvent.DodgeInfo);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("Dodge handler failed: " + ex.Message));
			}
		}
	}
	public sealed class DodgeServerHandler : IServerHandler<DodgeEvent>
	{
		public DodgeEvent Handle(DodgeEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class HealthDepletedClientHandler : IClientHandler<HealthDepletedEvent>
	{
		public void Handle(HealthDepletedEvent networkEvent)
		{
			try
			{
				HealthEvent onHealthDepleted = PlayerHealthController.OnHealthDepleted;
				if (onHealthDepleted != null)
				{
					onHealthDepleted.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("HealthDepleted handler failed: " + ex.Message));
			}
		}
	}
	public sealed class HealthDepletedServerHandler : IServerHandler<HealthDepletedEvent>
	{
		public HealthDepletedEvent Handle(HealthDepletedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class MaxHealthChangedClientHandler : IClientHandler<MaxHealthChangedEvent>
	{
		public void Handle(MaxHealthChangedEvent networkEvent)
		{
			try
			{
				if (!CoopRewardState.ClientInNativeRewardPhase)
				{
					PlayerHealthEvent onPlayerMaxHealthChanged = PlayerHealthController.OnPlayerMaxHealthChanged;
					if (onPlayerMaxHealthChanged != null)
					{
						onPlayerMaxHealthChanged.Invoke(networkEvent.NewMaxHealth);
					}
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("MaxHealthChanged handler failed: " + ex.Message));
			}
		}
	}
	public sealed class MaxHealthChangedServerHandler : IServerHandler<MaxHealthChangedEvent>
	{
		public MaxHealthChangedEvent Handle(MaxHealthChangedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class PlayerDamagedClientHandler : IClientHandler<PlayerDamagedEvent>
	{
		public void Handle(PlayerDamagedEvent e)
		{
			try
			{
				if (CoopRewardState.ClientInNativeRewardPhase)
				{
					return;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val != (Object)null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth");
					FieldInfo fieldInfo2 = AccessTools.Field(typeof(PlayerHealthController), "_maxPlayerHealth");
					object? obj = fieldInfo?.GetValue(val);
					object? obj2 = ((obj is FloatVariable) ? obj : null);
					object? obj3 = fieldInfo2?.GetValue(val);
					object? obj4 = ((obj3 is FloatVariable) ? obj3 : null);
					if (obj4 != null)
					{
						((FloatVariable)obj4).Set(e.MaxHealth);
					}
					if (obj2 != null)
					{
						((FloatVariable)obj2).Set(e.RemainingHealth);
					}
				}
				PlayerHealthEvent onPlayerDamaged = PlayerHealthController.OnPlayerDamaged;
				if (onPlayerDamaged != null)
				{
					onPlayerDamaged.Invoke(e.Damage);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("PlayerDamaged handler failed: " + ex.Message));
			}
		}
	}
	public sealed class PlayerDamagedServerHandler : IServerHandler<PlayerDamagedEvent>
	{
		public PlayerDamagedEvent Handle(PlayerDamagedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class PlayerHealedClientHandler : IClientHandler<PlayerHealedEvent>
	{
		public void Handle(PlayerHealedEvent networkEvent)
		{
			try
			{
				if (CoopRewardState.ClientInNativeRewardPhase)
				{
					return;
				}
				if (networkEvent.TargetSlotIndex >= 0)
				{
					int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(MultiplayerPlugin.Services);
					if (localSlotIndex >= 0 && networkEvent.TargetSlotIndex != localSlotIndex)
					{
						return;
					}
				}
				PlayerHealthController val = Object.FindObjectOfType<PlayerHealthController>();
				if ((Object)(object)val != (Object)null)
				{
					object? obj = AccessTools.Field(typeof(PlayerHealthController), "_playerHealth")?.GetValue(val);
					object? obj2 = ((obj is FloatVariable) ? obj : null);
					if (obj2 != null)
					{
						((FloatVariable)obj2).Set(networkEvent.RemainingHealth);
					}
				}
				PlayerHealthEvent onPlayerHealed = PlayerHealthController.OnPlayerHealed;
				if (onPlayerHealed != null)
				{
					onPlayerHealed.Invoke(networkEvent.Amount);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("PlayerHealed handler failed: " + ex.Message));
			}
		}
	}
	public sealed class PlayerHealedServerHandler : IServerHandler<PlayerHealedEvent>
	{
		public PlayerHealedEvent Handle(PlayerHealedEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.Enemy
{
	public sealed class EnemyAttackClientHandler : IClientHandler<EnemyAttackEvent>
	{
		public void Handle(EnemyAttackEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				Enemy val = MultiplayerPlugin.Services.Resolve<EnemyIdentifier>().Find(e.EnemyId);
				if ((Object)(object)val != (Object)null)
				{
					EnemyAttacked onEnemyAttack = Enemy.OnEnemyAttack;
					if (onEnemyAttack != null)
					{
						onEnemyAttack.Invoke(e.Damage, e.IsMelee, val, (DamageSource)3, false);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("EnemyAttack handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class EnemyAttackServerHandler : IServerHandler<EnemyAttackEvent>
	{
		public EnemyAttackEvent Handle(EnemyAttackEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class EnemyDamagedClientHandler : IClientHandler<EnemyDamagedEvent>
	{
		private static readonly HashSet<string> _warnedMissing = new HashSet<string>();

		public void Handle(EnemyDamagedEvent networkEvent)
		{
			try
			{
				Enemy val = MultiplayerPlugin.Services.Resolve<EnemyIdentifier>().Find(networkEvent.EnemyId);
				if ((Object)(object)val != (Object)null)
				{
					val.CurrentHealth = networkEvent.RemainingHealth;
					EnemyDamaged onEnemyDamaged = Enemy.OnEnemyDamaged;
					if (onEnemyDamaged != null)
					{
						onEnemyDamaged.Invoke(val, networkEvent.Damage, (EnemyDamageSource)networkEvent.DamageSource);
					}
				}
				else if (_warnedMissing.Add(networkEvent.EnemyId))
				{
					MultiplayerPlugin.Logger.LogWarning((object)("[EnemyDamaged] Could not find enemy guid=" + networkEvent.EnemyId + " (will not warn again for this guid)"));
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("EnemyDamaged handler failed: " + ex.Message));
			}
		}
	}
	public sealed class EnemyDamagedServerHandler : IServerHandler<EnemyDamagedEvent>
	{
		public EnemyDamagedEvent Handle(EnemyDamagedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class EnemyDestroyedClientHandler : IClientHandler<EnemyDestroyedEvent>
	{
		public void Handle(EnemyDestroyedEvent networkEvent)
		{
			try
			{
				EnemyIdentifier enemyIdentifier = MultiplayerPlugin.Services.Resolve<EnemyIdentifier>();
				Enemy val = enemyIdentifier.Find(networkEvent.EnemyId);
				if ((Object)(object)val != (Object)null)
				{
					enemyIdentifier.Unregister(networkEvent.EnemyId);
					EnemyManager obj = Object.FindObjectOfType<EnemyManager>();
					if (obj != null)
					{
						obj.RemoveEnemy(val);
					}
					Object.Destroy((Object)(object)((Component)val).gameObject);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("EnemyDestroyed handler failed: " + ex.Message));
			}
		}
	}
	public sealed class EnemyDestroyedServerHandler : IServerHandler<EnemyDestroyedEvent>
	{
		public EnemyDestroyedEvent Handle(EnemyDestroyedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class EnemyKilledClientHandler : IClientHandler<EnemyKilledEvent>
	{
		public void Handle(EnemyKilledEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				Enemy val = MultiplayerPlugin.Services.Resolve<EnemyIdentifier>().Find(e.EnemyId);
				if (!((Object)(object)val != (Object)null))
				{
					return;
				}
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)("[EnemyKilled] '" + val.locKey + "' (guid=" + e.EnemyId + ") hp → 0"));
				}
				val.CurrentHealth = 0f;
				try
				{
					AccessTools.Method(typeof(Enemy), "UpdateHealthBar", (Type[])null, (Type[])null)?.Invoke(val, null);
				}
				catch
				{
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("EnemyKilled handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class EnemyKilledServerHandler : IServerHandler<EnemyKilledEvent>
	{
		public EnemyKilledEvent Handle(EnemyKilledEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class EnemyMovedClientHandler : IClientHandler<EnemyMovedEvent>
	{
		public void Handle(EnemyMovedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)$"[EnemyMoved] guid={networkEvent.EnemyId} slot {networkEvent.FromSlot} → {networkEvent.ToSlot}");
				Enemy val = MultiplayerPlugin.Services.Resolve<EnemyIdentifier>().Find(networkEvent.EnemyId);
				if ((Object)(object)val != (Object)null)
				{
					MultiplayerPlugin.Logger.LogInfo((object)("[EnemyMoved] Found '" + val.locKey + "' by GUID"));
				}
				else
				{
					MultiplayerPlugin.Logger.LogWarning((object)("[EnemyMoved] Could not find enemy guid=" + networkEvent.EnemyId));
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("EnemyMoved handler failed: " + ex.Message));
			}
		}
	}
	public sealed class EnemyMovedServerHandler : IServerHandler<EnemyMovedEvent>
	{
		public EnemyMovedEvent Handle(EnemyMovedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class EnemySpawnedClientHandler : IClientHandler<EnemySpawnedEvent>
	{
		public void Handle(EnemySpawnedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Enemy spawned {networkEvent.LocKey} at slot {networkEvent.SlotIndex} (HP: {networkEvent.CurrentHealth}/{networkEvent.MaxHealth})");
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("EnemySpawned handler failed: " + ex.Message));
			}
		}
	}
	public sealed class EnemySpawnedServerHandler : IServerHandler<EnemySpawnedEvent>
	{
		public EnemySpawnedEvent Handle(EnemySpawnedEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.Deck
{
	public sealed class BallDrawnClientHandler : IClientHandler<BallDrawnEvent>
	{
		public void Handle(BallDrawnEvent e)
		{
			try
			{
				if (LobbyUI.GameStartReceived)
				{
					return;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Drew orb {e.OrbName} (level {e.Level})");
				DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
				DeckManager val = ((array.Length != 0) ? array[0] : null);
				if (val?.shuffledDeck != null && val.shuffledDeck.Count > 0)
				{
					GameObject val2 = val.shuffledDeck.Peek();
					BallDrawn onBallDrawn = DeckManager.onBallDrawn;
					if (onBallDrawn != null)
					{
						onBallDrawn.Invoke(val2);
					}
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("BallDrawn handler failed: " + ex.Message));
			}
		}
	}
	public sealed class BallDrawnServerHandler : IServerHandler<BallDrawnEvent>
	{
		public BallDrawnEvent Handle(BallDrawnEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class BallUpgradedClientHandler : IClientHandler<BallUpgradedEvent>
	{
		public void Handle(BallUpgradedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Orb upgraded {networkEvent.PreviousOrbName} -> {networkEvent.NewOrbName} (level {networkEvent.NewLevel})");
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("BallUpgraded handler failed: " + ex.Message));
			}
		}
	}
	public sealed class BallUpgradedServerHandler : IServerHandler<BallUpgradedEvent>
	{
		public BallUpgradedEvent Handle(BallUpgradedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class BallUsedClientHandler : IClientHandler<BallUsedEvent>
	{
		public void Handle(BallUsedEvent e)
		{
			try
			{
				if (LobbyUI.GameStartReceived)
				{
					return;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
				DeckManager val = ((array.Length != 0) ? array[0] : null);
				if ((Object)(object)val == (Object)null || val.shuffledDeck == null || val.shuffledDeck.Count == 0)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)("[BallUsed] shuffledDeck empty, cannot draw for '" + e.OrbName + "'"));
					}
					return;
				}
				DeckInfoManager val2 = Object.FindObjectOfType<DeckInfoManager>();
				if ((Object)(object)val2 != (Object)null && DeckInfoManager.animating)
				{
					ForceCompleteShuffleAnimation(val2);
				}
				GameObject val3 = val.shuffledDeck.Pop();
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[BallUsed] Popped '{((val3 != null) ? ((Object)val3).name : null)}' ({val.shuffledDeck.Count} remaining)");
				}
				if ((Object)(object)val2 != (Object)null && val2.displayOrbs != null && val2.displayOrbs.Count > 0)
				{
					SetActiveOrbDirectly(val2);
				}
				else
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)$"[BallUsed] displayOrbs empty ({((val2 == null) ? null : val2.displayOrbs?.Count).GetValueOrDefault(-1)}) — cannot set active orb");
					}
				}
				ClientBallRenderer.Instance?.OnOrbDrawn((val3 != null) ? ((Object)val3).name : null);
			}
			catch (Exception ex)
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("BallUsed handler failed: " + ex.Message));
				}
			}
		}

		private static void SetActiveOrbDirectly(DeckInfoManager dim)
		{
			//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d3: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d7: Unknown result type (might be due to invalid IL or missing references)
			//IL_0139: Unknown result type (might be due to invalid IL or missing references)
			//IL_0143: Unknown result type (might be due to invalid IL or missing references)
			//IL_0129: Unknown result type (might be due to invalid IL or missing references)
			//IL_0161: Unknown result type (might be due to invalid IL or missing references)
			//IL_0166: Unknown result type (might be due to invalid IL or missing references)
			//IL_016d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0172: Unknown result type (might be due to invalid IL or missing references)
			//IL_02c7: Unknown result type (might be due to invalid IL or missing references)
			//IL_02ed: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				GameObject val = dim.displayOrbs.Pop();
				object? obj = AccessTools.Field(typeof(DeckInfoManager), "_plungerParent")?.GetValue(dim);
				Transform val2 = (Transform)((obj is Transform) ? obj : null);
				if ((Object)(object)val2 != (Object)null)
				{
					DOTween.Kill((object)val2, false);
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(DeckInfoManager), "_currentOrb");
				object? obj2 = fieldInfo?.GetValue(dim);
				GameObject val3 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				if ((Object)(object)val3 != (Object)null)
				{
					DOTween.Kill((object)val3.transform, false);
					Object.Destroy((Object)(object)val3);
				}
				AccessTools.Field(typeof(DeckInfoManager), "_nextOrb")?.SetValue(dim, null);
				DOTween.Kill((object)val.transform, false);
				SpriteRenderer component = val.GetComponent<SpriteRenderer>();
				float num;
				if (!((Object)(object)component != (Object)null))
				{
					num = 0f;
				}
				else
				{
					Bounds bounds = ((Renderer)component).bounds;
					num = ((Bounds)(ref bounds)).size.y;
				}
				float num2 = num;
				val.transform.SetParent((Transform)null);
				object? obj3 = AccessTools.Field(typeof(DeckInfoManager), "_currentOrbDisplayPos")?.GetValue(dim);
				Transform val4 = (Transform)((obj3 is Transform) ? obj3 : null);
				if ((Object)(object)val4 != (Object)null)
				{
					val.transform.position = val4.position;
				}
				val.transform.localScale = Vector3.one * 0.85f;
				if ((Object)(object)val2 != (Object)null && num2 > 0f)
				{
					val2.position += Vector3.up * num2;
				}
				UpcomingOrbDisplay componentInChildren = val.GetComponentInChildren<UpcomingOrbDisplay>();
				int num3 = 0;
				if ((Object)(object)((componentInChildren != null) ? componentInChildren.attack : null) != (Object)null)
				{
					num3 = Mathf.Clamp(componentInChildren.attack.Level - 1, 0, 2);
				}
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(DeckInfoManager), "_currentOrbLevelRingRenderer");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(DeckInfoManager), "_orbLevelDisplaySprites");
				object? obj4 = fieldInfo2?.GetValue(dim);
				SpriteRenderer val5 = (SpriteRenderer)((obj4 is SpriteRenderer) ? obj4 : null);
				Sprite[] array = fieldInfo3?.GetValue(dim) as Sprite[];
				if ((Object)(object)val5 != (Object)null && array != null && num3 < array.Length)
				{
					val5.sprite = array[num3];
				}
				if ((Object)(object)((componentInChildren != null) ? componentInChildren.mainOrbLevelFrameMask : null) != (Object)null)
				{
					componentInChildren.mainOrbLevelFrameMask.SetActive(true);
				}
				fieldInfo?.SetValue(dim, val);
				Animator componentInChildren2 = val.GetComponentInChildren<Animator>();
				if ((Object)(object)componentInChildren2 != (Object)null)
				{
					componentInChildren2.speed = 1f;
				}
				OrbInfoEvent onActiveOrbScaleStarted = DeckInfoManager.onActiveOrbScaleStarted;
				if (onActiveOrbScaleStarted != null)
				{
					onActiveOrbScaleStarted.Invoke(val);
				}
				DeckInfoAnim onActiveOrbScaleCompleted = DeckInfoManager.onActiveOrbScaleCompleted;
				if (onActiveOrbScaleCompleted != null)
				{
					onActiveOrbScaleCompleted.Invoke();
				}
				DeckInfoManager.populatingDisplayOrb = false;
				DeckInfoManager.animating = false;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[BallUsed] Set active orb directly at ({((val4 != null) ? new float?(val4.position.x) : null):F1},{((val4 != null) ? new float?(val4.position.y) : null):F1}), displayOrbs remaining: {dim.displayOrbs.Count}");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[BallUsed] SetActiveOrbDirectly failed: " + ex.Message));
				}
				DeckInfoManager.populatingDisplayOrb = false;
			}
		}

		private static void ForceCompleteShuffleAnimation(DeckInfoManager dim)
		{
			try
			{
				object? obj = AccessTools.Field(typeof(DeckInfoManager), "_plungerParent")?.GetValue(dim);
				Transform val = (Transform)((obj is Transform) ? obj : null);
				if ((Object)(object)val != (Object)null)
				{
					int num = 0;
					while (DeckInfoManager.animating && num++ < 5)
					{
						DOTween.Complete((object)val, true);
					}
				}
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[BallUsed] Force-completed shuffle animation (still animating: {DeckInfoManager.animating})");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[BallUsed] Failed to complete shuffle anim: " + ex.Message));
				}
			}
		}
	}
	public sealed class BallUsedServerHandler : IServerHandler<BallUsedEvent>
	{
		public BallUsedEvent Handle(BallUsedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class DeckShuffledClientHandler : IClientHandler<DeckShuffledEvent>
	{
		public void Handle(DeckShuffledEvent networkEvent)
		{
			try
			{
				if (!LobbyUI.GameStartReceived)
				{
					MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Deck shuffled ({networkEvent.DeckSize} cards)");
					Shuffled onDeckShuffled = DeckManager.onDeckShuffled;
					if (onDeckShuffled != null)
					{
						onDeckShuffled.Invoke(networkEvent.DeckSize);
					}
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("DeckShuffled handler failed: " + ex.Message));
			}
		}
	}
	public sealed class DeckShuffledServerHandler : IServerHandler<DeckShuffledEvent>
	{
		public DeckShuffledEvent Handle(DeckShuffledEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.Cursor
{
	public sealed class CursorPositionClientHandler : IClientHandler<CursorPositionEvent>
	{
		public void Handle(CursorPositionEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null)
				{
					return;
				}
				services.TryResolve<IMultiplayerMode>(out var instance);
				services.TryResolve<PlayerRegistry>(out var instance2);
				int num = LocalSlotIndex(instance, instance2);
				if (e.FromSlot != num)
				{
					RemoteCursorRenderer.Instance?.SetRemoteCursor(e.FromSlot, e.WorldX, e.WorldY);
					if (instance != null && instance.IsHosting && services.TryResolve<IMessageSender>(out var instance3))
					{
						instance3.Send(e);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("CursorPosition handler failed: " + ex.Message));
				}
			}
		}

		private static int LocalSlotIndex(IMultiplayerMode mode, PlayerRegistry registry)
		{
			if (mode != null && mode.IsHosting)
			{
				return 0;
			}
			return (registry?.LocalSlot?.SlotIndex).GetValueOrDefault(-1);
		}
	}
	public sealed class CursorPositionServerHandler : IServerHandler<CursorPositionEvent>
	{
		public CursorPositionEvent Handle(CursorPositionEvent networkEvent)
		{
			return null;
		}
	}
}
namespace Multipeglin.Events.Handlers.Currency
{
	public sealed class GoldChangedClientHandler : IClientHandler<GoldChangedEvent>
	{
		public void Handle(GoldChangedEvent networkEvent)
		{
			try
			{
				if (CoopRewardState.ClientInNativeRewardPhase)
				{
					MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Ignoring GoldChanged during reward phase (host gold {networkEvent.NewAmount}, keeping client's local gold)");
					return;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<CoopStateManager>(out var instance) && instance.TotalPlayerCount > 1)
				{
					MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Ignoring GoldChanged in coop (host gold {networkEvent.NewAmount}, client gold is per-slot)");
					return;
				}
				MultiplayerPlugin.Logger.LogInfo((object)string.Format("Multiplayer: Gold changed {0} -> {1} ({2}{3})", networkEvent.PreviousAmount, networkEvent.NewAmount, networkEvent.IsGain ? "+" : string.Empty, networkEvent.Delta));
				CurrencyManager val = Object.FindObjectOfType<CurrencyManager>();
				if ((Object)(object)val != (Object)null)
				{
					AccessTools.Field(typeof(CurrencyManager), "<GoldAmount>k__BackingField")?.SetValue(val, networkEvent.NewAmount);
				}
				if (networkEvent.IsGain)
				{
					CurrencyEvent onGoldAdded = CurrencyManager.OnGoldAdded;
					if (onGoldAdded != null)
					{
						onGoldAdded.Invoke(networkEvent.PreviousAmount, networkEvent.Delta, false);
					}
				}
				else
				{
					CurrencyEvent onGoldRemoved = CurrencyManager.OnGoldRemoved;
					if (onGoldRemoved != null)
					{
						onGoldRemoved.Invoke(networkEvent.PreviousAmount, -networkEvent.Delta, false);
					}
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("Gold update failed: " + ex.Message));
			}
		}
	}
	public sealed class GoldChangedServerHandler : IServerHandler<GoldChangedEvent>
	{
		public GoldChangedEvent Handle(GoldChangedEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.Coop
{
	public sealed class AllChoicesCompleteClientHandler : IClientHandler<AllChoicesCompleteEvent>
	{
		public void Handle(AllChoicesCompleteEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)("[CoopReward] All choices complete for phase '" + networkEvent.Phase + "'"));
			}
			if (networkEvent.Phase != "shop" && networkEvent.Phase != "text_scenario" && networkEvent.Phase != "treasure" && networkEvent.Phase != "peg_minigame")
			{
				CoopRewardState.AllChoicesComplete = true;
				CoopRewardState.WaitingForOtherPlayers = false;
			}
			if (networkEvent.Phase == "post_battle")
			{
				CoopRewardState.ClientInNativeRewardPhase = false;
				CoopRewardState.PendingPostBattleRelicChoices = null;
				MultiplayerClientPatches.AllowNativeRewardLogic = false;
				MultiplayerClientPatches.ClientChosenPostBattleRelicEffect = -1;
				MultiplayerClientPatches.ClientChosenPostBattleRelicName = null;
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)"[CoopReward] Post-battle reward phase ended on client");
				}
			}
			else if (networkEvent.Phase == "shop")
			{
				CoopRewardState.ShopPhaseActive = false;
				CoopRewardState.ShopAwaitingHostNavigation = true;
				CoopRewardState.WaitingForOtherPlayers = true;
				MultiplayerClientPatches.AllowShopLogic = false;
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)"[CoopReward] Shop phase ended — awaiting host navigation shot");
				}
			}
			else if (networkEvent.Phase == "text_scenario")
			{
				CoopRewardState.TextScenarioPhaseActive = false;
				CoopRewardState.TextScenarioAwaitingHostNavigation = true;
				CoopRewardState.WaitingForOtherPlayers = true;
				MultiplayerClientPatches.AllowTextScenarioLogic = false;
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogInfo((object)"[CoopReward] TextScenario phase ended — awaiting host navigation shot");
				}
			}
			else if (networkEvent.Phase == "treasure")
			{
				CoopRewardState.TreasurePhaseActive = false;
				CoopRewardState.TreasureAwaitingHostNavigation = true;
				CoopRewardState.WaitingForOtherPlayers = true;
				MultiplayerClientPatches.AllowTreasureLogic = false;
				MultiplayerClientPatches.AllowRelicSync = false;
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogInfo((object)"[CoopReward] Treasure phase ended — awaiting host navigation shot");
				}
			}
			else if (networkEvent.Phase == "peg_minigame")
			{
				CoopRewardState.PegMinigamePhaseActive = false;
				CoopRewardState.PegMinigameAwaitingHostNavigation = true;
				CoopRewardState.WaitingForOtherPlayers = true;
				MultiplayerClientPatches.AllowPegMinigameLogic = false;
				ManualLogSource logger6 = MultiplayerPlugin.Logger;
				if (logger6 != null)
				{
					logger6.LogInfo((object)"[CoopReward] PegMinigame phase ended — awaiting host navigation shot");
				}
			}
		}
	}
	public sealed class AllChoicesCompleteServerHandler : IServerHandler<AllChoicesCompleteEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("AllChoicesCompleteServer");

		public AllChoicesCompleteEvent Handle(AllChoicesCompleteEvent networkEvent)
		{
			_log.LogInfo((object)("[AllChoicesCompleteServer] Broadcasting all choices complete: phase=" + networkEvent.Phase));
			CoopRewardState.WaitingForOtherPlayers = false;
			if (networkEvent.Phase != "shop" && networkEvent.Phase != "text_scenario")
			{
				CoopRewardState.AllChoicesComplete = true;
			}
			if (networkEvent.Phase == "post_battle")
			{
				CoopRewardState.ClientInNativeRewardPhase = false;
				MultiplayerClientPatches.AllowNativeRewardLogic = false;
			}
			return networkEvent;
		}
	}
	public sealed class CoopNavigateClientInput : MonoBehaviour
	{
		private const float FallbackSeconds = 8f;

		private bool _phaseEntryLogged;

		private float _diagTimer;

		private bool _shotFired;

		private float _shotFiredAt = -1f;

		private int _pendingFallbackChildIndex = -1;

		private float _lastBallWorldX = float.NaN;

		private float _lastBallWorldY = float.NaN;

		private void Update()
		{
			//IL_0296: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!CoopNavigateState.PhaseActive)
				{
					_phaseEntryLogged = false;
					_shotFired = false;
					_shotFiredAt = -1f;
					_pendingFallbackChildIndex = -1;
					_lastBallWorldX = float.NaN;
					_lastBallWorldY = float.NaN;
				}
				else
				{
					if (CoopNavigateState.Resolved)
					{
						return;
					}
					IServiceContainer services = MultiplayerPlugin.Services;
					if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || instance.IsHosting)
					{
						return;
					}
					if (!_phaseEntryLogged)
					{
						_phaseEntryLogged = true;
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)("[CoopNavigate/ClientInput] Active: phase=" + CoopNavigateState.Source + ", " + $"children={CoopNavigateState.ChildNodeCount}, " + $"isSpectating={instance.IsSpectating}, voteCast={CoopNavigateState.LocalVoteCast}"));
						}
					}
					_diagTimer += Time.unscaledDeltaTime;
					if (_diagTimer >= 2f)
					{
						_diagTimer = 0f;
						if (!CoopNavigateState.LocalVoteCast)
						{
							ManualLogSource logger2 = MultiplayerPlugin.Logger;
							if (logger2 != null)
							{
								logger2.LogInfo((object)("[CoopNavigate/ClientInput] Waiting for click: " + $"phaseActive={CoopNavigateState.PhaseActive} resolved={CoopNavigateState.Resolved} " + $"voteCast={CoopNavigateState.LocalVoteCast}"));
							}
						}
					}
					if (CoopNavigateState.LocalVoteCast)
					{
						return;
					}
					if (_shotFired)
					{
						TrackActiveBallPosition();
						if (!(_shotFiredAt > 0f) || !(Time.unscaledTime - _shotFiredAt > 8f) || !services.TryResolve<IMessageSender>(out var instance2))
						{
							return;
						}
						int num = ResolveFallbackChildFromBallPosition();
						if (num < 0)
						{
							num = _pendingFallbackChildIndex;
						}
						if (num >= 0)
						{
							ManualLogSource logger3 = MultiplayerPlugin.Logger;
							if (logger3 != null)
							{
								logger3.LogWarning((object)($"[CoopNavigate/ClientInput] Slot trigger never fired after {8f:F0}s — " + $"sending fallback vote child={num} (ballX={_lastBallWorldX:F2})"));
							}
							CoopNavigateState.LocalVoteCast = true;
							instance2.Send(new NavigateVoteEvent
							{
								ChildIndex = num
							});
							_pendingFallbackChildIndex = -1;
						}
					}
					else
					{
						if (!Input.GetMouseButtonDown(0))
						{
							return;
						}
						if (MultiplayerClientPatches.IsPointerOverInteractiveUI())
						{
							ManualLogSource logger4 = MultiplayerPlugin.Logger;
							if (logger4 != null)
							{
								logger4.LogInfo((object)"[CoopNavigate/ClientInput] Click ignored — pointer over interactive UI");
							}
							return;
						}
						int num2 = Math.Max(1, CoopNavigateState.ChildNodeCount);
						int num3 = ResolveChildIndexFromMouse(num2);
						ManualLogSource logger5 = MultiplayerPlugin.Logger;
						if (logger5 != null)
						{
							logger5.LogInfo((object)("[CoopNavigate/ClientInput] Click detected at " + $"x={Input.mousePosition.x:F0}/{Screen.width} -> child={num3} " + $"(childCount={num2})"));
						}
						if (num3 >= 0)
						{
							FireNavBall();
							_shotFired = true;
							_shotFiredAt = Time.unscaledTime;
							_pendingFallbackChildIndex = num3;
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger6 = MultiplayerPlugin.Logger;
				if (logger6 != null)
				{
					logger6.LogWarning((object)("[CoopNavigate/ClientInput] Update failed: " + ex.Message));
				}
			}
		}

		private void TrackActiveBallPosition()
		{
			//IL_0025: Unknown result type (might be due to invalid IL or missing references)
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_002c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0038: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				PachinkoBall val = FindActiveNavBall();
				if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).transform == (Object)null))
				{
					Vector3 position = ((Component)val).transform.position;
					_lastBallWorldX = position.x;
					_lastBallWorldY = position.y;
				}
			}
			catch
			{
			}
		}

		private static PachinkoBall FindActiveNavBall()
		{
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				NavOnlyController[] array = Resources.FindObjectsOfTypeAll<NavOnlyController>();
				if (array != null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(NavOnlyController), "_ball");
					NavOnlyController[] array2 = array;
					foreach (NavOnlyController val in array2)
					{
						if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
						{
							continue;
						}
						Scene scene = ((Component)val).gameObject.scene;
						if (((Scene)(ref scene)).IsValid())
						{
							object? obj = fieldInfo?.GetValue(val);
							object? obj2 = ((obj is GameObject) ? obj : null);
							PachinkoBall val2 = ((obj2 != null) ? ((GameObject)obj2).GetComponent<PachinkoBall>() : null);
							if ((Object)(object)val2 != (Object)null)
							{
								return val2;
							}
						}
					}
				}
				BattleController val3 = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val3 != (Object)null)
				{
					object? obj3 = AccessTools.Field(typeof(BattleController), "_activePachinkoBall")?.GetValue(val3);
					object? obj4 = ((obj3 is GameObject) ? obj3 : null);
					return (obj4 != null) ? ((GameObject)obj4).GetComponent<PachinkoBall>() : null;
				}
			}
			catch
			{
			}
			return null;
		}

		private int ResolveFallbackChildFromBallPosition()
		{
			if (float.IsNaN(_lastBallWorldX))
			{
				return -1;
			}
			int num = Math.Max(1, CoopNavigateState.ChildNodeCount);
			float[] array = TryGetSlotManagerWorldX();
			if (array == null)
			{
				return -1;
			}
			int num2 = 0;
			int num3 = 1;
			int num4 = 2;
			if (array[num2] > array[num4])
			{
				int num5 = num4;
				num4 = num2;
				num2 = num5;
			}
			int num6 = num2;
			float num7 = Mathf.Abs(_lastBallWorldX - array[num2]);
			float num8 = Mathf.Abs(_lastBallWorldX - array[num3]);
			if (num8 < num7)
			{
				num7 = num8;
				num6 = num3;
			}
			if (Mathf.Abs(_lastBallWorldX - array[num4]) < num7)
			{
				num6 = num4;
			}
			if (num6 == num2)
			{
				return 0;
			}
			if (num6 == num4)
			{
				return num - 1;
			}
			if (num == 1)
			{
				return 0;
			}
			if (num > 2)
			{
				return 1;
			}
			if (!(_lastBallWorldX < array[num3]))
			{
				return num - 1;
			}
			return 0;
		}

		private static float[] TryGetSlotManagerWorldX()
		{
			//IL_0179: Unknown result type (might be due to invalid IL or missing references)
			//IL_017e: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b9: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e1: Unknown result type (might be due to invalid IL or missing references)
			//IL_0224: Unknown result type (might be due to invalid IL or missing references)
			//IL_01f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_020a: Unknown result type (might be due to invalid IL or missing references)
			//IL_023f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0258: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				PostBattleController val = Object.FindObjectOfType<PostBattleController>();
				if ((Object)(object)val != (Object)null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(PostBattleController), "_leftSlotManager");
					FieldInfo fieldInfo2 = AccessTools.Field(typeof(PostBattleController), "_centerSlotManager");
					FieldInfo fieldInfo3 = AccessTools.Field(typeof(PostBattleController), "_rightSlotManager");
					object? obj = fieldInfo?.GetValue(val);
					SlotManager val2 = (SlotManager)((obj is SlotManager) ? obj : null);
					object? obj2 = fieldInfo2?.GetValue(val);
					SlotManager val3 = (SlotManager)((obj2 is SlotManager) ? obj2 : null);
					object? obj3 = fieldInfo3?.GetValue(val);
					SlotManager val4 = (SlotManager)((obj3 is SlotManager) ? obj3 : null);
					if ((Object)(object)val2 != (Object)null && (Object)(object)val3 != (Object)null && (Object)(object)val4 != (Object)null)
					{
						return new float[3]
						{
							((Component)val2).transform.position.x,
							((Component)val3).transform.position.x,
							((Component)val4).transform.position.x
						};
					}
				}
				NavOnlyController[] array = Resources.FindObjectsOfTypeAll<NavOnlyController>();
				if (array != null)
				{
					FieldInfo fieldInfo4 = AccessTools.Field(typeof(NavOnlyController), "_leftSlotManager");
					FieldInfo fieldInfo5 = AccessTools.Field(typeof(NavOnlyController), "_centreSlotManager");
					FieldInfo fieldInfo6 = AccessTools.Field(typeof(NavOnlyController), "_rightSlotManager");
					NavOnlyController[] array2 = array;
					foreach (NavOnlyController val5 in array2)
					{
						if ((Object)(object)val5 == (Object)null || (Object)(object)((Component)val5).gameObject == (Object)null)
						{
							continue;
						}
						Scene scene = ((Component)val5).gameObject.scene;
						if (((Scene)(ref scene)).IsValid())
						{
							object? obj4 = fieldInfo4?.GetValue(val5);
							SlotManager val6 = (SlotManager)((obj4 is SlotManager) ? obj4 : null);
							object? obj5 = fieldInfo5?.GetValue(val5);
							SlotManager val7 = (SlotManager)((obj5 is SlotManager) ? obj5 : null);
							object? obj6 = fieldInfo6?.GetValue(val5);
							SlotManager val8 = (SlotManager)((obj6 is SlotManager) ? obj6 : null);
							if ((Object)(object)val6 != (Object)null && (Object)(object)val8 != (Object)null)
							{
								float num = (((Object)(object)val7 != (Object)null) ? ((Component)val7).transform.position.x : ((((Component)val6).transform.position.x + ((Component)val8).transform.position.x) * 0.5f));
								return new float[3]
								{
									((Component)val6).transform.position.x,
									num,
									((Component)val8).transform.position.x
								};
							}
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static int ResolveChildIndexFromMouse(int childCount)
		{
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			int num = ((Screen.width <= 0) ? 1 : Screen.width);
			float num2 = Mathf.Clamp01(Input.mousePosition.x / (float)num);
			switch (childCount)
			{
			case 1:
				return 0;
			case 2:
				return (!(num2 < 0.5f)) ? 1 : 0;
			default:
				if (num2 < 0.34f)
				{
					return 0;
				}
				if (num2 > 0.66f)
				{
					return childCount - 1;
				}
				return 1;
			}
		}

		private static void FireNavBall()
		{
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0055: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				bool flag = false;
				NavOnlyController[] array = Resources.FindObjectsOfTypeAll<NavOnlyController>();
				if (array != null)
				{
					FieldInfo fieldInfo = AccessTools.Field(typeof(NavOnlyController), "_ball");
					NavOnlyController[] array2 = array;
					foreach (NavOnlyController val in array2)
					{
						if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
						{
							continue;
						}
						Scene scene = ((Component)val).gameObject.scene;
						if (((Scene)(ref scene)).IsValid())
						{
							object? obj = fieldInfo?.GetValue(val);
							object? obj2 = ((obj is GameObject) ? obj : null);
							PachinkoBall val2 = ((obj2 != null) ? ((GameObject)obj2).GetComponent<PachinkoBall>() : null);
							if ((Object)(object)val2 != (Object)null && TryFire(val2))
							{
								flag = true;
							}
						}
					}
				}
				if (flag)
				{
					return;
				}
				BattleController val3 = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val3 != (Object)null)
				{
					object? obj3 = AccessTools.Field(typeof(BattleController), "_activePachinkoBall")?.GetValue(val3);
					object? obj4 = ((obj3 is GameObject) ? obj3 : null);
					PachinkoBall val4 = ((obj4 != null) ? ((GameObject)obj4).GetComponent<PachinkoBall>() : null);
					if ((Object)(object)val4 != (Object)null)
					{
						TryFire(val4);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopNavigate/ClientInput] FireNavBall failed: " + ex.Message));
				}
			}
		}

		private static bool TryFire(PachinkoBall pb)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_004b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_006e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0079: Unknown result type (might be due to invalid IL or missing references)
			//IL_008e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((int)pb.CurrentState != 1)
				{
					AccessTools.Property(typeof(PachinkoBall), "CurrentState")?.GetSetMethod(nonPublic: true)?.Invoke(pb, new object[1] { (object)(FireballState)1 });
				}
				Vector3 position = ((Component)pb).transform.position;
				Vector2 aimVector = pb.aimVector;
				pb.Fire(true);
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopNavigate/ClientInput] Fired nav ball: aim=({aimVector.x:F2},{aimVector.y:F2})");
				}
				BroadcastShot(position, aimVector);
				return true;
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[CoopNavigate/ClientInput] TryFire failed: " + ex.Message));
				}
				return false;
			}
		}

		private static void BroadcastShot(Vector3 origin, Vector2 aim)
		{
			//IL_002a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_0042: Unknown result type (might be due to invalid IL or missing references)
			//IL_004e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMessageSender>(out var instance))
				{
					int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(services);
					instance.Send(new NavBallShotEvent
					{
						Slot = localSlotIndex,
						OriginX = origin.x,
						OriginY = origin.y,
						AimX = aim.x,
						AimY = aim.y
					});
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[CoopNavigate/ClientInput] BroadcastShot failed: " + ex.Message));
				}
			}
		}
	}
	public static class CoopNavigateResolver
	{
		private static float _lastWatchdogLogAt;

		public static int[] CaptureChildRoomTypes()
		{
			//IL_004d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0053: Expected I4, but got O
			//IL_0052->IL0052: Incompatible stack types: O vs I4
			//IL_004c->IL0052: Incompatible stack types: I4 vs O
			//IL_004c->IL0052: Incompatible stack types: O vs I4
			MapNode currentNode = StaticGameData.currentNode;
			if (((currentNode != null) ? currentNode.ChildNodes : null) == null || currentNode.ChildNodes.Length == 0)
			{
				return Array.Empty<int>();
			}
			int[] array = new int[currentNode.ChildNodes.Length];
			for (int i = 0; i < currentNode.ChildNodes.Length; i++)
			{
				MapNode val = currentNode.ChildNodes[i];
				object obj = array;
				int num = i;
				int num2;
				if (!((Object)(object)val != (Object)null))
				{
					num2 = 0;
					obj = num2;
					num2 = (int)obj;
				}
				else
				{
					obj = val.RoomType;
					num2 = (int)obj;
				}
				((int[])num2)[num] = (int)obj;
			}
			return array;
		}

		public static bool StartPhase(string source, int childNodeCount, int[] childRoomTypes = null)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null)
			{
				return false;
			}
			if (!services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
			{
				return false;
			}
			if (!services.TryResolve<PlayerRegistry>(out var instance2))
			{
				return false;
			}
			int slotCount = instance2.SlotCount;
			if (slotCount <= 1)
			{
				return false;
			}
			if (childNodeCount < 1)
			{
				childNodeCount = 1;
			}
			CoopNavigateState.StartPhase(source, childNodeCount, slotCount, Time.unscaledTime, childRoomTypes);
			if (services.TryResolve<CoopStateManager>(out var instance3) && instance3.ActivePlayerSlot != 0)
			{
				instance3.SwapToPlayer(0);
			}
			TurnChangeClientHandler.TurnMessage = string.Empty;
			if (services.TryResolve<IGameEventRegistry>(out var instance4))
			{
				instance4.Dispatch(new NavigatePhaseStartEvent
				{
					Source = source,
					ChildNodeCount = childNodeCount,
					ChildRoomTypes = (childRoomTypes ?? Array.Empty<int>())
				});
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)$"[CoopNavigate] Phase started: source={source}, children={childNodeCount}, voters={slotCount}");
			}
			return true;
		}

		public static void RecordHostVote(int childIndex)
		{
			if (CoopNavigateState.PhaseActive && !CoopNavigateState.Resolved && CoopNavigateState.RecordVote(0, childIndex))
			{
				CoopNavigateState.LocalVoteCast = true;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopNavigate] Host voted child={childIndex} ({CoopNavigateState.VotedSlots.Count}/{CoopNavigateState.TotalVotersExpected})");
				}
				BroadcastTallyUpdate();
				TryResolveIfDone(forceSkip: false);
			}
		}

		public static void RecordClientVote(int slotIndex, int childIndex)
		{
			if (CoopNavigateState.PhaseActive && !CoopNavigateState.Resolved && CoopNavigateState.RecordVote(slotIndex, childIndex))
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopNavigate] Slot {slotIndex} voted child={childIndex} ({CoopNavigateState.VotedSlots.Count}/{CoopNavigateState.TotalVotersExpected})");
				}
				BroadcastTallyUpdate();
				TryResolveIfDone(forceSkip: false);
			}
		}

		public static void OnPeerDisconnected()
		{
			if (!CoopNavigateState.PhaseActive || CoopNavigateState.Resolved)
			{
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<PlayerRegistry>(out var instance))
			{
				CoopNavigateState.TotalVotersExpected = instance.SlotCount;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopNavigate] Voter count adjusted on disconnect -> {CoopNavigateState.TotalVotersExpected}");
				}
				TryResolveIfDone(forceSkip: false);
			}
		}

		public static void TickWatchdog()
		{
			if (!CoopNavigateState.PhaseActive || CoopNavigateState.Resolved)
			{
				_lastWatchdogLogAt = 0f;
				return;
			}
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
			{
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (_lastWatchdogLogAt > 0f && unscaledTime - _lastWatchdogLogAt < 5f)
			{
				return;
			}
			_lastWatchdogLogAt = unscaledTime;
			float num = ((CoopNavigateState.PhaseStartedAt > 0f) ? (unscaledTime - CoopNavigateState.PhaseStartedAt) : (-1f));
			List<int> list = new List<int>();
			if (services.TryResolve<PlayerRegistry>(out var instance2))
			{
				foreach (PlayerSlot allSlot in instance2.GetAllSlots())
				{
					if (!CoopNavigateState.VotedSlots.Contains(allSlot.SlotIndex))
					{
						list.Add(allSlot.SlotIndex);
					}
				}
			}
			string text = ((list.Count > 0) ? string.Join(",", list) : "(none)");
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogWarning((object)($"[CoopNavigate/Watchdog] Phase '{CoopNavigateState.Source}' unresolved after {num:F1}s: " + $"votes={CoopNavigateState.VotedSlots.Count}/{CoopNavigateState.TotalVotersExpected}, " + "tally=[" + string.Join(",", CoopNavigateState.VoteCounts) + "], pendingSlots=" + text));
			}
		}

		public static void ForceResolve()
		{
			if (CoopNavigateState.PhaseActive && !CoopNavigateState.Resolved)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)"[CoopNavigate] Host force-resolving navigate phase");
				}
				TryResolveIfDone(forceSkip: true);
			}
		}

		private static void BroadcastTallyUpdate()
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<IGameEventRegistry>(out var instance))
			{
				instance.Dispatch(new NavigateVoteUpdateEvent
				{
					VoteCounts = new List<int>(CoopNavigateState.VoteCounts)
				});
			}
		}

		private static void TryResolveIfDone(bool forceSkip)
		{
			if (!CoopNavigateState.Resolved && (forceSkip || CoopNavigateState.AllVotesIn))
			{
				int num = PickWinner(CoopNavigateState.VoteCounts);
				CoopNavigateState.Resolved = true;
				CoopNavigateState.ChosenChildIndex = num;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)string.Format("[CoopNavigate] Resolved (forceSkip={0}): chose child={1}, tally=[{2}]", forceSkip, num, string.Join(",", CoopNavigateState.VoteCounts)));
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IGameEventRegistry>(out var instance))
				{
					instance.Dispatch(new NavigateResolvedEvent
					{
						ChosenChildIndex = num,
						VoteCounts = new List<int>(CoopNavigateState.VoteCounts)
					});
				}
				StaticGameData.chosenNextNodeIndex = num;
				if (services != null && services.TryResolve<CoopStateManager>(out var instance2))
				{
					instance2.UnmergeNavPhaseRelics();
				}
				string source = CoopNavigateState.Source;
				CoopNavigateState.Reset();
				if (source == "post_battle")
				{
					InvokePostBattleVictory();
				}
				else if (source == "nav_only")
				{
					InvokeNavOnlyFadeAndLoad();
				}
			}
		}

		private static bool LeaderIsUncatchable()
		{
			List<int> voteCounts = CoopNavigateState.VoteCounts;
			if (voteCounts == null || voteCounts.Count == 0)
			{
				return false;
			}
			int num = CoopNavigateState.TotalVotersExpected - CoopNavigateState.VotedSlots.Count;
			if (num <= 0)
			{
				return false;
			}
			int num2 = -1;
			int num3 = 0;
			bool flag = false;
			for (int i = 0; i < voteCounts.Count; i++)
			{
				if (voteCounts[i] > num2)
				{
					num3 = ((num2 >= 0) ? num2 : 0);
					num2 = voteCounts[i];
					flag = true;
				}
				else if (voteCounts[i] == num2)
				{
					flag = false;
				}
				else if (voteCounts[i] > num3)
				{
					num3 = voteCounts[i];
				}
			}
			if (flag)
			{
				return num2 >= num3 + num;
			}
			return false;
		}

		private static int PickWinner(List<int> votes)
		{
			if (votes == null || votes.Count == 0)
			{
				return 0;
			}
			int num = -1;
			for (int i = 0; i < votes.Count; i++)
			{
				if (votes[i] > num)
				{
					num = votes[i];
				}
			}
			List<int> list = new List<int>();
			for (int j = 0; j < votes.Count; j++)
			{
				if (votes[j] == num)
				{
					list.Add(j);
				}
			}
			if (list.Count == 1)
			{
				return list[0];
			}
			return list[Random.Range(0, list.Count)];
		}

		private static void InvokePostBattleVictory()
		{
			try
			{
				PostBattleController[] array = Resources.FindObjectsOfTypeAll<PostBattleController>();
				PostBattleController val = null;
				PostBattleController[] array2 = array;
				foreach (PostBattleController val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).gameObject != (Object)null && ((Component)val2).gameObject.activeInHierarchy)
					{
						val = val2;
						break;
					}
				}
				if ((Object)(object)val == (Object)null && array != null && array.Length != 0)
				{
					val = array[0];
				}
				if ((Object)(object)val == (Object)null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[CoopNavigate] No PostBattleController found to trigger victory");
					}
				}
				else
				{
					BattleController.CurrentBattleState = (BattleState)9;
					AccessTools.Method(typeof(PostBattleController), "TriggerVictory", (Type[])null, (Type[])null)?.Invoke(val, null);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogError((object)("[CoopNavigate] InvokePostBattleVictory failed: " + ex.Message));
				}
			}
		}

		private static void InvokeNavOnlyFadeAndLoad()
		{
			try
			{
				NavOnlyController[] array = Resources.FindObjectsOfTypeAll<NavOnlyController>();
				NavOnlyController val = null;
				NavOnlyController[] array2 = array;
				foreach (NavOnlyController val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).gameObject != (Object)null && ((Component)val2).gameObject.activeInHierarchy)
					{
						val = val2;
						break;
					}
				}
				if ((Object)(object)val == (Object)null && array.Length != 0)
				{
					val = array[0];
				}
				if ((Object)(object)val == (Object)null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[CoopNavigate] No NavOnlyController found to FadeAndLoad");
					}
				}
				else if (val.isTreasureScene && AllTreasureBombsDetonated(val))
				{
					ChestScenarioController obj = Object.FindObjectOfType<ChestScenarioController>();
					if (obj != null)
					{
						obj.DoBonusChestStuff();
					}
					val.FadeAndLoad((Scene)11, -1f);
				}
				else
				{
					val.FadeAndLoad((Scene)0, -1f);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogError((object)("[CoopNavigate] InvokeNavOnlyFadeAndLoad failed: " + ex.Message));
				}
			}
		}

		private static bool AllTreasureBombsDetonated(NavOnlyController noc)
		{
			if (!(AccessTools.Field(typeof(NavOnlyController), "_bombs")?.GetValue(noc) is Bomb[] array) || array.Length == 0)
			{
				return false;
			}
			Bomb[] array2 = array;
			foreach (Bomb val in array2)
			{
				if ((Object)(object)val != (Object)null && !val.detonated)
				{
					return false;
				}
			}
			return true;
		}
	}
	public static class CoopNavigateState
	{
		public static bool PhaseActive;

		public static string Source;

		public static int ChildNodeCount;

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

		public static List<int> VoteCounts = new List<int>();

		public static HashSet<int> VotedSlots = new HashSet<int>();

		public static int TotalVotersExpected;

		public static bool Resolved;

		public static int ChosenChildIndex = -1;

		public static bool LocalVoteCast;

		public static float PhaseStartedAt = -1f;

		public static bool AllVotesIn
		{
			get
			{
				if (TotalVotersExpected > 0)
				{
					return VotedSlots.Count >= TotalVotersExpected;
				}
				return false;
			}
		}

		public static void StartPhase(string source, int childNodeCount, int totalVoters, float now, int[] childRoomTypes = null)
		{
			NavBallShotClientHandler.DestroyAllGhostBalls();
			NavigatePhaseStartClientHandler.DestroyActiveVerifier();
			PhaseActive = true;
			Source = source ?? "post_battle";
			ChildNodeCount = Math.Max(1, childNodeCount);
			TotalVotersExpected = Math.Max(1, totalVoters);
			VoteCounts = new List<int>(new int[ChildNodeCount]);
			VotedSlots = new HashSet<int>();
			Resolved = false;
			ChosenChildIndex = -1;
			LocalVoteCast = false;
			PhaseStartedAt = now;
			ChildRoomTypes = childRoomTypes ?? Array.Empty<int>();
			PachinkoBallPatches.ResetNavBallBroadcastLatch();
		}

		public static bool RecordVote(int slotIndex, int childIndex)
		{
			if (!PhaseActive || Resolved)
			{
				return false;
			}
			if (childIndex < 0 || childIndex >= VoteCounts.Count)
			{
				return false;
			}
			if (!VotedSlots.Add(slotIndex))
			{
				return false;
			}
			VoteCounts[childIndex] += 1;
			return true;
		}

		public static void Reset()
		{
			NavBallShotClientHandler.DestroyAllGhostBalls();
			NavigatePhaseStartClientHandler.DestroyActiveVerifier();
			PhaseActive = false;
			Source = null;
			ChildNodeCount = 0;
			VoteCounts = new List<int>();
			VotedSlots = new HashSet<int>();
			TotalVotersExpected = 0;
			Resolved = false;
			ChosenChildIndex = -1;
			LocalVoteCast = false;
			PhaseStartedAt = -1f;
			ChildRoomTypes = Array.Empty<int>();
		}
	}
	public sealed class CoopOrbRewardChoicesClientHandler : IClientHandler<CoopOrbRewardChoicesEvent>
	{
		public void Handle(CoopOrbRewardChoicesEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || (services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting))
			{
				return;
			}
			int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(services);
			if (localSlotIndex >= 0 && networkEvent.TargetSlotIndex == localSlotIndex)
			{
				CoopRewardState.PerSlotOrbChoices[localSlotIndex] = networkEvent.OrbPrefabNames ?? new List<string>();
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopOrbReward] Stored {CoopRewardState.PerSlotOrbChoices[localSlotIndex].Count} orb choices for slot {localSlotIndex}");
				}
			}
		}
	}
	public sealed class CoopOrbRewardChoicesServerHandler : IServerHandler<CoopOrbRewardChoicesEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("CoopOrbReward");

		public CoopOrbRewardChoicesEvent Handle(CoopOrbRewardChoicesEvent networkEvent)
		{
			_log.LogInfo((object)$"[CoopOrbReward] Broadcasting {networkEvent.OrbPrefabNames?.Count ?? 0} orb choices to slot {networkEvent.TargetSlotIndex}");
			return networkEvent;
		}
	}
	public static class CoopRewardState
	{
		public static RelicChoicesEvent PendingRelicChoices;

		public static RewardChoicesEvent PendingRewardChoices;

		public static bool WaitingForOtherPlayers;

		public static bool AllChoicesComplete;

		public static bool HostRelicSelectionActive;

		public static bool HostHasChosenRelic;

		public static HashSet<int> ClientRelicChoicesReceived = new HashSet<int>();

		public static int TotalClientsExpected;

		public static object PendingGameInitInstance;

		public static bool ClientInNativeRewardPhase;

		public static bool HostRewardPhaseActive;

		public static bool HostRewardsDone;

		public static PostBattleController PendingPostBattleController;

		public static Dictionary<int, RewardChoicesEvent> PendingSentRewardChoices = new Dictionary<int, RewardChoicesEvent>();

		public static HashSet<int> ClientRewardChoicesReceived = new HashSet<int>();

		public static int TotalRewardClientsExpected;

		public static Dictionary<int, List<string>> PerSlotOrbChoices = new Dictionary<int, List<string>>();

		public static Dictionary<int, string> PerSlotTreasureRelics = new Dictionary<int, string>();

		public static bool ShopPhaseActive;

		public static bool HostShopDone;

		public static HashSet<int> ClientShopChoicesReceived = new HashSet<int>();

		public static int TotalShopClientsExpected;

		public static object PendingShopManager;

		public static bool ShopCompletionProceeded;

		public static bool ClientShopChoiceSent;

		public static bool ShopAwaitingHostNavigation;

		public static bool TreasurePhaseActive;

		public static bool HostTreasureDone;

		public static HashSet<int> ClientTreasureChoicesReceived = new HashSet<int>();

		public static int TotalTreasureClientsExpected;

		public static ChestScenarioController PendingChestController;

		public static bool ClientTreasureChoiceSent;

		public static bool TreasureAwaitingHostNavigation;

		public static bool PegMinigamePhaseActive;

		public static bool HostPegMinigameDone;

		public static HashSet<int> ClientPegMinigameChoicesReceived = new HashSet<int>();

		public static int TotalPegMinigameClientsExpected;

		public static PegMinigameManager PendingPegMinigameManager;

		public static bool ClientPegMinigameChoiceSent;

		public static bool PegMinigameAwaitingHostNavigation;

		public static bool TextScenarioPhaseActive;

		public static bool HostTextScenarioDone;

		public static HashSet<int> ClientTextScenarioChoicesReceived = new HashSet<int>();

		public static int TotalTextScenarioClientsExpected;

		public static object PendingDialogueSystemScenario;

		public static bool ClientTextScenarioChoiceSent;

		public static bool TextScenarioAwaitingHostNavigation;

		public static List<RelicChoiceEntry> PendingPostBattleRelicChoices;

		public static bool AllClientRelicChoicesReceived
		{
			get
			{
				if (TotalClientsExpected > 0)
				{
					return ClientRelicChoicesReceived.Count >= TotalClientsExpected;
				}
				return false;
			}
		}

		public static bool AllClientRewardChoicesReceived
		{
			get
			{
				if (TotalRewardClientsExpected > 0)
				{
					return ClientRewardChoicesReceived.Count >= TotalRewardClientsExpected;
				}
				return false;
			}
		}

		public static bool AllClientShopChoicesReceived
		{
			get
			{
				if (TotalShopClientsExpected > 0)
				{
					return ClientShopChoicesReceived.Count >= TotalShopClientsExpected;
				}
				return false;
			}
		}

		public static bool AllClientTreasureChoicesReceived
		{
			get
			{
				if (TotalTreasureClientsExpected > 0)
				{
					return ClientTreasureChoicesReceived.Count >= TotalTreasureClientsExpected;
				}
				return false;
			}
		}

		public static bool AllClientPegMinigameChoicesReceived
		{
			get
			{
				if (TotalPegMinigameClientsExpected > 0)
				{
					return ClientPegMinigameChoicesReceived.Count >= TotalPegMinigameClientsExpected;
				}
				return false;
			}
		}

		public static bool AllClientTextScenarioChoicesReceived
		{
			get
			{
				if (TotalTextScenarioClientsExpected > 0)
				{
					return ClientTextScenarioChoicesReceived.Count >= TotalTextScenarioClientsExpected;
				}
				return false;
			}
		}

		public static void Reset()
		{
			WaitingForOtherPlayers = false;
			AllChoicesComplete = false;
			HostRelicSelectionActive = false;
			HostHasChosenRelic = false;
			ClientRelicChoicesReceived.Clear();
			TotalClientsExpected = 0;
			PendingGameInitInstance = null;
			PendingSentRewardChoices.Clear();
			ClientRewardChoicesReceived.Clear();
			TotalRewardClientsExpected = 0;
			PerSlotOrbChoices.Clear();
			PerSlotTreasureRelics.Clear();
			ClientInNativeRewardPhase = false;
			HostRewardPhaseActive = false;
			HostRewardsDone = false;
			PendingPostBattleController = null;
			ShopPhaseActive = false;
			HostShopDone = false;
			ClientShopChoicesReceived.Clear();
			TotalShopClientsExpected = 0;
			PendingShopManager = null;
			ShopCompletionProceeded = false;
			ClientShopChoiceSent = false;
			ShopAwaitingHostNavigation = false;
			TreasurePhaseActive = false;
			HostTreasureDone = false;
			ClientTreasureChoicesReceived.Clear();
			TotalTreasureClientsExpected = 0;
			PendingChestController = null;
			ClientTreasureChoiceSent = false;
			TreasureAwaitingHostNavigation = false;
			PegMinigamePhaseActive = false;
			HostPegMinigameDone = false;
			ClientPegMinigameChoicesReceived.Clear();
			TotalPegMinigameClientsExpected = 0;
			PendingPegMinigameManager = null;
			ClientPegMinigameChoiceSent = false;
			PegMinigameAwaitingHostNavigation = false;
			TextScenarioPhaseActive = false;
			HostTextScenarioDone = false;
			ClientTextScenarioChoicesReceived.Clear();
			TotalTextScenarioClientsExpected = 0;
			PendingDialogueSystemScenario = null;
			ClientTextScenarioChoiceSent = false;
			TextScenarioAwaitingHostNavigation = false;
		}
	}
	public static class CoopSlotHelper
	{
		public static int GetLocalSlotIndex(IServiceContainer services)
		{
			if (services == null)
			{
				return -1;
			}
			if (!services.TryResolve<PlayerRegistry>(out var instance))
			{
				return -1;
			}
			if (!services.TryResolve<INetworkTransport>(out var instance2))
			{
				return -1;
			}
			if (instance2.IsHost)
			{
				return 0;
			}
			if (instance.LocalSlot != null)
			{
				return instance.LocalSlot.SlotIndex;
			}
			foreach (PlayerSlot allSlot in instance.GetAllSlots())
			{
				if (!allSlot.IsHost)
				{
					return allSlot.SlotIndex;
				}
			}
			return -1;
		}
	}
	public sealed class CoopTreasureRelicChoiceClientHandler : IClientHandler<CoopTreasureRelicChoiceEvent>
	{
		public void Handle(CoopTreasureRelicChoiceEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || (services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting))
			{
				return;
			}
			int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(services);
			if (localSlotIndex >= 0 && networkEvent.TargetSlotIndex == localSlotIndex)
			{
				CoopRewardState.PerSlotTreasureRelics[localSlotIndex] = networkEvent.RelicName;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopTreasureRelic] Stored host-rolled relic '{networkEvent.RelicName}' (rarity={networkEvent.Rarity}) for slot {localSlotIndex}");
				}
			}
		}
	}
	public sealed class CoopTreasureRelicChoiceServerHandler : IServerHandler<CoopTreasureRelicChoiceEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("CoopTreasureRelic");

		public CoopTreasureRelicChoiceEvent Handle(CoopTreasureRelicChoiceEvent networkEvent)
		{
			_log.LogInfo((object)$"[CoopTreasureRelic] Broadcasting relic '{networkEvent.RelicName}' (rarity={networkEvent.Rarity}) to slot {networkEvent.TargetSlotIndex}");
			return networkEvent;
		}
	}
	public static class CoopWaitWatchdog
	{
		private static float _lastLogAt;

		private static string _lastSnapshot;

		private static float _snapshotStableSince;

		public static void Tick(IMultiplayerMode mode)
		{
			if (mode == null || (!mode.IsHosting && !mode.IsSpectating))
			{
				Reset();
				return;
			}
			if (!CoopRewardState.WaitingForOtherPlayers && (!CoopNavigateState.PhaseActive || CoopNavigateState.Resolved))
			{
				Reset();
				return;
			}
			float unscaledTime = Time.unscaledTime;
			if (_lastLogAt > 0f && unscaledTime - _lastLogAt < 5f)
			{
				return;
			}
			_lastLogAt = unscaledTime;
			string text = BuildSnapshot();
			if (text == _lastSnapshot)
			{
				float num = unscaledTime - _snapshotStableSince;
				if (num >= 15f)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogError((object)$"[CoopWaitWatchdog] DEADLOCK SUSPECTED — same wait state for {num:F1}s: {text}");
					}
				}
				else
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)$"[CoopWaitWatchdog] still waiting ({num:F1}s): {text}");
					}
				}
			}
			else
			{
				_lastSnapshot = text;
				_snapshotStableSince = unscaledTime;
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)("[CoopWaitWatchdog] wait state: " + text));
				}
			}
		}

		private static void Reset()
		{
			_lastLogAt = 0f;
			_lastSnapshot = null;
			_snapshotStableSince = 0f;
		}

		private static string BuildSnapshot()
		{
			StringBuilder stringBuilder = new StringBuilder(256);
			stringBuilder.Append("WaitForOthers=").Append(CoopRewardState.WaitingForOtherPlayers);
			stringBuilder.Append(" AllChoicesComplete=").Append(CoopRewardState.AllChoicesComplete);
			stringBuilder.Append(" HostRewardActive=").Append(CoopRewardState.HostRewardPhaseActive);
			stringBuilder.Append(" HostRewardsDone=").Append(CoopRewardState.HostRewardsDone);
			stringBuilder.Append(" ClientInNativeReward=").Append(CoopRewardState.ClientInNativeRewardPhase);
			stringBuilder.Append(" RewardClients=").Append(CoopRewardState.ClientRewardChoicesReceived?.Count ?? 0).Append('/')
				.Append(CoopRewardState.TotalRewardClientsExpected);
			stringBuilder.Append(" Nav.PhaseActive=").Append(CoopNavigateState.PhaseActive);
			stringBuilder.Append(" Nav.LocalVoteCast=").Append(CoopNavigateState.LocalVoteCast);
			stringBuilder.Append(" Nav.Resolved=").Append(CoopNavigateState.Resolved);
			stringBuilder.Append(" Nav.Votes=").Append(CoopNavigateState.VotedSlots?.Count ?? 0).Append('/')
				.Append(CoopNavigateState.TotalVotersExpected);
			return stringBuilder.ToString();
		}
	}
	public sealed class NavBallShotClientHandler : IClientHandler<NavBallShotEvent>
	{
		private static readonly List<GameObject> _spawnedGhosts = new List<GameObject>();

		public static void DestroyAllGhostBalls()
		{
			if (_spawnedGhosts.Count == 0)
			{
				return;
			}
			int num = 0;
			foreach (GameObject spawnedGhost in _spawnedGhosts)
			{
				if (!((Object)(object)spawnedGhost == (Object)null))
				{
					try
					{
						Object.Destroy((Object)(object)spawnedGhost);
						num++;
					}
					catch
					{
					}
				}
			}
			_spawnedGhosts.Clear();
			if (num > 0)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[NavBallShot] Destroyed {num} leftover ghost nav balls");
				}
			}
		}

		public void Handle(NavBallShotEvent networkEvent)
		{
			try
			{
				if (!CoopNavigateState.PhaseActive || CoopNavigateState.Resolved)
				{
					return;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null)
				{
					int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(services);
					if (localSlotIndex < 0 || localSlotIndex != networkEvent.Slot)
					{
						SpawnGhostNavBall(networkEvent);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[NavBallShot] ghost spawn failed: " + ex.Message));
				}
			}
		}

		private static void SpawnGhostNavBall(NavBallShotEvent ev)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_006d: Unknown result type (might be due to invalid IL or missing references)
			//IL_008f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0091: Unknown result type (might be due to invalid IL or missing references)
			//IL_0087: Unknown result type (might be due to invalid IL or missing references)
			//IL_008c: Unknown result type (might be due to invalid IL or missing references)
			//IL_00dc: Unknown result type (might be due to invalid IL or missing references)
			Vector3 val = default(Vector3);
			((Vector3)(ref val))..ctor(ev.OriginX, ev.OriginY, 0f);
			Vector2 val2 = default(Vector2);
			((Vector2)(ref val2))..ctor(ev.AimX, ev.AimY);
			Transform ballStart;
			GameObject val3 = TryGetNavOnlyPrefab(out ballStart) ?? TryGetBattleControllerNavPrefab(out ballStart);
			if ((Object)(object)val3 == (Object)null)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"[NavBallShot] no nav-orb prefab available for slot {ev.Slot}");
				}
				return;
			}
			Vector3 val4 = val;
			if (((Vector3)(ref val4)).sqrMagnitude < 0.001f && (Object)(object)ballStart != (Object)null)
			{
				val4 = ballStart.position;
			}
			GameObject val5 = Object.Instantiate<GameObject>(val3, val4, Quaternion.identity);
			PachinkoBall component = val5.GetComponent<PachinkoBall>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val5);
				return;
			}
			component.IsDummy = true;
			try
			{
				AccessTools.Field(typeof(PachinkoBall), "_aimVector")?.SetValue(component, val2);
			}
			catch
			{
			}
			try
			{
				component.Fire(false);
			}
			catch
			{
				try
				{
					component.FireDummy();
				}
				catch
				{
				}
			}
			_spawnedGhosts.Add(val5);
			ManualLogSource logger2 = MultiplayerPlugin.Logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)$"[NavBallShot] ghost spawned for slot={ev.Slot} at ({ev.OriginX:F2},{ev.OriginY:F2}) aim=({ev.AimX:F2},{ev.AimY:F2})");
			}
		}

		private static GameObject TryGetNavOnlyPrefab(out Transform ballStart)
		{
			//IL_006c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0071: Unknown result type (might be due to invalid IL or missing references)
			ballStart = null;
			try
			{
				NavOnlyController[] array = Resources.FindObjectsOfTypeAll<NavOnlyController>();
				if (array == null)
				{
					return null;
				}
				FieldInfo fieldInfo = AccessTools.Field(typeof(NavOnlyController), "_navigationOrb");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(NavOnlyController), "_ballStartTransform");
				NavOnlyController[] array2 = array;
				foreach (NavOnlyController val in array2)
				{
					if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null)
					{
						continue;
					}
					Scene scene = ((Component)val).gameObject.scene;
					if (((Scene)(ref scene)).IsValid())
					{
						object? obj = fieldInfo?.GetValue(val);
						GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
						if ((Object)(object)val2 != (Object)null)
						{
							object? obj2 = fieldInfo2?.GetValue(val);
							ballStart = (Transform)((obj2 is Transform) ? obj2 : null);
							return val2;
						}
					}
				}
			}
			catch
			{
			}
			return null;
		}

		private static GameObject TryGetBattleControllerNavPrefab(out Transform ballStart)
		{
			ballStart = null;
			try
			{
				BattleController val = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val == (Object)null)
				{
					return null;
				}
				object? obj = AccessTools.Field(typeof(BattleController), "_navigationOrb")?.GetValue(val);
				return (GameObject)((obj is GameObject) ? obj : null);
			}
			catch
			{
				return null;
			}
		}
	}
	public sealed class NavBallShotServerHandler : IServerHandler<NavBallShotEvent>
	{
		public NavBallShotEvent Handle(NavBallShotEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null)
			{
				return networkEvent;
			}
			if (!services.TryResolve<PlayerRegistry>(out var instance) || !services.TryResolve<GameEventRegistry>(out var instance2))
			{
				return networkEvent;
			}
			int currentSenderPeerId = instance2.CurrentSenderPeerId;
			PlayerSlot slotByPeerId = instance.GetSlotByPeerId(currentSenderPeerId);
			if (slotByPeerId != null)
			{
				networkEvent.Slot = slotByPeerId.SlotIndex;
			}
			return networkEvent;
		}
	}
	public sealed class NavigatePhaseStartClientHandler : IClientHandler<NavigatePhaseStartEvent>
	{
		private sealed class NavBallArmVerifier : MonoBehaviour
		{
			public ManualLogSource Log;

			private float _t;

			private int _retries;

			private void Update()
			{
				//IL_00ce: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f3: Unknown result type (might be due to invalid IL or missing references)
				//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
				_t += Time.unscaledDeltaTime;
				if (_t < 0.25f)
				{
					return;
				}
				_t = 0f;
				if (!CoopNavigateState.PhaseActive || CoopNavigateState.Resolved)
				{
					Object.Destroy((Object)(object)((Component)this).gameObject);
					if ((Object)(object)_verifierGo == (Object)(object)((Component)this).gameObject)
					{
						_verifierGo = null;
					}
					return;
				}
				try
				{
					BattleController val = Object.FindObjectOfType<BattleController>();
					if ((Object)(object)val == (Object)null)
					{
						return;
					}
					object? obj = AccessTools.Field(typeof(BattleController), "_activePachinkoBall")?.GetValue(val);
					GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
					if ((Object)(object)val2 != (Object)null && val2.activeInHierarchy)
					{
						PachinkoBall component = val2.GetComponent<PachinkoBall>();
						ManualLogSource log = Log;
						if (log != null)
						{
							string text = $"[CoopNavigate] Verify: nav ball alive at {val2.transform.position} ";
							object obj2;
							if (!((Object)(object)component != (Object)null))
							{
								obj2 = "noPB";
							}
							else
							{
								FireballState currentState = component.CurrentState;
								obj2 = ((object)(FireballState)(ref currentState)).ToString();
							}
							log.LogInfo((object)(text + "state=" + (string?)obj2));
						}
						Object.Destroy((Object)(object)((Component)this).gameObject);
						if ((Object)(object)_verifierGo == (Object)(object)((Component)this).gameObject)
						{
							_verifierGo = null;
						}
						return;
					}
					_retries++;
					if (_retries == 1 || _retries % 8 == 0)
					{
						ManualLogSource log2 = Log;
						if (log2 != null)
						{
							log2.LogWarning((object)$"[CoopNavigate] Verify: nav ball still not armed after {(float)_retries * 0.25f:F2}s — retrying ArmNavigationBall");
						}
						try
						{
							val.ArmNavigationBall();
						}
						catch (Exception ex)
						{
							ManualLogSource log3 = Log;
							if (log3 != null)
							{
								log3.LogError((object)("[CoopNavigate] Verify: ArmNavigationBall threw: " + ex.Message));
							}
						}
					}
					if (_retries >= 24)
					{
						ManualLogSource log4 = Log;
						if (log4 != null)
						{
							log4.LogError((object)"[CoopNavigate] Verify: gave up after 6s — nav ball never armed on client");
						}
						Object.Destroy((Object)(object)((Component)this).gameObject);
						if ((Object)(object)_verifierGo == (Object)(object)((Component)this).gameObject)
						{
							_verifierGo = null;
						}
					}
				}
				catch (Exception ex2)
				{
					ManualLogSource log5 = Log;
					if (log5 != null)
					{
						log5.LogError((object)("[CoopNavigate] Verify Update failed: " + ex2.Message));
					}
					Object.Destroy((Object)(object)((Component)this).gameObject);
					if ((Object)(object)_verifierGo == (Object)(object)((Component)this).gameObject)
					{
						_verifierGo = null;
					}
				}
			}
		}

		private static readonly HashSet<int> _spawnedShopBlockIds = new HashSet<int>();

		private static GameObject _verifierGo;

		public void Handle(NavigatePhaseStartEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null)
			{
				if (logger != null)
				{
					logger.LogWarning((object)"[CoopNavigate] Client: no Services — skipping phase start");
				}
			}
			else
			{
				if (services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting)
				{
					return;
				}
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopNavigate] === Client received navigate phase start: source={networkEvent.Source}, children={networkEvent.ChildNodeCount} ===");
				}
				CoopNavigateState.StartPhase(networkEvent.Source, networkEvent.ChildNodeCount, 1, Time.unscaledTime, networkEvent.ChildRoomTypes);
				MultiplayerClientPatches.AllowNavigateLogic = true;
				CoopRewardState.WaitingForOtherPlayers = false;
				CoopRewardState.AllChoicesComplete = true;
				CoopRewardState.ClientInNativeRewardPhase = false;
				CoopRewardState.TreasureAwaitingHostNavigation = false;
				CoopRewardState.TextScenarioAwaitingHostNavigation = false;
				CoopRewardState.ShopAwaitingHostNavigation = false;
				CoopRewardState.PegMinigameAwaitingHostNavigation = false;
				CoopRewardState.TreasurePhaseActive = false;
				CoopRewardState.TextScenarioPhaseActive = false;
				CoopRewardState.ShopPhaseActive = false;
				CoopRewardState.PegMinigamePhaseActive = false;
				TurnChangeClientHandler.TurnMessage = string.Empty;
				if (logger != null)
				{
					logger.LogInfo((object)"[CoopNavigate] Cleared WaitingForOtherPlayers / TurnMessage / ClientInNativeRewardPhase");
				}
				ForceCloseBattleUpgradeCanvas(logger);
				LogBattleControllerState(logger, "pre-SkipMimicNavigation");
				try
				{
					if (networkEvent.Source == "nav_only")
					{
						InvokeNavOnlyArm(logger, networkEvent.ChildNodeCount);
					}
					else
					{
						InvokePostBattleStartNavigation(logger, networkEvent.ChildNodeCount);
					}
				}
				catch (Exception ex)
				{
					if (logger != null)
					{
						logger.LogError((object)("[CoopNavigate] Client failed to arm nav ball: " + ex.Message + "\n" + ex.StackTrace));
					}
				}
				LogBattleControllerState(logger, "post-SkipMimicNavigation");
				ScheduleVerifyArmed(logger);
			}
		}

		private static void InvokeNavOnlyArm(ManualLogSource log, int childNodeCount)
		{
			//IL_01d0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01d6: Invalid comparison between Unknown and I4
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0220: Unknown result type (might be due to invalid IL or missing references)
			NavOnlyController[] array = Resources.FindObjectsOfTypeAll<NavOnlyController>();
			NavOnlyController val = null;
			if (array != null)
			{
				NavOnlyController[] array2 = array;
				foreach (NavOnlyController val2 in array2)
				{
					if ((Object)(object)val2 == (Object)null || !((Object)(object)((Component)val2).gameObject != (Object)null))
					{
						continue;
					}
					Scene scene = ((Component)val2).gameObject.scene;
					if (((Scene)(ref scene)).IsValid())
					{
						val = val2;
						if (((Component)val2).gameObject.activeInHierarchy)
						{
							break;
						}
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				if (log != null)
				{
					log.LogWarning((object)"[CoopNavigate] Client: no NavOnlyController found to arm");
				}
				return;
			}
			if (log != null)
			{
				log.LogInfo((object)$"[CoopNavigate] Found NavOnlyController '{((Object)val).name}' (active={((Component)val).gameObject.activeInHierarchy}, treasure={val.isTreasureScene}) — arming (children={childNodeCount})");
			}
			if (!((Component)val).gameObject.activeInHierarchy)
			{
				((Component)val).gameObject.SetActive(true);
			}
			DismissActiveScenarioForNavigation(val, log);
			TryFadeOutNavCurtain(log);
			FieldInfo fieldInfo = AccessTools.Field(typeof(NavOnlyController), "_ball");
			object? obj = fieldInfo?.GetValue(val);
			GameObject val3 = (GameObject)((obj is GameObject) ? obj : null);
			if ((Object)(object)val3 == (Object)null)
			{
				if (log != null)
				{
					log.LogInfo((object)"[CoopNavigate] Client: NavOnlyController._ball is null — calling Initialize()");
				}
				try
				{
					val.Initialize();
					object? obj2 = fieldInfo?.GetValue(val);
					val3 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				}
				catch (Exception ex)
				{
					if (log != null)
					{
						log.LogError((object)("[CoopNavigate] Client: NavOnlyController.Initialize() threw: " + ex.Message));
					}
				}
			}
			if ((Object)(object)val3 == (Object)null)
			{
				if (log != null)
				{
					log.LogError((object)"[CoopNavigate] Client: nav ball still null after Initialize — cannot arm");
				}
				return;
			}
			PachinkoBall component = val3.GetComponent<PachinkoBall>();
			if ((Object)(object)component == (Object)null)
			{
				if (log != null)
				{
					log.LogError((object)"[CoopNavigate] Client: nav ball has no PachinkoBall component");
				}
				return;
			}
			try
			{
				component.Arm();
			}
			catch (Exception ex2)
			{
				if (log != null)
				{
					log.LogError((object)("[CoopNavigate] Client: PachinkoBall.Arm threw: " + ex2.Message));
				}
			}
			try
			{
				if ((int)component.CurrentState != 1)
				{
					AccessTools.Property(typeof(PachinkoBall), "CurrentState")?.GetSetMethod(nonPublic: true)?.Invoke(component, new object[1] { (object)(FireballState)1 });
					if (log != null)
					{
						log.LogInfo((object)$"[CoopNavigate] Forced ball state -> AIMING (was {component.CurrentState})");
					}
				}
			}
			catch (Exception ex3)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] Force-AIMING failed: " + ex3.Message));
				}
			}
			TrajectorySimulation component2 = val3.GetComponent<TrajectorySimulation>();
			if (Object.op_Implicit((Object)(object)component2))
			{
				((Behaviour)component2).enabled = true;
			}
			try
			{
				PredictionManager val4 = Object.FindObjectOfType<PredictionManager>();
				if (val4 != null)
				{
					val4.CopyAllPegs();
				}
				if (log != null)
				{
					log.LogInfo((object)("[CoopNavigate] Client called PredictionManager.CopyAllPegs (pm=" + (((Object)(object)val4 != (Object)null) ? "ok" : "null") + ")"));
				}
			}
			catch (Exception ex4)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] CopyAllPegs failed: " + ex4.Message));
				}
			}
			ConfigureNavOnlySlotManagers(val, childNodeCount, log);
			if (log != null)
			{
				log.LogInfo((object)"[CoopNavigate] Client armed NavOnly nav ball");
			}
		}

		private static void ConfigureNavOnlySlotManagers(NavOnlyController noc, int childCount, ManualLogSource log)
		{
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			//IL_00be: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0144: Unknown result type (might be due to invalid IL or missing references)
			//IL_0158: Unknown result type (might be due to invalid IL or missing references)
			//IL_00e4: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f8: Unknown result type (might be due to invalid IL or missing references)
			//IL_018f: 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_019a: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(NavOnlyController), "_leftSlotManager");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(NavOnlyController), "_rightSlotManager");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(NavOnlyController), "_centreSlotManager");
				object? obj = fieldInfo?.GetValue(noc);
				SlotManager val = (SlotManager)((obj is SlotManager) ? obj : null);
				object? obj2 = fieldInfo2?.GetValue(noc);
				SlotManager val2 = (SlotManager)((obj2 is SlotManager) ? obj2 : null);
				object? obj3 = fieldInfo3?.GetValue(noc);
				SlotManager val3 = (SlotManager)((obj3 is SlotManager) ? obj3 : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
				{
					if (log != null)
					{
						log.LogWarning((object)"[CoopNavigate] Client: NavOnlyController slot managers not wired");
					}
					return;
				}
				Sprite val4 = LookupIconForChildSlot(0, childCount);
				Color val5 = LookupColorForChildSlot(0, childCount);
				Sprite val6 = LookupIconForChildSlot(childCount - 1, childCount);
				Color val7 = LookupColorForChildSlot(childCount - 1, childCount);
				((Component)val).gameObject.SetActive(true);
				((Component)val2).gameObject.SetActive(true);
				if (childCount <= 1)
				{
					val.ConfigureForNavigation(val4, val5, 0f, 0f);
					val2.ConfigureForNavigation(val6, val7, 0f, 0f);
					val.ToggleNavigationIconVisibility(false);
					val2.ToggleNavigationIconVisibility(false);
					if ((Object)(object)val3 != (Object)null)
					{
						((Component)val3).gameObject.SetActive(true);
						val3.ConfigureForIconOnly(val4, 0f);
					}
				}
				else
				{
					val.ConfigureForNavigation(val4, val5, 0f, 0f);
					val2.ConfigureForNavigation(val6, val7, 0f, 0f);
					if ((Object)(object)val3 != (Object)null)
					{
						((Component)val3).gameObject.SetActive(true);
						if (childCount > 2)
						{
							Sprite val8 = LookupIconForChildSlot(1, childCount);
							Color val9 = LookupColorForChildSlot(1, childCount);
							val3.ConfigureForNavigation(val8, val9, 0f, 0f);
						}
						else
						{
							val3.ConfigureDudNavigation();
						}
					}
				}
				if (log != null)
				{
					log.LogInfo((object)$"[CoopNavigate] Client activated NavOnly slot managers (children={childCount}, types=[{FormatRoomTypes(CoopNavigateState.ChildRoomTypes)}])");
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] ConfigureNavOnlySlotManagers failed: " + ex.Message));
				}
			}
		}

		private static Sprite LookupIconForChildSlot(int childIndex, int childCount)
		{
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0044: Unknown result type (might be due to invalid IL or missing references)
			int[] childRoomTypes = CoopNavigateState.ChildRoomTypes;
			if (childRoomTypes == null || childIndex < 0 || childIndex >= childRoomTypes.Length)
			{
				return AnyMapNodeIcon();
			}
			RoomType val = (RoomType)childRoomTypes[childIndex];
			try
			{
				MapNode[] array = Resources.FindObjectsOfTypeAll<MapNode>();
				if (array != null)
				{
					MapNode[] array2 = array;
					foreach (MapNode val2 in array2)
					{
						if ((Object)(object)val2 != (Object)null && val2.RoomType == val && (Object)(object)val2.activeIcon != (Object)null)
						{
							return val2.activeIcon;
						}
					}
				}
			}
			catch
			{
			}
			return AnyMapNodeIcon();
		}

		private static Sprite AnyMapNodeIcon()
		{
			try
			{
				MapNode[] array = Resources.FindObjectsOfTypeAll<MapNode>();
				if (array != null && array.Length != 0)
				{
					return array[0].activeIcon;
				}
			}
			catch
			{
			}
			return null;
		}

		private static Color LookupColorForChildSlot(int childIndex, int childCount)
		{
			//IL_0026: Unknown result type (might be due to invalid IL or missing references)
			//IL_002b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0013: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			int[] childRoomTypes = CoopNavigateState.ChildRoomTypes;
			if (childRoomTypes == null || childIndex < 0 || childIndex >= childRoomTypes.Length)
			{
				return Color.white;
			}
			try
			{
				return MapNode.GetColorForNodeType((RoomType)childRoomTypes[childIndex]);
			}
			catch
			{
				return Color.white;
			}
		}

		private static string FormatRoomTypes(int[] types)
		{
			//IL_001f: Unknown result type (might be due to invalid IL or missing references)
			if (types == null || types.Length == 0)
			{
				return string.Empty;
			}
			string[] array = new string[types.Length];
			for (int i = 0; i < types.Length; i++)
			{
				int num = i;
				RoomType val = (RoomType)types[i];
				array[num] = ((object)(RoomType)(ref val)).ToString();
			}
			return string.Join(",", array);
		}

		private static void DismissActiveScenarioForNavigation(NavOnlyController noc, ManualLogSource log)
		{
			//IL_0036: Unknown result type (might be due to invalid IL or missing references)
			//IL_003b: Unknown result type (might be due to invalid IL or missing references)
			//IL_009a: Unknown result type (might be due to invalid IL or missing references)
			//IL_009f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0101: Unknown result type (might be due to invalid IL or missing references)
			//IL_0106: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)noc == (Object)null)
			{
				return;
			}
			try
			{
				ShopManager[] array = Resources.FindObjectsOfTypeAll<ShopManager>();
				Scene scene;
				foreach (ShopManager val in array)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null))
					{
						scene = ((Component)val).gameObject.scene;
						if (((Scene)(ref scene)).IsValid() && (Object)(object)val.navController == (Object)(object)noc)
						{
							DismissShopForNavigation(val, log);
							return;
						}
					}
				}
				ChestScenarioController[] array2 = Resources.FindObjectsOfTypeAll<ChestScenarioController>();
				foreach (ChestScenarioController val2 in array2)
				{
					if (!((Object)(object)val2 == (Object)null) && !((Object)(object)((Component)val2).gameObject == (Object)null))
					{
						scene = ((Component)val2).gameObject.scene;
						if (((Scene)(ref scene)).IsValid() && (Object)(object)val2.navController == (Object)(object)noc)
						{
							DismissChestForNavigation(val2, log);
							return;
						}
					}
				}
				DialogueSystemScenario[] array3 = Resources.FindObjectsOfTypeAll<DialogueSystemScenario>();
				foreach (DialogueSystemScenario val3 in array3)
				{
					if ((Object)(object)val3 == (Object)null || (Object)(object)((Component)val3).gameObject == (Object)null)
					{
						continue;
					}
					scene = ((Component)val3).gameObject.scene;
					if (((Scene)(ref scene)).IsValid())
					{
						GameObject navController = val3.navController;
						if ((Object)(object)((navController != null) ? navController.GetComponent<NavOnlyController>() : null) == (Object)(object)noc)
						{
							DismissDialogueForNavigation(val3, log);
							return;
						}
					}
				}
				if (log != null)
				{
					log.LogWarning((object)"[CoopNavigate] DismissActiveScenarioForNavigation: no matching scenario controller found for this NavOnlyController");
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] DismissActiveScenarioForNavigation failed: " + ex.Message));
				}
			}
		}

		private static void DismissShopForNavigation(ShopManager shop, ManualLogSource log)
		{
			//IL_006b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0077: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0083: 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_03d8: Unknown result type (might be due to invalid IL or missing references)
			//IL_03dd: Unknown result type (might be due to invalid IL or missing references)
			//IL_03e9: Unknown result type (might be due to invalid IL or missing references)
			//IL_03f6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03fd: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)shop.shopUI != (Object)null && ((Component)shop.shopUI).gameObject.activeInHierarchy)
				{
					((Component)shop.shopUI).gameObject.SetActive(false);
				}
				if ((Object)(object)shop.fadeCurtain != (Object)null)
				{
					((Behaviour)shop.fadeCurtain).enabled = false;
					((Graphic)shop.fadeCurtain).raycastTarget = false;
				}
				if ((Object)(object)shop.navCurtain != (Object)null)
				{
					Color color = ((Graphic)shop.navCurtain).color;
					((Graphic)shop.navCurtain).color = new Color(color.r, color.g, color.b, 0f);
					((Behaviour)shop.navCurtain).enabled = false;
					((Graphic)shop.navCurtain).raycastTarget = false;
				}
				if ((Object)(object)shop.playfieldMouseDetector != (Object)null && !((Component)shop.playfieldMouseDetector).gameObject.activeSelf)
				{
					((Component)shop.playfieldMouseDetector).gameObject.SetActive(true);
				}
				if ((Object)(object)shop.pegLayout != (Object)null && !shop.pegLayout.activeSelf)
				{
					shop.pegLayout.SetActive(true);
				}
				try
				{
					PredictionManager val = Object.FindObjectOfType<PredictionManager>();
					if ((Object)(object)val != (Object)null && (Object)(object)shop.pegLayout != (Object)null && (Object)(object)shop.relicManager != (Object)null)
					{
						object? obj = AccessTools.Field(typeof(ShopManager), "_pegboardFrame")?.GetValue(shop);
						GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
						val.Initialize(shop.pegLayout, val2, shop.relicManager, true);
						if (log != null)
						{
							log.LogInfo((object)("[CoopNavigate] Client initialized PredictionManager (pegLayout=" + ((Object)shop.pegLayout).name + ", frame=" + (((Object)(object)val2 != (Object)null) ? ((Object)val2).name : "null") + ")"));
						}
					}
					else if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] Client: cannot init PredictionManager (pm=" + (((Object)(object)val != (Object)null) ? "ok" : "null") + ", pegLayout=" + (((Object)(object)shop.pegLayout != (Object)null) ? "ok" : "null") + ", relicMgr=" + (((Object)(object)shop.relicManager != (Object)null) ? "ok" : "null") + ")"));
					}
				}
				catch (Exception ex)
				{
					if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] PredictionManager.Initialize failed: " + ex.Message));
					}
				}
				try
				{
					if ((Object)(object)shop.pegLayout != (Object)null && _spawnedShopBlockIds.Add(((Object)shop).GetInstanceID()))
					{
						SpawnBlocksToMatchShopItems component = shop.pegLayout.GetComponent<SpawnBlocksToMatchShopItems>();
						if ((Object)(object)component != (Object)null)
						{
							FieldInfo fieldInfo = AccessTools.Field(typeof(ShopManager), "_purchasableOrbs");
							FieldInfo fieldInfo2 = AccessTools.Field(typeof(ShopManager), "_purchasableRelics");
							FieldInfo fieldInfo3 = AccessTools.Field(typeof(ShopManager), "_orbRemoved");
							IPurchasableItem[] array = fieldInfo?.GetValue(shop) as IPurchasableItem[];
							IPurchasableItem[] array2 = fieldInfo2?.GetValue(shop) as IPurchasableItem[];
							bool valueOrDefault = ((bool?)fieldInfo3?.GetValue(shop)).GetValueOrDefault();
							if (array != null)
							{
								component.SpawnOrbBlocks(array);
							}
							if (array2 != null)
							{
								component.SpawnRelicBlocks(array2);
							}
							component.ToggleRemoveOrbRow(valueOrDefault);
							if (log != null)
							{
								log.LogInfo((object)$"[CoopNavigate] Client spawned shop blocks: orbs={((array != null) ? array.Length : 0)}, relics={((array2 != null) ? array2.Length : 0)}, orbRemoved={valueOrDefault}");
							}
						}
					}
				}
				catch (Exception ex2)
				{
					if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] SpawnBlocksToMatchShopItems failed: " + ex2.Message));
					}
				}
				if ((Object)(object)Camera.main != (Object)null)
				{
					Vector3 position = ((Component)Camera.main).transform.position;
					((Component)Camera.main).transform.position = new Vector3(position.x, shop.cameraNavY, position.z);
				}
				ShopManager.isOpen = false;
				PauseMenu.PauseBlock = false;
				try
				{
					AccessTools.Field(typeof(ShopManager), "_storeClosed")?.SetValue(shop, true);
				}
				catch (Exception ex3)
				{
					if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] set _storeClosed failed: " + ex3.Message));
					}
				}
				try
				{
					((Selectable)shop.exitStoreButton).interactable = false;
				}
				catch
				{
				}
				try
				{
					EventSystem current = EventSystem.current;
					if (current != null)
					{
						current.SetSelectedGameObject((GameObject)null);
					}
				}
				catch
				{
				}
				CoopRewardState.ShopPhaseActive = false;
				CoopRewardState.ShopAwaitingHostNavigation = false;
				CoopRewardState.WaitingForOtherPlayers = false;
				if (log != null)
				{
					log.LogInfo((object)"[CoopNavigate] Client dismissed ShopManager UI for navigation");
				}
			}
			catch (Exception ex4)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] DismissShopForNavigation failed: " + ex4.Message));
				}
			}
		}

		private static void DismissChestForNavigation(ChestScenarioController chest, ManualLogSource log)
		{
			//IL_026a: Unknown result type (might be due to invalid IL or missing references)
			//IL_026f: Unknown result type (might be due to invalid IL or missing references)
			//IL_027a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0286: Unknown result type (might be due to invalid IL or missing references)
			//IL_028c: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((Object)(object)chest.skipButton != (Object)null && ((Component)chest.skipButton).gameObject.activeInHierarchy)
				{
					((Component)chest.skipButton).gameObject.SetActive(false);
				}
				if ((Object)(object)chest.clickTextContainer != (Object)null && chest.clickTextContainer.activeInHierarchy)
				{
					chest.clickTextContainer.SetActive(false);
				}
				if ((Object)(object)chest.relicGrantPopup != (Object)null && ((Component)chest.relicGrantPopup).gameObject.activeInHierarchy)
				{
					((Component)chest.relicGrantPopup).gameObject.SetActive(false);
				}
				if ((Object)(object)chest.navCurtain != (Object)null && ((Behaviour)chest.navCurtain).enabled)
				{
					((Behaviour)chest.navCurtain).enabled = false;
				}
				if ((Object)(object)chest.playfieldMouseDetection != (Object)null && !chest.playfieldMouseDetection.activeSelf)
				{
					chest.playfieldMouseDetection.SetActive(true);
				}
				try
				{
					PredictionManager val = Object.FindObjectOfType<PredictionManager>();
					MapData dataToLoad = StaticGameData.dataToLoad;
					MapData obj = ((dataToLoad is MapDataTreasure) ? dataToLoad : null);
					GameObject val2 = ((obj != null) ? obj.pegboardFrame : null);
					if ((Object)(object)val != (Object)null && (Object)(object)chest.pegLayout != (Object)null && (Object)(object)chest.relicManager != (Object)null && (Object)(object)val2 != (Object)null)
					{
						val.Initialize(chest.pegLayout, val2, chest.relicManager, true);
						val.CreateFakePegboard();
						if (log != null)
						{
							log.LogInfo((object)("[CoopNavigate] Client initialized chest PredictionManager (pegLayout=" + ((Object)chest.pegLayout).name + ", frame=" + ((Object)val2).name + ")"));
						}
					}
					else if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] Cannot init chest PredictionManager (pm=" + (((Object)(object)val != (Object)null) ? "ok" : "null") + ", pegLayout=" + (((Object)(object)chest.pegLayout != (Object)null) ? "ok" : "null") + ", relicMgr=" + (((Object)(object)chest.relicManager != (Object)null) ? "ok" : "null") + ", frame=" + (((Object)(object)val2 != (Object)null) ? "ok" : "null") + ")"));
					}
				}
				catch (Exception ex)
				{
					if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] Chest PredictionManager.Initialize failed: " + ex.Message));
					}
				}
				if ((Object)(object)Camera.main != (Object)null)
				{
					Vector3 position = ((Component)Camera.main).transform.position;
					((Component)Camera.main).transform.position = new Vector3(position.x, chest.cameraNavY, position.z);
				}
				PauseMenu.PauseBlock = false;
				CoopRewardState.TreasurePhaseActive = false;
				CoopRewardState.TreasureAwaitingHostNavigation = false;
				CoopRewardState.WaitingForOtherPlayers = false;
				if (log != null)
				{
					log.LogInfo((object)"[CoopNavigate] Client dismissed ChestScenarioController UI for navigation");
				}
			}
			catch (Exception ex2)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] DismissChestForNavigation failed: " + ex2.Message));
				}
			}
		}

		private static void DismissDialogueForNavigation(DialogueSystemScenario dialogue, ManualLogSource log)
		{
			try
			{
				if ((Object)(object)dialogue.mainTextAnimatorCanvas != (Object)null && ((Component)dialogue.mainTextAnimatorCanvas).gameObject.activeInHierarchy)
				{
					((Component)dialogue.mainTextAnimatorCanvas).gameObject.SetActive(false);
				}
				if ((Object)(object)dialogue.navCurtain != (Object)null && ((Behaviour)dialogue.navCurtain).enabled)
				{
					((Behaviour)dialogue.navCurtain).enabled = false;
				}
				if ((Object)(object)dialogue.fullCurtain != (Object)null && ((Behaviour)dialogue.fullCurtain).enabled)
				{
					((Behaviour)dialogue.fullCurtain).enabled = false;
				}
				PauseMenu.PauseBlock = false;
				CoopRewardState.TextScenarioPhaseActive = false;
				CoopRewardState.TextScenarioAwaitingHostNavigation = false;
				CoopRewardState.WaitingForOtherPlayers = false;
				if (log != null)
				{
					log.LogInfo((object)"[CoopNavigate] Client dismissed DialogueSystemScenario UI for navigation");
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] DismissDialogueForNavigation failed: " + ex.Message));
				}
			}
		}

		private static void TryFadeOutNavCurtain(ManualLogSource log)
		{
			try
			{
				ChestScenarioController[] array = Resources.FindObjectsOfTypeAll<ChestScenarioController>();
				if (array == null)
				{
					return;
				}
				ChestScenarioController[] array2 = array;
				foreach (ChestScenarioController val in array2)
				{
					if (!((Object)(object)val == (Object)null) && !((Object)(object)val.navCurtain == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
					{
						((Behaviour)val.navCurtain).enabled = false;
					}
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] TryFadeOutNavCurtain failed: " + ex.Message));
				}
			}
		}

		private static void InvokePostBattleStartNavigation(ManualLogSource log, int childNodeCount)
		{
			//IL_01b0: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b6: Invalid comparison between Unknown and I4
			//IL_0200: Unknown result type (might be due to invalid IL or missing references)
			PostBattleController[] array = Resources.FindObjectsOfTypeAll<PostBattleController>();
			PostBattleController val = null;
			if (array != null)
			{
				PostBattleController[] array2 = array;
				foreach (PostBattleController val2 in array2)
				{
					if ((Object)(object)val2 != (Object)null && (Object)(object)((Component)val2).gameObject != (Object)null && ((Component)val2).gameObject.activeInHierarchy)
					{
						val = val2;
						break;
					}
				}
				if ((Object)(object)val == (Object)null && array.Length != 0)
				{
					val = array[0];
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				if (log != null)
				{
					log.LogWarning((object)"[CoopNavigate] Client: no PostBattleController to start navigation on");
				}
				return;
			}
			if (log != null)
			{
				log.LogInfo((object)$"[CoopNavigate] Found PostBattleController '{((Object)val).name}' (active={((Component)val).gameObject.activeInHierarchy}) — running client nav setup (children={childNodeCount})");
			}
			if (!((Component)val).gameObject.activeInHierarchy)
			{
				((Component)val).gameObject.SetActive(true);
			}
			ForceDeactivateWinTimeline(val, log);
			object? obj = AccessTools.Field(typeof(PostBattleController), "_battleController")?.GetValue(val);
			BattleController val3 = (BattleController)((obj is BattleController) ? obj : null);
			if ((Object)(object)val3 == (Object)null)
			{
				if (log != null)
				{
					log.LogWarning((object)"[CoopNavigate] Client: PostBattleController._battleController is null");
				}
				return;
			}
			try
			{
				val3.RemoveClearedPegs();
				val3.ResetDamageTally();
				val3.PreparePegsForNavigation();
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] Client peg-prep failed: " + ex.Message));
				}
			}
			ActivateSlotManagers(val, childNodeCount, log);
			try
			{
				val3.ArmNavigationBall();
				try
				{
					val3.ArmNavigationBallForShot();
				}
				catch (Exception ex2)
				{
					if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] ArmNavigationBallForShot failed: " + ex2.Message));
					}
				}
				try
				{
					object? obj2 = AccessTools.Field(typeof(BattleController), "_activePachinkoBall")?.GetValue(val3);
					object? obj3 = ((obj2 is GameObject) ? obj2 : null);
					PachinkoBall val4 = ((obj3 != null) ? ((GameObject)obj3).GetComponent<PachinkoBall>() : null);
					if ((Object)(object)val4 != (Object)null && (int)val4.CurrentState != 1)
					{
						AccessTools.Property(typeof(PachinkoBall), "CurrentState")?.GetSetMethod(nonPublic: true)?.Invoke(val4, new object[1] { (object)(FireballState)1 });
						if (log != null)
						{
							log.LogInfo((object)$"[CoopNavigate] Forced post_battle ball state -> AIMING (was {val4.CurrentState})");
						}
					}
				}
				catch (Exception ex3)
				{
					if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] Force-AIMING (post_battle) failed: " + ex3.Message));
					}
				}
				try
				{
					PredictionManager predictionManager = val3.PredictionManager;
					if (predictionManager != null)
					{
						predictionManager.CopyAllPegs();
					}
				}
				catch (Exception ex4)
				{
					if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] post_battle CopyAllPegs failed: " + ex4.Message));
					}
				}
				if (log != null)
				{
					log.LogInfo((object)"[CoopNavigate] Client armed nav ball");
				}
			}
			catch (Exception ex5)
			{
				if (log != null)
				{
					log.LogError((object)("[CoopNavigate] Client ArmNavigationBall threw: " + ex5.Message));
				}
			}
		}

		private static void ForceDeactivateWinTimeline(PostBattleController pbc, ManualLogSource log)
		{
			try
			{
				object? obj = AccessTools.Field(typeof(PostBattleController), "_winTimeline")?.GetValue(pbc);
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				if ((Object)(object)val != (Object)null && val.activeInHierarchy)
				{
					val.SetActive(false);
					if (log != null)
					{
						log.LogInfo((object)"[CoopNavigate] Force-deactivated PostBattleController._winTimeline");
					}
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] ForceDeactivateWinTimeline failed: " + ex.Message));
				}
			}
		}

		private static void ActivateSlotManagers(PostBattleController pbc, int childCount, ManualLogSource log)
		{
			//IL_00b2: Unknown result type (might be due to invalid IL or missing references)
			//IL_00b7: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cd: Unknown result type (might be due to invalid IL or missing references)
			//IL_0136: Unknown result type (might be due to invalid IL or missing references)
			//IL_014b: Unknown result type (might be due to invalid IL or missing references)
			//IL_00f9: Unknown result type (might be due to invalid IL or missing references)
			//IL_010c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_016b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0170: Unknown result type (might be due to invalid IL or missing references)
			//IL_0175: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				FieldInfo fieldInfo = AccessTools.Field(typeof(PostBattleController), "_leftSlotManager");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(PostBattleController), "_centerSlotManager");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(PostBattleController), "_rightSlotManager");
				object? obj = fieldInfo?.GetValue(pbc);
				SlotManager val = (SlotManager)((obj is SlotManager) ? obj : null);
				object? obj2 = fieldInfo2?.GetValue(pbc);
				SlotManager val2 = (SlotManager)((obj2 is SlotManager) ? obj2 : null);
				object? obj3 = fieldInfo3?.GetValue(pbc);
				SlotManager val3 = (SlotManager)((obj3 is SlotManager) ? obj3 : null);
				if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || (Object)(object)val3 == (Object)null)
				{
					if (log != null)
					{
						log.LogWarning((object)"[CoopNavigate] Client: SlotManagers not all wired on PBC");
					}
					return;
				}
				Sprite val4 = LookupIconForChildSlot(0, childCount);
				Color val5 = LookupColorForChildSlot(0, childCount);
				Sprite val6 = LookupIconForChildSlot(childCount - 1, childCount);
				Color val7 = LookupColorForChildSlot(childCount - 1, childCount);
				((Component)val).gameObject.SetActive(true);
				((Component)val3).gameObject.SetActive(true);
				((Component)val2).gameObject.SetActive(true);
				if (childCount <= 1)
				{
					val.ConfigureHalfNavigation(val5, 0f, 0f);
					val3.ConfigureHalfNavigation(val5, 0f, 0f);
					val2.ConfigureForNavigation(val4, val5, 0f, 0f);
				}
				else
				{
					val.ConfigureForNavigation(val4, val5, 0f, 0f);
					val3.ConfigureForNavigation(val6, val7, 0f, 0f);
					if (childCount > 2)
					{
						Sprite val8 = LookupIconForChildSlot(1, childCount);
						Color val9 = LookupColorForChildSlot(1, childCount);
						val2.ConfigureForNavigation(val8, val9, 0f, 0f);
					}
					else
					{
						val2.ConfigureDudNavigation();
					}
				}
				if (log != null)
				{
					log.LogInfo((object)$"[CoopNavigate] Client activated {childCount} slot manager(s) (types=[{FormatRoomTypes(CoopNavigateState.ChildRoomTypes)}])");
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] ActivateSlotManagers failed: " + ex.Message));
				}
			}
		}

		private static void ForceCloseBattleUpgradeCanvas(ManualLogSource log)
		{
			try
			{
				BattleUpgradeCanvas[] array = Resources.FindObjectsOfTypeAll<BattleUpgradeCanvas>();
				if (array == null)
				{
					return;
				}
				BattleUpgradeCanvas[] array2 = array;
				foreach (BattleUpgradeCanvas val in array2)
				{
					if ((Object)(object)val != (Object)null && (Object)(object)((Component)val).gameObject != (Object)null && ((Component)val).gameObject.activeInHierarchy)
					{
						((Component)val).gameObject.SetActive(false);
						if (log != null)
						{
							log.LogInfo((object)("[CoopNavigate] Force-closed BattleUpgradeCanvas '" + ((Object)val).name + "'"));
						}
					}
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] ForceCloseBattleUpgradeCanvas failed: " + ex.Message));
				}
			}
		}

		private static void LogBattleControllerState(ManualLogSource log, string label)
		{
			//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
			//IL_00c1: Unknown result type (might be due to invalid IL or missing references)
			//IL_00d9: Unknown result type (might be due to invalid IL or missing references)
			//IL_01b8: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				BattleController val = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val == (Object)null)
				{
					if (log != null)
					{
						log.LogWarning((object)("[CoopNavigate] [" + label + "] BattleController is null"));
					}
					return;
				}
				object? obj = AccessTools.Field(typeof(BattleController), "_activePachinkoBall")?.GetValue(val);
				GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
				object? obj2 = AccessTools.Field(typeof(BattleController), "_navigationOrb")?.GetValue(val);
				GameObject val3 = (GameObject)((obj2 is GameObject) ? obj2 : null);
				FieldInfo fieldInfo = AccessTools.Field(typeof(BattleController), "_relicManager");
				FieldInfo fieldInfo2 = AccessTools.Field(typeof(BattleController), "_deckManager");
				FieldInfo fieldInfo3 = AccessTools.Field(typeof(BattleController), "_predictionManager");
				BattleState currentBattleState = BattleController.CurrentBattleState;
				if (log != null)
				{
					log.LogInfo((object)($"[CoopNavigate] [{label}] BC state={currentBattleState} " + "activeBall=" + (((Object)(object)val2 != (Object)null) ? $"alive(active={val2.activeInHierarchy})" : "null") + " navOrbPrefab=" + (((Object)(object)val3 != (Object)null) ? ((Object)val3).name : "NULL") + " relicMgr=" + (((object)fieldInfo != null && fieldInfo.GetValue(val) != null) ? "ok" : "NULL") + " deckMgr=" + (((object)fieldInfo2 != null && fieldInfo2.GetValue(val) != null) ? "ok" : "NULL") + " predMgr=" + (((object)fieldInfo3 != null && fieldInfo3.GetValue(val) != null) ? "ok" : "NULL") + " " + $"spawn={val.pachinkoBallSpawnLocation}"));
				}
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] [" + label + "] state-log failed: " + ex.Message));
				}
			}
		}

		public static void DestroyActiveVerifier()
		{
			if ((Object)(object)_verifierGo != (Object)null)
			{
				try
				{
					Object.Destroy((Object)(object)_verifierGo);
				}
				catch
				{
				}
				_verifierGo = null;
			}
		}

		private static void ScheduleVerifyArmed(ManualLogSource log)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			//IL_001d: Expected O, but got Unknown
			//IL_001d: Unknown result type (might be due to invalid IL or missing references)
			//IL_002e: Expected O, but got Unknown
			try
			{
				DestroyActiveVerifier();
				GameObject val = new GameObject("CoopNavVerify")
				{
					hideFlags = (HideFlags)61
				};
				Object.DontDestroyOnLoad((Object)val);
				val.AddComponent<NavBallArmVerifier>().Log = log;
				_verifierGo = val;
			}
			catch (Exception ex)
			{
				if (log != null)
				{
					log.LogWarning((object)("[CoopNavigate] ScheduleVerifyArmed failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class NavigatePhaseStartServerHandler : IServerHandler<NavigatePhaseStartEvent>
	{
		public NavigatePhaseStartEvent Handle(NavigatePhaseStartEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class NavigateResolvedClientHandler : IClientHandler<NavigateResolvedEvent>
	{
		public void Handle(NavigateResolvedEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)string.Format("[CoopNavigate] Client received navigate resolved: chosen={0}, tally=[{1}]", networkEvent.ChosenChildIndex, string.Join(",", networkEvent.VoteCounts ?? new List<int>())));
				}
				CoopNavigateState.Reset();
				MultiplayerClientPatches.AllowNavigateLogic = false;
			}
		}
	}
	public sealed class NavigateResolvedServerHandler : IServerHandler<NavigateResolvedEvent>
	{
		public NavigateResolvedEvent Handle(NavigateResolvedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class NavigateVoteClientHandler : IClientHandler<NavigateVoteEvent>
	{
		public void Handle(NavigateVoteEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting || !services.TryResolve<PlayerRegistry>(out var instance2))
			{
				return;
			}
			GameEventRegistry instance3;
			int num = (services.TryResolve<GameEventRegistry>(out instance3) ? instance3 : null)?.CurrentSenderPeerId ?? (-1);
			PlayerSlot slotByPeerId = instance2.GetSlotByPeerId(num);
			if (slotByPeerId == null)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"[CoopNavigate] Vote from unknown peer {num} — ignoring");
				}
			}
			else
			{
				CoopNavigateResolver.RecordClientVote(slotByPeerId.SlotIndex, networkEvent.ChildIndex);
			}
		}
	}
	public sealed class NavigateVoteServerHandler : IServerHandler<NavigateVoteEvent>
	{
		public NavigateVoteEvent Handle(NavigateVoteEvent networkEvent)
		{
			return null;
		}
	}
	public sealed class NavigateVoteUpdateClientHandler : IClientHandler<NavigateVoteUpdateEvent>
	{
		public void Handle(NavigateVoteUpdateEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if ((services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting) && networkEvent.VoteCounts != null)
			{
				if (!CoopNavigateState.PhaseActive)
				{
					CoopNavigateState.PhaseActive = true;
					CoopNavigateState.ChildNodeCount = networkEvent.VoteCounts.Count;
				}
				CoopNavigateState.VoteCounts = new List<int>(networkEvent.VoteCounts);
			}
		}
	}
	public sealed class NavigateVoteUpdateServerHandler : IServerHandler<NavigateVoteUpdateEvent>
	{
		public NavigateVoteUpdateEvent Handle(NavigateVoteUpdateEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class OrbDiscardRequestClientHandler : IClientHandler<OrbDiscardRequestEvent>
	{
		public static bool PendingDiscard { get; set; }

		public void Handle(OrbDiscardRequestEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting || !services.TryResolve<TurnManager>(out var instance2) || !services.TryResolve<PlayerRegistry>(out var instance3) || !services.TryResolve<IGameEventRegistry>(out var instance4))
			{
				return;
			}
			int num = (instance4 as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
			PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
			if (slotByPeerId == null)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"[OrbDiscardRequest] No slot for peer {num}");
				}
				return;
			}
			if (!instance2.IsSlotsTurn(slotByPeerId.SlotIndex))
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)($"[OrbDiscardRequest] Rejected from slot {slotByPeerId.SlotIndex} ({slotByPeerId.PlayerName}): " + $"not their turn (current: slot {instance2.CurrentPlayerSlot}, phase: {instance2.Phase})"));
				}
				return;
			}
			ManualLogSource logger3 = MultiplayerPlugin.Logger;
			if (logger3 != null)
			{
				logger3.LogInfo((object)$"[OrbDiscardRequest] Accepted discard from slot {slotByPeerId.SlotIndex} ({slotByPeerId.PlayerName})");
			}
			PendingDiscard = true;
		}
	}
	public sealed class OrbDiscardRequestServerHandler : IServerHandler<OrbDiscardRequestEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("OrbDiscardRequestServer");

		public OrbDiscardRequestEvent Handle(OrbDiscardRequestEvent networkEvent)
		{
			_log.LogInfo((object)"[OrbDiscardRequestServer] Received discard request — suppressing rebroadcast");
			return null;
		}
	}
	public sealed class PendingDamagePreviewClientHandler : IClientHandler<PendingDamagePreviewEvent>
	{
		public void Handle(PendingDamagePreviewEvent networkEvent)
		{
			if (networkEvent.Entries == null || networkEvent.Entries.Count == 0)
			{
				PendingDamageOverlay.ClearAll();
				return;
			}
			foreach (PendingDamagePreviewEvent.DamageEntry entry in networkEvent.Entries)
			{
				PendingDamageOverlay.SetPlayerDamage(entry.SlotIndex, entry.PlayerName, entry.Damage, entry.TargetEnemyGuid, entry.IsAoE);
			}
		}
	}
	public sealed class PendingDamagePreviewServerHandler : IServerHandler<PendingDamagePreviewEvent>
	{
		public PendingDamagePreviewEvent Handle(PendingDamagePreviewEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class PostBattleBossHealClientHandler : IClientHandler<PostBattleBossHealEvent>
	{
		public void Handle(PostBattleBossHealEvent networkEvent)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || networkEvent?.Entries == null || (services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting) || !services.TryResolve<PlayerRegistry>(out var instance2))
				{
					return;
				}
				PlayerSlot mySlot = instance2.LocalSlot;
				if (mySlot == null)
				{
					return;
				}
				PostBattleBossHealEvent.Entry entry = networkEvent.Entries.FirstOrDefault((PostBattleBossHealEvent.Entry e) => e.SlotIndex == mySlot.SlotIndex);
				if (entry != null && !(entry.HealedAmount <= 0f))
				{
					PlayerHealthController val = Resources.FindObjectsOfTypeAll<PlayerHealthController>().FirstOrDefault();
					if ((Object)(object)val != (Object)null)
					{
						SetFloatVariable(val, "_playerHealth", entry.NewCurrentHealth);
						SetFloatVariable(val, "_maxPlayerHealth", entry.MaxHealth);
					}
					PlayerHealthEvent onPlayerHealed = PlayerHealthController.OnPlayerHealed;
					if (onPlayerHealed != null)
					{
						onPlayerHealed.Invoke(entry.HealedAmount);
					}
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[BossHeal] applied slot={entry.SlotIndex} +{entry.HealedAmount} -> {entry.NewCurrentHealth}/{entry.MaxHealth}");
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[BossHeal] handler failed: " + ex.Message));
				}
			}
		}

		private static void SetFloatVariable(PlayerHealthController phc, string fieldName, float value)
		{
			object obj = AccessTools.Field(typeof(PlayerHealthController), fieldName)?.GetValue(phc);
			if (obj != null)
			{
				AccessTools.Method(obj.GetType(), "Set", new Type[1] { typeof(float) }, (Type[])null)?.Invoke(obj, new object[1] { value });
			}
		}
	}
	public sealed class PostBattleBossHealServerHandler : IServerHandler<PostBattleBossHealEvent>
	{
		public PostBattleBossHealEvent Handle(PostBattleBossHealEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class PostBattleCompleteClientHandler : IClientHandler<PostBattleCompleteEvent>
	{
		public void Handle(PostBattleCompleteEvent networkEvent)
		{
			//IL_0308: Unknown result type (might be due to invalid IL or missing references)
			//IL_0313: Invalid comparison between Unknown and I4
			//IL_035b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Expected I4, but got Unknown
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[PostBattleComplete] From unknown peer {num}");
					}
					return;
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)($"[PostBattleComplete] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}) finished rewards: " + $"HP={networkEvent.CurrentHealth}/{networkEvent.MaxHealth} Gold={networkEvent.Gold} Deck={networkEvent.CompleteDeck?.Count ?? 0}"));
				}
				if (!services.TryResolve<CoopStateManager>(out var instance4))
				{
					return;
				}
				CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
				if (playerState == null)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)$"[PostBattleComplete] No CoopPlayerState for slot {slotByPeerId.SlotIndex}");
					}
					return;
				}
				float currentHealth = playerState.CurrentHealth;
				float maxHealth = playerState.MaxHealth;
				int gold = playerState.Gold;
				if (networkEvent.MaxHealth > maxHealth)
				{
					playerState.MaxHealth = networkEvent.MaxHealth;
				}
				float maxHealth2 = playerState.MaxHealth;
				if (networkEvent.CurrentHealth > currentHealth)
				{
					playerState.CurrentHealth = ((networkEvent.CurrentHealth > maxHealth2) ? maxHealth2 : networkEvent.CurrentHealth);
				}
				if (currentHealth != playerState.CurrentHealth || maxHealth != playerState.MaxHealth || gold != playerState.Gold)
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogInfo((object)($"[PostBattleComplete] Slot {slotByPeerId.SlotIndex} state: hp {currentHealth}->{playerState.CurrentHealth}/{playerState.MaxHealth} " + $"gold {gold} (client reported hp={networkEvent.CurrentHealth}/{networkEvent.MaxHealth} gold={networkEvent.Gold})"));
					}
				}
				if (networkEvent.CompleteDeck != null)
				{
					playerState.CompleteDeck = networkEvent.CompleteDeck.Select((PostBattleOrbEntry o) => new SerializedOrb
					{
						PrefabName = o.PrefabName,
						Guid = Guid.NewGuid().ToString(),
						Level = o.Level
					}).ToList();
				}
				playerState.BattleDeck.Clear();
				playerState.ShuffledOrder.Clear();
				playerState.CurrentOrb = string.Empty;
				if (networkEvent.ChosenRelicEffect >= 0)
				{
					Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
					Relic val = null;
					Relic[] array2 = array;
					foreach (Relic val2 in array2)
					{
						if ((int)val2.effect == networkEvent.ChosenRelicEffect)
						{
							val = val2;
							break;
						}
					}
					if ((Object)(object)val != (Object)null)
					{
						playerState.OwnedRelics.Add(new SerializedRelic
						{
							Effect = networkEvent.ChosenRelicEffect,
							LocKey = val.locKey,
							Rarity = (int)val.globalRarity
						});
						ManualLogSource logger5 = MultiplayerPlugin.Logger;
						if (logger5 != null)
						{
							logger5.LogInfo((object)$"[PostBattleComplete] Added relic '{val.locKey}' (effect={networkEvent.ChosenRelicEffect}) to slot {slotByPeerId.SlotIndex}");
						}
					}
					else
					{
						ManualLogSource logger6 = MultiplayerPlugin.Logger;
						if (logger6 != null)
						{
							logger6.LogWarning((object)$"[PostBattleComplete] Could not find Relic asset for effect={networkEvent.ChosenRelicEffect}");
						}
					}
				}
				else if (!string.IsNullOrEmpty(networkEvent.ChosenRelicName))
				{
					ManualLogSource logger7 = MultiplayerPlugin.Logger;
					if (logger7 != null)
					{
						logger7.LogInfo((object)"[PostBattleComplete] Player skipped boss relic selection");
					}
				}
				CoopRewardState.ClientRewardChoicesReceived.Add(slotByPeerId.SlotIndex);
				ManualLogSource logger8 = MultiplayerPlugin.Logger;
				if (logger8 != null)
				{
					logger8.LogInfo((object)($"[PostBattleComplete] Reward completion: {CoopRewardState.ClientRewardChoicesReceived.Count}/{CoopRewardState.TotalRewardClientsExpected}" + $" hostDone={CoopRewardState.HostRewardsDone}"));
				}
				if (!CoopRewardState.HostRewardsDone || !CoopRewardState.AllClientRewardChoicesReceived)
				{
					return;
				}
				ManualLogSource logger9 = MultiplayerPlugin.Logger;
				if (logger9 != null)
				{
					logger9.LogInfo((object)"[PostBattleComplete] All players done — dispatching AllChoicesComplete and starting navigation");
				}
				CoopRewardState.HostRewardPhaseActive = false;
				CoopRewardState.WaitingForOtherPlayers = false;
				instance4.ClearNegativeDebuffsFromAllPlayers();
				if (services.TryResolve<IGameEventRegistry>(out var instance5))
				{
					instance5.Dispatch(new AllChoicesCompleteEvent
					{
						Phase = "post_battle"
					});
				}
				PostBattleController pendingPostBattleController = CoopRewardState.PendingPostBattleController;
				if (!((Object)(object)pendingPostBattleController != (Object)null))
				{
					return;
				}
				CoopRewardState.PendingPostBattleController = null;
				try
				{
					MapNode currentNode = StaticGameData.currentNode;
					int valueOrDefault = ((currentNode == null) ? null : currentNode.ChildNodes?.Length).GetValueOrDefault();
					CoopNavigateResolver.StartPhase("post_battle", valueOrDefault, CoopNavigateResolver.CaptureChildRoomTypes());
				}
				catch (Exception ex)
				{
					ManualLogSource logger10 = MultiplayerPlugin.Logger;
					if (logger10 != null)
					{
						logger10.LogWarning((object)("[PostBattleComplete] StartPhase failed: " + ex.Message));
					}
				}
				AccessTools.Method(typeof(PostBattleController), "StartNavigation", (Type[])null, (Type[])null)?.Invoke(pendingPostBattleController, new object[1] { true });
			}
			catch (Exception ex2)
			{
				ManualLogSource logger11 = MultiplayerPlugin.Logger;
				if (logger11 != null)
				{
					logger11.LogWarning((object)("[PostBattleComplete] Handler failed: " + ex2.Message));
				}
			}
		}
	}
	public sealed class PostBattleCompleteServerHandler : IServerHandler<PostBattleCompleteEvent>
	{
		public PostBattleCompleteEvent Handle(PostBattleCompleteEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[PostBattleCompleteServer] Received — suppressing rebroadcast");
			}
			return null;
		}
	}
	public sealed class PostBattleGoldSpentClientHandler : IClientHandler<PostBattleGoldSpentEvent>
	{
		public void Handle(PostBattleGoldSpentEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[PostBattleGoldSpent] From unknown peer {num}");
					}
				}
				else
				{
					if (!services.TryResolve<CoopStateManager>(out var instance4))
					{
						return;
					}
					CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
					if (playerState != null)
					{
						int gold = playerState.Gold;
						playerState.Gold = Math.Max(0, playerState.Gold - e.Amount);
						float currentHealth = playerState.CurrentHealth;
						float maxHealth = playerState.MaxHealth;
						if (e.MaxHealth > maxHealth)
						{
							playerState.MaxHealth = e.MaxHealth;
						}
						if (e.CurrentHealth > currentHealth)
						{
							playerState.CurrentHealth = Math.Min(e.CurrentHealth, playerState.MaxHealth);
						}
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogInfo((object)($"[PostBattleGoldSpent] Slot {slotByPeerId.SlotIndex} spent {e.Amount} gold ({gold} -> {playerState.Gold}), " + $"hp {currentHealth}/{maxHealth} -> {playerState.CurrentHealth}/{playerState.MaxHealth} (client reported {e.CurrentHealth}/{e.MaxHealth})"));
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[PostBattleGoldSpent] Handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class PostBattleGoldSpentServerHandler : IServerHandler<PostBattleGoldSpentEvent>
	{
		public PostBattleGoldSpentEvent Handle(PostBattleGoldSpentEvent networkEvent)
		{
			return null;
		}
	}
	public sealed class PostBattleRelicChoicesClientHandler : IClientHandler<PostBattleRelicChoicesEvent>
	{
		public void Handle(PostBattleRelicChoicesEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && (!services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting))
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[PostBattleRelicChoices] Received {e.Choices?.Count ?? 0} relic choices from host");
					}
					CoopRewardState.PendingPostBattleRelicChoices = e.Choices;
					ApplyRelicChoicesToUI(e);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[PostBattleRelicChoices] Handler failed: " + ex.Message + "\n" + ex.StackTrace));
				}
			}
		}

		internal static void ApplyRelicChoicesToUI(PostBattleRelicChoicesEvent e)
		{
			if (e?.Choices == null || e.Choices.Count == 0)
			{
				return;
			}
			BattleUpgradeCanvas[] array = Resources.FindObjectsOfTypeAll<BattleUpgradeCanvas>();
			if (array == null || array.Length == 0)
			{
				return;
			}
			BattleUpgradeCanvas val = null;
			BattleUpgradeCanvas[] array2 = array;
			foreach (BattleUpgradeCanvas val2 in array2)
			{
				if (((Component)val2).gameObject.activeInHierarchy)
				{
					val = val2;
					break;
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				return;
			}
			object? obj = AccessTools.Field(typeof(BattleUpgradeCanvas), "_relicPanel")?.GetValue(val);
			GameObject val3 = (GameObject)((obj is GameObject) ? obj : null);
			if ((Object)(object)val3 == (Object)null || !val3.activeInHierarchy)
			{
				return;
			}
			RelicIcon[] componentsInChildren = val3.GetComponentsInChildren<RelicIcon>(true);
			if (componentsInChildren == null || componentsInChildren.Length == 0)
			{
				return;
			}
			Relic[] allRelics = Resources.FindObjectsOfTypeAll<Relic>();
			int num = 0;
			for (int j = 0; j < componentsInChildren.Length; j++)
			{
				if (j < e.Choices.Count)
				{
					RelicChoiceEntry relicChoiceEntry = e.Choices[j];
					Relic val4 = FindRelicByEffect(allRelics, relicChoiceEntry.Effect);
					if ((Object)(object)val4 != (Object)null)
					{
						componentsInChildren[j].SetRelic(val4);
						componentsInChildren[j].shouldShowTooltip = false;
						((Component)((Component)componentsInChildren[j]).transform.parent).gameObject.SetActive(true);
						num++;
						ManualLogSource logger = MultiplayerPlugin.Logger;
						if (logger != null)
						{
							logger.LogInfo((object)$"[PostBattleRelicChoices] Set icon {j} to '{val4.locKey}' (effect={relicChoiceEntry.Effect})");
						}
					}
					else
					{
						ManualLogSource logger2 = MultiplayerPlugin.Logger;
						if (logger2 != null)
						{
							logger2.LogWarning((object)$"[PostBattleRelicChoices] Could not find Relic asset for effect={relicChoiceEntry.Effect}");
						}
					}
				}
				else
				{
					((Component)((Component)componentsInChildren[j]).transform.parent).gameObject.SetActive(false);
				}
			}
			ManualLogSource logger3 = MultiplayerPlugin.Logger;
			if (logger3 != null)
			{
				logger3.LogInfo((object)$"[PostBattleRelicChoices] Applied {num}/{e.Choices.Count} host relic choices to UI");
			}
		}

		private static Relic FindRelicByEffect(Relic[] allRelics, int effect)
		{
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Invalid comparison between Unknown and I4
			foreach (Relic val in allRelics)
			{
				if ((int)val.effect == effect)
				{
					return val;
				}
			}
			return null;
		}
	}
	public sealed class PostBattleRelicChoicesServerHandler : IServerHandler<PostBattleRelicChoicesEvent>
	{
		public PostBattleRelicChoicesEvent Handle(PostBattleRelicChoicesEvent e)
		{
			return e;
		}
	}
	public sealed class PostBattleStartClientHandler : IClientHandler<PostBattleStartEvent>
	{
		public void Handle(PostBattleStartEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || (services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting))
			{
				return;
			}
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[PostBattleStart] Client received post-battle start — activating native reward screen");
			}
			CoopRewardState.ClientInNativeRewardPhase = true;
			CoopRewardState.AllChoicesComplete = false;
			CoopRewardState.WaitingForOtherPlayers = false;
			CoopRewardState.PendingPostBattleRelicChoices = null;
			MultiplayerClientPatches.AllowNativeRewardLogic = true;
			MultiplayerClientPatches.ClientChosenPostBattleRelicEffect = -1;
			MultiplayerClientPatches.ClientChosenPostBattleRelicName = null;
			PostBattleController[] array = Resources.FindObjectsOfTypeAll<PostBattleController>();
			if (array == null || array.Length == 0)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)"[PostBattleStart] No PostBattleController found in scene!");
				}
				CoopRewardState.ClientInNativeRewardPhase = false;
				MultiplayerClientPatches.AllowNativeRewardLogic = false;
			}
			else
			{
				((Component)array[0]).gameObject.SetActive(true);
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)"[PostBattleStart] PostBattleController activated on client");
				}
			}
		}
	}
	public sealed class PostBattleStartServerHandler : IServerHandler<PostBattleStartEvent>
	{
		public PostBattleStartEvent Handle(PostBattleStartEvent networkEvent)
		{
			ManualLogSource logger = MultiplayerPlugin.Logger;
			if (logger != null)
			{
				logger.LogInfo((object)"[PostBattleStartServer] Broadcasting post-battle start to clients");
			}
			return networkEvent;
		}
	}
	public sealed class RelicChoiceClientHandler : IClientHandler<RelicChoiceEvent>
	{
		public void Handle(RelicChoiceEvent networkEvent)
		{
			//IL_0102: Unknown result type (might be due to invalid IL or missing references)
			//IL_010d: Invalid comparison between Unknown and I4
			//IL_011a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0121: Expected I4, but got Unknown
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[CoopReward] RelicChoice from unknown peer {num}");
					}
					return;
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[CoopReward] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}) chose relic effect {networkEvent.ChosenRelicEffect}");
				}
				if (services.TryResolve<CoopStateManager>(out var instance4))
				{
					CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
					if (playerState != null)
					{
						string locKey = string.Empty;
						int rarity = 0;
						Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
						foreach (Relic val in array)
						{
							if ((int)val.effect == networkEvent.ChosenRelicEffect)
							{
								locKey = val.locKey;
								rarity = (int)val.globalRarity;
								break;
							}
						}
						playerState.OwnedRelics.Add(new SerializedRelic
						{
							Effect = networkEvent.ChosenRelicEffect,
							LocKey = locKey,
							Rarity = rarity
						});
						ManualLogSource logger3 = MultiplayerPlugin.Logger;
						if (logger3 != null)
						{
							logger3.LogInfo((object)$"[CoopReward] Added relic {networkEvent.ChosenRelicEffect} to slot {slotByPeerId.SlotIndex} state");
						}
						ApplyRelicStatEffects(playerState, networkEvent.ChosenRelicEffect);
					}
				}
				CoopRewardState.ClientRelicChoicesReceived.Add(slotByPeerId.SlotIndex);
				if (CoopRewardState.HostHasChosenRelic && CoopRewardState.AllClientRelicChoicesReceived)
				{
					CoopRewardState.HostRelicSelectionActive = false;
					CoopRewardState.WaitingForOtherPlayers = false;
					object pendingGameInitInstance = CoopRewardState.PendingGameInitInstance;
					GameInit val2 = (GameInit)((pendingGameInitInstance is GameInit) ? pendingGameInitInstance : null);
					string text = (((Object)(object)val2 != (Object)null) ? "starting_relic" : "treasure");
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogInfo((object)("[CoopReward] All relic choices received (phase=" + text + ")"));
					}
					if (services.TryResolve<IGameEventRegistry>(out var instance5))
					{
						instance5.Dispatch(new AllChoicesCompleteEvent
						{
							Phase = text
						});
					}
					if ((Object)(object)val2 != (Object)null)
					{
						typeof(GameInit).GetMethod("LoadMapScene", BindingFlags.Instance | BindingFlags.NonPublic)?.Invoke(val2, null);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogWarning((object)("[CoopReward] RelicChoice handler failed: " + ex.Message));
				}
			}
		}

		public static void ApplyRelicStatEffectsStatic(CoopPlayerState playerState, int relicEffect, ManualLogSource log = null)
		{
			ApplyRelicStatEffects(playerState, relicEffect);
		}

		private static void ApplyRelicStatEffects(CoopPlayerState playerState, int relicEffect)
		{
			bool flag = false;
			foreach (SerializedRelic ownedRelic in playerState.OwnedRelics)
			{
				if (ownedRelic.Effect == 106)
				{
					flag = true;
					break;
				}
			}
			float num = 0f;
			switch (relicEffect)
			{
			case 23:
				num = 15f;
				break;
			case 24:
				num = 25f;
				break;
			case 74:
				num = 50f;
				break;
			case 88:
				ApplyHaglinsSatchel(playerState);
				return;
			}
			if (!(num <= 0f))
			{
				if (flag)
				{
					num += 1f;
				}
				float maxHealth = playerState.MaxHealth;
				float currentHealth = playerState.CurrentHealth;
				playerState.MaxHealth += num;
				playerState.CurrentHealth += num;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)($"[CoopReward] Relic HP effect={relicEffect}: slot {playerState.SlotIndex} " + $"MaxHP {maxHealth}->{playerState.MaxHealth}, HP {currentHealth}->{playerState.CurrentHealth}" + (flag ? " (+1 from INCREASE_MAX_HP_GAIN)" : string.Empty)));
				}
			}
		}

		private static void ApplyHaglinsSatchel(CoopPlayerState playerState)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<CoopStateManager>(out var instance))
				{
					return;
				}
				Relic val = FindRelicByEffect(88);
				if ((Object)(object)val == (Object)null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[CoopReward] Haglin's Satchel: could not find Relic asset");
					}
					playerState.Gold += 100;
					return;
				}
				int activePlayerSlot = instance.ActivePlayerSlot;
				instance.SwapToPlayer(playerState.SlotIndex);
				DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
				if (array != null && array.Length != 0)
				{
					array[0].RelicModifyDeck(val);
				}
				playerState.Gold += 100;
				instance.SaveActivePlayerState();
				if (activePlayerSlot != playerState.SlotIndex)
				{
					instance.SwapToPlayer(activePlayerSlot);
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)($"[CoopReward] Haglin's Satchel applied to slot {playerState.SlotIndex}: " + $"deck={playerState.CompleteDeck?.Count ?? 0} orbs, gold +100 (now {playerState.Gold})"));
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[CoopReward] Haglin's Satchel failed: " + ex.Message));
				}
				playerState.Gold += 100;
			}
		}

		private static Relic FindRelicByEffect(int effect)
		{
			//IL_000f: Unknown result type (might be due to invalid IL or missing references)
			//IL_0015: Invalid comparison between Unknown and I4
			Relic[] array = Resources.FindObjectsOfTypeAll<Relic>();
			foreach (Relic val in array)
			{
				if ((int)val.effect == effect)
				{
					return val;
				}
			}
			return null;
		}
	}
	public sealed class RelicChoicesClientHandler : IClientHandler<RelicChoicesEvent>
	{
		public void Handle(RelicChoicesEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || (services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting))
			{
				return;
			}
			int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(services);
			if (localSlotIndex >= 0 && networkEvent.TargetSlotIndex == localSlotIndex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopReward] Received {networkEvent.Choices?.Count ?? 0} relic choices for slot {networkEvent.TargetSlotIndex}");
				}
				CoopRewardState.PendingRelicChoices = networkEvent;
				CoopRewardState.WaitingForOtherPlayers = false;
				CoopRewardState.AllChoicesComplete = false;
			}
		}
	}
	public sealed class RelicChoiceServerHandler : IServerHandler<RelicChoiceEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("RelicChoiceServer");

		public RelicChoiceEvent Handle(RelicChoiceEvent networkEvent)
		{
			_log.LogInfo((object)$"[RelicChoiceServer] Received relic choice: effect={networkEvent.ChosenRelicEffect} — suppressing rebroadcast");
			return null;
		}
	}
	public sealed class RelicChoicesServerHandler : IServerHandler<RelicChoicesEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("RelicChoicesServer");

		public RelicChoicesEvent Handle(RelicChoicesEvent networkEvent)
		{
			_log.LogInfo((object)$"[RelicChoicesServer] Broadcasting relic choices to slot {networkEvent.TargetSlotIndex}: {networkEvent.Choices?.Count ?? 0} options");
			return networkEvent;
		}
	}
	public sealed class RewardChoiceClientHandler : IClientHandler<RewardChoiceEvent>
	{
		public void Handle(RewardChoiceEvent networkEvent)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[CoopReward] RewardChoice from unknown peer {num}");
					}
					return;
				}
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)$"[CoopReward] Player '{slotByPeerId.PlayerName}' (slot {slotByPeerId.SlotIndex}) chose reward option {networkEvent.ChosenOptionIndex}");
				}
				if (!CoopRewardState.PendingSentRewardChoices.TryGetValue(slotByPeerId.SlotIndex, out var value))
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)$"[CoopReward] No pending reward choices found for slot {slotByPeerId.SlotIndex} -- ignoring");
					}
					return;
				}
				RewardOption rewardOption = value.Options.FirstOrDefault((RewardOption o) => o.OptionIndex == networkEvent.ChosenOptionIndex);
				if (rewardOption == null)
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogWarning((object)($"[CoopReward] Invalid option index {networkEvent.ChosenOptionIndex} for slot {slotByPeerId.SlotIndex} " + "(available: " + string.Join(", ", value.Options.Select((RewardOption o) => o.OptionIndex)) + ")"));
					}
					return;
				}
				if (!services.TryResolve<CoopStateManager>(out var instance4))
				{
					ManualLogSource logger5 = MultiplayerPlugin.Logger;
					if (logger5 != null)
					{
						logger5.LogWarning((object)"[CoopReward] CoopStateManager not available -- cannot apply reward");
					}
					return;
				}
				CoopPlayerState playerState = instance4.GetPlayerState(slotByPeerId.SlotIndex);
				if (playerState == null)
				{
					ManualLogSource logger6 = MultiplayerPlugin.Logger;
					if (logger6 != null)
					{
						logger6.LogWarning((object)$"[CoopReward] No CoopPlayerState for slot {slotByPeerId.SlotIndex} -- cannot apply reward");
					}
					return;
				}
				ApplyReward(playerState, rewardOption, slotByPeerId.SlotIndex);
				CoopRewardState.ClientRewardChoicesReceived.Add(slotByPeerId.SlotIndex);
				ManualLogSource logger7 = MultiplayerPlugin.Logger;
				if (logger7 != null)
				{
					logger7.LogInfo((object)$"[CoopReward] Reward choices received: {CoopRewardState.ClientRewardChoicesReceived.Count}/{CoopRewardState.TotalRewardClientsExpected}");
				}
				if (CoopRewardState.AllClientRewardChoicesReceived)
				{
					ManualLogSource logger8 = MultiplayerPlugin.Logger;
					if (logger8 != null)
					{
						logger8.LogInfo((object)"[CoopReward] All post-battle reward choices received");
					}
					CoopRewardState.PendingSentRewardChoices.Clear();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger9 = MultiplayerPlugin.Logger;
				if (logger9 != null)
				{
					logger9.LogWarning((object)("[CoopReward] RewardChoice handler failed: " + ex.Message));
				}
			}
		}

		private static void ApplyReward(CoopPlayerState playerState, RewardOption option, int slotIndex)
		{
			switch (option.Type)
			{
			case "heal":
			{
				float currentHealth2 = playerState.CurrentHealth;
				float maxHealth2 = playerState.MaxHealth;
				playerState.CurrentHealth = Math.Min(playerState.CurrentHealth + 20f, maxHealth2);
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogInfo((object)$"[CoopReward] Slot {slotIndex} heal: HP {currentHealth2} -> {playerState.CurrentHealth} (max {maxHealth2})");
				}
				break;
			}
			case "max_hp":
			{
				float maxHealth = playerState.MaxHealth;
				float currentHealth = playerState.CurrentHealth;
				playerState.MaxHealth += 5f;
				playerState.CurrentHealth += 5f;
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)($"[CoopReward] Slot {slotIndex} max_hp: MaxHP {maxHealth} -> {playerState.MaxHealth}, " + $"HP {currentHealth} -> {playerState.CurrentHealth}"));
				}
				break;
			}
			case "skip":
			{
				int gold = playerState.Gold;
				int num = ((option.GoldReward > 0) ? option.GoldReward : 10);
				playerState.Gold += num;
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogInfo((object)$"[CoopReward] Slot {slotIndex} skip: Gold {gold} -> {playerState.Gold} (+{num})");
				}
				break;
			}
			default:
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"[CoopReward] Slot {slotIndex} unknown reward type '{option.Type}' -- not applied");
				}
				break;
			}
			}
		}
	}
	public sealed class RewardChoicesClientHandler : IClientHandler<RewardChoicesEvent>
	{
		public void Handle(RewardChoicesEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || (services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting))
			{
				return;
			}
			int localSlotIndex = CoopSlotHelper.GetLocalSlotIndex(services);
			if (localSlotIndex >= 0 && networkEvent.TargetSlotIndex == localSlotIndex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)$"[CoopReward] Received {networkEvent.Options?.Count ?? 0} reward options for slot {networkEvent.TargetSlotIndex}");
				}
				CoopRewardState.PendingRewardChoices = networkEvent;
				CoopRewardState.WaitingForOtherPlayers = false;
				CoopRewardState.AllChoicesComplete = false;
			}
		}
	}
	public sealed class RewardChoiceServerHandler : IServerHandler<RewardChoiceEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("RewardChoiceServer");

		public RewardChoiceEvent Handle(RewardChoiceEvent networkEvent)
		{
			_log.LogInfo((object)$"[RewardChoiceServer] Received reward choice: optionIndex={networkEvent.ChosenOptionIndex} — suppressing rebroadcast");
			return null;
		}
	}
	public sealed class RewardChoicesServerHandler : IServerHandler<RewardChoicesEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("RewardChoicesServer");

		public RewardChoicesEvent Handle(RewardChoicesEvent networkEvent)
		{
			_log.LogInfo((object)$"[RewardChoicesServer] Broadcasting reward choices to slot {networkEvent.TargetSlotIndex}: {networkEvent.Options?.Count ?? 0} options");
			return networkEvent;
		}
	}
	public sealed class RunStatsSnapshotClientHandler : IClientHandler<RunStatsSnapshotEvent>
	{
		public static List<PerPlayerStats> LatestPerPlayerStats { get; set; } = new List<PerPlayerStats>();


		public void Handle(RunStatsSnapshotEvent e)
		{
			//IL_0070: Unknown result type (might be due to invalid IL or missing references)
			//IL_0033: Unknown result type (might be due to invalid IL or missing references)
			//IL_04c3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0346: Unknown result type (might be due to invalid IL or missing references)
			//IL_034b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0358: Unknown result type (might be due to invalid IL or missing references)
			//IL_0365: Unknown result type (might be due to invalid IL or missing references)
			//IL_0372: Unknown result type (might be due to invalid IL or missing references)
			//IL_037f: Unknown result type (might be due to invalid IL or missing references)
			//IL_038c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0399: Unknown result type (might be due to invalid IL or missing references)
			//IL_03a6: Unknown result type (might be due to invalid IL or missing references)
			//IL_03b3: Unknown result type (might be due to invalid IL or missing references)
			//IL_0434: Unknown result type (might be due to invalid IL or missing references)
			//IL_0439: Unknown result type (might be due to invalid IL or missing references)
			//IL_0446: Unknown result type (might be due to invalid IL or missing references)
			//IL_0453: Unknown result type (might be due to invalid IL or missing references)
			//IL_0460: Unknown result type (might be due to invalid IL or missing references)
			//IL_046d: Unknown result type (might be due to invalid IL or missing references)
			//IL_047f: Expected O, but got Unknown
			//IL_03cf: Expected O, but got Unknown
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || multiplayerMode.IsHosting)
				{
					return;
				}
				RunStats val = (RunStats)(((object)StaticGameData.CurrentRunStats) ?? ((object)new RunStats()));
				val.hasWon = e.HasWon;
				val.hasWonCore = e.HasWonCore;
				val.isCustomRun = e.IsCustomRun;
				val.vampireDealTaken = e.VampireDealTaken;
				val.selectedClass = (Class)e.SelectedClass;
				val.cruciballLevel = e.CruciballLevel;
				val.seed = e.Seed ?? string.Empty;
				val.finalHp = e.FinalHp;
				val.maxHp = e.MaxHp;
				val.totalDamageDealt = e.TotalDamageDealt;
				val.coinsEarned = e.CoinsEarned;
				val.pegsHit = e.PegsHit;
				val.pegsHitRefresh = e.PegsHitRefresh;
				val.pegsHitCrit = e.PegsHitCrit;
				val.bombsThrown = e.BombsThrown;
				val.bombsThrownRigged = e.BombsThrownRigged;
				val.runTimerElapsedMilliseconds = e.RunTimerElapsedMs;
				if (DateTime.TryParse(e.EndDateIso, out var result))
				{
					val.endDate = result;
				}
				try
				{
					val.runTimerSw.Reset();
				}
				catch
				{
				}
				val.visitedRooms = new Queue<RoomType>();
				if (e.VisitedRooms != null)
				{
					foreach (int visitedRoom in e.VisitedRooms)
					{
						val.visitedRooms.Enqueue((RoomType)visitedRoom);
					}
				}
				val.visitedBosses = new Queue<BossType>();
				if (e.VisitedBosses != null)
				{
					foreach (int visitedBoss in e.VisitedBosses)
					{
						val.visitedBosses.Enqueue((BossType)visitedBoss);
					}
				}
				val.relics = (e.Relics ?? new List<int>()).ConvertAll((int r) => (RelicEffect)r);
				val.challenges = (e.Challenges ?? new List<int>()).ConvertAll((int c) => (ChallengeEffect)c);
				val.stacksPerStatusEffect = new Dictionary<StatusEffectType, int>();
				if (e.StatusEffectStacks != null)
				{
					for (int i = 0; i < e.StatusEffectStacks.Count; i++)
					{
						if (e.StatusEffectStacks[i] > 0)
						{
							val.stacksPerStatusEffect[(StatusEffectType)i] = e.StatusEffectStacks[i];
						}
					}
				}
				val.slimePegsPerSlimeType = new Dictionary<SlimeType, int>();
				if (e.SlimePegCounts != null)
				{
					for (int j = 0; j < e.SlimePegCounts.Count; j++)
					{
						if (e.SlimePegCounts[j] > 0)
						{
							val.slimePegsPerSlimeType[(SlimeType)j] = e.SlimePegCounts[j];
						}
					}
				}
				val.orbStats = new Dictionary<string, OrbPlayData>();
				if (e.Orbs != null)
				{
					foreach (OrbStatsEntry orb in e.Orbs)
					{
						if (!string.IsNullOrEmpty(orb.Id))
						{
							val.orbStats[orb.Id] = new OrbPlayData
							{
								id = orb.Id,
								name = orb.Name,
								damageDealt = orb.DamageDealt,
								timesFired = orb.TimesFired,
								timesDiscarded = orb.TimesDiscarded,
								timesRemoved = orb.TimesRemoved,
								starting = orb.Starting,
								amountInDeck = orb.AmountInDeck,
								levelInstances = (orb.LevelInstances ?? new int[3])
							};
						}
					}
				}
				val.enemyData = new Dictionary<string, EnemyPlayData>();
				if (e.Enemies != null)
				{
					foreach (EnemyStatsEntry enemy in e.Enemies)
					{
						if (!string.IsNullOrEmpty(enemy.Name))
						{
							val.enemyData[enemy.Name] = new EnemyPlayData
							{
								name = enemy.Name,
								amountFought = enemy.AmountFought,
								meleeDamageReceived = enemy.MeleeDamageReceived,
								rangedDamageReceived = enemy.RangedDamageReceived,
								defeatedBy = enemy.DefeatedBy
							};
						}
					}
				}
				StaticGameData.CurrentRunStats = val;
				LatestPerPlayerStats = e.Players ?? new List<PerPlayerStats>();
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)($"[RunStatsSync] Applied snapshot: class={val.selectedClass}, won={val.hasWon}, " + $"dmg={val.totalDamageDealt}, pegs={val.pegsHit}, players={LatestPerPlayerStats.Count}"));
				}
				RunSummary val2 = Object.FindObjectOfType<RunSummary>();
				if (!((Object)(object)val2 != (Object)null))
				{
					return;
				}
				object? obj2 = AccessTools.Field(typeof(RunSummary), "runStatisticDetails")?.GetValue(val2);
				RunStatisticsDetails val3 = (RunStatisticsDetails)((obj2 is RunStatisticsDetails) ? obj2 : null);
				if (!((Object)(object)val3 != (Object)null))
				{
					return;
				}
				try
				{
					val3.Initialize(val);
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)"[RunStatsSync] Re-initialized RunStatisticsDetails");
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)("[RunStatsSync] Re-init failed: " + ex.Message));
					}
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("[RunStatsSync] Handler failed: " + ex2.Message));
				}
			}
		}
	}
	public sealed class RunStatsSnapshotServerHandler : IServerHandler<RunStatsSnapshotEvent>
	{
		public RunStatsSnapshotEvent Handle(RunStatsSnapshotEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class ShootRequestClientHandler : IClientHandler<ShootRequestEvent>
	{
		public static PendingShot LatestPendingShot { get; private set; }

		public void Handle(ShootRequestEvent networkEvent)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting || !services.TryResolve<TurnManager>(out var instance2) || !services.TryResolve<PlayerRegistry>(out var instance3) || !services.TryResolve<IGameEventRegistry>(out var instance4))
			{
				return;
			}
			int num = (instance4 as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
			PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
			if (slotByPeerId == null)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)$"[ShootRequest] No slot for peer {num}");
				}
				return;
			}
			if (!instance2.IsSlotsTurn(slotByPeerId.SlotIndex))
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)($"[ShootRequest] Rejected shot from slot {slotByPeerId.SlotIndex} ({slotByPeerId.PlayerName}): " + $"not their turn (current: slot {instance2.CurrentPlayerSlot}, phase: {instance2.Phase})"));
				}
				return;
			}
			LatestPendingShot = new PendingShot
			{
				SlotIndex = slotByPeerId.SlotIndex,
				PlayerName = slotByPeerId.PlayerName,
				AimDirectionX = networkEvent.AimDirectionX,
				AimDirectionY = networkEvent.AimDirectionY,
				TargetEnemyGuid = networkEvent.TargetEnemyGuid
			};
			ManualLogSource logger3 = MultiplayerPlugin.Logger;
			if (logger3 != null)
			{
				logger3.LogInfo((object)($"[ShootRequest] Accepted shot from slot {slotByPeerId.SlotIndex} ({slotByPeerId.PlayerName}): " + $"dir=({networkEvent.AimDirectionX:F3}, {networkEvent.AimDirectionY:F3})"));
			}
		}

		public static PendingShot PeekPendingShot()
		{
			return LatestPendingShot;
		}

		public static PendingShot ConsumePendingShot()
		{
			PendingShot latestPendingShot = LatestPendingShot;
			LatestPendingShot = null;
			return latestPendingShot;
		}
	}
	public class PendingShot
	{
		public int SlotIndex { get; set; }

		public string PlayerName { get; set; }

		public float AimDirectionX { get; set; }

		public float AimDirectionY { get; set; }

		public string TargetEnemyGuid { get; set; }
	}
	public sealed class ShootRequestServerHandler : IServerHandler<ShootRequestEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("ShootRequestServer");

		public ShootRequestEvent Handle(ShootRequestEvent networkEvent)
		{
			_log.LogInfo((object)$"[ShootRequestServer] Received shoot request: aim=({networkEvent.AimDirectionX:F2},{networkEvent.AimDirectionY:F2}) — suppressing rebroadcast");
			return null;
		}
	}
	public sealed class SkipTurnRequestClientHandler : IClientHandler<SkipTurnRequestEvent>
	{
		public void Handle(SkipTurnRequestEvent networkEvent)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				IGameEventRegistry instance2;
				int num = ((services.TryResolve<IGameEventRegistry>(out instance2) ? instance2 : null) as GameEventRegistry)?.CurrentSenderPeerId ?? (-1);
				if (!services.TryResolve<PlayerRegistry>(out var instance3))
				{
					return;
				}
				PlayerSlot slotByPeerId = instance3.GetSlotByPeerId(num);
				if (slotByPeerId == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[SkipTurn] From unknown peer {num}");
					}
					return;
				}
				CoopSubscriptions instance4 = CoopSubscriptions.Instance;
				if (instance4 == null)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)"[SkipTurn] CoopSubscriptions.Instance null — cannot skip");
					}
				}
				else
				{
					instance4.SkipCurrentTurn(slotByPeerId.SlotIndex, $"client slot {slotByPeerId.SlotIndex}");
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger3 = MultiplayerPlugin.Logger;
				if (logger3 != null)
				{
					logger3.LogWarning((object)("[SkipTurn] Handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class SkipTurnRequestServerHandler : IServerHandler<SkipTurnRequestEvent>
	{
		public SkipTurnRequestEvent Handle(SkipTurnRequestEvent networkEvent)
		{
			return null;
		}
	}
	public sealed class SlotConfigClientHandler : IClientHandler<SlotConfigEvent>
	{
		public void Handle(SlotConfigEvent networkEvent)
		{
			//IL_003a: Unknown result type (might be due to invalid IL or missing references)
			//IL_003f: Unknown result type (might be due to invalid IL or missing references)
			//IL_007b: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				SpecialSlotController val = Object.FindObjectOfType<SpecialSlotController>();
				if ((Object)(object)val == (Object)null || val.slotTriggers == null)
				{
					return;
				}
				SlotTrigger[] slotTriggers = val.slotTriggers;
				float[] multipliers = networkEvent.Multipliers;
				bool[] portalsOn = networkEvent.PortalsOn;
				bool[] flamesOn = networkEvent.FlamesOn;
				Color bottomPortalColor = val.bottomPortalColor;
				for (int i = 0; i < slotTriggers.Length; i++)
				{
					SlotTrigger val2 = slotTriggers[i];
					if (!((Object)(object)val2 == (Object)null))
					{
						if (multipliers != null && i < multipliers.Length)
						{
							val2.multiplier = multipliers[i];
						}
						if (portalsOn != null && i < portalsOn.Length)
						{
							val2.TogglePortal(portalsOn[i], bottomPortalColor);
						}
						if (flamesOn != null && i < flamesOn.Length)
						{
							val2.SetSlotFlame(flamesOn[i]);
						}
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[SlotConfig] apply failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class SlotConfigServerHandler : IServerHandler<SlotConfigEvent>
	{
		public SlotConfigEvent Handle(SlotConfigEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class TargetSelectClientHandler : IClientHandler<TargetSelectEvent>
	{
		private static Enemy _currentClientTarget;

		public static string CurrentClientTargetGuid { get; private set; }

		public void Handle(TargetSelectEvent networkEvent)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsHosting)
				{
					return;
				}
				if ((Object)(object)_currentClientTarget != (Object)null)
				{
					try
					{
						_currentClientTarget.ToggleTargetedUI(false);
					}
					catch
					{
					}
					_currentClientTarget = null;
				}
				CurrentClientTargetGuid = networkEvent.TargetEnemyGuid;
				if (string.IsNullOrEmpty(networkEvent.TargetEnemyGuid))
				{
					return;
				}
				IServiceContainer services2 = MultiplayerPlugin.Services;
				EnemyIdentifier instance2;
				EnemyIdentifier enemyIdentifier = ((services2 != null && services2.TryResolve<EnemyIdentifier>(out instance2)) ? instance2 : null);
				if (enemyIdentifier != null)
				{
					Enemy val = enemyIdentifier.Find(networkEvent.TargetEnemyGuid);
					if (!((Object)(object)val == (Object)null) && !(val.CurrentHealth <= 0f))
					{
						val.ToggleTargetedUI(true);
						_currentClientTarget = val;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[TargetSelect] Handler failed: " + ex.Message));
				}
			}
		}

		public static void ClearClientTarget()
		{
			if ((Object)(object)_currentClientTarget != (Object)null)
			{
				try
				{
					_currentClientTarget.ToggleTargetedUI(false);
				}
				catch
				{
				}
				_currentClientTarget = null;
			}
			CurrentClientTargetGuid = null;
		}
	}
	public sealed class TargetSelectServerHandler : IServerHandler<TargetSelectEvent>
	{
		public TargetSelectEvent Handle(TargetSelectEvent networkEvent)
		{
			return null;
		}
	}
	public sealed class TurnChangeClientHandler : IClientHandler<TurnChangeEvent>
	{
		public static TurnChangeEvent LatestTurnState { get; internal set; }

		public static bool IsMyTurn { get; internal set; }

		public static string TurnMessage { get; internal set; } = string.Empty;


		public void Handle(TurnChangeEvent networkEvent)
		{
			LatestTurnState = networkEvent;
			IServiceContainer services = MultiplayerPlugin.Services;
			int num = -1;
			if (services != null && services.TryResolve<PlayerRegistry>(out var instance) && services.TryResolve<INetworkTransport>(out var instance2))
			{
				if (instance2.IsHost)
				{
					num = 0;
				}
				else if (instance.LocalSlot != null)
				{
					num = instance.LocalSlot.SlotIndex;
				}
			}
			IsMyTurn = num >= 0 && networkEvent.ActiveSlotIndex == num && networkEvent.TurnPhase == "PLAYER_AIMING";
			MultiplayerClientPatches.ClientShotSentThisTurn = false;
			MultiplayerClientPatches._clientPendingOrbName = null;
			ClientAimRenderer.Instance?.HideAim();
			EnableClientTargeting(IsMyTurn);
			TargetSelectClientHandler.ClearClientTarget();
			try
			{
				BattleController val = Object.FindObjectOfType<BattleController>();
				if ((Object)(object)val != (Object)null)
				{
					val.NumShotsDiscarded = 0;
				}
				OrbDiscardButton val2 = Object.FindObjectOfType<OrbDiscardButton>();
				if ((Object)(object)val2 != (Object)null)
				{
					AccessTools.Method(typeof(OrbDiscardButton), "UpdateDiscardCount", (Type[])null, (Type[])null)?.Invoke(val2, null);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[TurnChange] Discard UI refresh failed: " + ex.Message));
				}
			}
			if (IsMyTurn)
			{
				TurnMessage = "Your turn! Aim and shoot.";
			}
			else if (networkEvent.TurnPhase == "PLAYER_AIMING")
			{
				TurnMessage = "Waiting for " + networkEvent.ActivePlayerName + "...";
			}
			else if (networkEvent.TurnPhase == "SHOT_IN_FLIGHT")
			{
				TurnMessage = networkEvent.ActivePlayerName + "'s shot in flight...";
			}
			else if (networkEvent.TurnPhase == "ALL_DONE" || networkEvent.TurnPhase == "DAMAGE_PHASE")
			{
				TurnMessage = string.Empty;
			}
			else
			{
				TurnMessage = string.Empty;
			}
			ManualLogSource logger2 = MultiplayerPlugin.Logger;
			if (logger2 != null)
			{
				logger2.LogInfo((object)($"[TurnChange] Slot {networkEvent.ActiveSlotIndex} ({networkEvent.ActivePlayerName}), " + $"phase={networkEvent.TurnPhase}, round={networkEvent.RoundNumber}, isMyTurn={IsMyTurn}"));
			}
		}

		private static void EnableClientTargeting(bool enable)
		{
			try
			{
				TargetingManager val = Object.FindObjectOfType<TargetingManager>();
				if (!((Object)(object)val == (Object)null))
				{
					if (enable)
					{
						val.SetTargetingStatus(true, (TargetingType)2);
						val.AutoSelect();
					}
					else
					{
						val.SetTargetingStatus(false, (TargetingType)0);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[TurnChange] EnableClientTargeting failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class TurnChangeServerHandler : IServerHandler<TurnChangeEvent>
	{
		private static readonly ManualLogSource _log = Logger.CreateLogSource("TurnChangeServer");

		public TurnChangeEvent Handle(TurnChangeEvent networkEvent)
		{
			_log.LogInfo((object)$"[TurnChangeServer] Broadcasting turn change: slot={networkEvent.ActiveSlotIndex}, player={networkEvent.ActivePlayerName}, phase={networkEvent.TurnPhase}, round={networkEvent.RoundNumber}");
			if (networkEvent.ActiveSlotIndex > 0 && networkEvent.TurnPhase == "PLAYER_AIMING")
			{
				try
				{
					BattleController obj = Object.FindObjectOfType<BattleController>();
					if (obj != null)
					{
						PredictionManager predictionManager = obj.PredictionManager;
						if (predictionManager != null)
						{
							predictionManager.PlayerFired();
						}
					}
				}
				catch (Exception ex)
				{
					_log.LogWarning((object)("[TurnChangeServer] Failed to hide prediction: " + ex.Message));
				}
			}
			ClientAimRenderer.Instance?.HideAim();
			TurnChangeClientHandler.LatestTurnState = networkEvent;
			if (TurnChangeClientHandler.IsMyTurn = networkEvent.ActiveSlotIndex == 0 && networkEvent.TurnPhase == "PLAYER_AIMING")
			{
				TurnChangeClientHandler.TurnMessage = "Your turn! Aim and shoot.";
			}
			else if (networkEvent.TurnPhase == "PLAYER_AIMING")
			{
				TurnChangeClientHandler.TurnMessage = "Waiting for " + networkEvent.ActivePlayerName + "...";
			}
			else if (networkEvent.TurnPhase == "SHOT_IN_FLIGHT")
			{
				TurnChangeClientHandler.TurnMessage = networkEvent.ActivePlayerName + "'s shot in flight...";
			}
			else if (networkEvent.TurnPhase == "ALL_DONE")
			{
				TurnChangeClientHandler.TurnMessage = "All players have shot.";
			}
			else if (networkEvent.TurnPhase == "DAMAGE_PHASE")
			{
				TurnChangeClientHandler.TurnMessage = "Enemies attacking...";
			}
			else
			{
				TurnChangeClientHandler.TurnMessage = string.Empty;
			}
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.Battle
{
	public sealed class AnimationSyncClientHandler : IClientHandler<AnimationSyncEvent>
	{
		public void Handle(AnimationSyncEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode == null || !multiplayerMode.IsSpectating)
				{
					return;
				}
				Animator val = null;
				IServiceContainer services2 = MultiplayerPlugin.Services;
				EnemyIdentifier instance2;
				Enemy val2 = ((services2 != null && services2.TryResolve<EnemyIdentifier>(out instance2)) ? instance2 : null)?.Find(e.EntityGuid);
				if ((Object)(object)val2 != (Object)null)
				{
					val = ((Component)val2).GetComponentInChildren<Animator>();
				}
				else
				{
					IServiceContainer services3 = MultiplayerPlugin.Services;
					PegIdentifier instance3;
					Peg val3 = ((services3 != null && services3.TryResolve<PegIdentifier>(out instance3)) ? instance3 : null)?.Find(e.EntityGuid);
					if ((Object)(object)val3 != (Object)null)
					{
						val = ((Component)val3).GetComponentInChildren<Animator>();
					}
				}
				if (!((Object)(object)val == (Object)null))
				{
					switch (e.ParamType)
					{
					case "trigger":
						val.SetTrigger(e.ParamName);
						break;
					case "bool":
						val.SetBool(e.ParamName, e.Value != 0);
						break;
					case "integer":
						val.SetInteger(e.ParamName, e.Value);
						break;
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("AnimationSync handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class AnimationSyncServerHandler : IServerHandler<AnimationSyncEvent>
	{
		public AnimationSyncEvent Handle(AnimationSyncEvent e)
		{
			return e;
		}
	}
	public sealed class AttackStartedClientHandler : IClientHandler<AttackStartedEvent>
	{
		[CompilerGenerated]
		private sealed class <Playback>d__4 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private float <waited>5__2;

			private ClientAttackProjectile <cap>5__3;

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

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

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

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

			private bool MoveNext()
			{
				//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
				//IL_00af: Expected O, but got Unknown
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					goto IL_00c6;
				case 1:
					<>1__state = -1;
					goto IL_0077;
				case 2:
					{
						<>1__state = -1;
						<cap>5__3 = null;
						goto IL_00c6;
					}
					IL_00c6:
					if (_queue.Count > 0)
					{
						PlayOneImmediate(_queue.Dequeue());
						<waited>5__2 = 0f;
						<cap>5__3 = ClientAttackProjectile.Instance;
						goto IL_0077;
					}
					_playbackRunning = false;
					return false;
					IL_0077:
					if ((Object)(object)<cap>5__3 != (Object)null && <cap>5__3.IsAttacking && <waited>5__2 < 2f)
					{
						<waited>5__2 += Time.deltaTime;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					<>2__current = (object)new WaitForSeconds(0.3f);
					<>1__state = 2;
					return true;
				}
			}

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

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

		private static readonly Queue<AttackStartedEvent> _queue = new Queue<AttackStartedEvent>();

		private static bool _playbackRunning;

		public void Handle(AttackStartedEvent e)
		{
			try
			{
				_queue.Enqueue(e);
				StartPlaybackIfNeeded();
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("AttackStarted handler failed: " + ex.Message));
				}
			}
		}

		private static void StartPlaybackIfNeeded()
		{
			if (_playbackRunning)
			{
				return;
			}
			ClientAttackProjectile instance = ClientAttackProjectile.Instance;
			if ((Object)(object)instance == (Object)null)
			{
				if (_queue.Count > 0)
				{
					PlayOneImmediate(_queue.Dequeue());
				}
			}
			else
			{
				_playbackRunning = true;
				((MonoBehaviour)instance).StartCoroutine(Playback());
			}
		}

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

		private static void PlayOneImmediate(AttackStartedEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				BattleController.OnAttackStarted?.Invoke();
				if (multiplayerMode != null && multiplayerMode.IsSpectating && !string.IsNullOrEmpty(e.AnimTrigger))
				{
					AttackPerformed onAttackPerformed = AttackManager.OnAttackPerformed;
					if (onAttackPerformed != null)
					{
						onAttackPerformed.Invoke(e.AnimTrigger);
					}
					ClientAttackProjectile.Instance?.SetupAttack(e.TargetEnemyGuid, e.NumPegsHit, e.IsCrit, e.OrbName);
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)($"[AttackStarted] slot={e.SlotIndex} anim='{e.AnimTrigger}' target={e.TargetEnemyGuid} " + $"pegs={e.NumPegsHit} crit={e.IsCrit} orb={e.OrbName}"));
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("AttackStarted playback failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class AttackStartedServerHandler : IServerHandler<AttackStartedEvent>
	{
		public AttackStartedEvent Handle(AttackStartedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class AwaitingShotClientHandler : IClientHandler<AwaitingShotEvent>
	{
		public void Handle(AwaitingShotEvent networkEvent)
		{
			try
			{
				BattleEvent onStartedAwaitingShot = BattleController.OnStartedAwaitingShot;
				if (onStartedAwaitingShot != null)
				{
					onStartedAwaitingShot.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("AwaitingShot handler failed: " + ex.Message));
			}
		}
	}
	public sealed class AwaitingShotServerHandler : IServerHandler<AwaitingShotEvent>
	{
		public AwaitingShotEvent Handle(AwaitingShotEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class BattleEndedClientHandler : IClientHandler<BattleEndedEvent>
	{
		public void Handle(BattleEndedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)"[BattleEnded] Clearing enemy GUID registry");
				IServiceContainer services = MultiplayerPlugin.Services;
				((services != null && services.TryResolve<EnemyIdentifier>(out var instance)) ? instance : null)?.Clear();
				BattleEvent onBattleEnded = BattleController.OnBattleEnded;
				if (onBattleEnded != null)
				{
					onBattleEnded.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("BattleEnded handler failed: " + ex.Message));
			}
		}
	}
	public sealed class BattleEndedServerHandler : IServerHandler<BattleEndedEvent>
	{
		public BattleEndedEvent Handle(BattleEndedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class BattleStartedClientHandler : IClientHandler<BattleStartedEvent>
	{
		public void Handle(BattleStartedEvent networkEvent)
		{
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)"[BattleStarted] Clearing enemy GUID registry for new battle");
				IServiceContainer services = MultiplayerPlugin.Services;
				((services != null && services.TryResolve<EnemyIdentifier>(out var instance)) ? instance : null)?.Clear();
				MapStateApplier.ResetNavigationState();
				BattleEvent onBattleStarted = BattleController.OnBattleStarted;
				if (onBattleStarted != null)
				{
					onBattleStarted.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("BattleStarted handler failed: " + ex.Message));
			}
		}
	}
	public sealed class BattleStartedServerHandler : IServerHandler<BattleStartedEvent>
	{
		public BattleStartedEvent Handle(BattleStartedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class BombDetonatedClientHandler : IClientHandler<BombDetonatedEvent>
	{
		public void Handle(BombDetonatedEvent networkEvent)
		{
			try
			{
				BattleController.OnBombDetonated?.Invoke();
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("BombDetonated handler failed: " + ex.Message));
			}
		}
	}
	public sealed class BombDetonatedServerHandler : IServerHandler<BombDetonatedEvent>
	{
		public BombDetonatedEvent Handle(BombDetonatedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class BombThrownClientHandler : IClientHandler<BombThrownEvent>
	{
		[CompilerGenerated]
		private sealed class <>c__DisplayClass5_0
		{
			public bool lobPointReached;

			internal void <SpawnBombsAfterLobAnimation>b__0()
			{
				lobPointReached = true;
			}
		}

		[CompilerGenerated]
		private sealed class <SpawnBombsAfterLobAnimation>d__5 : IEnumerator<object>, IEnumerator, IDisposable
		{
			private int <>1__state;

			private object <>2__current;

			private <>c__DisplayClass5_0 <>8__1;

			public int riggedCount;

			public int regularCount;

			private LobPoint <lobCallback>5__2;

			private float <timeout>5__3;

			private float <elapsed>5__4;

			private GameObject <bombPrefab>5__5;

			private GameObject <riggedPrefab>5__6;

			private Vector3 <spawnPos>5__7;

			private WaitForSeconds <wait>5__8;

			private int <i>5__9;

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

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

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

			[DebuggerHidden]
			void IDisposable.Dispose()
			{
				<>8__1 = null;
				<lobCallback>5__2 = null;
				<bombPrefab>5__5 = null;
				<riggedPrefab>5__6 = null;
				<wait>5__8 = null;
				<>1__state = -2;
			}

			private bool MoveNext()
			{
				//IL_004a: Unknown result type (might be due to invalid IL or missing references)
				//IL_0054: Expected O, but got Unknown
				//IL_0064: Unknown result type (might be due to invalid IL or missing references)
				//IL_006e: Expected O, but got Unknown
				//IL_00da: Unknown result type (might be due to invalid IL or missing references)
				//IL_00e4: Expected O, but got Unknown
				//IL_0224: Unknown result type (might be due to invalid IL or missing references)
				//IL_01c1: Unknown result type (might be due to invalid IL or missing references)
				//IL_0166: Unknown result type (might be due to invalid IL or missing references)
				//IL_0154: Unknown result type (might be due to invalid IL or missing references)
				//IL_016b: Unknown result type (might be due to invalid IL or missing references)
				//IL_0187: Unknown result type (might be due to invalid IL or missing references)
				//IL_018c: Unknown result type (might be due to invalid IL or missing references)
				//IL_018d: Unknown result type (might be due to invalid IL or missing references)
				//IL_0192: Unknown result type (might be due to invalid IL or missing references)
				//IL_019d: Unknown result type (might be due to invalid IL or missing references)
				//IL_01a7: Expected O, but got Unknown
				BattleController val;
				ref GameObject reference;
				object? obj;
				ref GameObject reference2;
				object? obj2;
				object? obj3;
				Transform val2;
				Vector3 val3;
				switch (<>1__state)
				{
				default:
					return false;
				case 0:
					<>1__state = -1;
					<>8__1 = new <>c__DisplayClass5_0();
					<>8__1.lobPointReached = false;
					<lobCallback>5__2 = (LobPoint)delegate
					{
						<>8__1.lobPointReached = true;
					};
					PeglinBattleAnimationController.OnLobPoint = (LobPoint)Delegate.Combine((Delegate?)(object)PeglinBattleAnimationController.OnLobPoint, (Delegate?)(object)<lobCallback>5__2);
					<timeout>5__3 = 1.5f;
					<elapsed>5__4 = 0f;
					goto IL_00af;
				case 1:
					<>1__state = -1;
					goto IL_00af;
				case 2:
					<>1__state = -1;
					<i>5__9++;
					goto IL_0206;
				case 3:
					{
						<>1__state = -1;
						<i>5__9++;
						break;
					}
					IL_00af:
					if (!<>8__1.lobPointReached && <elapsed>5__4 < <timeout>5__3)
					{
						<elapsed>5__4 += Time.deltaTime;
						<>2__current = null;
						<>1__state = 1;
						return true;
					}
					PeglinBattleAnimationController.OnLobPoint = (LobPoint)Delegate.Remove((Delegate?)(object)PeglinBattleAnimationController.OnLobPoint, (Delegate?)(object)<lobCallback>5__2);
					val = Object.FindObjectOfType<BattleController>();
					if ((Object)(object)val == (Object)null)
					{
						return false;
					}
					reference = ref <bombPrefab>5__5;
					obj = _bombPrefabField?.GetValue(val);
					reference = (GameObject)((obj is GameObject) ? obj : null);
					reference2 = ref <riggedPrefab>5__6;
					obj2 = _riggedBombPrefabField?.GetValue(val);
					reference2 = (GameObject)((obj2 is GameObject) ? obj2 : null);
					obj3 = _playerTransformField?.GetValue(val);
					val2 = (Transform)((obj3 is Transform) ? obj3 : null);
					val3 = (Vector3)((_playerOffsetField != null) ? ((Vector3)_playerOffsetField.GetValue(val)) : Vector3.zero);
					if ((Object)(object)val2 == (Object)null || (Object)(object)<bombPrefab>5__5 == (Object)null)
					{
						return false;
					}
					<spawnPos>5__7 = val2.position + val3;
					<wait>5__8 = new WaitForSeconds(0.02f);
					<i>5__9 = 0;
					goto IL_0206;
					IL_0206:
					if (<i>5__9 < riggedCount)
					{
						SpawnVisualBomb(<riggedPrefab>5__6 ?? <bombPrefab>5__5, <spawnPos>5__7, riggedCount + regularCount);
						<>2__current = <wait>5__8;
						<>1__state = 2;
						return true;
					}
					<i>5__9 = 0;
					break;
				}
				if (<i>5__9 < regularCount)
				{
					SpawnVisualBomb(<bombPrefab>5__5, <spawnPos>5__7, riggedCount + regularCount);
					<>2__current = <wait>5__8;
					<>1__state = 3;
					return true;
				}
				return false;
			}

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

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

		private static readonly FieldInfo _bombPrefabField = AccessTools.Field(typeof(BattleController), "_tossableBombPrefab");

		private static readonly FieldInfo _riggedBombPrefabField = AccessTools.Field(typeof(BattleController), "_tossableRiggedBombPrefab");

		private static readonly FieldInfo _playerTransformField = AccessTools.Field(typeof(BattleController), "_playerTransform");

		private static readonly FieldInfo _playerOffsetField = AccessTools.Field(typeof(BattleController), "_playerTransformOffset");

		public void Handle(BombThrownEvent networkEvent)
		{
			try
			{
				BattleController.OnBombThrown?.Invoke();
				if (networkEvent.RegularCount + networkEvent.RiggedCount > 0)
				{
					MainThreadDispatcher instance = MainThreadDispatcher.Instance;
					if (instance != null)
					{
						((MonoBehaviour)instance).StartCoroutine(SpawnBombsAfterLobAnimation(networkEvent.RegularCount, networkEvent.RiggedCount));
					}
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("BombThrown handler failed: " + ex.Message));
			}
		}

		[IteratorStateMachine(typeof(<SpawnBombsAfterLobAnimation>d__5))]
		private static IEnumerator SpawnBombsAfterLobAnimation(int regularCount, int riggedCount)
		{
			//yield-return decompiler failed: Unexpected instruction in Iterator.Dispose()
			return new <SpawnBombsAfterLobAnimation>d__5(0)
			{
				regularCount = regularCount,
				riggedCount = riggedCount
			};
		}

		private static void SpawnVisualBomb(GameObject prefab, Vector3 spawnPos, int totalThrown)
		{
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				BombLob component = Object.Instantiate<GameObject>(prefab, spawnPos, Quaternion.identity).GetComponent<BombLob>();
				if (component != null)
				{
					component.Shoot(false, totalThrown);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("Failed to spawn visual bomb: " + ex.Message));
			}
		}
	}
	public sealed class BombThrownServerHandler : IServerHandler<BombThrownEvent>
	{
		public BombThrownEvent Handle(BombThrownEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class CritActivatedClientHandler : IClientHandler<CritActivatedEvent>
	{
		public void Handle(CritActivatedEvent networkEvent)
		{
			try
			{
				CriticalHitActivated onCriticalHitActivated = BattleController.onCriticalHitActivated;
				if (onCriticalHitActivated != null)
				{
					onCriticalHitActivated.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("CritActivated handler failed: " + ex.Message));
			}
		}
	}
	public sealed class CritActivatedServerHandler : IServerHandler<CritActivatedEvent>
	{
		public CritActivatedEvent Handle(CritActivatedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class CritDeactivatedClientHandler : IClientHandler<CritDeactivatedEvent>
	{
		public void Handle(CritDeactivatedEvent networkEvent)
		{
			try
			{
				CriticalHitActivated onCriticalHitDeactivated = BattleController.onCriticalHitDeactivated;
				if (onCriticalHitDeactivated != null)
				{
					onCriticalHitDeactivated.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("CritDeactivated handler failed: " + ex.Message));
			}
		}
	}
	public sealed class CritDeactivatedServerHandler : IServerHandler<CritDeactivatedEvent>
	{
		public CritDeactivatedEvent Handle(CritDeactivatedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class DamageTextClientHandler : IClientHandler<DamageTextEvent>
	{
		public void Handle(DamageTextEvent e)
		{
			//IL_0071: 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)
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode != null && multiplayerMode.IsSpectating)
				{
					DamageCountDisplay val = Object.FindObjectOfType<DamageCountDisplay>();
					if (!((Object)(object)val == (Object)null))
					{
						Vector2 val2 = default(Vector2);
						((Vector2)(ref val2))..ctor(e.PosX, e.PosY);
						Color val3 = default(Color);
						((Color)(ref val3))..ctor(e.R, e.G, e.B, e.A);
						val.CreateText(e.Text, val2, val3, false, 0);
					}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("DamageText handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class DamageTextServerHandler : IServerHandler<DamageTextEvent>
	{
		public DamageTextEvent Handle(DamageTextEvent e)
		{
			return e;
		}
	}
	public sealed class DefeatClientHandler : IClientHandler<DefeatEvent>
	{
		public void Handle(DefeatEvent networkEvent)
		{
			try
			{
				PlayerHealthController.OnDefeat?.Invoke();
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("Defeat handler failed: " + ex.Message));
			}
		}
	}
	public sealed class DefeatServerHandler : IServerHandler<DefeatEvent>
	{
		public DefeatEvent Handle(DefeatEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class OrbDiscardedClientHandler : IClientHandler<OrbDiscardedEvent>
	{
		public void Handle(OrbDiscardedEvent networkEvent)
		{
			try
			{
				if (LobbyUI.GameStartReceived)
				{
					if (!TurnChangeClientHandler.IsMyTurn)
					{
						return;
					}
					string text = PopClientShuffledDeck();
					BattleController val = Object.FindObjectOfType<BattleController>();
					if ((Object)(object)val != (Object)null)
					{
						val.NumShotsDiscarded++;
						BattleController.OnOrbDiscarded?.Invoke();
					}
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)"[OrbDiscarded] Client's discard processed — resetting aiming ball");
					}
					MultiplayerClientPatches._clientPendingOrbName = text;
					MultiplayerClientPatches.ResetClientAimingBall();
					if (!string.IsNullOrEmpty(text))
					{
						IServiceContainer services = MultiplayerPlugin.Services;
						if (services != null && services.TryResolve<GameStateApplyService>(out var instance))
						{
							instance.DeckApplier.RefreshActiveOrbDisplay(text);
						}
					}
				}
				else
				{
					BattleController.OnOrbDiscarded?.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("OrbDiscarded handler failed: " + ex.Message));
			}
		}

		private static string PopClientShuffledDeck()
		{
			try
			{
				DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
				if (array == null || array.Length == 0)
				{
					return null;
				}
				DeckManager obj = array[0];
				if (AccessTools.Field(typeof(DeckManager), "shuffledDeck")?.GetValue(obj) is Stack<GameObject> stack && stack.Count > 0)
				{
					GameObject val = stack.Pop();
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[OrbDiscarded] Popped '{((val != null) ? ((Object)val).name : null)}' from client shuffledDeck (remaining: {stack.Count})");
					}
					return (val != null) ? ((Object)val).name : null;
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("[OrbDiscarded] Failed to pop shuffledDeck: " + ex.Message));
				}
			}
			return null;
		}
	}
	public sealed class OrbDiscardedServerHandler : IServerHandler<OrbDiscardedEvent>
	{
		public OrbDiscardedEvent Handle(OrbDiscardedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class ReloadStartedClientHandler : IClientHandler<ReloadStartedEvent>
	{
		public void Handle(ReloadStartedEvent networkEvent)
		{
			try
			{
				ReloadStarted onReloadStarted = BattleController.OnReloadStarted;
				if (onReloadStarted != null)
				{
					onReloadStarted.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("ReloadStarted handler failed: " + ex.Message));
			}
		}
	}
	public sealed class ReloadStartedServerHandler : IServerHandler<ReloadStartedEvent>
	{
		public ReloadStartedEvent Handle(ReloadStartedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class RoundIncrementedClientHandler : IClientHandler<RoundIncrementedEvent>
	{
		public void Handle(RoundIncrementedEvent networkEvent)
		{
			try
			{
				RoundCountIncremented onRoundCountIncremented = BattleController.OnRoundCountIncremented;
				if (onRoundCountIncremented != null)
				{
					onRoundCountIncremented.Invoke(networkEvent.RoundCount);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("RoundIncremented handler failed: " + ex.Message));
			}
		}
	}
	public sealed class RoundIncrementedServerHandler : IServerHandler<RoundIncrementedEvent>
	{
		public RoundIncrementedEvent Handle(RoundIncrementedEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class ShotCompleteClientHandler : IClientHandler<ShotCompleteEvent>
	{
		public void Handle(ShotCompleteEvent networkEvent)
		{
			try
			{
				ShotComplete onShotComplete = BattleController.OnShotComplete;
				if (onShotComplete != null)
				{
					onShotComplete.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("ShotComplete handler failed: " + ex.Message));
			}
		}
	}
	public sealed class ShotCompleteServerHandler : IServerHandler<ShotCompleteEvent>
	{
		public ShotCompleteEvent Handle(ShotCompleteEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class ShotTimeoutClientHandler : IClientHandler<ShotTimeoutEvent>
	{
		public void Handle(ShotTimeoutEvent networkEvent)
		{
			try
			{
				ShotTimeoutEvent onShotTimeout = BattleController.OnShotTimeout;
				if (onShotTimeout != null)
				{
					onShotTimeout.Invoke();
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("ShotTimeout handler failed: " + ex.Message));
			}
		}
	}
	public sealed class ShotTimeoutServerHandler : IServerHandler<ShotTimeoutEvent>
	{
		public ShotTimeoutEvent Handle(ShotTimeoutEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class SpiritOfRadiaPhaseTransitionClientHandler : IClientHandler<SpiritOfRadiaPhaseTransitionEvent>
	{
		public void Handle(SpiritOfRadiaPhaseTransitionEvent networkEvent)
		{
			try
			{
				switch (networkEvent.Step)
				{
				case 1:
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)"[SpiritOfRadia] Client: firing PreTransitionStarted");
					}
					SpiritOfRadiaPhaseTransitionStarted preTransitionStarted = SpiritOfRadiaBoss.PreTransitionStarted;
					if (preTransitionStarted != null)
					{
						preTransitionStarted.Invoke();
					}
					break;
				}
				case 2:
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogInfo((object)"[SpiritOfRadia] Client: firing OnSpiritOfRadiaPhaseTransitionStarted");
					}
					SpiritOfRadiaPhaseTransitionStarted onSpiritOfRadiaPhaseTransitionStarted = SpiritOfRadiaBoss.OnSpiritOfRadiaPhaseTransitionStarted;
					if (onSpiritOfRadiaPhaseTransitionStarted != null)
					{
						onSpiritOfRadiaPhaseTransitionStarted.Invoke();
					}
					HidePhase2VisualLeftovers();
					break;
				}
				default:
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)$"[SpiritOfRadia] Unknown step {networkEvent.Step}");
					}
					break;
				}
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogWarning((object)("[SpiritOfRadia] Client handler failed: " + ex.Message));
				}
			}
		}

		private static void HidePhase2VisualLeftovers()
		{
			SpiritOfRadiaBoss val = Object.FindObjectOfType<SpiritOfRadiaBoss>();
			if (!((Object)(object)val == (Object)null))
			{
				TryHideField(val, "_topCrystals");
				TryHideBehaviourField(val, "_targetingUI");
			}
		}

		private static void TryHideField(SpiritOfRadiaBoss boss, string fieldName)
		{
			try
			{
				object? obj = AccessTools.Field(typeof(SpiritOfRadiaBoss), fieldName)?.GetValue(boss);
				GameObject val = (GameObject)((obj is GameObject) ? obj : null);
				if ((Object)(object)val != (Object)null && val.activeSelf)
				{
					val.SetActive(false);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[SpiritOfRadia] Failed to hide " + fieldName + ": " + ex.Message));
				}
			}
		}

		private static void TryHideBehaviourField(SpiritOfRadiaBoss boss, string fieldName)
		{
			try
			{
				object? obj = (AccessTools.Field(typeof(SpiritOfRadiaBoss), fieldName) ?? AccessTools.Field(typeof(Enemy), fieldName))?.GetValue(boss);
				Behaviour val = (Behaviour)((obj is Behaviour) ? obj : null);
				if ((Object)(object)val != (Object)null && ((Component)val).gameObject.activeSelf)
				{
					((Component)val).gameObject.SetActive(false);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[SpiritOfRadia] Failed to hide behaviour " + fieldName + ": " + ex.Message));
				}
			}
		}
	}
	public sealed class SpiritOfRadiaPhaseTransitionServerHandler : IServerHandler<SpiritOfRadiaPhaseTransitionEvent>
	{
		public SpiritOfRadiaPhaseTransitionEvent Handle(SpiritOfRadiaPhaseTransitionEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class TurnCompleteClientHandler : IClientHandler<TurnCompleteEvent>
	{
		public void Handle(TurnCompleteEvent networkEvent)
		{
			try
			{
				BattleController.OnTurnComplete?.Invoke();
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("TurnComplete handler failed: " + ex.Message));
			}
		}
	}
	public sealed class TurnCompleteServerHandler : IServerHandler<TurnCompleteEvent>
	{
		public TurnCompleteEvent Handle(TurnCompleteEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class VictoryClientHandler : IClientHandler<VictoryEvent>
	{
		public void Handle(VictoryEvent networkEvent)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode != null && multiplayerMode.IsSpectating)
				{
					MapStateApplier.ClientWaitingMessage = "Waiting for other players...";
				}
				BattleController.OnVictory?.Invoke();
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("Victory handler failed: " + ex.Message));
			}
		}
	}
	public sealed class VictoryServerHandler : IServerHandler<VictoryEvent>
	{
		public VictoryEvent Handle(VictoryEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.Events.Handlers.Ball
{
	public sealed class AimUpdateClientHandler : IClientHandler<AimUpdateEvent>
	{
		public void Handle(AimUpdateEvent e)
		{
			try
			{
				if (!TurnChangeClientHandler.IsMyTurn)
				{
					ClientAimRenderer.Instance?.UpdateAim(e.AimX, e.AimY, e.SpawnX, e.SpawnY);
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("AimUpdate handler failed: " + ex.Message));
			}
		}
	}
	public sealed class AimUpdateServerHandler : IServerHandler<AimUpdateEvent>
	{
		public AimUpdateEvent Handle(AimUpdateEvent e)
		{
			IServiceContainer services = MultiplayerPlugin.Services;
			if (services != null && services.TryResolve<TurnManager>(out var instance) && instance.CurrentPlayerSlot > 0)
			{
				ClientAimRenderer.Instance?.UpdateAim(e.AimX, e.AimY, e.SpawnX, e.SpawnY);
			}
			return e;
		}
	}
	public sealed class BallStateSnapshotClientHandler : IClientHandler<BallStateSnapshot>
	{
		public void Handle(BallStateSnapshot e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode != null && multiplayerMode.IsSpectating)
				{
					ClientBallRenderer.Instance?.ApplyBallSnapshot(e);
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("BallStateSnapshot handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class BallStateSnapshotServerHandler : IServerHandler<BallStateSnapshot>
	{
		public BallStateSnapshot Handle(BallStateSnapshot e)
		{
			return e;
		}
	}
	public sealed class BallWallBounceClientHandler : IClientHandler<BallWallBounceEvent>
	{
		public void Handle(BallWallBounceEvent networkEvent)
		{
			//IL_0047: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				MultiplayerPlugin.Logger.LogInfo((object)$"Multiplayer: Ball bounced off wall at ({networkEvent.PosX:F2}, {networkEvent.PosY:F2})");
				PachinkoBallWallBounce onPachinkoBallWallBounce = PachinkoBall.OnPachinkoBallWallBounce;
				if (onPachinkoBallWallBounce != null)
				{
					onPachinkoBallWallBounce.Invoke(new Vector3(networkEvent.PosX, networkEvent.PosY, networkEvent.PosZ));
				}
			}
			catch (Exception ex)
			{
				MultiplayerPlugin.Logger.LogWarning((object)("BallWallBounce handler failed: " + ex.Message));
			}
		}
	}
	public sealed class BallWallBounceServerHandler : IServerHandler<BallWallBounceEvent>
	{
		public BallWallBounceEvent Handle(BallWallBounceEvent networkEvent)
		{
			return networkEvent;
		}
	}
	public sealed class ShotFiredClientHandler : IClientHandler<ShotFiredEvent>
	{
		public void Handle(ShotFiredEvent e)
		{
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				IMultiplayerMode instance;
				IMultiplayerMode multiplayerMode = ((services != null && services.TryResolve<IMultiplayerMode>(out instance)) ? instance : null);
				if (multiplayerMode != null && multiplayerMode.IsSpectating)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)$"[ShotFired] orb={e.OrbName}, aim=({e.AimX:F2},{e.AimY:F2}), spawn=({e.SpawnX:F1},{e.SpawnY:F1})");
					}
					ClientBallRenderer.Instance?.OnShotFired(e.AimX, e.AimY, e.OrbName);
					ClientAimRenderer.Instance?.HideAim();
				}
			}
			catch (Exception ex)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)("ShotFired handler failed: " + ex.Message));
				}
			}
		}
	}
	public sealed class ShotFiredServerHandler : IServerHandler<ShotFiredEvent>
	{
		public ShotFiredEvent Handle(ShotFiredEvent networkEvent)
		{
			return networkEvent;
		}
	}
}
namespace Multipeglin.DI
{
	public interface IServiceContainer
	{
		void RegisterSingleton<TInterface>(TInterface instance);

		void RegisterSingleton<TInterface, TImplementation>() where TImplementation : class, TInterface, new();

		T Resolve<T>();

		bool TryResolve<T>(out T instance);
	}
	public class ServiceContainer : IServiceContainer
	{
		private readonly Dictionary<Type, object> _singletons = new Dictionary<Type, object>();

		private readonly Dictionary<Type, Func<object>> _factories = new Dictionary<Type, Func<object>>();

		public void RegisterSingleton<TInterface>(TInterface instance)
		{
			_singletons[typeof(TInterface)] = instance;
		}

		public void RegisterSingleton<TInterface, TImplementation>() where TImplementation : class, TInterface, new()
		{
			_factories[typeof(TInterface)] = () => new TImplementation();
		}

		public T Resolve<T>()
		{
			Type typeFromHandle = typeof(T);
			if (_singletons.TryGetValue(typeFromHandle, out var value))
			{
				return (T)value;
			}
			if (_factories.TryGetValue(typeFromHandle, out var value2))
			{
				T val = (T)value2();
				_singletons[typeFromHandle] = val;
				_factories.Remove(typeFromHandle);
				return val;
			}
			throw new InvalidOperationException("No registration found for type " + typeFromHandle.FullName);
		}

		public bool TryResolve<T>(out T instance)
		{
			try
			{
				instance = Resolve<T>();
				return true;
			}
			catch (InvalidOperationException)
			{
				instance = default(T);
				return false;
			}
		}
	}
	public static class ServiceRegistration
	{
		public static IServiceContainer CreateAndConfigure(ManualLogSource log)
		{
			log.LogInfo((object)"[DI] Phase 1: Core services...");
			ServiceContainer serviceContainer = Phase1_Core(log);
			log.LogInfo((object)"[DI] Phase 2a: MessageTypeRegistry...");
			Phase2a_TypeRegistry(serviceContainer);
			log.LogInfo((object)"[DI] Phase 2b: JsonNetworkSerializer...");
			Phase2b_Serializer(serviceContainer);
			log.LogInfo((object)"[DI] Phase 2c: Transport...");
			Phase2c_Transport(serviceContainer, log);
			log.LogInfo((object)"[DI] Phase 3: Events...");
			Phase3_Events(serviceContainer, log);
			log.LogInfo((object)"[DI] Phase 4: Handlers...");
			Phase4_Handlers(serviceContainer);
			log.LogInfo((object)"[DI] Phase 5: Subscriptions...");
			Phase5_Subscriptions(serviceContainer, log);
			log.LogInfo((object)"[DI] Phase 6: Handshake hook...");
			Phase6_Handshake(serviceContainer);
			log.LogInfo((object)"[DI] All phases complete.");
			return serviceContainer;
		}

		private static ServiceContainer Phase1_Core(ManualLogSource log)
		{
			ServiceContainer serviceContainer = new ServiceContainer();
			serviceContainer.RegisterSingleton<ManualLogSource>(log);
			serviceContainer.RegisterSingleton((IMultiplayerMode)new MultiplayerMode());
			return serviceContainer;
		}

		private static void Phase2a_TypeRegistry(ServiceContainer container)
		{
			MessageTypeRegistry instance = new MessageTypeRegistry();
			container.RegisterSingleton(instance);
		}

		private static void Phase2b_Serializer(ServiceContainer container)
		{
			JsonNetworkSerializer instance = new JsonNetworkSerializer(container.Resolve<MessageTypeRegistry>());
			container.RegisterSingleton((INetworkSerializer)instance);
		}

		private static void Phase2c_Transport(ServiceContainer container, ManualLogSource log)
		{
			TransportRouter instance = new TransportRouter(new LiteNetTransport(), null);
			container.RegisterSingleton(instance);
			container.RegisterSingleton((INetworkTransport)instance);
			container.RegisterSingleton((ISteamTransport)instance);
			log.LogInfo((object)"[DI] Transport router registered (Steam will attach at UI start if available)");
		}

		private static void Phase3_Events(ServiceContainer container, ManualLogSource log)
		{
			INetworkSerializer serializer = container.Resolve<INetworkSerializer>();
			INetworkTransport transport = container.Resolve<INetworkTransport>();
			MessageTypeRegistry typeRegistry = container.Resolve<MessageTypeRegistry>();
			GameEventRegistry gameEventRegistry = new GameEventRegistry(serializer, transport, typeRegistry, log);
			container.RegisterSingleton((IGameEventRegistry)gameEventRegistry);
			container.RegisterSingleton(gameEventRegistry);
			NetworkHost instance = new NetworkHost(transport, serializer);
			container.RegisterSingleton((IMessageSender)instance);
			NetworkClient instance2 = new NetworkClient(transport, gameEventRegistry, serializer);
			container.RegisterSingleton((IMessageReceiver)instance2);
			EnemyIdentifier enemyIdentifier = new EnemyIdentifier();
			container.RegisterSingleton(enemyIdentifier);
			PegIdentifier pegIdentifier = new PegIdentifier();
			container.RegisterSingleton(pegIdentifier);
			OrbIdentifier orbIdentifier = new OrbIdentifier();
			container.RegisterSingleton(orbIdentifier);
			BallIdentifier instance3 = new BallIdentifier();
			container.RegisterSingleton(instance3);
			PlayerRegistry playerRegistry = new PlayerRegistry();
			container.RegisterSingleton(playerRegistry);
			CoopStateManager coopStateManager = new CoopStateManager(log, playerRegistry);
			coopStateManager.SetOrbIdentifier(orbIdentifier);
			container.RegisterSingleton(coopStateManager);
			TurnManager instance4 = new TurnManager(log, coopStateManager);
			container.RegisterSingleton(instance4);
			GameStateSyncService instance5 = new GameStateSyncService(log, gameEventRegistry, container.Resolve<IMultiplayerMode>(), enemyIdentifier, pegIdentifier, orbIdentifier, coopStateManager);
			container.RegisterSingleton((IGameStateSyncService)instance5);
			GameStateApplyService instance6 = new GameStateApplyService(log, enemyIdentifier, pegIdentifier, orbIdentifier);
			container.RegisterSingleton(instance6);
			VersionChecker versionChecker = new VersionChecker(log);
			versionChecker.Check();
			container.RegisterSingleton(versionChecker);
			AppLevelRttProvider instance7 = new AppLevelRttProvider(container.Resolve<IMultiplayerMode>(), log);
			container.RegisterSingleton(instance7);
			container.RegisterSingleton((IRttProvider)instance7);
			HostRttTracker instance8 = new HostRttTracker(container.Resolve<IMultiplayerMode>(), log);
			container.RegisterSingleton(instance8);
			EventDiscovery eventDiscovery = new EventDiscovery(log);
			eventDiscovery.ScanGameDelegates();
			container.RegisterSingleton(eventDiscovery);
		}

		private static void Phase4_Handlers(ServiceContainer container)
		{
			GameEventRegistry gameEventRegistry = container.Resolve<GameEventRegistry>();
			EventDiscovery eventDiscovery = container.Resolve<EventDiscovery>();
			RegisterAllHandlers(gameEventRegistry);
			foreach (string registeredTypeId in gameEventRegistry.RegisteredTypeIds)
			{
				eventDiscovery.MarkRegistered(registeredTypeId);
			}
			eventDiscovery.LogReport();
		}

		private static void Phase5_Subscriptions(ServiceContainer container, ManualLogSource log)
		{
			IGameEventRegistry registry = container.Resolve<IGameEventRegistry>();
			IMultiplayerMode multiplayerMode = container.Resolve<IMultiplayerMode>();
			EnemyIdentifier enemyIdentifier = container.Resolve<EnemyIdentifier>();
			OrbIdentifier orbIdentifier = container.Resolve<OrbIdentifier>();
			IGameStateSyncService syncService = container.Resolve<IGameStateSyncService>();
			CoopStateManager coopStateManager = container.Resolve<CoopStateManager>();
			TurnManager turnManager = container.Resolve<TurnManager>();
			SubscribeAll(registry, multiplayerMode, enemyIdentifier, orbIdentifier, syncService, coopStateManager, turnManager, log);
		}

		private static void Phase6_Handshake(ServiceContainer container)
		{
			INetworkTransport transport = container.Resolve<INetworkTransport>();
			GameEventRegistry eventRegistry = container.Resolve<GameEventRegistry>();
			ManualLogSource log = container.Resolve<ManualLogSource>();
			IGameStateSyncService syncService = container.Resolve<IGameStateSyncService>();
			transport.OnClientConnected += delegate
			{
				eventRegistry.Dispatch(new HandshakeEvent
				{
					PlayerName = MultiplayerUI.LocalPlayerName,
					ModVersion = "0.1.10",
					CompiledGameVersion = "2.0.12",
					RuntimeGameVersion = (Application.version ?? "unknown"),
					IsHost = transport.IsHost,
					RegisteredHandlerCount = eventRegistry.RegisteredTypeIds.Count
				});
				if (transport.IsHost)
				{
					syncService.SyncAll("ClientHandshake");
				}
			};
			PlayerRegistry playerRegistry = container.Resolve<PlayerRegistry>();
			transport.OnDisconnected += delegate(int peerId)
			{
				if (transport.IsHost)
				{
					PlayerSlot slotByPeerId = playerRegistry.GetSlotByPeerId(peerId);
					if (slotByPeerId != null)
					{
						log.LogInfo((object)$"[Disconnect] Peer {peerId} disconnected: slot {slotByPeerId.SlotIndex} ({slotByPeerId.PlayerName})");
						CoopSubscriptions instance = CoopSubscriptions.Instance;
						if (instance != null)
						{
							instance.HandlePlayerDisconnect(slotByPeerId.SlotIndex, slotByPeerId.PlayerName);
						}
						else
						{
							log.LogWarning((object)$"[Disconnect] CoopSubscriptions.Instance is null — cannot handle turn removal for slot {slotByPeerId.SlotIndex}");
						}
						playerRegistry.RemoveByPeerId(peerId);
						log.LogInfo((object)$"[Disconnect] Removed peer {peerId} from PlayerRegistry. Remaining slots: {playerRegistry.SlotCount}");
						try
						{
							IGameEventRegistry eventRegistry2 = container.Resolve<IGameEventRegistry>();
							LobbyHelper.BroadcastLobbyState(playerRegistry, eventRegistry2);
						}
						catch (Exception ex)
						{
							log.LogWarning((object)("[Disconnect] BroadcastLobbyState failed: " + ex.Message));
						}
						try
						{
							CoopNavigateResolver.OnPeerDisconnected();
							return;
						}
						catch (Exception ex2)
						{
							log.LogWarning((object)("[Disconnect] CoopNavigateResolver.OnPeerDisconnected failed: " + ex2.Message));
							return;
						}
					}
					log.LogWarning((object)$"[Disconnect] Peer {peerId} disconnected but no slot found in registry");
				}
			};
		}

		private static void RegisterAllHandlers(IGameEventRegistry registry)
		{
			registry.Register(new HandshakeServerHandler(), new HandshakeClientHandler());
			registry.Register(new DisconnectServerHandler(), new DisconnectClientHandler());
			registry.Register(new PingServerHandler(), new PingClientHandler());
			registry.Register(new PongServerHandler(), new PongClientHandler());
			registry.Register(new HostPingNoopServerHandler(), new HostPingClientHandler());
			registry.Register(new HostPongServerHandler(), new HostPongClientHandler());
			registry.Register(new BattleStartedServerHandler(), new BattleStartedClientHandler());
			registry.Register(new BattleEndedServerHandler(), new BattleEndedClientHandler());
			registry.Register(new VictoryServerHandler(), new VictoryClientHandler());
			registry.Register(new DefeatServerHandler(), new DefeatClientHandler());
			registry.Register(new AttackStartedServerHandler(), new AttackStartedClientHandler());
			registry.Register(new TurnCompleteServerHandler(), new TurnCompleteClientHandler());
			registry.Register(new ShotCompleteServerHandler(), new ShotCompleteClientHandler());
			registry.Register(new RoundIncrementedServerHandler(), new RoundIncrementedClientHandler());
			registry.Register(new ReloadStartedServerHandler(), new ReloadStartedClientHandler());
			registry.Register(new CritActivatedServerHandler(), new CritActivatedClientHandler());
			registry.Register(new CritDeactivatedServerHandler(), new CritDeactivatedClientHandler());
			registry.Register(new BombThrownServerHandler(), new BombThrownClientHandler());
			registry.Register(new BombDetonatedServerHandler(), new BombDetonatedClientHandler());
			registry.Register(new OrbDiscardedServerHandler(), new OrbDiscardedClientHandler());
			registry.Register(new AwaitingShotServerHandler(), new AwaitingShotClientHandler());
			registry.Register(new ShotTimeoutServerHandler(), new ShotTimeoutClientHandler());
			registry.Register(new DamageTextServerHandler(), new DamageTextClientHandler());
			registry.Register(new AnimationSyncServerHandler(), new AnimationSyncClientHandler());
			registry.Register(new SpiritOfRadiaPhaseTransitionServerHandler(), new SpiritOfRadiaPhaseTransitionClientHandler());
			registry.Register(new PlayerDamagedServerHandler(), new PlayerDamagedClientHandler());
			registry.Register(new PlayerHealedServerHandler(), new PlayerHealedClientHandler());
			registry.Register(new ArmourHitServerHandler(), new ArmourHitClientHandler());
			registry.Register(new DodgeServerHandler(), new DodgeClientHandler());
			registry.Register(new HealthDepletedServerHandler(), new HealthDepletedClientHandler());
			registry.Register(new MaxHealthChangedServerHandler(), new MaxHealthChangedClientHandler());
			registry.Register(new EnemySpawnedServerHandler(), new EnemySpawnedClientHandler());
			registry.Register(new EnemyDamagedServerHandler(), new EnemyDamagedClientHandler());
			registry.Register(new EnemyDestroyedServerHandler(), new EnemyDestroyedClientHandler());
			registry.Register(new EnemyKilledServerHandler(), new EnemyKilledClientHandler());
			registry.Register(new EnemyAttackServerHandler(), new EnemyAttackClientHandler());
			registry.Register(new EnemyMovedServerHandler(), new EnemyMovedClientHandler());
			registry.Register(new BallDrawnServerHandler(), new BallDrawnClientHandler());
			registry.Register(new BallUsedServerHandler(), new BallUsedClientHandler());
			registry.Register(new BallUpgradedServerHandler(), new BallUpgradedClientHandler());
			registry.Register(new DeckShuffledServerHandler(), new DeckShuffledClientHandler());
			registry.Register(new RelicAddedServerHandler(), new RelicAddedClientHandler());
			registry.Register(new RelicRemovedServerHandler(), new RelicRemovedClientHandler());
			registry.Register(new RelicUsedServerHandler(), new RelicUsedClientHandler());
			registry.Register(new GoldChangedServerHandler(), new GoldChangedClientHandler());
			registry.Register(new StatusEffectsUpdatedServerHandler(), new StatusEffectsUpdatedClientHandler());
			registry.Register(new ShotFiredServerHandler(), new ShotFiredClientHandler());
			registry.Register(new BallWallBounceServerHandler(), new BallWallBounceClientHandler());
			registry.Register(new BallStateSnapshotServerHandler(), new BallStateSnapshotClientHandler());
			registry.Register(new AimUpdateServerHandler(), new AimUpdateClientHandler());
			registry.Register(new CursorPositionServerHandler(), new CursorPositionClientHandler());
			registry.Register(new PegHitServerHandler(), new PegHitClientHandler());
			registry.Register(new PegActivatedServerHandler(), new PegActivatedClientHandler());
			registry.Register(new PegDestroyedServerHandler(), new PegDestroyedClientHandler());
			registry.Register(new NodeSelectedServerHandler(), new NodeSelectedClientHandler());
			registry.Register(new NodeActivatedServerHandler(), new NodeActivatedClientHandler());
			registry.Register(new LobbyStateServerHandler(), new LobbyStateClientHandler());
			registry.Register(new ClassSelectServerHandler(), new ClassSelectClientHandler());
			registry.Register(new ReadyServerHandler(), new ReadyClientHandler());
			registry.Register(new GameStartServerHandler(), new GameStartClientHandler());
			registry.Register(new TurnChangeServerHandler(), new TurnChangeClientHandler());
			registry.Register(new ShootRequestServerHandler(), new ShootRequestClientHandler());
			registry.Register(new TargetSelectServerHandler(), new TargetSelectClientHandler());
			registry.Register(new PendingDamagePreviewServerHandler(), new PendingDamagePreviewClientHandler());
			registry.Register(new RelicChoicesServerHandler(), new RelicChoicesClientHandler());
			registry.Register(new RelicChoiceServerHandler(), new RelicChoiceClientHandler());
			registry.Register(new RewardChoicesServerHandler(), new RewardChoicesClientHandler());
			registry.Register(new RewardChoiceServerHandler(), new RewardChoiceClientHandler());
			registry.Register(new AllChoicesCompleteServerHandler(), new AllChoicesCompleteClientHandler());
			registry.Register(new PostBattleStartServerHandler(), new PostBattleStartClientHandler());
			registry.Register(new PostBattleCompleteServerHandler(), new PostBattleCompleteClientHandler());
			registry.Register(new PostBattleGoldSpentServerHandler(), new PostBattleGoldSpentClientHandler());
			registry.Register(new PostBattleBossHealServerHandler(), new PostBattleBossHealClientHandler());
			registry.Register(new PostBattleRelicChoicesServerHandler(), new PostBattleRelicChoicesClientHandler());
			registry.Register(new CoopOrbRewardChoicesServerHandler(), new CoopOrbRewardChoicesClientHandler());
			registry.Register(new CoopTreasureRelicChoiceServerHandler(), new CoopTreasureRelicChoiceClientHandler());
			registry.Register(new RunStatsSnapshotServerHandler(), new RunStatsSnapshotClientHandler());
			registry.Register(new OrbDiscardRequestServerHandler(), new OrbDiscardRequestClientHandler());
			registry.Register(new SkipTurnRequestServerHandler(), new SkipTurnRequestClientHandler());
			registry.Register(new NavigatePhaseStartServerHandler(), new NavigatePhaseStartClientHandler());
			registry.Register(new NavigateVoteServerHandler(), new NavigateVoteClientHandler());
			registry.Register(new NavigateVoteUpdateServerHandler(), new NavigateVoteUpdateClientHandler());
			registry.Register(new NavigateResolvedServerHandler(), new NavigateResolvedClientHandler());
			registry.Register(new NavBallShotServerHandler(), new NavBallShotClientHandler());
			registry.Register(new SlotConfigServerHandler(), new SlotConfigClientHandler());
			registry.Register(new MirrorEventStartServerHandler(), new MirrorEventStartClientHandler());
			registry.Register(new MirrorEventCompleteServerHandler(), new MirrorEventCompleteClientHandler());
			registry.Register(new TextScenarioCompleteServerHandler(), new TextScenarioCompleteClientHandler());
			registry.Register(new ShopCompleteServerHandler(), new ShopCompleteClientHandler());
			registry.Register(new ShopPurchaseServerHandler(), new ShopPurchaseClientHandler());
			registry.Register(new TreasureCompleteServerHandler(), new TreasureCompleteClientHandler());
			registry.Register(new PegMinigameCompleteServerHandler(), new PegMinigameCompleteClientHandler());
			registry.Register(new FullGameStateServerHandler(), new FullGameStateClientHandler());
			registry.Register(new MapStateSnapshotServerHandler(), new MapStateSnapshotClientHandler());
			registry.Register(new PlayerStateSnapshotServerHandler(), new PlayerStateSnapshotClientHandler());
			registry.Register(new EnemyStateSnapshotServerHandler(), new EnemyStateSnapshotClientHandler());
			registry.Register(new PegboardStateSnapshotServerHandler(), new PegboardStateSnapshotClientHandler());
			registry.Register(new DeckStateSnapshotServerHandler(), new DeckStateSnapshotClientHandler());
			registry.Register(new RelicStateSnapshotServerHandler(), new RelicStateSnapshotClientHandler());
		}

		private static void SubscribeAll(IGameEventRegistry registry, IMultiplayerMode multiplayerMode, EnemyIdentifier enemyIdentifier, OrbIdentifier orbIdentifier, IGameStateSyncService syncService, CoopStateManager coopStateManager, TurnManager turnManager, ManualLogSource log)
		{
			new BattleEventSubscriptions(registry, multiplayerMode).Subscribe();
			new HealthSubscriptions(registry, log, coopStateManager).Subscribe();
			new EnemySubscriptions(registry, enemyIdentifier, log, coopStateManager).Subscribe();
			new DeckSubscriptions(registry, orbIdentifier, log).Subscribe();
			new RelicSubscriptions(registry, log).Subscribe();
			new CurrencySubscriptions(registry, log, coopStateManager).Subscribe();
			new StatusEffectEventSubscriptions(registry, multiplayerMode).Subscribe();
			new BallSubscriptions(registry, log).Subscribe();
			new PegSubscriptions(registry, log).Subscribe();
			new MapSubscriptions(registry, log).Subscribe();
			BattleControllerUpdateManager bcUpdater = new BattleControllerUpdateManager();
			CoopDeckManager deckMgr = new CoopDeckManager(log);
			OrbStatusEffectApplier orbApplier = new OrbStatusEffectApplier(bcUpdater, log);
			BuffApplier buffApplier = new BuffApplier(log);
			new CoopSubscriptions(multiplayerMode, coopStateManager, turnManager, syncService, bcUpdater, deckMgr, orbApplier, buffApplier, log).Subscribe();
			new StateSyncSubscriptions(syncService, multiplayerMode, log).Subscribe();
		}
	}
}
namespace Multipeglin.Debug
{
	public sealed class DebugHotkeys : MonoBehaviour
	{
		private const string EnvVar = "MULTIPEGLIN_DEBUG";

		private bool _enabled;

		private void Awake()
		{
			string environmentVariable = Environment.GetEnvironmentVariable("MULTIPEGLIN_DEBUG");
			_enabled = environmentVariable == "1" || string.Equals(environmentVariable, "true", StringComparison.OrdinalIgnoreCase);
			if (_enabled)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[DebugHotkeys] enabled via MULTIPEGLIN_DEBUG; F10 = nuke enemies");
				}
			}
		}

		private void Update()
		{
			if (!_enabled || !Input.GetKeyDown((KeyCode)291) || MultiplayerPlugin.Services == null)
			{
				return;
			}
			if (!MultiplayerPlugin.Services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogInfo((object)"[DebugHotkeys] F10 ignored — not hosting");
				}
				return;
			}
			EnemyManager val = Object.FindObjectOfType<EnemyManager>();
			if ((Object)(object)val == (Object)null || val.Enemies == null || val.Enemies.Count == 0)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogInfo((object)"[DebugHotkeys] F10 ignored — no EnemyManager/enemies");
				}
				return;
			}
			List<Enemy> list = new List<Enemy>(val.Enemies);
			int num = 0;
			foreach (Enemy item in list)
			{
				if ((Object)(object)item == (Object)null)
				{
					continue;
				}
				try
				{
					item.Damage(99999L, false, 0f, 1f, true, (EnemyDamageSource)0, true, true);
					num++;
				}
				catch (Exception ex)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)("[DebugHotkeys] Damage failed on enemy: " + ex.Message));
					}
				}
			}
			ManualLogSource logger4 = MultiplayerPlugin.Logger;
			if (logger4 != null)
			{
				logger4.LogInfo((object)$"[DebugHotkeys] F10 nuked {num} enemies");
			}
		}
	}
	[HarmonyPatch]
	internal static class DebugStartingDeck
	{
		private const string EnvVar = "MULTIPEGLIN_DEBUG";

		private static readonly string[] OrbPrefabNames = new string[2] { "BigBossD9000-Lvl1", "BeastWarb-Lvl1" };

		private static readonly HashSet<string> _grantedThisRun = new HashSet<string>();

		private static bool _runStarted;

		public static void TryGrantHostDebugOrbs()
		{
			if (IsEnabled())
			{
				if (!_runStarted)
				{
					_grantedThisRun.Clear();
					_runStarted = true;
				}
				TryGrantPending("GameInit");
			}
		}

		[HarmonyPatch(typeof(MapController), "Awake")]
		[HarmonyPostfix]
		public static void MapController_Awake_Postfix()
		{
			TryRetry("MapController");
		}

		[HarmonyPatch(typeof(BattleController), "Awake")]
		[HarmonyPostfix]
		public static void BattleController_Awake_Postfix()
		{
			TryRetry("BattleController");
		}

		private static void TryRetry(string reason)
		{
			if (IsEnabled() && _runStarted && _grantedThisRun.Count != OrbPrefabNames.Length)
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<IMultiplayerMode>(out var instance) && instance.IsHosting)
				{
					TryGrantPending(reason);
				}
			}
		}

		private static void TryGrantPending(string reason)
		{
			TryEnsureCustomOrbsBuilt();
			DeckManager[] array = Resources.FindObjectsOfTypeAll<DeckManager>();
			if (array == null || array.Length == 0)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[DebugDeck/" + reason + "] No DeckManager found — deferring debug orb grant"));
				}
				return;
			}
			DeckManager val = array[0];
			string[] orbPrefabNames = OrbPrefabNames;
			foreach (string text in orbPrefabNames)
			{
				if (_grantedThisRun.Contains(text))
				{
					continue;
				}
				GameObject val2 = FindOrbPrefab(text);
				if ((Object)(object)val2 == (Object)null)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)("[DebugDeck/" + reason + "] Prefab '" + text + "' not yet available — will retry"));
					}
					continue;
				}
				try
				{
					val.AddOrbToDeck(val2);
					_grantedThisRun.Add(text);
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogInfo((object)("[DebugDeck/" + reason + "] Granted '" + text + "' to host deck"));
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogWarning((object)("[DebugDeck/" + reason + "] AddOrbToDeck('" + text + "') failed: " + ex.Message));
					}
				}
			}
			if (_grantedThisRun.Count != OrbPrefabNames.Length)
			{
				return;
			}
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services != null && services.TryResolve<CoopStateManager>(out var instance))
				{
					instance?.SaveActivePlayerState();
				}
			}
			catch (Exception ex2)
			{
				ManualLogSource logger5 = MultiplayerPlugin.Logger;
				if (logger5 != null)
				{
					logger5.LogWarning((object)("[DebugDeck/" + reason + "] post-grant SaveActivePlayerState failed: " + ex2.Message));
				}
			}
		}

		private static bool IsEnabled()
		{
			string environmentVariable = Environment.GetEnvironmentVariable("MULTIPEGLIN_DEBUG");
			if (!(environmentVariable == "1"))
			{
				return string.Equals(environmentVariable, "true", StringComparison.OrdinalIgnoreCase);
			}
			return true;
		}

		private static void TryEnsureCustomOrbsBuilt()
		{
			try
			{
				(Type.GetType("Multipeglin.CustomOrbs.CustomOrbRegistry, Multipeglin.CustomOrbs")?.GetMethod("EnsureBuilt", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))?.Invoke(null, null);
			}
			catch (TargetInvocationException ex)
			{
				Exception ex2 = ex.InnerException ?? ex;
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)("[DebugDeck] CustomOrbRegistry.EnsureBuilt nudge failed: " + ex2.GetType().Name + ": " + ex2.Message + "\n" + ex2.StackTrace));
				}
			}
			catch (Exception arg)
			{
				ManualLogSource logger2 = MultiplayerPlugin.Logger;
				if (logger2 != null)
				{
					logger2.LogWarning((object)$"[DebugDeck] CustomOrbRegistry.EnsureBuilt nudge failed: {arg}");
				}
			}
		}

		private static GameObject FindOrbPrefab(string name)
		{
			return (from a in Resources.FindObjectsOfTypeAll<Attack>().Where(delegate(Attack a)
				{
					//IL_0035: Unknown result type (might be due to invalid IL or missing references)
					//IL_003a: Unknown result type (might be due to invalid IL or missing references)
					if ((Object)(object)a != (Object)null && (Object)(object)((Component)a).gameObject != (Object)null && ((Object)((Component)a).gameObject).name == name)
					{
						Scene scene = ((Component)a).gameObject.scene;
						return string.IsNullOrEmpty(((Scene)(ref scene)).name);
					}
					return false;
				})
				select ((Component)a).gameObject).FirstOrDefault();
		}
	}
}
namespace Multipeglin.Continue
{
	public static class ContinueCompatibility
	{
		public static readonly IReadOnlyDictionary<string, HashSet<string>> CONTINUE_COMPATIBILITY_LIST = new Dictionary<string, HashSet<string>>(StringComparer.Ordinal) { ["0.1.10"] = new HashSet<string>(StringComparer.Ordinal) { "0.1.8", "0.1.9" } };

		public static bool IsCompatible(string currentModVersion, string savedModVersion)
		{
			if (string.Equals(currentModVersion, savedModVersion, StringComparison.Ordinal))
			{
				return true;
			}
			if (string.IsNullOrEmpty(currentModVersion) || string.IsNullOrEmpty(savedModVersion))
			{
				return false;
			}
			if (CONTINUE_COMPATIBILITY_LIST.TryGetValue(currentModVersion, out var value) && value != null && value.Contains(savedModVersion))
			{
				return true;
			}
			return false;
		}
	}
	public static class ContinueFiles
	{
		public const string DIRECTORY_NAME = "continues";

		public const string FILE_PREFIX = "continue-";

		public const string FILE_SUFFIX = ".save";

		public static string ContinuesDirectory
		{
			get
			{
				string text = Path.Combine(Paths.PluginPath, "Multipeglin", "continues");
				try
				{
					Directory.CreateDirectory(text);
				}
				catch
				{
				}
				return text;
			}
		}

		public static string Sanitize(string playerName)
		{
			if (string.IsNullOrEmpty(playerName))
			{
				return "_";
			}
			StringBuilder stringBuilder = new StringBuilder(playerName.Length);
			foreach (char c in playerName)
			{
				if (char.IsLetterOrDigit(c))
				{
					stringBuilder.Append(c);
				}
				else
				{
					stringBuilder.Append('_');
				}
			}
			if (stringBuilder.Length != 0)
			{
				return stringBuilder.ToString();
			}
			return "_";
		}

		public static string BuildFileName(IEnumerable<string> playerNames, string seed)
		{
			if (playerNames == null)
			{
				playerNames = Array.Empty<string>();
			}
			List<string> list = playerNames.Select(Sanitize).OrderBy<string, string>((string n) => n, StringComparer.OrdinalIgnoreCase).ToList();
			string text = ((list.Count > 0) ? string.Join("-", list) : "_");
			string text2 = Sanitize(seed ?? "0");
			return "continue-" + text + "-" + text2 + ".save";
		}

		public static string BuildFilePath(IEnumerable<string> playerNames, string seed)
		{
			return Path.Combine(ContinuesDirectory, BuildFileName(playerNames, seed));
		}

		public static bool DeleteForRoster(IEnumerable<string> playerNames, string seed)
		{
			try
			{
				string path = BuildFilePath(playerNames, seed);
				if (File.Exists(path))
				{
					File.Delete(path);
					return true;
				}
			}
			catch
			{
			}
			return false;
		}

		public static void Write(string filePath, ContinueSaveData data)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_001a: Expected O, but got Unknown
			string contents = JsonConvert.SerializeObject((object)data, (Formatting)0, new JsonSerializerSettings
			{
				NullValueHandling = (NullValueHandling)0,
				DefaultValueHandling = (DefaultValueHandling)0
			});
			string text = filePath + ".tmp";
			File.WriteAllText(text, contents, Encoding.UTF8);
			if (File.Exists(filePath))
			{
				File.Delete(filePath);
			}
			File.Move(text, filePath);
		}

		public static ContinueSaveData Read(string filePath)
		{
			if (!File.Exists(filePath))
			{
				return null;
			}
			string text = File.ReadAllText(filePath, Encoding.UTF8);
			if (string.IsNullOrEmpty(text))
			{
				return null;
			}
			return JsonConvert.DeserializeObject<ContinueSaveData>(text);
		}

		public static IReadOnlyList<ContinueSaveEntry> ListUsableSaves(int maxCount, string requiredModVersion, string requiredGameVersion, string requiredHostName = null)
		{
			string continuesDirectory = ContinuesDirectory;
			if (!Directory.Exists(continuesDirectory))
			{
				return Array.Empty<ContinueSaveEntry>();
			}
			List<ContinueSaveEntry> list = new List<ContinueSaveEntry>();
			string[] files;
			try
			{
				files = Directory.GetFiles(continuesDirectory, "continue-*.save");
			}
			catch
			{
				return Array.Empty<ContinueSaveEntry>();
			}
			string[] array = files;
			foreach (string text in array)
			{
				ContinueSaveData continueSaveData;
				DateTime lastWriteTimeUtc;
				try
				{
					continueSaveData = Read(text);
					lastWriteTimeUtc = File.GetLastWriteTimeUtc(text);
				}
				catch
				{
					continue;
				}
				if (continueSaveData != null && continueSaveData.SchemaVersion == 1 && ContinueCompatibility.IsCompatible(requiredModVersion, continueSaveData.ModVersion) && string.Equals(continueSaveData.GameVersion, requiredGameVersion, StringComparison.Ordinal) && (string.IsNullOrEmpty(requiredHostName) || string.Equals(continueSaveData.Players?.FirstOrDefault((ContinuePlayer p) => p != null && p.SlotIndex == 0)?.PlayerName, requiredHostName, StringComparison.Ordinal)))
				{
					list.Add(new ContinueSaveEntry
					{
						FilePath = text,
						ModifiedUtc = lastWriteTimeUtc,
						Data = continueSaveData
					});
				}
			}
			list.Sort((ContinueSaveEntry a, ContinueSaveEntry b) => b.ModifiedUtc.CompareTo(a.ModifiedUtc));
			if (maxCount > 0 && list.Count > maxCount)
			{
				list = list.GetRange(0, maxCount);
			}
			return list;
		}
	}
	public sealed class ContinueSaveEntry
	{
		public string FilePath { get; set; }

		public DateTime ModifiedUtc { get; set; }

		public ContinueSaveData Data { get; set; }

		public string FileName => Path.GetFileName(FilePath);

		public string DisplayPlayerNames
		{
			get
			{
				if (Data?.Players == null || Data.Players.Count == 0)
				{
					return string.Empty;
				}
				List<string> list = new List<string>(Data.Players.Count);
				foreach (ContinuePlayer player in Data.Players)
				{
					list.Add(string.IsNullOrEmpty(player.PlayerName) ? $"slot {player.SlotIndex}" : player.PlayerName);
				}
				list.Sort(StringComparer.OrdinalIgnoreCase);
				return string.Join(", ", list);
			}
		}

		public string DisplayStageLabel => Data?.StageLabel ?? string.Empty;
	}
	public static class ContinueLoader
	{
		public static bool ApplyPending { get; private set; }

		public static bool LaunchScene(ContinueSaveData data)
		{
			//IL_0154: Unknown result type (might be due to invalid IL or missing references)
			//IL_01bf: Unknown result type (might be due to invalid IL or missing references)
			//IL_016e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0178: Expected O, but got Unknown
			if (data == null)
			{
				ManualLogSource logger = MultiplayerPlugin.Logger;
				if (logger != null)
				{
					logger.LogWarning((object)"[ContinueLoader] LaunchScene: null data");
				}
				return false;
			}
			try
			{
				if (!string.IsNullOrEmpty(data.GameRunSaveBase64))
				{
					int currentProfileIndex = DataSerializer.CurrentProfileIndex;
					string text = Path.Combine(Application.persistentDataPath, $"Save_{currentProfileIndex}r.data");
					byte[] array = Convert.FromBase64String(data.GameRunSaveBase64);
					File.WriteAllBytes(text, array);
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)$"[ContinueLoader] wrote {array.Length} bytes to {text}");
					}
					try
					{
						DataSerializer.LoadFile((SaveType)1);
					}
					catch (Exception ex)
					{
						ManualLogSource logger3 = MultiplayerPlugin.Logger;
						if (logger3 != null)
						{
							logger3.LogWarning((object)("[ContinueLoader] LoadFile(RUN) threw: " + ex.Message));
						}
					}
				}
				else
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogWarning((object)"[ContinueLoader] save has no GameRunSaveBase64 — game continue may fail");
					}
				}
				try
				{
					if (!string.IsNullOrEmpty(data.Seed))
					{
						StaticGameData.currentSeed = data.Seed;
					}
				}
				catch
				{
				}
				try
				{
					CruciballManager val = Resources.FindObjectsOfTypeAll<CruciballManager>()?.FirstOrDefault();
					if ((Object)(object)val != (Object)null && data.CruciballLevel >= 0)
					{
						val.currentCruciballLevel = data.CruciballLevel;
					}
				}
				catch
				{
				}
				LoadMapData val2 = Resources.FindObjectsOfTypeAll<LoadMapData>().FirstOrDefault();
				if ((Object)(object)val2 == (Object)null)
				{
					ManualLogSource logger5 = MultiplayerPlugin.Logger;
					if (logger5 != null)
					{
						logger5.LogWarning((object)"[ContinueLoader] no LoadMapData found in memory; cannot drive continue");
					}
					return false;
				}
				val2.SceneToLoad = (Scene)data.MapScene;
				val2.NewGame = false;
				val2.ContinueGame = true;
				try
				{
					if (StaticGameData.CurrentRunStats == null)
					{
						StaticGameData.CurrentRunStats = new RunStats();
					}
					else
					{
						StaticGameData.CurrentRunStats.Reset();
					}
				}
				catch
				{
				}
				ApplyPending = true;
				if ((Object)(object)PeglinSceneLoader.Instance != (Object)null)
				{
					PeglinSceneLoader.Instance.LoadScene((Scene)2, (LoadSceneMode)0, false, 0.5f);
					ManualLogSource logger6 = MultiplayerPlugin.Logger;
					if (logger6 != null)
					{
						logger6.LogInfo((object)$"[ContinueLoader] launched POST_MAIN_MENU → {val2.SceneToLoad}");
					}
					return true;
				}
				ManualLogSource logger7 = MultiplayerPlugin.Logger;
				if (logger7 != null)
				{
					logger7.LogWarning((object)"[ContinueLoader] PeglinSceneLoader.Instance is null");
				}
				return false;
			}
			catch (Exception arg)
			{
				ManualLogSource logger8 = MultiplayerPlugin.Logger;
				if (logger8 != null)
				{
					logger8.LogError((object)$"[ContinueLoader] LaunchScene failed: {arg}");
				}
				ApplyPending = false;
				return false;
			}
		}

		public static void ApplyPendingCoopState()
		{
			//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
			if (!ApplyPending)
			{
				return;
			}
			try
			{
				ContinueSaveData activeSave = ContinueSession.ActiveSave;
				if (activeSave == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogWarning((object)"[ContinueLoader] ApplyPending set but no ActiveSave");
					}
					ApplyPending = false;
					return;
				}
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<CoopStateManager>(out var instance) || instance == null)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogWarning((object)"[ContinueLoader] CoopStateManager unavailable, deferring");
					}
					return;
				}
				instance.PlayerStates.Clear();
				foreach (ContinuePlayer player in activeSave.Players)
				{
					if (player?.State != null)
					{
						player.State.SlotIndex = player.SlotIndex;
						if (string.IsNullOrEmpty(player.State.PlayerName))
						{
							player.State.PlayerName = player.PlayerName;
						}
						instance.PlayerStates[player.SlotIndex] = player.State;
					}
				}
				try
				{
					AccessTools.Property(typeof(CoopStateManager), "ActivePlayerSlot")?.SetValue(instance, 0);
				}
				catch
				{
				}
				try
				{
					if (instance.PlayerStates.ContainsKey(0))
					{
						instance.LoadPlayerState(0);
					}
				}
				catch (Exception ex)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)("[ContinueLoader] LoadPlayerState(0) threw: " + ex.Message));
					}
				}
				ManualLogSource logger4 = MultiplayerPlugin.Logger;
				if (logger4 != null)
				{
					logger4.LogInfo((object)$"[ContinueLoader] restored {instance.PlayerStates.Count} coop player states");
				}
				if (services.TryResolve<TurnManager>(out var instance2) && instance2 != null)
				{
					try
					{
						instance2.Reset();
						instance2.BuildTurnOrder();
					}
					catch (Exception ex2)
					{
						ManualLogSource logger5 = MultiplayerPlugin.Logger;
						if (logger5 != null)
						{
							logger5.LogWarning((object)("[ContinueLoader] turn rebuild failed: " + ex2.Message));
						}
					}
				}
				if (!string.IsNullOrEmpty(activeSave.RandomStateJson))
				{
					try
					{
						Random.state = JsonUtility.FromJson<State>(activeSave.RandomStateJson);
						ManualLogSource logger6 = MultiplayerPlugin.Logger;
						if (logger6 != null)
						{
							logger6.LogInfo((object)"[ContinueLoader] restored UnityEngine.Random.state");
						}
					}
					catch (Exception ex3)
					{
						ManualLogSource logger7 = MultiplayerPlugin.Logger;
						if (logger7 != null)
						{
							logger7.LogWarning((object)("[ContinueLoader] restore Random.state failed: " + ex3.Message));
						}
					}
				}
				ApplyPending = false;
			}
			catch (Exception arg)
			{
				ManualLogSource logger8 = MultiplayerPlugin.Logger;
				if (logger8 != null)
				{
					logger8.LogError((object)$"[ContinueLoader] ApplyPendingCoopState failed: {arg}");
				}
				ApplyPending = false;
			}
		}
	}
	public sealed class ContinueSaveData
	{
		public const int SCHEMA_VERSION_CURRENT = 1;

		public int SchemaVersion { get; set; } = 1;


		public string ModVersion { get; set; }

		public string GameVersion { get; set; }

		public string SavedAtUtc { get; set; }

		public string Seed { get; set; }

		public int CruciballLevel { get; set; }

		public int Act { get; set; }

		public int FloorCount { get; set; }

		public int MapScene { get; set; }

		public string StageLabel { get; set; }

		public List<ContinuePlayer> Players { get; set; } = new List<ContinuePlayer>();


		public ContinueTurnState TurnState { get; set; } = new ContinueTurnState();


		public string GameRunSaveBase64 { get; set; }

		public string RandomStateJson { get; set; }

		public DateTime ParsedSavedAt
		{
			get
			{
				if (DateTime.TryParse(SavedAtUtc, null, DateTimeStyles.RoundtripKind, out var result))
				{
					return result;
				}
				return DateTime.MinValue;
			}
		}
	}
	public sealed class ContinuePlayer
	{
		public int SlotIndex { get; set; }

		public string PlayerName { get; set; }

		public int ChosenClass { get; set; }

		public CoopPlayerState State { get; set; }
	}
	public sealed class ContinueTurnState
	{
		public List<int> TurnOrder { get; set; } = new List<int>();


		public int RoundNumber { get; set; }
	}
	public static class ContinueSaver
	{
		public static void Save(string reason)
		{
			//IL_0120: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected I4, but got Unknown
			//IL_029f: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				IServiceContainer services = MultiplayerPlugin.Services;
				if (services == null || !services.TryResolve<IMultiplayerMode>(out var instance) || !instance.IsHosting)
				{
					return;
				}
				if (!services.TryResolve<CoopStateManager>(out var instance2) || instance2 == null)
				{
					ManualLogSource logger = MultiplayerPlugin.Logger;
					if (logger != null)
					{
						logger.LogInfo((object)("[ContinueSaver] " + reason + ": CoopStateManager unavailable, skipping save"));
					}
					return;
				}
				if (instance2.PlayerStates.Count == 0)
				{
					ManualLogSource logger2 = MultiplayerPlugin.Logger;
					if (logger2 != null)
					{
						logger2.LogInfo((object)("[ContinueSaver] " + reason + ": no players in coop state, skipping save"));
					}
					return;
				}
				try
				{
					instance2.SaveActivePlayerState();
				}
				catch (Exception ex)
				{
					ManualLogSource logger3 = MultiplayerPlugin.Logger;
					if (logger3 != null)
					{
						logger3.LogWarning((object)("[ContinueSaver] SaveActivePlayerState threw: " + ex.Message));
					}
				}
				MapController instance3 = MapController.instance;
				int act = (((Object)(object)instance3 != (Object)null) ? instance3.Act : 0);
				int num = 0;
				int mapScene = 0;
				string mapNameLocKey = string.Empty;
				if ((Object)(object)instance3 != (Object)null)
				{
					try
					{
						num = (int)(AccessTools.Field(typeof(MapController), "floorCount")?.GetValue(instance3) ?? ((object)0));
					}
					catch
					{
					}
					try
					{
						mapScene = (int)instance3.thisScene;
					}
					catch
					{
					}
					mapNameLocKey = instance3.mapNameLocKey ?? string.Empty;
				}
				int num2 = 0;
				try
				{
					CruciballManager val = Resources.FindObjectsOfTypeAll<CruciballManager>()?.FirstOrDefault();
					if ((Object)(object)val != (Object)null)
					{
						num2 = val.currentCruciballLevel;
					}
				}
				catch
				{
				}
				string seed = StaticGameData.currentSeed ?? string.Empty;
				try
				{
					if ((Object)(object)instance3 != (Object)null && AccessTools.Field(typeof(MapController), "_nodes")?.GetValue(instance3) is MapNode[] array)
					{
						MapNode[] array2 = array;
						foreach (MapNode obj4 in array2)
						{
							if (obj4 != null)
							{
								obj4.SaveNode();
							}
						}
					}
					DataSerializer.SaveFile((SaveType)1);
				}
				catch (Exception ex2)
				{
					ManualLogSource logger4 = MultiplayerPlugin.Logger;
					if (logger4 != null)
					{
						logger4.LogWarning((object)("[ContinueSaver] Pre-read SaveRun failed: " + ex2.Message));
					}
				}
				string text = null;
				try
				{
					int currentProfileIndex = DataSerializer.CurrentProfileIndex;
					string text2 = Path.Combine(Application.persistentDataPath, $"Save_{currentProfileIndex}r.data");
					if (File.Exists(text2))
					{
						text = Convert.ToBase64String(File.ReadAllBytes(text2));
					}
					else
					{
						ManualLogSource logger5 = MultiplayerPlugin.Logger;
						if (logger5 != null)
						{
							logger5.LogWarning((object)("[ContinueSaver] " + reason + ": RUN save file not found at " + text2));
						}
					}
				}
				catch (Exception ex3)
				{
					ManualLogSource logger6 = MultiplayerPlugin.Logger;
					if (logger6 != null)
					{
						logger6.LogWarning((object)("[ContinueSaver] Failed to read RUN save bytes: " + ex3.Message));
					}
				}
				string text3 = BuildStageLabel(mapNameLocKey, act, num, num2);
				string randomStateJson = null;
				try
				{
					randomStateJson = JsonUtility.ToJson((object)Random.state);
				}
				catch (Exception ex4)
				{
					ManualLogSource logger7 = MultiplayerPlugin.Logger;
					if (logger7 != null)
					{
						logger7.LogWarning((object)("[ContinueSaver] capture Random.state failed: " + ex4.Message));
					}
				}
				ContinueSaveData continueSaveData = new ContinueSaveData
				{
					SchemaVersion = 1,
					ModVersion = "0.1.10",
					GameVersion = Application.version,
					SavedAtUtc = DateTime.UtcNow.ToString("o"),
					Seed = seed,
					CruciballLevel = num2,
					Act = act,
					FloorCount = num,
					MapScene = mapScene,
					StageLabel = text3,
					GameRunSaveBase64 = text,
					RandomStateJson = randomStateJson
				};
				foreach (KeyValuePair<int, CoopPlayerState> item in instance2.PlayerStates.OrderBy((KeyValuePair<int, CoopPlayerState> p) => p.Key))
				{
					continueSaveData.Players.Add(new ContinuePlayer
					{
						SlotIndex = item.Key,
						PlayerName = (item.Value.PlayerName ?? string.Empty),
						ChosenClass = item.Value.ChosenClass,
						State = item.Value
					});
				}
				if (services.TryResolve<TurnManager>(out var instance4) && instance4 != null)
				{
					continueSaveData.TurnState.TurnOrder = instance4.TurnOrder?.ToList() ?? new List<int>();
					continueSaveData.TurnState.RoundNumber = instance4.RoundNumber;
				}
				string text4 = ContinueFiles.BuildFilePath(continueSaveData.Players.Select((ContinuePlayer p) => p.PlayerName), seed);
				ContinueFiles.Write(text4, continueSaveData);
				ManualLogSource logger8 = MultiplayerPlugin.Logger;
				if (logger8 != null)
				{
					logger8.LogInfo((object)("[ContinueSaver] " + reason + ": wrote " + Path.GetFileName(text4) + " " + $"(players={continueSaveData.Players.Count}, stage='{text3}', runBytes={text?.Length ?? 0} b64)"));
				}
			}
			catch (Exception arg)
			{
				ManualLogSource logger9 = MultiplayerPlugin.Logger;
				if (logger9 != null)
				{
					logger9.LogError((object)$"[ContinueSaver] {reason} failed: {arg}");
				}
			}
		}

		private static string BuildStageLabel(string mapNameLocKey, int act, int floor, int cruciball)
		{
			string text = ResolveActName(mapNameLocKey, act);
			string text2 = ((floor > 0) ? $"{text}-{floor}" : text);
			if (cruciball <= 0)
			{
				return text2;
			}
			return $"{text2} Cruciball-{cruciball}";
		}

		private static string ResolveActName(string locKey, int act)
		{
			if (!string.IsNullOrEmpty(locKey))
			{
				try
				{
					string translation = LocalizationManager.GetTranslation(locKey, true, 0, true, false, (GameObject)null, (string)null, true);
					if (!string.IsNullOrEmpty(translation))
					{
						return translation;
					}
				}
				catch
				{
				}
			}
			if (act <= 0)
			{
				return "Act";
			}
			return $"Act-{act}";
		}
	}
	public static class ContinueSession
	{
		private static Dictionary<string, int> _expectedNameToSlot = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);

		public static ContinueSaveData ActiveSave { get; private set; }

		public static string ActiveSavePath { get; private set; }

		public static bool IsActive => ActiveSave != null;

		public static IReadOnlyCollection<string> ExpectedSanitizedNames => _expectedNameToSlot.Keys;

		public static int ExpectedPlayerCount => _expectedNameToSlot.Count;

		public static void Begin(ContinueSaveData data, string filePath)
		{
			ActiveSave = data ?? throw new ArgumentNullException("data");
			ActiveSavePath = filePath;
			_expectedNameToSlot = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
			if (data.Players == null)
			{
				return;
			}
			foreach (ContinuePlayer player in data.Players)
			{
				string key = ContinueFiles.Sanitize(player.PlayerName ?? string.Empty);
				_expectedNameToSlot[key] = player.SlotIndex;
			}
		}

		public static void Clear()
		{
			ActiveSave = null;
			ActiveSavePath = null;
			_expectedNameToSlot = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
		}

		public static int GetSlotForPlayer(string playerName)
		{
			if (!IsActive)
			{
				return -1;
			}
			string key = ContinueFiles.Sanitize(playerName ?? string.Empty);
			if (!_expectedNameToSlot.TryGetValue(key, out var value))
			{
				return -1;
			}
			return value;
		}

		public static bool IsExpected(string playerName)
		{
			return GetSlotForPlayer(playerName) >= 0;
		}

		public static int GetClassForPlayer(string playerName)
		{
			if (!IsActive || ActiveSave?.Players == null)
			{
				return 0;
			}
			string b = ContinueFiles.Sanitize(playerName ?? string.Empty);
			foreach (ContinuePlayer player in ActiveSave.Players)
			{
				if (string.Equals(ContinueFiles.Sanitize(player.PlayerName ?? string.Empty), b, StringComparison.OrdinalIgnoreCase))
				{
					return player.ChosenClass;
				}
			}
			return 0;
		}

		public static bool AllExpectedPlayersPresent(IEnumerable<string> presentNames)
		{
			if (!IsActive)
			{
				return true;
			}
			if (presentNames == null)
			{
				return _expectedNameToSlot.Count == 0;
			}
			HashSet<string> hashSet = new HashSet<string>(presentNames.Where((string n) => !string.IsNullOrEmpty(n)).Select(ContinueFiles.Sanitize), StringComparer.OrdinalIgnoreCase);
			return _expectedNameToSlot.Keys.All(hashSet.Contains);
		}
	}
}