using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using BepInEx;
using BepInEx.Bootstrap;
using BepInEx.Logging;
using DG.Tweening;
using DG.Tweening.Core;
using HarmonyLib;
using Lamb.UI;
using Lamb.UI.DeathScreen;
using Lamb.UI.FollowerInteractionWheel;
using Lamb.UI.KitchenMenu;
using Lamb.UI.PauseMenu;
using MMBiomeGeneration;
using MMTools;
using Rewired;
using Spine;
using Spine.Unity;
using TMPro;
using Unify;
using Unify.Input;
using UnityEngine;
using UnityEngine.AddressableAssets;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using src.UINavigator;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("ClassLibrary1")]
[assembly: AssemblyDescription("")]
[assembly: AssemblyConfiguration("")]
[assembly: AssemblyCompany("")]
[assembly: AssemblyProduct("ClassLibrary1")]
[assembly: AssemblyCopyright("Copyright ©  2026")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("b05729a9-afdc-413c-b90e-c3a9f2cd0a2c")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace COTLMultiplayerExpansion;

internal sealed class BuildingTransitionVote : MonoBehaviour
{
	private const float BaseCountdownSeconds = 10f;

	private static readonly MethodInfo BuildingTriggerMethod = AccessTools.Method(typeof(EnterBuilding), "OnTriggerEnter2D", new Type[1] { typeof(Collider2D) }, (Type[])null);

	private static readonly FieldInfo TriggeredField = AccessTools.Field(typeof(EnterBuilding), "_triggered");

	private static readonly FieldInfo DestinationField = AccessTools.Field(typeof(EnterBuilding), "Destination");

	private static BuildingTransitionVote _instance;

	private static EnterBuilding _replayingBuilding;

	private EnterBuilding _selectedBuilding;

	private Collider2D _initiatorCollider;

	private Vector3 _roomAnchor;

	private float _remaining;

	private float _nextBlockedLogAt;

	private int _initiatorSlot = -1;

	private bool _active;

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

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

	private Canvas _canvas;

	private TextMeshProUGUI _titleText;

	private TextMeshProUGUI _statusText;

	private TextMeshProUGUI _timerText;

	private RectTransform _progressFill;

	private Button _denyButton;

	internal static bool HasActiveVote
	{
		get
		{
			if ((Object)(object)_instance != (Object)null)
			{
				return _instance._active;
			}
			return false;
		}
	}

	internal static bool ShouldBlockBuildingTrigger(EnterBuilding building, Collider2D collision)
	{
		//IL_0063: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)building == (Object)null || (Object)(object)collision == (Object)null || !CoopManager.CoopActive || (Object)(object)_replayingBuilding == (Object)(object)building)
		{
			return false;
		}
		PlayerFarming val = ResolvePlayer(collision);
		if ((Object)(object)val == (Object)null || CountActivePlayers() <= 1)
		{
			return false;
		}
		BuildingTransitionVote buildingTransitionVote = EnsureRunner();
		if ((Object)(object)buildingTransitionVote == (Object)null)
		{
			return false;
		}
		if (DoorTransitionVote.HasActiveVote)
		{
			buildingTransitionVote.MovePlayerInside(building, val, ((Component)val).transform.position);
			return true;
		}
		return buildingTransitionVote.HandleBuildingTrigger(building, collision, val);
	}

	internal static bool BlockCompetingTrigger(Component transition, Collider2D collision)
	{
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		if (!HasActiveVote)
		{
			return false;
		}
		PlayerFarming val = ResolvePlayer(collision);
		if ((Object)(object)val != (Object)null)
		{
			_instance.MovePlayerInside(_instance._selectedBuilding, val, _instance._roomAnchor);
		}
		if (Time.unscaledTime >= _instance._nextBlockedLogAt)
		{
			_instance._nextBlockedLogAt = Time.unscaledTime + 1f;
			Plugin.Log.LogInfo((object)"[RoomVote] Blocked another transition while the temple/building vote was active.");
		}
		return true;
	}

	internal static void EmergencyCancel()
	{
		if (HasActiveVote)
		{
			_instance.CancelVote("emergency exit");
		}
	}

	private static BuildingTransitionVote EnsureRunner()
	{
		if ((Object)(object)_instance != (Object)null)
		{
			return _instance;
		}
		if ((Object)(object)CoopManager.Instance == (Object)null || (Object)(object)((Component)CoopManager.Instance).gameObject == (Object)null)
		{
			return null;
		}
		_instance = ((Component)CoopManager.Instance).gameObject.GetComponent<BuildingTransitionVote>();
		if ((Object)(object)_instance == (Object)null)
		{
			_instance = ((Component)CoopManager.Instance).gameObject.AddComponent<BuildingTransitionVote>();
		}
		return _instance;
	}

	private void OnDestroy()
	{
		TransitionVotePlayerState.RestoreAll();
		DestroyVoteUI();
		if ((Object)(object)_instance == (Object)(object)this)
		{
			_instance = null;
		}
	}

	private bool HandleBuildingTrigger(EnterBuilding building, Collider2D collision, PlayerFarming player)
	{
		//IL_0010: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0095: 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 (MMTransition.IsPlaying)
		{
			MovePlayerInside(building, player, ((Component)player).transform.position);
			return true;
		}
		if (IsBlockingCinematicActive())
		{
			MovePlayerInside(building, player, ((Component)player).transform.position);
			return true;
		}
		if (GetTriggered(building))
		{
			return false;
		}
		if (!_active)
		{
			if (TransitionVotePlayerState.IsInitiatorBlocked(player, out var _))
			{
				MovePlayerInside(building, player, ((Component)player).transform.position);
				return true;
			}
			BeginVote(building, collision, player);
			return true;
		}
		if ((Object)(object)_selectedBuilding == (Object)(object)building)
		{
			RegisterEntry(player);
			EvaluateFullyResolvedVote();
			return true;
		}
		MovePlayerInside(building, player, _roomAnchor);
		if (Time.unscaledTime >= _nextBlockedLogAt)
		{
			_nextBlockedLogAt = Time.unscaledTime + 1f;
			Plugin.Log.LogInfo((object)"[RoomVote] Blocked a different building entrance while a vote was active.");
		}
		return true;
	}

	private static bool IsBlockingCinematicActive()
	{
		try
		{
			if (LetterBox.IsPlaying)
			{
				return true;
			}
			return MMConversation.isPlaying && !MMConversation.isBark;
		}
		catch
		{
			return false;
		}
	}

	private void BeginVote(EnterBuilding building, Collider2D collision, PlayerFarming initiator)
	{
		//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)
		_selectedBuilding = building;
		_initiatorCollider = collision;
		_roomAnchor = ((Component)initiator).transform.position;
		_initiatorSlot = Mathf.Clamp(initiator.playerID, 0, 7);
		_remaining = 10f;
		_enteredPlayers.Clear();
		_deniedPlayers.Clear();
		_active = true;
		RegisterEntry(initiator);
		CreateVoteUI();
		RefreshVoteUI();
		Plugin.Log.LogInfo((object)$"[RoomVote] P{initiator.playerID + 1} started {GetBuildingLabel(building)} vote ({CountActivePlayers()} active players).");
	}

	private void RegisterEntry(PlayerFarming player)
	{
		if (!((Object)(object)player == (Object)null))
		{
			int num = Mathf.Clamp(player.playerID, 0, 7);
			bool num2 = _enteredPlayers.Add(num);
			_deniedPlayers.Remove(num);
			if (num2)
			{
				TransitionVotePlayerState.Hide(player);
				Plugin.Log.LogInfo((object)$"[RoomVote] P{num + 1} entered the selected building door; countdown speed is now x{GetCountdownSpeed():0.0}.");
			}
		}
	}

	private void Update()
	{
		if (!_active)
		{
			return;
		}
		if ((Object)(object)_selectedBuilding == (Object)null || (Object)(object)((Component)_selectedBuilding).gameObject == (Object)null || !((Component)_selectedBuilding).gameObject.activeInHierarchy)
		{
			CancelVote("selected building door disappeared");
			return;
		}
		if (MMTransition.IsPlaying)
		{
			ClearVoteState(restoreHiddenPlayers: true);
			return;
		}
		EvaluateFullyResolvedVote();
		if (!_active)
		{
			return;
		}
		PollDenyInputs();
		if (_active)
		{
			_remaining -= Time.unscaledDeltaTime * GetCountdownSpeed();
			RefreshVoteUI();
			if (_remaining <= 0f)
			{
				ResolveTimedVote();
			}
		}
	}

	private void PollDenyInputs()
	{
		foreach (PlayerFarming activePlayer in GetActivePlayers())
		{
			if (_enteredPlayers.Contains(activePlayer.playerID))
			{
				continue;
			}
			try
			{
				if (InputManager.Gameplay.GetHeavyAttackButtonDown(activePlayer))
				{
					ToggleDeny(activePlayer);
					if (!_active)
					{
						break;
					}
				}
			}
			catch
			{
			}
		}
	}

	private void ToggleDeny(PlayerFarming player)
	{
		if (!_active || (Object)(object)player == (Object)null)
		{
			return;
		}
		int num = Mathf.Clamp(player.playerID, 0, 7);
		if (!_enteredPlayers.Contains(num))
		{
			if (_deniedPlayers.Contains(num))
			{
				_deniedPlayers.Remove(num);
				Plugin.Log.LogInfo((object)$"[RoomVote] P{num + 1} withdrew DENY ENTRY.");
			}
			else
			{
				_deniedPlayers.Add(num);
				Plugin.Log.LogInfo((object)$"[RoomVote] P{num + 1} voted DENY ENTRY.");
			}
			RefreshVoteUI();
			EvaluateFullyResolvedVote();
		}
	}

	private void EvaluateFullyResolvedVote()
	{
		if (_active)
		{
			int num = CountActivePlayers();
			int num2 = CountActiveVotes(_enteredPlayers);
			int num3 = CountActiveVotes(_deniedPlayers);
			if (num2 >= num)
			{
				CommitVote("everyone entered");
			}
			else if (num3 > num2)
			{
				CancelVote("DENY votes exceeded entered players", applyInitiatorCooldown: true);
			}
			else if (num2 + num3 >= num)
			{
				CommitVote("all players resolved without DENY exceeding entry");
			}
		}
	}

	private void ResolveTimedVote()
	{
		int num = CountActiveVotes(_enteredPlayers);
		if (CountActiveVotes(_deniedPlayers) > num)
		{
			CancelVote("timer expired with DENY exceeding entry", applyInitiatorCooldown: true);
		}
		else
		{
			CommitVote("timer expired without DENY exceeding entry");
		}
	}

	private void CommitVote(string reason)
	{
		if (!_active)
		{
			return;
		}
		EnterBuilding selectedBuilding = _selectedBuilding;
		Collider2D val = FindReplayCollider();
		int num = CountActiveVotes(_enteredPlayers);
		int num2 = CountActiveVotes(_deniedPlayers);
		Plugin.Log.LogInfo((object)$"[RoomVote] BUILDING ENTRY APPROVED ({num} entered, {num2} denied): {reason}.");
		TransitionVotePlayerState.PrepareForApprovedTransition();
		ClearVoteState();
		if ((Object)(object)selectedBuilding == (Object)null || (Object)(object)val == (Object)null || BuildingTriggerMethod == null)
		{
			Plugin.Log.LogWarning((object)"[RoomVote] Approved building entry could not replay safely.");
			SetTriggered(selectedBuilding, value: false);
			TransitionVotePlayerState.RestoreAll();
			return;
		}
		try
		{
			_replayingBuilding = selectedBuilding;
			BuildingTriggerMethod.Invoke(selectedBuilding, new object[1] { val });
		}
		catch (Exception exception)
		{
			SetTriggered(selectedBuilding, value: false);
			try
			{
				PlayerFarming.SetCollidersActive(true, false);
			}
			catch
			{
			}
			Plugin.Log.LogWarning((object)("[RoomVote] Approved building replay failed: " + GetInnermostMessage(exception)));
			TransitionVotePlayerState.RestoreAll();
		}
		finally
		{
			_replayingBuilding = null;
		}
		((MonoBehaviour)this).StartCoroutine(RestoreHiddenPlayersAfterTransition());
	}

	private void CancelVote(string reason, bool applyInitiatorCooldown = false)
	{
		if (_active)
		{
			int num = CountActiveVotes(_enteredPlayers);
			int num2 = CountActiveVotes(_deniedPlayers);
			EnterBuilding building = _selectedBuilding;
			int initiatorSlot = _initiatorSlot;
			Plugin.Log.LogInfo((object)$"[RoomVote] BUILDING ENTRY DENIED ({num} entered, {num2} denied): {reason}.");
			SetTriggered(building, value: false);
			TransitionVotePlayerState.RestoreAndSpread(delegate(PlayerFarming player)
			{
				//IL_0013: Unknown result type (might be due to invalid IL or missing references)
				MovePlayerInside(building, player, _roomAnchor);
			});
			if (applyInitiatorCooldown)
			{
				TransitionVotePlayerState.BlockDeniedInitiator(initiatorSlot);
			}
			ClearVoteState();
		}
	}

	private void ClearVoteState(bool restoreHiddenPlayers = false)
	{
		if (restoreHiddenPlayers)
		{
			TransitionVotePlayerState.RestoreAll();
		}
		_active = false;
		_selectedBuilding = null;
		_initiatorCollider = null;
		_initiatorSlot = -1;
		_enteredPlayers.Clear();
		_deniedPlayers.Clear();
		DestroyVoteUI();
	}

	private IEnumerator RestoreHiddenPlayersAfterTransition()
	{
		float transitionStartDeadline = Time.unscaledTime + 0.6f;
		while (!MMTransition.IsPlaying && Time.unscaledTime < transitionStartDeadline)
		{
			yield return null;
		}
		float transitionEndDeadline = Time.unscaledTime + 12f;
		while (MMTransition.IsPlaying && Time.unscaledTime < transitionEndDeadline)
		{
			yield return null;
		}
		TransitionVotePlayerState.RestoreAll();
	}

	private Collider2D FindReplayCollider()
	{
		if ((Object)(object)_initiatorCollider != (Object)null && (Object)(object)ResolvePlayer(_initiatorCollider) != (Object)null)
		{
			return _initiatorCollider;
		}
		foreach (PlayerFarming activePlayer in GetActivePlayers())
		{
			Collider2D component = ((Component)activePlayer).GetComponent<Collider2D>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
		}
		return null;
	}

	private float GetCountdownSpeed()
	{
		int num = Mathf.Max(1, CountActiveVotes(_enteredPlayers));
		return 1f + 0.5f * (float)(num - 1);
	}

	private static int CountActiveVotes(HashSet<int> votes)
	{
		int num = 0;
		foreach (PlayerFarming activePlayer in GetActivePlayers())
		{
			if (votes.Contains(activePlayer.playerID))
			{
				num++;
			}
		}
		return num;
	}

	private static int CountActivePlayers()
	{
		return GetActivePlayers().Count;
	}

	private static List<PlayerFarming> GetActivePlayers()
	{
		List<PlayerFarming> list = new List<PlayerFarming>();
		HashSet<int> hashSet = new HashSet<int>();
		if (PlayerFarming.players == null)
		{
			return list;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player != (Object)null && player.playerID >= 0 && player.playerID < 8 && (Object)(object)((Component)player).gameObject != (Object)null && ((Component)player).gameObject.activeInHierarchy && hashSet.Add(player.playerID))
			{
				list.Add(player);
			}
		}
		return list;
	}

	private static PlayerFarming ResolvePlayer(Collider2D collision)
	{
		if ((Object)(object)collision == (Object)null)
		{
			return null;
		}
		PlayerFarming val = ((Component)collision).gameObject.GetComponent<PlayerFarming>();
		if ((Object)(object)val == (Object)null)
		{
			val = ((Component)collision).gameObject.GetComponentInParent<PlayerFarming>();
		}
		return val;
	}

	private void MovePlayerInside(EnterBuilding building, PlayerFarming player, Vector3 roomAnchor)
	{
		//IL_0014: 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_003a: 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_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		//IL_007a: 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_00b8: 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_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_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Invalid comparison between Unknown and I4
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Invalid comparison between Unknown and I4
		if ((Object)(object)building == (Object)null || (Object)(object)player == (Object)null)
		{
			return;
		}
		try
		{
			Vector3 val = roomAnchor - ((Component)building).transform.position;
			if (((Vector3)(ref val)).sqrMagnitude < 0.04f)
			{
				val = ((Component)player).transform.position - ((Component)building).transform.position;
			}
			if (((Vector3)(ref val)).sqrMagnitude < 0.04f)
			{
				val = Vector3.down;
			}
			val.z = 0f;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(0f - normalized.y, normalized.x, 0f);
			float num = ((float)Mathf.Clamp(player.playerID, 0, 7) - 3.5f) * 0.28f;
			((Component)player).transform.position = ((Component)building).transform.position + normalized * 2.25f + val2 * num;
			if ((Object)(object)player.state != (Object)null)
			{
				player.state.LockStateChanges = false;
				if ((int)player.state.CURRENT_STATE == 13 || (int)player.state.CURRENT_STATE == 24)
				{
					player.state.CURRENT_STATE = (State)0;
				}
			}
		}
		catch
		{
		}
	}

	private static bool GetTriggered(EnterBuilding building)
	{
		try
		{
			return (Object)(object)building != (Object)null && TriggeredField != null && Convert.ToBoolean(TriggeredField.GetValue(building));
		}
		catch
		{
			return false;
		}
	}

	private static void SetTriggered(EnterBuilding building, bool value)
	{
		try
		{
			if ((Object)(object)building != (Object)null && TriggeredField != null)
			{
				TriggeredField.SetValue(building, value);
			}
		}
		catch
		{
		}
	}

	private void CreateVoteUI()
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Expected O, but got Unknown
		//IL_009d: 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_00dc: Expected O, but got Unknown
		//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_013e: 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_01b2: 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_01d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e7: 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_022f: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: 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_0286: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b8: 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_02f2: Expected O, but got Unknown
		//IL_0315: Unknown result type (might be due to invalid IL or missing references)
		//IL_032a: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		//IL_038c: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c1: Expected O, but got Unknown
		//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0409: Unknown result type (might be due to invalid IL or missing references)
		//IL_0423: Unknown result type (might be due to invalid IL or missing references)
		//IL_0433: Unknown result type (might be due to invalid IL or missing references)
		//IL_044d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0471: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b4: Expected O, but got Unknown
		//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ee: 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_0518: Unknown result type (might be due to invalid IL or missing references)
		//IL_052c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0555: Unknown result type (might be due to invalid IL or missing references)
		//IL_057f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0584: Unknown result type (might be due to invalid IL or missing references)
		//IL_0594: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ab: Expected O, but got Unknown
		//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c7: Expected O, but got Unknown
		//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0605: Unknown result type (might be due to invalid IL or missing references)
		DestroyVoteUI();
		GameObject val = new GameObject("COTLMP Building Vote Canvas", new Type[4]
		{
			typeof(RectTransform),
			typeof(Canvas),
			typeof(CanvasScaler),
			typeof(GraphicRaycaster)
		});
		val.transform.SetParent(((Component)this).transform, false);
		_canvas = val.GetComponent<Canvas>();
		_canvas.renderMode = (RenderMode)0;
		_canvas.sortingOrder = 32700;
		CanvasScaler component = val.GetComponent<CanvasScaler>();
		component.uiScaleMode = (ScaleMode)1;
		component.referenceResolution = new Vector2(1920f, 1080f);
		component.matchWidthOrHeight = 0.5f;
		GameObject val2 = new GameObject("Building Vote Panel", new Type[2]
		{
			typeof(RectTransform),
			typeof(Image)
		});
		val2.transform.SetParent(val.transform, false);
		RectTransform component2 = val2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(1f, 0f);
		component2.anchorMax = new Vector2(1f, 0f);
		component2.pivot = new Vector2(1f, 0f);
		component2.anchoredPosition = new Vector2(-14f, 14f);
		component2.sizeDelta = new Vector2(350f, 101f);
		Image component3 = val2.GetComponent<Image>();
		component3.sprite = TransitionVoteSkin.GetPanelSprite();
		component3.preserveAspect = true;
		((Graphic)component3).color = (((Object)(object)component3.sprite != (Object)null) ? new Color(1f, 1f, 1f, 0.88f) : new Color(0.018f, 0.015f, 0.013f, 0.76f));
		((Graphic)component3).raycastTarget = false;
		_titleText = CreateText(val2.transform, "Vote Title", new Vector2(67f, -12f), new Vector2(194f, 29f), 20f, (TextAlignmentOptions)513, new Color(0.96f, 0.9f, 0.74f, 1f));
		_timerText = CreateText(val2.transform, "Vote Timer", new Vector2(278f, -12f), new Vector2(52f, 29f), 21f, (TextAlignmentOptions)516, new Color(1f, 0.8f, 0.24f, 1f));
		_statusText = CreateText(val2.transform, "Vote Status", new Vector2(67f, -43f), new Vector2(260f, 20f), 14f, (TextAlignmentOptions)513, new Color(0.88f, 0.86f, 0.78f, 1f));
		GameObject val3 = new GameObject("Vote Timer Track", new Type[2]
		{
			typeof(RectTransform),
			typeof(Image)
		});
		val3.transform.SetParent(val2.transform, false);
		RectTransform component4 = val3.GetComponent<RectTransform>();
		component4.anchorMin = new Vector2(0f, 1f);
		component4.anchorMax = new Vector2(0f, 1f);
		component4.pivot = new Vector2(0f, 1f);
		component4.anchoredPosition = new Vector2(67f, -78f);
		component4.sizeDelta = new Vector2(104f, 3f);
		((Graphic)val3.GetComponent<Image>()).color = new Color(0.21f, 0.17f, 0.14f, 0.72f);
		GameObject val4 = new GameObject("Vote Timer Fill", new Type[2]
		{
			typeof(RectTransform),
			typeof(Image)
		});
		val4.transform.SetParent(val3.transform, false);
		_progressFill = val4.GetComponent<RectTransform>();
		_progressFill.anchorMin = new Vector2(0f, 0f);
		_progressFill.anchorMax = new Vector2(0f, 1f);
		_progressFill.pivot = new Vector2(0f, 0.5f);
		_progressFill.anchoredPosition = Vector2.zero;
		_progressFill.sizeDelta = new Vector2(104f, 0f);
		((Graphic)val4.GetComponent<Image>()).color = new Color(0.82f, 0.035f, 0.025f, 1f);
		GameObject val5 = new GameObject("Deny Entry Button", new Type[3]
		{
			typeof(RectTransform),
			typeof(Image),
			typeof(Button)
		});
		val5.transform.SetParent(val2.transform, false);
		RectTransform component5 = val5.GetComponent<RectTransform>();
		component5.anchorMin = new Vector2(0f, 1f);
		component5.anchorMax = new Vector2(0f, 1f);
		component5.pivot = new Vector2(0f, 1f);
		component5.anchoredPosition = new Vector2(242f, -65f);
		component5.sizeDelta = new Vector2(88f, 25f);
		Image component6 = val5.GetComponent<Image>();
		((Graphic)component6).color = new Color(0.58f, 0.035f, 0.025f, 0.94f);
		_denyButton = val5.GetComponent<Button>();
		((Selectable)_denyButton).targetGraphic = (Graphic)(object)component6;
		Navigation navigation = ((Selectable)_denyButton).navigation;
		((Navigation)(ref navigation)).mode = (Mode)0;
		((Selectable)_denyButton).navigation = navigation;
		_denyButton.onClick = new ButtonClickedEvent();
		((UnityEvent)_denyButton.onClick).AddListener((UnityAction)delegate
		{
			PlayerFarming val6 = FindPlayerBySlot(0);
			if ((Object)(object)val6 != (Object)null)
			{
				ToggleDeny(val6);
			}
		});
		((TMP_Text)CreateText(val5.transform, "Deny Entry Label", Vector2.zero, new Vector2(88f, 25f), 13f, (TextAlignmentOptions)514, new Color(1f, 0.93f, 0.8f, 1f))).text = "RT  DENY";
	}

	private void RefreshVoteUI()
	{
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		if (_active && !((Object)(object)_titleText == (Object)null) && !((Object)(object)_statusText == (Object)null) && !((Object)(object)_timerText == (Object)null))
		{
			int num = CountActivePlayers();
			int num2 = CountActiveVotes(_enteredPlayers);
			int num3 = CountActiveVotes(_deniedPlayers);
			((TMP_Text)_titleText).text = GetBuildingLabel(_selectedBuilding);
			((TMP_Text)_timerText).text = Mathf.CeilToInt(Mathf.Max(0f, _remaining)).ToString();
			((TMP_Text)_statusText).text = "READY  " + num2 + "/" + num + "        NO  " + num3;
			if ((Object)(object)_progressFill != (Object)null)
			{
				_progressFill.sizeDelta = new Vector2(104f * Mathf.Clamp01(_remaining / 10f), 0f);
			}
		}
	}

	private static TextMeshProUGUI CreateText(Transform parent, string name, Vector2 anchoredPosition, Vector2 size, float fontSize, TextAlignmentOptions alignment, Color color)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: 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_0079: 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_009e: 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_00ae: 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)
		GameObject val = new GameObject(name, new Type[2]
		{
			typeof(RectTransform),
			typeof(TextMeshProUGUI)
		});
		val.transform.SetParent(parent, false);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0f, 1f);
		component.anchorMax = new Vector2(0f, 1f);
		component.pivot = new Vector2(0f, 1f);
		component.anchoredPosition = anchoredPosition;
		component.sizeDelta = size;
		TextMeshProUGUI component2 = val.GetComponent<TextMeshProUGUI>();
		((TMP_Text)component2).font = TMP_Settings.defaultFontAsset;
		((TMP_Text)component2).fontSize = fontSize;
		((TMP_Text)component2).alignment = alignment;
		((Graphic)component2).color = color;
		((TMP_Text)component2).outlineColor = Color32.op_Implicit(Color.black);
		((TMP_Text)component2).outlineWidth = 0.16f;
		((Graphic)component2).raycastTarget = false;
		return component2;
	}

	private void DestroyVoteUI()
	{
		if ((Object)(object)_canvas != (Object)null && (Object)(object)((Component)_canvas).gameObject != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_canvas).gameObject);
		}
		_canvas = null;
		_titleText = null;
		_statusText = null;
		_timerText = null;
		_progressFill = null;
		_denyButton = null;
	}

	private static PlayerFarming FindPlayerBySlot(int slot)
	{
		foreach (PlayerFarming activePlayer in GetActivePlayers())
		{
			if (activePlayer.playerID == slot)
			{
				return activePlayer;
			}
		}
		return null;
	}

	private static string GetBuildingLabel(EnterBuilding building)
	{
		try
		{
			object obj = DestinationField?.GetValue(building);
			string text = ((obj != null) ? obj.ToString() : string.Empty);
			if (!string.IsNullOrEmpty(text) && !char.IsDigit(text[0]))
			{
				return text.ToUpperInvariant() + " ENTRY";
			}
		}
		catch
		{
		}
		try
		{
			if (((object)Unsafe.As<FollowerLocation, FollowerLocation>(ref PlayerFarming.Location)/*cast due to .constrained prefix*/).ToString().IndexOf("Church", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return "CULT ENTRY";
			}
		}
		catch
		{
		}
		return "TEMPLE ENTRY";
	}

	private static string GetInnermostMessage(Exception exception)
	{
		Exception ex = exception;
		while (ex != null && ex.InnerException != null)
		{
			ex = ex.InnerException;
		}
		if (ex == null)
		{
			return "unknown error";
		}
		return ex.GetType().Name + ": " + ex.Message;
	}
}
internal static class CoopConversationSession
{
	private static readonly Dictionary<int, State> StateSnapshot = new Dictionary<int, State>();

	private static PlayerFarming _owner;

	private static bool _active;

	private static bool _lockOwner;

	private static float _restoreOthersUntil;

	private static float _postCloseRecoveryUntil = -100f;

	private static float _townEventRecoveryUntil = -100f;

	private static float _nextPresentationRecoveryAt = -100f;

	private static float _activeSince = -100f;

	private static int _generation;

	public static bool Active => _active;

	public static PlayerFarming Owner => _owner;

	public static bool AllowAnyPlayerAdvance
	{
		get
		{
			if (_active)
			{
				return IsChurchLocation();
			}
			return false;
		}
	}

	public static bool KeepInputWithOwner(UINavigatorNew navigator)
	{
		if (!_active || (Object)(object)navigator == (Object)null)
		{
			return false;
		}
		if (AllowAnyPlayerAdvance)
		{
			return false;
		}
		if ((Object)(object)_owner == (Object)null || (Object)(object)((Component)_owner).gameObject == (Object)null || !((Component)_owner).gameObject.activeInHierarchy)
		{
			_owner = PlayerFarming.Instance;
		}
		if ((Object)(object)_owner != (Object)null && (Object)(object)navigator.AllowInputOnlyFromPlayer != (Object)(object)_owner)
		{
			navigator.AllowInputOnlyFromPlayer = _owner;
		}
		return (Object)(object)_owner != (Object)null;
	}

	public static void Prepare(bool setPlayerInactive)
	{
		//IL_0014: 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 (PlayerFarming.players == null || PlayerFarming.players.Count <= 1 || GameManager.IsDungeon(PlayerFarming.Location))
		{
			return;
		}
		if (_active)
		{
			EndSession(_generation);
		}
		_generation++;
		_owner = CoopMenuOverlaySession.ResolveRecentOwner(2.5f);
		if ((Object)(object)_owner == (Object)null)
		{
			_owner = PlayerFarming.Instance;
		}
		if ((Object)(object)_owner == (Object)null)
		{
			return;
		}
		StateSnapshot.Clear();
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player != (Object)null && (Object)(object)player.state != (Object)null)
			{
				StateSnapshot[player.playerID] = player.state.CURRENT_STATE;
			}
		}
		_lockOwner = setPlayerInactive;
		_active = true;
		_restoreOthersUntil = Time.unscaledTime + 1f;
	}

	public static void Activate()
	{
		if (_active && !((Object)(object)_owner == (Object)null))
		{
			SimulationManager.UnPause();
			Time.timeScale = 1f;
			_activeSince = Time.unscaledTime;
			RestoreNonOwnerPlayers();
			if (_lockOwner && (Object)(object)_owner.state != (Object)null)
			{
				_owner.SetInactive();
			}
			RestoreWorldPresentation();
			Plugin.Log.LogInfo((object)$"[QoL] Opened non-blocking NPC conversation for player {_owner.playerID + 1}");
		}
	}

	public static void Tick()
	{
		if (_active)
		{
			if (IsChurchLocation() && Time.unscaledTime - _activeSince >= 20f && MMConversation.isPlaying)
			{
				Plugin.Log.LogWarning((object)"[QoL] Church conversation exceeded 20 seconds; closing it to prevent a permanent temple lock.");
				CoopEmergencyEscape.TryForceCloseConversation("church conversation watchdog");
				EmergencyRecoverAll();
				return;
			}
			KeepInputWithOwner(MonoSingleton<UINavigatorNew>.Instance);
			if (Time.unscaledTime <= _restoreOthersUntil)
			{
				RestoreNonOwnerPlayers();
			}
			TryRestoreWorldPresentation();
		}
		else if (Time.unscaledTime <= _postCloseRecoveryUntil || Time.unscaledTime <= _townEventRecoveryUntil)
		{
			RecoverAllPlayersAfterConversation();
			TryRestoreWorldPresentation();
		}
	}

	public static void BeginTownEventRecovery(float duration, string reason)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		if (!GameManager.IsDungeon(PlayerFarming.Location) && PlayerFarming.players != null && PlayerFarming.players.Count > 1)
		{
			_townEventRecoveryUntil = Mathf.Max(_townEventRecoveryUntil, Time.unscaledTime + Mathf.Max(0.5f, duration));
			RecoverAllPlayersAfterConversation();
			RestoreWorldPresentation();
			Plugin.Log.LogInfo((object)("[QoL] Armed town event movement/camera recovery: " + reason));
		}
	}

	public static int CaptureGeneration()
	{
		return _generation;
	}

	public static void EndSession(int expectedGeneration)
	{
		if (_active && expectedGeneration == _generation)
		{
			_active = false;
			_postCloseRecoveryUntil = Time.unscaledTime + 1.25f;
			RecoverAllPlayersAfterConversation();
			RestoreWorldPresentation();
			Plugin.Log.LogInfo((object)"[QoL] Closed non-blocking NPC conversation");
			_owner = null;
			_lockOwner = false;
			_activeSince = -100f;
			StateSnapshot.Clear();
		}
	}

	public static void ForceEndSession()
	{
		EndSession(_generation);
	}

	public static void EmergencyRecoverAll()
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		_active = false;
		_owner = null;
		_lockOwner = false;
		_activeSince = -100f;
		StateSnapshot.Clear();
		_postCloseRecoveryUntil = Time.unscaledTime + 2f;
		if (!GameManager.IsDungeon(PlayerFarming.Location))
		{
			RecoverAllPlayersAfterConversation();
			RestoreWorldPresentation();
		}
	}

	private static void RestoreNonOwnerPlayers()
	{
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Invalid comparison between Unknown and I4
		//IL_006f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Invalid comparison between Unknown and I4
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		if (PlayerFarming.players == null)
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player == (Object)(object)_owner) && !TransitionVotePlayerState.IsHidden(player) && !((Object)(object)player.state == (Object)null) && (int)player.state.CURRENT_STATE == 13)
			{
				if (StateSnapshot.TryGetValue(player.playerID, out var value) && (int)value != 13)
				{
					player.state.LockStateChanges = false;
					player.state.CURRENT_STATE = value;
				}
				else
				{
					player.state.LockStateChanges = false;
					player.state.CURRENT_STATE = (State)0;
				}
			}
		}
	}

	private static void RecoverAllPlayersAfterConversation()
	{
		//IL_0007: 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_007c: Invalid comparison between Unknown and I4
		if (PlayerFarming.players == null || GameManager.IsDungeon(PlayerFarming.Location))
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)((Component)player).gameObject == (Object)null) && ((Component)player).gameObject.activeInHierarchy && !TransitionVotePlayerState.IsHidden(player) && !((Object)(object)player.state == (Object)null))
			{
				player.state.LockStateChanges = false;
				if ((int)player.state.CURRENT_STATE == 13)
				{
					player.state.CURRENT_STATE = (State)0;
				}
			}
		}
		UINavigatorNew instance = MonoSingleton<UINavigatorNew>.Instance;
		if ((Object)(object)instance != (Object)null)
		{
			instance.AllowInputOnlyFromPlayer = PlayerFarming.Instance;
		}
	}

	private static void RestoreWorldPresentation()
	{
		//IL_00a9: 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_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_0057: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			SimulationManager.UnPause();
			Time.timeScale = 1f;
			GameManager instance = GameManager.GetInstance();
			if ((Object)(object)instance != (Object)null)
			{
				CameraFollowTarget camFollowTarget = instance.CamFollowTarget;
				if ((Object)(object)camFollowTarget != (Object)null)
				{
					camFollowTarget.DisablePlayerLook = false;
					camFollowTarget.IN_CONVERSATION = false;
					camFollowTarget.SnappyMovement = false;
					camFollowTarget.SetOffset(Vector3.zero);
					camFollowTarget.CurrentOffset = Vector3.zero;
					camFollowTarget.targetDistance = Mathf.Max(camFollowTarget.targetDistance, 12f);
					camFollowTarget.distance = Mathf.Max(camFollowTarget.distance, 11f);
					if ((Object)(object)camFollowTarget.TargetCamera != (Object)null)
					{
						camFollowTarget.ResetTargetCamera(0f);
					}
				}
				instance.CameraSetConversationMode(false);
				instance.CameraSetOffset(Vector3.zero);
				if (PlayerFarming.players != null)
				{
					if ((Object)(object)camFollowTarget != (Object)null && camFollowTarget.targets != null)
					{
						for (int num = camFollowTarget.targets.Count - 1; num >= 0; num--)
						{
							Target val = camFollowTarget.targets[num];
							bool flag = false;
							foreach (PlayerFarming player in PlayerFarming.players)
							{
								if ((Object)(object)player != (Object)null && val != null && (Object)(object)val.gameObject == (Object)(object)player.CameraBone)
								{
									flag = true;
									break;
								}
							}
							if (!flag)
							{
								camFollowTarget.targets.RemoveAt(num);
							}
						}
					}
					foreach (PlayerFarming player2 in PlayerFarming.players)
					{
						if ((Object)(object)player2 != (Object)null && !TransitionVotePlayerState.IsHidden(player2) && (Object)(object)player2.CameraBone != (Object)null && !instance.CameraContains(player2.CameraBone))
						{
							instance.AddToCamera(player2.CameraBone, player2.isLamb ? 1f : 0.1f);
						}
					}
				}
			}
			LetterBox.Hide(true);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[QoL] Conversation presentation recovery was partial: " + ex.Message));
		}
	}

	public static void RecoverHubPresentation()
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		if (PlayerFarming.players != null && PlayerFarming.players.Count > 1 && !GameManager.IsDungeon(PlayerFarming.Location))
		{
			RestoreWorldPresentation();
		}
	}

	private static void TryRestoreWorldPresentation()
	{
		if (!(Time.unscaledTime < _nextPresentationRecoveryAt))
		{
			_nextPresentationRecoveryAt = Time.unscaledTime + 0.2f;
			RestoreWorldPresentation();
		}
	}

	private static bool IsChurchLocation()
	{
		try
		{
			return string.Equals(((object)Unsafe.As<FollowerLocation, FollowerLocation>(ref PlayerFarming.Location)/*cast due to .constrained prefix*/).ToString(), "Church", StringComparison.OrdinalIgnoreCase);
		}
		catch
		{
			return false;
		}
	}
}
internal static class CoopEmergencyEscape
{
	private static float _nextAllowedAt;

	public static void Tick()
	{
		if (Time.unscaledTime < _nextAllowedAt || !Input.GetKeyDown((KeyCode)291))
		{
			return;
		}
		_nextAllowedAt = Time.unscaledTime + 0.75f;
		int num = CoopMenuOverlaySession.EmergencyCloseAll();
		DoorTransitionVote.EmergencyCancel();
		BuildingTransitionVote.EmergencyCancel();
		TransitionVotePlayerState.RestoreAll();
		UIMenuBase[] array = Object.FindObjectsOfType<UIMenuBase>();
		foreach (UIMenuBase val in array)
		{
			if (!((Object)(object)val == (Object)null) && !((Object)(object)((Component)val).gameObject == (Object)null) && ((Component)val).gameObject.activeInHierarchy)
			{
				try
				{
					val.Hide(true);
					num++;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[Emergency] Could not hide " + ((object)val).GetType().Name + ": " + ex.Message));
				}
			}
		}
		if (TryForceCloseConversation("F10 emergency"))
		{
			num++;
		}
		SimulationManager.UnPause();
		Time.timeScale = 1f;
		CoopConversationSession.EmergencyRecoverAll();
		RestorePlayers();
		UINavigatorNew instance = MonoSingleton<UINavigatorNew>.Instance;
		if ((Object)(object)instance != (Object)null)
		{
			instance.AllowInputOnlyFromPlayer = PlayerFarming.Instance;
		}
		try
		{
			LetterBox.Hide(true);
			if ((Object)(object)HUD_Manager.Instance != (Object)null)
			{
				HUD_Manager.Instance.Show(0, false);
			}
		}
		catch (Exception ex2)
		{
			Plugin.Log.LogWarning((object)("[Emergency] Presentation recovery was partial: " + ex2.Message));
		}
		Plugin.Log.LogWarning((object)("[Emergency] F10 closed " + num + " active menu(s) and restored keyboard/controller ownership"));
	}

	internal static bool TryForceCloseConversation(string reason)
	{
		bool isPlaying;
		try
		{
			isPlaying = MMConversation.isPlaying;
		}
		catch
		{
			return false;
		}
		if (!isPlaying)
		{
			return false;
		}
		try
		{
			object obj2 = AccessTools.Field(typeof(MMConversation), "mmConversation")?.GetValue(null);
			MethodInfo methodInfo = AccessTools.Method(typeof(MMConversation), "DoClose", new Type[3]
			{
				typeof(bool),
				typeof(Action),
				typeof(bool)
			}, (Type[])null);
			if (methodInfo != null)
			{
				methodInfo.Invoke(methodInfo.IsStatic ? null : obj2, new object[3]
				{
					true,
					null,
					MMConversation.isBark
				});
			}
			MethodInfo methodInfo2 = AccessTools.Method(typeof(MMConversation), "FinishCloseFadeTweenByForce", Type.EmptyTypes, (Type[])null);
			if (methodInfo2 != null)
			{
				methodInfo2.Invoke(methodInfo2.IsStatic ? null : obj2, null);
			}
			if (MMConversation.isPlaying)
			{
				MethodInfo methodInfo3 = AccessTools.Method(typeof(MMConversation), "ClearConversation", Type.EmptyTypes, (Type[])null);
				if (methodInfo3 != null)
				{
					methodInfo3.Invoke(methodInfo3.IsStatic ? null : obj2, null);
				}
			}
			Plugin.Log.LogWarning((object)("[Emergency] Forcibly closed a stuck conversation (" + reason + ")"));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[Emergency] Stuck conversation close was partial (" + reason + "): " + ex.Message));
		}
		return true;
	}

	private static void RestorePlayers()
	{
		//IL_0008: 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_0073: Invalid comparison between Unknown and I4
		//IL_007e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Invalid comparison between Unknown and I4
		if (PlayerFarming.players == null)
		{
			return;
		}
		bool flag = GameManager.IsDungeon(PlayerFarming.Location);
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)((Component)player).gameObject == (Object)null) && ((Component)player).gameObject.activeInHierarchy && !((Object)(object)player.state == (Object)null))
			{
				player.state.LockStateChanges = false;
				if ((int)player.state.CURRENT_STATE == 13 || (!flag && (int)player.state.CURRENT_STATE == 49))
				{
					player.state.CURRENT_STATE = (State)0;
				}
			}
		}
	}
}
internal sealed class CoopEnemyBalanceMarker : MonoBehaviour
{
	public bool Applied;

	public int PlayerCount;

	public float Multiplier = 1f;
}
internal sealed class CoopMenuOverlaySession : MonoBehaviour
{
	private static readonly Dictionary<int, State> StateSnapshot = new Dictionary<int, State>();

	private static PlayerFarming _capturedOwner;

	private static float _capturedOwnerAt = -100f;

	private static readonly List<CoopMenuOverlaySession> ActiveSessions = new List<CoopMenuOverlaySession>();

	private static CoopMenuOverlaySession _focusedSession;

	private PlayerFarming _owner;

	private RectTransform _visualRoot;

	private readonly List<RectTransform> _visualRoots = new List<RectTransform>();

	private float _visualScale;

	private float _backgroundAlpha;

	private bool _restoreConversationCamera;

	private string _sessionName;

	private bool _worldReleased;

	private bool _visualApplied;

	private bool _sessionEnded;

	private UIMenuBase _boundMenu;

	private GameObject _ownerTag;

	public static bool BlocksFollowerWheelPresentation
	{
		get
		{
			for (int i = 0; i < ActiveSessions.Count; i++)
			{
				CoopMenuOverlaySession coopMenuOverlaySession = ActiveSessions[i];
				if ((Object)(object)coopMenuOverlaySession != (Object)null && !coopMenuOverlaySession._sessionEnded && coopMenuOverlaySession._sessionName == "follower wheel")
				{
					return true;
				}
			}
			return false;
		}
	}

	public static void CapturePlayerStates(PlayerFarming owner)
	{
		//IL_005f: Unknown result type (might be due to invalid IL or missing references)
		_capturedOwner = owner;
		_capturedOwnerAt = Time.unscaledTime;
		StateSnapshot.Clear();
		if (PlayerFarming.players == null)
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player != (Object)null && (Object)(object)player.state != (Object)null)
			{
				StateSnapshot[player.playerID] = player.state.CURRENT_STATE;
			}
		}
	}

	public static PlayerFarming ResolveOwner(PlayerFarming explicitOwner = null)
	{
		if ((Object)(object)explicitOwner != (Object)null)
		{
			return explicitOwner;
		}
		PlayerFarming val = ResolveRecentOwner(2.5f);
		if ((Object)(object)val != (Object)null)
		{
			return val;
		}
		if ((Object)(object)MonoSingleton<UINavigatorNew>.Instance != (Object)null && (Object)(object)MonoSingleton<UINavigatorNew>.Instance.AllowInputOnlyFromPlayer != (Object)null)
		{
			return MonoSingleton<UINavigatorNew>.Instance.AllowInputOnlyFromPlayer;
		}
		return PlayerFarming.Instance;
	}

	public static PlayerFarming ResolveRecentOwner(float maxAge)
	{
		if ((Object)(object)_capturedOwner == (Object)null || (Object)(object)((Component)_capturedOwner).gameObject == (Object)null || !((Component)_capturedOwner).gameObject.activeInHierarchy)
		{
			return null;
		}
		if (!(Time.unscaledTime - _capturedOwnerAt <= Mathf.Max(0f, maxAge)))
		{
			return null;
		}
		return _capturedOwner;
	}

	public static int EmergencyCloseAll()
	{
		List<CoopMenuOverlaySession> list = new List<CoopMenuOverlaySession>(ActiveSessions);
		int num = 0;
		foreach (CoopMenuOverlaySession item in list)
		{
			if ((Object)(object)item == (Object)null || item._sessionEnded)
			{
				continue;
			}
			num++;
			try
			{
				if ((Object)(object)item._boundMenu != (Object)null && ((Component)item._boundMenu).gameObject.activeInHierarchy)
				{
					item._boundMenu.Hide(true);
				}
				else
				{
					item.EndSession();
				}
			}
			catch
			{
				item.EndSession();
			}
		}
		return num;
	}

	public static int CloseAllForTransition()
	{
		List<CoopMenuOverlaySession> list = new List<CoopMenuOverlaySession>(ActiveSessions);
		int num = 0;
		foreach (CoopMenuOverlaySession item in list)
		{
			if ((Object)(object)item == (Object)null || item._sessionEnded)
			{
				continue;
			}
			num++;
			try
			{
				if ((Object)(object)item._boundMenu != (Object)null && ((Component)item._boundMenu).gameObject.activeInHierarchy)
				{
					item._boundMenu.Hide(true);
				}
				if ((Object)(object)item != (Object)null && (Object)(object)((Component)item).gameObject != (Object)null && ((Component)item).gameObject.activeSelf)
				{
					((Component)item).gameObject.SetActive(false);
				}
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[QoL] Transition menu close was partial for " + item._sessionName + ": " + ex.Message));
			}
			finally
			{
				if ((Object)(object)item != (Object)null && !item._sessionEnded)
				{
					item.EndSession();
				}
			}
		}
		ActiveSessions.Clear();
		_focusedSession = null;
		_capturedOwner = null;
		_capturedOwnerAt = -100f;
		StateSnapshot.Clear();
		UINavigatorNew instance = MonoSingleton<UINavigatorNew>.Instance;
		if ((Object)(object)instance != (Object)null)
		{
			instance.AllowInputOnlyFromPlayer = PlayerFarming.Instance;
		}
		SimulationManager.UnPause();
		Time.timeScale = 1f;
		return num;
	}

	public static void Attach(Component menu, PlayerFarming owner, float visualScale, float backgroundAlpha, bool restoreConversationCamera, string sessionName)
	{
		if (!((Object)(object)menu == (Object)null) && !((Object)(object)menu.gameObject == (Object)null) && PlayerFarming.players != null && PlayerFarming.players.Count > 1)
		{
			CoopMenuOverlaySession coopMenuOverlaySession = menu.gameObject.GetComponent<CoopMenuOverlaySession>();
			if ((Object)(object)coopMenuOverlaySession == (Object)null)
			{
				coopMenuOverlaySession = menu.gameObject.AddComponent<CoopMenuOverlaySession>();
			}
			coopMenuOverlaySession._owner = ResolveOwner(owner);
			coopMenuOverlaySession._visualScale = Mathf.Clamp(visualScale, 0.24f, 1f);
			coopMenuOverlaySession._backgroundAlpha = Mathf.Clamp01(backgroundAlpha);
			coopMenuOverlaySession._restoreConversationCamera = restoreConversationCamera;
			coopMenuOverlaySession._sessionName = sessionName ?? "context menu";
			coopMenuOverlaySession._sessionEnded = false;
			coopMenuOverlaySession._worldReleased = false;
			coopMenuOverlaySession._visualApplied = false;
			coopMenuOverlaySession._visualRoots.Clear();
			if (!ActiveSessions.Contains(coopMenuOverlaySession))
			{
				ActiveSessions.Add(coopMenuOverlaySession);
			}
			_focusedSession = coopMenuOverlaySession;
			if (coopMenuOverlaySession._restoreConversationCamera)
			{
				CoopConversationSession.RecoverHubPresentation();
			}
			if ((Object)(object)coopMenuOverlaySession._ownerTag != (Object)null)
			{
				Object.Destroy((Object)(object)coopMenuOverlaySession._ownerTag);
				coopMenuOverlaySession._ownerTag = null;
			}
			coopMenuOverlaySession.BindMenu(menu.GetComponent<UIMenuBase>());
		}
	}

	private void BindMenu(UIMenuBase menu)
	{
		if (!((Object)(object)_boundMenu == (Object)(object)menu))
		{
			if ((Object)(object)_boundMenu != (Object)null)
			{
				UIMenuBase boundMenu = _boundMenu;
				boundMenu.OnHide = (Action)Delegate.Remove(boundMenu.OnHide, new Action(EndSession));
			}
			_boundMenu = menu;
			if ((Object)(object)_boundMenu != (Object)null)
			{
				UIMenuBase boundMenu2 = _boundMenu;
				boundMenu2.OnHide = (Action)Delegate.Combine(boundMenu2.OnHide, new Action(EndSession));
			}
		}
	}

	private IEnumerator Start()
	{
		yield return null;
		if (!_sessionEnded)
		{
			ReleaseWorldForOtherPlayers();
			yield return (object)new WaitForSecondsRealtime(0.25f);
			if (!_sessionEnded)
			{
				ApplyCompactVisual();
			}
		}
	}

	private void LateUpdate()
	{
		if (_sessionEnded || (Object)(object)_owner == (Object)null || PlayerFarming.players == null || PlayerFarming.players.Count <= 1)
		{
			return;
		}
		if (!_worldReleased)
		{
			ReleaseWorldForOtherPlayers();
		}
		if (_visualApplied)
		{
			if (OwnerRequestedMenuFocus())
			{
				_focusedSession = this;
			}
			UINavigatorNew instance = MonoSingleton<UINavigatorNew>.Instance;
			if ((Object)(object)_focusedSession == (Object)(object)this && (Object)(object)instance != (Object)null && (Object)(object)instance.AllowInputOnlyFromPlayer != (Object)(object)_owner)
			{
				instance.AllowInputOnlyFromPlayer = _owner;
			}
			if (_restoreConversationCamera)
			{
				CoopConversationSession.RecoverHubPresentation();
			}
			RestoreNonOwnerPlayers();
		}
	}

	private void ReleaseWorldForOtherPlayers()
	{
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		if (_worldReleased || (Object)(object)_owner == (Object)null)
		{
			return;
		}
		_worldReleased = true;
		try
		{
			if (!ActiveSessions.Contains(this))
			{
				ActiveSessions.Add(this);
			}
			_focusedSession = this;
			Time.timeScale = 1f;
			SimulationManager.UnPause();
			UINavigatorNew instance = MonoSingleton<UINavigatorNew>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.AllowInputOnlyFromPlayer = _owner;
			}
			if (_restoreConversationCamera && (Object)(object)GameManager.GetInstance() != (Object)null && !MMConversation.isPlaying)
			{
				GameManager.GetInstance().CameraSetConversationMode(false);
				GameManager.GetInstance().CameraSetOffset(Vector3.zero);
				LetterBox.Hide(true);
				foreach (PlayerFarming player in PlayerFarming.players)
				{
					if ((Object)(object)player != (Object)null && (Object)(object)player.CameraBone != (Object)null && !GameManager.GetInstance().CameraContains(player.CameraBone))
					{
						GameManager.GetInstance().AddToCamera(player.CameraBone, player.isLamb ? 1f : 0.1f);
					}
				}
			}
			RestoreNonOwnerPlayers();
			Plugin.Log.LogInfo((object)("[QoL] Opened non-blocking " + _sessionName + " for player " + (_owner.playerID + 1)));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[QoL] Could not fully release co-op world for " + _sessionName + ": " + ex.Message));
		}
	}

	private void EndSession()
	{
		if (!_sessionEnded)
		{
			_sessionEnded = true;
			ActiveSessions.Remove(this);
			if ((Object)(object)_focusedSession == (Object)(object)this)
			{
				_focusedSession = ((ActiveSessions.Count > 0) ? ActiveSessions[ActiveSessions.Count - 1] : null);
			}
			if ((Object)(object)_ownerTag != (Object)null)
			{
				Object.Destroy((Object)(object)_ownerTag);
				_ownerTag = null;
			}
			if ((Object)(object)_owner != (Object)null)
			{
				_capturedOwner = _owner;
				_capturedOwnerAt = Time.unscaledTime;
			}
			if (_sessionName == "follower wheel")
			{
				CoopConversationSession.BeginTownEventRecovery(1.5f, "follower wheel closed");
			}
			UINavigatorNew instance = MonoSingleton<UINavigatorNew>.Instance;
			if ((Object)(object)instance != (Object)null && (Object)(object)instance.AllowInputOnlyFromPlayer == (Object)(object)_owner)
			{
				instance.AllowInputOnlyFromPlayer = PlayerFarming.Instance;
			}
			Plugin.Log.LogInfo((object)("[QoL] Closed non-blocking " + _sessionName + " and released its input owner"));
		}
	}

	private bool OwnerRequestedMenuFocus()
	{
		try
		{
			return (Object)(object)_owner != (Object)null && _owner.rewiredPlayer != null && _owner.rewiredPlayer.GetAnyButtonDown();
		}
		catch
		{
			return false;
		}
	}

	private void OnDisable()
	{
		EndSession();
	}

	private void OnDestroy()
	{
		EndSession();
		if ((Object)(object)_boundMenu != (Object)null)
		{
			UIMenuBase boundMenu = _boundMenu;
			boundMenu.OnHide = (Action)Delegate.Remove(boundMenu.OnHide, new Action(EndSession));
		}
	}

	private void RestoreNonOwnerPlayers()
	{
		//IL_0048: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Invalid comparison between Unknown and I4
		//IL_0052: 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_0067: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: Invalid comparison between Unknown and I4
		//IL_006c: 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)
		if (PlayerFarming.players == null)
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player == (Object)(object)_owner) && !((Object)(object)player.state == (Object)null) && (int)player.state.CURRENT_STATE == 13)
			{
				State cURRENT_STATE = (State)0;
				if (StateSnapshot.TryGetValue(player.playerID, out var value))
				{
					cURRENT_STATE = (State)(((int)value != 13) ? ((int)value) : 0);
				}
				player.state.LockStateChanges = false;
				player.state.CURRENT_STATE = cURRENT_STATE;
			}
		}
	}

	private void ApplyCompactVisual()
	{
		//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)
		if (_visualApplied || (Object)(object)_owner == (Object)null)
		{
			return;
		}
		try
		{
			if (_visualScale >= 0.99f)
			{
				_visualRoots.Clear();
				FindVisualRoots(_visualRoots);
				for (int i = 0; i < _visualRoots.Count; i++)
				{
					MakeBackgroundTransparent(_visualRoots[i]);
				}
				CreateOwnerTag();
				_visualApplied = true;
				return;
			}
			_visualRoots.Clear();
			FindVisualRoots(_visualRoots);
			if (_visualRoots.Count != 0)
			{
				for (int j = 0; j < _visualRoots.Count; j++)
				{
					RectTransform val = _visualRoots[j];
					((Transform)val).localScale = Vector3.one * _visualScale;
					MakeBackgroundTransparent(val);
				}
				_visualRoot = _visualRoots[0];
				MoveVisualsToReservedSlot(_visualRoots);
				if (_sessionName == "cooking menu" || _sessionName == "kitchen menu")
				{
					ImproveCompactCookingReadability(_visualRoots);
				}
				CreateOwnerTag();
				_visualApplied = true;
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[QoL] Compact overlay layout failed for " + _sessionName + ": " + ex.Message));
		}
	}

	private void ImproveCompactCookingReadability(List<RectTransform> visuals)
	{
		//IL_009e: 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_00b6: 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_00ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_0055: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_0064: Unknown result type (might be due to invalid IL or missing references)
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		//IL_006a: 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_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0072: Unknown result type (might be due to invalid IL or missing references)
		//IL_0129: 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_01e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01eb: Unknown result type (might be due to invalid IL or missing references)
		//IL_01f0: 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)
		//IL_01ff: 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_0208: 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_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_0234: 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)
		//IL_0249: 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_0258: Unknown result type (might be due to invalid IL or missing references)
		//IL_0266: 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_02b9: Unknown result type (might be due to invalid IL or missing references)
		if (visuals == null || visuals.Count == 0)
		{
			return;
		}
		Vector2 val = default(Vector2);
		((Vector2)(ref val))..ctor(float.MaxValue, float.MaxValue);
		Vector2 val2 = default(Vector2);
		((Vector2)(ref val2))..ctor(float.MinValue, float.MinValue);
		Vector3[] array = (Vector3[])(object)new Vector3[4];
		foreach (RectTransform visual in visuals)
		{
			visual.GetWorldCorners(array);
			for (int i = 0; i < array.Length; i++)
			{
				Vector2 val3 = RectTransformUtility.WorldToScreenPoint((Camera)null, array[i]);
				val = Vector2.Min(val, val3);
				val2 = Vector2.Max(val2, val3);
			}
		}
		float num = Mathf.Max(1f, val2.x - val.x);
		float num2 = Mathf.Max(1f, val2.y - val.y);
		float num3 = val.x + num * 0.48f;
		foreach (RectTransform visual2 in visuals)
		{
			TextMeshProUGUI[] componentsInChildren = ((Component)visual2).GetComponentsInChildren<TextMeshProUGUI>(true);
			foreach (TextMeshProUGUI val4 in componentsInChildren)
			{
				if (!((Object)(object)val4 == (Object)null) && !string.IsNullOrWhiteSpace(((TMP_Text)val4).text))
				{
					float num4 = ((RectTransformUtility.WorldToScreenPoint((Camera)null, ((Transform)((TMP_Text)val4).rectTransform).position).x >= num3) ? 1.7f : 1.25f);
					((TMP_Text)val4).enableAutoSizing = false;
					((TMP_Text)val4).fontSize = Mathf.Clamp(((TMP_Text)val4).fontSize * num4, 18f, 54f);
					((TMP_Text)val4).outlineWidth = Mathf.Max(((TMP_Text)val4).outlineWidth, 0.08f);
				}
			}
			Graphic[] componentsInChildren2 = ((Component)visual2).GetComponentsInChildren<Graphic>(true);
			foreach (Graphic val5 in componentsInChildren2)
			{
				if (!((Object)(object)val5 == (Object)null) && (val5 is Image || val5 is RawImage))
				{
					val5.rectTransform.GetWorldCorners(array);
					Vector2 val6 = RectTransformUtility.WorldToScreenPoint((Camera)null, array[0]);
					Vector2 val7 = RectTransformUtility.WorldToScreenPoint((Camera)null, array[2]);
					float num5 = Mathf.Abs(val7.x - val6.x);
					float num6 = Mathf.Abs(val7.y - val6.y);
					float num7 = (val6.x + val7.x) * 0.5f;
					Color color = val5.color;
					float num8 = color.r * 0.2126f + color.g * 0.7152f + color.b * 0.0722f;
					if (num7 < val.x + num * 0.2f && num6 > num2 * 0.22f && num5 < num * 0.18f && num8 < 0.16f)
					{
						color.a = 0f;
						val5.color = color;
					}
				}
			}
		}
		Plugin.Log.LogInfo((object)"[QoL] Enlarged compact food text and removed the dark left-side decoration");
	}

	private void FindVisualRoots(List<RectTransform> results)
	{
		Transform transform = ((Component)this).transform;
		RectTransform val = (RectTransform)(object)((transform is RectTransform) ? transform : null);
		if ((Object)(object)val == (Object)null)
		{
			return;
		}
		if ((Object)(object)((Component)this).GetComponent<Canvas>() == (Object)null)
		{
			results.Add(val);
			return;
		}
		for (int i = 0; i < ((Transform)val).childCount; i++)
		{
			Transform child = ((Transform)val).GetChild(i);
			RectTransform val2 = (RectTransform)(object)((child is RectTransform) ? child : null);
			if (!((Object)(object)val2 == (Object)null) && ((Component)val2).GetComponentsInChildren<Graphic>(true).Length > 0)
			{
				results.Add(val2);
			}
		}
		if (results.Count == 0)
		{
			results.Add(val);
		}
	}

	private void MoveVisualsToReservedSlot(List<RectTransform> visuals)
	{
		//IL_0031: 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_00d4: 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_00df: 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_00f1: 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_00f8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0093: Unknown result type (might be due to invalid IL or missing references)
		//IL_0098: 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_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a3: 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_00a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_012d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0132: Unknown result type (might be due to invalid IL or missing references)
		//IL_0137: 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_0142: 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)
		if (visuals == null || visuals.Count == 0 || (Object)(object)_owner == (Object)null)
		{
			return;
		}
		Canvas componentInParent = ((Component)visuals[0]).GetComponentInParent<Canvas>();
		Camera val = (((Object)(object)componentInParent != (Object)null && (int)componentInParent.renderMode != 0) ? componentInParent.worldCamera : null);
		Vector2 val2 = default(Vector2);
		((Vector2)(ref val2))..ctor(float.MaxValue, float.MaxValue);
		Vector2 val3 = default(Vector2);
		((Vector2)(ref val3))..ctor(float.MinValue, float.MinValue);
		Vector3[] array = (Vector3[])(object)new Vector3[4];
		foreach (RectTransform visual in visuals)
		{
			visual.GetWorldCorners(array);
			for (int i = 0; i < array.Length; i++)
			{
				Vector2 val4 = RectTransformUtility.WorldToScreenPoint(val, array[i]);
				val2 = Vector2.Min(val2, val4);
				val3 = Vector2.Max(val3, val4);
			}
		}
		Vector2 val5 = (val2 + val3) * 0.5f;
		Vector2 val6 = GetReservedScreenPoint(_owner.playerID) - val5;
		Vector3 position = default(Vector3);
		foreach (RectTransform visual2 in visuals)
		{
			Transform parent = ((Transform)visual2).parent;
			RectTransform val7 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if (!((Object)(object)val7 == (Object)null))
			{
				Vector2 val8 = RectTransformUtility.WorldToScreenPoint(val, ((Transform)visual2).position) + val6;
				if (RectTransformUtility.ScreenPointToWorldPointInRectangle(val7, val8, val, ref position))
				{
					((Transform)visual2).position = position;
				}
			}
		}
	}

	private static Vector2 GetReservedScreenPoint(int playerID)
	{
		//IL_003b: Unknown result type (might be due to invalid IL or missing references)
		int num = Mathf.Clamp(playerID, 0, 7);
		int num2 = num % 3;
		int num3 = num / 3;
		float num4 = (float)Screen.width * (0.17f + 0.33f * (float)num2);
		float num5 = (float)Screen.height * (0.81f - 0.31f * (float)num3);
		return new Vector2(num4, num5);
	}

	private void CreateOwnerTag()
	{
		//IL_0084: Unknown result type (might be due to invalid IL or missing references)
		//IL_008e: 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_00d2: 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_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_0118: 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_0160: Unknown result type (might be due to invalid IL or missing references)
		//IL_0165: Unknown result type (might be due to invalid IL or missing references)
		//IL_0173: 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)
		//IL_01a9: 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_01c7: 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_01dd: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e7: 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)
		if ((Object)(object)_ownerTag != (Object)null || (Object)(object)_owner == (Object)null)
		{
			return;
		}
		Canvas val = ((Component)this).GetComponent<Canvas>() ?? ((Component)this).GetComponentInParent<Canvas>() ?? ((Component)this).GetComponentInChildren<Canvas>(true);
		if (!((Object)(object)val == (Object)null))
		{
			_ownerTag = new GameObject("COTLMP Menu Owner P" + (_owner.playerID + 1), new Type[2]
			{
				typeof(RectTransform),
				typeof(Image)
			});
			_ownerTag.transform.SetParent(((Component)val).transform, false);
			_ownerTag.transform.SetAsLastSibling();
			RectTransform component = _ownerTag.GetComponent<RectTransform>();
			Vector2 reservedScreenPoint = GetReservedScreenPoint(_owner.playerID);
			component.anchorMin = new Vector2(reservedScreenPoint.x / (float)Screen.width, Mathf.Clamp01(reservedScreenPoint.y / (float)Screen.height + 0.14f));
			component.anchorMax = component.anchorMin;
			component.pivot = new Vector2(0.5f, 0.5f);
			component.sizeDelta = new Vector2(72f, 34f);
			Image component2 = _ownerTag.GetComponent<Image>();
			Color color = Plugin.IndicatorColors[Mathf.Clamp(_owner.playerID, 0, Plugin.IndicatorColors.Length - 1)];
			color.a = 0.88f;
			((Graphic)component2).color = color;
			((Graphic)component2).raycastTarget = false;
			GameObject val2 = new GameObject("Label", new Type[2]
			{
				typeof(RectTransform),
				typeof(TextMeshProUGUI)
			});
			val2.transform.SetParent(_ownerTag.transform, false);
			RectTransform component3 = val2.GetComponent<RectTransform>();
			component3.anchorMin = Vector2.zero;
			component3.anchorMax = Vector2.one;
			component3.offsetMin = Vector2.zero;
			component3.offsetMax = Vector2.zero;
			TextMeshProUGUI component4 = val2.GetComponent<TextMeshProUGUI>();
			TextMeshProUGUI componentInChildren = ((Component)this).GetComponentInChildren<TextMeshProUGUI>(true);
			if ((Object)(object)componentInChildren != (Object)null)
			{
				((TMP_Text)component4).font = ((TMP_Text)componentInChildren).font;
				((TMP_Text)component4).fontSharedMaterial = ((TMP_Text)componentInChildren).fontSharedMaterial;
			}
			((TMP_Text)component4).text = "P" + (_owner.playerID + 1);
			((TMP_Text)component4).fontSize = 22f;
			((TMP_Text)component4).fontStyle = (FontStyles)1;
			((TMP_Text)component4).alignment = (TextAlignmentOptions)514;
			((Graphic)component4).color = Color.white;
			((Graphic)component4).raycastTarget = false;
		}
	}

	private void MakeBackgroundTransparent(RectTransform visual)
	{
		//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_00dc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: 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_0106: 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_011b: Unknown result type (might be due to invalid IL or missing references)
		//IL_014a: 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)
		Graphic[] componentsInChildren = ((Component)visual).GetComponentsInChildren<Graphic>(true);
		foreach (Graphic val in componentsInChildren)
		{
			if (!((Object)(object)val == (Object)null) && (val is Image || val is RawImage))
			{
				string text = ((Object)((Component)val).gameObject).name.ToLowerInvariant();
				bool num = text.Contains("background") || text.Contains("backdrop") || text.Contains("vignette") || text.Contains("fade") || text.Contains("overlay") || text.Contains("info card") || text.Contains("infocard") || text.Contains("detail") || text == "bg";
				RectTransform rectTransform = val.rectTransform;
				Vector3[] array = (Vector3[])(object)new Vector3[4];
				rectTransform.GetWorldCorners(array);
				Vector2 val2 = RectTransformUtility.WorldToScreenPoint((Camera)null, array[0]);
				Vector2 val3 = RectTransformUtility.WorldToScreenPoint((Camera)null, array[2]);
				float num2 = Mathf.Abs(val3.x - val2.x);
				float num3 = Mathf.Abs(val3.y - val2.y);
				Color color = val.color;
				bool flag = num2 > (float)Screen.width * 0.055f && num3 > (float)Screen.height * 0.055f;
				if (num || flag)
				{
					color.a = Mathf.Min(color.a, _backgroundAlpha);
					val.color = color;
				}
			}
		}
	}
}
internal static class CustomSpineCompatibility
{
	private sealed class SelectionRouteState
	{
		public bool Changed;

		public string PreviousSelection;
	}

	private sealed class CultTweakerFleeceState
	{
		public bool Changed;

		public int PreviousIndex;
	}

	private sealed class CotlApiBleatState
	{
		public IDictionary Overrides;

		public object Key;

		public object Value;

		public bool Removed;
	}

	private sealed class CotlApiPlayerSkinState
	{
		public PlayerFarming Player;

		public bool OriginalIsGoat;

		public bool CapturedIdentity;

		public IDictionary Overrides;

		public object Key;

		public object Value;

		public bool Removed;
	}

	private static class CultTweakerFleecePatch
	{
		public static void Prefix(PlayerFarming __instance, out CultTweakerFleeceState __state)
		{
			__state = new CultTweakerFleeceState();
			if (!_active || (Object)(object)__instance == (Object)null || __instance.playerID < 2 || __instance.playerID >= 8 || _cultTweakerFleeceIndexP1Field == null)
			{
				return;
			}
			try
			{
				object value = _cultTweakerFleeceIndexP1Field.GetValue(null);
				if (value is int)
				{
					__state.PreviousIndex = (int)value;
					if (__state.PreviousIndex != -1)
					{
						_cultTweakerFleeceIndexP1Field.SetValue(null, -1);
						__state.Changed = true;
					}
				}
			}
			catch (Exception exception)
			{
				LogFleeceWarning(exception);
			}
		}

		public static Exception Finalizer(Exception __exception, CultTweakerFleeceState __state)
		{
			if (__state != null && __state.Changed && _cultTweakerFleeceIndexP1Field != null)
			{
				try
				{
					_cultTweakerFleeceIndexP1Field.SetValue(null, __state.PreviousIndex);
				}
				catch (Exception exception)
				{
					LogFleeceWarning(exception);
				}
			}
			return __exception;
		}
	}

	private static class CotlApiExtraPlayerBleatPatch
	{
		public static void Prefix(object __instance, out CotlApiBleatState __state)
		{
			__state = new CotlApiBleatState();
			if (!_active || __instance == null || _playerBleatOverrideProperty == null)
			{
				return;
			}
			try
			{
				PlayerFarming val = (PlayerFarming)((__instance is PlayerFarming) ? __instance : null);
				if ((Object)(object)val == (Object)null)
				{
					object? obj = AccessTools.Field(__instance.GetType(), "<>4__this")?.GetValue(__instance);
					val = (PlayerFarming)((obj is PlayerFarming) ? obj : null);
				}
				if ((Object)(object)val == (Object)null || val.playerID < 2 || val.playerID >= 8 || !(_playerBleatOverrideProperty.GetValue(null, null) is IDictionary dictionary))
				{
					return;
				}
				string b = ((!val.isLamb || val.IsGoat) ? "GOAT" : "LAMB");
				object obj2 = null;
				foreach (object key in dictionary.Keys)
				{
					if (key != null && string.Equals(key.ToString(), b, StringComparison.OrdinalIgnoreCase))
					{
						obj2 = key;
						break;
					}
				}
				if (obj2 != null && dictionary.Contains(obj2))
				{
					__state.Overrides = dictionary;
					__state.Key = obj2;
					__state.Value = dictionary[obj2];
					dictionary.Remove(obj2);
					__state.Removed = true;
				}
			}
			catch (Exception exception)
			{
				LogBleatWarning(exception);
			}
		}

		public static Exception Finalizer(Exception __exception, CotlApiBleatState __state)
		{
			if (__state != null && __state.Removed && __state.Overrides != null && __state.Key != null)
			{
				try
				{
					__state.Overrides[__state.Key] = __state.Value;
				}
				catch (Exception exception)
				{
					LogBleatWarning(exception);
				}
			}
			return __exception;
		}
	}

	private static class CotlApiExtraPlayerSkinPatch
	{
		public static void Prefix(PlayerFarming __instance, out CotlApiPlayerSkinState __state)
		{
			__state = new CotlApiPlayerSkinState();
			if (!_active || (Object)(object)__instance == (Object)null || __instance.playerID < 2 || __instance.playerID >= 8)
			{
				return;
			}
			__state.Player = __instance;
			__state.OriginalIsGoat = __instance.IsGoat;
			__state.CapturedIdentity = true;
			if (_playerSkinOverrideProperty == null)
			{
				return;
			}
			try
			{
				if (_playerSkinOverrideProperty.GetValue(null, null) is IDictionary dictionary)
				{
					string name = ((!__instance.isLamb || __instance.IsGoat) ? "GOAT" : "LAMB");
					object obj = FindDictionaryKey(dictionary, name);
					if (obj != null && dictionary.Contains(obj))
					{
						__state.Overrides = dictionary;
						__state.Key = obj;
						__state.Value = dictionary[obj];
						dictionary.Remove(obj);
						__state.Removed = true;
					}
				}
			}
			catch (Exception exception)
			{
				LogSkinIdentityWarning(exception);
			}
		}

		public static void Postfix(PlayerFarming __instance, bool BlackAndWhite)
		{
			if (!_active || (Object)(object)__instance == (Object)null || __instance.playerID < 2 || __instance.playerID >= 8 || _apiPlayerSetSkinPatchMethod == null || !ShouldPreserveCustomSpineColor(__instance))
			{
				return;
			}
			int customHurtLevel = GetCustomHurtLevel(__instance);
			string selectionSkinName = GetSelectionSkinName(ResolvedSelections[__instance.playerID]);
			if (customHurtLevel <= 0 || string.IsNullOrEmpty(selectionSkinName) || IsVanillaHurtCompatibleSkin(selectionSkinName))
			{
				return;
			}
			HealthPlayer health = __instance.health;
			if ((Object)(object)health == (Object)null)
			{
				return;
			}
			float pLAYER_HEALTH = health.PLAYER_HEALTH;
			try
			{
				health.PLAYER_HEALTH = Mathf.Max(pLAYER_HEALTH, 3f);
				object[] array = new object[3] { null, __instance, BlackAndWhite };
				object obj = _apiPlayerSetSkinPatchMethod.Invoke(null, array);
				if (!(obj is bool) || (bool)obj)
				{
					throw new InvalidOperationException("COTL_API declined the routed custom-spine skin rebuild");
				}
				object obj2 = array[0];
				ApplyMatchingHurtSkin(__instance, (Skin)((obj2 is Skin) ? obj2 : null), selectionSkinName, customHurtLevel);
				RefreshCustomSpineAnimation(__instance, "hurt skin", logSuccess: false);
				if (!HurtSkinGuardLogged[__instance.playerID])
				{
					HurtSkinGuardLogged[__instance.playerID] = true;
					Plugin.Log.LogInfo((object)$"[MP][CustomSpine] Player {__instance.playerID + 1} now uses only '{selectionSkinName}'-compatible hurt visuals");
				}
			}
			catch (Exception exception)
			{
				LogHurtSkinWarning(exception);
			}
			finally
			{
				health.PLAYER_HEALTH = pLAYER_HEALTH;
			}
		}

		public static Exception Finalizer(Exception __exception, CotlApiPlayerSkinState __state)
		{
			if (__state == null)
			{
				return __exception;
			}
			try
			{
				if (__state.Removed && __state.Overrides != null && __state.Key != null)
				{
					__state.Overrides[__state.Key] = __state.Value;
				}
				if (__state.CapturedIdentity && (Object)(object)__state.Player != (Object)null)
				{
					__state.Player.IsGoat = __state.OriginalIsGoat;
				}
			}
			catch (Exception exception)
			{
				LogSkinIdentityWarning(exception);
			}
			return __exception;
		}
	}

	private const string ApiGuid = "io.github.xhayper.COTL_API";

	private const string LoaderGuid = "InfernoDragon0.cotl.CustomSpineLoader";

	private const string MatchPlayerOne = "Match Player 1";

	private const string MatchPlayerTwo = "Match Player 2";

	private const string CotlmpDefault = "COTLMP default goat";

	private static readonly string[] SlotChoices = new string[8];

	private static readonly string[] ResolvedSelections = new string[8];

	private static readonly object[] ResolvedAssets = new object[8];

	private static readonly object[] SlotDropdowns = new object[8];

	private static readonly bool[] ApplyScheduled = new bool[8];

	private static Plugin _host;

	private static Type _skinManagerType;

	private static FieldInfo _selectedSpineField;

	private static FieldInfo _selectedSpineTwoField;

	private static IDictionary _customPlayerSpines;

	private static MethodInfo _playerStartMethod;

	private static MethodInfo _apiPlayerStartPatchMethod;

	private static MethodInfo _apiPlayerSetSkinPatchMethod;

	private static FieldInfo _startCompleteField;

	private static FieldInfo _dropdownDisplayTypeField;

	private static FieldInfo _cultTweakerFleeceIndexP1Field;

	private static MethodInfo _refreshAnimationFromStateMethod;

	private static PropertyInfo _playerBleatOverrideProperty;

	private static PropertyInfo _playerSkinOverrideProperty;

	private static string[] _dropdownOptions = Array.Empty<string>();

	private static bool _active;

	private static bool _routeWarningLogged;

	private static bool _settingsWarningLogged;

	private static bool _onEnableWarningLogged;

	private static bool _fleeceWarningLogged;

	private static bool _animationWarningLogged;

	private static bool _bleatWarningLogged;

	private static bool _skinIdentityWarningLogged;

	private static bool _hurtSkinWarningLogged;

	private static readonly bool[] HurtSkinGuardLogged = new bool[8];

	internal static void Initialize(Plugin host, Harmony harmony)
	{
		//IL_0270: Unknown result type (might be due to invalid IL or missing references)
		//IL_0277: Expected O, but got Unknown
		//IL_02da: Unknown result type (might be due to invalid IL or missing references)
		//IL_02ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_02fc: Expected O, but got Unknown
		//IL_02fc: Expected O, but got Unknown
		//IL_032e: Unknown result type (might be due to invalid IL or missing references)
		//IL_033b: Expected O, but got Unknown
		//IL_0379: Unknown result type (might be due to invalid IL or missing references)
		//IL_0387: Expected O, but got Unknown
		//IL_03d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_03e7: Expected O, but got Unknown
		if (!Chainloader.PluginInfos.ContainsKey("io.github.xhayper.COTL_API") || !Chainloader.PluginInfos.ContainsKey("InfernoDragon0.cotl.CustomSpineLoader"))
		{
			Plugin.Log.LogInfo((object)"[MP][CustomSpine] Optional COTL_API/CustomSpineLoader integration inactive");
			return;
		}
		_host = host;
		_skinManagerType = AccessTools.TypeByName("COTL_API.CustomSkins.CustomSkinManager");
		if (_skinManagerType == null)
		{
			Plugin.Log.LogWarning((object)"[MP][CustomSpine] Installed API layout is unsupported; compatibility disabled without changing normal COTLMP behavior");
			return;
		}
		_selectedSpineField = AccessTools.Field(_skinManagerType, "SelectedSpine");
		_selectedSpineTwoField = AccessTools.Field(_skinManagerType, "SelectedSpine2");
		FieldInfo fieldInfo = AccessTools.Field(_skinManagerType, "CustomPlayerSpines");
		_playerStartMethod = AccessTools.Method(typeof(PlayerFarming), "Start", (Type[])null, (Type[])null);
		_apiPlayerStartPatchMethod = AccessTools.Method(_skinManagerType, "PlayerFarming_Start", (Type[])null, (Type[])null);
		_apiPlayerSetSkinPatchMethod = AccessTools.Method(_skinManagerType, "PlayerFarming_SetSkin", (Type[])null, (Type[])null);
		_startCompleteField = AccessTools.Field(typeof(PlayerFarming), "StartComplete");
		_dropdownDisplayTypeField = AccessTools.Field(typeof(MMDropdown), "_displayType");
		Type type = AccessTools.TypeByName("CustomSpineLoader.SpineLoaderHelper.PlayerSpineLoader");
		_cultTweakerFleeceIndexP1Field = ((type != null) ? AccessTools.Field(type, "currentFleeceIndexP1") : null);
		_refreshAnimationFromStateMethod = AccessTools.Method(typeof(SimpleSpineAnimator), "UpdateAnimFromState", (Type[])null, (Type[])null);
		_playerBleatOverrideProperty = AccessTools.Property(_skinManagerType, "PlayerBleatOverride");
		_playerSkinOverrideProperty = AccessTools.Property(_skinManagerType, "PlayerSkinOverride");
		if (_selectedSpineField == null || _selectedSpineTwoField == null || fieldInfo == null || _playerStartMethod == null)
		{
			Plugin.Log.LogWarning((object)"[MP][CustomSpine] Installed API layout is unsupported; compatibility disabled without changing normal COTLMP behavior");
			return;
		}
		_customPlayerSpines = fieldInfo.GetValue(null) as IDictionary;
		if (_customPlayerSpines == null)
		{
			Plugin.Log.LogWarning((object)"[MP][CustomSpine] COTL_API player-spine registry was unavailable; compatibility disabled");
			return;
		}
		for (int i = 2; i < 8; i++)
		{
			SlotChoices[i] = ((i % 2 == 0) ? "Match Player 1" : "Match Player 2");
		}
		_active = true;
		try
		{
			PatchPlayerLifecycle(harmony, _playerStartMethod);
			MethodInfo target = AccessTools.Method(typeof(PlayerFarming), "SetSkin", new Type[1] { typeof(bool) }, (Type[])null);
			PatchPlayerLifecycle(harmony, target);
			PatchCultTweakerFleeceCompatibility(harmony, target);
			PatchCotlApiPlayerSkinCompatibility(harmony, target);
			PatchCotlApiBleatCompatibility(harmony);
			HarmonyMethod val = new HarmonyMethod(typeof(CustomSpineCompatibility), "PlayerStart_RefreshCustomAnimation_Postfix", (Type[])null);
			val.priority = 0;
			val.after = new string[1] { "io.github.xhayper.COTL_API" };
			HarmonyMethod val2 = val;
			harmony.Patch((MethodBase)_playerStartMethod, (HarmonyMethod)null, val2, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			MethodInfo methodInfo = AccessTools.Method(_skinManagerType, "ChangeSelectedPlayerSpine", (Type[])null, (Type[])null);
			if (methodInfo != null)
			{
				harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(CustomSpineCompatibility), "ChangeSelectedPlayerSpine_Prefix", (Type[])null), new HarmonyMethod(typeof(CustomSpineCompatibility), "ChangeSelectedPlayerSpine_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			MethodInfo methodInfo2 = AccessTools.Method(_skinManagerType, "AddPlayerSpine", (Type[])null, (Type[])null);
			if (methodInfo2 != null)
			{
				harmony.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(CustomSpineCompatibility), "AddPlayerSpine_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			MethodInfo methodInfo3 = AccessTools.Method(_skinManagerType, "PlayerFarming_OnEnable", (Type[])null, (Type[])null);
			if (methodInfo3 != null && _apiPlayerStartPatchMethod != null)
			{
				harmony.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(CustomSpineCompatibility), "ApiPlayerOnEnable_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
				Plugin.Log.LogInfo((object)"[MP][CustomSpine] Guarded COTL_API player OnEnable from premature full Start/HUD initialization");
			}
			MethodInfo methodInfo4 = AccessTools.Method(typeof(MMDropdown), "Open", (Type[])null, (Type[])null);
			if (methodInfo4 != null && _dropdownDisplayTypeField != null)
			{
				harmony.Patch((MethodBase)methodInfo4, new HarmonyMethod(typeof(CustomSpineCompatibility), "CustomSpineDropdown_Open_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			}
			CreateSettingsDropdowns();
			RefreshResolvedSelection(2);
			RefreshResolvedSelection(3);
			Plugin.Log.LogInfo((object)"[MP8][CustomSpine] P3-P8 compatibility enabled (alternating P1/P2 matches by default)");
		}
		catch (Exception ex)
		{
			_active = false;
			Plugin.Log.LogWarning((object)("[MP][CustomSpine] Compatibility initialization failed safely: " + ex.GetBaseException().Message));
		}
	}

	private static bool ApiPlayerOnEnable_Prefix(PlayerFarming __0, ref bool __result)
	{
		if (!_active || (Object)(object)__0 == (Object)null)
		{
			return true;
		}
		__result = true;
		if (!HasCompletedStart(__0))
		{
			return false;
		}
		if (PlayerFarming.players == null || PlayerFarming.players.Count <= 0 || (Object)(object)PlayerFarming.Instance == (Object)null)
		{
			return false;
		}
		PlayerSpineRoute_Prefix(__0, out var __state);
		try
		{
			_apiPlayerStartPatchMethod.Invoke(null, new object[1] { __0 });
			RefreshCustomSpineAnimation(__0, "OnEnable");
		}
		catch (Exception ex)
		{
			if (!_onEnableWarningLogged)
			{
				_onEnableWarningLogged = true;
				Plugin.Log.LogWarning((object)("[MP][CustomSpine] Safe OnEnable spine refresh failed; the next normal player Start/SetSkin will retry: " + ex.GetBaseException().Message));
			}
		}
		finally
		{
			PlayerSpineRoute_Finalizer(null, __state);
		}
		return false;
	}

	private static void PatchPlayerLifecycle(Harmony harmony, MethodInfo target)
	{
		//IL_0019: Unknown result type (might be due to invalid IL or missing references)
		//IL_001f: Expected O, but got Unknown
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_0056: Expected O, but got Unknown
		if (!(target == null))
		{
			HarmonyMethod val = new HarmonyMethod(typeof(CustomSpineCompatibility), "PlayerSpineRoute_Prefix", (Type[])null);
			val.priority = 800;
			val.before = new string[1] { "io.github.xhayper.COTL_API" };
			HarmonyMethod val2 = val;
			val = new HarmonyMethod(typeof(CustomSpineCompatibility), "PlayerSpineRoute_Finalizer", (Type[])null);
			val.priority = 0;
			val.after = new string[1] { "io.github.xhayper.COTL_API" };
			HarmonyMethod val3 = val;
			harmony.Patch((MethodBase)target, val2, (HarmonyMethod)null, (HarmonyMethod)null, val3, (HarmonyMethod)null);
		}
	}

	private static void PatchCultTweakerFleeceCompatibility(Harmony harmony, MethodInfo target)
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Expected O, but got Unknown
		if (target == null || _cultTweakerFleeceIndexP1Field == null)
		{
			Plugin.Log.LogWarning((object)"[MP8][CustomSpine] CultTweaker fleece compatibility unavailable; extra-player fleece isolation was not installed");
			return;
		}
		HarmonyMethod val = new HarmonyMethod(typeof(CultTweakerFleecePatch), "Prefix", (Type[])null);
		val.priority = 900;
		val.before = new string[1] { "InfernoDragon0.cotl.CustomSpineLoader" };
		HarmonyMethod val2 = val;
		val = new HarmonyMethod(typeof(CultTweakerFleecePatch), "Finalizer", (Type[])null);
		val.priority = 0;
		val.after = new string[1] { "InfernoDragon0.cotl.CustomSpineLoader" };
		HarmonyMethod val3 = val;
		harmony.Patch((MethodBase)target, val2, (HarmonyMethod)null, (HarmonyMethod)null, val3, (HarmonyMethod)null);
		Plugin.Log.LogInfo((object)"[MP8][CustomSpine] Isolated P3-P8 from CultTweaker's two-player fleece override");
	}

	private static void PatchCotlApiBleatCompatibility(Harmony harmony)
	{
		//IL_004b: Unknown result type (might be due to invalid IL or missing references)
		//IL_0051: Expected O, but got Unknown
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0088: Expected O, but got Unknown
		MethodInfo methodInfo = Patches.FindNestedMoveNext(typeof(PlayerFarming), "BleatRoutine");
		if (methodInfo == null || _playerBleatOverrideProperty == null)
		{
			Plugin.Log.LogWarning((object)"[MP8][CustomSpine] COTL_API bleat compatibility unavailable; extra-player bleat routing was not installed");
			return;
		}
		HarmonyMethod val = new HarmonyMethod(typeof(CotlApiExtraPlayerBleatPatch), "Prefix", (Type[])null);
		val.priority = 900;
		val.before = new string[1] { "io.github.xhayper.COTL_API" };
		HarmonyMethod val2 = val;
		val = new HarmonyMethod(typeof(CotlApiExtraPlayerBleatPatch), "Finalizer", (Type[])null);
		val.priority = 0;
		val.after = new string[1] { "io.github.xhayper.COTL_API" };
		HarmonyMethod val3 = val;
		harmony.Patch((MethodBase)methodInfo, val2, (HarmonyMethod)null, (HarmonyMethod)null, val3, (HarmonyMethod)null);
		Plugin.Log.LogInfo((object)"[MP8][CustomSpine] Routed P3-P8 bleats to their own player instances");
	}

	private static void PatchCotlApiPlayerSkinCompatibility(Harmony harmony, MethodInfo target)
	{
		//IL_0036: Unknown result type (might be due to invalid IL or missing references)
		//IL_003c: Expected O, but got Unknown
		//IL_006d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Expected O, but got Unknown
		//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ae: Expected O, but got Unknown
		if (target == null || _apiPlayerSetSkinPatchMethod == null)
		{
			Plugin.Log.LogWarning((object)"[MP8][CustomSpine] COTL_API player-skin compatibility unavailable; extra-player skin identity guards were not installed");
			return;
		}
		HarmonyMethod val = new HarmonyMethod(typeof(CotlApiExtraPlayerSkinPatch), "Prefix", (Type[])null);
		val.priority = 850;
		val.before = new string[1] { "io.github.xhayper.COTL_API" };
		HarmonyMethod val2 = val;
		val = new HarmonyMethod(typeof(CotlApiExtraPlayerSkinPatch), "Postfix", (Type[])null);
		val.priority = 0;
		val.after = new string[2] { "io.github.xhayper.COTL_API", "InfernoDragon0.cotl.CustomSpineLoader" };
		HarmonyMethod val3 = val;
		val = new HarmonyMethod(typeof(CotlApiExtraPlayerSkinPatch), "Finalizer", (Type[])null);
		val.priority = 0;
		val.after = new string[1] { "io.github.xhayper.COTL_API" };
		HarmonyMethod val4 = val;
		harmony.Patch((MethodBase)target, val2, val3, (HarmonyMethod)null, val4, (HarmonyMethod)null);
		Plugin.Log.LogInfo((object)"[MP8][CustomSpine] Isolated P3-P8 skin, hurt, and player-type state from COTL_API's two-player globals");
	}

	private static void PlayerStart_RefreshCustomAnimation_Postfix(PlayerFarming __instance)
	{
		RefreshCustomSpineAnimation(__instance, "Start");
	}

	private static void RefreshCustomSpineAnimation(PlayerFarming player, string source, bool logSuccess = true)
	{
		if (!_active || (Object)(object)player == (Object)null || player.playerID < 2 || player.playerID >= 8 || !ShouldPreserveCustomSpineColor(player) || _refreshAnimationFromStateMethod == null)
		{
			return;
		}
		try
		{
			SimpleSpineAnimator val = player.simpleSpineAnimator;
			if ((Object)(object)val == (Object)null)
			{
				val = (player.simpleSpineAnimator = ((Component)player).GetComponentInChildren<SimpleSpineAnimator>());
			}
			if (!((Object)(object)val == (Object)null))
			{
				_refreshAnimationFromStateMethod.Invoke(val, null);
				if ((Object)(object)player.Spine != (Object)null && player.Spine.AnimationState != null && ((SkeletonRenderer)player.Spine).skeleton != null)
				{
					player.Spine.AnimationState.Apply(((SkeletonRenderer)player.Spine).skeleton, true);
					player.Spine.Update(0f, false);
				}
				if (logSuccess)
				{
					Plugin.Log.LogInfo((object)$"[MP][CustomSpine] Refreshed player {player.playerID + 1} animation after spine rebuild ({source})");
				}
			}
		}
		catch (Exception ex)
		{
			if (!_animationWarningLogged)
			{
				_animationWarningLogged = true;
				Plugin.Log.LogWarning((object)("[MP][CustomSpine] Animation refresh failed safely: " + ex.GetBaseException().Message));
			}
		}
	}

	private static void LogFleeceWarning(Exception exception)
	{
		if (!_fleeceWarningLogged)
		{
			_fleeceWarningLogged = true;
			Plugin.Log.LogWarning((object)("[MP][CustomSpine] CultTweaker fleece isolation failed safely: " + exception.GetBaseException().Message));
		}
	}

	private static void LogBleatWarning(Exception exception)
	{
		if (!_bleatWarningLogged)
		{
			_bleatWarningLogged = true;
			Plugin.Log.LogWarning((object)("[MP][CustomSpine] Extra-player bleat routing failed safely: " + exception.GetBaseException().Message));
		}
	}

	private static void LogSkinIdentityWarning(Exception exception)
	{
		if (!_skinIdentityWarningLogged)
		{
			_skinIdentityWarningLogged = true;
			Plugin.Log.LogWarning((object)("[MP][CustomSpine] Extra-player skin identity isolation failed safely: " + exception.GetBaseException().Message));
		}
	}

	private static void LogHurtSkinWarning(Exception exception)
	{
		if (!_hurtSkinWarningLogged)
		{
			_hurtSkinWarningLogged = true;
			Plugin.Log.LogWarning((object)("[MP][CustomSpine] Extra-player hurt-skin correction failed safely: " + exception.GetBaseException().Message));
		}
	}

	private static object FindDictionaryKey(IDictionary dictionary, string name)
	{
		foreach (object key in dictionary.Keys)
		{
			if (key != null && string.Equals(key.ToString(), name, StringComparison.OrdinalIgnoreCase))
			{
				return key;
			}
		}
		return null;
	}

	private static int GetCustomHurtLevel(PlayerFarming player)
	{
		if ((Object)(object)player == (Object)null || (Object)(object)player.health == (Object)null)
		{
			return 0;
		}
		float num = ((Health)player.health).HP + ((Health)player.health).BlackHearts + ((Health)player.health).BlueHearts + ((Health)player.health).SpiritHearts;
		bool flag = Mathf.Approximately(player.health.PLAYER_TOTAL_HEALTH, 2f);
		if (num <= 1f && !flag)
		{
			return 2;
		}
		if ((num <= 2f && !flag) || (num <= 1f && flag))
		{
			return 1;
		}
		return 0;
	}

	private static string GetSelectionSkinName(string selection)
	{
		if (string.IsNullOrEmpty(selection))
		{
			return string.Empty;
		}
		string[] array = selection.Split(new char[1] { '/' }, 2);
		if (array.Length != 2)
		{
			return selection;
		}
		return array[1];
	}

	private static bool IsVanillaHurtCompatibleSkin(string skinName)
	{
		if (!string.Equals(skinName, "Lamb", StringComparison.OrdinalIgnoreCase))
		{
			return string.Equals(skinName, "Goat", StringComparison.OrdinalIgnoreCase);
		}
		return true;
	}

	private static void ApplyMatchingHurtSkin(PlayerFarming player, Skin playerSkin, string skinName, int hurtLevel)
	{
		if ((Object)(object)player.Spine == (Object)null || ((SkeletonRenderer)player.Spine).skeleton == null || playerSkin == null)
		{
			return;
		}
		Skeleton skeleton = ((SkeletonRenderer)player.Spine).skeleton;
		SkeletonData data = skeleton.Data;
		if (data == null)
		{
			return;
		}
		string[] array = new string[3]
		{
			skinName + "_Hurt" + hurtLevel,
			skinName + "Hurt" + hurtLevel,
			skinName + "/Hurt" + hurtLevel
		};
		Skin val = null;
		for (int i = 0; i < array.Length; i++)
		{
			val = data.FindSkin(array[i]);
			if (val != null)
			{
				break;
			}
		}
		if (val != null)
		{
			playerSkin.AddSkin(val);
			skeleton.SetSkin(playerSkin);
			skeleton.SetToSetupPose();
		}
	}

	private static void PlayerSpineRoute_Prefix(PlayerFarming __instance, out SelectionRouteState __state)
	{
		__state = new SelectionRouteState();
		if (!_active || (Object)(object)__instance == (Object)null || __instance.playerID < 2 || __instance.playerID >= 8)
		{
			return;
		}
		try
		{
			string text = RefreshResolvedSelection(__instance.playerID);
			string text2 = _selectedSpineField.GetValue(null) as string;
			if (text2 != text)
			{
				__state.PreviousSelection = text2;
				_selectedSpineField.SetValue(null, text ?? string.Empty);
				__state.Changed = true;
			}
		}
		catch (Exception exception)
		{
			LogRouteWarning(exception);
		}
	}

	private static Exception PlayerSpineRoute_Finalizer(Exception __exception, SelectionRouteState __state)
	{
		if (__state != null && __state.Changed)
		{
			try
			{
				_selectedSpineField.SetValue(null, __state.PreviousSelection ?? string.Empty);
			}
			catch (Exception exception)
			{
				LogRouteWarning(exception);
			}
		}
		return __exception;
	}

	public static bool ChangeSelectedPlayerSpine_Prefix(string __0, int __1)
	{
		if (!_active || __1 < 2 || __1 >= 8)
		{
			return true;
		}
		if (IsRegisteredSelection(__0))
		{
			SetSlotChoice(__1, __0, updateDropdown: true);
		}
		else
		{
			Plugin.Log.LogWarning((object)$"[MP][CustomSpine] Ignored unavailable spine '{__0}' for player {__1 + 1}");
		}
		return false;
	}

	public static void ChangeSelectedPlayerSpine_Postfix(int __1)
	{
		if (_active)
		{
			switch (__1)
			{
			case 0:
				ScheduleMatchingPlayers("Match Player 1");
				break;
			case 1:
				ScheduleMatchingPlayers("Match Player 2");
				break;
			}
		}
	}

	public static void AddPlayerSpine_Postfix()
	{
		if (_active)
		{
			RefreshDropdownOptions();
			for (int i = 2; i < 8; i++)
			{
				RefreshResolvedSelection(i);
			}
		}
	}

	private static void CustomSpineDropdown_Open_Prefix(MMDropdown __instance)
	{
		if (!_active || (Object)(object)__instance == (Object)null || _dropdownDisplayTypeField == null)
		{
			return;
		}
		Transform val = ((Component)__instance).transform;
		while ((Object)(object)val != (Object)null)
		{
			string name = ((Object)((Component)val).gameObject).name;
			if (name.StartsWith("Player ", StringComparison.Ordinal) && name.EndsWith(" custom spine", StringComparison.Ordinal))
			{
				_dropdownDisplayTypeField.SetValue(__instance, (object)(Display)1);
				break;
			}
			val = val.parent;
		}
	}

	internal static bool ShouldPreserveCustomSpineColor(PlayerFarming player)
	{
		if (!_active || (Object)(object)player == (Object)null || player.playerID < 2 || player.playerID >= 8 || SlotChoices[player.playerID] == "COTLMP default goat" || (Object)(object)player.Spine == (Object)null)
		{
			return false;
		}
		object obj = ResolvedAssets[player.playerID];
		if (obj == null || string.IsNullOrEmpty(ResolvedSelections[player.playerID]))
		{
			return false;
		}
		return ((SkeletonRenderer)player.Spine).skeletonDataAsset == obj;
	}

	private static void CreateSettingsDropdowns()
	{
		RefreshDropdownOptions();
		Type type = AccessTools.TypeByName("COTL_API.CustomSettings.CustomSettingsManager");
		if (type == null)
		{
			LogSettingsWarning("COTL_API settings API was not found; using automatic extra-player matching");
			return;
		}
		MethodInfo methodInfo = AccessTools.Method(type, "AddSavedDropdown", (Type[])null, (Type[])null);
		if (methodInfo == null)
		{
			LogSettingsWarning("COTL_API settings API was not found; using automatic extra-player matching");
			return;
		}
		for (int i = 2; i < 8; i++)
		{
			string text = ((i % 2 == 0) ? "Match Player 1" : "Match Player 2");
			SlotDropdowns[i] = CreateDropdown(methodInfo, i, $"Player {i + 1} custom spine", text);
			LoadSavedDropdownChoice(i, text);
		}
	}

	private static object CreateDropdown(MethodInfo addSavedDropdown, int slot, string label, string defaultValue)
	{
		try
		{
			Action<int> action = delegate(int index)
			{
				OnDropdownChanged(slot, index);
			};
			return addSavedDropdown.Invoke(null, new object[6] { "COTL Multiplayer", "com.cotlmp.multiplayerexpansion", label, defaultValue, _dropdownOptions, action });
		}
		catch (Exception ex)
		{
			LogSettingsWarning("Could not create extra-player spine settings: " + ex.GetBaseException().Message);
			return null;
		}
	}

	private static void LoadSavedDropdownChoice(int slot, string fallback)
	{
		object obj = SlotDropdowns[slot];
		if (obj == null)
		{
			SlotChoices[slot] = fallback;
			return;
		}
		PropertyInfo propertyInfo = AccessTools.Property(obj.GetType(), "Value");
		string text = propertyInfo?.GetValue(obj, null) as string;
		if (!IsChoiceAvailable(text))
		{
			text = fallback;
			propertyInfo?.SetValue(obj, text, null);
		}
		SlotChoices[slot] = text;
	}

	private static void OnDropdownChanged(int slot, int index)
	{
		string[] array = GetDropdownOptions(SlotDropdowns[slot]) ?? _dropdownOptions;
		if (index >= 0 && index < array.Length)
		{
			SetSlotChoice(slot, array[index], updateDropdown: false);
		}
	}

	private static void SetSlotChoice(int slot, string choice, bool updateDropdown)
	{
		if (slot >= 2 && slot < 8 && IsChoiceAvailable(choice))
		{
			SlotChoices[slot] = choice;
			RefreshResolvedSelection(slot);
			if (updateDropdown)
			{
				SetDropdownValue(SlotDropdowns[slot], choice);
			}
			ScheduleApply(slot);
			Plugin.Log.LogInfo((object)$"[MP][CustomSpine] Player {slot + 1} selection set to '{choice}'");
		}
	}

	private static void ScheduleMatchingPlayers(string matchChoice)
	{
		for (int i = 2; i < 8; i++)
		{
			if (SlotChoices[i] == matchChoice)
			{
				RefreshResolvedSelection(i);
				ScheduleApply(i);
			}
		}
	}

	private static void ScheduleApply(int slot)
	{
		if (!((Object)(object)_host == (Object)null) && !ApplyScheduled[slot])
		{
			ApplyScheduled[slot] = true;
			((MonoBehaviour)_host).StartCoroutine(ApplySelectionDelayed(slot));
		}
	}

	private static IEnumerator ApplySelectionDelayed(int slot)
	{
		yield return null;
		PlayerFarming val = FindPlayer(slot);
		for (int i = 0; i < 30; i++)
		{
			if (!((Object)(object)val != (Object)null))
			{
				break;
			}
			if (HasCompletedStart(val))
			{
				break;
			}
			yield return null;
			val = FindPlayer(slot);
		}
		ApplyScheduled[slot] = false;
		if ((Object)(object)val == (Object)null || !HasCompletedStart(val))
		{
			yield break;
		}
		try
		{
			_playerStartMethod.Invoke(val, null);
			Plugin.Log.LogInfo((object)$"[MP][CustomSpine] Applied full spine selection to player {slot + 1}");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"[MP][CustomSpine] Live player {slot + 1} spine refresh deferred until its next spawn/enable: {ex.GetBaseException().Message}");
		}
	}

	private static PlayerFarming FindPlayer(int slot)
	{
		if (PlayerFarming.players == null)
		{
			return null;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player != (Object)null && player.playerID == slot)
			{
				return player;
			}
		}
		return null;
	}

	private static bool HasCompletedStart(PlayerFarming player)
	{
		if (_startCompleteField == null)
		{
			return true;
		}
		object value = _startCompleteField.GetValue(player);
		if (value is bool)
		{
			return (bool)value;
		}
		return false;
	}

	private static string RefreshResolvedSelection(int slot)
	{
		string text = ResolveSelection(slot);
		ResolvedSelections[slot] = text;
		ResolvedAssets[slot] = GetRegisteredAsset(text);
		return text;
	}

	private static string ResolveSelection(int slot)
	{
		string text = SlotChoices[slot];
		switch (text)
		{
		case "Match Player 1":
			return ResolveInheritedSelection(_selectedSpineField);
		case "Match Player 2":
			return ResolveInheritedSelection(_selectedSpineTwoField);
		case "COTLMP default goat":
			return ResolveDefaultGoat();
		default:
			if (IsRegisteredSelection(text))
			{
				return text;
			}
			return ResolveInheritedSelection((slot % 2 == 0) ? _selectedSpineField : _selectedSpineTwoField);
		}
	}

	private static string ResolveInheritedSelection(FieldInfo field)
	{
		string text = field?.GetValue(null) as string;
		if (!IsRegisteredSelection(text))
		{
			return string.Empty;
		}
		return text;
	}

	private static string ResolveDefaultGoat()
	{
		if (!IsRegisteredSelection("Default/Goat"))
		{
			return string.Empty;
		}
		return "Default/Goat";
	}

	private static bool IsChoiceAvailable(string choice)
	{
		switch (choice)
		{
		default:
			return IsRegisteredSelection(choice);
		case "Match Player 1":
		case "Match Player 2":
		case "COTLMP default goat":
			return true;
		}
	}

	private static bool IsRegisteredSelection(string selection)
	{
		if (!string.IsNullOrEmpty(selection))
		{
			return GetRegisteredAsset(selection) != null;
		}
		return false;
	}

	private static object GetRegisteredAsset(string selection)
	{
		if (_customPlayerSpines == null || string.IsNullOrEmpty(selection) || !_customPlayerSpines.Contains(selection))
		{
			return null;
		}
		return _customPlayerSpines[selection];
	}

	private static void RefreshDropdownOptions()
	{
		List<string> list = new List<string> { "Match Player 1", "Match Player 2", "COTLMP default goat" };
		if (_customPlayerSpines != null)
		{
			List<string> list2 = new List<string>();
			foreach (DictionaryEntry customPlayerSpine in _customPlayerSpines)
			{
				string text = customPlayerSpine.Key as string;
				if (!string.IsNullOrEmpty(text) && customPlayerSpine.Value != null && !text.StartsWith("Placeholder/", StringComparison.Ordinal))
				{
					list2.Add(text);
				}
			}
			list.AddRange(list2.Distinct().OrderBy<string, string>((string value) => value, StringComparer.OrdinalIgnoreCase));
		}
		_dropdownOptions = list.ToArray();
		SetDropdownOptions(SlotDropdowns[2], _dropdownOptions);
		SetDropdownOptions(SlotDropdowns[3], _dropdownOptions);
	}

	private static string[] GetDropdownOptions(object dropdown)
	{
		if (dropdown == null)
		{
			return null;
		}
		return AccessTools.Property(dropdown.GetType(), "Options")?.GetValue(dropdown, null) as string[];
	}

	private static void SetDropdownOptions(object dropdown, string[] options)
	{
		if (dropdown != null)
		{
			AccessTools.Property(dropdown.GetType(), "Options")?.SetValue(dropdown, options, null);
		}
	}

	private static void SetDropdownValue(object dropdown, string value)
	{
		if (dropdown != null)
		{
			AccessTools.Property(dropdown.GetType(), "Value")?.SetValue(dropdown, value, null);
		}
	}

	private static void LogRouteWarning(Exception exception)
	{
		if (!_routeWarningLogged)
		{
			_routeWarningLogged = true;
			Plugin.Log.LogWarning((object)("[MP][CustomSpine] Selection routing failed safely; current player will use its normal appearance: " + exception.GetBaseException().Message));
		}
	}

	private static void LogSettingsWarning(string message)
	{
		if (!_settingsWarningLogged)
		{
			_settingsWarningLogged = true;
			Plugin.Log.LogWarning((object)("[MP][CustomSpine] " + message));
		}
	}
}
internal sealed class DoorTransitionVote : MonoBehaviour
{
	private const float BaseCountdownSeconds = 10f;

	private static readonly MethodInfo DoorTriggerMethod = AccessTools.Method(typeof(Door), "OnTriggerEnter2D", new Type[1] { typeof(Collider2D) }, (Type[])null);

	private static readonly FieldInfo DoorConnectionTypeField = AccessTools.Field(typeof(Door), "ConnectionType");

	private static readonly FieldInfo DoorUsedField = AccessTools.Field(typeof(Door), "Used");

	private static DoorTransitionVote _instance;

	private static Door _replayingDoor;

	private Door _selectedDoor;

	private Collider2D _initiatorCollider;

	private Vector3 _roomAnchor;

	private float _remaining;

	private float _nextBlockedDoorLogAt;

	private int _initiatorSlot = -1;

	private bool _active;

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

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

	private Canvas _canvas;

	private TextMeshProUGUI _titleText;

	private TextMeshProUGUI _statusText;

	private TextMeshProUGUI _timerText;

	private RectTransform _progressFill;

	private Button _denyButton;

	internal static bool HasActiveVote
	{
		get
		{
			if ((Object)(object)_instance != (Object)null)
			{
				return _instance._active;
			}
			return false;
		}
	}

	internal static void EmergencyCancel()
	{
		if (HasActiveVote)
		{
			_instance.CancelVote("emergency exit");
		}
	}

	internal static bool ShouldBlockDoorTrigger(Door door, Collider2D collision)
	{
		if (BuildingTransitionVote.HasActiveVote)
		{
			return BuildingTransitionVote.BlockCompetingTrigger((Component)(object)door, collision);
		}
		if ((Object)(object)door == (Object)null || (Object)(object)collision == (Object)null || !CoopManager.CoopActive || (Object)(object)_replayingDoor == (Object)(object)door)
		{
			return false;
		}
		PlayerFarming val = ResolvePlayer(collision);
		if ((Object)(object)val == (Object)null || CountActivePlayers() <= 1 || !IsEligibleDoor(door))
		{
			return false;
		}
		DoorTransitionVote doorTransitionVote = EnsureRunner();
		if ((Object)(object)doorTransitionVote != (Object)null)
		{
			return doorTransitionVote.HandleDoorTrigger(door, collision, val);
		}
		return false;
	}

	private static DoorTransitionVote EnsureRunner()
	{
		if ((Object)(object)_instance != (Object)null)
		{
			return _instance;
		}
		if ((Object)(object)CoopManager.Instance == (Object)null || (Object)(object)((Component)CoopManager.Instance).gameObject == (Object)null)
		{
			return null;
		}
		_instance = ((Component)CoopManager.Instance).gameObject.GetComponent<DoorTransitionVote>();
		if ((Object)(object)_instance == (Object)null)
		{
			_instance = ((Component)CoopManager.Instance).gameObject.AddComponent<DoorTransitionVote>();
		}
		return _instance;
	}

	private void OnDestroy()
	{
		TransitionVotePlayerState.RestoreAll();
		DestroyVoteUI();
		if ((Object)(object)_instance == (Object)(object)this)
		{
			_instance = null;
		}
	}

	private bool HandleDoorTrigger(Door door, Collider2D collision, PlayerFarming player)
	{
		//IL_005a: 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 (MMTransition.IsPlaying)
		{
			return false;
		}
		if (!_active)
		{
			if (TransitionVotePlayerState.IsInitiatorBlocked(player, out var _))
			{
				MovePlayerInside(door, player, ((Component)player).transform.position);
				return true;
			}
			BeginVote(door, collision, player);
			return true;
		}
		if ((Object)(object)_selectedDoor == (Object)(object)door)
		{
			RegisterEntry(player);
			EvaluateFullyResolvedVote();
			return true;
		}
		MovePlayerInside(door, player, _roomAnchor);
		if (Time.unscaledTime >= _nextBlockedDoorLogAt)
		{
			_nextBlockedDoorLogAt = Time.unscaledTime + 1f;
			Plugin.Log.LogInfo((object)"[RoomVote] Blocked another door while a vote was active.");
		}
		return true;
	}

	private void BeginVote(Door door, Collider2D collision, PlayerFarming initiator)
	{
		//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)
		_selectedDoor = door;
		_initiatorCollider = collision;
		_roomAnchor = ((Component)initiator).transform.position;
		_initiatorSlot = Mathf.Clamp(initiator.playerID, 0, 7);
		_remaining = 10f;
		_enteredPlayers.Clear();
		_deniedPlayers.Clear();
		_active = true;
		RegisterEntry(initiator);
		CreateVoteUI();
		RefreshVoteUI();
		Plugin.Log.LogInfo((object)$"[RoomVote] P{initiator.playerID + 1} started entry vote ({GetDoorLabel(door)}, {CountActivePlayers()} active players).");
	}

	private void RegisterEntry(PlayerFarming player)
	{
		if (!((Object)(object)player == (Object)null))
		{
			int num = Mathf.Clamp(player.playerID, 0, 7);
			bool num2 = _enteredPlayers.Add(num);
			_deniedPlayers.Remove(num);
			if (num2)
			{
				TransitionVotePlayerState.Hide(player);
				Plugin.Log.LogInfo((object)$"[RoomVote] P{num + 1} entered the selected door; countdown speed is now x{GetCountdownSpeed():0.0}.");
			}
		}
	}

	private void Update()
	{
		if (!_active)
		{
			return;
		}
		if ((Object)(object)_selectedDoor == (Object)null || (Object)(object)((Component)_selectedDoor).gameObject == (Object)null || !((Component)_selectedDoor).gameObject.activeInHierarchy)
		{
			CancelVote("selected door disappeared");
			return;
		}
		if (MMTransition.IsPlaying)
		{
			ClearVoteState(restoreHiddenPlayers: true);
			return;
		}
		EvaluateFullyResolvedVote();
		if (!_active)
		{
			return;
		}
		PollDenyInputs();
		if (_active)
		{
			_remaining -= Time.unscaledDeltaTime * GetCountdownSpeed();
			RefreshVoteUI();
			if (_remaining <= 0f)
			{
				ResolveTimedVote();
			}
		}
	}

	private void PollDenyInputs()
	{
		foreach (PlayerFarming activePlayer in GetActivePlayers())
		{
			if (_enteredPlayers.Contains(activePlayer.playerID))
			{
				continue;
			}
			try
			{
				if (InputManager.Gameplay.GetHeavyAttackButtonDown(activePlayer))
				{
					ToggleDeny(activePlayer);
					if (!_active)
					{
						break;
					}
				}
			}
			catch
			{
			}
		}
	}

	private void ToggleDeny(PlayerFarming player)
	{
		if (!_active || (Object)(object)player == (Object)null)
		{
			return;
		}
		int num = Mathf.Clamp(player.playerID, 0, 7);
		if (!_enteredPlayers.Contains(num))
		{
			if (_deniedPlayers.Contains(num))
			{
				_deniedPlayers.Remove(num);
				Plugin.Log.LogInfo((object)$"[RoomVote] P{num + 1} withdrew DENY ENTRY.");
			}
			else
			{
				_deniedPlayers.Add(num);
				Plugin.Log.LogInfo((object)$"[RoomVote] P{num + 1} voted DENY ENTRY.");
			}
			RefreshVoteUI();
			EvaluateFullyResolvedVote();
		}
	}

	private void EvaluateFullyResolvedVote()
	{
		if (_active)
		{
			int num = CountActivePlayers();
			int num2 = CountActiveVotes(_enteredPlayers);
			int num3 = CountActiveVotes(_deniedPlayers);
			if (num2 >= num)
			{
				CommitVote("everyone entered");
			}
			else if (num3 > num2)
			{
				CancelVote("DENY votes exceeded entered players", applyInitiatorCooldown: true);
			}
			else if (num2 + num3 >= num)
			{
				CommitVote("all players resolved without DENY exceeding entry");
			}
		}
	}

	private void ResolveTimedVote()
	{
		int num = CountActiveVotes(_enteredPlayers);
		if (CountActiveVotes(_deniedPlayers) > num)
		{
			CancelVote("timer expired with DENY exceeding entry", applyInitiatorCooldown: true);
		}
		else
		{
			CommitVote("timer expired without DENY exceeding entry");
		}
	}

	private void CommitVote(string reason)
	{
		if (!_active)
		{
			return;
		}
		Door selectedDoor = _selectedDoor;
		Collider2D val = FindReplayCollider();
		int num = CountActiveVotes(_enteredPlayers);
		int num2 = CountActiveVotes(_deniedPlayers);
		Plugin.Log.LogInfo((object)$"[RoomVote] ENTRY APPROVED ({num} entered, {num2} denied): {reason}.");
		TransitionVotePlayerState.PrepareForApprovedTransition();
		ClearVoteState();
		if ((Object)(object)selectedDoor == (Object)null || (Object)(object)val == (Object)null || DoorTriggerMethod == null)
		{
			Plugin.Log.LogWarning((object)"[RoomVote] Approved entry could not replay the selected door safely.");
			SetDoorUsed(selectedDoor, used: false);
			TransitionVotePlayerState.RestoreAll();
			return;
		}
		try
		{
			_replayingDoor = selectedDoor;
			DoorTriggerMethod.Invoke(selectedDoor, new object[1] { val });
		}
		catch (Exception exception)
		{
			SetDoorUsed(selectedDoor, used: false);
			try
			{
				PlayerFarming.SetCollidersActive(true, false);
			}
			catch
			{
			}
			Plugin.Log.LogWarning((object)("[RoomVote] Approved door replay failed: " + GetInnermostMessage(exception)));
			TransitionVotePlayerState.RestoreAll();
		}
		finally
		{
			_replayingDoor = null;
		}
		((MonoBehaviour)this).StartCoroutine(RestoreHiddenPlayersAfterTransition());
	}

	private void CancelVote(string reason, bool applyInitiatorCooldown = false)
	{
		if (_active)
		{
			int num = CountActiveVotes(_enteredPlayers);
			int num2 = CountActiveVotes(_deniedPlayers);
			Door door = _selectedDoor;
			int initiatorSlot = _initiatorSlot;
			Plugin.Log.LogInfo((object)$"[RoomVote] ENTRY DENIED ({num} entered, {num2} denied): {reason}.");
			SetDoorUsed(door, used: false);
			TransitionVotePlayerState.RestoreAndSpread(delegate(PlayerFarming player)
			{
				//IL_000d: Unknown result type (might be due to invalid IL or missing references)
				MovePlayerInside(door, player, _roomAnchor);
			});
			if (applyInitiatorCooldown)
			{
				TransitionVotePlayerState.BlockDeniedInitiator(initiatorSlot);
			}
			ClearVoteState();
		}
	}

	private void ClearVoteState(bool restoreHiddenPlayers = false)
	{
		if (restoreHiddenPlayers)
		{
			TransitionVotePlayerState.RestoreAll();
		}
		_active = false;
		_selectedDoor = null;
		_initiatorCollider = null;
		_initiatorSlot = -1;
		_enteredPlayers.Clear();
		_deniedPlayers.Clear();
		DestroyVoteUI();
	}

	private IEnumerator RestoreHiddenPlayersAfterTransition()
	{
		float transitionStartDeadline = Time.unscaledTime + 0.6f;
		while (!MMTransition.IsPlaying && Time.unscaledTime < transitionStartDeadline)
		{
			yield return null;
		}
		float transitionEndDeadline = Time.unscaledTime + 12f;
		while (MMTransition.IsPlaying && Time.unscaledTime < transitionEndDeadline)
		{
			yield return null;
		}
		TransitionVotePlayerState.RestoreAll();
	}

	private Collider2D FindReplayCollider()
	{
		if ((Object)(object)_initiatorCollider != (Object)null && (Object)(object)ResolvePlayer(_initiatorCollider) != (Object)null)
		{
			return _initiatorCollider;
		}
		foreach (PlayerFarming activePlayer in GetActivePlayers())
		{
			Collider2D component = ((Component)activePlayer).GetComponent<Collider2D>();
			if ((Object)(object)component != (Object)null)
			{
				return component;
			}
		}
		return null;
	}

	private float GetCountdownSpeed()
	{
		int num = Mathf.Max(1, CountActiveVotes(_enteredPlayers));
		return 1f + 0.5f * (float)(num - 1);
	}

	private static int CountActiveVotes(HashSet<int> votes)
	{
		int num = 0;
		foreach (PlayerFarming activePlayer in GetActivePlayers())
		{
			if (votes.Contains(activePlayer.playerID))
			{
				num++;
			}
		}
		return num;
	}

	private static int CountActivePlayers()
	{
		return GetActivePlayers().Count;
	}

	private static List<PlayerFarming> GetActivePlayers()
	{
		List<PlayerFarming> list = new List<PlayerFarming>();
		HashSet<int> hashSet = new HashSet<int>();
		if (PlayerFarming.players == null)
		{
			return list;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player != (Object)null && player.playerID >= 0 && player.playerID < 8 && (Object)(object)((Component)player).gameObject != (Object)null && ((Component)player).gameObject.activeInHierarchy && hashSet.Add(player.playerID))
			{
				list.Add(player);
			}
		}
		return list;
	}

	private static PlayerFarming ResolvePlayer(Collider2D collision)
	{
		if ((Object)(object)collision == (Object)null)
		{
			return null;
		}
		PlayerFarming val = ((Component)collision).gameObject.GetComponent<PlayerFarming>();
		if ((Object)(object)val == (Object)null)
		{
			val = ((Component)collision).gameObject.GetComponentInParent<PlayerFarming>();
		}
		return val;
	}

	private static bool IsEligibleDoor(Door door)
	{
		if ((Object)(object)door == (Object)null || DoorConnectionTypeField == null)
		{
			return false;
		}
		try
		{
			int num = Convert.ToInt32(DoorConnectionTypeField.GetValue(door));
			return num != 0 && num != 8 && !GetDoorUsed(door);
		}
		catch
		{
			return false;
		}
	}

	private static bool GetDoorUsed(Door door)
	{
		try
		{
			return (Object)(object)door != (Object)null && DoorUsedField != null && Convert.ToBoolean(DoorUsedField.GetValue(door));
		}
		catch
		{
			return false;
		}
	}

	private static void SetDoorUsed(Door door, bool used)
	{
		try
		{
			if ((Object)(object)door != (Object)null && DoorUsedField != null)
			{
				DoorUsedField.SetValue(door, used);
			}
		}
		catch
		{
		}
	}

	private static void MovePlayerInside(Door door, PlayerFarming player, Vector3 roomAnchor)
	{
		//IL_0014: 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_003a: 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_004a: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		//IL_007a: 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_00b8: 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_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_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d4: Unknown result type (might be due to invalid IL or missing references)
		//IL_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_00fe: Unknown result type (might be due to invalid IL or missing references)
		//IL_0105: Invalid comparison between Unknown and I4
		//IL_010d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0114: Invalid comparison between Unknown and I4
		if ((Object)(object)door == (Object)null || (Object)(object)player == (Object)null)
		{
			return;
		}
		try
		{
			Vector3 val = roomAnchor - ((Component)door).transform.position;
			if (((Vector3)(ref val)).sqrMagnitude < 0.04f)
			{
				val = ((Component)player).transform.position - ((Component)door).transform.position;
			}
			if (((Vector3)(ref val)).sqrMagnitude < 0.04f)
			{
				val = Vector3.down;
			}
			val.z = 0f;
			Vector3 normalized = ((Vector3)(ref val)).normalized;
			Vector3 val2 = default(Vector3);
			((Vector3)(ref val2))..ctor(0f - normalized.y, normalized.x, 0f);
			float num = ((float)Mathf.Clamp(player.playerID, 0, 7) - 3.5f) * 0.28f;
			((Component)player).transform.position = ((Component)door).transform.position + normalized * 2.25f + val2 * num;
			if ((Object)(object)player.state != (Object)null)
			{
				player.state.LockStateChanges = false;
				if ((int)player.state.CURRENT_STATE == 13 || (int)player.state.CURRENT_STATE == 24)
				{
					player.state.CURRENT_STATE = (State)0;
				}
			}
		}
		catch
		{
		}
	}

	private void CreateVoteUI()
	{
		//IL_0045: Unknown result type (might be due to invalid IL or missing references)
		//IL_004b: Expected O, but got Unknown
		//IL_009d: 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_00dc: Expected O, but got Unknown
		//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_013e: 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_01b2: 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_01d8: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e7: 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_022f: Unknown result type (might be due to invalid IL or missing references)
		//IL_023e: 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_0286: Unknown result type (might be due to invalid IL or missing references)
		//IL_0295: Unknown result type (might be due to invalid IL or missing references)
		//IL_02b8: 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_02f2: Expected O, but got Unknown
		//IL_0315: Unknown result type (might be due to invalid IL or missing references)
		//IL_032a: Unknown result type (might be due to invalid IL or missing references)
		//IL_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)
		//IL_038c: Unknown result type (might be due to invalid IL or missing references)
		//IL_03bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c1: Expected O, but got Unknown
		//IL_03ef: Unknown result type (might be due to invalid IL or missing references)
		//IL_0409: Unknown result type (might be due to invalid IL or missing references)
		//IL_0423: Unknown result type (might be due to invalid IL or missing references)
		//IL_0433: Unknown result type (might be due to invalid IL or missing references)
		//IL_044d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0471: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ad: Unknown result type (might be due to invalid IL or missing references)
		//IL_04b4: Expected O, but got Unknown
		//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_04ee: 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_0518: Unknown result type (might be due to invalid IL or missing references)
		//IL_052c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0555: Unknown result type (might be due to invalid IL or missing references)
		//IL_057f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0584: Unknown result type (might be due to invalid IL or missing references)
		//IL_0594: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a1: Unknown result type (might be due to invalid IL or missing references)
		//IL_05ab: Expected O, but got Unknown
		//IL_05bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_05c7: Expected O, but got Unknown
		//IL_05d3: Unknown result type (might be due to invalid IL or missing references)
		//IL_05e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0605: Unknown result type (might be due to invalid IL or missing references)
		DestroyVoteUI();
		GameObject val = new GameObject("COTLMP Room Vote Canvas", new Type[4]
		{
			typeof(RectTransform),
			typeof(Canvas),
			typeof(CanvasScaler),
			typeof(GraphicRaycaster)
		});
		val.transform.SetParent(((Component)this).transform, false);
		_canvas = val.GetComponent<Canvas>();
		_canvas.renderMode = (RenderMode)0;
		_canvas.sortingOrder = 32700;
		CanvasScaler component = val.GetComponent<CanvasScaler>();
		component.uiScaleMode = (ScaleMode)1;
		component.referenceResolution = new Vector2(1920f, 1080f);
		component.matchWidthOrHeight = 0.5f;
		GameObject val2 = new GameObject("Room Vote Panel", new Type[2]
		{
			typeof(RectTransform),
			typeof(Image)
		});
		val2.transform.SetParent(val.transform, false);
		RectTransform component2 = val2.GetComponent<RectTransform>();
		component2.anchorMin = new Vector2(1f, 0f);
		component2.anchorMax = new Vector2(1f, 0f);
		component2.pivot = new Vector2(1f, 0f);
		component2.anchoredPosition = new Vector2(-14f, 14f);
		component2.sizeDelta = new Vector2(350f, 101f);
		Image component3 = val2.GetComponent<Image>();
		component3.sprite = TransitionVoteSkin.GetPanelSprite();
		component3.preserveAspect = true;
		((Graphic)component3).color = (((Object)(object)component3.sprite != (Object)null) ? new Color(1f, 1f, 1f, 0.88f) : new Color(0.018f, 0.015f, 0.013f, 0.76f));
		((Graphic)component3).raycastTarget = false;
		_titleText = CreateText(val2.transform, "Vote Title", new Vector2(67f, -12f), new Vector2(194f, 29f), 20f, (TextAlignmentOptions)513, new Color(0.96f, 0.9f, 0.74f, 1f));
		_timerText = CreateText(val2.transform, "Vote Timer", new Vector2(278f, -12f), new Vector2(52f, 29f), 21f, (TextAlignmentOptions)516, new Color(1f, 0.8f, 0.24f, 1f));
		_statusText = CreateText(val2.transform, "Vote Status", new Vector2(67f, -43f), new Vector2(260f, 20f), 14f, (TextAlignmentOptions)513, new Color(0.88f, 0.86f, 0.78f, 1f));
		GameObject val3 = new GameObject("Vote Timer Track", new Type[2]
		{
			typeof(RectTransform),
			typeof(Image)
		});
		val3.transform.SetParent(val2.transform, false);
		RectTransform component4 = val3.GetComponent<RectTransform>();
		component4.anchorMin = new Vector2(0f, 1f);
		component4.anchorMax = new Vector2(0f, 1f);
		component4.pivot = new Vector2(0f, 1f);
		component4.anchoredPosition = new Vector2(67f, -78f);
		component4.sizeDelta = new Vector2(104f, 3f);
		((Graphic)val3.GetComponent<Image>()).color = new Color(0.21f, 0.17f, 0.14f, 0.72f);
		GameObject val4 = new GameObject("Vote Timer Fill", new Type[2]
		{
			typeof(RectTransform),
			typeof(Image)
		});
		val4.transform.SetParent(val3.transform, false);
		_progressFill = val4.GetComponent<RectTransform>();
		_progressFill.anchorMin = new Vector2(0f, 0f);
		_progressFill.anchorMax = new Vector2(0f, 1f);
		_progressFill.pivot = new Vector2(0f, 0.5f);
		_progressFill.anchoredPosition = Vector2.zero;
		_progressFill.sizeDelta = new Vector2(104f, 0f);
		((Graphic)val4.GetComponent<Image>()).color = new Color(0.82f, 0.035f, 0.025f, 1f);
		GameObject val5 = new GameObject("Deny Entry Button", new Type[3]
		{
			typeof(RectTransform),
			typeof(Image),
			typeof(Button)
		});
		val5.transform.SetParent(val2.transform, false);
		RectTransform component5 = val5.GetComponent<RectTransform>();
		component5.anchorMin = new Vector2(0f, 1f);
		component5.anchorMax = new Vector2(0f, 1f);
		component5.pivot = new Vector2(0f, 1f);
		component5.anchoredPosition = new Vector2(242f, -65f);
		component5.sizeDelta = new Vector2(88f, 25f);
		Image component6 = val5.GetComponent<Image>();
		((Graphic)component6).color = new Color(0.58f, 0.035f, 0.025f, 0.94f);
		_denyButton = val5.GetComponent<Button>();
		((Selectable)_denyButton).targetGraphic = (Graphic)(object)component6;
		Navigation navigation = ((Selectable)_denyButton).navigation;
		((Navigation)(ref navigation)).mode = (Mode)0;
		((Selectable)_denyButton).navigation = navigation;
		_denyButton.onClick = new ButtonClickedEvent();
		((UnityEvent)_denyButton.onClick).AddListener((UnityAction)delegate
		{
			PlayerFarming val6 = FindPlayerBySlot(0);
			if ((Object)(object)val6 != (Object)null)
			{
				ToggleDeny(val6);
			}
		});
		((TMP_Text)CreateText(val5.transform, "Deny Entry Label", Vector2.zero, new Vector2(88f, 25f), 13f, (TextAlignmentOptions)514, new Color(1f, 0.93f, 0.8f, 1f))).text = "RT  DENY";
	}

	private void RefreshVoteUI()
	{
		//IL_010b: Unknown result type (might be due to invalid IL or missing references)
		if (_active && !((Object)(object)_titleText == (Object)null) && !((Object)(object)_statusText == (Object)null) && !((Object)(object)_timerText == (Object)null))
		{
			int num = CountActivePlayers();
			int num2 = CountActiveVotes(_enteredPlayers);
			int num3 = CountActiveVotes(_deniedPlayers);
			((TMP_Text)_titleText).text = GetDoorLabel(_selectedDoor);
			((TMP_Text)_timerText).text = Mathf.CeilToInt(Mathf.Max(0f, _remaining)).ToString();
			((TMP_Text)_statusText).text = "READY  " + num2 + "/" + num + "        NO  " + num3;
			if ((Object)(object)_progressFill != (Object)null)
			{
				_progressFill.sizeDelta = new Vector2(104f * Mathf.Clamp01(_remaining / 10f), 0f);
			}
		}
	}

	private static TextMeshProUGUI CreateText(Transform parent, string name, Vector2 anchoredPosition, Vector2 size, float fontSize, TextAlignmentOptions alignment, Color color)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Unknown result type (might be due to invalid IL or missing references)
		//IL_0033: 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_0079: 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_009e: 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_00ae: 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)
		GameObject val = new GameObject(name, new Type[2]
		{
			typeof(RectTransform),
			typeof(TextMeshProUGUI)
		});
		val.transform.SetParent(parent, false);
		RectTransform component = val.GetComponent<RectTransform>();
		component.anchorMin = new Vector2(0f, 1f);
		component.anchorMax = new Vector2(0f, 1f);
		component.pivot = new Vector2(0f, 1f);
		component.anchoredPosition = anchoredPosition;
		component.sizeDelta = size;
		TextMeshProUGUI component2 = val.GetComponent<TextMeshProUGUI>();
		((TMP_Text)component2).font = TMP_Settings.defaultFontAsset;
		((TMP_Text)component2).fontSize = fontSize;
		((TMP_Text)component2).alignment = alignment;
		((Graphic)component2).color = color;
		((TMP_Text)component2).outlineColor = Color32.op_Implicit(Color.black);
		((TMP_Text)component2).outlineWidth = 0.16f;
		((Graphic)component2).raycastTarget = false;
		return component2;
	}

	private void DestroyVoteUI()
	{
		if ((Object)(object)_canvas != (Object)null && (Object)(object)((Component)_canvas).gameObject != (Object)null)
		{
			Object.Destroy((Object)(object)((Component)_canvas).gameObject);
		}
		_canvas = null;
		_titleText = null;
		_statusText = null;
		_timerText = null;
		_progressFill = null;
		_denyButton = null;
	}

	private static PlayerFarming FindPlayerBySlot(int slot)
	{
		foreach (PlayerFarming activePlayer in GetActivePlayers())
		{
			if (activePlayer.playerID == slot)
			{
				return activePlayer;
			}
		}
		return null;
	}

	private static string GetDoorLabel(Door door)
	{
		if ((Object)(object)door == (Object)null || (Object)(object)((Component)door).gameObject == (Object)null)
		{
			return "ROOM";
		}
		try
		{
			string text = ((Component)door).gameObject.tag ?? string.Empty;
			if (text.EndsWith(" Door", StringComparison.OrdinalIgnoreCase))
			{
				return text.Substring(0, text.Length - 5).ToUpperInvariant() + " ROOM";
			}
		}
		catch
		{
		}
		return "ROOM";
	}

	private static string GetInnermostMessage(Exception exception)
	{
		Exception ex = exception;
		while (ex != null && ex.InnerException != null)
		{
			ex = ex.InnerException;
		}
		if (ex == null)
		{
			return "unknown error";
		}
		return ex.GetType().Name + ": " + ex.Message;
	}
}
internal static class EightPlayerDifficultyMenu
{
	internal const string PlayerPrefsKey = "COTLMP.8PDifficulty";

	private static readonly FieldInfo CoopButtonField = AccessTools.Field(typeof(UIPauseMenuController), "_coopButton");

	private static readonly FieldInfo CoopButtonTextField = AccessTools.Field(typeof(UIPauseMenuController), "_coopButtonText");

	public static void Attach(UIPauseMenuController pauseMenu)
	{
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Expected O, but got Unknown
		if ((Object)(object)pauseMenu == (Object)null || CoopButtonField == null || (Object)(object)((Component)pauseMenu).transform.Find("COTLMP 8P Difficulty Button") != (Object)null)
		{
			return;
		}
		object? value = CoopButtonField.GetValue(pauseMenu);
		MMButton val = (MMButton)((value is MMButton) ? value : null);
		if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).transform.parent == (Object)null)
		{
			Plugin.Log.LogWarning((object)"[8PDifficulty] Pause menu button template was unavailable");
			return;
		}
		try
		{
			GameObject val2 = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.parent);
			((Object)val2).name = "COTLMP 8P Difficulty Button";
			val2.transform.SetSiblingIndex(((Component)val).transform.GetSiblingIndex() + 1);
			MMButton component = val2.GetComponent<MMButton>();
			if ((Object)(object)component == (Object)null)
			{
				Object.Destroy((Object)(object)val2);
				return;
			}
			((Button)component).onClick = new ButtonClickedEvent();
			component.OnSelected = null;
			component.OnDeselected = null;
			component.OnConfirmDenied = null;
			component.OnPointerEntered = null;
			component.OnPointerExited = null;
			component.OnTryNavigateLeft = null;
			component.OnTryNavigateRight = null;
			TextMeshProUGUI label = FindClonedLabel(pauseMenu, val2);
			val2.AddComponent<EightPlayerDifficultyButton>().Initialise(component, label);
			Transform parent = val2.transform.parent;
			RectTransform val3 = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if ((Object)(object)val3 != (Object)null)
			{
				LayoutRebuilder.ForceRebuildLayoutImmediate(val3);
			}
			Plugin.Log.LogInfo((object)("[8PDifficulty] Added pause-menu selector: " + GetModeName(GetMode())));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[8PDifficulty] Could not add pause-menu selector: " + ex.Message));
		}
	}

	private static TextMeshProUGUI FindClonedLabel(UIPauseMenuController pauseMenu, GameObject clone)
	{
		TextMeshProUGUI val = (TextMeshProUGUI)((CoopButtonTextField != null) ? /*isinst with value type is only supported in some contexts*/: null);
		TextMeshProUGUI[] componentsInChildren = clone.GetComponentsInChildren<TextMeshProUGUI>(true);
		if ((Object)(object)val != (Object)null)
		{
			TextMeshProUGUI[] array = componentsInChildren;
			foreach (TextMeshProUGUI val2 in array)
			{
				if ((Object)(object)val2 != (Object)null && ((Object)((Component)val2).gameObject).name == ((Object)((Component)val).gameObject).name)
				{
					return val2;
				}
			}
		}
		if (componentsInChildren.Length == 0)
		{
			return null;
		}
		return componentsInChildren[0];
	}

	internal static int GetMode()
	{
		return Mathf.Clamp(PlayerPrefs.GetInt("COTLMP.8PDifficulty", 1), 0, 3);
	}

	internal static void SetMode(int mode)
	{
		PlayerPrefs.SetInt("COTLMP.8PDifficulty", Mathf.Clamp(mode, 0, 3));
		PlayerPrefs.Save();
	}

	internal static string GetModeName(int mode)
	{
		return Mathf.Clamp(mode, 0, 3) switch
		{
			0 => "EASY", 
			2 => "HARD", 
			3 => "EXTREME", 
			_ => "NORMAL", 
		};
	}
}
internal sealed class EightPlayerDifficultyButton : MonoBehaviour
{
	private MMButton _button;

	private TextMeshProUGUI _label;

	private bool _selected;

	private bool _axisReady = true;

	public void Initialise(MMButton button, TextMeshProUGUI label)
	{
		//IL_0020: Unknown result type (might be due to invalid IL or missing references)
		//IL_002a: Expected O, but got Unknown
		_button = button;
		_label = label;
		((UnityEvent)((Button)_button).onClick).AddListener((UnityAction)delegate
		{
			ChangeMode(1);
		});
		_button.OnSelected = (Action)Delegate.Combine(_button.OnSelected, (Action)delegate
		{
			_selected = true;
		});
		_button.OnDeselected = (Action)Delegate.Combine(_button.OnDeselected, (Action)delegate
		{
			_selected = false;
			_axisReady = true;
		});
		RefreshLabel();
	}

	private void Update()
	{
		RefreshLabel();
		if (_selected)
		{
			PlayerFarming val = (((Object)(object)MonoSingleton<UINavigatorNew>.Instance != (Object)null) ? MonoSingleton<UINavigatorNew>.Instance.AllowInputOnlyFromPlayer : null);
			float horizontalAxis = InputManager.UI.GetHorizontalAxis(val);
			if (Mathf.Abs(horizontalAxis) < 0.2f)
			{
				_axisReady = true;
			}
			else if (_axisReady && Mathf.Abs(horizontalAxis) > 0.55f)
			{
				_axisReady = false;
				ChangeMode((horizontalAxis > 0f) ? 1 : (-1));
			}
		}
	}

	private void ChangeMode(int direction)
	{
		int mode = (EightPlayerDifficultyMenu.GetMode() + direction + 4) % 4;
		EightPlayerDifficultyMenu.SetMode(mode);
		RefreshLabel();
		UIManager.PlayAudio("event:/ui/change_selection");
		Plugin.Log.LogInfo((object)("[8PDifficulty] Changed to " + EightPlayerDifficultyMenu.GetModeName(mode)));
	}

	private void RefreshLabel()
	{
		if ((Object)(object)_label != (Object)null)
		{
			((TMP_Text)_label).text = "8P DIFFICULTY: " + EightPlayerDifficultyMenu.GetModeName(EightPlayerDifficultyMenu.GetMode());
			((TMP_Text)_label).enableAutoSizing = true;
			((TMP_Text)_label).fontSizeMin = 15f;
		}
	}
}
public static class Patches
{
	public struct TownCameraZoomState
	{
		public bool Applied;

		public bool EnforceConversationGroupZoom;

		public float MinZoom;

		public float MaxZoom;

		public float ZoomLimiter;

		public float ConversationGroupZoom;
	}

	private sealed class PlayerListScopeState
	{
		public int SavedPlayersCount;

		public List<PlayerFarming> HiddenPlayers;
	}

	private static readonly FieldInfo EnemyRoundSpawnPointSetsField = AccessTools.Field(typeof(EnemyRoundsRandom), "spawnPointSets");

	private static int _lastRegularBalancePlayerCount = -1;

	private static int _lastBossBalancePlayerCount = -1;

	private static bool _loggedPromptFallback;

	private static float _lastLoggedGroupCameraZoom = -1f;

	private static float _nextGroupCameraLogAt;

	private static bool _removingPlayer = false;

	private static bool _manualRemoveRequested = false;

	private static float _autoRemoveSuppressedUntil = 0f;

	private const float AutoRemoveSuppressSeconds = 8f;

	private static int _savedExtraSlotCount = 0;

	private static bool _autoRespawnRoutineRunning = false;

	private static float _nextAutoRespawnAttemptAt = 0f;

	private static float _nextAutoRespawnHeartbeatAt = 0f;

	private static float _nextControllerHealHeartbeatAt = 0f;

	private static float _nextRumbleCleanupAt = 0f;

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

	private static readonly Dictionary<int, bool> _pendingSpawnUseAnimation = new Dictionary<int, bool>();

	private static readonly Dictionary<int, float> _pendingSpawnFirstSeenAt = new Dictionary<int, float>();

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

	private static int _startupExtraRespawnDepth = 0;

	private static float _dungeonIntroProtectUntil = 0f;

	private static float _nextPendingBlockLogAt = 0f;

	private static string _lastLoggedDungeonRoomPath = null;

	private static bool _p2EntranceGuardRunning = false;

	private static bool _dungeonRoomStabilizeRunning = false;

	private static int _lastStabilizedDungeonRoomId = int.MinValue;

	private static float _nextDungeonRoomStabilizeCheckAt = 0f;

	private static float _roomEntryDistanceRepositionGraceUntil = 0f;

	private static int _roomTransitionWatchdogToken = 0;

	private static int _compactRoomEntryToken = 0;

	private static bool _initialWeaponAutoEquipRunning = false;

	private static int _initialWeaponAutoEquipRoomId = int.MinValue;

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

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

	private static float _lastObservedWakeHealth = 2f;

	private static float _lastObservedSacrificialWakeHealth = 2f;

	private static float _sacrificialReviveWindowUntil = 0f;

	private const float SacrificialReviveWindowSeconds = 7f;

	private const float BoostedWakeHealthThreshold = 2.01f;

	private static readonly Dictionary<int, float> _nextExtraFalseDownedWatchdogAt = new Dictionary<int, float>();

	private static readonly Dictionary<int, float> _postReviveRaceGuardUntil = new Dictionary<int, float>();

	private static readonly Dictionary<int, float> _nextPostReviveForceApplyAt = new Dictionary<int, float>();

	private static float _nextPostReviveRaceGuardHeartbeatAt = 0f;

	private const float PostReviveRaceGuardSeconds = 4f;

	private const float PostReviveRaceGuardPollInterval = 0.18f;

	private static readonly Image[] _playerWidgets = (Image[])(object)new Image[8];

	private static readonly RectTransform[] _playerArrows = (RectTransform[])(object)new RectTransform[8];

	private static readonly Dictionary<int, Sprite> _cachedSprites = new Dictionary<int, Sprite>();

	private static readonly Dictionary<int, Image> _cachedTextImages = new Dictionary<int, Image>();

	private static readonly Dictionary<int, SpriteRenderer> _cachedHaloSR = new Dictionary<int, SpriteRenderer>();

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

	private static readonly Dictionary<int, Sprite> _cachedHaloSprites = new Dictionary<int, Sprite>();

	private static readonly Dictionary<int, string> _haloSpriteNames = new Dictionary<int, string>
	{
		{ 2, "halo_orange.png" },
		{ 3, "halo_blue.png" },
		{ 4, "halo_green.png" },
		{ 5, "halo_yellow.png" },
		{ 6, "halo_cyan.png" },
		{ 7, "halo_pink.png" }
	};

	private static int _podiumExtraCount = 0;

	private static readonly Vector3[] SpawnOffsets = (Vector3[])(object)new Vector3[8]
	{
		Vector3.zero,
		new Vector3(0.65f, 0f, 0f),
		new Vector3(-0.65f, 0f, 0f),
		new Vector3(0f, 0.55f, 0f),
		new Vector3(0f, -0.55f, 0f),
		new Vector3(0.65f, 0.55f, 0f),
		new Vector3(-0.65f, 0.55f, 0f),
		new Vector3(-0.65f, -0.55f, 0f)
	};

	private static readonly Vector3[] InitialSpawnOffsets = (Vector3[])(object)new Vector3[8]
	{
		Vector3.zero,
		new Vector3(0f, -0.95f, 0f),
		new Vector3(1f, -0.58f, 0f),
		new Vector3(1.25f, 0.22f, 0f),
		new Vector3(0.55f, 0.84f, 0f),
		new Vector3(-0.55f, 0.84f, 0f),
		new Vector3(-1.25f, 0.22f, 0f),
		new Vector3(-1f, -0.58f, 0f)
	};

	private static readonly FieldInfo _playerControllerUntouchableTimerField = AccessTools.Field(typeof(PlayerController), "untouchableTimer");

	private static readonly FieldInfo _playerControllerInvincibleTimerField = AccessTools.Field(typeof(PlayerController), "invincibleTimer");

	private static readonly FieldInfo _playerControllerImmuneToProjectilesTimerField = AccessTools.Field(typeof(PlayerController), "immuneToProjectilesTimer");

	private static readonly FieldInfo _playerControllerUntouchableTimerFlashField = AccessTools.Field(typeof(PlayerController), "untouchableTimerFlash");

	private static Type _cachedHealthReflectionType;

	private static FieldInfo _healthInvincibleField;

	private static FieldInfo _healthUntouchableField;

	private static FieldInfo _healthIgnoreProjectilesField;

	private static FieldInfo _healthMaxHpField;

	private static FieldInfo _healthTotalHpField;

	private static PropertyInfo _healthIgnoreProjectilesProperty;

	private static PropertyInfo _healthMaxHpProperty;

	private static PropertyInfo _healthTotalHpProperty;

	private static MethodInfo _healthClearAllStasisEffectsMethod;

	private static bool _faithAmmoDumped = false;

	private static bool _delayedRespawnAfterReviveQueued = false;

	private const float DelayedReviveRespawnInitialDelay = 0.35f;

	private const float DelayedReviveRespawnPollInterval = 0.2f;

	private const float DelayedReviveRespawnMaxDuration = 15f;

	private static readonly Vector3[] _teleporterOffsets = (Vector3[])(object)new Vector3[8]
	{
		new Vector3(-0.6f, 0.6f, 0f),
		new Vector3(0.6f, 0.6f, 0f),
		new Vector3(-1.2f, 0f, 0f),
		new Vector3(1.2f, 0f, 0f),
		new Vector3(-0.6f, -0.6f, 0f),
		new Vector3(0.6f, -0.6f, 0f),
		new Vector3(-1.8f, -0.3f, 0f),
		new Vector3(1.8f, -0.3f, 0f)
	};

	private static readonly FieldInfo _teleporterStencilField = typeof(Interaction_BaseTeleporter).GetField("PlayerStencilRT", BindingFlags.Instance | BindingFlags.NonPublic);

	private static readonly FieldInfo _clearRubbleButtonDownField = typeof(Interaction_PlayerClearRubble).GetField("buttonDown", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _clearRubbleActivatingPlayersField = typeof(Interaction_PlayerClearRubble).GetField("activatingPlayers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _interactionPlayerFarmingField = typeof(Interaction).GetField("_playerFarming", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _dlcShrinePlayerAnimsSetField = typeof(Interaction_DLCShrine).GetField("playerAnimsSet", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _templeAltarActivatedField = typeof(Interaction_TempleAltar).GetField("Activated", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _templeAltarActivatingField = typeof(Interaction_TempleAltar).GetField("Activating", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _templeAltarCoopPlayerFrozenField = typeof(Interaction_TempleAltar).GetField("CoopPlayerFrozen", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _templeAltarInteractedField = typeof(Interaction_TempleAltar).GetField("<Interacted>k__BackingField", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _templeAltarColliderField = typeof(Interaction_TempleAltar).GetField("Collider", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _templeAltarForceRitualField = typeof(Interaction_TempleAltar).GetField("forceRitual", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static bool _templeExtraReleaseQueued = false;

	private static bool _loggedFishingBoundsSuppressed = false;

	private static readonly Stack<PlayerListScopeState> _twoPlayerListScopes = new Stack<PlayerListScopeState>();

	private static bool _spawnedExtraWeaponPodiums = false;

	private static bool _spawnedExtraSpellPodiums = false;

	private static readonly FieldInfo _twinPodiumField = typeof(Interaction_WeaponSelectionPodium).GetField("TwinPodium", BindingFlags.Instance | BindingFlags.NonPublic);

	private static readonly FieldInfo _podiumWeaponLevelField = typeof(Interaction_WeaponSelectionPodium).GetField("WeaponLevel", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly FieldInfo _podiumIncreaseWeaponLevelField = typeof(Interaction_WeaponSelectionPodium).GetField("increaseWeaponLevel", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);

	private static readonly MethodInfo _podiumTryToOpenDoorsMethod = typeof(Interaction_WeaponSelectionPodium).GetMethod("TryToOpenDoors", BindingFlags.Instance | BindingFlags.NonPublic);

	private static readonly Dictionary<int, List<Interaction_WeaponSelectionPodium>> _podiumClones = new Dictionary<int, List<Interaction_WeaponSelectionPodium>>();

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

	private static bool _positioningDeferred = false;

	private static readonly Dictionary<int, GameObject> _extraHeartBars = new Dictionary<int, GameObject>();

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

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

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

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

	private static readonly MethodInfo _hudHeartsClearHealthEvents = typeof(HUD_Hearts).GetMethod("ClearHealthEvents", BindingFlags.Instance | BindingFlags.NonPublic);

	private static readonly FieldInfo _hudHeartsCreatedLoopField = typeof(HUD_Hearts).GetField("createdloop", BindingFlags.Instance | BindingFlags.NonPublic);

	private static readonly MethodInfo _faithAmmoUpdateBar = typeof(FaithAmmo).GetMethod("UpdateBar", BindingFlags.Instance | BindingFlags.NonPublic);

	private static readonly FieldInfo _coopIndicatorAnimateOnDamagedField = typeof(CoopIndicatorIcon).GetField("animateIconOnDamaged", BindingFlags.Instance | BindingFlags.NonPublic);

	private static bool _reroutingFaithAmmoUse = false;

	private static bool _rewiredPlayersExpanded = false;

	private static bool _rewiredPlayerExpansionFailureLogged = false;

	private static bool _assignmentJoystickClampLogged = false;

	private static bool _assignmentUpdateFailureLogged = false;

	private static readonly HashSet<string> _installedVJoyMaps = new HashSet<string>();

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

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

	private static readonly FieldInfo _coopAssignPreventSpawnBufferTimeField = typeof(UICoopAssignController).GetField("preventSpawnBufferTime", BindingFlags.Instance | BindingFlags.NonPublic);

	private static readonly MethodInfo _coopAssignCheckInputsForSpawnButtonMethod = typeof(UICoopAssignController).GetMethod("CheckInputsForSpawnButton", BindingFlags.Instance | BindingFlags.NonPublic);

	private static readonly MethodInfo _coopAssignConfirmSpawnButtonPressMethod = typeof(UICoopAssignController).GetMethod("ConfirmSpawnButtonPress", BindingFlags.Instance | BindingFlags.NonPublic);

	private static int _safeBiomeClearPatchCountLog = -1;

	private static readonly Dictionary<char, int[]> _digitBitmaps = new Dictionary<char, int[]>
	{
		{
			'1',
			new int[35]
			{
				0, 1, 1, 0, 0, 1, 1, 1, 0, 0,
				0, 1, 1, 0, 0, 0, 1, 1, 0, 0,
				0, 1, 1, 0, 0, 0, 1, 1, 0, 0,
				1, 1, 1, 1, 0
			}
		},
		{
			'2',
			new int[35]
			{
				1, 1, 1, 1, 0, 1, 0, 0, 1, 1,
				0, 0, 0, 1, 1, 0, 1, 1, 1, 0,
				1, 1, 0, 0, 0, 1, 1, 0, 0, 0,
				1, 1, 1, 1, 1
			}
		},
		{
			'3',
			new int[35]
			{
				1, 1, 1, 1, 0, 1, 0, 0, 1, 1,
				0, 0, 0, 1, 1, 0, 1, 1, 1, 0,
				0, 0, 0, 1, 1, 1, 0, 0, 1, 1,
				1, 1, 1, 1, 0
			}
		},
		{
			'4',
			new int[35]
			{
				0, 0, 1, 1, 0, 0, 1, 1, 1, 0,
				1, 1, 0, 1, 0, 1, 0, 0, 1, 0,
				1, 1, 1, 1, 1, 0, 0, 0, 1, 0,
				0, 0, 1, 1, 0
			}
		},
		{
			'5',
			new int[35]
			{
				1, 1, 1, 1, 1, 1, 1, 0, 0, 0,
				1, 1, 0, 0, 0, 1, 1, 1, 1, 0,
				0, 0, 0, 1, 1, 1, 0, 0, 1, 1,
				1, 1, 1, 1, 0
			}
		},
		{
			'6',
			new int[35]
			{
				0, 1, 1, 1, 1, 1, 1, 0, 0, 0,
				1, 1, 0, 0, 0, 1, 1, 1, 1, 0,
				1, 1, 0, 1, 1, 1, 0, 0, 1, 1,
				0, 1, 1, 1, 0
			}
		},
		{
			'7',
			new int[35]
			{
				1, 1, 1, 1, 1, 0, 0, 0, 1, 1,
				0, 0, 1, 1, 0, 0, 1, 1, 0, 0,
				1, 1, 0, 0, 0, 1, 1, 0, 0, 0,
				1, 1, 0, 0, 0
			}
		},
		{
			'8',
			new int[35]
			{
				0, 1, 1, 1, 0, 1, 1, 0, 1, 1,
				1, 1, 0, 1, 1, 0, 1, 1, 1, 0,
				1, 1, 0, 1, 1, 1, 1, 0, 1, 1,
				0, 1, 1, 1, 0
			}
		}
	};

	public static void PauseMenu_Start_Difficulty_Postfix(UIPauseMenuController __instance)
	{
		EightPlayerDifficultyMenu.Attach(__instance);
	}

	public static void MMConversation_Update_InputRecovery_Prefix()
	{
		CoopConversationSession.Tick();
		if (!MMConversation.isPlaying || MMConversation.CURRENT_CONVERSATION == null || PlayerFarming.players == null)
		{
			return;
		}
		UINavigatorNew instance = MonoSingleton<UINavigatorNew>.Instance;
		if ((Object)(object)instance == (Object)null || CoopConversationSession.KeepInputWithOwner(instance))
		{
			return;
		}
		PlayerFarming allowInputOnlyFromPlayer = instance.AllowInputOnlyFromPlayer;
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)((Component)player).gameObject == (Object)null || !((Component)player).gameObject.activeInHierarchy)
			{
				continue;
			}
			try
			{
				if (InputManager.Gameplay.GetAdvanceDialogueButtonDown(player))
				{
					instance.AllowInputOnlyFromPlayer = player;
					if ((Object)(object)allowInputOnlyFromPlayer != (Object)(object)player)
					{
						Plugin.Log.LogInfo((object)$"[QoL] Conversation advance ownership recovered with P{(player.isLamb ? 1 : (player.playerID + 1))}");
					}
					return;
				}
			}
			catch
			{
			}
		}
		if ((Object)(object)allowInputOnlyFromPlayer == (Object)null || (Object)(object)((Component)allowInputOnlyFromPlayer).gameObject == (Object)null || !((Component)allowInputOnlyFromPlayer).gameObject.activeInHierarchy)
		{
			instance.AllowInputOnlyFromPlayer = PlayerFarming.Instance;
		}
	}

	public static void MMConversation_Play_Prefix(bool SetPlayerInactiveOnStart)
	{
		CoopConversationSession.Prepare(SetPlayerInactiveOnStart);
	}

	public static void MMConversation_Play_Postfix()
	{
		CoopConversationSession.Activate();
	}

	public static void MMConversation_DoClose_Prefix(out int __state)
	{
		__state = CoopConversationSession.CaptureGeneration();
	}

	public static void MMConversation_DoClose_Postfix(int __state)
	{
		CoopConversationSession.EndSession(__state);
	}

	public static void MMConversation_ClearConversation_Postfix()
	{
		CoopConversationSession.ForceEndSession();
	}

	public static bool GameManager_ConversationPresentation_Prefix()
	{
		if (!CoopConversationSession.Active)
		{
			return !CoopMenuOverlaySession.BlocksFollowerWheelPresentation;
		}
		return false;
	}

	public static bool CoopManager_ConversationFreeze_Prefix()
	{
		return !CoopConversationSession.Active;
	}

	private static int GetBalancedCoopPlayerCount()
	{
		int num = 0;
		if (PlayerFarming.players != null)
		{
			foreach (PlayerFarming player in PlayerFarming.players)
			{
				if ((Object)(object)player != (Object)null && (Object)(object)((Component)player).gameObject != (Object)null && ((Component)player).gameObject.activeInHierarchy)
				{
					num++;
				}
			}
		}
		if (CoopManager.CoopActive && _savedExtraSlotCount > 0)
		{
			num = Mathf.Max(num, 2 + _savedExtraSlotCount);
		}
		return Mathf.Clamp(num, 1, 8);
	}

	public static void EnemyHealth_InitHP_Postfix(Health __instance)
	{
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0028: Invalid comparison between Unknown and I4
		//IL_002c: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance == (Object)null || __instance.isPlayer || __instance.isPlayerAlly || __instance.InanimateObject || (int)__instance.team != 2)
		{
			return;
		}
		bool flag;
		try
		{
			flag = GameManager.IsDungeon(PlayerFarming.Location);
		}
		catch
		{
			return;
		}
		if (!flag)
		{
			return;
		}
		int balancedCoopPlayerCount = GetBalancedCoopPlayerCount();
		if (balancedCoopPlayerCount <= 2)
		{
			return;
		}
		CoopEnemyBalanceMarker coopEnemyBalanceMarker = ((Component)__instance).GetComponent<CoopEnemyBalanceMarker>();
		if ((Object)(object)coopEnemyBalanceMarker != (Object)null && coopEnemyBalanceMarker.Applied)
		{
			return;
		}
		UnitObject component = ((Component)__instance).GetComponent<UnitObject>();
		if ((Object)(object)component == (Object)null)
		{
			return;
		}
		string text = ((object)component).GetType().Name + " " + ((Object)((Component)component).gameObject).name;
		bool num = component.IsBoss || (Object)(object)((Component)component).GetComponentInParent<MiniBossController>() != (Object)null || text.IndexOf("boss", StringComparison.OrdinalIgnoreCase) >= 0 || text.IndexOf("leader", StringComparison.OrdinalIgnoreCase) >= 0;
		float num2 = balancedCoopPlayerCount - 2;
		float num3 = (num ? (1f + num2 * 0.65f) : (1f + num2 * 0.25f));
		if ((Object)(object)coopEnemyBalanceMarker == (Object)null)
		{
			coopEnemyBalanceMarker = ((Component)__instance).gameObject.AddComponent<CoopEnemyBalanceMarker>();
		}
		coopEnemyBalanceMarker.Applied = true;
		coopEnemyBalanceMarker.PlayerCount = balancedCoopPlayerCount;
		coopEnemyBalanceMarker.Multiplier = num3;
		__instance.totalHP = Mathf.Max(1f, __instance.totalHP * num3);
		__instance.HP = __instance.totalHP;
		if (num)
		{
			if (_lastBossBalancePlayerCount != balancedCoopPlayerCount)
			{
				_lastBossBalancePlayerCount = balancedCoopPlayerCount;
				Plugin.Log.LogInfo((object)$"[Balance] Boss HP x{num3:0.00} for {balancedCoopPlayerCount} players");
			}
		}
		else if (_lastRegularBalancePlayerCount != balancedCoopPlayerCount)
		{
			_lastRegularBalancePlayerCount = balancedCoopPlayerCount;
			Plugin.Log.LogInfo((object)$"[Balance] Enemy HP x{num3:0.00} for {balancedCoopPlayerCount} players");
		}
	}

	public static void EnemyGroupsChance_InitEnemies_Prefix(EnemyGroupsChance __instance)
	{
		//IL_0027: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance == (Object)null || __instance.Groups == null || __instance.Groups.Count < 2 || GetBalancedCoopPlayerCount() < 5 || !GameManager.IsDungeon(PlayerFarming.Location) || (Object)(object)RoomManager.r == (Object)null || RoomManager.r.EnemyChoice != -1)
		{
			return;
		}
		int num = -1;
		List<int> list = new List<int>();
		for (int i = 0; i < __instance.Groups.Count; i++)
		{
			GroupProbability val = __instance.Groups[i];
			if (val != null && !((Object)(object)val.GroupObject == (Object)null))
			{
				int num2 = val.GroupObject.GetComponentsInChildren<UnitObject>(true).Length;
				if (num2 > num)
				{
					num = num2;
					list.Clear();
					list.Add(i);
				}
				else if (num2 == num)
				{
					list.Add(i);
				}
			}
		}
		if (num > 0 && list.Count > 0)
		{
			RoomManager.r.EnemyChoice = list[Random.Range(0, list.Count)];
			Plugin.Log.LogInfo((object)$"[Balance] Selected dense room group {RoomManager.r.EnemyChoice + 1}/{__instance.Groups.Count} ({num} enemies)");
		}
	}

	public static void EnemyRoundsRandom_GetEnemyRound_Postfix(EnemyRoundsRandom __instance, List<AssetReferenceGameObject> __result)
	{
		//IL_0021: Unknown result type (might be due to invalid IL or missing references)
		int balancedCoopPlayerCount = GetBalancedCoopPlayerCount();
		if ((Object)(object)__instance == (Object)null || __result == null || __result.Count <= 0 || balancedCoopPlayerCount < 4 || !GameManager.IsDungeon(PlayerFarming.Location) || EnemyRoundSpawnPointSetsField == null || !(EnemyRoundSpawnPointSetsField.GetValue(__instance) is Array { Length: not 0 } array))
		{
			return;
		}
		int count = __result.Count;
		int num = Mathf.Min(count + Mathf.CeilToInt((float)(balancedCoopPlayerCount - 2) * 0.65f), Mathf.CeilToInt((float)count * 1.55f));
		int num2 = count;
		foreach (object item in array)
		{
			if (item != null)
			{
				FieldInfo field = item.GetType().GetField("Positions", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				Array array2 = ((field != null) ? (field.GetValue(item) as Array) : null);
				if (array2 != null && array2.Length > num2 && array2.Length <= num)
				{
					num2 = array2.Length;
				}
			}
		}
		if (num2 > count)
		{
			for (int i = count; i < num2; i++)
			{
				__result.Add(__result[i % count]);
			}
			Plugin.Log.LogInfo((object)$"[Balance] Expanded random enemy round {count} -> {num2} for {balancedCoopPlayerCount} players");
		}
	}

	public static void CameraFollowTarget_LateUpdate_Prefix(CameraFollowTarget __instance, out TownCameraZoomState __state)
	{
		//IL_0027: 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_02df: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e8: Unknown result type (might be due to invalid IL or missing references)
		//IL_02f8: 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_0318: Unknown result type (might be due to invalid IL or missing references)
		__state = default(TownCameraZoomState);
		TransitionVotePlayerState.KeepHiddenOutOfCamera(__instance);
		int balancedCoopPlayerCount = GetBalancedCoopPlayerCount();
		bool flag = (Object)(object)__instance != (Object)null && balancedCoopPlayerCount > 1 && CoopManager.CoopActive && GameManager.IsDungeon(PlayerFarming.Location) && !MMTransition.IsPlaying && !LetterBox.IsPlaying;
		bool flag2 = (Object)(object)__instance != (Object)null && balancedCoopPlayerCount > 1 && CoopManager.CoopActive && MMConversation.isPlaying && !MMTransition.IsPlaying && !LetterBox.IsPlaying;
		bool flag3 = CoopConversationSession.Active || flag2 || flag;
		if (flag3 && (Object)(object)__instance.TargetCamera != (Object)null)
		{
			__instance.ResetTargetCamera(0f);
			Plugin.Log.LogWarning((object)"[Camera8P] Cleared a stale single-target camera while preserving the co-op group");
		}
		if ((Object)(object)__instance == (Object)null || balancedCoopPlayerCount <= 1 || !CoopManager.CoopActive || (!flag3 && (Object)(object)__instance.TargetCamera != (Object)null) || (!flag3 && MMConversation.isPlaying) || MMTransition.IsPlaying || (!flag3 && LetterBox.IsPlaying) || PlayerFarming.players == null)
		{
			return;
		}
		if (flag3)
		{
			__instance.DisablePlayerLook = false;
			__instance.IN_CONVERSATION = false;
			__instance.SnappyMovement = false;
			__instance.SetOffset(Vector3.zero);
			__instance.CurrentOffset = Vector3.zero;
			if ((Object)(object)__instance.TargetCamera != (Object)null)
			{
				__instance.ResetTargetCamera(0f);
			}
		}
		HashSet<GameObject> hashSet = new HashSet<GameObject>();
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player != (Object)null && (Object)(object)((Component)player).gameObject != (Object)null && ((Component)player).gameObject.activeInHierarchy && (Object)(object)player.CameraBone != (Object)null && !TransitionVotePlayerState.IsHidden(player))
			{
				hashSet.Add(player.CameraBone);
			}
		}
		if (__instance.targets != null)
		{
			for (int num = __instance.targets.Count - 1; num >= 0; num--)
			{
				Target val = __instance.targets[num];
				if (val == null || (Object)(object)val.gameObject == (Object)null || !hashSet.Contains(val.gameObject))
				{
					__instance.targets.RemoveAt(num);
				}
				else
				{
					val.Weight = 1f;
				}
			}
		}
		int num2 = 0;
		float num3 = float.MaxValue;
		float num4 = float.MinValue;
		float num5 = float.MaxValue;
		float num6 = float.MinValue;
		foreach (PlayerFarming player2 in PlayerFarming.players)
		{
			if (!((Object)(object)player2 == (Object)null) && !((Object)(object)((Component)player2).gameObject == (Object)null) && ((Component)player2).gameObject.activeInHierarchy && !((Object)(object)player2.CameraBone == (Object)null) && !TransitionVotePlayerState.IsHidden(player2))
			{
				if (!__instance.Contains(player2.CameraBone))
				{
					__instance.AddTarget(player2.CameraBone, 1f);
				}
				Vector3 position = player2.CameraBone.transform.position;
				num3 = Mathf.Min(num3, position.x);
				num4 = Mathf.Max(num4, position.x);
				num5 = Mathf.Min(num5, position.y);
				num6 = Mathf.Max(num6, position.y);
				num2++;
			}
		}
		if (num2 > 1)
		{
			__state.Applied = true;
			__state.MinZoom = __instance.MinZoom;
			__state.MaxZoom = __instance.MaxZoom;
			__state.ZoomLimiter = __instance.ZoomLimiter;
			float num7 = Mathf.Max(0f, num4 - num3);
			float num8 = Mathf.Max(0f, num6 - num5);
			float num9 = Mathf.Max(1f, (float)Screen.width / Mathf.Max(1f, (float)Screen.height));
			float num10 = ((flag2 || CoopConversationSession.Active) ? 11f : Mathf.Max(11f, __instance.targetDistance)) + Mathf.Max(num7 / num9 * 0.9f, num8 * 1.08f);
			num10 = Mathf.Clamp(num10, Mathf.Max(13f, __instance.MaxZoom), 38f);
			float num11 = Mathf.Max(num7, num8);
			__instance.MaxZoom = num10;
			__instance.ZoomLimiter = Mathf.Max(2.5f, num11);
			if (flag2 || CoopConversationSession.Active)
			{
				__state.EnforceConversationGroupZoom = true;
				__state.ConversationGroupZoom = num10;
				__instance.targetDistance = num10;
			}
			if (Time.unscaledTime >= _nextGroupCameraLogAt && Mathf.Abs(num10 - _lastLoggedGroupCameraZoom) >= 2f)
			{
				_nextGroupCameraLogAt = Time.unscaledTime + 2f;
				_lastLoggedGroupCameraZoom = num10;
				Plugin.Log.LogInfo((object)$"[Camera8P] Group spread {num7:0.0}x{num8:0.0}; dynamic zoom target {num10:0.0}");
			}
		}
	}

	public static void CameraFollowTarget_LateUpdate_Postfix(CameraFollowTarget __instance, TownCameraZoomState __state)
	{
		if (!((Object)(object)__instance == (Object)null) && __state.Applied)
		{
			__instance.MinZoom = __state.MinZoom;
			__instance.MaxZoom = __state.MaxZoom;
			__instance.ZoomLimiter = __state.ZoomLimiter;
			if (__state.EnforceConversationGroupZoom)
			{
				__instance.targetDistance = __state.ConversationGroupZoom;
			}
		}
	}

	public static void CoopContextInteraction_Capture_Prefix(StateMachine state)
	{
		CoopMenuOverlaySession.CapturePlayerStates(ResolvePlayerFromStateMachine(state));
	}

	public static void Kitchen_ShowMenu_Capture_Prefix(Interaction_Kitchen __instance)
	{
		PlayerFarming val = null;
		if (PlayerFarming.players != null)
		{
			foreach (PlayerFarming player in PlayerFarming.players)
			{
				if ((Object)(object)player != (Object)null && ((Object)(object)player.currentInteraction == (Object)(object)__instance || (Object)(object)player.previousInteraction == (Object)(object)__instance))
				{
					val = player;
					break;
				}
			}
		}
		if ((Object)(object)val == (Object)null && _interactionPlayerFarmingField != null)
		{
			object? value = _interactionPlayerFarmingField.GetValue(__instance);
			val = (PlayerFarming)((value is PlayerFarming) ? value : null);
		}
		if ((Object)(object)val != (Object)null)
		{
			CoopMenuOverlaySession.CapturePlayerStates(val);
			Plugin.Log.LogInfo((object)$"[QoL] Captured kitchen menu owner P{val.playerID + 1}");
		}
	}

	public static void FollowerWheel_Show_Postfix(UIFollowerInteractionWheelOverlayController __instance, PlayerFarming playerFarming)
	{
		PlayerFarming owner = CoopMenuOverlaySession.ResolveOwner(playerFarming);
		CoopMenuOverlaySession.Attach((Component)(object)__instance, owner, 1f, 0.025f, restoreConversationCamera: true, "follower wheel");
	}

	public static void CookingFireMenu_Show_Postfix(UICookingFireMenuController __result)
	{
		CoopMenuOverlaySession.Attach((Component)(object)__result, CoopMenuOverlaySession.ResolveOwner(), 0.3f, 0.025f, restoreConversationCamera: false, "cooking menu");
	}

	public static void KitchenMenu_Show_Postfix(UIKitchenMenuController __result)
	{
		CoopMenuOverlaySession.Attach((Component)(object)__result, CoopMenuOverlaySession.ResolveOwner(), 0.3f, 0.025f, restoreConversationCamera: false, "kitchen menu");
	}

	public static void CookingMinigame_Initialise_Postfix(UICookingMinigameOverlayController __instance)
	{
		CoopMenuOverlaySession.Attach((Component)(object)__instance, CoopMenuOverlaySession.ResolveOwner(), 0.34f, 0.025f, restoreConversationCamera: true, "cooking minigame");
	}

	public static void RepairMinigame_Initialise_Postfix(UIRebuildBedMinigameOverlayController __instance)
	{
		CoopMenuOverlaySession.Attach((Component)(object)__instance, CoopMenuOverlaySession.ResolveOwner(), 0.34f, 0.025f, restoreConversationCamera: true, "repair minigame");
	}

	public static void IndependentHoldAction_Prefix(Interaction __instance)
	{
		if ((Object)(object)__instance == (Object)null || PlayerFarming.players == null || PlayerFarming.players.Count <= 1)
		{
			return;
		}
		string name = ((object)__instance).GetType().Name;
		if (name.IndexOf("Collect", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Devotion", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Compost", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Berries", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Woodcutting", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("ClearToxicWaste", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("PlayerClearRubble", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("FarmCrop", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Weed", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("Hatchery", StringComparison.OrdinalIgnoreCase) >= 0 || name.IndexOf("PlayerBuild", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			__instance.FreezeCoopPlayersOnHoldToInteract = false;
			if (name.IndexOf("PlayerBuild", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				__instance.allowMultipleInteractors = true;
			}
			FieldInfo field = ((object)__instance).GetType().GetField("RequireUseOthersFirst", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (field != null && field.FieldType == typeof(bool))
			{
				field.SetValue(__instance, false);
			}
		}
	}

	public static void Interaction_OnInteract_OwnerRecovery_Postfix(Interaction __instance, StateMachine state)
	{
		if (!((Object)(object)__instance == (Object)null) && !(_interactionPlayerFarmingField == null))
		{
			PlayerFarming val = ResolvePlayerFromStateMachine(state);
			if ((Object)(object)val != (Object)null)
			{
				_interactionPlayerFarmingField.SetValue(__instance, val);
			}
		}
	}

	public static void Interaction_CanMultiplePlayersInteract_Postfix(Interaction __instance, ref bool __result)
	{
		if (__instance is Interaction_PlayerBuild || __instance is Interaction_PlayerBuildProject)
		{
			__result = true;
		}
	}

	public static void PlayerBuild_OnInteract_Prefix(Interaction_PlayerBuild __instance)
	{
		if (!((Object)(object)__instance == (Object)null))
		{
			((Interaction)__instance).allowMultipleInteractors = true;
			((Interaction)__instance).FreezeCoopPlayersOnHoldToInteract = false;
		}
	}

	public static Exception MMControlPrompt_AssignPrompt_Finalizer(Exception __exception)
	{
		if (__exception == null)
		{
			return null;
		}
		if (!(__exception is NullReferenceException))
		{
			return __exception;
		}
		if (!_loggedPromptFallback)
		{
			_loggedPromptFallback = true;
			Plugin.Log.LogWarning((object)"[Input] Missing vJoy prompt art was ignored; menu input remains usable and F10 is the emergency exit");
		}
		return null;
	}

	public static void Structure_ProgressCompleted_Postfix(Structure __instance)
	{
		//IL_0009: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)__instance == (Object)null) && !GameManager.IsDungeon(PlayerFarming.Location) && ((object)Unsafe.As<TYPES, TYPES>(ref __instance.Type)/*cast due to .constrained prefix*/).ToString().IndexOf("TEMPLE", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			CoopConversationSession.BeginTownEventRecovery(10f, "temple construction completed");
		}
	}

	private static PlayerFarming ResolvePlayerFromStateMachine(StateMachine state)
	{
		if ((Object)(object)state == (Object)null)
		{
			return null;
		}
		PlayerFarming val = ((Component)state).GetComponent<PlayerFarming>() ?? ((Component)state).GetComponentInParent<PlayerFarming>() ?? ((Component)state).GetComponentInChildren<PlayerFarming>(true);
		if ((Object)(object)val != (Object)null)
		{
			return val;
		}
		if (PlayerFarming.players != null)
		{
			foreach (PlayerFarming player in PlayerFarming.players)
			{
				if ((Object)(object)player != (Object)null && (Object)(object)player.state == (Object)(object)state)
				{
					return player;
				}
			}
		}
		return null;
	}

	public static void RegisterRewiredPlayerExpansionPatch(Harmony harmony)
	{
		//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_0080: Expected O, but got Unknown
		//IL_0080: Expected O, but got Unknown
		try
		{
			MethodInfo methodInfo = AccessTools.TypeByName("lNiLuHSggoLjokYLQforkkbXwySd")?.GetMethod("nCqQXpERRSjcZexCfinOHERlXKhM", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			if (methodInfo == null)
			{
				methodInfo = FindRewiredPlayerManagerInitializeMethod(FindRewiredPlayerManagerType());
			}
			if (methodInfo == null)
			{
				Plugin.Log.LogError((object)"[MP8] Rewired player-manager initializer was not found; players 5-8 cannot be created");
				return;
			}
			harmony.Patch((MethodBase)methodInfo, new HarmonyMethod(typeof(Patches), "RewiredPlayerManager_Initialize_Prefix", (Type[])null), new HarmonyMethod(typeof(Patches), "RewiredPlayerManager_Initialize_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Plugin.Log.LogInfo((object)"[MP8] Registered pre-initialization Rewired player expansion");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogError((object)("[MP8] Could not register Rewired player expansion: " + ex.GetType().Name + ": " + ex.Message));
		}
	}

	private static Type FindRewiredPlayerManagerType()
	{
		FieldInfo[] fields = typeof(ReInput).GetFields(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		for (int i = 0; i < fields.Length; i++)
		{
			Type fieldType = fields[i].FieldType;
			MethodInfo[] methods = fieldType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
			bool flag = false;
			for (int j = 0; j < methods.Length; j++)
			{
				ParameterInfo[] parameters = methods[j].GetParameters();
				if (methods[j].ReturnType == typeof(Player) && parameters.Length == 1 && parameters[0].ParameterType == typeof(int))
				{
					flag = true;
					break;
				}
			}
			if (flag && FindRewiredPlayerManagerInitializeMethod(fieldType) != null)
			{
				return fieldType;
			}
		}
		return null;
	}

	private static MethodInfo FindRewiredPlayerManagerInitializeMethod(Type playerManagerType)
	{
		if (playerManagerType == null)
		{
			return null;
		}
		MethodInfo[] methods = playerManagerType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public);
		for (int i = 0; i < methods.Length; i++)
		{
			if (methods[i].ReturnType == typeof(void) && methods[i].GetParameters().Length == 0)
			{
				return methods[i];
			}
		}
		return null;
	}

	public static void RewiredPlayerManager_Initialize_Prefix()
	{
		if (_rewiredPlayersExpanded)
		{
			return;
		}
		try
		{
			object obj = null;
			PropertyInfo[] properties = typeof(ReInput).GetProperties(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
			for (int i = 0; i < properties.Length; i++)
			{
				if (properties[i].PropertyType.FullName == "Rewired.Data.UserData")
				{
					obj = properties[i].GetValue(null, null);
					break;
				}
			}
			if (obj == null)
			{
				throw new InvalidOperationException("Rewired UserData is unavailable");
			}
			Type type = obj.GetType();
			PropertyInfo property = type.GetProperty("playerCount", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method = type.GetMethod("DuplicatePlayer", BindingFlags.Instance | BindingFlags.Public);
			MethodInfo method2 = type.GetMethod("GetPlayer", BindingFlags.Instance | BindingFlags.Public, null, new Type[1] { typeof(int) }, null);
			if (property == null || method == null)
			{
				throw new MissingMethodException("Rewired UserData player editor API is unavailable");
			}
			int num = Convert.ToInt32(property.GetValue(obj, null));
			int num2 = 9;
			int num3;
			for (num3 = num; num3 < num2; num3 = Convert.ToInt32(property.GetValue(obj, null)))
			{
				int num4 = Math.Max(1, num3 - 1);
				method.Invoke(obj, new object[1] { num4 });
			}
			if (method2 != null)
			{
				for (int j = num; j < num3; j++)
				{
					object? instance = method2.Invoke(obj, new object[1] { j });
					SetPrivateFieldIfPresent(instance, "_startPlaying", true);
					SetPrivateFieldIfPresent(instance, "_assignMouseOnStart", false);
					SetPrivateFieldIfPresent(instance, "_assignKeyboardOnStart", false);
					SetPrivateFieldIfPresent(instance, "_excludeFromControllerAutoAssignment", false);
				}
			}
			_rewiredPlayersExpanded = num3 >= num2;
			Plugin.Log.LogInfo((object)$"[MP8] Rewired UserData expanded from {Math.Max(0, num - 1)} to {Math.Max(0, num3 - 1)} runtime players");
		}
		catch (Exception ex)
		{
			if (!_rewiredPlayerExpansionFailureLogged)
			{
				_rewiredPlayerExpansionFailureLogged = true;
				Plugin.Log.LogError((object)("[MP8] Rewired player expansion failed: " + ex.GetType().Name + ": " + ex.Message));
			}
		}
	}

	public static void RewiredPlayerManager_Initialize_Postfix()
	{
		try
		{
			Plugin.Log.LogInfo((object)$"[MP8] Rewired runtime player profiles ready: {ReInput.players.playerCount}/{8}");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP8] Could not verify Rewired runtime player count: " + ex.Message));
		}
	}

	private static void SetPrivateFieldIfPresent(object instance, string fieldName, object value)
	{
		instance?.GetType().GetField(fieldName, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.SetValue(instance, value);
	}

	public static void CoopManager_Awake()
	{
		GameObject[] allPlayerGameObjects = CoopManager.AllPlayerGameObjects;
		if (allPlayerGameObjects.Length < 8)
		{
			GameObject[] array = (GameObject[])(object)new GameObject[8];
			for (int i = 0; i < allPlayerGameObjects.Length; i++)
			{
				array[i] = allPlayerGameObjects[i];
			}
			typeof(CoopManager).GetField("AllPlayerGameObjects", BindingFlags.Static | BindingFlags.Public).SetValue(null, array);
			Plugin.Log.LogInfo((object)$"AllPlayerGameObjects expanded to {8}");
		}
	}

	public static void OnControllerConnected(ControllerStatusChangedEventArgs args)
	{
		if (!CoopManager.CoopActive || PlayerFarming.playersCount >= 8 || (Object)(object)CoopManager.Instance == (Object)null || CoopManager.Instance.IsSpawningOrRemovingPlayer)
		{
			return;
		}
		Joystick val = null;
		foreach (Joystick joystick in ReInput.controllers.Joysticks)
		{
			if (((Controller)joystick).id == args.controllerId)
			{
				val = joystick;
				break;
			}
		}
		if (val == null)
		{
			return;
		}
		for (int i = 0; i < 8; i++)
		{
			Player player = RewiredInputManager.GetPlayer(i);
			if (player != null && player.controllers.ContainsController((Controller)(object)val))
			{
				Plugin.Log.LogInfo((object)$"OnControllerConnected: already assigned to slot {i}, skipping");
				return;
			}
		}
		int playersCount = PlayerFarming.playersCount;
		Plugin.Log.LogInfo((object)$"OnControllerConnected: auto-assigning to slot {playersCount}");
		for (int j = 0; j < 8; j++)
		{
			RewiredInputManager.GetPlayer(j).controllers.RemoveController((Controller)(object)val);
		}
		Player player2 = RewiredInputManager.GetPlayer(playersCount);
		player2.controllers.AddController((Controller)(object)val, true);
		EnsureVJoyMapForPlayer(player2, val, "OnControllerConnected");
		MarkDesiredExtraSlot(playersCount, desired: true);
		if (playersCount >= 2)
		{
			_pendingSpawnSlots.Add(playersCount);
		}
		CoopManager.Instance.SpawnCoopPlayer(playersCount, false, 0f);
		CoopManager.CoopActive = true;
		CoopManager.RefreshCoopPlayerRewired();
		TryStopAllRumble("OnControllerConnected");
		Plugin.Log.LogInfo((object)$"Auto-spawned goat at slot {playersCount}");
	}

	public static bool AddPlayerFromMenu()
	{
		if (PlayerFarming.playersCount < 8)
		{
			Plugin.Log.LogInfo((object)$"AddPlayerFromMenu: players={PlayerFarming.playersCount}, opening assign menu");
			UICoopAssignController obj = MonoSingleton<UIManager>.Instance.ShowCoopAssignMenu();
			((UIMenuBase)obj).OnHidden = (Action)Delegate.Combine(((UIMenuBase)obj).OnHidden, (Action)delegate
			{
				if (CoopManager.CoopActive)
				{
					CoopManager.AddtionalUser = UserHelper.GetPlayer(1);
				}
			});
		}
		return false;
	}

	public static bool OnCoopButtonPressed(UIPauseMenuController __instance)
	{
		Plugin.Log.LogInfo((object)$"OnCoopButtonPressed: players={PlayerFarming.playersCount}, coopActive={CoopManager.CoopActive}");
		if (PlayerFarming.playersCount < 8)
		{
			((UIMenuBase)__instance).Hide(true);
			CoopManager.AddPlayerFromMenu();
			return false;
		}
		if (CoopManager.CoopActive)
		{
			((UIMenuBase)__instance).Hide(false);
			_manualRemoveRequested = true;
			CoopManager.RemovePlayerFromMenu();
			return false;
		}
		return true;
	}

	public static void RefreshCoopText(UIPauseMenuController __instance)
	{
		//IL_006c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0073: Expected O, but got Unknown
		//IL_008a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0091: Expected O, but got Unknown
		FieldInfo field = typeof(UIPauseMenuController).GetField("_coopButtonText", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field2 = typeof(UIPauseMenuController).GetField("_coopButton", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field3 = typeof(UIPauseMenuController).GetField("DenyCoop", BindingFlags.Instance | BindingFlags.NonPublic);
		if (field == null || field2 == null)
		{
			return;
		}
		object value = field.GetValue(__instance);
		TextMeshProUGUI val = (TextMeshProUGUI)((value is TextMeshProUGUI) ? value : null);
		object value2 = field2.GetValue(__instance);
		MMButton val2 = (MMButton)((value2 is MMButton) ? value2 : null);
		bool flag = field3 != null && (bool)field3.GetValue(__instance);
		if (!((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null || flag))
		{
			if (PlayerFarming.playersCount < 8)
			{
				((TMP_Text)val).text = $"Add Player ({PlayerFarming.playersCount}/{8})";
				val2.Interactable = true;
			}
			else
			{
				((TMP_Text)val).text = $"Remove Player ({PlayerFarming.playersCount}/{8})";
				val2.Interactable = true;
			}
		}
	}

	public static bool ConfirmSpawnButtonPress(UICoopAssignController __instance)
	{
		FieldInfo field = typeof(UICoopAssignController).GetField("displayedConnectedGamepads", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		FieldInfo field2 = typeof(UICoopAssignController).GetField("keyboardInputOption", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		FieldInfo field3 = typeof(UICoopAssignController).GetField("preventSpawnBufferTime", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		FieldInfo field4 = typeof(UICoopAssignController).GetField("confirmLock", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field == null || field2 == null)
		{
			Plugin.Log.LogError((object)"Reflection failed");
			return true;
		}
		if (field3 != null)
		{
			float num = (float)field3.GetValue(__instance);
			if (Time.realtimeSinceStartup < num + 0.25f)
			{
				return false;
			}
		}
		if (field4 != null)
		{
			if ((bool)field4.GetValue(__instance))
			{
				return false;
			}
			field4.SetValue(__instance, true);
		}
		if (!(field.GetValue(__instance) is CoopAssignInputOption[] array))
		{
			return true;
		}
		int num2 = PlayerFarming.playersCount;
		if (num2 < 1)
		{
			num2 = 1;
		}
		Plugin.Log.LogInfo((object)$"ConfirmSpawnButtonPress: nextSlot={num2}, players={PlayerFarming.playersCount}");
		EnforceKeyboardOwnership();
		List<Joystick> list = new List<Joystick>(ReInput.controllers.Joysticks);
		for (int i = 0; i < array.Length && i < list.Count; i++)
		{
			CoopAssignInputOption val = array[i];
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeSelf || val.selection != -1)
			{
				continue;
			}
			Joystick val2 = list[i];
			if (val2 == null)
			{
				continue;
			}
			for (int j = 1; j < 8; j++)
			{
				if (!RewiredInputManager.GetPlayer(j).controllers.ContainsController((Controller)(object)val2))
				{
					continue;
				}
				PlayerFarming val3 = null;
				foreach (PlayerFarming player3 in PlayerFarming.players)
				{
					if (!player3.isLamb && player3.playerID == j && ((Component)player3).gameObject.activeSelf)
					{
						val3 = player3;
						break;
					}
				}
				if ((Object)(object)val3 == (Object)null)
				{
					continue;
				}
				Plugin.Log.LogInfo((object)$"Joystick [{i}] moved to Lamb side — removing goat slot {j} (dropout)");
				int playerID = val3.playerID;
				MarkDesiredExtraSlot(playerID, desired: false);
				_pendingSpawnSlots.Remove(playerID);
				_pendingSpawnUseAnimation.Remove(playerID);
				if (_cachedSprites.ContainsKey(playerID))
				{
					_cachedSprites.Remove(playerID);
				}
				if (_cachedTextImages.ContainsKey(playerID))
				{
					_cachedTextImages.Remove(playerID);
				}
				if (_cachedHaloSR.ContainsKey(playerID))
				{
					_cachedHaloSR.Remove(playerID);
				}
				if (_cachedHaloSprites.ContainsKey(playerID))
				{
					_cachedHaloSprites.Remove(playerID);
				}
				_haloLogged.Remove(playerID);
				_removingPlayer = true;
				CoopManager.AddtionalUser = null;
				UnhookVanillaCoopDelegates();
				CoopManager.Instance.RemoveCoopPlayer(val3, true, false, true);
				if (_extraHeartBars.TryGetValue(playerID, out var value) && (Object)(object)value != (Object)null)
				{
					Object.Destroy((Object)(object)value);
				}
				_extraHeartBars.Remove(playerID);
				if (PlayerFarming.playersCount > 1 && (Object)(object)HUD_Manager.Instance != (Object)null)
				{
					foreach (PlayerFarming player4 in PlayerFarming.players)
					{
						if (!player4.isLamb)
						{
							HUD_Manager.Instance.healthManager.Init(player4);
						}
					}
				}
				int num3 = 0;
				foreach (PlayerFarming player5 in PlayerFarming.players)
				{
					if (!player5.isLamb)
					{
						num3++;
					}
				}
				if (num3 <= 0)
				{
					UICoopAssignController.SetInputForSoloPlay();
					UserHelper.DisengagePlayer(1);
					CoopManager.CoopActive = false;
					CoopManager.EnableCoopBlockers(false, true);
					DifficultyManager.LoadCurrentDifficulty();
				}
				else
				{
					Player player = RewiredInputManager.GetPlayer(playerID);
					if (player != null)
					{
						foreach (Joystick item in new List<Joystick>(player.controllers.Joysticks))
						{
							player.controllers.RemoveController((Controller)(object)item);
						}
					}
					EnforceKeyboardOwnership();
					CoopManager.RefreshCoopPlayerRewired();
				}
				GameManager.GetInstance().WaitForSeconds(2f, (Action)delegate
				{
					_removingPlayer = false;
					Plugin.Log.LogInfo((object)"Dropout remove guard released");
				});
				break;
			}
			bool flag = false;
			for (int num4 = 1; num4 < 8; num4++)
			{
				if (RewiredInputManager.GetPlayer(num4).controllers.ContainsController((Controller)(object)val2))
				{
					flag = true;
					break;
				}
			}
			if (!flag)
			{
				for (int num5 = 1; num5 < 8; num5++)
				{
					RewiredInputManager.GetPlayer(num5).controllers.RemoveController((Controller)(object)val2);
				}
				if (!RewiredInputManager.GetPlayer(0).controllers.ContainsController((Controller)(object)val2))
				{
					RewiredInputManager.GetPlayer(0).controllers.AddController((Controller)(object)val2, true);
				}
				Plugin.Log.LogInfo((object)$"Joystick [{i}] assigned to Lamb (slot 0)");
			}
		}
		num2 = PlayerFarming.playersCount;
		if (num2 < 1)
		{
			num2 = 1;
		}
		for (int num6 = 0; num6 < array.Length && num6 < list.Count; num6++)
		{
			if (num2 >= 8)
			{
				break;
			}
			CoopAssignInputOption val4 = array[num6];
			if ((Object)(object)val4 == (Object)null || !((Component)val4).gameObject.activeSelf || val4.selection != 1)
			{
				continue;
			}
			val4.inputLock = false;
			Joystick val5 = list[num6];
			if (val5 == null)
			{
				continue;
			}
			bool flag2 = false;
			for (int num7 = 1; num7 < 8; num7++)
			{
				if (!RewiredInputManager.GetPlayer(num7).controllers.ContainsController((Controller)(object)val5))
				{
					continue;
				}
				PlayerFarming val6 = null;
				foreach (PlayerFarming player6 in PlayerFarming.players)
				{
					if (!player6.isLamb && player6.playerID == num7 && ((Component)player6).gameObject.activeSelf)
					{
						val6 = player6;
						break;
					}
				}
				if ((Object)(object)val6 != (Object)null)
				{
					flag2 = true;
					Plugin.Log.LogInfo((object)$"Joystick [{num6}] already active goat slot {num7}, skipping");
					break;
				}
			}
			if (!flag2)
			{
				for (int num8 = 0; num8 < 8; num8++)
				{
					RewiredInputManager.GetPlayer(num8).controllers.RemoveController((Controller)(object)val5);
				}
				Player player2 = RewiredInputManager.GetPlayer(num2);
				player2.controllers.AddController((Controller)(object)val5, true);
				EnsureVJoyMapForPlayer(player2, val5, "ConfirmSpawnButtonPress");
				Plugin.Log.LogInfo((object)$"Joystick [{num6}] -> new goat slot {num2}");
				MarkDesiredExtraSlot(num2, desired: true);
				if (num2 >= 2)
				{
					_pendingSpawnSlots.Add(num2);
					_pendingSpawnUseAnimation[num2] = false;
				}
				CoopManager.Instance.SpawnCoopPlayer(num2, false, 0f);
				CoopManager.CoopActive = true;
				num2++;
			}
		}
		Plugin.Log.LogInfo((object)"Spawn complete");
		((UIMenuBase)__instance).Hide(false);
		return false;
	}

	public static void CoopAssign_OnEnable_Prefix(UICoopAssignController __instance)
	{
		//IL_011e: 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)
		try
		{
			if (UICoopAssignController.displayedConnectedGamepadsPreviousSelection == null || UICoopAssignController.displayedConnectedGamepadsPreviousSelection.Length < 8)
			{
				int[] displayedConnectedGamepadsPreviousSelection = UICoopAssignController.displayedConnectedGamepadsPreviousSelection;
				int[] array = new int[8];
				if (displayedConnectedGamepadsPreviousSelection != null)
				{
					Array.Copy(displayedConnectedGamepadsPreviousSelection, array, Math.Min(displayedConnectedGamepadsPreviousSelection.Length, array.Length));
				}
				UICoopAssignController.displayedConnectedGamepadsPreviousSelection = array;
			}
			CoopAssignInputOption[] displayedConnectedGamepads = __instance.displayedConnectedGamepads;
			if (displayedConnectedGamepads == null || displayedConnectedGamepads.Length == 0 || displayedConnectedGamepads.Length >= 8)
			{
				return;
			}
			CoopAssignInputOption val = displayedConnectedGamepads[^1];
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)"[MP8] Could not expand controller assignment UI: template is null");
				return;
			}
			CoopAssignInputOption[] array2 = (CoopAssignInputOption[])(object)new CoopAssignInputOption[8];
			Array.Copy(displayedConnectedGamepads, array2, displayedConnectedGamepads.Length);
			for (int i = displayedConnectedGamepads.Length; i < 8; i++)
			{
				CoopAssignInputOption val2 = Object.Instantiate<CoopAssignInputOption>(val, ((Component)val).transform.parent);
				((Object)((Component)val2).gameObject).name = $"Gamepad {i + 1} (COTLMP 8P)";
				((Component)val2).gameObject.SetActive(false);
				((Component)val2).transform.SetSiblingIndex(((Component)val).transform.GetSiblingIndex() + (i - displayedConnectedGamepads.Length) + 1);
				array2[i] = val2;
			}
			__instance.displayedConnectedGamepads = array2;
			if ((Object)(object)__instance.GamepadContentContainer != (Object)null)
			{
				__instance.GamepadContentContainer.localScale = Vector3.one * 0.75f;
			}
			Plugin.Log.LogInfo((object)$"[MP8] Controller assignment UI expanded from {displayedConnectedGamepads.Length} to {array2.Length} gamepads");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP8] Controller assignment UI expansion failed: " + ex.GetType().Name + ": " + ex.Message));
		}
	}

	public static bool CoopAssign_UpdateDisplayedConnectedGamepads_Prefix(UICoopAssignController __instance)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0006: Invalid comparison between Unknown and I4
		//IL_0008: 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)
		if ((int)UnifyManager.platform != 1 && (int)UnifyManager.platform != 0)
		{
			return true;
		}
		try
		{
			CoopAssignInputOption[] displayedConnectedGamepads = __instance.displayedConnectedGamepads;
			if (displayedConnectedGamepads == null || displayedConnectedGamepads.Length == 0)
			{
				return false;
			}
			List<Joystick> list = new List<Joystick>(ReInput.controllers.Joysticks);
			if (list.Count == 0)
			{
				Scene activeScene = SceneManager.GetActiveScene();
				if (((Scene)(ref activeScene)).name != "TestUIScene")
				{
					((UIMenuBase)__instance).Hide(false);
				}
				return false;
			}
			CoopAssignInputOption keyboardInputOption = __instance.keyboardInputOption;
			if ((Object)(object)keyboardInputOption != (Object)null)
			{
				((Component)keyboardInputOption).gameObject.SetActive(true);
				keyboardInputOption.SetpadNumDisplay(-1);
				bool flag = (Input.GetMouseButtonDown(0) && !__instance.mouseToggleDisabled) || Input.GetKeyDown((KeyCode)32);
				if ((keyboardInputOption.selection == 1 && flag) || Input.GetKeyDown((KeyCode)276))
				{
					keyboardInputOption.SetSelection(-1, false);
					SetCoopAssignPreventSpawnBuffer(__instance);
				}
				else if ((keyboardInputOption.selection == -1 && flag) || Input.GetKeyDown((KeyCode)275))
				{
					keyboardInputOption.SetSelection(1, false);
					SetCoopAssignPreventSpawnBuffer(__instance);
				}
				else
				{
					keyboardInputOption.inputLock = false;
				}
			}
			int num = Math.Min(displayedConnectedGamepads.Length, Math.Min(8, list.Count));
			if (list.Count > num && !_assignmentJoystickClampLogged)
			{
				_assignmentJoystickClampLogged = true;
				Plugin.Log.LogWarning((object)$"[MP8] Assignment menu is using the first {num} of {list.Count} detected joysticks");
			}
			for (int i = 0; i < num; i++)
			{
				CoopAssignInputOption val = displayedConnectedGamepads[i];
				Joystick val2 = list[i];
				if (!((Object)(object)val == (Object)null) && val2 != null)
				{
					((Component)val).gameObject.SetActive(true);
					val.SetpadNumDisplay(i + 1);
					int controllerElementIdByIdentifierSafe = GetControllerElementIdByIdentifierSafe((Controller)(object)val2, "D-Pad Left");
					int controllerElementIdByIdentifierSafe2 = GetControllerElementIdByIdentifierSafe((Controller)(object)val2, "D-Pad Right");
					int num2 = FindJoystickOwnerSlot(val2);
					EnsureVJoyMapForPlayer((num2 >= 0) ? RewiredInputManager.GetPlayer(num2) : null, val2, "AssignmentMenu");
					bool num3 = IsVJoyJoystick(val2) && ((Controller)val2).GetAnyButtonDown();
					bool flag2 = ((ControllerWithAxes)val2).GetAxis(0) < -0.8f || (controllerElementIdByIdentifierSafe >= 0 && ((Controller)val2).GetButtonById(controllerElementIdByIdentifierSafe)) || InputManager.UI.GetPageNavigateLeftDown(val2);
					bool flag3 = num3 || ((ControllerWithAxes)val2).GetAxis(0) > 0.8f || (controllerElementIdByIdentifierSafe2 >= 0 && ((Controller)val2).GetButtonById(controllerElementIdByIdentifierSafe2)) || InputManager.UI.GetPageNavigateRightDown(val2);
					if (flag2)
					{
						val.SetSelection(-1, false);
						SetCoopAssignPreventSpawnBuffer(__instance);
					}
					else if (flag3)
					{
						val.SetSelection(1, false);
						SetCoopAssignPreventSpawnBuffer(__instance);
					}
					else
					{
						val.inputLock = false;
					}
				}
			}
			for (int j = num; j < displayedConnectedGamepads.Length; j++)
			{
				if ((Object)(object)displayedConnectedGamepads[j] != (Object)null)
				{
					((Component)displayedConnectedGamepads[j]).gameObject.SetActive(false);
				}
			}
			_coopAssignCheckInputsForSpawnButtonMethod?.Invoke(__instance, null);
			if ((Object)(object)__instance.spawnButton != (Object)null && ((Component)__instance.spawnButton).gameObject.activeSelf)
			{
				bool flag4 = Input.GetKeyDown((KeyCode)13) || Input.GetKeyDown((KeyCode)271);
				int num4 = ((ReInput.players != null) ? ReInput.players.playerCount : 0);
				int num5 = 0;
				while (!flag4 && num5 < num4)
				{
					Player player = ReInput.players.GetPlayer(num5);
					flag4 = player != null && player.GetButtonDown(38);
					num5++;
				}
				if (flag4)
				{
					_coopAssignConfirmSpawnButtonPressMethod?.Invoke(__instance, null);
				}
			}
			return false;
		}
		catch (Exception ex)
		{
			if (!_assignmentUpdateFailureLogged)
			{
				_assignmentUpdateFailureLogged = true;
				Plugin.Log.LogError((object)("[MP8] Safe controller-assignment update failed: " + ex.GetType().Name + ": " + ex.Message));
			}
			return false;
		}
	}

	private static void SetCoopAssignPreventSpawnBuffer(UICoopAssignController instance)
	{
		_coopAssignPreventSpawnBufferTimeField?.SetValue(instance, Time.realtimeSinceStartup);
	}

	private static int GetControllerElementIdByIdentifierSafe(Controller controller, string identifier)
	{
		if (controller == null)
		{
			return -1;
		}
		try
		{
			for (int i = 0; i < controller.elementCount; i++)
			{
				if (controller.GetElementIdentifierById(i).name == identifier)
				{
					return i;
				}
			}
		}
		catch
		{
		}
		return -1;
	}

	public static void CoopAssign_OnShowStarted(UICoopAssignController __instance)
	{
		//IL_006a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0071: Expected O, but got Unknown
		if (!CoopManager.CoopActive)
		{
			return;
		}
		FieldInfo field = typeof(UICoopAssignController).GetField("displayedConnectedGamepads", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		FieldInfo field2 = typeof(UICoopAssignController).GetField("keyboardInputOption", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field == null || field2 == null)
		{
			return;
		}
		CoopAssignInputOption[] array = field.GetValue(__instance) as CoopAssignInputOption[];
		object value = field2.GetValue(__instance);
		CoopAssignInputOption val = (CoopAssignInputOption)((value is CoopAssignInputOption) ? value : null);
		if (array == null)
		{
			return;
		}
		FieldInfo field3 = typeof(UICoopAssignController).GetField("keyboardInputOptionPreviousSelection", BindingFlags.Static | BindingFlags.NonPublic);
		if ((Object)(object)val != (Object)null)
		{
			int num = ((!RewiredInputManager.GetPlayer(0).controllers.hasKeyboard) ? 1 : (-1));
			field3?.SetValue(null, num);
			val.SetSelection(num, true);
		}
		List<Joystick> list = new List<Joystick>(ReInput.controllers.Joysticks);
		for (int i = 0; i < array.Length && i < list.Count; i++)
		{
			Joystick val2 = list[i];
			int num2 = -1;
			for (int j = 0; j < 8; j++)
			{
				Player player = RewiredInputManager.GetPlayer(j);
				if (player != null && player.controllers.ContainsController((Controller)(object)val2))
				{
					num2 = j;
					break;
				}
			}
			int num3 = ((num2 != 0) ? 1 : (-1));
			UICoopAssignController.displayedConnectedGamepadsPreviousSelection[i] = num3;
			array[i].SetSelection(num3, true);
			Plugin.Log.LogInfo((object)$"CoopAssign_OnShowStarted: joystick[{i}] ownerSlot={num2} → selection={num3}");
		}
	}

	public static bool RemovePlayerFromMenu()
	{
		if (_removingPlayer)
		{
			Plugin.Log.LogInfo((object)"Remove guard active, skipping");
			return false;
		}
		if (PlayerFarming.playersCount > 1 && CoopManager.CoopActive)
		{
			bool manualRemoveRequested = _manualRemoveRequested;
			_manualRemoveRequested = false;
			if (!manualRemoveRequested && Time.unscaledTime < _autoRemoveSuppressedUntil)
			{
				float num = Math.Max(0f, _autoRemoveSuppressedUntil - Time.unscaledTime);
				Plugin.Log.LogInfo((object)$"Auto remove suppressed ({num:0.00}s left)");
				return false;
			}
			PlayerFarming val = null;
			for (int num2 = PlayerFarming.players.Count - 1; num2 >= 0; num2--)
			{
				PlayerFarming val2 = PlayerFarming.players[num2];
				if (!((Object)(object)val2 == (Object)null) && !val2.isLamb && !((Object)(object)((Component)val2).gameObject == (Object)null) && ((Component)val2).gameObject.activeSelf)
				{
					if (manualRemoveRequested)
					{
						val = val2;
						break;
					}
					int playerID = val2.playerID;
					if (playerID > 0 && playerID < 8 && !SlotHasJoystick(playerID))
					{
						val = val2;
						break;
					}
				}
			}
			if ((Object)(object)val == (Object)null)
			{
				if (!manualRemoveRequested)
				{
					Plugin.Log.LogInfo((object)"Auto remove ignored: no goat slot lost joystick ownership");
				}
				else
				{
					Plugin.Log.LogWarning((object)"No Goat found to remove");
				}
				return false;
			}
			_removingPlayer = true;
			CoopManager.AddtionalUser = null;
			int playerID2 = val.playerID;
			MarkDesiredExtraSlot(playerID2, desired: false);
			_pendingSpawnSlots.Remove(playerID2);
			_pendingSpawnUseAnimation.Remove(playerID2);
			if (_cachedSprites.ContainsKey(playerID2))
			{
				_cachedSprites.Remove(playerID2);
			}
			if (_cachedTextImages.ContainsKey(playerID2))
			{
				_cachedTextImages.Remove(playerID2);
			}
			if (_cachedHaloSR.ContainsKey(playerID2))
			{
				_cachedHaloSR.Remove(playerID2);
			}
			if (_cachedHaloSprites.ContainsKey(playerID2))
			{
				_cachedHaloSprites.Remove(playerID2);
			}
			_haloLogged.Remove(playerID2);
			Plugin.Log.LogInfo((object)string.Format("Removing playerID {0} ({1})", playerID2, manualRemoveRequested ? "manual" : "auto-disconnect"));
			UnhookVanillaCoopDelegates();
			CoopManager.Instance.RemoveCoopPlayer(val, true, false, true);
			if (_extraHeartBars.TryGetValue(playerID2, out var value) && (Object)(object)value != (Object)null)
			{
				Object.Destroy((Object)(object)value);
			}
			_extraHeartBars.Remove(playerID2);
			int num3 = 0;
			foreach (PlayerFarming player2 in PlayerFarming.players)
			{
				if (!player2.isLamb)
				{
					num3++;
				}
			}
			if (num3 <= 0)
			{
				_desiredExtraSlots.Clear();
				UICoopAssignController.SetInputForSoloPlay();
				UserHelper.DisengagePlayer(1);
			}
			else
			{
				Player player = RewiredInputManager.GetPlayer(playerID2);
				if (player != null)
				{
					foreach (Joystick item in new List<Joystick>(player.controllers.Joysticks))
					{
						player.controllers.RemoveController((Controller)(object)item);
					}
				}
				EnforceKeyboardOwnership();
				CoopManager.RefreshCoopPlayerRewired();
			}
			if (PlayerFarming.playersCount <= 1)
			{
				CoopManager.CoopActive = false;
				CoopManager.EnableCoopBlockers(false, true);
				DifficultyManager.LoadCurrentDifficulty();
			}
			TryStopAllRumble($"RemovePlayerFromMenu(slot={playerID2})");
			if (!manualRemoveRequested)
			{
				_autoRemoveSuppressedUntil = Time.unscaledTime + 8f;
				Plugin.Log.LogInfo((object)$"Auto remove cooldown armed for {8f:0.0}s");
			}
			GameManager.GetInstance().WaitForSeconds(2f, (Action)delegate
			{
				_removingPlayer = false;
				Plugin.Log.LogInfo((object)"Remove guard released");
			});
		}
		return false;
	}

	public static void PlayerFarming_OnEnable_Prefix(PlayerFarming __instance)
	{
		//IL_001a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)__instance == (Object)null || __instance.isLamb || __instance.playerID <= 1 || !GameManager.IsDungeon(PlayerFarming.Location) || (Object)(object)__instance.Spine == (Object)null)
		{
			return;
		}
		int num = __instance.playerID;
		if (num < 2 || num >= 8)
		{
			for (int i = 2; i < 8; i++)
			{
				if (CoopManager.AllPlayerGameObjects != null && i < CoopManager.AllPlayerGameObjects.Length && (Object)(object)CoopManager.AllPlayerGameObjects[i] == (Object)(object)((Component)__instance).gameObject)
				{
					num = i;
					break;
				}
			}
		}
		if (num < 2 || num >= 8)
		{
			return;
		}
		bool value = false;
		_pendingSpawnUseAnimation.TryGetValue(num, out value);
		if (value)
		{
			Plugin.Log.LogInfo((object)$"[MP] PlayerFarming_OnEnable_Prefix: keeping mesh visible for animated spawn slot {num}");
			return;
		}
		MeshRenderer component = ((Component)__instance.Spine).GetComponent<MeshRenderer>();
		if ((Object)(object)component != (Object)null)
		{
			((Renderer)component).enabled = false;
		}
		Plugin.Log.LogInfo((object)$"[MP] PlayerFarming_OnEnable_Prefix: hid mesh for slot {num}");
	}

	public static void SpawnCoopPlayer_Postfix(int slot)
	{
		if (slot >= 1 && slot < 8 && (Object)(object)CoopManager.Instance != (Object)null)
		{
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(PlaceSpawnedPlayerInFormation(slot));
		}
		if (slot < 2)
		{
			_pendingSpawnSlots.Remove(slot);
			_pendingSpawnUseAnimation.Remove(slot);
		}
		else
		{
			MarkDesiredExtraSlot(slot, desired: true);
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(ApplyVisualDelayed(slot));
		}
	}

	private static IEnumerator PlaceSpawnedPlayerInFormation(int slot)
	{
		PlayerFarming player = null;
		for (float waited = 0f; waited < 3f; waited += 0.05f)
		{
			if (!((Object)(object)player == (Object)null))
			{
				break;
			}
			player = FindActivePlayerBySlot(slot);
			if ((Object)(object)player == (Object)null)
			{
				yield return (object)new WaitForSecondsRealtime(0.05f);
			}
		}
		if (!((Object)(object)player == (Object)null) && !((Object)(object)PlayerFarming.Instance == (Object)null) && slot < InitialSpawnOffsets.Length)
		{
			yield return null;
			((Component)player).transform.position = ((Component)PlayerFarming.Instance).transform.position + InitialSpawnOffsets[slot];
			Plugin.Log.LogInfo((object)$"[MP] Fast spawn formation placed P{slot + 1} at offset {InitialSpawnOffsets[slot]}");
		}
	}

	private static IEnumerator RespawnExtraSlots(int count)
	{
		_startupExtraRespawnDepth++;
		try
		{
			bool inDungeon = GameManager.IsDungeon(PlayerFarming.Location);
			float timeout = 30f;
			float waited;
			for (waited = 0f; waited < timeout; waited += 0.25f)
			{
				if ((Object)(object)PlayerFarming.Instance != (Object)null && ((Component)PlayerFarming.Instance).gameObject.activeSelf && PlayerFarming.playersCount >= 1 && (Object)(object)PlayerFarming.Instance.state != (Object)null && (inDungeon || (int)PlayerFarming.Instance.state.CURRENT_STATE != 13))
				{
					break;
				}
				yield return (object)new WaitForSeconds(0.25f);
			}
			if (waited >= timeout)
			{
				Plugin.Log.LogWarning((object)"RespawnExtraSlots: timed out waiting for PlayerFarming.Instance");
				yield break;
			}
			if (inDungeon)
			{
				_dungeonIntroProtectUntil = Time.unscaledTime + 8f;
			}
			yield return (object)new WaitForSeconds(1f);
			for (int s = 2; s < 2 + count && s < 8; s++)
			{
				if (_pendingSpawnSlots.Contains(s))
				{
					Plugin.Log.LogInfo((object)$"RespawnExtraSlots: slot {s} already pending, skipping duplicate startup spawn");
					continue;
				}
				if ((Object)(object)FindActivePlayerBySlot(s) != (Object)null)
				{
					Plugin.Log.LogInfo((object)$"RespawnExtraSlots: slot {s} already active, skipping startup spawn");
					continue;
				}
				if (CoopManager.AllPlayerGameObjects != null && s < CoopManager.AllPlayerGameObjects.Length && (Object)(object)CoopManager.AllPlayerGameObjects[s] != (Object)null && CoopManager.AllPlayerGameObjects[s].activeInHierarchy)
				{
					Plugin.Log.LogInfo((object)$"RespawnExtraSlots: slot {s} already has active gameobject, skipping startup spawn");
					continue;
				}
				Player player = RewiredInputManager.GetPlayer(s);
				if (player == null || player.controllers == null || player.controllers.Joysticks == null || player.controllers.Joysticks.Count <= 0)
				{
					Plugin.Log.LogWarning((object)$"RespawnExtraSlots: slot {s} has no joystick, skipping");
					continue;
				}
				Plugin.Log.LogInfo((object)$"RespawnExtraSlots: spawning slot {s}");
				float spawnWait = 0f;
				while ((Object)(object)CoopManager.Instance != (Object)null && CoopManager.Instance.IsSpawningOrRemovingPlayer && spawnWait < 10f)
				{
					yield return (object)new WaitForSeconds(0.1f);
					spawnWait += 0.1f;
				}
				if (_pendingSpawnSlots.Contains(s))
				{
					Plugin.Log.LogInfo((object)$"RespawnExtraSlots: slot {s} became pending during wait, skipping duplicate startup spawn");
					continue;
				}
				if ((Object)(object)FindActivePlayerBySlot(s) != (Object)null)
				{
					Plugin.Log.LogInfo((object)$"RespawnExtraSlots: slot {s} became active during wait, skipping duplicate startup spawn");
					continue;
				}
				_pendingSpawnSlots.Add(s);
				bool flag = false;
				_pendingSpawnUseAnimation[s] = flag;
				Plugin.Log.LogInfo((object)$"RespawnExtraSlots: slot {s} spawn mode animated={flag}");
				try
				{
					CoopManager.Instance.SpawnCoopPlayer(s, flag, -1f);
				}
				catch (Exception ex)
				{
					_pendingSpawnSlots.Remove(s);
					_pendingSpawnUseAnimation.Remove(s);
					Plugin.Log.LogWarning((object)$"RespawnExtraSlots: failed spawning slot {s}: {ex.GetType().Name}: {ex.Message}");
				}
				yield return (object)new WaitForSeconds(1f);
			}
		}
		finally
		{
			_startupExtraRespawnDepth = Math.Max(0, _startupExtraRespawnDepth - 1);
		}
	}

	public static void NewRun_Prefix()
	{
		_lastRegularBalancePlayerCount = -1;
		_lastBossBalancePlayerCount = -1;
		_spawnedExtraWeaponPodiums = false;
		_spawnedExtraSpellPodiums = false;
		_podiumClones.Clear();
		_podiumOwnerSlotByInstanceId.Clear();
		int num = 0;
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!player.isLamb && player.playerID >= 2)
			{
				num++;
			}
		}
		if (num > 0)
		{
			_savedExtraSlotCount = num;
			Plugin.Log.LogInfo((object)$"NewRun_Prefix: saved {num} extra slot(s) for dungeon respawn");
		}
		_cachedHaloSR.Clear();
		_cachedHaloSprites.Clear();
		_cachedTextImages.Clear();
		_cachedSprites.Clear();
		_haloLogged.Clear();
		foreach (KeyValuePair<int, GameObject> extraHeartBar in _extraHeartBars)
		{
			if ((Object)(object)extraHeartBar.Value != (Object)null)
			{
				Object.Destroy((Object)(object)extraHeartBar.Value);
			}
		}
		_extraHeartBars.Clear();
		_positioningDeferred = false;
		_podiumExtraCount = 0;
		_autoRespawnRoutineRunning = false;
		_nextAutoRespawnAttemptAt = 0f;
		_nextAutoRespawnHeartbeatAt = 0f;
		_pendingSpawnSlots.Clear();
		_pendingSpawnUseAnimation.Clear();
		_pendingSpawnFirstSeenAt.Clear();
		_nextPendingBlockLogAt = 0f;
		_delayedRespawnAfterReviveQueued = false;
		_lastObservedWakeHealth = 2f;
		_lastObservedSacrificialWakeHealth = 2f;
		_sacrificialReviveWindowUntil = 0f;
		_nextExtraFalseDownedWatchdogAt.Clear();
		_postReviveRaceGuardUntil.Clear();
		_nextPostReviveForceApplyAt.Clear();
		_nextPostReviveRaceGuardHeartbeatAt = 0f;
		_lastLoggedDungeonRoomPath = null;
		_p2EntranceGuardRunning = false;
		_dungeonRoomStabilizeRunning = false;
		_lastStabilizedDungeonRoomId = int.MinValue;
		_nextDungeonRoomStabilizeCheckAt = 0f;
		_roomEntryDistanceRepositionGraceUntil = 0f;
		_compactRoomEntryToken++;
		_initialWeaponAutoEquipRunning = false;
		_initialWeaponAutoEquipRoomId = int.MinValue;
		Plugin.Log.LogInfo((object)"NewRun_Prefix: all visual caches cleared");
	}

	public static void CoopManager_Start_Postfix()
	{
		CoopManager_Start_Postfix_Inner();
	}

	public static void CoopManager_Start_Postfix_Inner()
	{
		//IL_0038: 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)
		EnsureRanchFollowingCapacity();
		RefreshDesiredExtraSlotsFromActivePlayers();
		_spawnedExtraWeaponPodiums = false;
		_spawnedExtraSpellPodiums = false;
		_delayedRespawnAfterReviveQueued = false;
		_nextAutoRespawnHeartbeatAt = 0f;
		_nextDungeonRoomStabilizeCheckAt = 0f;
		if (!CoopManager.CoopActive)
		{
			return;
		}
		if (GameManager.IsDungeon(PlayerFarming.Location) && (Object)(object)CoopManager.Instance != (Object)null && !_p2EntranceGuardRunning)
		{
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(EnsureP2DungeonEntranceNotStuckRoutine());
		}
		int savedExtraSlotCount = _savedExtraSlotCount;
		if (savedExtraSlotCount > 0)
		{
			if (GameManager.IsDungeon(PlayerFarming.Location))
			{
				_dungeonIntroProtectUntil = Time.unscaledTime + 8f;
			}
			_podiumExtraCount = savedExtraSlotCount;
			_savedExtraSlotCount = 0;
			Plugin.Log.LogInfo((object)$"CoopManager_Start_Postfix: scheduling respawn of {savedExtraSlotCount} extra slot(s)");
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(RespawnExtraSlots(savedExtraSlotCount));
			_nextAutoRespawnAttemptAt = Time.unscaledTime + 5f;
		}
		else
		{
			TryAutoRespawnMissingExtraSlots("CoopManager.Start");
		}
	}

	private static IEnumerator ApplyVisualDelayed(int slot)
	{
		if (slot < 2)
		{
			_pendingSpawnSlots.Remove(slot);
			_pendingSpawnUseAnimation.Remove(slot);
			yield break;
		}
		PlayerFarming player = null;
		float waited = 0f;
		while ((Object)(object)player == (Object)null && waited < 10f)
		{
			foreach (PlayerFarming player2 in PlayerFarming.players)
			{
				if ((Object)(object)player2 != (Object)null && player2.playerID == slot)
				{
					player = player2;
					break;
				}
			}
			if ((Object)(object)player == (Object)null)
			{
				yield return (object)new WaitForSeconds(0.2f);
				waited += 0.2f;
			}
		}
		if ((Object)(object)player == (Object)null)
		{
			Plugin.Log.LogWarning((object)$"ApplyVisualDelayed: gave up waiting for playerID={slot}");
			_pendingSpawnSlots.Remove(slot);
			_pendingSpawnUseAnimation.Remove(slot);
			yield break;
		}
		bool useAnimatedSpawn = false;
		_pendingSpawnUseAnimation.TryGetValue(slot, out useAnimatedSpawn);
		bool inDungeon = GameManager.IsDungeon(PlayerFarming.Location);
		MeshRenderer meshR = null;
		if (slot >= 2 && (Object)(object)player.Spine != (Object)null)
		{
			meshR = ((Component)player.Spine).GetComponent<MeshRenderer>();
			if (!useAnimatedSpawn && (Object)(object)meshR != (Object)null && ((Renderer)meshR).enabled)
			{
				((Renderer)meshR).enabled = false;
			}
		}
		if (slot >= 2 && (Object)(object)PlayerFarming.Instance != (Object)null && slot < InitialSpawnOffsets.Length && (!useAnimatedSpawn || !inDungeon))
		{
			((Component)player).transform.position = ((Component)PlayerFarming.Instance).transform.position + InitialSpawnOffsets[slot];
		}
		if (slot >= 2 && inDungeon)
		{
			float waitLimit = 8f;
			for (float w = 0f; w < waitLimit; w += 0.1f)
			{
				if (!((Object)(object)player.state != (Object)null))
				{
					break;
				}
				if (!player.state.LockStateChanges && (int)player.state.CURRENT_STATE != 13 && (int)player.state.CURRENT_STATE != 49)
				{
					break;
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
			yield return null;
			if ((!useAnimatedSpawn || !inDungeon) && (Object)(object)PlayerFarming.Instance != (Object)null && slot < InitialSpawnOffsets.Length)
			{
				((Component)player).transform.position = ((Component)PlayerFarming.Instance).transform.position + InitialSpawnOffsets[slot];
			}
		}
		else
		{
			for (float waitLimit = 0f; waitLimit < 0.4f; waitLimit += 0.1f)
			{
				if (!((Object)(object)PlayerFarming.Instance == (Object)null) && !((Object)(object)PlayerFarming.Instance.state == (Object)null) && (int)PlayerFarming.Instance.state.CURRENT_STATE != 13)
				{
					break;
				}
				yield return (object)new WaitForSeconds(0.1f);
			}
			yield return null;
			if (slot < InitialSpawnOffsets.Length && (Object)(object)PlayerFarming.Instance != (Object)null)
			{
				((Component)player).transform.position = ((Component)PlayerFarming.Instance).transform.position + InitialSpawnOffsets[slot];
			}
		}
		if (slot >= 2 && (Object)(object)meshR != (Object)null && !((Renderer)meshR).enabled)
		{
			((Renderer)meshR).enabled = true;
		}
		if (slot < Plugin.GoatColors.Length && !CustomSpineCompatibility.ShouldPreserveCustomSpineColor(player) && (Object)(object)player.Spine != (Object)null && ((SkeletonRenderer)player.Spine).skeleton != null)
		{
			((SkeletonRenderer)player.Spine).skeleton.R = Plugin.GoatColors[slot].r;
			((SkeletonRenderer)player.Spine).skeleton.G = Plugin.GoatColors[slot].g;
			((SkeletonRenderer)player.Spine).skeleton.B = Plugin.GoatColors[slot].b;
			((SkeletonRenderer)player.Spine).skeleton.A = Plugin.GoatColors[slot].a;
		}
		if ((Object)(object)GameManager.GetInstance() != (Object)null)
		{
			GameManager.GetInstance().AddToCamera(player.CameraBone, 0.1f);
		}
		EnsurePlayerAwakeAfterRespawn(player, $"ApplyVisualDelayed(slot={slot})");
		if (slot >= 2)
		{
			EnsureExtraSpawnStateUnlocked(player, $"ApplyVisualDelayed(slot={slot})");
		}
		if (_podiumClones.TryGetValue(slot, out var value))
		{
			foreach (Interaction_WeaponSelectionPodium item in value)
			{
				if ((Object)(object)item != (Object)null)
				{
					EnsurePodiumCloneOwner(item, slot, player, forceInteractable: true);
					Plugin.Log.LogInfo((object)$"[MP] Refreshed podium clone state for slot {slot} on {((Object)item).name}");
				}
			}
		}
		HUD_Hearts val = player.hudHearts;
		if ((Object)(object)val != (Object)null && (Object)(object)val.playerFarming != (Object)(object)player)
		{
			Plugin.Log.LogWarning((object)$"[MP] ApplyVisualDelayed: stale hudHearts owner for slot {slot}, skipping direct faithAmmo init");
			val = null;
		}
		if ((Object)(object)val == (Object)null && _extraHeartBars.TryGetValue(slot, out var value2) && (Object)(object)value2 != (Object)null)
		{
			HUD_Hearts component = value2.GetComponent<HUD_Hearts>();
			if ((Object)(object)component != (Object)null && (Object)(object)component.playerFarming == (Object)(object)player)
			{
				val = component;
				player.hudHearts = component;
			}
		}
		if (slot >= 2 && (Object)(object)val != (Object)null)
		{
			SyncFaithAmmoForOwner(player, val, $"ApplyVisualDelayed(slot={slot})", forceReinit: true);
		}
		_pendingSpawnSlots.Remove(slot);
		_pendingSpawnUseAnimation.Remove(slot);
		Plugin.Log.LogInfo((object)$"ApplyVisualDelayed done for slot {slot}");
	}

	private static bool IsDungeonContextLikely()
	{
		//IL_0000: 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 (GameManager.IsDungeon(PlayerFarming.Location))
		{
			return true;
		}
		try
		{
			Scene activeScene = SceneManager.GetActiveScene();
			string name = ((Scene)(ref activeScene)).name;
			if (!string.IsNullOrEmpty(name) && name.IndexOf("Dungeon", StringComparison.OrdinalIgnoreCase) >= 0)
			{
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	private unsafe static bool IsReviveDesyncState(State st)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Invalid comparison between Unknown and I4
		//IL_0005: 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
		//IL_000f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0012: Invalid comparison between Unknown and I4
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Invalid comparison between Unknown and I4
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Invalid comparison between Unknown and I4
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Invalid comparison between Unknown and I4
		//IL_003d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0040: Invalid comparison between Unknown and I4
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		//IL_0045: Invalid comparison between Unknown and I4
		//IL_0047: Unknown result type (might be due to invalid IL or missing references)
		//IL_004a: Invalid comparison between Unknown and I4
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Invalid comparison between Unknown and I4
		//IL_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_0054: Invalid comparison between Unknown and I4
		//IL_0056: Unknown result type (might be due to invalid IL or missing references)
		//IL_0059: Invalid comparison between Unknown and I4
		if ((int)st != 13 && (int)st != 49 && (int)st != 24 && (int)st != 16 && !string.Equals(((object)(*(State*)(&st))/*cast due to .constrained prefix*/).ToString(), "CoopReviving", StringComparison.Ordinal) && (int)st != 63 && (int)st != 35 && (int)st != 56 && (int)st != 41 && (int)st != 42 && (int)st != 32 && (int)st != 33 && (int)st != 52)
		{
			return (int)st == 62;
		}
		return true;
	}

	private unsafe static bool IsHardDownedOrReviveState(State st)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		//IL_0003: Invalid comparison between Unknown and I4
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0022: Invalid comparison between Unknown and I4
		//IL_0024: Unknown result type (might be due to invalid IL or missing references)
		//IL_0027: Invalid comparison between Unknown and I4
		//IL_0029: Unknown result type (might be due to invalid IL or missing references)
		//IL_002c: Invalid comparison between Unknown and I4
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0031: Invalid comparison between Unknown and I4
		//IL_0033: Unknown result type (might be due to invalid IL or missing references)
		//IL_0036: Invalid comparison between Unknown and I4
		//IL_0038: Unknown result type (might be due to invalid IL or missing references)
		//IL_003b: Invalid comparison between Unknown and I4
		if ((int)st != 63 && !string.Equals(((object)(*(State*)(&st))/*cast due to .constrained prefix*/).ToString(), "CoopReviving", StringComparison.Ordinal) && (int)st != 35 && (int)st != 56 && (int)st != 32 && (int)st != 33 && (int)st != 52)
		{
			return (int)st == 62;
		}
		return true;
	}

	private static bool IsFalseDownedVisualStateForExtra(PlayerFarming player)
	{
		//IL_0095: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Invalid comparison between Unknown and I4
		if ((Object)(object)player == (Object)null || player.isLamb || player.playerID < 2)
		{
			return false;
		}
		try
		{
			if ((Object)(object)player.health == (Object)null || ((Health)player.health).CurrentHP <= 0f)
			{
				return false;
			}
		}
		catch
		{
			return false;
		}
		try
		{
			if (Health.team2 != null && Health.team2.Count > 0)
			{
				return false;
			}
		}
		catch
		{
		}
		if (IsLikelyLegitDownedState(player))
		{
			return false;
		}
		bool flag = false;
		try
		{
			flag = player.IsKnockedOut;
		}
		catch
		{
		}
		if (!flag)
		{
			try
			{
				flag = (Object)(object)player.state != (Object)null && (int)player.state.CURRENT_STATE == 63;
			}
			catch
			{
			}
		}
		return flag;
	}

	private static bool IsLikelyLegitDownedState(PlayerFarming player)
	{
		//IL_0032: 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_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_007c: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Invalid comparison between Unknown and I4
		if ((Object)(object)player == (Object)null)
		{
			return false;
		}
		bool flag = false;
		try
		{
			Interaction_CoopRevive component = ((Component)player).GetComponent<Interaction_CoopRevive>();
			flag = (Object)(object)component != (Object)null && ((Behaviour)component).enabled;
		}
		catch
		{
		}
		bool flag2 = false;
		State val = (State)0;
		try
		{
			if ((Object)(object)player.state != (Object)null)
			{
				val = player.state.CURRENT_STATE;
				flag2 = true;
			}
		}
		catch
		{
		}
		if (flag2 && IsHardDownedOrReviveState(val))
		{
			return true;
		}
		bool flag3 = false;
		try
		{
			flag3 = player.IsKnockedOut;
		}
		catch
		{
		}
		if (!flag3)
		{
			return false;
		}
		if (flag)
		{
			return true;
		}
		if (flag2 && (int)val == 49)
		{
			return true;
		}
		try
		{
			if ((Object)(object)player.health != (Object)null && ((Health)player.health).CurrentHP <= 0f)
			{
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	private static bool ShouldForceIdleForSpawnUnlock(State st)
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		return IsHardDownedOrReviveState(st);
	}

	private static bool IsLikelyReviveDesyncState(PlayerFarming player)
	{
		//IL_004a: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null || (Object)(object)player.health == (Object)null || ((Health)player.health).CurrentHP <= 0f)
		{
			return false;
		}
		if (player.IsKnockedOut)
		{
			return true;
		}
		try
		{
			if ((Object)(object)player.state != (Object)null && IsReviveDesyncState(player.state.CURRENT_STATE))
			{
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	private static bool NeedsWakeRecovery(PlayerFarming player)
	{
		//IL_0071: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null || (Object)(object)player.health == (Object)null)
		{
			return false;
		}
		bool flag = ((Health)player.health).CurrentHP <= 0f;
		bool isKnockedOut = player.IsKnockedOut;
		bool flag2 = false;
		bool flag3 = false;
		try
		{
			Interaction_CoopRevive component = ((Component)player).GetComponent<Interaction_CoopRevive>();
			flag2 = (Object)(object)component != (Object)null && ((Behaviour)component).enabled;
		}
		catch
		{
		}
		try
		{
			if ((Object)(object)player.state != (Object)null)
			{
				flag3 = IsHardDownedOrReviveState(player.state.CURRENT_STATE);
			}
		}
		catch
		{
		}
		return flag || isKnockedOut || flag2 || flag3;
	}

	private static bool AnyNonLambPlayerNeedsWakeRecovery()
	{
		if (PlayerFarming.players == null)
		{
			return false;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !player.isLamb && !((Object)(object)((Component)player).gameObject == (Object)null) && ((Component)player).gameObject.activeInHierarchy && NeedsWakeRecovery(player))
			{
				return true;
			}
		}
		return false;
	}

	private static float GetReviveWakeHealth(PlayerFarming player, string reason)
	{
		bool flag = IsWakeAllRespawnReason(reason);
		bool num = IsSacrificialReviveFlowReason(reason);
		float num2 = _lastObservedWakeHealth;
		if (num)
		{
			float lastObservedSacrificialWakeHealth = _lastObservedSacrificialWakeHealth;
			if (!float.IsNaN(lastObservedSacrificialWakeHealth) && lastObservedSacrificialWakeHealth > 0f)
			{
				num2 = lastObservedSacrificialWakeHealth;
			}
		}
		if (float.IsNaN(num2) || num2 <= 0f)
		{
			num2 = 1f;
		}
		if (!num)
		{
			if (flag)
			{
				return 1f;
			}
			return Mathf.Clamp(num2, 1f, 2f);
		}
		if ((Object)(object)player == (Object)null || player.isLamb || player.playerID < 2)
		{
			return Mathf.Max(2f, num2);
		}
		float num3 = Mathf.Max(2f, num2);
		try
		{
			PlayerFarming val = FindActivePlayerBySlot(1);
			if ((Object)(object)val != (Object)null && (Object)(object)val.health != (Object)null)
			{
				float currentHP = ((Health)val.health).CurrentHP;
				if (currentHP > num3)
				{
					num3 = currentHP;
				}
			}
		}
		catch
		{
		}
		return Mathf.Max(2f, num3);
	}

	private static void EnsurePlayerAwakeAfterRespawn(PlayerFarming player, string reason)
	{
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		bool flag = IsSacrificialReviveFlowReason(reason);
		bool flag2 = NeedsWakeRecovery(player);
		if (!flag2 && !flag)
		{
			return;
		}
		float reviveWakeHealth = GetReviveWakeHealth(player, reason);
		if (flag2)
		{
			try
			{
				CoopManager.WakeKnockedOutPlayer(player, reviveWakeHealth, (PlayerFarming)null, (HeartPickupType)0, false);
			}
			catch
			{
			}
		}
		try
		{
			if ((Object)(object)player.health != (Object)null)
			{
				if (flag)
				{
					TryRaiseHealthCapacity(player.health, reviveWakeHealth);
				}
				if (((Health)player.health).CurrentHP < reviveWakeHealth)
				{
					((Health)player.health).HP = reviveWakeHealth;
				}
				if (flag && player.playerID >= 2 && ((Health)player.health).CurrentHP + 0.01f < reviveWakeHealth)
				{
					Plugin.Log.LogWarning((object)$"[MP] Sacrificial wake health clamp suspected for playerID={player.playerID}: hp={((Health)player.health).CurrentHP:0.00}, target={reviveWakeHealth:0.00} ({reason})");
				}
			}
		}
		catch
		{
		}
		player.IsKnockedOut = false;
		EnsureExtraSpawnStateUnlocked(player, reason);
		QueuePostReviveHardReset(player, reason);
		Plugin.Log.LogInfo((object)$"[MP] Cleared downed state for playerID={player.playerID} ({reason})");
	}

	private static void QueuePostReviveHardReset(PlayerFarming player, string reason)
	{
		if (!((Object)(object)player == (Object)null) && !player.isLamb && player.playerID >= 1 && player.playerID < 8 && !((Object)(object)CoopManager.Instance == (Object)null))
		{
			int playerID = player.playerID;
			ArmPostReviveRaceGuard(playerID);
			if (!_postReviveHardResetSlots.Contains(playerID))
			{
				_postReviveHardResetSlots.Add(playerID);
				Plugin.Log.LogInfo((object)$"[MP] Queued post-revive hard reset for playerID={playerID} ({reason})");
				((MonoBehaviour)CoopManager.Instance).StartCoroutine(PostReviveHardResetRoutine(playerID, reason));
			}
		}
	}

	private static void QueuePostReviveHardResetForAll(string reason)
	{
		if (PlayerFarming.players == null)
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !player.isLamb && !((Object)(object)((Component)player).gameObject == (Object)null) && ((Component)player).gameObject.activeInHierarchy)
			{
				QueuePostReviveHardReset(player, reason);
			}
		}
	}

	private static void ArmPostReviveRaceGuard(int slot)
	{
		if (slot >= 1 && slot < 8)
		{
			float num = Time.unscaledTime + 4f;
			if (!_postReviveRaceGuardUntil.TryGetValue(slot, out var value) || !(value > num))
			{
				_postReviveRaceGuardUntil[slot] = Mathf.Max(value, num);
			}
		}
	}

	private static bool IsLikelyStaleDownedPresentation(PlayerFarming player)
	{
		//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_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007b: Invalid comparison between Unknown and I4
		//IL_007d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0080: Invalid comparison between Unknown and I4
		if ((Object)(object)player == (Object)null)
		{
			return false;
		}
		try
		{
			if ((Object)(object)player.health == (Object)null || ((Health)player.health).CurrentHP <= 0f)
			{
				return false;
			}
		}
		catch
		{
			return false;
		}
		if (IsLikelyLegitDownedState(player))
		{
			return false;
		}
		if (IsFalseKnockedOutState(player))
		{
			return true;
		}
		try
		{
			if ((Object)(object)player.state != (Object)null)
			{
				State cURRENT_STATE = player.state.CURRENT_STATE;
				if (IsHardDownedOrReviveState(cURRENT_STATE))
				{
					return true;
				}
				if (((int)cURRENT_STATE == 49 || (int)cURRENT_STATE == 16) && !MMConversation.isPlaying && !LetterBox.IsPlaying)
				{
					return true;
				}
			}
		}
		catch
		{
		}
		try
		{
			Interaction_CoopRevive component = ((Component)player).GetComponent<Interaction_CoopRevive>();
			if ((Object)(object)component != (Object)null && ((Behaviour)component).enabled)
			{
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	private static void ProcessPostReviveRaceGuards(string reason)
	{
		//IL_0196: Unknown result type (might be due to invalid IL or missing references)
		//IL_019b: 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_01a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01aa: Invalid comparison between Unknown and I4
		//IL_01ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_01b0: Invalid comparison between Unknown and I4
		//IL_0061: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)CoopManager.Instance == (Object)null || !CoopManager.CoopActive || _postReviveRaceGuardUntil.Count == 0)
		{
			return;
		}
		float unscaledTime = Time.unscaledTime;
		for (int i = 1; i < 8; i++)
		{
			if (!_postReviveRaceGuardUntil.TryGetValue(i, out var value))
			{
				continue;
			}
			if (unscaledTime > value)
			{
				_postReviveRaceGuardUntil.Remove(i);
				_nextPostReviveForceApplyAt.Remove(i);
			}
			else if (!GameManager.IsDungeon(PlayerFarming.Location))
			{
				_postReviveRaceGuardUntil.Remove(i);
				_nextPostReviveForceApplyAt.Remove(i);
			}
			else if (MMConversation.isPlaying || LetterBox.IsPlaying)
			{
				_nextExtraFalseDownedWatchdogAt[i] = unscaledTime + 0.35f;
			}
			else
			{
				if ((_nextExtraFalseDownedWatchdogAt.TryGetValue(i, out var value2) && unscaledTime < value2) || (_nextPostReviveForceApplyAt.TryGetValue(i, out var value3) && unscaledTime < value3))
				{
					continue;
				}
				PlayerFarming val = FindActivePlayerBySlot(i);
				if ((Object)(object)val == (Object)null || (Object)(object)((Component)val).gameObject == (Object)null || !((Component)val).gameObject.activeInHierarchy)
				{
					continue;
				}
				if (!IsLikelyStaleDownedPresentation(val))
				{
					_nextExtraFalseDownedWatchdogAt[i] = unscaledTime + 0.2f;
					_nextPostReviveForceApplyAt.Remove(i);
					continue;
				}
				string text = $"RaceGuard:{reason}(slot={i})";
				bool flag = false;
				bool flag2 = false;
				bool flag3 = false;
				bool flag4 = false;
				bool flag5 = false;
				try
				{
					flag5 = IsFalseKnockedOutState(val);
				}
				catch
				{
				}
				try
				{
					flag3 = val.IsKnockedOut;
				}
				catch
				{
				}
				try
				{
					if ((Object)(object)val.state != (Object)null)
					{
						State cURRENT_STATE = val.state.CURRENT_STATE;
						flag = IsHardDownedOrReviveState(cURRENT_STATE);
						flag2 = (int)cURRENT_STATE == 49 || (int)cURRENT_STATE == 16;
					}
				}
				catch
				{
				}
				try
				{
					Interaction_CoopRevive component = ((Component)val).GetComponent<Interaction_CoopRevive>();
					flag4 = (Object)(object)component != (Object)null && ((Behaviour)component).enabled;
				}
				catch
				{
				}
				bool flag6 = flag5 || flag3 || flag || flag2 || flag4;
				ForceReviveVisualState(val, text + (flag6 ? ".hard" : ".soft"));
				if (flag6)
				{
					SnapSpawnedPlayerToAwakeIdle(val, text);
					QueuePostReviveHardReset(val, text);
					_postReviveRaceGuardUntil[i] = Mathf.Max(value, unscaledTime + 1.25f);
					_nextExtraFalseDownedWatchdogAt[i] = unscaledTime + 0.9f;
					_nextPostReviveForceApplyAt[i] = unscaledTime + 1.1f;
				}
				else
				{
					_nextExtraFalseDownedWatchdogAt[i] = unscaledTime + 0.35f;
					_nextPostReviveForceApplyAt[i] = unscaledTime + 0.5f;
				}
				float num = 0f;
				try
				{
					if ((Object)(object)val.health != (Object)null)
					{
						num = ((Health)val.health).CurrentHP;
					}
				}
				catch
				{
				}
				Plugin.Log.LogWarning((object)$"[MP] Post-revive race guard corrected stale downed presentation for playerID={i} ({reason}, hp={num:0.00}, hardReset={flag6})");
			}
		}
	}

	private static FieldInfo FindBoolFieldOnTypeChain(Type t, params string[] names)
	{
		while (t != null)
		{
			foreach (string name in names)
			{
				FieldInfo field = t.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
				if (field != null && field.FieldType == typeof(bool))
				{
					return field;
				}
			}
			t = t.BaseType;
		}
		return null;
	}

	private static PropertyInfo FindBoolPropertyOnTypeChain(Type t, params string[] names)
	{
		while (t != null)
		{
			foreach (string name in names)
			{
				PropertyInfo property = t.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
				if (property != null && property.PropertyType == typeof(bool))
				{
					return property;
				}
			}
			t = t.BaseType;
		}
		return null;
	}

	private static bool IsNumericType(Type t)
	{
		if (!(t == typeof(float)) && !(t == typeof(int)))
		{
			return t == typeof(double);
		}
		return true;
	}

	private static FieldInfo FindNumericFieldOnTypeChain(Type t, params string[] names)
	{
		while (t != null)
		{
			foreach (string name in names)
			{
				FieldInfo field = t.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
				if (field != null && IsNumericType(field.FieldType))
				{
					return field;
				}
			}
			t = t.BaseType;
		}
		return null;
	}

	private static PropertyInfo FindNumericPropertyOnTypeChain(Type t, params string[] names)
	{
		while (t != null)
		{
			foreach (string name in names)
			{
				PropertyInfo property = t.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.FlattenHierarchy);
				if (property != null && property.CanWrite && IsNumericType(property.PropertyType))
				{
					return property;
				}
			}
			t = t.BaseType;
		}
		return null;
	}

	private static void EnsureHealthReflection(object health)
	{
		if (health != null)
		{
			Type type = health.GetType();
			if (!(type == _cachedHealthReflectionType))
			{
				_cachedHealthReflectionType = type;
				_healthInvincibleField = FindBoolFieldOnTypeChain(type, "invincible");
				_healthUntouchableField = FindBoolFieldOnTypeChain(type, "untouchable");
				_healthIgnoreProjectilesField = FindBoolFieldOnTypeChain(type, "IgnoreProjectiles", "ignoreProjectiles");
				_healthMaxHpField = FindNumericFieldOnTypeChain(type, "MaxHP", "maxHP", "MaxHealth", "maxHealth");
				_healthTotalHpField = FindNumericFieldOnTypeChain(type, "TotalHP", "totalHP", "TotalHealth", "totalHealth");
				_healthIgnoreProjectilesProperty = FindBoolPropertyOnTypeChain(type, "IgnoreProjectiles", "ignoreProjectiles");
				_healthMaxHpProperty = FindNumericPropertyOnTypeChain(type, "MaxHP", "maxHP", "MaxHealth", "maxHealth");
				_healthTotalHpProperty = FindNumericPropertyOnTypeChain(type, "TotalHP", "totalHP", "TotalHealth", "totalHealth");
				_healthClearAllStasisEffectsMethod = AccessTools.Method(type, "ClearAllStasisEffects", (Type[])null, (Type[])null);
			}
		}
	}

	private static void TryRaiseNumericField(FieldInfo fi, object instance, float target)
	{
		try
		{
			if (fi == null || instance == null)
			{
				return;
			}
			object value = fi.GetValue(instance);
			if (!(((value == null) ? 0f : Convert.ToSingle(value)) >= target))
			{
				if (fi.FieldType == typeof(float))
				{
					fi.SetValue(instance, target);
				}
				else if (fi.FieldType == typeof(int))
				{
					fi.SetValue(instance, Mathf.CeilToInt(target));
				}
				else if (fi.FieldType == typeof(double))
				{
					fi.SetValue(instance, (double)target);
				}
			}
		}
		catch
		{
		}
	}

	private static void TryRaiseNumericProperty(PropertyInfo pi, object instance, float target)
	{
		try
		{
			if (pi == null || instance == null || !pi.CanWrite)
			{
				return;
			}
			object obj = null;
			try
			{
				obj = pi.GetValue(instance, null);
			}
			catch
			{
			}
			if (!(((obj == null) ? 0f : Convert.ToSingle(obj)) >= target))
			{
				if (pi.PropertyType == typeof(float))
				{
					pi.SetValue(instance, target, null);
				}
				else if (pi.PropertyType == typeof(int))
				{
					pi.SetValue(instance, Mathf.CeilToInt(target), null);
				}
				else if (pi.PropertyType == typeof(double))
				{
					pi.SetValue(instance, (double)target, null);
				}
			}
		}
		catch
		{
		}
	}

	private static void TryRaiseHealthCapacity(object health, float targetHp)
	{
		if (health != null && !(targetHp <= 0f))
		{
			EnsureHealthReflection(health);
			TryRaiseNumericField(_healthMaxHpField, health, targetHp);
			TryRaiseNumericField(_healthTotalHpField, health, targetHp);
			TryRaiseNumericProperty(_healthMaxHpProperty, health, targetHp);
			TryRaiseNumericProperty(_healthTotalHpProperty, health, targetHp);
		}
	}

	private static void TrySetFloatField(FieldInfo fi, object instance, float value)
	{
		try
		{
			if (fi != null && instance != null && fi.FieldType == typeof(float))
			{
				fi.SetValue(instance, value);
			}
		}
		catch
		{
		}
	}

	private static void TrySetIntField(FieldInfo fi, object instance, int value)
	{
		try
		{
			if (fi != null && instance != null && fi.FieldType == typeof(int))
			{
				fi.SetValue(instance, value);
			}
		}
		catch
		{
		}
	}

	private static void TrySetBoolField(FieldInfo fi, object instance, bool value)
	{
		try
		{
			if (fi != null && instance != null && fi.FieldType == typeof(bool))
			{
				fi.SetValue(instance, value);
			}
		}
		catch
		{
		}
	}

	private static void TrySetBoolProperty(PropertyInfo pi, object instance, bool value)
	{
		try
		{
			if (pi != null && instance != null && pi.CanWrite && pi.PropertyType == typeof(bool))
			{
				pi.SetValue(instance, value, null);
			}
		}
		catch
		{
		}
	}

	private static void ForceReviveVisualState(PlayerFarming player, string reason)
	{
		//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_020a: Unknown result type (might be due to invalid IL or missing references)
		//IL_020e: Invalid comparison between Unknown and I4
		//IL_0210: Unknown result type (might be due to invalid IL or missing references)
		//IL_0214: Invalid comparison between Unknown and I4
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		bool flag = !string.IsNullOrEmpty(reason) && reason.IndexOf("PostRevive:", StringComparison.Ordinal) >= 0;
		bool flag2 = false;
		bool flag3 = false;
		bool flag4 = false;
		try
		{
			if ((Object)(object)player.state != (Object)null)
			{
				flag2 = ShouldForceIdleForSpawnUnlock(player.state.CURRENT_STATE);
			}
		}
		catch
		{
		}
		try
		{
			flag3 = player.IsKnockedOut;
		}
		catch
		{
		}
		try
		{
			if ((Object)(object)player.health != (Object)null)
			{
				EnsureHealthReflection(player.health);
				float reviveWakeHealth = GetReviveWakeHealth(player, reason);
				if (IsSacrificialReviveFlowReason(reason))
				{
					TryRaiseHealthCapacity(player.health, reviveWakeHealth);
				}
				if (((Health)player.health).CurrentHP < reviveWakeHealth)
				{
					((Health)player.health).HP = reviveWakeHealth;
				}
				((Behaviour)player.health).enabled = true;
				TrySetBoolField(_healthInvincibleField, player.health, value: false);
				TrySetBoolField(_healthUntouchableField, player.health, value: false);
				TrySetBoolField(_healthIgnoreProjectilesField, player.health, value: false);
				TrySetBoolProperty(_healthIgnoreProjectilesProperty, player.health, value: false);
				if (_healthClearAllStasisEffectsMethod != null)
				{
					try
					{
						_healthClearAllStasisEffectsMethod.Invoke(player.health, null);
					}
					catch
					{
					}
				}
			}
		}
		catch
		{
		}
		try
		{
			player.IsKnockedOut = false;
		}
		catch
		{
		}
		try
		{
			Interaction_CoopRevive component = ((Component)player).GetComponent<Interaction_CoopRevive>();
			flag4 = (Object)(object)component != (Object)null && ((Behaviour)component).enabled;
			if (flag4)
			{
				((Behaviour)component).enabled = false;
			}
		}
		catch
		{
		}
		try
		{
			if ((Object)(object)player.playerController != (Object)null)
			{
				TrySetFloatField(_playerControllerInvincibleTimerField, player.playerController, 0f);
				TrySetFloatField(_playerControllerUntouchableTimerField, player.playerController, 0f);
				TrySetFloatField(_playerControllerImmuneToProjectilesTimerField, player.playerController, 0f);
				TrySetIntField(_playerControllerUntouchableTimerFlashField, player.playerController, 0);
				if (flag2 || flag3 || flag4 || flag)
				{
					player.playerController.ResetSpecificMovementAnimations();
				}
			}
		}
		catch
		{
		}
		try
		{
			if ((Object)(object)player.state != (Object)null)
			{
				player.state.LockStateChanges = false;
				State cURRENT_STATE = player.state.CURRENT_STATE;
				bool flag5 = (int)cURRENT_STATE == 49 || (int)cURRENT_STATE == 16;
				if (flag2 || (flag && flag5))
				{
					player.state.CURRENT_STATE = (State)0;
				}
			}
		}
		catch
		{
		}
		bool flag6 = true;
		if (!string.IsNullOrEmpty(reason) && reason.IndexOf(".soft", StringComparison.Ordinal) >= 0 && reason.IndexOf("PostRevive:", StringComparison.Ordinal) < 0 && reason.IndexOf("Watchdog", StringComparison.Ordinal) < 0 && reason.IndexOf("WakeKnockedOutPlayer", StringComparison.Ordinal) < 0)
		{
			flag6 = false;
		}
		if (flag6)
		{
			try
			{
				player.SetSkin(false);
			}
			catch
			{
				try
				{
					player.SetSkin();
				}
				catch
				{
				}
			}
		}
		try
		{
			if ((Object)(object)player.Spine != (Object)null)
			{
				player.Spine.timeScale = 1f;
				player.Spine.UseDeltaTime = true;
				MeshRenderer component2 = ((Component)player.Spine).GetComponent<MeshRenderer>();
				if ((Object)(object)component2 != (Object)null && !((Renderer)component2).enabled)
				{
					((Renderer)component2).enabled = true;
				}
				if (((SkeletonRenderer)player.Spine).skeleton != null && player.Spine.AnimationState != null)
				{
					player.Spine.AnimationState.Apply(((SkeletonRenderer)player.Spine).skeleton, true);
				}
			}
		}
		catch
		{
		}
		EnsureExtraSpawnStateUnlocked(player, reason);
	}

	private static void SnapSpawnedPlayerToAwakeIdle(PlayerFarming player, string reason)
	{
		if ((Object)(object)player == (Object)null || (Object)(object)player.state == (Object)null)
		{
			return;
		}
		try
		{
			player.IsKnockedOut = false;
		}
		catch
		{
		}
		try
		{
			player.state.LockStateChanges = false;
			player.state.CURRENT_STATE = (State)0;
		}
		catch
		{
		}
		try
		{
			if ((Object)(object)player.playerController != (Object)null)
			{
				player.playerController.ResetSpecificMovementAnimations();
			}
		}
		catch
		{
		}
		try
		{
			if ((Object)(object)player.Spine != (Object)null)
			{
				player.Spine.timeScale = 1f;
				player.Spine.UseDeltaTime = true;
				if (player.Spine.AnimationState != null && ((SkeletonRenderer)player.Spine).skeleton != null)
				{
					player.Spine.AnimationState.Apply(((SkeletonRenderer)player.Spine).skeleton, true);
				}
			}
		}
		catch
		{
		}
		Plugin.Log.LogInfo((object)$"[MP] Spawn visual snap to Idle for playerID={player.playerID} ({reason})");
	}

	private static IEnumerator PostReviveHardResetRoutine(int slot, string reason)
	{
		try
		{
			int settledTicks = 0;
			for (int i = 0; i < 18; i++)
			{
				if ((Object)(object)CoopManager.Instance == (Object)null)
				{
					break;
				}
				if (!CoopManager.CoopActive)
				{
					break;
				}
				PlayerFarming val = FindActivePlayerBySlot(slot);
				if ((Object)(object)val == (Object)null)
				{
					yield return (object)new WaitForSeconds(0.1f);
					continue;
				}
				bool num = NeedsWakeRecovery(val) || IsFalseKnockedOutState(val);
				bool flag = !num && i < 6;
				if (num || i < 2 || flag)
				{
					ForceReviveVisualState(val, $"PostRevive:{reason}.tick{i}");
				}
				if (!num)
				{
					settledTicks++;
					if (settledTicks >= 6 && i >= 8)
					{
						break;
					}
				}
				else
				{
					settledTicks = 0;
				}
				yield return (object)new WaitForSeconds((i < 6) ? 0.12f : 0.18f);
			}
		}
		finally
		{
			_postReviveHardResetSlots.Remove(slot);
		}
	}

	private static void EnsureExtraSpawnStateUnlocked(PlayerFarming player, string reason)
	{
		//IL_0042: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)player == (Object)null || player.isLamb || player.playerID < 1 || (Object)(object)player.state == (Object)null)
		{
			return;
		}
		try
		{
			player.state.LockStateChanges = false;
		}
		catch
		{
		}
		try
		{
			if (ShouldForceIdleForSpawnUnlock(player.state.CURRENT_STATE))
			{
				player.state.CURRENT_STATE = (State)0;
				Plugin.Log.LogInfo((object)$"[MP] Restored spawn state to Idle for playerID={player.playerID} ({reason})");
			}
		}
		catch
		{
		}
	}

	private static void EnsureAllExtraPlayersUnlocked(string reason)
	{
		if (PlayerFarming.players == null)
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)((Component)player).gameObject == (Object)null) && ((Component)player).gameObject.activeInHierarchy)
			{
				EnsureExtraSpawnStateUnlocked(player, reason);
			}
		}
	}

	private static bool IsFalseKnockedOutState(PlayerFarming player)
	{
		//IL_005c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0063: Invalid comparison between Unknown and I4
		if ((Object)(object)player == (Object)null)
		{
			return false;
		}
		try
		{
			if ((Object)(object)player.health == (Object)null || ((Health)player.health).CurrentHP <= 0f)
			{
				return false;
			}
			if (IsLikelyLegitDownedState(player))
			{
				return false;
			}
			if (player.IsKnockedOut)
			{
				return true;
			}
			if ((Object)(object)player.state != (Object)null && (int)player.state.CURRENT_STATE == 63)
			{
				return true;
			}
			return false;
		}
		catch
		{
			return false;
		}
	}

	private static void ClearFalseKnockedOutState(PlayerFarming player, string reason)
	{
		if (IsFalseKnockedOutState(player))
		{
			player.IsKnockedOut = false;
			EnsureExtraSpawnStateUnlocked(player, reason);
			QueuePostReviveHardReset(player, reason);
			Plugin.Log.LogInfo((object)$"[MP] Cleared false downed flag for playerID={player.playerID} ({reason})");
		}
	}

	private static void ClearFalseKnockedOutStatesForAll(string reason)
	{
		if (PlayerFarming.players == null)
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)((Component)player).gameObject == (Object)null) && ((Component)player).gameObject.activeInHierarchy)
			{
				ClearFalseKnockedOutState(player, reason);
			}
		}
	}

	public static void SetSkin_Recolor(PlayerFarming __instance)
	{
		if (__instance.isLamb)
		{
			return;
		}
		int playerID = __instance.playerID;
		if (playerID > 0)
		{
			if (playerID < Plugin.GoatColors.Length && !CustomSpineCompatibility.ShouldPreserveCustomSpineColor(__instance) && (Object)(object)__instance.Spine != (Object)null && ((SkeletonRenderer)__instance.Spine).skeleton != null)
			{
				((SkeletonRenderer)__instance.Spine).skeleton.R = Plugin.GoatColors[playerID].r;
				((SkeletonRenderer)__instance.Spine).skeleton.G = Plugin.GoatColors[playerID].g;
				((SkeletonRenderer)__instance.Spine).skeleton.B = Plugin.GoatColors[playerID].b;
				((SkeletonRenderer)__instance.Spine).skeleton.A = Plugin.GoatColors[playerID].a;
			}
			ApplyIndicator(__instance, playerID);
		}
	}

	private static void ApplyIndicator(PlayerFarming player, int slot)
	{
		//IL_0011: Unknown result type (might be due to invalid IL or missing references)
		//IL_0016: Unknown result type (might be due to invalid IL or missing references)
		//IL_062d: Unknown result type (might be due to invalid IL or missing references)
		//IL_063c: Unknown result type (might be due to invalid IL or missing references)
		//IL_05af: Unknown result type (might be due to invalid IL or missing references)
		//IL_05b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0672: 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_05d0: Unknown result type (might be due to invalid IL or missing references)
		//IL_05d5: 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_00ca: 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_039f: Unknown result type (might be due to invalid IL or missing references)
		//IL_03c9: 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_03f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_02e4: 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)
		if (slot >= Plugin.IndicatorColors.Length)
		{
			return;
		}
		Color val = Plugin.IndicatorColors[slot];
		string text = (slot + 1).ToString();
		HUD_Hearts val2 = player.hudHearts;
		if ((Object)(object)val2 != (Object)null && (Object)(object)val2.playerFarming != (Object)(object)player)
		{
			val2 = null;
		}
		if ((Object)(object)val2 != (Object)null && (Object)(object)val2.coopIndicatorIcon != (Object)null)
		{
			CoopIndicatorIcon coopIndicatorIcon = val2.coopIndicatorIcon;
			if ((Object)(object)coopIndicatorIcon.GoatImage != (Object)null)
			{
				((Graphic)coopIndicatorIcon.GoatImage).color = val;
			}
			if ((Object)(object)coopIndicatorIcon.UserName != (Object)null)
			{
				coopIndicatorIcon.UserName.text = text;
			}
		}
		Image[] componentsInChildren2;
		if (slot >= 2 && (Object)(object)val2 != (Object)null && (Object)(object)val2.faithAmmo != (Object)null)
		{
			Color color = Color.Lerp(val, Color.white, 0.05f);
			Transform[] componentsInChildren;
			if (!_faithAmmoDumped)
			{
				_faithAmmoDumped = true;
				componentsInChildren = ((Component)val2.faithAmmo).GetComponentsInChildren<Transform>(true);
				foreach (Transform val3 in componentsInChildren)
				{
					Image component = ((Component)val3).GetComponent<Image>();
					Plugin.Log.LogInfo((object)string.Format("[FaithAmmo] child: '{0}' hasImage={1} color={2}", ((Object)((Component)val3).gameObject).name, (Object)(object)component != (Object)null, ((Object)(object)component != (Object)null) ? ((object)((Graphic)component).color).ToString() : "n/a"));
				}
			}
			Transform val4 = null;
			componentsInChildren = ((Component)val2.faithAmmo).GetComponentsInChildren<Transform>(true);
			foreach (Transform val5 in componentsInChildren)
			{
				if (((Object)((Component)val5).gameObject).name == "FaithBarContainer")
				{
					val4 = val5;
					break;
				}
			}
			if ((Object)(object)val4 != (Object)null)
			{
				componentsInChildren2 = ((Component)val4).GetComponentsInChildren<Image>(true);
				foreach (Image val6 in componentsInChildren2)
				{
					switch (((Object)((Component)val6).gameObject).name)
					{
					case "Glow":
					case "Goop":
					case "LoseFaithFeedback":
					case "GainFaithFeedback":
					case "RedGlow":
					case "FaithProgressBar":
					case "FaithProgressBar (1)":
					case "White flash":
						continue;
					}
					((Graphic)val6).color = color;
				}
			}
			componentsInChildren = ((Component)val2.faithAmmo).GetComponentsInChildren<Transform>(true);
			foreach (Transform val7 in componentsInChildren)
			{
				if (((Object)((Component)val7).gameObject).name == "Goat")
				{
					Image component2 = ((Component)val7).GetComponent<Image>();
					if ((Object)(object)component2 != (Object)null)
					{
						((Graphic)component2).color = color;
					}
				}
			}
		}
		if (slot < 2 || (Object)(object)player.CoopIndicatorGoat == (Object)null)
		{
			return;
		}
		componentsInChildren2 = player.CoopIndicatorGoat.GetComponentsInChildren<Image>(true);
		foreach (Image val8 in componentsInChildren2)
		{
			if (((Object)((Component)val8).gameObject).name != "Text (1)")
			{
				((Graphic)val8).color = val;
			}
		}
		SpriteRenderer[] componentsInChildren3 = player.CoopIndicatorGoat.GetComponentsInChildren<SpriteRenderer>(true);
		for (int j = 0; j < componentsInChildren3.Length; j++)
		{
			componentsInChildren3[j].color = val;
		}
		SkeletonGraphic[] componentsInChildren4 = player.CoopIndicatorGoat.GetComponentsInChildren<SkeletonGraphic>(true);
		for (int k = 0; k < componentsInChildren4.Length; k++)
		{
			((Graphic)componentsInChildren4[k]).color = val;
		}
		if (!_cachedTextImages.TryGetValue(slot, out var value) || (Object)(object)value == (Object)null)
		{
			_cachedTextImages.Remove(slot);
			Transform[] componentsInChildren = player.CoopIndicatorGoat.GetComponentsInChildren<Transform>(true);
			foreach (Transform val9 in componentsInChildren)
			{
				if (((Object)((Component)val9).gameObject).name.Contains("Text"))
				{
					Image component3 = ((Component)val9).GetComponent<Image>();
					if ((Object)(object)component3 != (Object)null)
					{
						_cachedTextImages[slot] = component3;
						value = component3;
						break;
					}
				}
			}
		}
		if (!_cachedTextImages.TryGetValue(slot, out var value2) || (Object)(object)value2 == (Object)null)
		{
			return;
		}
		if (!_cachedSprites.TryGetValue(slot, out var value3) || (Object)(object)value3 == (Object)null)
		{
			Sprite sprite = value2.sprite;
			float num = (((Object)(object)sprite != (Object)null) ? sprite.pixelsPerUnit : 100f) * 0.12f;
			string text2 = Path.Combine(Path.GetDirectoryName(typeof(Plugin).Assembly.Location), text + ".png");
			Texture2D val10 = null;
			if (File.Exists(text2))
			{
				try
				{
					val10 = LoadPNG(text2);
					if ((Object)(object)val10 != (Object)null)
					{
						Plugin.Log.LogInfo((object)$"[MP] Loaded PNG sprite: {text2} {((Texture)val10).width}x{((Texture)val10).height}");
					}
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[MP] Failed to load PNG " + text2 + ": " + ex.Message));
					val10 = null;
				}
			}
			if ((Object)(object)val10 == (Object)null)
			{
				int num2;
				Rect rect;
				if (!((Object)(object)sprite != (Object)null))
				{
					num2 = 32;
				}
				else
				{
					rect = sprite.rect;
					num2 = (int)((Rect)(ref rect)).width;
				}
				int num3 = num2;
				int num4;
				if (!((Object)(object)sprite != (Object)null))
				{
					num4 = 32;
				}
				else
				{
					rect = sprite.rect;
					num4 = (int)((Rect)(ref rect)).height;
				}
				int num5 = num4;
				val10 = BuildNumberTexture(text, num3, num5);
				Plugin.Log.LogInfo((object)$"[MP] Using generated texture {num3}x{num5} (no PNG found at {text2})");
			}
			value3 = Sprite.Create(val10, new Rect(0f, 0f, (float)((Texture)val10).width, (float)((Texture)val10).height), new Vector2(0.5f, 0.5f), num);
			_cachedSprites[slot] = value3;
		}
		if ((Object)(object)value2.sprite != (Object)(object)value3)
		{
			value2.sprite = value3;
			((Graphic)value2).color = Color.white;
			((Behaviour)value2).enabled = true;
		}
	}

	private static SpriteRenderer FindHaloSR(PlayerFarming player, int slot)
	{
		if (_cachedHaloSR.TryGetValue(slot, out var value) && (Object)(object)value != (Object)null)
		{
			return value;
		}
		if ((Object)(object)player.CoopIndicatorGoat == (Object)null)
		{
			return null;
		}
		SpriteRenderer component = player.CoopIndicatorGoat.GetComponent<SpriteRenderer>();
		if ((Object)(object)component != (Object)null)
		{
			_cachedHaloSR[slot] = component;
			Plugin.Log.LogInfo((object)$"[MP] Found halo SR on CoopIndicatorGoat root, slot={slot}");
		}
		return component;
	}

	private static Sprite GetHaloSprite(int slot)
	{
		//IL_00a3: 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)
		if (_cachedHaloSprites.TryGetValue(slot, out var value) && (Object)(object)value != (Object)null)
		{
			return value;
		}
		if (!_haloSpriteNames.TryGetValue(slot, out var value2))
		{
			return null;
		}
		string text = Path.Combine(Path.GetDirectoryName(typeof(Plugin).Assembly.Location), value2);
		if (!File.Exists(text))
		{
			Plugin.Log.LogWarning((object)("[MP] Halo PNG not found: " + text));
			return null;
		}
		try
		{
			Texture2D val = LoadPNG(text);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			float num = 100f;
			Sprite val2 = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), num);
			_cachedHaloSprites[slot] = val2;
			Plugin.Log.LogInfo((object)$"[MP] Loaded halo sprite: {value2} {((Texture)val).width}x{((Texture)val).height} ppu={num}");
			return val2;
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Failed to load halo PNG " + text + ": " + ex.Message));
			return null;
		}
	}

	public static void HUD_Update(HUD_Manager __instance)
	{
		//IL_0065: Unknown result type (might be due to invalid IL or missing references)
		//IL_006b: Expected O, but got Unknown
		//IL_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0089: Expected O, but got Unknown
		//IL_0109: Unknown result type (might be due to invalid IL or missing references)
		if (PlayerFarming.playersCount < 2 || LetterBox.IsPlaying)
		{
			return;
		}
		FieldInfo field = typeof(HUD_Manager).GetField("_playerTwoWidget", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field2 = typeof(HUD_Manager).GetField("_playerTwoArrow", BindingFlags.Instance | BindingFlags.NonPublic);
		if (field == null || field2 == null)
		{
			return;
		}
		object value = field.GetValue(__instance);
		Image val = (Image)((value is Image) ? value : null);
		object value2 = field2.GetValue(__instance);
		RectTransform val2 = (RectTransform)((value2 is RectTransform) ? value2 : null);
		if ((Object)(object)val == (Object)null || (Object)(object)val2 == (Object)null)
		{
			return;
		}
		((Component)val).gameObject.SetActive(false);
		for (int i = 1; i < 8; i++)
		{
			if ((Object)(object)_playerWidgets[i] == (Object)null)
			{
				_playerWidgets[i] = Object.Instantiate<Image>(val, ((Component)val).transform.parent);
				_playerArrows[i] = Object.Instantiate<RectTransform>(val2, ((Component)val2).transform.parent);
				((Graphic)_playerWidgets[i]).color = Plugin.IndicatorColors[i];
				((Component)_playerWidgets[i]).gameObject.SetActive(false);
			}
			UpdateExtraPlayerWidget(_playerWidgets[i], _playerArrows[i], i);
		}
	}

	private static void UpdateExtraPlayerWidget(Image widget, RectTransform arrow, int slot)
	{
		//IL_0083: 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_008e: Unknown result type (might be due to invalid IL or missing references)
		//IL_009b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a8: 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_011f: 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_00fa: 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_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)
		//IL_0191: 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_01a7: 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_0134: 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_01c9: 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_0204: Unknown result type (might be due to invalid IL or missing references)
		//IL_020b: Unknown result type (might be due to invalid IL or missing references)
		if ((Object)(object)widget == (Object)null || (Object)(object)arrow == (Object)null)
		{
			return;
		}
		PlayerFarming val = null;
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player != (Object)null && player.playerID == slot)
			{
				val = player;
				break;
			}
		}
		if ((Object)(object)val == (Object)null)
		{
			((Component)widget).gameObject.SetActive(false);
			return;
		}
		Vector3 val2 = CameraManager.instance.CameraRef.WorldToScreenPoint(((Component)val).transform.position);
		bool flag = val2.z < 0f || val2.x < 0f || val2.x > (float)Screen.width || val2.y < 0f || val2.y > (float)Screen.height;
		if (!flag && (Object)(object)PlayerFarming.Instance != (Object)null && Vector3.Distance(((Component)PlayerFarming.Instance).transform.position, ((Component)val).transform.position) > 15f)
		{
			flag = true;
		}
		((Component)widget).gameObject.SetActive(flag);
		if (flag)
		{
			if (val2.z < 0f)
			{
				val2.x = (float)Screen.width - val2.x;
				val2.y = (float)Screen.height - val2.y;
			}
			int num = 60;
			((Transform)((Graphic)widget).rectTransform).position = new Vector3(Mathf.Clamp(val2.x, (float)num, (float)(Screen.width - num)), Mathf.Clamp(val2.y, (float)num, (float)(Screen.height - num)), 0f);
			((Transform)arrow).up = ((Component)arrow).transform.position - val2;
			if ((Object)(object)PlayerFarming.Instance != (Object)null)
			{
				float num2 = Vector3.Distance(((Component)PlayerFarming.Instance).transform.position, ((Component)val).transform.position);
				float num3 = Mathf.Lerp(1f, 0.5f, Mathf.Clamp01(num2 / 30f));
				((Transform)((Graphic)widget).rectTransform).localScale = Vector3.one * num3;
			}
		}
	}

	private static void UnhookVanillaCoopDelegates()
	{
		//IL_003e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0044: Expected O, but got Unknown
		//IL_009d: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a4: Expected O, but got Unknown
		//IL_0052: Unknown result type (might be due to invalid IL or missing references)
		//IL_005c: Expected O, but got Unknown
		//IL_00b4: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Expected O, but got Unknown
		MethodInfo method = typeof(CoopManager).GetMethod("OnPlayerUserChanged", BindingFlags.Static | BindingFlags.NonPublic);
		if (method != null)
		{
			Delegate obj = Delegate.CreateDelegate(typeof(PlayerUserChangedDelegate), method, throwOnBindFailure: false);
			PlayerUserChangedDelegate val = (PlayerUserChangedDelegate)((obj is PlayerUserChangedDelegate) ? obj : null);
			if (val != null)
			{
				UserHelper.OnPlayerUserChanged = (PlayerUserChangedDelegate)Delegate.Remove((Delegate?)(object)UserHelper.OnPlayerUserChanged, (Delegate?)(object)val);
			}
		}
		MethodInfo method2 = typeof(CoopManager).GetMethod("OnPlayerGamePadChanged", BindingFlags.Static | BindingFlags.NonPublic);
		if (method2 != null)
		{
			Delegate obj2 = Delegate.CreateDelegate(typeof(PlayerGamePadChangedDelegate), method2, throwOnBindFailure: false);
			PlayerGamePadChangedDelegate val2 = (PlayerGamePadChangedDelegate)((obj2 is PlayerGamePadChangedDelegate) ? obj2 : null);
			if (val2 != null)
			{
				UserHelper.OnPlayerGamePadChanged = (PlayerGamePadChangedDelegate)Delegate.Remove((Delegate?)(object)UserHelper.OnPlayerGamePadChanged, (Delegate?)(object)val2);
			}
		}
	}

	public static void RefreshCoopPlayerRewired()
	{
		EnforceKeyboardOwnership();
		if (ReInput.controllers == null)
		{
			return;
		}
		for (int i = 0; i < PlayerFarming.players.Count; i++)
		{
			PlayerFarming val = PlayerFarming.players[i];
			if ((Object)(object)val == (Object)null || !((Component)val).gameObject.activeSelf)
			{
				continue;
			}
			Player player = RewiredInputManager.GetPlayer((!val.isLamb) ? val.playerID : 0);
			if (player == null)
			{
				continue;
			}
			val.rewiredPlayer = player;
			val.canUseKeyboard = player.controllers.hasKeyboard;
			foreach (Joystick joystick in player.controllers.Joysticks)
			{
				EnsureVJoyMapForPlayer(player, joystick, "RefreshCoopPlayerRewired");
			}
		}
		RefreshDesiredExtraSlotsFromActivePlayers();
		TryAutoRespawnMissingExtraSlots("RefreshCoopPlayerRewired");
		StopOrphanedRumbleHeartbeat("RefreshCoopPlayerRewired");
	}

	private static void MarkDesiredExtraSlot(int slot, bool desired)
	{
		if (slot >= 2 && slot < 8)
		{
			if (desired)
			{
				_desiredExtraSlots.Add(slot);
			}
			else
			{
				_desiredExtraSlots.Remove(slot);
			}
		}
	}

	private static void RefreshDesiredExtraSlotsFromActivePlayers()
	{
		if (!CoopManager.CoopActive)
		{
			_desiredExtraSlots.Clear();
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !player.isLamb && ((Component)player).gameObject.activeSelf)
			{
				MarkDesiredExtraSlot(player.playerID, desired: true);
			}
		}
	}

	private static void PrunePendingSpawnSlots()
	{
		if (_pendingSpawnSlots.Count > 0)
		{
			_pendingSpawnSlots.RemoveWhere((int slot) => slot < 2 || slot >= 8);
		}
		if (_pendingSpawnUseAnimation.Count > 0)
		{
			List<int> list = null;
			foreach (int key in _pendingSpawnUseAnimation.Keys)
			{
				if (key < 2 || key >= 8)
				{
					if (list == null)
					{
						list = new List<int>();
					}
					list.Add(key);
				}
			}
			if (list != null)
			{
				foreach (int item in list)
				{
					_pendingSpawnUseAnimation.Remove(item);
				}
			}
		}
		if (_pendingSpawnFirstSeenAt.Count > 0)
		{
			List<int> list2 = null;
			foreach (int key2 in _pendingSpawnFirstSeenAt.Keys)
			{
				if (!_pendingSpawnSlots.Contains(key2))
				{
					if (list2 == null)
					{
						list2 = new List<int>();
					}
					list2.Add(key2);
				}
			}
			if (list2 != null)
			{
				foreach (int item2 in list2)
				{
					_pendingSpawnFirstSeenAt.Remove(item2);
				}
			}
		}
		if (_pendingSpawnSlots.Count == 0)
		{
			return;
		}
		bool flag = (Object)(object)CoopManager.Instance != (Object)null && CoopManager.Instance.IsSpawningOrRemovingPlayer;
		float unscaledTime = Time.unscaledTime;
		List<int> list3 = null;
		List<int> list4 = null;
		foreach (int pendingSpawnSlot in _pendingSpawnSlots)
		{
			bool num = (Object)(object)FindActivePlayerBySlot(pendingSpawnSlot) != (Object)null;
			bool flag2 = CoopManager.AllPlayerGameObjects != null && pendingSpawnSlot < CoopManager.AllPlayerGameObjects.Length && (Object)(object)CoopManager.AllPlayerGameObjects[pendingSpawnSlot] != (Object)null && CoopManager.AllPlayerGameObjects[pendingSpawnSlot].activeInHierarchy;
			if (num)
			{
				if (list3 == null)
				{
					list3 = new List<int>();
				}
				list3.Add(pendingSpawnSlot);
				continue;
			}
			if (flag)
			{
				_pendingSpawnFirstSeenAt.Remove(pendingSpawnSlot);
				continue;
			}
			if (!_pendingSpawnFirstSeenAt.TryGetValue(pendingSpawnSlot, out var value))
			{
				_pendingSpawnFirstSeenAt[pendingSpawnSlot] = unscaledTime;
				continue;
			}
			float num2 = (flag2 ? 6f : 12f);
			if (!(unscaledTime - value < num2))
			{
				if (list4 == null)
				{
					list4 = new List<int>();
				}
				list4.Add(pendingSpawnSlot);
			}
		}
		if (list3 != null)
		{
			foreach (int item3 in list3)
			{
				_pendingSpawnSlots.Remove(item3);
				_pendingSpawnUseAnimation.Remove(item3);
				_pendingSpawnFirstSeenAt.Remove(item3);
			}
		}
		if (list4 == null || list4.Count == 0)
		{
			return;
		}
		foreach (int item4 in list4)
		{
			_pendingSpawnSlots.Remove(item4);
			_pendingSpawnUseAnimation.Remove(item4);
			_pendingSpawnFirstSeenAt.Remove(item4);
			Plugin.Log.LogWarning((object)$"[MP] Cleared stale pending spawn slot {item4} after timeout");
		}
	}

	private static bool SlotHasJoystick(int slot)
	{
		Player player = RewiredInputManager.GetPlayer(slot);
		if (player != null && player.controllers != null && player.controllers.Joysticks != null)
		{
			return player.controllers.Joysticks.Count > 0;
		}
		return false;
	}

	private static bool IsVJoyJoystick(Joystick joystick)
	{
		if (joystick == null)
		{
			return false;
		}
		return ((((Controller)joystick).name ?? string.Empty) + " " + (((Controller)joystick).hardwareName ?? string.Empty) + " " + (((Controller)joystick).hardwareIdentifier ?? string.Empty)).IndexOf("vJoy", StringComparison.OrdinalIgnoreCase) >= 0;
	}

	private static bool HasUsableJoystickMap(Player player, Joystick joystick)
	{
		if (player == null || joystick == null || player.controllers == null || player.controllers.maps == null)
		{
			return false;
		}
		IList<ControllerMap> maps = player.controllers.maps.GetMaps((Controller)(object)joystick);
		if (maps == null)
		{
			return false;
		}
		bool flag = false;
		bool flag2 = false;
		for (int i = 0; i < maps.Count; i++)
		{
			ControllerMap val = maps[i];
			if (val == null || val.categoryId != 0)
			{
				continue;
			}
			foreach (ActionElementMap allMap in val.AllMaps)
			{
				if (allMap != null)
				{
					flag |= allMap.actionId == 1;
					flag2 |= allMap.actionId == 0;
				}
			}
		}
		return flag && flag2;
	}

	private static ControllerMap GetOrCreateVJoyMap(Player player, Joystick joystick, int categoryId)
	{
		ControllerMap map = player.controllers.maps.GetMap((ControllerType)2, ((Controller)joystick).id, categoryId, 0);
		if (map == null)
		{
			player.controllers.maps.AddEmptyMap((ControllerType)2, ((Controller)joystick).id, categoryId, 0);
			map = player.controllers.maps.GetMap((ControllerType)2, ((Controller)joystick).id, categoryId, 0);
		}
		if (map != null)
		{
			map.enabled = true;
		}
		return map;
	}

	private static bool MapContainsAction(ControllerMap map, int actionId)
	{
		if (map == null)
		{
			return false;
		}
		foreach (ActionElementMap allMap in map.AllMaps)
		{
			if (allMap != null && allMap.actionId == actionId)
			{
				return true;
			}
		}
		return false;
	}

	private static int CreateVJoyBinding(ControllerMap map, int actionId, Pole pole, int elementId, ControllerElementType elementType, AxisRange axisRange, bool invert = false)
	{
		//IL_0014: 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: Unknown result type (might be due to invalid IL or missing references)
		if (map == null || elementId < 0 || MapContainsAction(map, actionId))
		{
			return 0;
		}
		return map.CreateElementMap(actionId, pole, elementId, elementType, axisRange, invert) ? 1 : 0;
	}

	private static int CreateVJoyButtonBindings(ControllerMap map, Joystick joystick, int buttonIndex, params int[] actionIds)
	{
		int num = TranslateElementIdentifierByIndex(joystick, (ControllerElementType)1, buttonIndex);
		if (num < 0)
		{
			return 0;
		}
		int num2 = 0;
		for (int i = 0; i < actionIds.Length; i++)
		{
			num2 += CreateVJoyBinding(map, actionIds[i], (Pole)0, num, (ControllerElementType)1, (AxisRange)0);
		}
		return num2;
	}

	private static bool TryCreateStandaloneVJoyMaps(Player player, Joystick joystick, out int createdMaps, out int createdBindings)
	{
		createdMaps = 0;
		createdBindings = 0;
		ControllerMap orCreateVJoyMap = GetOrCreateVJoyMap(player, joystick, 0);
		ControllerMap orCreateVJoyMap2 = GetOrCreateVJoyMap(player, joystick, 1);
		int elementId = TranslateElementIdentifierByIndex(joystick, (ControllerElementType)0, 0);
		int elementId2 = TranslateElementIdentifierByIndex(joystick, (ControllerElementType)0, 1);
		if (orCreateVJoyMap != null)
		{
			int elementMapCount = orCreateVJoyMap.elementMapCount;
			createdBindings += CreateVJoyBinding(orCreateVJoyMap, 1, (Pole)0, elementId, (ControllerElementType)0, (AxisRange)0);
			createdBindings += CreateVJoyBinding(orCreateVJoyMap, 0, (Pole)0, elementId2, (ControllerElementType)0, (AxisRange)0);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 0, 9, 64);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 1, 2);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 2, 16);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 3, 13);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 4, 23);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 5, 26, 17);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 6, 58);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 7, 71);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 8, 93);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 9, 94);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 10, 59);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap, joystick, 11, 31);
			if (orCreateVJoyMap.elementMapCount > elementMapCount)
			{
				createdMaps++;
			}
		}
		if (orCreateVJoyMap2 != null)
		{
			int elementMapCount2 = orCreateVJoyMap2.elementMapCount;
			createdBindings += CreateVJoyBinding(orCreateVJoyMap2, 35, (Pole)0, elementId, (ControllerElementType)0, (AxisRange)0);
			createdBindings += CreateVJoyBinding(orCreateVJoyMap2, 34, (Pole)0, elementId2, (ControllerElementType)0, (AxisRange)0);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap2, joystick, 0, 38);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap2, joystick, 2, 39);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap2, joystick, 4, 43);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap2, joystick, 5, 44);
			createdBindings += CreateVJoyButtonBindings(orCreateVJoyMap2, joystick, 6, 56);
			if (orCreateVJoyMap2.elementMapCount > elementMapCount2)
			{
				createdMaps++;
			}
		}
		player.controllers.maps.SetAllMapsEnabled(true, (Controller)(object)joystick);
		return HasUsableJoystickMap(player, joystick);
	}

	private static bool TryFindJoystickMapTemplate(out Player sourcePlayer, out Joystick sourceJoystick, out IList<ControllerMap> sourceMaps)
	{
		sourcePlayer = null;
		sourceJoystick = null;
		sourceMaps = null;
		if (!ReInput.isReady || ReInput.players == null)
		{
			return false;
		}
		for (int i = 0; i < ReInput.players.playerCount; i++)
		{
			Player player = ReInput.players.GetPlayer(i);
			if (player == null || player.controllers == null)
			{
				continue;
			}
			foreach (Joystick joystick in player.controllers.Joysticks)
			{
				if (joystick == null || IsVJoyJoystick(joystick))
				{
					continue;
				}
				IList<ControllerMap> maps = player.controllers.maps.GetMaps((Controller)(object)joystick);
				if (maps == null)
				{
					continue;
				}
				for (int j = 0; j < maps.Count; j++)
				{
					if (maps[j] != null && maps[j].elementMapCount > 0)
					{
						sourcePlayer = player;
						sourceJoystick = joystick;
						sourceMaps = maps;
						return true;
					}
				}
			}
		}
		return false;
	}

	private static int TranslateElementIdentifierByIndex(Joystick targetJoystick, ControllerElementType elementType, int elementIndex)
	{
		//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)
		if (targetJoystick == null || elementIndex < 0)
		{
			return -1;
		}
		int num = 0;
		foreach (Element element in ((Controller)targetJoystick).Elements)
		{
			if (element != null && element.type == elementType)
			{
				if (num == elementIndex && element.elementIdentifier != null)
				{
					return element.elementIdentifier.id;
				}
				num++;
			}
		}
		return -1;
	}

	private static bool EnsureVJoyMapForPlayer(Player player, Joystick joystick, string reason)
	{
		//IL_01d7: 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_0203: 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)
		if (player == null || joystick == null || !IsVJoyJoystick(joystick))
		{
			return false;
		}
		string text = player.id + ":" + ((Controller)joystick).id;
		if (HasUsableJoystickMap(player, joystick))
		{
			_installedVJoyMaps.Add(text);
			return true;
		}
		float unscaledTime = Time.unscaledTime;
		if (_nextVJoyMapAttemptAt.TryGetValue(text, out var value) && unscaledTime < value)
		{
			return false;
		}
		_nextVJoyMapAttemptAt[text] = unscaledTime + 2f;
		try
		{
			if (!TryFindJoystickMapTemplate(out var sourcePlayer, out var sourceJoystick, out var sourceMaps))
			{
				if (TryCreateStandaloneVJoyMaps(player, joystick, out var createdMaps, out var createdBindings))
				{
					_installedVJoyMaps.Add(text);
					Plugin.Log.LogInfo((object)$"[MP8][vJoy] Installed standalone map with {createdBindings} bindings in {createdMaps} map(s) for joystick id={((Controller)joystick).id} -> slot {player.id} ({reason})");
					return true;
				}
				if (_loggedVJoyDevices.Add(((Controller)joystick).id))
				{
					Plugin.Log.LogWarning((object)$"[MP8][vJoy] Standalone map creation failed for joystick id={((Controller)joystick).id}; axes or controller elements are missing");
				}
				return false;
			}
			int num = 0;
			int num2 = 0;
			for (int i = 0; i < sourceMaps.Count; i++)
			{
				ControllerMap val = sourceMaps[i];
				if (val == null || val.elementMapCount == 0)
				{
					continue;
				}
				player.controllers.maps.AddEmptyMap((ControllerType)2, ((Controller)joystick).id, val.categoryId, val.layoutId);
				ControllerMap map = player.controllers.maps.GetMap((ControllerType)2, ((Controller)joystick).id, val.categoryId, val.layoutId);
				if (map == null)
				{
					continue;
				}
				map.enabled = true;
				foreach (ActionElementMap allMap in val.AllMaps)
				{
					if (allMap != null)
					{
						int num3 = TranslateElementIdentifierByIndex(joystick, allMap.elementType, allMap.elementIndex);
						if (num3 >= 0 && map.CreateElementMap(allMap.actionId, allMap.axisContribution, num3, allMap.elementType, allMap.axisRange, allMap.invert))
						{
							num2++;
						}
					}
				}
				if (map.elementMapCount > 0)
				{
					num++;
				}
			}
			if (num > 0 && num2 > 0)
			{
				player.controllers.maps.SetAllMapsEnabled(true, (Controller)(object)joystick);
				_installedVJoyMaps.Add(text);
				Plugin.Log.LogInfo((object)$"[MP8][vJoy] Installed {num2} bindings in {num} map(s) for joystick id={((Controller)joystick).id} -> slot {player.id} from {((Controller)sourceJoystick).name} slot {sourcePlayer.id} ({reason})");
				return true;
			}
			Plugin.Log.LogWarning((object)$"[MP8][vJoy] Generic map creation produced no bindings for joystick id={((Controller)joystick).id} -> slot {player.id} ({reason})");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"[MP8][vJoy] Map creation failed for joystick id={((Controller)joystick).id} -> slot {player.id}: {ex.GetType().Name}: {ex.Message}");
		}
		return false;
	}

	private static int FindJoystickOwnerSlot(Joystick joystick)
	{
		if (joystick == null)
		{
			return -1;
		}
		for (int i = 0; i < 8; i++)
		{
			Player player = RewiredInputManager.GetPlayer(i);
			if (player != null && player.controllers != null && player.controllers.ContainsController((Controller)(object)joystick))
			{
				return i;
			}
		}
		return -1;
	}

	private static bool IsSlotExpectedToKeepJoystick(int slot, HashSet<int> activeGoatSlots)
	{
		if (slot <= 0 || slot >= 8)
		{
			return false;
		}
		if (activeGoatSlots != null && activeGoatSlots.Contains(slot))
		{
			return true;
		}
		if (_desiredExtraSlots.Contains(slot))
		{
			return true;
		}
		if (slot == 1 && PlayerFarming.playersCount > 1)
		{
			return true;
		}
		return false;
	}

	private static void AggressiveControllerOwnershipHeartbeat(string reason)
	{
		if (!CoopManager.CoopActive || (Object)(object)CoopManager.Instance == (Object)null || ReInput.controllers == null || CoopManager.Instance.IsSpawningOrRemovingPlayer || _removingPlayer)
		{
			return;
		}
		EnforceKeyboardOwnership();
		RefreshDesiredExtraSlotsFromActivePlayers();
		List<Joystick> list = new List<Joystick>(ReInput.controllers.Joysticks);
		if (list.Count == 0)
		{
			return;
		}
		HashSet<int> hashSet = new HashSet<int>();
		foreach (PlayerFarming player3 in PlayerFarming.players)
		{
			if (!((Object)(object)player3 == (Object)null) && !player3.isLamb && ((Component)player3).gameObject.activeSelf && player3.playerID >= 1 && player3.playerID < 8)
			{
				hashSet.Add(player3.playerID);
			}
		}
		List<int> list2 = new List<int>();
		for (int i = 1; i < 8; i++)
		{
			if (IsSlotExpectedToKeepJoystick(i, hashSet) && !SlotHasJoystick(i))
			{
				list2.Add(i);
			}
		}
		if (list2.Count == 0)
		{
			return;
		}
		HashSet<int> hashSet2 = new HashSet<int>();
		bool flag = false;
		foreach (int item in list2)
		{
			Player player = RewiredInputManager.GetPlayer(item);
			if (player == null || player.controllers == null)
			{
				continue;
			}
			Joystick val = null;
			int num = -1;
			Joystick val2 = null;
			foreach (Joystick item2 in list)
			{
				if (item2 != null && !hashSet2.Contains(((Controller)item2).id))
				{
					int num2 = FindJoystickOwnerSlot(item2);
					if (num2 < 0 || !IsSlotExpectedToKeepJoystick(num2, hashSet))
					{
						val = item2;
						num = num2;
						break;
					}
					if (num2 == 0 && val2 == null)
					{
						val2 = item2;
					}
				}
			}
			if (val == null && val2 != null)
			{
				val = val2;
				num = 0;
			}
			if (val == null)
			{
				continue;
			}
			for (int j = 0; j < 8; j++)
			{
				Player player2 = RewiredInputManager.GetPlayer(j);
				if (player2 != null && player2.controllers != null)
				{
					player2.controllers.RemoveController((Controller)(object)val);
				}
			}
			player.controllers.AddController((Controller)(object)val, true);
			EnsureVJoyMapForPlayer(player, val, "ControllerHeal");
			hashSet2.Add(((Controller)val).id);
			if (item >= 2)
			{
				MarkDesiredExtraSlot(item, desired: true);
			}
			flag = true;
			Plugin.Log.LogInfo((object)$"[MP] Controller-heal ({reason}): joystick id={((Controller)val).id} owner={num} -> slot {item}");
		}
		if (flag)
		{
			try
			{
				CoopManager.RefreshCoopPlayerRewired();
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[MP] Controller-heal refresh failed (" + reason + "): " + ex.GetType().Name + ": " + ex.Message));
			}
			TryAutoRespawnMissingExtraSlots("ControllerHeal:" + reason);
			StopOrphanedRumbleHeartbeat("ControllerHeal:" + reason);
		}
	}

	private static void TryStopAllRumble(string reason)
	{
		try
		{
			MMVibrate.StopRumble((PlayerFarming)null);
			Plugin.Log.LogInfo((object)("[MP] Forced rumble stop (" + reason + ")"));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Failed to stop rumble (" + reason + "): " + ex.GetType().Name + ": " + ex.Message));
		}
	}

	private static void StopOrphanedRumbleHeartbeat(string reason)
	{
		if (Time.unscaledTime < _nextRumbleCleanupAt)
		{
			return;
		}
		_nextRumbleCleanupAt = Time.unscaledTime + 0.5f;
		if (ReInput.controllers == null)
		{
			return;
		}
		bool flag = false;
		for (int i = 1; i < 8; i++)
		{
			bool num = SlotHasJoystick(i);
			bool flag2 = (Object)(object)FindActivePlayerBySlot(i) != (Object)null;
			bool flag3 = _pendingSpawnSlots.Contains(i);
			if (num && !flag2 && !flag3)
			{
				flag = true;
				break;
			}
		}
		if (flag)
		{
			TryStopAllRumble(reason + ":orphan-slot");
		}
	}

	private static List<int> GetMissingSpawnableExtraSlots()
	{
		List<int> list = new List<int>();
		for (int i = 2; i < 8; i++)
		{
			if (_pendingSpawnSlots.Contains(i))
			{
				continue;
			}
			if ((Object)(object)FindActivePlayerBySlot(i) != (Object)null)
			{
				_warnedOrphanSlotObjects.Remove(i);
				continue;
			}
			if (CoopManager.AllPlayerGameObjects != null && i < CoopManager.AllPlayerGameObjects.Length && (Object)(object)CoopManager.AllPlayerGameObjects[i] != (Object)null && CoopManager.AllPlayerGameObjects[i].activeInHierarchy)
			{
				if ((Object)(object)CoopManager.Instance != (Object)null && CoopManager.Instance.IsSpawningOrRemovingPlayer)
				{
					continue;
				}
				if (_warnedOrphanSlotObjects.Add(i))
				{
					Plugin.Log.LogWarning((object)$"[MP] Slot {i} has active player object but no active PlayerFarming; treating as missing.");
				}
			}
			else
			{
				_warnedOrphanSlotObjects.Remove(i);
			}
			Player player = RewiredInputManager.GetPlayer(i);
			if ((player != null && player.controllers != null && player.controllers.Joysticks != null && player.controllers.Joysticks.Count > 0) || _desiredExtraSlots.Contains(i))
			{
				list.Add(i);
			}
		}
		return list;
	}

	private static bool IsReviveOrCutsceneFlowActive()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		//IL_0017: 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_007c: 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_0082: Unknown result type (might be due to invalid IL or missing references)
		//IL_0085: Invalid comparison between Unknown and I4
		//IL_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Invalid comparison between Unknown and I4
		//IL_008c: Unknown result type (might be due to invalid IL or missing references)
		//IL_008f: Invalid comparison between Unknown and I4
		//IL_0091: Unknown result type (might be due to invalid IL or missing references)
		//IL_0094: Invalid comparison between Unknown and I4
		if ((Object)UIDeathScreenOverlayController.Instance != (Object)null && (Object)(object)((Component)UIDeathScreenOverlayController.Instance).gameObject != (Object)null && ((Component)UIDeathScreenOverlayController.Instance).gameObject.activeInHierarchy)
		{
			return true;
		}
		if (MMConversation.isPlaying || LetterBox.IsPlaying)
		{
			return true;
		}
		if ((Object)(object)PlayerFarming.Instance == (Object)null || (Object)(object)PlayerFarming.Instance.state == (Object)null)
		{
			return true;
		}
		State cURRENT_STATE = PlayerFarming.Instance.state.CURRENT_STATE;
		if ((int)cURRENT_STATE == 13 || (int)cURRENT_STATE == 49 || (int)cURRENT_STATE == 24 || (int)cURRENT_STATE == 16)
		{
			return true;
		}
		string name = ((Object)PlayerFarming.Instance).name;
		if (!string.IsNullOrEmpty(name) && name.IndexOf("TempPlayer", StringComparison.OrdinalIgnoreCase) >= 0)
		{
			return true;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null))
			{
				if (IsFalseKnockedOutState(player))
				{
					ClearFalseKnockedOutState(player, "IsReviveOrCutsceneFlowActive");
				}
				else if (player.IsKnockedOut || IsLikelyReviveDesyncState(player))
				{
					return true;
				}
			}
		}
		return false;
	}

	private static IEnumerator DelayedRespawnAfterReviveRoutine(string reason)
	{
		try
		{
			if ((Object)(object)CoopManager.Instance == (Object)null)
			{
				yield break;
			}
			bool allowDuringReviveFlow = IsWakeAllRespawnReason(reason) || IsSacrificialReviveFlowReason(reason);
			float num = (allowDuringReviveFlow ? 0.05f : 0.35f);
			yield return (object)new WaitForSeconds(num);
			float deadline = Time.unscaledTime + 15f;
			int attempts = 0;
			while (Time.unscaledTime < deadline)
			{
				if ((Object)(object)CoopManager.Instance == (Object)null || !CoopManager.CoopActive)
				{
					yield break;
				}
				_nextAutoRespawnAttemptAt = 0f;
				TryAutoRespawnMissingExtraSlots($"{reason}.poll{attempts}");
				if ((reason.StartsWith("WakeAllKnockedOutPlayers", StringComparison.Ordinal) || IsSacrificialReviveFlowReason(reason)) && AnyNonLambPlayerNeedsWakeRecovery())
				{
					EnsureAllPlayersAwake(reason + ".DelayedRespawnAfterReviveRoutine");
					EnsureAllExtraPlayersUnlocked(reason + ".DelayedRespawnAfterReviveRoutine");
					QueuePostReviveHardResetForAll(reason + ".DelayedRespawnAfterReviveRoutine");
				}
				PrunePendingSpawnSlots();
				List<int> missingSpawnableExtraSlots = GetMissingSpawnableExtraSlots();
				bool flag = _pendingSpawnSlots.Count > 0;
				bool isSpawningOrRemovingPlayer = CoopManager.Instance.IsSpawningOrRemovingPlayer;
				bool flag2 = IsReviveOrCutsceneFlowActive();
				if (missingSpawnableExtraSlots.Count == 0 && !flag && !isSpawningOrRemovingPlayer && (!flag2 || allowDuringReviveFlow))
				{
					if (attempts > 0)
					{
						Plugin.Log.LogInfo((object)$"[MP] Delayed revive respawn settled after {attempts} poll(s) ({reason})");
					}
					break;
				}
				if (attempts % 8 == 0)
				{
					Plugin.Log.LogInfo((object)$"[MP] Delayed revive respawn polling ({reason}): missing={missingSpawnableExtraSlots.Count}, pending={_pendingSpawnSlots.Count}, blocked={flag2}, spawning={isSpawningOrRemovingPlayer}");
				}
				attempts++;
				yield return (object)new WaitForSeconds(0.2f);
			}
			_nextAutoRespawnAttemptAt = 0f;
			TryAutoRespawnMissingExtraSlots(reason + ".final");
			if (!reason.StartsWith("WakeAllKnockedOutPlayers", StringComparison.Ordinal) && !IsSacrificialReviveFlowReason(reason))
			{
				yield break;
			}
			if (AnyNonLambPlayerNeedsWakeRecovery())
			{
				EnsureAllPlayersAwake(reason + ".DelayedRespawnAfterReviveRoutine.final");
				EnsureAllExtraPlayersUnlocked(reason + ".DelayedRespawnAfterReviveRoutine.final");
				QueuePostReviveHardResetForAll(reason + ".DelayedRespawnAfterReviveRoutine.final");
			}
			for (int i = 0; i < 8; i++)
			{
				if ((Object)(object)CoopManager.Instance == (Object)null)
				{
					break;
				}
				if (!CoopManager.CoopActive)
				{
					break;
				}
				yield return (object)new WaitForSeconds(0.25f);
				if (AnyNonLambPlayerNeedsWakeRecovery())
				{
					EnsureAllPlayersAwake(reason + ".DelayedRespawnAfterReviveRoutine.stabilize");
					EnsureAllExtraPlayersUnlocked(reason + ".DelayedRespawnAfterReviveRoutine.stabilize");
					QueuePostReviveHardResetForAll(reason + ".DelayedRespawnAfterReviveRoutine.stabilize");
				}
			}
		}
		finally
		{
			_delayedRespawnAfterReviveQueued = false;
		}
	}

	private static void EnsureAllPlayersAwake(string reason)
	{
		if (PlayerFarming.players == null)
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !player.isLamb && ((Component)player).gameObject.activeInHierarchy)
			{
				EnsurePlayerAwakeAfterRespawn(player, reason);
			}
		}
	}

	private static void QueueDelayedRespawnAfterRevive(string reason)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		if (!((Object)(object)CoopManager.Instance == (Object)null) && !_delayedRespawnAfterReviveQueued)
		{
			if (GameManager.IsDungeon(PlayerFarming.Location) && Time.unscaledTime < _dungeonIntroProtectUntil)
			{
				Plugin.Log.LogInfo((object)("[MP] Suppressed delayed respawn during dungeon intro window (" + reason + ")"));
				return;
			}
			_delayedRespawnAfterReviveQueued = true;
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(DelayedRespawnAfterReviveRoutine(reason));
		}
	}

	private static bool IsDungeonAutoRespawnReasonAllowed(string reason)
	{
		if (string.IsNullOrEmpty(reason))
		{
			return false;
		}
		if (!reason.StartsWith("WakeAllKnockedOutPlayers", StringComparison.Ordinal) && !reason.StartsWith("WakeKnockedOutPlayer", StringComparison.Ordinal) && !reason.StartsWith("ResetMainPlayerOnConversationEnd", StringComparison.Ordinal) && !reason.StartsWith("CoopManager.Start", StringComparison.Ordinal))
		{
			return reason.StartsWith("LambHeartbeat", StringComparison.Ordinal);
		}
		return true;
	}

	private static bool IsWakeAllRespawnReason(string reason)
	{
		if (!string.IsNullOrEmpty(reason))
		{
			return reason.IndexOf("WakeAllKnockedOutPlayers", StringComparison.Ordinal) >= 0;
		}
		return false;
	}

	private static bool IsWakeAllWithHealthRespawnReason(string reason)
	{
		if (!string.IsNullOrEmpty(reason))
		{
			return reason.IndexOf("WakeAllKnockedOutPlayersWithHealth", StringComparison.Ordinal) >= 0;
		}
		return false;
	}

	private static bool IsSacrificialReviveFlowReason(string reason)
	{
		if (IsWakeAllWithHealthRespawnReason(reason))
		{
			return true;
		}
		try
		{
			return Time.unscaledTime <= _sacrificialReviveWindowUntil;
		}
		catch
		{
			return false;
		}
	}

	private static void OpenSacrificialReviveWindow(string reason)
	{
		try
		{
			float num = Time.unscaledTime + 7f;
			if (num > _sacrificialReviveWindowUntil)
			{
				_sacrificialReviveWindowUntil = num;
			}
			Plugin.Log.LogInfo((object)$"[MP] Opened sacrificial revive window ({reason}) until t={_sacrificialReviveWindowUntil:0.00}");
		}
		catch
		{
			_sacrificialReviveWindowUntil = 7f;
		}
	}

	public static void CoopManager_WakeAllKnockedOutPlayers_Postfix()
	{
		QueueDelayedRespawnAfterRevive("WakeAllKnockedOutPlayers");
	}

	public static void CoopManager_WakeAllKnockedOutPlayersWithHealth_Postfix(float wakeUpHealth)
	{
		if (wakeUpHealth > 0f)
		{
			_lastObservedWakeHealth = wakeUpHealth;
			_lastObservedSacrificialWakeHealth = wakeUpHealth;
		}
		OpenSacrificialReviveWindow("WakeAllKnockedOutPlayersWithHealth");
		QueueDelayedRespawnAfterRevive("WakeAllKnockedOutPlayersWithHealth");
	}

	public static void CoopManager_WakeKnockedOutPlayer_Postfix(PlayerFarming playerFarming, float wakeUpHealth, PlayerFarming playerWhoIsReviving)
	{
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		if (wakeUpHealth > 0f)
		{
			_lastObservedWakeHealth = wakeUpHealth;
		}
		if ((Object)(object)playerFarming == (Object)null || (Object)(object)((Component)playerFarming).gameObject == (Object)null || !((Component)playerFarming).gameObject.activeInHierarchy || (!NeedsWakeRecovery(playerFarming) && !IsFalseKnockedOutState(playerFarming)))
		{
			return;
		}
		float num = 0f;
		try
		{
			if ((Object)(object)playerFarming.health != (Object)null)
			{
				num = ((Health)playerFarming.health).CurrentHP;
			}
		}
		catch
		{
		}
		float num2 = Mathf.Max(wakeUpHealth, num);
		bool flag = (Object)(object)playerWhoIsReviving == (Object)null;
		bool flag2 = false;
		try
		{
			flag2 = GameManager.IsDungeon(PlayerFarming.Location) && IsReviveOrCutsceneFlowActive();
		}
		catch
		{
		}
		bool flag3 = flag && flag2;
		if (num2 > 2.01f || flag3)
		{
			float num3 = num2;
			if (flag3 && num3 < 6f)
			{
				num3 = 6f;
			}
			_lastObservedSacrificialWakeHealth = num3;
			OpenSacrificialReviveWindow(string.Format("WakeKnockedOutPlayer(hp={0:0.##},reviver={1})", num3, ((Object)(object)playerWhoIsReviving != (Object)null) ? playerWhoIsReviving.playerID.ToString() : "none"));
			Plugin.Log.LogInfo((object)string.Format("[MP] Detected sacrificial/system WakeKnockedOutPlayer health={0:0.##} (raw={1:0.##}, reviver={2}, cutsceneFlow={3}); treating as sacrificial revive flow.", num3, num2, ((Object)(object)playerWhoIsReviving != (Object)null) ? playerWhoIsReviving.playerID.ToString() : "none", flag2));
		}
		ForceReviveVisualState(playerFarming, "WakeKnockedOutPlayer.Postfix");
		if (!playerFarming.isLamb && playerFarming.playerID >= 1 && playerFarming.playerID < 8)
		{
			MarkDesiredExtraSlot(playerFarming.playerID, desired: true);
			QueuePostReviveHardReset(playerFarming, "WakeKnockedOutPlayer.Postfix");
			_nextAutoRespawnAttemptAt = 0f;
			TryAutoRespawnMissingExtraSlots("WakeKnockedOutPlayer");
			QueueDelayedRespawnAfterRevive("WakeKnockedOutPlayer");
		}
	}

	public static void CoopManager_ResetMainPlayerOnConversationEnd_Postfix(bool SetPlayerToIdle, bool ShowHUD)
	{
		QueueDelayedRespawnAfterRevive("ResetMainPlayerOnConversationEnd");
	}

	private static void TryAutoRespawnMissingExtraSlots(string reason)
	{
		//IL_0106: 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)
		if ((Object)(object)CoopManager.Instance == (Object)null || !CoopManager.CoopActive || _autoRespawnRoutineRunning || (_startupExtraRespawnDepth > 0 && (string.IsNullOrEmpty(reason) || !reason.StartsWith("CoopManager.Start", StringComparison.Ordinal))))
		{
			return;
		}
		PrunePendingSpawnSlots();
		if (_pendingSpawnSlots.Count > 0)
		{
			if (Time.unscaledTime >= _nextPendingBlockLogAt)
			{
				_nextPendingBlockLogAt = Time.unscaledTime + 3f;
				Plugin.Log.LogInfo((object)("[MP] Auto-respawn blocked by pending slots (" + reason + "): [" + string.Join(",", _pendingSpawnSlots) + "]"));
			}
		}
		else
		{
			if (CoopManager.Instance.IsSpawningOrRemovingPlayer || CoopManager.Instance.LockedAddRemoveCoopPlayer || Time.unscaledTime < _nextAutoRespawnAttemptAt || (Object)(object)PlayerFarming.Instance == (Object)null || (Object)(object)((Component)PlayerFarming.Instance).gameObject == (Object)null || !((Component)PlayerFarming.Instance).gameObject.activeInHierarchy || (GameManager.IsDungeon(PlayerFarming.Location) && Time.unscaledTime < _dungeonIntroProtectUntil && (string.IsNullOrEmpty(reason) || !reason.StartsWith("CoopManager.Start", StringComparison.Ordinal))) || (GameManager.IsDungeon(PlayerFarming.Location) && !IsDungeonAutoRespawnReasonAllowed(reason)))
			{
				return;
			}
			bool flag = IsWakeAllRespawnReason(reason) || IsSacrificialReviveFlowReason(reason);
			if ((!IsReviveOrCutsceneFlowActive() || flag) && PlayerFarming.playersCount >= 1)
			{
				List<int> missingSpawnableExtraSlots = GetMissingSpawnableExtraSlots();
				if (missingSpawnableExtraSlots.Count != 0)
				{
					_nextAutoRespawnAttemptAt = Time.unscaledTime + 1f;
					((MonoBehaviour)CoopManager.Instance).StartCoroutine(AutoRespawnMissingSlotsRoutine(missingSpawnableExtraSlots, reason));
				}
			}
		}
	}

	private static IEnumerator AutoRespawnMissingSlotsRoutine(List<int> missingSlots, string reason)
	{
		_autoRespawnRoutineRunning = true;
		bool allowDuringReviveFlow = IsWakeAllRespawnReason(reason) || IsSacrificialReviveFlowReason(reason);
		float interSpawnDelay = (allowDuringReviveFlow ? 0.15f : 0.75f);
		yield return (object)new WaitForSeconds(0.35f);
		foreach (int slot in missingSlots)
		{
			if ((Object)(object)CoopManager.Instance == (Object)null || !CoopManager.CoopActive)
			{
				break;
			}
			if (_pendingSpawnSlots.Contains(slot) || (Object)(object)FindActivePlayerBySlot(slot) != (Object)null)
			{
				continue;
			}
			Player player = RewiredInputManager.GetPlayer(slot);
			if (((player == null || player.controllers == null || player.controllers.Joysticks == null || player.controllers.Joysticks.Count <= 0) && !_desiredExtraSlots.Contains(slot)) || (Object)(object)PlayerFarming.Instance == (Object)null || (Object)(object)PlayerFarming.Instance.state == (Object)null || (IsReviveOrCutsceneFlowActive() && !allowDuringReviveFlow))
			{
				continue;
			}
			float spawnWait = 0f;
			while (CoopManager.Instance.IsSpawningOrRemovingPlayer && spawnWait < 10f)
			{
				yield return (object)new WaitForSeconds(0.1f);
				spawnWait += 0.1f;
			}
			if (!_pendingSpawnSlots.Contains(slot) && !((Object)(object)FindActivePlayerBySlot(slot) != (Object)null))
			{
				Plugin.Log.LogInfo((object)$"[MP] Auto-respawn ({reason}): spawning missing slot {slot}");
				_pendingSpawnSlots.Add(slot);
				bool flag = false;
				Plugin.Log.LogInfo((object)$"[MP] Auto-respawn spawn mode slot {slot}: animated={flag}");
				_pendingSpawnUseAnimation[slot] = flag;
				try
				{
					CoopManager.Instance.SpawnCoopPlayer(slot, flag, -1f);
				}
				catch (Exception ex)
				{
					_pendingSpawnSlots.Remove(slot);
					_pendingSpawnUseAnimation.Remove(slot);
					Plugin.Log.LogWarning((object)$"[MP] Auto-respawn failed for slot {slot}: {ex.GetType().Name}: {ex.Message}");
				}
				yield return (object)new WaitForSeconds(interSpawnDelay);
			}
		}
		_autoRespawnRoutineRunning = false;
		_nextAutoRespawnAttemptAt = Time.unscaledTime + 1.5f;
	}

	public static void PlayerFarming_Update_Camera(PlayerFarming __instance)
	{
		//IL_002d: 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_02b3: 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_0405: Unknown result type (might be due to invalid IL or missing references)
		//IL_0417: 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)
		//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c7: Unknown result type (might be due to invalid IL or missing references)
		//IL_04d9: Unknown result type (might be due to invalid IL or missing references)
		if (__instance.isLamb)
		{
			CoopEmergencyEscape.Tick();
			CoopConversationSession.Tick();
		}
		if (TransitionVotePlayerState.IsHidden(__instance))
		{
			return;
		}
		if (__instance.isLamb)
		{
			if (CoopManager.CoopActive && GameManager.IsDungeon(PlayerFarming.Location))
			{
				LogDungeonRoomTypeIfChanged();
				TryQueueDungeonRoomStabilize("LambHeartbeat");
			}
			if (CoopManager.CoopActive && Time.unscaledTime >= _nextControllerHealHeartbeatAt)
			{
				_nextControllerHealHeartbeatAt = Time.unscaledTime + 0.5f;
				ClearFalseKnockedOutStatesForAll("LambHeartbeat");
				AggressiveControllerOwnershipHeartbeat("LambHeartbeat");
			}
			if (CoopManager.CoopActive && Time.unscaledTime >= _nextPostReviveRaceGuardHeartbeatAt)
			{
				_nextPostReviveRaceGuardHeartbeatAt = Time.unscaledTime + 0.18f;
				ProcessPostReviveRaceGuards("LambHeartbeat");
			}
			if (CoopManager.CoopActive && Time.unscaledTime >= _nextAutoRespawnHeartbeatAt)
			{
				_nextAutoRespawnHeartbeatAt = Time.unscaledTime + 1f;
				RefreshDesiredExtraSlotsFromActivePlayers();
				TryAutoRespawnMissingExtraSlots("LambHeartbeat");
			}
			return;
		}
		int playerID = __instance.playerID;
		if (playerID < 2 || !((Component)__instance).gameObject.activeSelf || (Object)(object)GameManager.GetInstance() == (Object)null)
		{
			return;
		}
		if (CoopManager.CoopActive)
		{
			if (!_nextExtraFalseDownedWatchdogAt.TryGetValue(playerID, out var value))
			{
				value = 0f;
			}
			if (Time.unscaledTime >= value)
			{
				if (IsFalseDownedVisualStateForExtra(__instance))
				{
					_nextExtraFalseDownedWatchdogAt[playerID] = Time.unscaledTime + 0.75f;
					ForceReviveVisualState(__instance, $"PlayerUpdate.Watchdog(slot={playerID})");
					SnapSpawnedPlayerToAwakeIdle(__instance, $"PlayerUpdate.Watchdog(slot={playerID})");
					QueuePostReviveHardReset(__instance, $"PlayerUpdate.Watchdog(slot={playerID})");
					Plugin.Log.LogWarning((object)$"[MP] Watchdog cleared false downed state for playerID={playerID} (HP={((Health)__instance.health).CurrentHP:0.00})");
				}
				else
				{
					_nextExtraFalseDownedWatchdogAt[playerID] = Time.unscaledTime + 0.2f;
				}
			}
		}
		if (!MMTransition.IsPlaying && !LetterBox.IsPlaying && !MMConversation.isPlaying && !GameManager.GetInstance().CameraContains(__instance.CameraBone))
		{
			GameManager.GetInstance().AddToCamera(__instance.CameraBone, 0.1f);
		}
		if (playerID >= Plugin.IndicatorColors.Length)
		{
			return;
		}
		Color val = Plugin.IndicatorColors[playerID];
		string text = (playerID + 1).ToString();
		HUD_Hearts val2 = __instance.hudHearts;
		if ((Object)(object)val2 != (Object)null && (Object)(object)val2.playerFarming != (Object)(object)__instance)
		{
			val2 = null;
		}
		if ((Object)(object)val2 != (Object)null)
		{
			SyncFaithAmmoForOwner(__instance, val2, "PlayerUpdateSync", forceReinit: false);
		}
		ApplyIndicator(__instance, playerID);
		SpriteRenderer val3 = FindHaloSR(__instance, playerID);
		if ((Object)(object)val3 != (Object)null)
		{
			Sprite haloSprite = GetHaloSprite(playerID);
			if ((Object)(object)haloSprite != (Object)null && (Object)(object)val3.sprite != (Object)(object)haloSprite)
			{
				val3.sprite = haloSprite;
			}
			val3.color = Color.white;
		}
		if ((Object)(object)val2 != (Object)null && (Object)(object)val2.coopIndicatorIcon != (Object)null)
		{
			CoopIndicatorIcon coopIndicatorIcon = val2.coopIndicatorIcon;
			if ((Object)(object)coopIndicatorIcon.GoatImage != (Object)null)
			{
				((Graphic)coopIndicatorIcon.GoatImage).color = val;
			}
			if ((Object)(object)coopIndicatorIcon.UserName != (Object)null)
			{
				coopIndicatorIcon.UserName.text = text;
			}
		}
		if (playerID < Plugin.GoatColors.Length && !CustomSpineCompatibility.ShouldPreserveCustomSpineColor(__instance) && (Object)(object)__instance.Spine != (Object)null && ((SkeletonRenderer)__instance.Spine).skeleton != null)
		{
			((SkeletonRenderer)__instance.Spine).skeleton.R = Plugin.GoatColors[playerID].r;
			((SkeletonRenderer)__instance.Spine).skeleton.G = Plugin.GoatColors[playerID].g;
			((SkeletonRenderer)__instance.Spine).skeleton.B = Plugin.GoatColors[playerID].b;
			((SkeletonRenderer)__instance.Spine).skeleton.A = Plugin.GoatColors[playerID].a;
		}
		if ((Object)(object)__instance.CoopIndicatorGoat != (Object)null)
		{
			SkeletonGraphic[] componentsInChildren = __instance.CoopIndicatorGoat.GetComponentsInChildren<SkeletonGraphic>(true);
			foreach (SkeletonGraphic val4 in componentsInChildren)
			{
				if (val4.Skeleton != null)
				{
					val4.Skeleton.R = val.r;
					val4.Skeleton.G = val.g;
					val4.Skeleton.B = val.b;
				}
			}
		}
		if (!((Object)(object)val2 != (Object)null) || !((Object)(object)val2.faithAmmo != (Object)null))
		{
			return;
		}
		Transform[] componentsInChildren2 = ((Component)val2.faithAmmo).GetComponentsInChildren<Transform>(true);
		foreach (Transform val5 in componentsInChildren2)
		{
			if (!((Object)((Component)val5).gameObject).name.StartsWith("CoopIndicatorIcon"))
			{
				continue;
			}
			SkeletonGraphic[] componentsInChildren = ((Component)val5).GetComponentsInChildren<SkeletonGraphic>(true);
			foreach (SkeletonGraphic val6 in componentsInChildren)
			{
				if (val6.Skeleton != null)
				{
					val6.Skeleton.R = val.r;
					val6.Skeleton.G = val.g;
					val6.Skeleton.B = val.b;
				}
			}
		}
	}

	private static void EnforceKeyboardOwnership()
	{
		Keyboard keyboard = ReInput.controllers.Keyboard;
		Mouse mouse = ReInput.controllers.Mouse;
		for (int i = 1; i < 8; i++)
		{
			Player player = RewiredInputManager.GetPlayer(i);
			if (player != null)
			{
				if (keyboard != null)
				{
					player.controllers.RemoveController((Controller)(object)keyboard);
				}
				if (mouse != null)
				{
					player.controllers.RemoveController((Controller)(object)mouse);
				}
				player.controllers.hasKeyboard = false;
				player.controllers.hasMouse = false;
			}
		}
		Player player2 = RewiredInputManager.GetPlayer(0);
		if (player2 != null)
		{
			if (keyboard != null && !player2.controllers.ContainsController((Controller)(object)keyboard))
			{
				player2.controllers.AddController((Controller)(object)keyboard, true);
			}
			if (mouse != null && !player2.controllers.ContainsController((Controller)(object)mouse))
			{
				player2.controllers.AddController((Controller)(object)mouse, true);
			}
			player2.controllers.hasKeyboard = true;
			player2.controllers.hasMouse = true;
		}
	}

	private static bool ShouldAnimateIndicatorOnDamage(CoopIndicatorIcon icon)
	{
		if ((Object)(object)icon == (Object)null)
		{
			return false;
		}
		if (_coopIndicatorAnimateOnDamagedField == null)
		{
			return true;
		}
		try
		{
			object value = _coopIndicatorAnimateOnDamagedField.GetValue(icon);
			if (value is bool)
			{
				return (bool)value;
			}
		}
		catch
		{
		}
		return true;
	}

	private static CoopIndicatorIcon ResolveCanonicalIndicatorIcon(PlayerFarming owner)
	{
		if ((Object)(object)owner == (Object)null)
		{
			return null;
		}
		if ((Object)(object)owner.hudHearts != (Object)null && (Object)(object)owner.hudHearts.coopIndicatorIcon != (Object)null)
		{
			return owner.hudHearts.coopIndicatorIcon;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !((Object)(object)player != (Object)(object)owner) && (Object)(object)player.hudHearts != (Object)null && (Object)(object)player.hudHearts.coopIndicatorIcon != (Object)null)
			{
				return player.hudHearts.coopIndicatorIcon;
			}
		}
		return null;
	}

	private static void AnimateIndicatorDamageSingle(CoopIndicatorIcon icon)
	{
		//IL_0086: 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_00ef: 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_012c: 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)
		if ((Object)(object)icon == (Object)null || !ShouldAnimateIndicatorOnDamage(icon))
		{
			return;
		}
		try
		{
			ShortcutExtensions.DOKill((Component)(object)((Component)icon).transform, false);
		}
		catch
		{
		}
		if (icon.isLambIcon)
		{
			if ((Object)(object)icon.LambImage != (Object)null)
			{
				try
				{
					ShortcutExtensions.DOKill((Component)(object)icon.LambImage, false);
				}
				catch
				{
				}
				((Graphic)icon.LambImage).color = Color.red;
				DOTween.To((DOGetter<Color>)(() => ((Graphic)icon.LambImage).color), (DOSetter<Color>)delegate(Color c)
				{
					//IL_000b: Unknown result type (might be due to invalid IL or missing references)
					((Graphic)icon.LambImage).color = c;
				}, Color.white, 0.5f);
			}
		}
		else if ((Object)(object)icon.GoatImage != (Object)null)
		{
			try
			{
				ShortcutExtensions.DOKill((Component)(object)icon.GoatImage, false);
			}
			catch
			{
			}
			((Graphic)icon.GoatImage).color = Color.red;
			DOTween.To((DOGetter<Color>)(() => ((Graphic)icon.GoatImage).color), (DOSetter<Color>)delegate(Color c)
			{
				//IL_000b: Unknown result type (might be due to invalid IL or missing references)
				((Graphic)icon.GoatImage).color = c;
			}, Color.white, 0.5f);
		}
		((Component)icon).transform.localScale = Vector3.one * 1.5f;
		Tween val = (Tween)(object)ShortcutExtensions.DOScale(((Component)icon).transform, Vector3.one, 0.25f);
		if (val != null)
		{
			TweenSettingsExtensions.SetEase<Tween>(val, (Ease)27);
			TweenSettingsExtensions.SetUpdate<Tween>(val, true);
		}
	}

	public static bool CoopIndicatorIcon_AnimateDamageOnIcons_Prefix(PlayerFarming playerFarming)
	{
		if ((Object)(object)playerFarming == (Object)null)
		{
			return true;
		}
		CoopIndicatorIcon val = ResolveCanonicalIndicatorIcon(playerFarming);
		if ((Object)(object)val == (Object)null)
		{
			int playerID = playerFarming.playerID;
			if (_missingDamageIconLogs.Add(playerID))
			{
				Plugin.Log.LogWarning((object)$"[MP] Damage icon unresolved for playerID={playerID}; suppressing shared bounce fallback");
			}
			if (!playerFarming.isLamb)
			{
				return false;
			}
			return true;
		}
		AnimateIndicatorDamageSingle(val);
		return false;
	}

	public static void SetUsername_Postfix(CoopIndicatorIcon __instance, int playernumber)
	{
		//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_00e5: Unknown result type (might be due to invalid IL or missing references)
		PlayerFarming val = null;
		if (PlayerFarming.players != null)
		{
			foreach (PlayerFarming player in PlayerFarming.players)
			{
				if ((Object)(object)player != (Object)null && (Object)(object)player.hudHearts != (Object)null && (Object)(object)player.hudHearts.coopIndicatorIcon == (Object)(object)__instance)
				{
					val = player;
					break;
				}
			}
		}
		if ((Object)(object)val == (Object)null)
		{
			if (playernumber >= 4 && (Object)(object)__instance != (Object)null && (Object)(object)__instance.UserName != (Object)null)
			{
				__instance.UserName.text = (playernumber + 1).ToString();
			}
			return;
		}
		int playerID = val.playerID;
		if (playerID >= 2 && playerID < Plugin.IndicatorColors.Length)
		{
			Color color = Plugin.IndicatorColors[playerID];
			string text = (playerID + 1).ToString();
			if ((Object)(object)__instance.GoatImage != (Object)null)
			{
				((Graphic)__instance.GoatImage).color = color;
			}
			if ((Object)(object)__instance.UserName != (Object)null)
			{
				__instance.UserName.text = text;
			}
			ApplyIndicator(val, playerID);
		}
	}

	public static bool SetUsername_Prefix(CoopIndicatorIcon __instance, int playernumber)
	{
		if (playernumber < 4)
		{
			return true;
		}
		try
		{
			SetUsername_Postfix(__instance, playernumber);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"[MP] Safe extra username fallback failed for index={playernumber}: {ex.Message}");
		}
		return false;
	}

	public static void RefreshPlayersCount_Postfix()
	{
		for (int i = 2; i < PlayerFarming.players.Count; i++)
		{
			PlayerFarming val = PlayerFarming.players[i];
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			int playerID = val.playerID;
			if (playerID >= 2)
			{
				if (playerID < Plugin.GoatColors.Length && !CustomSpineCompatibility.ShouldPreserveCustomSpineColor(val) && (Object)(object)val.Spine != (Object)null && ((SkeletonRenderer)val.Spine).skeleton != null)
				{
					((SkeletonRenderer)val.Spine).skeleton.R = Plugin.GoatColors[playerID].r;
					((SkeletonRenderer)val.Spine).skeleton.G = Plugin.GoatColors[playerID].g;
					((SkeletonRenderer)val.Spine).skeleton.B = Plugin.GoatColors[playerID].b;
					((SkeletonRenderer)val.Spine).skeleton.A = Plugin.GoatColors[playerID].a;
				}
				ApplyIndicator(val, playerID);
			}
		}
	}

	private static int ResolveTeleporterSlot(PlayerFarming playerFarming)
	{
		if ((Object)(object)playerFarming == (Object)null)
		{
			return -1;
		}
		int num = ((!playerFarming.isLamb) ? playerFarming.playerID : 0);
		if (num >= 0 && num < _teleporterOffsets.Length)
		{
			return num;
		}
		int num2 = PlayerFarming.players.IndexOf(playerFarming);
		if (num2 >= 0 && num2 < _teleporterOffsets.Length)
		{
			return num2;
		}
		return -1;
	}

	public static bool TeleporterAnimEvent_Prefix(Interaction_BaseTeleporter __instance, TrackEntry trackEntry, Event e)
	{
		if (e == null || e.Data == null)
		{
			return true;
		}
		EnsureTeleporterStencilCapacity(__instance);
		return true;
	}

	public static Exception TeleporterAnimEvent_Finalizer(Exception __exception, Interaction_BaseTeleporter __instance)
	{
		if (__exception == null)
		{
			return null;
		}
		if (!(__exception is IndexOutOfRangeException))
		{
			return __exception;
		}
		EnsureTeleporterStencilCapacity(__instance);
		RecoverTeleporterPlayerState("[MP] Recovered teleporter player state after stencil bounds exception");
		return null;
	}

	private static void EnsureTeleporterStencilCapacity(Interaction_BaseTeleporter teleporter)
	{
		if ((Object)(object)teleporter == (Object)null || _teleporterStencilField == null || !(_teleporterStencilField.GetValue(teleporter) is Material[] array) || array.Length == 0)
		{
			return;
		}
		int num = 8;
		if (PlayerFarming.players != null)
		{
			num = Mathf.Max(num, PlayerFarming.players.Count);
		}
		num = Mathf.Max(num, PlayerFarming.playersCount);
		if (array.Length < num)
		{
			Material[] array2 = (Material[])(object)new Material[num];
			for (int i = 0; i < array2.Length; i++)
			{
				array2[i] = array[Mathf.Clamp(i, 0, array.Length - 1)];
			}
			_teleporterStencilField.SetValue(teleporter, array2);
			Plugin.Log.LogInfo((object)$"[MP] Expanded PlayerStencilRT to {array2.Length} for teleporter safety");
		}
	}

	private static void RecoverTeleporterPlayerState(string reason)
	{
		if (PlayerFarming.players == null)
		{
			return;
		}
		for (int i = 0; i < PlayerFarming.players.Count; i++)
		{
			PlayerFarming val = PlayerFarming.players[i];
			if ((Object)(object)val == (Object)null)
			{
				continue;
			}
			try
			{
				if ((Object)(object)val.Spine != (Object)null)
				{
					((SkeletonRenderer)val.Spine).CustomMaterialOverride?.Clear();
					MeshRenderer component = ((Component)val.Spine).GetComponent<MeshRenderer>();
					if ((Object)(object)component != (Object)null)
					{
						((Renderer)component).enabled = true;
					}
				}
				if ((Object)(object)val.state != (Object)null)
				{
					val.state.LockStateChanges = false;
				}
			}
			catch
			{
			}
		}
		Plugin.Log.LogWarning((object)reason);
	}

	public static IEnumerable<CodeInstruction> FishingTwoPlayerCount_Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		//IL_0097: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a1: Expected O, but got Unknown
		//IL_00e2: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ec: Expected O, but got Unknown
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		MethodInfo methodInfo = AccessTools.PropertyGetter(typeof(List<PlayerFarming>), "Count");
		MethodInfo methodInfo2 = AccessTools.Method(typeof(Patches), "GetFishingParticipantCount", (Type[])null, (Type[])null);
		FieldInfo fieldInfo = AccessTools.Field(typeof(PlayerFarming), "playersCount");
		MethodInfo methodInfo3 = AccessTools.Method(typeof(Patches), "GetFishingParticipantStaticCount", (Type[])null, (Type[])null);
		for (int i = 0; i < list.Count; i++)
		{
			CodeInstruction val = list[i];
			if (methodInfo != null && methodInfo2 != null && CodeInstructionExtensions.Calls(val, methodInfo))
			{
				list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo2);
			}
			else if (fieldInfo != null && methodInfo3 != null && val.opcode == OpCodes.Ldsfld && object.Equals(val.operand, fieldInfo))
			{
				list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo3);
			}
		}
		return list;
	}

	public static int GetFishingParticipantCount(List<PlayerFarming> players)
	{
		if (players == null)
		{
			return 0;
		}
		return Mathf.Min(players.Count, 2);
	}

	public static int GetFishingParticipantStaticCount()
	{
		int num = PlayerFarming.playersCount;
		if (PlayerFarming.players != null)
		{
			num = Mathf.Max(num, PlayerFarming.players.Count);
		}
		return Mathf.Min(num, 2);
	}

	public static void FishingTwoPlayerScope_Prefix()
	{
		BeginTwoPlayerListScope("fishing");
	}

	public static Exception FishingTwoPlayerScope_Finalizer(Exception __exception)
	{
		EndTwoPlayerListScope();
		return FishingBounds_Finalizer(__exception);
	}

	public static void TempleAltarTwoPlayerScope_Prefix()
	{
		BeginTwoPlayerListScope("temple altar");
	}

	public static Exception TempleAltarTwoPlayerScope_Finalizer(Exception __exception)
	{
		EndTwoPlayerListScope();
		if (__exception == null)
		{
			return null;
		}
		Plugin.Log.LogWarning((object)("[MP] Suppressed temple altar presentation exception: " + __exception.GetType().Name + ": " + __exception.Message));
		return null;
	}

	private static void BeginTwoPlayerListScope(string reason)
	{
		PlayerListScopeState playerListScopeState = new PlayerListScopeState
		{
			SavedPlayersCount = PlayerFarming.playersCount
		};
		try
		{
			if (PlayerFarming.players != null && PlayerFarming.players.Count > 2)
			{
				playerListScopeState.HiddenPlayers = new List<PlayerFarming>();
				for (int i = 2; i < PlayerFarming.players.Count; i++)
				{
					playerListScopeState.HiddenPlayers.Add(PlayerFarming.players[i]);
				}
				PlayerFarming.players.RemoveRange(2, PlayerFarming.players.Count - 2);
			}
			if (PlayerFarming.playersCount > 2)
			{
				PlayerFarming.playersCount = 2;
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Failed to limit " + reason + " player list: " + ex.Message));
		}
		_twoPlayerListScopes.Push(playerListScopeState);
	}

	private static void EndTwoPlayerListScope()
	{
		if (_twoPlayerListScopes.Count <= 0)
		{
			return;
		}
		PlayerListScopeState playerListScopeState = _twoPlayerListScopes.Pop();
		try
		{
			if (PlayerFarming.players != null && playerListScopeState.HiddenPlayers != null)
			{
				for (int i = 0; i < playerListScopeState.HiddenPlayers.Count; i++)
				{
					PlayerFarming val = playerListScopeState.HiddenPlayers[i];
					if ((Object)(object)val != (Object)null && !PlayerFarming.players.Contains(val))
					{
						PlayerFarming.players.Add(val);
					}
				}
			}
			PlayerFarming.playersCount = playerListScopeState.SavedPlayersCount;
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Failed to restore scoped player list: " + ex.Message));
		}
	}

	public static bool InteractionFishing_BlockExtraPlayers_Prefix(StateMachine state)
	{
		PlayerFarming val = null;
		try
		{
			val = (((Object)(object)state != (Object)null) ? ((Component)state).GetComponent<PlayerFarming>() : null);
		}
		catch
		{
		}
		if ((Object)(object)val == (Object)null || PlayerFarming.players == null)
		{
			return true;
		}
		int num = PlayerFarming.players.IndexOf(val);
		if (num < 2 && val.playerID < 2)
		{
			return true;
		}
		Plugin.Log.LogInfo((object)$"[MP] Ignored fishing interaction for unsupported playerID={val.playerID} index={num}");
		return false;
	}

	public static Exception FishingBounds_Finalizer(Exception __exception)
	{
		if (__exception == null)
		{
			return null;
		}
		if (!(__exception is IndexOutOfRangeException))
		{
			return __exception;
		}
		if (!_loggedFishingBoundsSuppressed)
		{
			_loggedFishingBoundsSuppressed = true;
			Plugin.Log.LogWarning((object)"[MP] Suppressed fishing two-slot bounds exception");
		}
		return null;
	}

	public static void TempleAltar_OnInteract_Postfix(Interaction_TempleAltar __instance)
	{
		QueueTempleExtraRelease(__instance, "OnInteract");
	}

	public static bool TempleAltar_TryOnboardSin_Prefix(Interaction_TempleAltar __instance, Action callback, ref IEnumerator __result)
	{
		if (!ShouldUseCoopSafeSinOnboarding())
		{
			return true;
		}
		__result = TempleAltarCoopSafeSinOnboardingRoutine(__instance, callback);
		Plugin.Log.LogWarning((object)"[MP] Replaced temple sin onboarding cinematic for 3+ player coop");
		return false;
	}

	private unsafe static IEnumerator TempleAltarCoopSafeSinOnboardingRoutine(Interaction_TempleAltar altar, Action callback)
	{
		yield return (object)new WaitForEndOfFrame();
		while (MMConversation.isPlaying)
		{
			yield return null;
		}
		if (!WillTempleSinOnboardingRun())
		{
			callback?.Invoke();
			yield break;
		}
		try
		{
			Time.timeScale = 1f;
			SimulationManager.UnPause();
			MonoSingleton<UIManager>.Instance.ForceBlockPause = false;
			MonoSingleton<UIManager>.Instance.ForceBlockMenus = true;
			DataManager.Instance.PleasureRevealed = true;
			DataManager.Instance.PleasureDoctrineEnabled = true;
			Type val = (Type)(UpgradeSystem.GetUnlocked((Type)267) ? 267 : 268);
			UpgradeSystem.ClearCooldown(val);
			if (_templeAltarForceRitualField != null && (Object)(object)altar != (Object)null)
			{
				_templeAltarForceRitualField.SetValue(altar, val);
			}
			Plugin.Log.LogWarning((object)("[MP] Skipped fragile sin onboarding cinematic; opening forced ritual " + ((object)(*(Type*)(&val))/*cast due to .constrained prefix*/).ToString()));
			if ((Object)(object)altar != (Object)null)
			{
				altar.DoRitual();
			}
			else
			{
				callback?.Invoke();
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Coop-safe sin onboarding handoff failed: " + ex.GetType().Name + ": " + ex.Message));
			callback?.Invoke();
		}
	}

	private static bool ShouldUseCoopSafeSinOnboarding()
	{
		if (!CoopManager.CoopActive)
		{
			return false;
		}
		int num = PlayerFarming.playersCount;
		if (PlayerFarming.players != null)
		{
			num = Mathf.Max(num, PlayerFarming.players.Count);
		}
		return num > 2;
	}

	public static void TempleAltar_DoCancel_Postfix(Interaction_TempleAltar __instance)
	{
		QueueTempleCancelExitCheck(__instance, "DoCancel");
	}

	public static void TempleAltar_CancelCleanup_Postfix(Interaction_TempleAltar __instance)
	{
		QueueTemplePresentationNormalize(__instance, "DoCancel.cleanup");
	}

	public static Exception TempleAltar_Finalizer(Exception __exception, Interaction_TempleAltar __instance)
	{
		if (__exception == null)
		{
			return null;
		}
		RecoverTempleAltarExitState(__instance, "exception:" + __exception.GetType().Name);
		Plugin.Log.LogWarning((object)("[MP] Suppressed temple altar exception: " + __exception.GetType().Name + ": " + __exception.Message));
		return null;
	}

	private static void QueueTempleExtraRelease(Interaction_TempleAltar altar, string reason)
	{
		if ((Object)(object)altar == (Object)null || _templeExtraReleaseQueued || !HasExtraTemplePlayers())
		{
			return;
		}
		try
		{
			((MonoBehaviour)altar).StartCoroutine(TempleExtraReleaseRoutine(reason));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Failed to queue temple extra-player release: " + ex.Message));
		}
	}

	private static IEnumerator TempleExtraReleaseRoutine(string reason)
	{
		_templeExtraReleaseQueued = true;
		yield return (object)new WaitForSecondsRealtime(0.35f);
		ReleaseTempleExtraPlayers(reason + ".stage");
		yield return (object)new WaitForSecondsRealtime(0.45f);
		ReleaseTempleExtraPlayers(reason + ".settle");
		_templeExtraReleaseQueued = false;
	}

	private static void QueueTempleCancelExitCheck(Interaction_TempleAltar altar, string reason)
	{
		if ((Object)(object)altar == (Object)null)
		{
			return;
		}
		try
		{
			((MonoBehaviour)altar).StartCoroutine(TempleCancelExitCheckRoutine(altar, reason));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Failed to queue temple cancel exit check: " + ex.Message));
		}
	}

	private static IEnumerator TempleCancelExitCheckRoutine(Interaction_TempleAltar altar, string reason)
	{
		yield return (object)new WaitForSecondsRealtime(0.25f);
		ReleaseTempleExtraPlayers(reason + ".early");
		float waitUntil = Time.unscaledTime + 12f;
		while (IsTempleSinOrConversationFlowActive() && Time.unscaledTime < waitUntil)
		{
			ReleaseTempleExtraPlayers(reason + ".conversation");
			yield return (object)new WaitForSecondsRealtime(0.25f);
		}
		if (IsTempleSinOrConversationFlowActive())
		{
			Plugin.Log.LogWarning((object)("[MP] Temple conversation did not finish after 12 seconds; applying automatic recovery (" + reason + ")"));
			CoopEmergencyEscape.TryForceCloseConversation("temple altar watchdog");
			CoopConversationSession.EmergencyRecoverAll();
			yield return (object)new WaitForSecondsRealtime(0.2f);
			RecoverTempleAltarExitState(altar, reason + ".watchdog");
			NormalizeTemplePresentation(reason + ".watchdog");
			yield break;
		}
		yield return (object)new WaitForSecondsRealtime(0.35f);
		if (!IsTempleSinOrConversationFlowActive() && NeedsTempleExitRecovery(altar))
		{
			RecoverTempleAltarExitState(altar, reason + ".delayed");
		}
		else if (!IsTempleSinOrConversationFlowActive())
		{
			CoopConversationSession.BeginTownEventRecovery(2.5f, "temple altar " + reason);
			NormalizeTemplePresentation(reason + ".completed");
		}
	}

	private static void QueueTemplePresentationNormalize(Interaction_TempleAltar altar, string reason)
	{
		if ((Object)(object)altar == (Object)null)
		{
			return;
		}
		try
		{
			((MonoBehaviour)altar).StartCoroutine(TemplePresentationNormalizeRoutine(reason));
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Failed to queue temple presentation normalize: " + ex.Message));
		}
	}

	private static IEnumerator TemplePresentationNormalizeRoutine(string reason)
	{
		yield return (object)new WaitForSecondsRealtime(0.35f);
		NormalizeTemplePresentation(reason + ".early");
		yield return (object)new WaitForSecondsRealtime(1.25f);
		NormalizeTemplePresentation(reason + ".late");
	}

	private static void NormalizeTemplePresentation(string reason)
	{
		//IL_00d5: 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_00ee: Invalid comparison between Unknown and I4
		if (PlayerFarming.players == null || IsTempleSinOrConversationFlowActive())
		{
			return;
		}
		bool flag = false;
		for (int i = 0; i < PlayerFarming.players.Count; i++)
		{
			PlayerFarming playerFarming = PlayerFarming.players[i];
			if ((Object)(object)playerFarming == (Object)null || !((Component)playerFarming).gameObject.activeInHierarchy)
			{
				continue;
			}
			try
			{
				if ((Object)(object)playerFarming.Spine != (Object)null)
				{
					playerFarming.Spine.UseDeltaTime = true;
					playerFarming.Spine.timeScale = 1f;
				}
			}
			catch
			{
			}
			if (!IsStuckTempleAnimation(playerFarming))
			{
				continue;
			}
			try
			{
				if ((Object)(object)playerFarming.state != (Object)null && !playerFarming.state.LockStateChanges && ((int)playerFarming.state.CURRENT_STATE == 0 || (int)playerFarming.state.CURRENT_STATE == 49))
				{
					playerFarming.state.CURRENT_STATE = (State)0;
				}
			}
			catch
			{
			}
			try
			{
				string currentSpineAnimationName = GetCurrentSpineAnimationName(playerFarming);
				if (!string.IsNullOrEmpty(currentSpineAnimationName) && currentSpineAnimationName.IndexOf("sermons/second-player", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					playerFarming.CustomAnimationWithCallback("sermons/second-player-stop", false, (Action)delegate
					{
						try
						{
							if ((Object)(object)playerFarming.state != (Object)null)
							{
								playerFarming.state.LockStateChanges = false;
								playerFarming.state.CURRENT_STATE = (State)0;
							}
						}
						catch
						{
						}
					});
					flag = true;
				}
				else if ((Object)(object)playerFarming.state != (Object)null)
				{
					playerFarming.state.LockStateChanges = false;
					playerFarming.state.CURRENT_STATE = (State)0;
					flag = true;
				}
			}
			catch
			{
			}
		}
		if (flag)
		{
			Plugin.Log.LogInfo((object)("[MP] Normalized stuck temple player animation (" + reason + ")"));
		}
	}

	private static string GetCurrentSpineAnimationName(PlayerFarming player)
	{
		try
		{
			if ((Object)(object)player == (Object)null || (Object)(object)player.Spine == (Object)null || player.Spine.AnimationState == null)
			{
				return null;
			}
			TrackEntry current = player.Spine.AnimationState.GetCurrent(0);
			object result;
			if (current == null)
			{
				result = null;
			}
			else
			{
				Animation animation = current.Animation;
				result = ((animation != null) ? animation.Name : null);
			}
			return (string)result;
		}
		catch
		{
			return null;
		}
	}

	private static bool IsStuckTempleAnimation(PlayerFarming player)
	{
		try
		{
			string currentSpineAnimationName = GetCurrentSpineAnimationName(player);
			if (string.IsNullOrEmpty(currentSpineAnimationName))
			{
				return false;
			}
			return currentSpineAnimationName.IndexOf("sermons/second-player", StringComparison.OrdinalIgnoreCase) >= 0 || currentSpineAnimationName.IndexOf("rituals/sin-onboarding", StringComparison.OrdinalIgnoreCase) >= 0;
		}
		catch
		{
			return false;
		}
	}

	private static bool HasExtraTemplePlayers()
	{
		if (PlayerFarming.players == null)
		{
			return false;
		}
		for (int i = 0; i < PlayerFarming.players.Count; i++)
		{
			if (IsExtraTemplePlayer(PlayerFarming.players[i]))
			{
				return true;
			}
		}
		return false;
	}

	private static bool IsExtraTemplePlayer(PlayerFarming player)
	{
		if ((Object)(object)player != (Object)null && !player.isLamb)
		{
			return player.playerID >= 2;
		}
		return false;
	}

	private static void ReleaseTempleExtraPlayers(string reason)
	{
		//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_00b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_00bb: Invalid comparison between Unknown and I4
		//IL_00bd: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c1: Invalid comparison between Unknown and I4
		//IL_00c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c7: Invalid comparison between Unknown and I4
		//IL_00c9: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cd: Invalid comparison between Unknown and I4
		//IL_00cf: Unknown result type (might be due to invalid IL or missing references)
		//IL_00d3: Invalid comparison between Unknown and I4
		if (PlayerFarming.players == null)
		{
			return;
		}
		bool flag = false;
		for (int i = 0; i < PlayerFarming.players.Count; i++)
		{
			PlayerFarming val = PlayerFarming.players[i];
			if (!IsExtraTemplePlayer(val) || !((Component)val).gameObject.activeInHierarchy)
			{
				continue;
			}
			bool flag2 = false;
			try
			{
				if (val.GoToAndStopping)
				{
					val.GoToAndStopping = false;
					flag2 = true;
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)val.Spine != (Object)null)
				{
					val.Spine.UseDeltaTime = true;
					val.Spine.timeScale = 1f;
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)val.state != (Object)null)
				{
					if (val.state.LockStateChanges)
					{
						val.state.LockStateChanges = false;
						flag2 = true;
					}
					State cURRENT_STATE = val.state.CURRENT_STATE;
					if ((int)cURRENT_STATE == 49 || (int)cURRENT_STATE == 16 || (int)cURRENT_STATE == 13 || (int)cURRENT_STATE == 24 || (int)cURRENT_STATE == 49)
					{
						val.state.CURRENT_STATE = (State)0;
						flag2 = true;
					}
				}
			}
			catch
			{
			}
			flag = flag || flag2;
		}
		if (flag)
		{
			Plugin.Log.LogInfo((object)("[MP8] Released extra players from temple staging state (" + reason + ")"));
		}
	}

	private static bool IsTempleSinOrConversationFlowActive()
	{
		try
		{
			if (MMConversation.isPlaying || LetterBox.IsPlaying)
			{
				return true;
			}
		}
		catch
		{
		}
		try
		{
			UIManager instance = MonoSingleton<UIManager>.Instance;
			if ((Object)(object)instance != (Object)null && instance.ForceBlockPause)
			{
				return true;
			}
		}
		catch
		{
		}
		return false;
	}

	private static bool WillTempleSinOnboardingRun()
	{
		//IL_0005: Unknown result type (might be due to invalid IL or missing references)
		//IL_0010: Expected O, but got Unknown
		try
		{
			if ((Object)DataManager.Instance == (Object)null)
			{
				return false;
			}
			bool unlocked = UpgradeSystem.GetUnlocked((Type)267);
			bool unlocked2 = UpgradeSystem.GetUnlocked((Type)268);
			bool flag = DataManager.Instance.PleasureRevealed && (unlocked || unlocked2);
			if (DataManager.Instance.BossesCompleted == null || DataManager.Instance.BossesCompleted.Count < 3)
			{
				return false;
			}
			if (flag)
			{
				return false;
			}
			if (Ritual.FollowerToAttendSermon == null || Ritual.FollowerToAttendSermon.Count <= 0)
			{
				return false;
			}
			return UpgradeSystem.GetUnlocked((Type)229);
		}
		catch
		{
			return false;
		}
	}

	private static bool NeedsTempleExitRecovery(Interaction_TempleAltar altar)
	{
		try
		{
			if (Mathf.Approximately(Time.timeScale, 0f))
			{
				return true;
			}
		}
		catch
		{
		}
		try
		{
			UIManager instance = MonoSingleton<UIManager>.Instance;
			if ((Object)(object)instance != (Object)null && (instance.ForceBlockMenus || instance.ForceDisableSaving))
			{
				return true;
			}
		}
		catch
		{
		}
		try
		{
			GameManager instance2 = GameManager.GetInstance();
			if ((Object)(object)instance2 != (Object)null && (Object)(object)instance2.CamFollowTarget != (Object)null && instance2.CamFollowTarget.DisablePlayerLook)
			{
				return true;
			}
		}
		catch
		{
		}
		if (GetBoolField(_templeAltarActivatedField, altar) || GetBoolField(_templeAltarActivatingField, altar) || GetBoolField(_templeAltarCoopPlayerFrozenField, altar))
		{
			return true;
		}
		return HasLockedExtraTemplePlayer();
	}

	private static bool HasLockedExtraTemplePlayer()
	{
		if (PlayerFarming.players == null)
		{
			return false;
		}
		for (int i = 0; i < PlayerFarming.players.Count; i++)
		{
			PlayerFarming val = PlayerFarming.players[i];
			if (!IsExtraTemplePlayer(val))
			{
				continue;
			}
			try
			{
				if (val.GoToAndStopping)
				{
					return true;
				}
				if ((Object)(object)val.state != (Object)null && val.state.LockStateChanges)
				{
					return true;
				}
			}
			catch
			{
			}
		}
		return false;
	}

	private static void RecoverTempleAltarExitState(Interaction_TempleAltar altar, string reason)
	{
		//IL_0069: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			Time.timeScale = 1f;
			SimulationManager.UnPause();
		}
		catch
		{
		}
		try
		{
			UIManager instance = MonoSingleton<UIManager>.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				instance.ForceBlockMenus = false;
				instance.ForceBlockPause = false;
				instance.ForceDisableSaving = false;
			}
		}
		catch
		{
		}
		try
		{
			GameManager instance2 = GameManager.GetInstance();
			if ((Object)(object)instance2 != (Object)null)
			{
				if ((Object)(object)instance2.CamFollowTarget != (Object)null)
				{
					instance2.CamFollowTarget.DisablePlayerLook = false;
				}
				instance2.CameraSetOffset(Vector3.zero);
				instance2.OnConversationEnd(true, true);
			}
		}
		catch
		{
		}
		if ((Object)(object)altar != (Object)null)
		{
			SetBoolField(_templeAltarActivatedField, altar, value: false);
			SetBoolField(_templeAltarActivatingField, altar, value: false);
			SetBoolField(_templeAltarCoopPlayerFrozenField, altar, value: false);
			SetBoolField(_templeAltarInteractedField, altar, value: false);
			try
			{
				object? obj4 = _templeAltarColliderField?.GetValue(altar);
				Collider2D val = (Collider2D)((obj4 is Collider2D) ? obj4 : null);
				if ((Object)(object)val != (Object)null)
				{
					((Behaviour)val).enabled = true;
				}
			}
			catch
			{
			}
			try
			{
				if ((Object)(object)altar.Menu != (Object)null)
				{
					altar.Menu.SetActive(false);
				}
				((Interaction)altar).HasChanged = true;
				if ((Object)(object)((Interaction)altar).state != (Object)null)
				{
					((Interaction)altar).state.CURRENT_STATE = (State)0;
				}
				AccessTools.Method(typeof(Interaction_TempleAltar), "ResetSprite", new Type[1] { typeof(bool) }, (Type[])null)?.Invoke(altar, new object[1] { false });
			}
			catch
			{
			}
		}
		ReleaseTempleExtraPlayers(reason);
		CoopConversationSession.BeginTownEventRecovery(3f, "temple altar recovery");
		Plugin.Log.LogWarning((object)("[MP] Temple altar exit recovery applied (" + reason + ")"));
	}

	private static bool GetBoolField(FieldInfo field, object instance)
	{
		if (field == null || instance == null)
		{
			return false;
		}
		try
		{
			object value = field.GetValue(instance);
			bool flag = false;
			int num;
			if (value is bool)
			{
				flag = (bool)value;
				num = 1;
			}
			else
			{
				num = 0;
			}
			return (byte)(num & (flag ? 1 : 0)) != 0;
		}
		catch
		{
			return false;
		}
	}

	private static void SetBoolField(FieldInfo field, object instance, bool value)
	{
		if (field == null || instance == null)
		{
			return;
		}
		try
		{
			field.SetValue(instance, value);
		}
		catch
		{
		}
	}

	public static bool SpawnPlayerIE_Prefix(PlayerFarming playerFarming, ref Vector3 positionOffset)
	{
		//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)
		if ((Object)(object)playerFarming == (Object)null)
		{
			return true;
		}
		if (PlayerFarming.players.Count <= 1)
		{
			return true;
		}
		if (playerFarming.isLamb || playerFarming.playerID <= 1)
		{
			return true;
		}
		int num = playerFarming.playerID;
		if (num < 2 || num >= _teleporterOffsets.Length)
		{
			num = ResolveTeleporterSlot(playerFarming);
		}
		if (num <= 1)
		{
			return true;
		}
		if (num < 0 || num >= _teleporterOffsets.Length)
		{
			return true;
		}
		positionOffset = _teleporterOffsets[num];
		return true;
	}

	public static void PlayerClearRubble_OnInteract_Prefix(Interaction_PlayerClearRubble __instance, StateMachine state)
	{
		PlayerFarming player = ResolvePlayerFromStateMachine(state);
		((Interaction)__instance).FreezeCoopPlayersOnHoldToInteract = false;
		__instance.RequireUseOthersFirst = false;
		EnsurePlayerClearRubbleCapacity(__instance, player);
	}

	public static void PlayerClearRubble_Update_Prefix(Interaction_PlayerClearRubble __instance)
	{
		EnsurePlayerClearRubbleCapacity(__instance, null);
	}

	public static void PlayerClearRubble_DoBuild_Prefix(Interaction_PlayerClearRubble __instance, PlayerFarming player)
	{
		EnsurePlayerClearRubbleCapacity(__instance, player);
	}

	public static void PlayerClearRubble_DoBuildMoveNext_Prefix(object __instance)
	{
		Interaction_PlayerClearRubble interaction = ResolveClearRubbleFromStateMachine(__instance);
		PlayerFarming player = ResolveClearRubblePlayerFromStateMachine(__instance);
		EnsurePlayerClearRubbleCapacity(interaction, player);
	}

	public static IEnumerable<CodeInstruction> PlayerClearRubblePlayerIndex_Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		//IL_0074: Unknown result type (might be due to invalid IL or missing references)
		//IL_007e: Expected O, but got Unknown
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		MethodInfo methodInfo = AccessTools.Method(typeof(List<PlayerFarming>), "IndexOf", new Type[1] { typeof(PlayerFarming) }, (Type[])null);
		MethodInfo methodInfo2 = AccessTools.Method(typeof(Patches), "GetClearRubblePlayerIndex", (Type[])null, (Type[])null);
		for (int i = 0; i < list.Count; i++)
		{
			if (methodInfo != null && methodInfo2 != null && CodeInstructionExtensions.Calls(list[i], methodInfo))
			{
				list[i] = new CodeInstruction(OpCodes.Call, (object)methodInfo2);
			}
		}
		return list;
	}

	public static int GetClearRubblePlayerIndex(List<PlayerFarming> players, PlayerFarming player)
	{
		int num = -1;
		if (players != null && (Object)(object)player != (Object)null)
		{
			num = players.IndexOf(player);
		}
		if (num >= 0)
		{
			return num;
		}
		if ((Object)(object)player == (Object)null)
		{
			return -1;
		}
		int playerID = player.playerID;
		if (playerID >= 0 && playerID < 8)
		{
			return playerID;
		}
		return -1;
	}

	public static Exception PlayerClearRubble_Finalizer(Exception __exception, object __instance)
	{
		if (__exception == null)
		{
			return null;
		}
		if (!(__exception is IndexOutOfRangeException))
		{
			return __exception;
		}
		object interaction = ((__instance is Interaction_PlayerClearRubble) ? __instance : null) ?? ResolveClearRubbleFromStateMachine(__instance);
		PlayerFarming player = ResolveClearRubblePlayerFromStateMachine(__instance);
		EnsurePlayerClearRubbleCapacity((Interaction_PlayerClearRubble)interaction, player);
		RecoverClearRubblePlayer(player);
		Plugin.Log.LogWarning((object)"[MP] Suppressed Interaction_PlayerClearRubble player-slot bounds exception");
		return null;
	}

	public static void PlayerWork_OnInteract_Prefix(object __instance, StateMachine state)
	{
		PlayerFarming player = ResolvePlayerFromStateMachine(state);
		EnsurePlayerWorkButtonCapacity(__instance, player);
	}

	public static void PlayerWork_Update_Prefix(object __instance)
	{
		EnsurePlayerWorkButtonCapacity(__instance, null);
	}

	public static void PlayerWork_MoveNext_Prefix(object __instance)
	{
		object interaction = ResolveCoroutineOwner(__instance);
		PlayerFarming player = ResolveCoroutinePlayer(__instance);
		EnsurePlayerWorkButtonCapacity(interaction, player);
	}

	public static Exception PlayerWork_Finalizer(Exception __exception, object __instance)
	{
		if (__exception == null)
		{
			return null;
		}
		if (!(__exception is IndexOutOfRangeException))
		{
			return __exception;
		}
		object obj = __instance;
		if (!(obj is Interaction_Woodcutting) && !(obj is Interaction_WoodcuttingRubble) && !(obj is Interaction_Berries) && !(obj is Interaction_ClearToxicWaste))
		{
			obj = ResolveCoroutineOwner(__instance);
		}
		PlayerFarming player = ResolveCoroutinePlayer(__instance);
		EnsurePlayerWorkButtonCapacity(obj, player);
		RecoverPlayerWorkPlayer(player);
		Plugin.Log.LogWarning((object)"[MP] Suppressed player work interaction slot bounds exception");
		return null;
	}

	public static MethodInfo FindNestedMoveNext(Type ownerType, string methodName)
	{
		if (ownerType == null || string.IsNullOrEmpty(methodName))
		{
			return null;
		}
		Type[] nestedTypes = ownerType.GetNestedTypes(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
		foreach (Type type in nestedTypes)
		{
			if (type != null && type.Name.IndexOf("<" + methodName + ">", StringComparison.Ordinal) >= 0)
			{
				MethodInfo method = type.GetMethod("MoveNext", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
				if (method != null)
				{
					return method;
				}
			}
		}
		return null;
	}

	private static void EnsurePlayerClearRubbleCapacity(Interaction_PlayerClearRubble interaction, PlayerFarming player)
	{
		if ((Object)(object)interaction == (Object)null || _clearRubbleButtonDownField == null)
		{
			return;
		}
		PruneClearRubbleActivatingPlayers(interaction);
		int num = 8;
		if (PlayerFarming.players != null)
		{
			num = Mathf.Max(num, PlayerFarming.players.Count);
		}
		num = Mathf.Max(num, PlayerFarming.playersCount);
		int playerListIndex = GetPlayerListIndex(player);
		if (playerListIndex >= 0)
		{
			num = Mathf.Max(num, playerListIndex + 1);
		}
		bool[] array = _clearRubbleButtonDownField.GetValue(interaction) as bool[];
		if (array == null || array.Length < num)
		{
			bool[] array2 = new bool[num];
			if (array != null)
			{
				Array.Copy(array, array2, Mathf.Min(array.Length, array2.Length));
			}
			_clearRubbleButtonDownField.SetValue(interaction, array2);
			Plugin.Log.LogInfo((object)$"[MP] Expanded Interaction_PlayerClearRubble.buttonDown to {array2.Length}");
		}
	}

	private static void EnsurePlayerWorkButtonCapacity(object interaction, PlayerFarming player)
	{
		if (interaction == null)
		{
			return;
		}
		Type type = interaction.GetType();
		Interaction val = (Interaction)((interaction is Interaction) ? interaction : null);
		if (val != null)
		{
			val.FreezeCoopPlayersOnHoldToInteract = false;
		}
		FieldInfo field = type.GetField("RequireUseOthersFirst", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field != null && field.FieldType == typeof(bool))
		{
			field.SetValue(interaction, false);
		}
		FieldInfo field2 = type.GetField("buttonDown", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field2 == null)
		{
			return;
		}
		PrunePlayerWorkActivatingPlayers(interaction);
		int num = 8;
		if (PlayerFarming.players != null)
		{
			num = Mathf.Max(num, PlayerFarming.players.Count);
		}
		num = Mathf.Max(num, PlayerFarming.playersCount);
		int clearRubblePlayerIndex = GetClearRubblePlayerIndex(PlayerFarming.players, player);
		if (clearRubblePlayerIndex >= 0)
		{
			num = Mathf.Max(num, clearRubblePlayerIndex + 1);
		}
		bool[] array = field2.GetValue(interaction) as bool[];
		if (array == null || array.Length < num)
		{
			bool[] array2 = new bool[num];
			if (array != null)
			{
				Array.Copy(array, array2, Mathf.Min(array.Length, array2.Length));
			}
			field2.SetValue(interaction, array2);
			Plugin.Log.LogInfo((object)("[MP] Expanded " + type.Name + ".buttonDown to " + array2.Length));
		}
	}

	private static void PrunePlayerWorkActivatingPlayers(object interaction)
	{
		if (interaction == null || !(interaction.GetType().GetField("activatingPlayers", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(interaction) is List<PlayerFarming> { Count: not 0 } list))
		{
			return;
		}
		for (int num = list.Count - 1; num >= 0; num--)
		{
			PlayerFarming val = list[num];
			if ((Object)(object)val == (Object)null || GetClearRubblePlayerIndex(PlayerFarming.players, val) < 0)
			{
				list.RemoveAt(num);
			}
		}
	}

	private static void PruneClearRubbleActivatingPlayers(Interaction_PlayerClearRubble interaction)
	{
		if ((Object)(object)interaction == (Object)null || _clearRubbleActivatingPlayersField == null || !(_clearRubbleActivatingPlayersField.GetValue(interaction) is List<PlayerFarming> { Count: not 0 } list))
		{
			return;
		}
		for (int num = list.Count - 1; num >= 0; num--)
		{
			PlayerFarming val = list[num];
			if ((Object)(object)val == (Object)null || GetPlayerListIndex(val) < 0)
			{
				list.RemoveAt(num);
			}
		}
	}

	private static int GetPlayerListIndex(PlayerFarming player)
	{
		if ((Object)(object)player == (Object)null || PlayerFarming.players == null)
		{
			return -1;
		}
		return GetClearRubblePlayerIndex(PlayerFarming.players, player);
	}

	private static Interaction_PlayerClearRubble ResolveClearRubbleFromStateMachine(object stateMachine)
	{
		object obj = ResolveCoroutineOwner(stateMachine);
		return (Interaction_PlayerClearRubble)((obj is Interaction_PlayerClearRubble) ? obj : null);
	}

	private static PlayerFarming ResolveClearRubblePlayerFromStateMachine(object stateMachine)
	{
		return ResolveCoroutinePlayer(stateMachine);
	}

	private static object ResolveCoroutineOwner(object stateMachine)
	{
		return stateMachine?.GetType().GetField("<>4__this", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(stateMachine);
	}

	private static PlayerFarming ResolveCoroutinePlayer(object stateMachine)
	{
		if (stateMachine == null)
		{
			return null;
		}
		object? obj = stateMachine.GetType().GetField("player", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)?.GetValue(stateMachine);
		return (PlayerFarming)((obj is PlayerFarming) ? obj : null);
	}

	private static void RecoverClearRubblePlayer(PlayerFarming player)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Invalid comparison between Unknown and I4
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		try
		{
			if ((Object)(object)player.state != (Object)null && (int)player.state.CURRENT_STATE == 49)
			{
				player.state.CURRENT_STATE = (State)0;
			}
			player.OnCrownReturn?.Invoke();
		}
		catch
		{
		}
	}

	private static void RecoverPlayerWorkPlayer(PlayerFarming player)
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0026: Invalid comparison between Unknown and I4
		//IL_002e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0035: Invalid comparison between Unknown and I4
		if ((Object)(object)player == (Object)null)
		{
			return;
		}
		try
		{
			if ((Object)(object)player.state != (Object)null && ((int)player.state.CURRENT_STATE == 49 || (int)player.state.CURRENT_STATE == 16))
			{
				player.state.CURRENT_STATE = (State)0;
			}
			player.OnCrownReturn?.Invoke();
		}
		catch
		{
		}
	}

	public static void RanchFollowingCapacity_Prefix()
	{
		EnsureRanchFollowingCapacity();
	}

	public static void Ranchable_GetLabelOwner_Prefix(Interaction_Ranchable __instance)
	{
		//IL_0018: Unknown result type (might be due to invalid IL or missing references)
		//IL_001d: Unknown result type (might be due to invalid IL or missing references)
		//IL_001e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0020: Invalid comparison between Unknown and I4
		//IL_0022: Unknown result type (might be due to invalid IL or missing references)
		//IL_0024: Invalid comparison between Unknown and I4
		if ((Object)(object)__instance == (Object)null || _interactionPlayerFarmingField == null)
		{
			return;
		}
		State currentState = __instance.CurrentState;
		if (((int)currentState == 3 || (int)currentState == 4) && !((Object)/*isinst with value type is only supported in some contexts*/ != (Object)null) && !((Object)(object)((Interaction)__instance).state == (Object)null))
		{
			PlayerFarming component = ((Component)((Interaction)__instance).state).GetComponent<PlayerFarming>();
			if ((Object)(object)component != (Object)null)
			{
				_interactionPlayerFarmingField.SetValue(__instance, component);
			}
		}
	}

	public static IEnumerable<CodeInstruction> Ranchable_FurnaceNullSafety_Transpiler(IEnumerable<CodeInstruction> instructions, MethodBase __originalMethod)
	{
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		MethodInfo methodInfo = AccessTools.Method(typeof(Interaction_DLCFurnace), "CanAddFuel", Type.EmptyTypes, (Type[])null);
		FieldInfo fieldInfo = AccessTools.Field(typeof(Interaction_DLCFurnace), "dropOffAnimalFurnace");
		MethodInfo methodInfo2 = AccessTools.Method(typeof(Interaction_DropOffItem), "SetOnState", new Type[1] { typeof(bool) }, (Type[])null);
		MethodInfo methodInfo3 = AccessTools.Method(typeof(Interaction_DropOffItem), "SetDropOffState", new Type[2]
		{
			typeof(bool),
			typeof(bool)
		}, (Type[])null);
		MethodInfo methodInfo4 = AccessTools.Method(typeof(Patches), "RanchFurnaceCanAddFuelSafe", (Type[])null, (Type[])null);
		MethodInfo methodInfo5 = AccessTools.Method(typeof(Patches), "GetRanchFurnaceDropOffSafe", (Type[])null, (Type[])null);
		MethodInfo methodInfo6 = AccessTools.Method(typeof(Patches), "RanchDropOffSetOnStateSafe", (Type[])null, (Type[])null);
		MethodInfo methodInfo7 = AccessTools.Method(typeof(Patches), "RanchDropOffSetDropOffStateSafe", (Type[])null, (Type[])null);
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		int num4 = 0;
		for (int i = 0; i < list.Count; i++)
		{
			CodeInstruction val = list[i];
			if (methodInfo != null && methodInfo4 != null && CodeInstructionExtensions.Calls(val, methodInfo))
			{
				val.opcode = OpCodes.Call;
				val.operand = methodInfo4;
				num++;
			}
			else if (fieldInfo != null && methodInfo5 != null && CodeInstructionExtensions.LoadsField(val, fieldInfo, false))
			{
				val.opcode = OpCodes.Call;
				val.operand = methodInfo5;
				num2++;
			}
			else if (methodInfo2 != null && methodInfo6 != null && CodeInstructionExtensions.Calls(val, methodInfo2) && HasRecentRanchDropOffGetter(list, i, methodInfo5, 2))
			{
				val.opcode = OpCodes.Call;
				val.operand = methodInfo6;
				num3++;
			}
			else if (methodInfo3 != null && methodInfo7 != null && CodeInstructionExtensions.Calls(val, methodInfo3) && HasRecentRanchDropOffGetter(list, i, methodInfo5, 3))
			{
				val.opcode = OpCodes.Call;
				val.operand = methodInfo7;
				num4++;
			}
		}
		Plugin.Log.LogInfo((object)string.Format("[MP] Ranch furnace safety rewrote {0}: CanAddFuel={1}, DropOffField={2}, SetOnState={3}, SetDropOffState={4}", __originalMethod?.Name ?? "unknown", num, num2, num3, num4));
		return list;
	}

	private static bool HasRecentRanchDropOffGetter(List<CodeInstruction> instructions, int callIndex, MethodInfo getter, int maxDistance)
	{
		if (instructions == null || getter == null)
		{
			return false;
		}
		int num = Mathf.Max(0, callIndex - maxDistance);
		for (int num2 = callIndex - 1; num2 >= num; num2--)
		{
			if (CodeInstructionExtensions.Calls(instructions[num2], getter))
			{
				return true;
			}
		}
		return false;
	}

	public static bool RanchFurnaceCanAddFuelSafe(Interaction_DLCFurnace furnace)
	{
		if ((Object)(object)furnace == (Object)null)
		{
			return false;
		}
		try
		{
			return furnace.CanAddFuel();
		}
		catch (NullReferenceException)
		{
			return false;
		}
	}

	public static Interaction_DropOffItem GetRanchFurnaceDropOffSafe(Interaction_DLCFurnace furnace)
	{
		if ((Object)(object)furnace == (Object)null)
		{
			return null;
		}
		return furnace.dropOffAnimalFurnace;
	}

	public static void RanchDropOffSetOnStateSafe(Interaction_DropOffItem dropOffItem, bool on)
	{
		if ((Object)(object)dropOffItem != (Object)null)
		{
			dropOffItem.SetOnState(on);
		}
	}

	public static void RanchDropOffSetDropOffStateSafe(Interaction_DropOffItem dropOffItem, bool inProximity, bool willAccept)
	{
		if ((Object)(object)dropOffItem != (Object)null)
		{
			dropOffItem.SetDropOffState(inProximity, willAccept);
		}
	}

	public static IEnumerable<CodeInstruction> AnimationAdorationUI_Hide_Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		List<CodeInstruction> list = new List<CodeInstruction>(instructions);
		MethodInfo methodInfo = AccessTools.Method(typeof(Debug), "LogError", new Type[1] { typeof(object) }, (Type[])null);
		int num = 0;
		for (int i = 1; i < list.Count; i++)
		{
			CodeInstruction val = list[i];
			CodeInstruction val2 = list[i - 1];
			if (methodInfo != null && CodeInstructionExtensions.Calls(val, methodInfo) && val2.opcode == OpCodes.Ldstr && string.Equals(val2.operand as string, "Hide adoration", StringComparison.Ordinal))
			{
				val.opcode = OpCodes.Pop;
				val.operand = null;
				num++;
			}
		}
		Plugin.Log.LogInfo((object)$"[MP] Removed {num} vanilla animal adoration hide diagnostic call(s)");
		return list;
	}

	private static void EnsureRanchFollowingCapacity()
	{
		DataManager instance;
		try
		{
			instance = DataManager.Instance;
		}
		catch
		{
			return;
		}
		if (instance == null)
		{
			return;
		}
		int requiredPlayerCapacity = GetRequiredPlayerCapacity();
		Ranchable_Animal[] followingPlayerAnimals = instance.FollowingPlayerAnimals;
		if (followingPlayerAnimals == null || followingPlayerAnimals.Length < requiredPlayerCapacity)
		{
			Ranchable_Animal[] array = (Ranchable_Animal[])(object)new Ranchable_Animal[requiredPlayerCapacity];
			if (followingPlayerAnimals != null)
			{
				Array.Copy(followingPlayerAnimals, array, Mathf.Min(followingPlayerAnimals.Length, array.Length));
			}
			instance.FollowingPlayerAnimals = array;
			Plugin.Log.LogInfo((object)$"[MP] Expanded FollowingPlayerAnimals from {((followingPlayerAnimals != null) ? followingPlayerAnimals.Length : 0)} to {array.Length}");
		}
	}

	public static void DLCShrine_PlayerCapacity_Prefix(Interaction_DLCShrine __instance)
	{
		if ((Object)(object)__instance == (Object)null || _dlcShrinePlayerAnimsSetField == null)
		{
			return;
		}
		int[] array = _dlcShrinePlayerAnimsSetField.GetValue(__instance) as int[];
		int requiredPlayerCapacity = GetRequiredPlayerCapacity();
		if (array == null || array.Length < requiredPlayerCapacity)
		{
			int[] array2 = new int[requiredPlayerCapacity];
			if (array != null)
			{
				Array.Copy(array, array2, Mathf.Min(array.Length, array2.Length));
			}
			_dlcShrinePlayerAnimsSetField.SetValue(__instance, array2);
			Plugin.Log.LogInfo((object)$"[MP] Expanded Interaction_DLCShrine.playerAnimsSet to {array2.Length}");
		}
	}

	public static void WaterInteraction_Update_Prefix(WaterInteraction __instance)
	{
		EnsureWaterInteractionCapacity(__instance);
	}

	public static void WaterInteraction_OnTriggerExit2D_Postfix(WaterInteraction __instance)
	{
		if (!((Object)(object)__instance == (Object)null) && __instance.playerColliders != null)
		{
			__instance.inTrigger = __instance.playerColliders.Count > 0;
			if (__instance.inTrigger && (Object)(object)AudioManager.Instance != (Object)null)
			{
				AudioManager.Instance.playerFootstepOverride = __instance.footstepSound;
			}
		}
	}

	public static Exception WaterInteraction_Finalizer(Exception __exception, WaterInteraction __instance)
	{
		if (__exception == null)
		{
			return null;
		}
		if (!(__exception is IndexOutOfRangeException))
		{
			return __exception;
		}
		EnsureWaterInteractionCapacity(__instance);
		Plugin.Log.LogWarning((object)"[MP] Suppressed WaterInteraction player-slot bounds exception");
		return null;
	}

	private static void EnsureWaterInteractionCapacity(WaterInteraction waterInteraction)
	{
		if ((Object)(object)waterInteraction == (Object)null)
		{
			return;
		}
		int num = GetRequiredPlayerCapacity();
		if (waterInteraction.playerColliders != null)
		{
			num = Mathf.Max(num, waterInteraction.playerColliders.Count);
		}
		Vector3[] playerOldPosition = waterInteraction.PlayerOldPosition;
		if (playerOldPosition == null || playerOldPosition.Length < num)
		{
			Vector3[] array = (Vector3[])(object)new Vector3[num];
			if (playerOldPosition != null)
			{
				Array.Copy(playerOldPosition, array, Mathf.Min(playerOldPosition.Length, array.Length));
			}
			waterInteraction.PlayerOldPosition = array;
			Plugin.Log.LogInfo((object)$"[MP] Expanded WaterInteraction.PlayerOldPosition to {array.Length}");
		}
	}

	private static int GetRequiredPlayerCapacity()
	{
		int num = 8;
		if (PlayerFarming.players != null)
		{
			num = Mathf.Max(num, PlayerFarming.players.Count);
		}
		return Mathf.Max(num, PlayerFarming.playersCount);
	}

	public static void WeaponPodium_SetWeapon_Postfix(Interaction_WeaponSelectionPodium __instance)
	{
		FieldInfo field = typeof(Interaction_WeaponSelectionPodium).GetField("isCoopPodium", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field == null || !(bool)field.GetValue(__instance) || _spawnedExtraWeaponPodiums)
		{
			return;
		}
		List<int> activeExtraSlotsForPodiums = GetActiveExtraSlotsForPodiums();
		if (activeExtraSlotsForPodiums.Count == 0 && _podiumExtraCount > 0)
		{
			for (int i = 2; i < 2 + _podiumExtraCount && i < 8; i++)
			{
				activeExtraSlotsForPodiums.Add(i);
			}
		}
		if (activeExtraSlotsForPodiums.Count != 0)
		{
			_spawnedExtraWeaponPodiums = true;
			Plugin.Log.LogInfo((object)("WeaponPodium_SetWeapon_Postfix: spawning weapon podiums for slots [" + string.Join(",", activeExtraSlotsForPodiums) + "]"));
			SpawnExtraPodiumsOfType(__instance, activeExtraSlotsForPodiums, field, "Weapon");
		}
	}

	public static void WeaponPodium_SetCurse_Postfix(Interaction_WeaponSelectionPodium __instance)
	{
		FieldInfo field = typeof(Interaction_WeaponSelectionPodium).GetField("isCoopPodium", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field == null || !(bool)field.GetValue(__instance) || _spawnedExtraSpellPodiums)
		{
			return;
		}
		List<int> activeExtraSlotsForPodiums = GetActiveExtraSlotsForPodiums();
		if (activeExtraSlotsForPodiums.Count == 0 && _podiumExtraCount > 0)
		{
			for (int i = 2; i < 2 + _podiumExtraCount && i < 8; i++)
			{
				activeExtraSlotsForPodiums.Add(i);
			}
		}
		if (activeExtraSlotsForPodiums.Count != 0)
		{
			_spawnedExtraSpellPodiums = true;
			Plugin.Log.LogInfo((object)("WeaponPodium_SetCurse_Postfix: spawning spell podiums for slots [" + string.Join(",", activeExtraSlotsForPodiums) + "]"));
			SpawnExtraPodiumsOfType(__instance, activeExtraSlotsForPodiums, field, "Spell");
		}
	}

	private static List<int> GetActiveExtraSlotsForPodiums()
	{
		List<int> list = new List<int>();
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if (!((Object)(object)player == (Object)null) && !player.isLamb && player.playerID >= 2 && player.playerID < 8 && !list.Contains(player.playerID))
			{
				list.Add(player.playerID);
			}
		}
		list.Sort();
		return list;
	}

	private static PlayerFarming FindActivePlayerBySlot(int slot)
	{
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player != (Object)null && !player.isLamb && player.playerID == slot && ((Component)player).gameObject.activeSelf)
			{
				return player;
			}
		}
		return null;
	}

	private static IEnumerator EnsureP2DungeonEntranceNotStuckRoutine()
	{
		if (_p2EntranceGuardRunning)
		{
			yield break;
		}
		_p2EntranceGuardRunning = true;
		try
		{
			if (!GameManager.IsDungeon(PlayerFarming.Location))
			{
				yield break;
			}
			yield return (object)new WaitForSeconds(1.8f);
			for (float waited = 0f; waited < 3f; waited += 0.2f)
			{
				if (!GameManager.IsDungeon(PlayerFarming.Location))
				{
					break;
				}
				PlayerFarming instance = PlayerFarming.Instance;
				PlayerFarming val = FindActivePlayerBySlot(1);
				if ((Object)(object)instance != (Object)null && (Object)(object)val != (Object)null && (Object)(object)((Component)instance).gameObject != (Object)null && (Object)(object)((Component)val).gameObject != (Object)null && ((Component)instance).gameObject.activeInHierarchy && ((Component)val).gameObject.activeInHierarchy)
				{
					Vector3 val2 = ((Component)val).transform.position - ((Component)instance).transform.position;
					float magnitude = ((Vector3)(ref val2)).magnitude;
					bool flag = val2.y < -2.8f && Mathf.Abs(val2.x) < 4.5f && magnitude > 3.2f;
					bool flag2 = false;
					bool flag3 = IsFalseKnockedOutState(val);
					try
					{
						if ((Object)(object)val.state != (Object)null)
						{
							State cURRENT_STATE = val.state.CURRENT_STATE;
							flag2 = val.state.LockStateChanges || (int)cURRENT_STATE == 13 || (int)cURRENT_STATE == 49 || (int)cURRENT_STATE == 24 || (int)cURRENT_STATE == 16;
						}
					}
					catch
					{
					}
					if (flag && (flag2 || flag3))
					{
						Vector3 position = ((Component)instance).transform.position + new Vector3(1.25f, -0.1f, 0f);
						((Component)val).transform.position = position;
						try
						{
							if ((Object)(object)val.state != (Object)null)
							{
								val.state.LockStateChanges = false;
								val.state.CURRENT_STATE = (State)0;
							}
						}
						catch
						{
						}
						try
						{
							if ((Object)(object)val.health != (Object)null && ((Health)val.health).CurrentHP <= 0f)
							{
								((Health)val.health).HP = 2f;
							}
						}
						catch
						{
						}
						val.IsKnockedOut = false;
						Plugin.Log.LogWarning((object)$"[MP] P2 entrance unstuck applied (dy={val2.y:0.00}, dist={magnitude:0.00}, stateLocked={flag2}, falseDowned={flag3})");
						break;
					}
				}
				yield return (object)new WaitForSeconds(0.2f);
			}
		}
		finally
		{
			_p2EntranceGuardRunning = false;
		}
	}

	private static bool TryInferPodiumOwnerSlotFromName(Interaction_WeaponSelectionPodium podium, out int slot)
	{
		slot = -1;
		if ((Object)(object)podium == (Object)null || string.IsNullOrEmpty(((Object)podium).name))
		{
			return false;
		}
		int num = ((Object)podium).name.LastIndexOf("_P", StringComparison.OrdinalIgnoreCase);
		if (num < 0)
		{
			return false;
		}
		int i = num + 2;
		int num2 = 0;
		bool flag = false;
		for (; i < ((Object)podium).name.Length && char.IsDigit(((Object)podium).name[i]); i++)
		{
			flag = true;
			num2 = num2 * 10 + (((Object)podium).name[i] - 48);
		}
		if (!flag)
		{
			return false;
		}
		int num3 = num2 - 1;
		if (num3 < 2 || num3 >= 8)
		{
			return false;
		}
		slot = num3;
		return true;
	}

	private static bool TryGetPodiumOwnerSlot(Interaction_WeaponSelectionPodium podium, out int slot)
	{
		slot = -1;
		if ((Object)(object)podium == (Object)null)
		{
			return false;
		}
		int instanceID = ((Object)podium).GetInstanceID();
		if (_podiumOwnerSlotByInstanceId.TryGetValue(instanceID, out slot))
		{
			return true;
		}
		if (!TryInferPodiumOwnerSlotFromName(podium, out slot))
		{
			return false;
		}
		_podiumOwnerSlotByInstanceId[instanceID] = slot;
		Plugin.Log.LogInfo((object)$"[MP] Inferred podium owner slot {slot} from clone name '{((Object)podium).name}'");
		return true;
	}

	private static void RelaxPodiumAffinityFor3PlusPlayers(Interaction_WeaponSelectionPodium podium)
	{
		//IL_004c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0052: Expected O, but got Unknown
		if (!((Object)(object)podium == (Object)null) && PlayerFarming.players != null && PlayerFarming.players.Count > 2)
		{
			((Interaction)podium).LambOnly = false;
			((Interaction)podium).GoatOnly = false;
			Interaction_WeaponSelectionPodium val = null;
			try
			{
				object obj = _twinPodiumField?.GetValue(podium);
				val = (Interaction_WeaponSelectionPodium)((obj is Interaction_WeaponSelectionPodium) ? obj : null);
			}
			catch
			{
				val = null;
			}
			if ((Object)(object)val != (Object)null)
			{
				((Interaction)val).LambOnly = false;
				((Interaction)val).GoatOnly = false;
			}
		}
	}

	private static void EnsurePodiumCloneOwner(Interaction_WeaponSelectionPodium podium, int slot, PlayerFarming owner, bool forceInteractable)
	{
		if ((Object)(object)podium == (Object)null || slot < 2)
		{
			return;
		}
		FieldInfo field = typeof(Interaction).GetField("playerFarming", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		FieldInfo field2 = typeof(Interaction_WeaponSelectionPodium).GetField("activated", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field != null)
		{
			field.SetValue(podium, null);
		}
		else
		{
			((Interaction)podium).playerFarming = null;
		}
		((Interaction)podium).LambOnly = false;
		((Interaction)podium).GoatOnly = false;
		RelaxPodiumAffinityFor3PlusPlayers(podium);
		if (forceInteractable && !podium.WeaponTaken)
		{
			if (field2 != null)
			{
				field2.SetValue(podium, false);
			}
			((Interaction)podium).Interactable = true;
			((Interaction)podium).SecondaryInteractable = true;
			((Behaviour)podium).enabled = true;
			((Interaction)podium).HasChanged = true;
		}
	}

	private static IEnumerator DeferredEnsurePodiumOwner(Interaction_WeaponSelectionPodium podium, int slot)
	{
		float waited = 0f;
		while (waited < 3f && !((Object)(object)podium == (Object)null))
		{
			if (!((Component)podium).gameObject.activeInHierarchy)
			{
				yield return (object)new WaitForSeconds(0.1f);
				waited += 0.1f;
				continue;
			}
			PlayerFarming val = FindActivePlayerBySlot(slot);
			EnsurePodiumCloneOwner(podium, slot, val, forceInteractable: true);
			if (!((Object)(object)val != (Object)null))
			{
				yield return (object)new WaitForSeconds(0.1f);
				waited += 0.1f;
				continue;
			}
			break;
		}
	}

	public static void WeaponPodium_OnEnable_Postfix(Interaction_WeaponSelectionPodium __instance)
	{
		if (!((Object)(object)__instance == (Object)null))
		{
			RelaxPodiumAffinityFor3PlusPlayers(__instance);
			if (TryGetPodiumOwnerSlot(__instance, out var slot))
			{
				PlayerFarming owner = FindActivePlayerBySlot(slot);
				EnsurePodiumCloneOwner(__instance, slot, owner, forceInteractable: true);
			}
		}
	}

	public static bool WeaponPodium_OnInteract_Prefix(Interaction_WeaponSelectionPodium __instance, StateMachine state)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return true;
		}
		RelaxPodiumAffinityFor3PlusPlayers(__instance);
		if (!TryGetPodiumOwnerSlot(__instance, out var slot))
		{
			return true;
		}
		if ((Object)(object)state == (Object)null)
		{
			return true;
		}
		PlayerFarming component = ((Component)state).GetComponent<PlayerFarming>();
		if ((Object)(object)component == (Object)null)
		{
			return true;
		}
		EnsurePodiumCloneOwner(__instance, slot, component, forceInteractable: true);
		return true;
	}

	public static void WeaponPodium_OnInteract_Postfix(Interaction_WeaponSelectionPodium __instance, StateMachine state)
	{
		RelaxPodiumAffinityFor3PlusPlayers(__instance);
	}

	private static void SpawnExtraPodiumsOfType(Interaction_WeaponSelectionPodium sourcePodium, List<int> extraSlots, FieldInfo isCoopField, string podLabel)
	{
		//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_0176: 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_0199: 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_026c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0459: Unknown result type (might be due to invalid IL or missing references)
		if (extraSlots == null || extraSlots.Count == 0)
		{
			return;
		}
		FieldInfo field = typeof(Interaction).GetField("playerFarming", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		FieldInfo field2 = typeof(Interaction_WeaponSelectionPodium).GetField("Used", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		FieldInfo field3 = typeof(Interaction_WeaponSelectionPodium).GetField("activated", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		FieldInfo field4 = typeof(Interaction_WeaponSelectionPodium).GetField("<WeaponTaken>k__BackingField", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field5 = typeof(Interaction_WeaponSelectionPodium).GetField("CoopPodium", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field6 = typeof(Interaction_WeaponSelectionPodium).GetField("TwinPodium", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field7 = typeof(Interaction_WeaponSelectionPodium).GetField("initialDungeonEnter", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field8 = typeof(Interaction_WeaponSelectionPodium).GetField("coopInitialDungeonEnterSet", BindingFlags.Instance | BindingFlags.NonPublic);
		FieldInfo field9 = typeof(Interaction_WeaponSelectionPodium).GetField("otherWeaponOptions", BindingFlags.Instance | BindingFlags.NonPublic);
		Vector3 position = ((Component)sourcePodium).transform.position;
		int num = Mathf.Max(1, DataManager.StartingEquipmentLevel + 1);
		try
		{
			object obj = _podiumWeaponLevelField?.GetValue(sourcePodium);
			if (obj is int && (int)obj > 0)
			{
				num = (int)obj;
			}
		}
		catch
		{
		}
		int currentRunWeaponLevel = DataManager.Instance.CurrentRunWeaponLevel;
		int currentRunCurseLevel = DataManager.Instance.CurrentRunCurseLevel;
		foreach (int extraSlot in extraSlots)
		{
			int num2 = Mathf.Max(0, extraSlot - 2);
			int num3 = num2 % 3 - 1;
			int num4 = num2 / 3 + 1;
			Vector3 val = position + new Vector3((float)num3 * 1.45f, (float)num4 * 1.35f, 0f);
			if (!_podiumClones.TryGetValue(extraSlot, out var value))
			{
				value = new List<Interaction_WeaponSelectionPodium>();
				_podiumClones[extraSlot] = value;
			}
			for (int num5 = value.Count - 1; num5 >= 0; num5--)
			{
				Interaction_WeaponSelectionPodium val2 = value[num5];
				if ((Object)(object)val2 == (Object)null)
				{
					value.RemoveAt(num5);
				}
				else if (((Object)val2).name.StartsWith(podLabel + "Podium_", StringComparison.Ordinal))
				{
					_podiumOwnerSlotByInstanceId.Remove(((Object)val2).GetInstanceID());
					Object.Destroy((Object)(object)((Component)val2).gameObject);
					value.RemoveAt(num5);
				}
			}
			GameObject val3 = Object.Instantiate<GameObject>(((Component)sourcePodium).gameObject, ((Component)sourcePodium).transform.parent);
			val3.transform.position = val;
			val3.transform.rotation = ((Component)sourcePodium).transform.rotation;
			((Object)val3).name = $"{podLabel}Podium_P{extraSlot + 1}";
			Renderer[] componentsInChildren = val3.GetComponentsInChildren<Renderer>(true);
			for (int i = 0; i < componentsInChildren.Length; i++)
			{
				componentsInChildren[i].enabled = true;
			}
			Interaction_WeaponSelectionPodium component = val3.GetComponent<Interaction_WeaponSelectionPodium>();
			DataManager.Instance.CurrentRunWeaponLevel = currentRunWeaponLevel;
			DataManager.Instance.CurrentRunCurseLevel = currentRunCurseLevel;
			_podiumWeaponLevelField?.SetValue(component, num);
			_podiumIncreaseWeaponLevelField?.SetValue(component, false);
			isCoopField.SetValue(component, false);
			component.DestroyOtherWeaponInCoop = false;
			field?.SetValue(component, null);
			if (field2 != null)
			{
				field2.SetValue(component, false);
			}
			if (field3 != null)
			{
				field3.SetValue(component, false);
			}
			if (field4 != null)
			{
				field4.SetValue(component, false);
			}
			if (field5 != null)
			{
				field5.SetValue(component, null);
			}
			if (field6 != null)
			{
				field6.SetValue(component, null);
			}
			if (field7 != null)
			{
				field7.SetValue(component, false);
			}
			if (field8 != null)
			{
				field8.SetValue(component, false);
			}
			if (field9 != null)
			{
				field9.SetValue(component, new Interaction_WeaponSelectionPodium[0]);
			}
			((Interaction)component).LambOnly = false;
			((Interaction)component).GoatOnly = false;
			if (!component.WeaponTaken)
			{
				((Interaction)component).Interactable = true;
				((Interaction)component).SecondaryInteractable = true;
				((Behaviour)component).enabled = true;
			}
			((Interaction)component).HasChanged = true;
			value.Add(component);
			_podiumOwnerSlotByInstanceId[((Object)component).GetInstanceID()] = extraSlot;
			EnsurePodiumCloneOwner(component, extraSlot, null, forceInteractable: true);
			Plugin.Log.LogInfo((object)$"Extra {podLabel} podium P{extraSlot + 1} at {val} (free interact)");
		}
	}

	public static void ResetPodiumFlag()
	{
		_spawnedExtraWeaponPodiums = false;
		_spawnedExtraSpellPodiums = false;
		_podiumOwnerSlotByInstanceId.Clear();
	}

	public static void PositionAllPlayers_Postfix(Vector3 pos)
	{
		//IL_002a: 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 (CoopManager.CoopActive && PlayerFarming.players != null && PlayerFarming.players.Count > 2)
		{
			int token = ++_compactRoomEntryToken;
			ApplyCompactRoomEntryFormation(pos, snapOnlyOutliers: false, "PositionAllPlayers");
			if ((Object)(object)CoopManager.Instance != (Object)null)
			{
				((MonoBehaviour)CoopManager.Instance).StartCoroutine(CompactRoomEntryGuardRoutine(pos, token));
			}
		}
	}

	private static IEnumerator CompactRoomEntryGuardRoutine(Vector3 entryPosition, int token)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		for (int i = 0; i < 6; i++)
		{
			if (token != _compactRoomEntryToken)
			{
				break;
			}
			if (i > 0 && !MMTransition.IsPlaying)
			{
				break;
			}
			ApplyCompactRoomEntryFormation(entryPosition, snapOnlyOutliers: true, "RoomEntryGuard");
			yield return (object)new WaitForSecondsRealtime(0.2f);
		}
	}

	private static void ApplyCompactRoomEntryFormation(Vector3 entryPosition, bool snapOnlyOutliers, string reason)
	{
		//IL_006e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0075: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Unknown result type (might be due to invalid IL or missing references)
		//IL_007f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0086: Unknown result type (might be due to invalid IL or missing references)
		//IL_008b: Unknown result type (might be due to invalid IL or missing references)
		//IL_00a5: Unknown result type (might be due to invalid IL or missing references)
		if (PlayerFarming.players == null)
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)((Component)player).gameObject == (Object)null || !((Component)player).gameObject.activeInHierarchy)
			{
				continue;
			}
			int num = ((!player.isLamb) ? Mathf.Clamp(player.playerID, 1, SpawnOffsets.Length - 1) : 0);
			Vector3 position = entryPosition + SpawnOffsets[num];
			float num2 = Vector3.Distance(((Component)player).transform.position, entryPosition);
			if (!snapOnlyOutliers || !(num2 <= 2.1f))
			{
				((Component)player).transform.position = position;
				if (snapOnlyOutliers)
				{
					Plugin.Log.LogWarning((object)$"[MP] Recovered out-of-bounds room entry for playerID={player.playerID}, distance={num2:0.00} ({reason})");
				}
			}
		}
	}

	public static bool PositionAllPlayers_Prefix(Vector3 pos, bool increment)
	{
		//IL_0018: 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)
		LogDungeonRoomTypeIfChanged();
		if (_savedExtraSlotCount <= 0)
		{
			return true;
		}
		if (_positioningDeferred)
		{
			return true;
		}
		if (!GameManager.IsDungeon(PlayerFarming.Location))
		{
			return true;
		}
		int num = 1 + _savedExtraSlotCount + 1;
		if (PlayerFarming.playersCount >= num)
		{
			return true;
		}
		_positioningDeferred = true;
		Plugin.Log.LogInfo((object)$"PositionAllPlayers deferred — waiting for {num} players (have {PlayerFarming.playersCount})");
		if ((Object)(object)CoopManager.Instance != (Object)null)
		{
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(DeferredPositionAllPlayers(pos, increment, num));
		}
		return false;
	}

	private static PlayerFarming FindCanonicalLamb()
	{
		try
		{
			if (PlayerFarming.players != null)
			{
				foreach (PlayerFarming player in PlayerFarming.players)
				{
					if ((Object)(object)player != (Object)null && player.isLamb && (Object)(object)((Component)player).gameObject != (Object)null && ((Component)player).gameObject.activeInHierarchy)
					{
						return player;
					}
				}
			}
		}
		catch
		{
		}
		try
		{
			PlayerFarming instance = PlayerFarming.Instance;
			if ((Object)(object)instance != (Object)null && instance.isLamb)
			{
				return instance;
			}
		}
		catch
		{
		}
		return null;
	}

	public static bool Door_OnTriggerEnter2D_Prefix(Door __instance, ref Collider2D collision)
	{
		if (DoorTransitionVote.ShouldBlockDoorTrigger(__instance, collision))
		{
			return false;
		}
		if (!CoopManager.CoopActive || (Object)(object)collision == (Object)null)
		{
			return true;
		}
		try
		{
			PlayerFarming component = ((Component)collision).gameObject.GetComponent<PlayerFarming>();
			if ((Object)(object)component == (Object)null || component.isLamb || component.playerID < 2)
			{
				return true;
			}
			PlayerFarming val = FindCanonicalLamb();
			if ((Object)(object)val == (Object)null)
			{
				Plugin.Log.LogWarning((object)$"[MP] Could not route door trigger from playerID={component.playerID}: Lamb not found");
				return true;
			}
			Collider2D val2 = ((Component)val).GetComponent<Collider2D>();
			if ((Object)(object)val2 == (Object)null)
			{
				val2 = ((Component)val).GetComponentInChildren<Collider2D>(true);
			}
			if ((Object)(object)val2 != (Object)null)
			{
				collision = val2;
				Plugin.Log.LogInfo((object)$"[MP] Routed room door trigger from playerID={component.playerID} through Lamb");
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Door trigger routing failed: " + ex.Message));
		}
		return true;
	}

	public static bool EnterBuilding_OnTriggerEnter2D_Prefix(EnterBuilding __instance, Collider2D __0)
	{
		return !BuildingTransitionVote.ShouldBlockBuildingTrigger(__instance, __0);
	}

	public unsafe static void MMTransition_Play_Postfix(TransitionType transitionType)
	{
		//IL_0078: Unknown result type (might be due to invalid IL or missing references)
		//IL_007a: Invalid comparison between Unknown and I4
		if (CoopManager.CoopActive)
		{
			int num = CoopMenuOverlaySession.CloseAllForTransition();
			bool flag = false;
			if (CoopConversationSession.Active)
			{
				flag = CoopEmergencyEscape.TryForceCloseConversation("room transition");
				CoopConversationSession.EmergencyRecoverAll();
			}
			if (num > 0 || flag)
			{
				Plugin.Log.LogInfo((object)$"[QoL] Transition cleanup closed {num} personal menu(s) and conversation={flag}");
			}
		}
		if (CoopManager.CoopActive && !((Object)(object)CoopManager.Instance == (Object)null) && MMTransition.IsPlaying)
		{
			int token = ++_roomTransitionWatchdogToken;
			float timeoutSeconds = (((int)transitionType == 2) ? 12f : 60f);
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(RoomTransitionWatchdogRoutine(token, timeoutSeconds, ((object)(*(TransitionType*)(&transitionType))/*cast due to .constrained prefix*/).ToString()));
		}
	}

	public static Exception BiomeChangeRoomRoutine_Finalizer(Exception __exception)
	{
		if (__exception == null)
		{
			return null;
		}
		Plugin.Log.LogError((object)("[MP] Biome room change failed; scheduling transition recovery: " + __exception));
		QueueImmediateTransitionRecovery("Biome ChangeRoom exception");
		return null;
	}

	public static Exception MMTransitionChangeRoomRoutine_Finalizer(Exception __exception)
	{
		if (__exception == null)
		{
			return null;
		}
		Plugin.Log.LogError((object)("[MP] MMTransition room fade failed; recovering immediately: " + __exception));
		QueueImmediateTransitionRecovery("MMTransition ChangeRoom exception");
		return null;
	}

	private static void QueueImmediateTransitionRecovery(string reason)
	{
		int token = ++_roomTransitionWatchdogToken;
		if ((Object)(object)CoopManager.Instance != (Object)null)
		{
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(RoomTransitionWatchdogRoutine(token, 0.1f, reason));
			return;
		}
		try
		{
			MMTransition.ForceStopMMTransition();
		}
		catch
		{
		}
		Time.timeScale = 1f;
		SimulationManager.UnPause();
	}

	private static IEnumerator RoomTransitionWatchdogRoutine(int token, float timeoutSeconds, string reason)
	{
		yield return (object)new WaitForSecondsRealtime(timeoutSeconds);
		if (token != _roomTransitionWatchdogToken || !MMTransition.IsPlaying)
		{
			yield break;
		}
		Plugin.Log.LogWarning((object)$"[MP] Transition watchdog timed out after {timeoutSeconds:0.0}s ({reason}); attempting ResumePlay");
		try
		{
			MMTransition.ResumePlay();
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] ResumePlay recovery failed: " + ex.Message));
		}
		float waitUntil = Time.realtimeSinceStartup + 1.5f;
		while (token == _roomTransitionWatchdogToken && MMTransition.IsPlaying && Time.realtimeSinceStartup < waitUntil)
		{
			yield return null;
		}
		if (token != _roomTransitionWatchdogToken)
		{
			yield break;
		}
		if (MMTransition.IsPlaying)
		{
			try
			{
				MMTransition.ForceStopMMTransition();
			}
			catch (Exception ex2)
			{
				Plugin.Log.LogWarning((object)("[MP] ForceStopMMTransition recovery failed: " + ex2.Message));
			}
		}
		RecoverPlayersAfterStuckTransition(reason);
	}

	private static void RecoverPlayersAfterStuckTransition(string reason)
	{
		//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_00ba: Unknown result type (might be due to invalid IL or missing references)
		//IL_00be: Invalid comparison between Unknown and I4
		//IL_00c0: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c4: Invalid comparison between Unknown and I4
		//IL_0116: Unknown result type (might be due to invalid IL or missing references)
		//IL_0122: Unknown result type (might be due to invalid IL or missing references)
		//IL_0127: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
		//IL_00ca: Invalid comparison between Unknown and I4
		try
		{
			Time.timeScale = 1f;
			SimulationManager.UnPause();
			PlayerFarming.SetCollidersActive(true, false);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Transition recovery global reset failed: " + ex.Message));
		}
		PlayerFarming val = FindCanonicalLamb();
		if (PlayerFarming.players != null)
		{
			foreach (PlayerFarming player in PlayerFarming.players)
			{
				if ((Object)(object)player == (Object)null || (Object)(object)((Component)player).gameObject == (Object)null || !((Component)player).gameObject.activeInHierarchy)
				{
					continue;
				}
				try
				{
					if ((Object)(object)player.state != (Object)null)
					{
						player.state.LockStateChanges = false;
						State cURRENT_STATE = player.state.CURRENT_STATE;
						if (!IsLikelyLegitDownedState(player) && ((int)cURRENT_STATE == 13 || (int)cURRENT_STATE == 24 || (int)cURRENT_STATE == 49))
						{
							player.state.CURRENT_STATE = (State)0;
						}
					}
					if ((Object)(object)val != (Object)null && (Object)(object)player != (Object)(object)val && player.playerID >= 1)
					{
						int num = Mathf.Clamp(player.playerID, 1, SpawnOffsets.Length - 1);
						((Component)player).transform.position = ((Component)val).transform.position + SpawnOffsets[num];
					}
					if (!player.isLamb)
					{
						EnsureExtraSpawnStateUnlocked(player, "TransitionRecovery:" + reason);
					}
					if ((Object)(object)GameManager.GetInstance() != (Object)null && !GameManager.GetInstance().CameraContains(player.CameraBone))
					{
						GameManager.GetInstance().AddToCamera(player.CameraBone, 0.1f);
					}
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogWarning((object)$"[MP] Transition player recovery failed for playerID={player.playerID}: {ex2.Message}");
				}
			}
		}
		AggressiveControllerOwnershipHeartbeat("TransitionRecovery:" + reason);
		TryQueueDungeonRoomStabilize("TransitionRecovery:" + reason);
		Plugin.Log.LogWarning((object)("[MP] Transition watchdog recovered gameplay after: " + reason));
	}

	private static IEnumerator DeferredPositionAllPlayers(Vector3 pos, bool increment, int expectedTotal)
	{
		//IL_0007: Unknown result type (might be due to invalid IL or missing references)
		//IL_0008: Unknown result type (might be due to invalid IL or missing references)
		float waited = 0f;
		while (PlayerFarming.playersCount < expectedTotal && waited < 15f)
		{
			yield return (object)new WaitForSeconds(0.25f);
			waited += 0.25f;
		}
		Plugin.Log.LogInfo((object)$"DeferredPositionAllPlayers: proceeding with {PlayerFarming.playersCount} players after {waited:F1}s");
		_positioningDeferred = false;
		PlayerFarming.PositionAllPlayers(pos, increment);
	}

	private static void LogDungeonRoomTypeIfChanged()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (!GameManager.IsDungeon(PlayerFarming.Location) || (Object)(object)BiomeGenerator.Instance == (Object)null || BiomeGenerator.Instance.CurrentRoom == null)
			{
				return;
			}
			string text = BiomeGenerator.Instance.CurrentRoom.GameObjectPath ?? "null";
			if (!string.Equals(text, _lastLoggedDungeonRoomPath, StringComparison.Ordinal))
			{
				_lastLoggedDungeonRoomPath = text;
				string text2 = "other";
				if (text.IndexOf("Reward Room Tarot.prefab", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					text2 = "clauneck_tarot_room";
				}
				else if (text.IndexOf("Special Free Tarot Cards.prefab", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					text2 = "cards_only_tarot_room";
				}
				else if (text.IndexOf("Entrance Room Dungeon", StringComparison.OrdinalIgnoreCase) >= 0)
				{
					text2 = "dungeon_entrance_room";
				}
				Plugin.Log.LogInfo((object)("[MP] Dungeon room loaded: tag=" + text2 + " path='" + text + "'"));
			}
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[MP] Failed room-type log: " + ex.Message));
		}
	}

	private static string GetCurrentDungeonRoomPathSafe()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (!GameManager.IsDungeon(PlayerFarming.Location))
			{
				return null;
			}
			if ((Object)(object)BiomeGenerator.Instance == (Object)null || BiomeGenerator.Instance.CurrentRoom == null)
			{
				return null;
			}
			return BiomeGenerator.Instance.CurrentRoom.GameObjectPath;
		}
		catch
		{
			return null;
		}
	}

	private static bool IsCurrentDungeonEntranceRoom()
	{
		string currentDungeonRoomPathSafe = GetCurrentDungeonRoomPathSafe();
		if (!string.IsNullOrEmpty(currentDungeonRoomPathSafe))
		{
			return currentDungeonRoomPathSafe.IndexOf("Entrance Room Dungeon", StringComparison.OrdinalIgnoreCase) >= 0;
		}
		return false;
	}

	private static int GetCurrentDungeonRoomInstanceIdSafe()
	{
		//IL_0000: Unknown result type (might be due to invalid IL or missing references)
		try
		{
			if (!GameManager.IsDungeon(PlayerFarming.Location))
			{
				return int.MinValue;
			}
			if ((Object)(object)BiomeGenerator.Instance == (Object)null || BiomeGenerator.Instance.CurrentRoom == null)
			{
				return int.MinValue;
			}
			return ((object)BiomeGenerator.Instance.CurrentRoom).GetHashCode();
		}
		catch
		{
			return int.MinValue;
		}
	}

	private static void QueueInitialWeaponAutoEquip(int roomId)
	{
		if (roomId != int.MinValue && !((Object)(object)CoopManager.Instance == (Object)null) && !_initialWeaponAutoEquipRunning && _initialWeaponAutoEquipRoomId != roomId)
		{
			_initialWeaponAutoEquipRoomId = roomId;
			_initialWeaponAutoEquipRunning = true;
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(InitialWeaponAutoEquipRoutine(roomId));
			Plugin.Log.LogInfo((object)"[MP] Armed initial-room weapon/curse fallback for 20 seconds");
		}
	}

	private static IEnumerator InitialWeaponAutoEquipRoutine(int roomId)
	{
		int autoEquipped = 0;
		try
		{
			yield return (object)new WaitForSecondsRealtime(20f);
			int i = 0;
			while (true)
			{
				if (i < 21)
				{
					if (!CoopManager.CoopActive || !IsCurrentDungeonEntranceRoom() || GetCurrentDungeonRoomInstanceIdSafe() != roomId)
					{
						break;
					}
					autoEquipped += AutoEquipMissingInitialEquipment();
					bool flag = true;
					foreach (int desiredExtraSlot in _desiredExtraSlots)
					{
						if ((Object)(object)FindActivePlayerBySlot(desiredExtraSlot) == (Object)null)
						{
							flag = false;
							break;
						}
					}
					if (!flag || HasActivePlayerWithoutInitialEquipment())
					{
						yield return (object)new WaitForSecondsRealtime(0.5f);
						i++;
						continue;
					}
				}
				if (autoEquipped > 0)
				{
					TryOpenInitialWeaponRoomDoors();
					Plugin.Log.LogWarning((object)$"[MP] Initial-room fallback auto-equipped {autoEquipped} missing weapon/curse item(s)");
				}
				break;
			}
		}
		finally
		{
			_initialWeaponAutoEquipRunning = false;
		}
	}

	private static bool HasActivePlayerWithoutInitialEquipment()
	{
		//IL_0043: Unknown result type (might be due to invalid IL or missing references)
		//IL_004d: Invalid comparison between Unknown and I4
		//IL_0050: Unknown result type (might be due to invalid IL or missing references)
		//IL_005a: Invalid comparison between Unknown and I4
		if (PlayerFarming.players == null)
		{
			return false;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player != (Object)null && (Object)(object)((Component)player).gameObject != (Object)null && ((Component)player).gameObject.activeInHierarchy && ((int)player.currentWeapon == 9999 || (int)player.currentCurse == 9999))
			{
				return true;
			}
		}
		return false;
	}

	private static int AutoEquipMissingInitialEquipment()
	{
		//IL_00ff: Unknown result type (might be due to invalid IL or missing references)
		//IL_0109: Invalid comparison between Unknown and I4
		//IL_0134: Unknown result type (might be due to invalid IL or missing references)
		//IL_013e: Invalid comparison between Unknown and I4
		//IL_0158: 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_0051: Unknown result type (might be due to invalid IL or missing references)
		//IL_005b: Invalid comparison between Unknown and I4
		//IL_007a: 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_00c4: 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_0098: Invalid comparison between Unknown and I4
		//IL_009b: 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 (PlayerFarming.players == null)
		{
			return 0;
		}
		int num = 0;
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)((Component)player).gameObject == (Object)null || !((Component)player).gameObject.activeInHierarchy)
			{
				continue;
			}
			if ((int)player.currentWeapon == 9999 && (Object)(object)player.playerWeapon != (Object)null)
			{
				try
				{
					Interaction_WeaponSelectionPodium val = FindInitialPodiumForPlayer(player, wantWeapon: true);
					EquipmentType val2 = (EquipmentType)0;
					int initialPodiumEquipmentLevel = GetInitialPodiumEquipmentLevel(val);
					if ((Object)(object)val != (Object)null && (int)val.TypeOfWeapon != 9999)
					{
						val2 = val.TypeOfWeapon;
					}
					player.AbortGoTo(false);
					player.playerWeapon.SetWeapon(val2, initialPodiumEquipmentLevel);
					ReleaseInitialPodium(player, val);
					num++;
					LogInitialAutoEquip(player, val2, initialPodiumEquipmentLevel, "weapon");
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)$"[MP] Initial weapon auto-equip failed for playerID={player.playerID}: {ex.Message}");
				}
			}
			if ((int)player.currentCurse == 9999 && (Object)(object)player.playerSpells != (Object)null)
			{
				try
				{
					Interaction_WeaponSelectionPodium val3 = FindInitialPodiumForPlayer(player, wantWeapon: false);
					if ((Object)(object)val3 != (Object)null && (int)val3.TypeOfWeapon != 9999)
					{
						int initialPodiumEquipmentLevel2 = GetInitialPodiumEquipmentLevel(val3);
						player.AbortGoTo(false);
						player.playerSpells.SetSpell(val3.TypeOfWeapon, initialPodiumEquipmentLevel2);
						ReleaseInitialPodium(player, val3);
						num++;
						LogInitialAutoEquip(player, val3.TypeOfWeapon, initialPodiumEquipmentLevel2, "curse");
					}
				}
				catch (Exception ex2)
				{
					Plugin.Log.LogWarning((object)$"[MP] Initial curse auto-equip failed for playerID={player.playerID}: {ex2.Message}");
				}
			}
			if ((Object)(object)player.state != (Object)null && !IsLikelyLegitDownedState(player))
			{
				player.state.LockStateChanges = false;
				player.state.CURRENT_STATE = (State)0;
			}
		}
		return num;
	}

	private static Interaction_WeaponSelectionPodium FindInitialPodiumForPlayer(PlayerFarming player, bool wantWeapon)
	{
		//IL_0096: Unknown result type (might be due to invalid IL or missing references)
		//IL_009c: Invalid comparison between Unknown and I4
		//IL_0049: Unknown result type (might be due to invalid IL or missing references)
		//IL_004f: Invalid comparison between Unknown and I4
		if ((Object)(object)player != (Object)null && !player.isLamb && player.playerID >= 2 && _podiumClones.TryGetValue(player.playerID, out var value))
		{
			foreach (Interaction_WeaponSelectionPodium item in value)
			{
				if ((Object)(object)item != (Object)null && (int)item.Type == 1 == wantWeapon)
				{
					return item;
				}
			}
		}
		Interaction_WeaponSelectionPodium val = null;
		foreach (Interaction_WeaponSelectionPodium podium in Interaction_WeaponSelectionPodium.Podiums)
		{
			if (!((Object)(object)podium == (Object)null) && (int)podium.Type == 1 == wantWeapon)
			{
				if ((Object)(object)val == (Object)null)
				{
					val = podium;
				}
				if (!podium.WeaponTaken)
				{
					return podium;
				}
			}
		}
		return val;
	}

	private static int GetInitialPodiumEquipmentLevel(Interaction_WeaponSelectionPodium podium)
	{
		int result = Mathf.Max(1, DataManager.StartingEquipmentLevel + 1);
		try
		{
			object obj = (((Object)(object)podium == (Object)null) ? null : _podiumWeaponLevelField?.GetValue(podium));
			if (obj is int && (int)obj > 0)
			{
				result = (int)obj;
			}
		}
		catch
		{
		}
		return result;
	}

	private static void ReleaseInitialPodium(PlayerFarming player, Interaction_WeaponSelectionPodium podium)
	{
		if (!((Object)(object)podium == (Object)null))
		{
			((Interaction)podium).EndIndicateHighlighted(player);
			podium.SetWeaponInactive();
			if ((Object)(object)player.interactor != (Object)null && (Object)(object)player.interactor.CurrentInteraction == (Object)(object)podium)
			{
				player.interactor.CurrentInteraction = null;
			}
		}
	}

	private static void LogInitialAutoEquip(PlayerFarming player, EquipmentType equipment, int level, string kind)
	{
		//IL_002a: Unknown result type (might be due to invalid IL or missing references)
		int num = (player.isLamb ? 1 : (player.playerID + 1));
		Plugin.Log.LogWarning((object)$"[MP] Auto-equipped {kind} {equipment} level {level} for P{num} after initial-room timeout");
	}

	private static void TryOpenInitialWeaponRoomDoors()
	{
		foreach (Interaction_WeaponSelectionPodium podium in Interaction_WeaponSelectionPodium.Podiums)
		{
			if (!((Object)(object)podium == (Object)null))
			{
				try
				{
					_podiumTryToOpenDoorsMethod?.Invoke(podium, null);
					break;
				}
				catch (Exception ex)
				{
					Plugin.Log.LogWarning((object)("[MP] Initial weapon door refresh failed: " + ex.Message));
					break;
				}
			}
		}
	}

	private static void StabilizeGoatRoomEntryState(string reason)
	{
		//IL_0207: 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_0288: 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_029e: 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_0089: 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_0099: 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_010e: 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_017a: 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_018c: 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_01c0: 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_01d8: Invalid comparison between Unknown and I4
		//IL_01da: Unknown result type (might be due to invalid IL or missing references)
		//IL_01de: Invalid comparison between Unknown and I4
		//IL_01e0: Unknown result type (might be due to invalid IL or missing references)
		//IL_01e4: Invalid comparison between Unknown and I4
		//IL_01e6: Unknown result type (might be due to invalid IL or missing references)
		//IL_01ea: Invalid comparison between Unknown and I4
		if (PlayerFarming.players == null)
		{
			return;
		}
		PlayerFarming instance = PlayerFarming.Instance;
		if ((Object)(object)instance == (Object)null || (Object)(object)((Component)instance).gameObject == (Object)null || !((Component)instance).gameObject.activeInHierarchy)
		{
			return;
		}
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player == (Object)null || player.isLamb || (Object)(object)((Component)player).gameObject == (Object)null || !((Component)player).gameObject.activeInHierarchy)
			{
				continue;
			}
			Vector3 val = ((Component)player).transform.position - ((Component)instance).transform.position;
			float magnitude = ((Vector3)(ref val)).magnitude;
			bool flag = IsCurrentDungeonEntranceRoom();
			bool flag2 = IsReviveOrCutsceneFlowActive();
			if (flag)
			{
				if (IsFalseKnockedOutState(player))
				{
					EnsurePlayerAwakeAfterRespawn(player, "RoomEntry:" + reason + ".EntranceFalseDowned");
					EnsureExtraSpawnStateUnlocked(player, "RoomEntry:" + reason + ".EntranceFalseDowned");
				}
				continue;
			}
			bool num = Time.unscaledTime >= _roomEntryDistanceRepositionGraceUntil;
			bool flag3 = magnitude > 6f || Mathf.Abs(val.x) > 7.5f || val.y < -2.25f;
			flag3 = num && ((!flag) ? (magnitude > 7.5f || Mathf.Abs(val.x) > 8.75f || (val.y < -4.75f && magnitude > 5.5f)) : (magnitude > 10.5f || Mathf.Abs(val.x) > 12f || val.y < -4.5f));
			bool flag4 = false;
			if (!flag && !flag2)
			{
				try
				{
					if ((Object)(object)player.state != (Object)null)
					{
						State cURRENT_STATE = player.state.CURRENT_STATE;
						flag4 = player.state.LockStateChanges || (int)cURRENT_STATE == 13 || (int)cURRENT_STATE == 49 || (int)cURRENT_STATE == 24 || (int)cURRENT_STATE == 16;
					}
				}
				catch
				{
				}
			}
			bool flag5 = IsFalseKnockedOutState(player);
			bool flag6 = magnitude > 10.5f || Mathf.Abs(val.x) > 12f || (val.y < -6f && magnitude > 6.5f);
			if ((!flag3 || flag4 || flag5 || flag6) && (flag3 || flag4 || flag5))
			{
				int num2 = player.playerID;
				if (num2 < 1 || num2 >= SpawnOffsets.Length)
				{
					num2 = Mathf.Clamp(num2, 1, SpawnOffsets.Length - 1);
				}
				Vector3 position = ((Component)instance).transform.position + SpawnOffsets[num2];
				((Component)player).transform.position = position;
				EnsurePlayerAwakeAfterRespawn(player, "RoomEntry:" + reason);
				EnsureExtraSpawnStateUnlocked(player, "RoomEntry:" + reason);
				Plugin.Log.LogWarning((object)$"[MP] Room stabilize repositioned playerID={player.playerID} (dist={magnitude:0.00}, stuck={flag4}, falseDowned={flag5})");
			}
		}
	}

	private static void TryQueueDungeonRoomStabilize(string reason)
	{
		//IL_0014: Unknown result type (might be due to invalid IL or missing references)
		if (!CoopManager.CoopActive || (Object)(object)CoopManager.Instance == (Object)null || !GameManager.IsDungeon(PlayerFarming.Location) || Time.unscaledTime < _nextDungeonRoomStabilizeCheckAt)
		{
			return;
		}
		_nextDungeonRoomStabilizeCheckAt = Time.unscaledTime + 0.25f;
		int currentDungeonRoomInstanceIdSafe = GetCurrentDungeonRoomInstanceIdSafe();
		if (currentDungeonRoomInstanceIdSafe == int.MinValue || currentDungeonRoomInstanceIdSafe == _lastStabilizedDungeonRoomId || _dungeonRoomStabilizeRunning)
		{
			return;
		}
		if (IsCurrentDungeonEntranceRoom())
		{
			QueueInitialWeaponAutoEquip(currentDungeonRoomInstanceIdSafe);
			if (!_p2EntranceGuardRunning)
			{
				((MonoBehaviour)CoopManager.Instance).StartCoroutine(EnsureP2DungeonEntranceNotStuckRoutine());
			}
			_lastStabilizedDungeonRoomId = currentDungeonRoomInstanceIdSafe;
			_roomEntryDistanceRepositionGraceUntil = Time.unscaledTime + 2.5f;
		}
		else
		{
			_roomEntryDistanceRepositionGraceUntil = Time.unscaledTime + 0.65f;
			_lastStabilizedDungeonRoomId = currentDungeonRoomInstanceIdSafe;
			((MonoBehaviour)CoopManager.Instance).StartCoroutine(DungeonRoomTransitionStabilizeRoutine(currentDungeonRoomInstanceIdSafe, reason));
		}
	}

	private static IEnumerator DungeonRoomTransitionStabilizeRoutine(int roomId, string reason)
	{
		if (_dungeonRoomStabilizeRunning)
		{
			yield break;
		}
		_dungeonRoomStabilizeRunning = true;
		try
		{
			yield return (object)new WaitForSeconds(0.2f);
			for (int i = 0; i < 18; i++)
			{
				if ((Object)(object)CoopManager.Instance == (Object)null)
				{
					break;
				}
				if (!CoopManager.CoopActive)
				{
					break;
				}
				if (!GameManager.IsDungeon(PlayerFarming.Location))
				{
					break;
				}
				int currentDungeonRoomInstanceIdSafe = GetCurrentDungeonRoomInstanceIdSafe();
				if (currentDungeonRoomInstanceIdSafe == int.MinValue || currentDungeonRoomInstanceIdSafe == roomId)
				{
					ClearFalseKnockedOutStatesForAll("RoomStabilize:" + reason);
					EnsureAllExtraPlayersUnlocked("RoomStabilize:" + reason);
					if (i <= 4)
					{
						StabilizeGoatRoomEntryState($"{reason}.tick{i}");
					}
					if (i == 0 || i == 2 || i == 6 || i == 12)
					{
						AggressiveControllerOwnershipHeartbeat("RoomStabilize:" + reason);
						_nextAutoRespawnAttemptAt = 0f;
						TryAutoRespawnMissingExtraSlots($"RoomStabilize:{reason}.tick{i}");
					}
					yield return (object)new WaitForSeconds(0.2f);
					continue;
				}
				break;
			}
		}
		finally
		{
			_dungeonRoomStabilizeRunning = false;
		}
	}

	private static void ForceRefreshFaithAmmoUI(FaithAmmo faithAmmo, string reason)
	{
		if ((Object)(object)faithAmmo == (Object)null)
		{
			return;
		}
		try
		{
			if (_faithAmmoUpdateBar != null)
			{
				_faithAmmoUpdateBar.Invoke(faithAmmo, null);
			}
			else
			{
				faithAmmo.Ammo = faithAmmo.Ammo;
			}
		}
		catch
		{
			try
			{
				faithAmmo.Ammo = faithAmmo.Ammo;
			}
			catch (Exception ex)
			{
				Plugin.Log.LogWarning((object)("[MP] faithAmmo UI refresh failed (" + reason + "): " + ex.Message));
			}
		}
	}

	private static void SyncFaithAmmoForOwner(PlayerFarming owner, HUD_Hearts hearts, string reason, bool forceReinit)
	{
		if ((Object)(object)owner == (Object)null || (Object)(object)hearts == (Object)null || (Object)(object)hearts.faithAmmo == (Object)null)
		{
			return;
		}
		FaithAmmo faithAmmo = hearts.faithAmmo;
		bool flag = false;
		if ((Object)(object)hearts.playerFarming != (Object)(object)owner)
		{
			hearts.playerFarming = owner;
			flag = true;
		}
		if ((Object)(object)owner.hudHearts != (Object)(object)hearts)
		{
			owner.hudHearts = hearts;
			flag = true;
		}
		if ((Object)(object)faithAmmo.playerFarming != (Object)(object)owner)
		{
			faithAmmo.playerFarming = owner;
			flag = true;
		}
		if ((Object)(object)owner.playerSpells != (Object)null && (Object)(object)owner.playerSpells.faithAmmo != (Object)(object)faithAmmo)
		{
			owner.playerSpells.faithAmmo = faithAmmo;
			flag = true;
			Plugin.Log.LogInfo((object)$"[MP] Synced playerSpells.faithAmmo -> HUD faithAmmo for playerID={owner.playerID} ({reason})");
		}
		if (!forceReinit && !flag)
		{
			return;
		}
		try
		{
			faithAmmo.Init(owner);
			faithAmmo.Ammo = faithAmmo.Ammo;
			ForceRefreshFaithAmmoUI(faithAmmo, reason);
			Plugin.Log.LogInfo((object)$"[MP] Rebound faithAmmo for playerID={owner.playerID} ({reason})");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"[MP] faithAmmo sync failed playerID={owner.playerID} ({reason}): {ex.Message}");
		}
	}

	private static IEnumerator ReassignHudHeartsNextFrame(PlayerFarming p, HUD_Hearts hearts)
	{
		yield return null;
		if ((Object)(object)p != (Object)null && (Object)(object)hearts != (Object)null)
		{
			if ((Object)(object)hearts.playerFarming != (Object)(object)p)
			{
				hearts.playerFarming = p;
			}
			if ((Object)(object)p.hudHearts != (Object)(object)hearts)
			{
				p.hudHearts = hearts;
				Plugin.Log.LogInfo((object)$"[MP] Re-assigned hudHearts for playerID={p.playerID} after frame delay");
			}
		}
		yield return null;
		SyncFaithAmmoForOwner(p, hearts, "ReassignHudHeartsNextFrame", forceReinit: true);
	}

	public static bool HUDHearts_SetWeapon_Prefix(HUD_Hearts __instance, EquipmentType weapon, int level, PlayerFarming playerfarming)
	{
		if ((Object)(object)playerfarming == (Object)null)
		{
			return false;
		}
		if ((Object)(object)__instance == (Object)null)
		{
			return false;
		}
		if ((Object)(object)__instance.playerFarming != (Object)null && (Object)(object)__instance.playerFarming != (Object)(object)playerfarming)
		{
			return true;
		}
		FieldInfo field = typeof(HUD_Hearts).GetField("currentWeapon", BindingFlags.Instance | BindingFlags.Public);
		if (field == null)
		{
			return true;
		}
		if (field.GetValue(__instance) == null)
		{
			return false;
		}
		return true;
	}

	public static bool HUDHearts_SetCurse_Prefix(HUD_Hearts __instance, EquipmentType curse, int level, PlayerFarming playerfarming)
	{
		if ((Object)(object)playerfarming == (Object)null)
		{
			return false;
		}
		if ((Object)(object)__instance == (Object)null)
		{
			return false;
		}
		if ((Object)(object)__instance.playerFarming != (Object)null && (Object)(object)__instance.playerFarming != (Object)(object)playerfarming)
		{
			return true;
		}
		FieldInfo field = typeof(HUD_Hearts).GetField("currentCurse", BindingFlags.Instance | BindingFlags.Public);
		if (field == null)
		{
			return true;
		}
		if (field.GetValue(__instance) == null)
		{
			return false;
		}
		return true;
	}

	private static bool IsCanonicalHudHearts(HUD_Hearts hearts)
	{
		if ((Object)(object)hearts == (Object)null)
		{
			return false;
		}
		PlayerFarming playerFarming = hearts.playerFarming;
		if ((Object)(object)playerFarming == (Object)null || (Object)(object)((Component)playerFarming).gameObject == (Object)null)
		{
			return false;
		}
		if ((Object)(object)playerFarming.hudHearts == (Object)null)
		{
			return true;
		}
		return (Object)(object)playerFarming.hudHearts == (Object)(object)hearts;
	}

	private static bool ShouldSuppressHudHeartEffects(HUD_Heart heart)
	{
		if ((Object)(object)heart == (Object)null)
		{
			return false;
		}
		HUD_Hearts val = null;
		try
		{
			val = ((Component)heart).GetComponentInParent<HUD_Hearts>(true);
		}
		catch
		{
			val = null;
		}
		if ((Object)(object)val == (Object)null)
		{
			return false;
		}
		if (IsCanonicalHudHearts(val))
		{
			return false;
		}
		int instanceID = ((Object)heart).GetInstanceID();
		if (_suppressedHeartEffectLogs.Add(instanceID))
		{
			int num = (((Object)(object)val.playerFarming != (Object)null) ? val.playerFarming.playerID : (-1));
			Plugin.Log.LogWarning((object)$"[MP] Suppressing stale heart effect for ownerID={num}, heartInstance={instanceID}");
		}
		return true;
	}

	public static void HUDHeart_SetSprite_Prefix(HUD_Heart __instance, ref bool DoEffects)
	{
		if (DoEffects && ShouldSuppressHudHeartEffects(__instance))
		{
			DoEffects = false;
		}
	}

	public static void HUDHeart_Activate_Prefix(HUD_Heart __instance, ref bool DoEffects)
	{
		if (DoEffects && ShouldSuppressHudHeartEffects(__instance))
		{
			DoEffects = false;
		}
	}

	private static bool IsCanonicalFaithAmmo(FaithAmmo faithAmmo)
	{
		if ((Object)(object)faithAmmo == (Object)null)
		{
			return false;
		}
		HUD_Hearts val = null;
		try
		{
			val = ((Component)faithAmmo).GetComponentInParent<HUD_Hearts>(true);
		}
		catch
		{
			val = null;
		}
		if ((Object)(object)val == (Object)null)
		{
			return true;
		}
		if (!IsCanonicalHudHearts(val))
		{
			return false;
		}
		if ((Object)(object)val.faithAmmo != (Object)null && (Object)(object)val.faithAmmo != (Object)(object)faithAmmo)
		{
			return false;
		}
		if ((Object)(object)faithAmmo.playerFarming != (Object)null && (Object)(object)val.playerFarming != (Object)null && (Object)(object)faithAmmo.playerFarming != (Object)(object)val.playerFarming)
		{
			return false;
		}
		return true;
	}

	private static bool IsLiveFaithAmmoForOwner(FaithAmmo faithAmmo)
	{
		if ((Object)(object)faithAmmo == (Object)null || (Object)(object)faithAmmo.playerFarming == (Object)null)
		{
			return false;
		}
		PlayerFarming playerFarming = faithAmmo.playerFarming;
		if ((Object)(object)playerFarming.hudHearts != (Object)null && (Object)(object)playerFarming.hudHearts.faithAmmo == (Object)(object)faithAmmo)
		{
			return true;
		}
		if ((Object)(object)playerFarming.playerSpells != (Object)null && (Object)(object)playerFarming.playerSpells.faithAmmo == (Object)(object)faithAmmo)
		{
			return true;
		}
		return false;
	}

	private static void LogFaithAmmoSuppressed(FaithAmmo faithAmmo, string reason)
	{
		if (!((Object)(object)faithAmmo == (Object)null))
		{
			int instanceID = ((Object)faithAmmo).GetInstanceID();
			if (_suppressedFaithAmmoLogs.Add(instanceID))
			{
				int num = (((Object)(object)faithAmmo.playerFarming != (Object)null) ? faithAmmo.playerFarming.playerID : (-1));
				Plugin.Log.LogWarning((object)$"[MP] Suppressing stale faithAmmo ({reason}) for ownerID={num}, instance={instanceID}");
			}
		}
	}

	private static void LogTrinketHudSuppressed(HUD_ActiveTrinketsCoOp hud, string reason)
	{
		if (!((Object)(object)hud == (Object)null))
		{
			int instanceID = ((Object)hud).GetInstanceID();
			if (_suppressedTrinketHudLogs.Add(instanceID))
			{
				int num = (((Object)(object)hud.playerFarming != (Object)null) ? hud.playerFarming.playerID : (-1));
				Plugin.Log.LogWarning((object)$"[MP] Suppressing stale trinket HUD update ({reason}) for ownerID={num}, instance={instanceID}");
			}
		}
	}

	public static bool HUDActiveTrinketsCoOp_OnTrinketsChanged_Prefix(HUD_ActiveTrinketsCoOp __instance, ref PlayerFarming playerFarming)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return false;
		}
		PlayerFarming playerFarming2 = __instance.playerFarming;
		if ((Object)(object)playerFarming2 == (Object)null)
		{
			LogTrinketHudSuppressed(__instance, "OnTrinketsChanged.ownerNull");
			if ((Object)(object)__instance.CardPrefab != (Object)null && (Object)(object)((Component)__instance.CardPrefab).gameObject != (Object)null)
			{
				((Component)__instance.CardPrefab).gameObject.SetActive(false);
			}
			return false;
		}
		if ((Object)(object)playerFarming == (Object)null)
		{
			playerFarming = playerFarming2;
		}
		if ((Object)(object)playerFarming2 != (Object)(object)playerFarming)
		{
			return false;
		}
		if (playerFarming.RunTrinkets == null)
		{
			LogTrinketHudSuppressed(__instance, "OnTrinketsChanged.runTrinketsNull");
			if ((Object)(object)__instance.CardPrefab != (Object)null && (Object)(object)((Component)__instance.CardPrefab).gameObject != (Object)null)
			{
				((Component)__instance.CardPrefab).gameObject.SetActive(false);
			}
			return false;
		}
		return true;
	}

	public static bool HUDActiveTrinketsCoOp_OnRomanNumeralSettingChanged_Prefix(HUD_ActiveTrinketsCoOp __instance, bool state)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return false;
		}
		if ((Object)(object)__instance.playerFarming == (Object)null || __instance.playerFarming.RunTrinkets == null)
		{
			LogTrinketHudSuppressed(__instance, "OnRomanNumeralSettingChanged.ownerNull");
			return false;
		}
		if ((Object)(object)__instance.CardPrefab == (Object)null || (Object)(object)__instance.CardPrefab.CardQuantity == (Object)null)
		{
			LogTrinketHudSuppressed(__instance, "OnRomanNumeralSettingChanged.cardNull");
			return false;
		}
		return true;
	}

	public static bool FaithAmmo_OnEnable_Prefix(FaithAmmo __instance)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return false;
		}
		if (!IsCanonicalFaithAmmo(__instance) && !IsLiveFaithAmmoForOwner(__instance))
		{
			LogFaithAmmoSuppressed(__instance, "OnEnable");
			return false;
		}
		if ((Object)(object)__instance.playerFarming != (Object)null && (Object)(object)__instance.playerFarming.hudHearts != (Object)null)
		{
			SyncFaithAmmoForOwner(__instance.playerFarming, __instance.playerFarming.hudHearts, "FaithAmmo.OnEnable", forceReinit: false);
		}
		return true;
	}

	public static bool FaithAmmo_OnGetSoul_Prefix(FaithAmmo __instance, int DeltaValue, PlayerFarming playerFarming)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return false;
		}
		if (!IsCanonicalFaithAmmo(__instance) && !IsLiveFaithAmmoForOwner(__instance))
		{
			LogFaithAmmoSuppressed(__instance, "OnGetSoul");
			return false;
		}
		if ((Object)(object)__instance.playerFarming == (Object)null || (Object)(object)playerFarming == (Object)null)
		{
			return false;
		}
		return (Object)(object)__instance.playerFarming == (Object)(object)playerFarming;
	}

	public static bool FaithAmmo_UseAmmo_Prefix(FaithAmmo __instance, float Amount, bool curseAttack, ref bool __result)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			__result = false;
			return false;
		}
		if ((Object)(object)((Component)__instance).gameObject == (Object)null || !((Component)__instance).gameObject.activeInHierarchy || !((Behaviour)__instance).isActiveAndEnabled)
		{
			LogFaithAmmoSuppressed(__instance, "UseAmmo.inactive");
			__result = false;
			return false;
		}
		if (_reroutingFaithAmmoUse)
		{
			return true;
		}
		PlayerFarming playerFarming = __instance.playerFarming;
		if ((Object)(object)playerFarming == (Object)null)
		{
			return true;
		}
		FaithAmmo val = null;
		if ((Object)(object)playerFarming.hudHearts != (Object)null && (Object)(object)playerFarming.hudHearts.faithAmmo != (Object)null)
		{
			val = playerFarming.hudHearts.faithAmmo;
		}
		else if ((Object)(object)playerFarming.playerSpells != (Object)null && (Object)(object)playerFarming.playerSpells.faithAmmo != (Object)null)
		{
			val = playerFarming.playerSpells.faithAmmo;
		}
		if ((Object)(object)val == (Object)null)
		{
			if ((Object)(object)playerFarming.hudHearts != (Object)null)
			{
				SyncFaithAmmoForOwner(playerFarming, playerFarming.hudHearts, "FaithAmmo.UseAmmo.ResolveCanonical", forceReinit: true);
			}
			return true;
		}
		if ((Object)(object)__instance == (Object)(object)val)
		{
			return true;
		}
		LogFaithAmmoSuppressed(__instance, "UseAmmo");
		try
		{
			if ((Object)(object)((Component)val).gameObject == (Object)null || !((Component)val).gameObject.activeInHierarchy || !((Behaviour)val).isActiveAndEnabled)
			{
				LogFaithAmmoSuppressed(val, "UseAmmo.canonicalInactive");
				__result = false;
				return false;
			}
			_reroutingFaithAmmoUse = true;
			__result = val.UseAmmo(Amount, curseAttack);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)$"[MP] Failed rerouting UseAmmo to canonical faithAmmo for playerID={playerFarming.playerID}: {ex.Message}");
			__result = false;
		}
		finally
		{
			_reroutingFaithAmmoUse = false;
		}
		ForceRefreshFaithAmmoUI(val, "FaithAmmo.UseAmmo.Reroute");
		return false;
	}

	public static void FaithAmmo_UseAmmo_Postfix(FaithAmmo __instance)
	{
		if (!((Object)(object)__instance == (Object)null) && !_reroutingFaithAmmoUse)
		{
			ForceRefreshFaithAmmoUI(__instance, "FaithAmmo.UseAmmo.Postfix");
		}
	}

	public static bool HUDHearts_OnHPUpdated_Prefix(HUD_Hearts __instance, HealthPlayer Target)
	{
		if (!IsCanonicalHudHearts(__instance))
		{
			return false;
		}
		if ((Object)(object)__instance.playerFarming != (Object)null)
		{
			return (Object)(object)__instance.playerFarming.health == (Object)(object)Target;
		}
		return false;
	}

	public static bool HUDHearts_LowHealthCheck_Prefix(HUD_Hearts __instance)
	{
		if (!CoopManager.CoopActive || PlayerFarming.players == null || PlayerFarming.players.Count <= 1)
		{
			return true;
		}
		int num = 0;
		int num2 = 0;
		PlayerFarming val = null;
		foreach (PlayerFarming player in PlayerFarming.players)
		{
			if ((Object)(object)player == (Object)null || (Object)(object)((Component)player).gameObject == (Object)null || !((Component)player).gameObject.activeInHierarchy || (Object)(object)player.health == (Object)null)
			{
				continue;
			}
			num++;
			if (IsPlayerInVanillaLowHealthState(player))
			{
				num2++;
				if ((Object)(object)val == (Object)null)
				{
					val = player;
				}
			}
		}
		if (num <= 0 || num2 * 100 <= num * 51)
		{
			foreach (PlayerFarming player2 in PlayerFarming.players)
			{
				if ((Object)(object)player2 != (Object)null && (Object)(object)player2.hudHearts != (Object)null)
				{
					SilenceLowHealthAlert(player2.hudHearts);
				}
			}
			try
			{
				AudioManager.Instance.SetMusicFilter("filter", 0f);
			}
			catch
			{
			}
			return false;
		}
		if ((Object)(object)__instance == (Object)null || (Object)(object)val == (Object)null || (Object)(object)__instance.playerFarming != (Object)(object)val)
		{
			SilenceLowHealthAlert(__instance);
			return false;
		}
		return true;
	}

	private static bool IsPlayerInVanillaLowHealthState(PlayerFarming player)
	{
		if ((Object)(object)player == (Object)null || (Object)(object)player.health == (Object)null || DataManager.Instance.PlayerFleece == 7)
		{
			return false;
		}
		return ((int)player.health.PLAYER_HEALTH + (int)player.health.PLAYER_SPIRIT_HEARTS + (int)player.health.PLAYER_BLUE_HEARTS + (int)player.health.PLAYER_BLACK_HEARTS + (int)player.health.PLAYER_FIRE_HEARTS + (int)player.health.PLAYER_ICE_HEARTS) switch
		{
			2 => player.health.PLAYER_TOTAL_HEALTH != 2f, 
			1 => true, 
			_ => false, 
		};
	}

	private static void SilenceLowHealthAlert(HUD_Hearts hearts)
	{
		if ((Object)(object)hearts == (Object)null)
		{
			return;
		}
		try
		{
			((MonoBehaviour)hearts).StopAllCoroutines();
			hearts.StopLoopedSound();
			_hudHeartsCreatedLoopField?.SetValue(hearts, false);
		}
		catch
		{
		}
	}

	public static bool HUDHearts_OnTotalHPUpdated_Prefix(HUD_Hearts __instance, HealthPlayer Target)
	{
		if (!IsCanonicalHudHearts(__instance))
		{
			return false;
		}
		if ((Object)(object)__instance.playerFarming != (Object)null)
		{
			return (Object)(object)__instance.playerFarming.health == (Object)(object)Target;
		}
		return false;
	}

	public static bool HUDHearts_OnEnable_Prefix(HUD_Hearts __instance)
	{
		if ((Object)(object)__instance == (Object)null)
		{
			return false;
		}
		PlayerFarming playerFarming = __instance.playerFarming;
		if ((Object)(object)playerFarming == (Object)null)
		{
			return true;
		}
		if ((Object)(object)playerFarming.hudHearts != (Object)null && (Object)(object)playerFarming.hudHearts != (Object)(object)__instance)
		{
			TryClearHudHeartEvents(__instance);
			return false;
		}
		return true;
	}

	private static void TryClearHudHeartEvents(HUD_Hearts hearts)
	{
		if ((Object)(object)hearts == (Object)null || _hudHeartsClearHealthEvents == null)
		{
			return;
		}
		try
		{
			_hudHeartsClearHealthEvents.Invoke(hearts, null);
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("HealthManager: failed ClearHealthEvents invoke: " + ex.Message));
		}
	}

	public static bool HealthManager_Init(Health_Manager __instance, PlayerFarming p)
	{
		//IL_0015: 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_0085: Expected O, but got Unknown
		//IL_00bc: Unknown result type (might be due to invalid IL or missing references)
		//IL_00c3: Expected O, but got Unknown
		//IL_0199: 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_01a2: 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_01b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_01cb: 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)
		if (p.isLamb)
		{
			return true;
		}
		if (p.playerID < 2)
		{
			return true;
		}
		if (!GameManager.IsDungeon(PlayerFarming.Location))
		{
			return true;
		}
		FieldInfo field = typeof(Health_Manager).GetField("health_secondPlayer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		FieldInfo field2 = typeof(Health_Manager).GetField("healthDungeonTwoPlayer", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
		if (field == null)
		{
			Plugin.Log.LogWarning((object)"HealthManager: health_secondPlayer field not found");
			return true;
		}
		object value = field.GetValue(__instance);
		HUD_Hearts val = (HUD_Hearts)((value is HUD_Hearts) ? value : null);
		if ((Object)(object)val == (Object)null)
		{
			Plugin.Log.LogWarning((object)"HealthManager: p2Bar is null");
			return true;
		}
		object obj = field2?.GetValue(__instance);
		GameObject val2 = (GameObject)((obj is GameObject) ? obj : null);
		if ((Object)(object)val2 != (Object)null)
		{
			val2.SetActive(true);
		}
		if (_extraHeartBars.TryGetValue(p.playerID, out var value2) && (Object)(object)value2 != (Object)null)
		{
			Object.Destroy((Object)(object)value2);
			Plugin.Log.LogInfo((object)$"HealthManager: destroyed stale cached heart bar for playerID={p.playerID}");
		}
		_extraHeartBars.Remove(p.playerID);
		GameObject val3 = Object.Instantiate<GameObject>(((Component)val).gameObject, ((Component)val).transform.parent);
		((Object)val3).name = $"HUD_Hearts_P{p.playerID + 1}";
		val3.SetActive(false);
		int num = p.playerID - 2;
		RectTransform component = ((Component)val).GetComponent<RectTransform>();
		RectTransform component2 = val3.GetComponent<RectTransform>();
		if ((Object)(object)component != (Object)null && (Object)(object)component2 != (Object)null)
		{
			Vector2 anchoredPosition = component.anchoredPosition;
			Rect rect = component.rect;
			component2.anchoredPosition = anchoredPosition + new Vector2(0f, (0f - (((Rect)(ref rect)).height + 10f)) * (float)(num + 1));
		}
		_extraHeartBars[p.playerID] = val3;
		HUD_Hearts component3 = val3.GetComponent<HUD_Hearts>();
		if ((Object)(object)component3 != (Object)null)
		{
			TryClearHudHeartEvents(component3);
			component3.playerFarming = null;
			component3.InitDungeon(p);
			p.hudHearts = component3;
			val3.SetActive(true);
			SyncFaithAmmoForOwner(p, component3, $"HealthManager_Init(playerID={p.playerID})", forceReinit: true);
			Plugin.Log.LogInfo((object)$"HealthManager: spawned heart bar for playerID={p.playerID} at stack index {num}");
			HUD_Hearts hearts = component3;
			CoopManager instance = CoopManager.Instance;
			if ((Object)(object)instance != (Object)null)
			{
				((MonoBehaviour)instance).StartCoroutine(ReassignHudHeartsNextFrame(p, hearts));
			}
		}
		else
		{
			val3.SetActive(true);
			Plugin.Log.LogWarning((object)$"HealthManager: HUD_Hearts component not found on clone for playerID={p.playerID}");
		}
		return false;
	}

	public static IEnumerable<CodeInstruction> BiomeConstants_BiomeGenerator_OnBiomeChangeRoom_Transpiler(IEnumerable<CodeInstruction> instructions)
	{
		MethodInfo clearNoArgs = AccessTools.Method(typeof(ParticleSystem), "Clear", Type.EmptyTypes, (Type[])null);
		MethodInfo clearWithChildren = AccessTools.Method(typeof(ParticleSystem), "Clear", new Type[1] { typeof(bool) }, (Type[])null);
		MethodInfo safeNoArgs = AccessTools.Method(typeof(Patches), "SafeParticleClear_NoArgs", (Type[])null, (Type[])null);
		MethodInfo safeWithChildren = AccessTools.Method(typeof(Patches), "SafeParticleClear_WithChildren", (Type[])null, (Type[])null);
		int replacedNoArgs = 0;
		int replacedWithChildren = 0;
		foreach (CodeInstruction instruction in instructions)
		{
			if (clearNoArgs != null && CodeInstructionExtensions.Calls(instruction, clearNoArgs))
			{
				replacedNoArgs++;
				instruction.opcode = OpCodes.Call;
				instruction.operand = safeNoArgs;
			}
			else if (clearWithChildren != null && CodeInstructionExtensions.Calls(instruction, clearWithChildren))
			{
				replacedWithChildren++;
				instruction.opcode = OpCodes.Call;
				instruction.operand = safeWithChildren;
			}
			yield return instruction;
		}
		int num = replacedNoArgs + replacedWithChildren;
		if (_safeBiomeClearPatchCountLog != num)
		{
			_safeBiomeClearPatchCountLog = num;
			Plugin.Log.LogInfo((object)($"[MP] Safe biome particle-clear transpiler replaced {num} ParticleSystem.Clear call(s) " + $"(noArgs={replacedNoArgs}, withChildren={replacedWithChildren})"));
		}
	}

	private static void SafeParticleClear_NoArgs(ParticleSystem _)
	{
	}

	private static void SafeParticleClear_WithChildren(ParticleSystem _, bool __)
	{
	}

	public static Exception SilentFinalizer(Exception __exception)
	{
		return null;
	}

	private static Texture2D BuildNumberTexture(string label, int w = 32, int h = 32)
	{
		//IL_0004: Unknown result type (might be due to invalid IL or missing references)
		//IL_000a: Expected O, but got Unknown
		//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_0158: 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_00d6: 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)
		Texture2D val = new Texture2D(w, h, (TextureFormat)4, false);
		Color[] array = (Color[])(object)new Color[w * h];
		for (int i = 0; i < array.Length; i++)
		{
			array[i] = Color.clear;
		}
		if (_digitBitmaps.TryGetValue((label.Length > 0) ? label[0] : '?', out var value))
		{
			float num = ((float)w - 4f) / 5f;
			float num2 = ((float)h - 4f) / 7f;
			int num3 = 2;
			int num4 = 2;
			for (int j = 0; j < 7; j++)
			{
				for (int k = 0; k < 5; k++)
				{
					if (value[j * 5 + k] == 0)
					{
						continue;
					}
					for (int l = -2; l <= 2; l++)
					{
						for (int m = -2; m <= 2; m++)
						{
							int num5 = num3 + (int)((float)k * num) + m;
							int num6 = num4 + (int)((float)j * num2) + l;
							if (num5 >= 0 && num5 < w && num6 >= 0 && num6 < h)
							{
								array[num6 * w + num5] = Color.black;
							}
						}
					}
				}
			}
			for (int n = 0; n < 7; n++)
			{
				for (int num7 = 0; num7 < 5; num7++)
				{
					if (value[n * 5 + num7] != 0)
					{
						int num8 = num3 + (int)((float)num7 * num);
						int num9 = num4 + (int)((float)n * num2);
						if (num8 >= 0 && num8 < w && num9 >= 0 && num9 < h)
						{
							array[num9 * w + num8] = Color.white;
						}
					}
				}
			}
		}
		val.SetPixels(array);
		val.Apply();
		return val;
	}

	internal static Texture2D LoadPNG(string path)
	{
		//IL_02fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_0302: Unknown result type (might be due to invalid IL or missing references)
		//IL_0309: Unknown result type (might be due to invalid IL or missing references)
		//IL_0311: Unknown result type (might be due to invalid IL or missing references)
		//IL_0318: Expected O, but got Unknown
		//IL_02d2: Unknown result type (might be due to invalid IL or missing references)
		//IL_02d7: Unknown result type (might be due to invalid IL or missing references)
		byte[] array = File.ReadAllBytes(path);
		int num = (array[16] << 24) | (array[17] << 16) | (array[18] << 8) | array[19];
		int num2 = (array[20] << 24) | (array[21] << 16) | (array[22] << 8) | array[23];
		int num3 = array[24];
		int num4 = array[25];
		if (num3 != 8 || (num4 != 6 && num4 != 2))
		{
			Plugin.Log.LogWarning((object)$"[MP] PNG {path} unsupported format colorType={num4} bitDepth={num3}");
			return null;
		}
		bool flag = num4 == 6;
		int num5 = (flag ? 4 : 3);
		List<byte> list = new List<byte>();
		int num6;
		for (int i = 8; i < array.Length - 4; i += 12 + num6)
		{
			num6 = (array[i] << 24) | (array[i + 1] << 16) | (array[i + 2] << 8) | array[i + 3];
			if (Encoding.ASCII.GetString(array, i + 4, 4) == "IDAT")
			{
				for (int j = 0; j < num6; j++)
				{
					list.Add(array[i + 8 + j]);
				}
			}
		}
		byte[] array2 = list.ToArray();
		byte[] array3;
		using (MemoryStream stream = new MemoryStream(array2, 2, array2.Length - 2))
		{
			using DeflateStream deflateStream = new DeflateStream(stream, CompressionMode.Decompress);
			using MemoryStream memoryStream = new MemoryStream();
			deflateStream.CopyTo(memoryStream);
			array3 = memoryStream.ToArray();
		}
		Color[] array4 = (Color[])(object)new Color[num * num2];
		int num7 = num * num5 + 1;
		byte[] array5 = new byte[num * num5];
		for (int k = 0; k < num2; k++)
		{
			int num8 = k * num7;
			byte b = array3[num8];
			byte[] array6 = new byte[num * num5];
			for (int l = 0; l < num * num5; l++)
			{
				byte b2 = array3[num8 + 1 + l];
				byte b3 = (byte)((l >= num5) ? array6[l - num5] : 0);
				byte b4 = array5[l];
				byte c = (byte)((l >= num5) ? array5[l - num5] : 0);
				byte[] array7 = array6;
				int num9 = l;
				array7[num9] = b switch
				{
					1 => (byte)(b2 + b3), 
					2 => (byte)(b2 + b4), 
					3 => (byte)(b2 + (b3 + b4 >> 1)), 
					4 => (byte)(b2 + PaethPredictor(b3, b4, c)), 
					_ => b2, 
				};
			}
			int num10 = num2 - 1 - k;
			for (int m = 0; m < num; m++)
			{
				int num11 = m * num5;
				float num12 = (float)(int)array6[num11] / 255f;
				float num13 = (float)(int)array6[num11 + 1] / 255f;
				float num14 = (float)(int)array6[num11 + 2] / 255f;
				float num15 = (flag ? ((float)(int)array6[num11 + 3] / 255f) : 1f);
				array4[num10 * num + m] = new Color(num12, num13, num14, num15);
			}
			array5 = array6;
		}
		Texture2D val = new Texture2D(num, num2, (TextureFormat)4, false)
		{
			filterMode = (FilterMode)1
		};
		val.SetPixels(array4);
		val.Apply();
		return val;
	}

	private static byte PaethPredictor(byte a, byte b, byte c)
	{
		int num = a + b - c;
		int num2 = Math.Abs(num - a);
		int num3 = Math.Abs(num - b);
		int num4 = Math.Abs(num - c);
		if (num2 > num3 || num2 > num4)
		{
			if (num3 > num4)
			{
				return c;
			}
			return b;
		}
		return a;
	}
}
[BepInPlugin("com.cotlmp.multiplayerexpansion", "COTL Multiplayer Expansion 8P", "2.33.4")]
[BepInDependency(/*Could not decode attribute arguments.*/)]
[BepInDependency(/*Could not decode attribute arguments.*/)]
public class Plugin : BaseUnityPlugin
{
	public static ManualLogSource Log;

	public const int MAX_PLAYERS = 8;

	public static readonly Color[] GoatColors = (Color[])(object)new Color[8]
	{
		Color.white,
		Color.white,
		new Color(0.4f, 0.7f, 1f, 1f),
		new Color(1f, 0.4f, 0.4f, 1f),
		new Color(0.35f, 1f, 0.45f, 1f),
		new Color(1f, 0.85f, 0.25f, 1f),
		new Color(0.75f, 0.45f, 1f, 1f),
		new Color(0.25f, 1f, 1f, 1f)
	};

	public static readonly Color[] IndicatorColors = (Color[])(object)new Color[8]
	{
		new Color(0.9f, 0.2f, 0.2f, 1f),
		new Color(0.6f, 0.3f, 0.9f, 1f),
		new Color(1f, 0.6f, 0.1f, 1f),
		new Color(0.4f, 0.7f, 1f, 1f),
		new Color(0.2f, 0.9f, 0.3f, 1f),
		new Color(1f, 0.85f, 0.15f, 1f),
		new Color(0.15f, 0.9f, 1f, 1f),
		new Color(1f, 0.35f, 0.75f, 1f)
	};

	private void Awake()
	{
		//IL_001f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0025: Expected O, but got Unknown
		//IL_0053: Unknown result type (might be due to invalid IL or missing references)
		//IL_0060: Expected O, but got Unknown
		//IL_0089: Unknown result type (might be due to invalid IL or missing references)
		//IL_0096: Expected O, but got Unknown
		//IL_00be: Unknown result type (might be due to invalid IL or missing references)
		//IL_00cc: Expected O, but got Unknown
		//IL_00f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_0102: Expected O, but got Unknown
		//IL_012a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0138: Expected O, but got Unknown
		//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_0194: Expected O, but got Unknown
		//IL_0194: Expected O, but got Unknown
		//IL_01bd: 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_01de: Expected O, but got Unknown
		//IL_01de: Expected O, but got Unknown
		//IL_0211: 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_0233: Expected O, but got Unknown
		//IL_0233: Expected O, but got Unknown
		//IL_0287: 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_02a8: Expected O, but got Unknown
		//IL_02a8: Expected O, but got Unknown
		//IL_02fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_0312: Unknown result type (might be due to invalid IL or missing references)
		//IL_031d: Expected O, but got Unknown
		//IL_031d: Expected O, but got Unknown
		//IL_0360: 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_0382: Expected O, but got Unknown
		//IL_0382: Expected O, but got Unknown
		//IL_03ca: Unknown result type (might be due to invalid IL or missing references)
		//IL_03d8: Expected O, but got Unknown
		//IL_0401: Unknown result type (might be due to invalid IL or missing references)
		//IL_040e: Expected O, but got Unknown
		//IL_0449: Unknown result type (might be due to invalid IL or missing references)
		//IL_0456: Expected O, but got Unknown
		//IL_047e: Unknown result type (might be due to invalid IL or missing references)
		//IL_048c: Expected O, but got Unknown
		//IL_04b5: Unknown result type (might be due to invalid IL or missing references)
		//IL_04c2: Expected O, but got Unknown
		//IL_052f: Unknown result type (might be due to invalid IL or missing references)
		//IL_053c: Expected O, but got Unknown
		//IL_0565: Unknown result type (might be due to invalid IL or missing references)
		//IL_0572: Expected O, but got Unknown
		//IL_059b: Unknown result type (might be due to invalid IL or missing references)
		//IL_05a8: Expected O, but got Unknown
		//IL_05f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_05fd: Expected O, but got Unknown
		//IL_0625: Unknown result type (might be due to invalid IL or missing references)
		//IL_063a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0647: Expected O, but got Unknown
		//IL_0647: Expected O, but got Unknown
		//IL_0681: Unknown result type (might be due to invalid IL or missing references)
		//IL_068f: Expected O, but got Unknown
		//IL_06b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_06c5: Expected O, but got Unknown
		//IL_06ed: Unknown result type (might be due to invalid IL or missing references)
		//IL_0704: Unknown result type (might be due to invalid IL or missing references)
		//IL_070f: Expected O, but got Unknown
		//IL_070f: Expected O, but got Unknown
		//IL_0737: Unknown result type (might be due to invalid IL or missing references)
		//IL_074e: Unknown result type (might be due to invalid IL or missing references)
		//IL_0759: Expected O, but got Unknown
		//IL_0759: Expected O, but got Unknown
		//IL_0781: Unknown result type (might be due to invalid IL or missing references)
		//IL_0798: Unknown result type (might be due to invalid IL or missing references)
		//IL_07a3: Expected O, but got Unknown
		//IL_07a3: Expected O, but got Unknown
		//IL_07de: Unknown result type (might be due to invalid IL or missing references)
		//IL_07eb: Expected O, but got Unknown
		//IL_0816: Unknown result type (might be due to invalid IL or missing references)
		//IL_0821: Expected O, but got Unknown
		//IL_04f9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0506: Expected O, but got Unknown
		//IL_08ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_08c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_08cc: Expected O, but got Unknown
		//IL_08cc: Expected O, but got Unknown
		//IL_0906: Unknown result type (might be due to invalid IL or missing references)
		//IL_091c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0931: Unknown result type (might be due to invalid IL or missing references)
		//IL_093c: Expected O, but got Unknown
		//IL_093c: Expected O, but got Unknown
		//IL_093c: Expected O, but got Unknown
		//IL_0976: Unknown result type (might be due to invalid IL or missing references)
		//IL_098d: Unknown result type (might be due to invalid IL or missing references)
		//IL_0998: Expected O, but got Unknown
		//IL_0998: Expected O, but got Unknown
		//IL_09cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_09e3: Unknown result type (might be due to invalid IL or missing references)
		//IL_09ee: Expected O, but got Unknown
		//IL_09ee: Expected O, but got Unknown
		//IL_0868: Unknown result type (might be due to invalid IL or missing references)
		//IL_0873: Expected O, but got Unknown
		//IL_0a42: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a59: Unknown result type (might be due to invalid IL or missing references)
		//IL_0a64: Expected O, but got Unknown
		//IL_0a64: Expected O, but got Unknown
		//IL_0ab8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ace: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ae3: Unknown result type (might be due to invalid IL or missing references)
		//IL_0aee: Expected O, but got Unknown
		//IL_0aee: Expected O, but got Unknown
		//IL_0aee: Expected O, but got Unknown
		//IL_0b42: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b59: Unknown result type (might be due to invalid IL or missing references)
		//IL_0b64: Expected O, but got Unknown
		//IL_0b64: Expected O, but got Unknown
		//IL_0bb8: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bcf: Unknown result type (might be due to invalid IL or missing references)
		//IL_0bda: Expected O, but got Unknown
		//IL_0bda: Expected O, but got Unknown
		//IL_0c32: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c47: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c52: Expected O, but got Unknown
		//IL_0c52: Expected O, but got Unknown
		//IL_0c8a: Unknown result type (might be due to invalid IL or missing references)
		//IL_0c9f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0caa: Expected O, but got Unknown
		//IL_0caa: Expected O, but got Unknown
		//IL_0ce2: Unknown result type (might be due to invalid IL or missing references)
		//IL_0cf7: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d02: Expected O, but got Unknown
		//IL_0d02: Expected O, but got Unknown
		//IL_0d48: Unknown result type (might be due to invalid IL or missing references)
		//IL_0d53: Expected O, but got Unknown
		//IL_0df9: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e06: Expected O, but got Unknown
		//IL_0e4c: Unknown result type (might be due to invalid IL or missing references)
		//IL_0e57: Expected O, but got Unknown
		//IL_0eae: Unknown result type (might be due to invalid IL or missing references)
		//IL_0ebc: Expected O, but got Unknown
		//IL_0f58: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f6f: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f7a: Expected O, but got Unknown
		//IL_0f7a: Expected O, but got Unknown
		//IL_0fc1: Unknown result type (might be due to invalid IL or missing references)
		//IL_0fcf: Expected O, but got Unknown
		//IL_1009: Unknown result type (might be due to invalid IL or missing references)
		//IL_1020: Unknown result type (might be due to invalid IL or missing references)
		//IL_102b: Expected O, but got Unknown
		//IL_102b: Expected O, but got Unknown
		//IL_1053: Unknown result type (might be due to invalid IL or missing references)
		//IL_1069: Unknown result type (might be due to invalid IL or missing references)
		//IL_107e: Unknown result type (might be due to invalid IL or missing references)
		//IL_1089: Expected O, but got Unknown
		//IL_1089: Expected O, but got Unknown
		//IL_1089: Expected O, but got Unknown
		//IL_10c3: Unknown result type (might be due to invalid IL or missing references)
		//IL_10d1: Expected O, but got Unknown
		//IL_0f13: Unknown result type (might be due to invalid IL or missing references)
		//IL_0f21: Expected O, but got Unknown
		//IL_1105: Unknown result type (might be due to invalid IL or missing references)
		//IL_111b: Unknown result type (might be due to invalid IL or missing references)
		//IL_1130: Unknown result type (might be due to invalid IL or missing references)
		//IL_113b: Expected O, but got Unknown
		//IL_113b: Expected O, but got Unknown
		//IL_113b: Expected O, but got Unknown
		//IL_1195: Unknown result type (might be due to invalid IL or missing references)
		//IL_11ac: Unknown result type (might be due to invalid IL or missing references)
		//IL_11b7: Expected O, but got Unknown
		//IL_11b7: Expected O, but got Unknown
		//IL_11df: Unknown result type (might be due to invalid IL or missing references)
		//IL_11f5: Unknown result type (might be due to invalid IL or missing references)
		//IL_120a: Unknown result type (might be due to invalid IL or missing references)
		//IL_1215: Expected O, but got Unknown
		//IL_1215: Expected O, but got Unknown
		//IL_1215: Expected O, but got Unknown
		//IL_1249: Unknown result type (might be due to invalid IL or missing references)
		//IL_125f: Unknown result type (might be due to invalid IL or missing references)
		//IL_1274: Unknown result type (might be due to invalid IL or missing references)
		//IL_127f: Expected O, but got Unknown
		//IL_127f: Expected O, but got Unknown
		//IL_127f: Expected O, but got Unknown
		//IL_12d9: Unknown result type (might be due to invalid IL or missing references)
		//IL_12f0: Unknown result type (might be due to invalid IL or missing references)
		//IL_12fb: Expected O, but got Unknown
		//IL_12fb: Expected O, but got Unknown
		//IL_1323: Unknown result type (might be due to invalid IL or missing references)
		//IL_1339: Unknown result type (might be due to invalid IL or missing references)
		//IL_134e: Unknown result type (might be due to invalid IL or missing references)
		//IL_1359: Expected O, but got Unknown
		//IL_1359: Expected O, but got Unknown
		//IL_1359: Expected O, but got Unknown
		//IL_138d: Unknown result type (might be due to invalid IL or missing references)
		//IL_13a3: Unknown result type (might be due to invalid IL or missing references)
		//IL_13b8: Unknown result type (might be due to invalid IL or missing references)
		//IL_13c3: Expected O, but got Unknown
		//IL_13c3: Expected O, but got Unknown
		//IL_13c3: Expected O, but got Unknown
		//IL_141d: Unknown result type (might be due to invalid IL or missing references)
		//IL_1434: Unknown result type (might be due to invalid IL or missing references)
		//IL_143f: Expected O, but got Unknown
		//IL_143f: Expected O, but got Unknown
		//IL_1467: Unknown result type (might be due to invalid IL or missing references)
		//IL_147d: Unknown result type (might be due to invalid IL or missing references)
		//IL_1492: Unknown result type (might be due to invalid IL or missing references)
		//IL_149d: Expected O, but got Unknown
		//IL_149d: Expected O, but got Unknown
		//IL_149d: Expected O, but got Unknown
		//IL_14d1: Unknown result type (might be due to invalid IL or missing references)
		//IL_14e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_14fc: Unknown result type (might be due to invalid IL or missing references)
		//IL_1507: Expected O, but got Unknown
		//IL_1507: Expected O, but got Unknown
		//IL_1507: Expected O, but got Unknown
		//IL_1561: Unknown result type (might be due to invalid IL or missing references)
		//IL_1578: Unknown result type (might be due to invalid IL or missing references)
		//IL_1583: Expected O, but got Unknown
		//IL_1583: Expected O, but got Unknown
		//IL_15ab: Unknown result type (might be due to invalid IL or missing references)
		//IL_15c1: Unknown result type (might be due to invalid IL or missing references)
		//IL_15d6: Unknown result type (might be due to invalid IL or missing references)
		//IL_15e1: Expected O, but got Unknown
		//IL_15e1: Expected O, but got Unknown
		//IL_15e1: Expected O, but got Unknown
		//IL_1615: Unknown result type (might be due to invalid IL or missing references)
		//IL_162b: Unknown result type (might be due to invalid IL or missing references)
		//IL_1640: Unknown result type (might be due to invalid IL or missing references)
		//IL_164b: Expected O, but got Unknown
		//IL_164b: Expected O, but got Unknown
		//IL_164b: Expected O, but got Unknown
		//IL_1782: Unknown result type (might be due to invalid IL or missing references)
		//IL_178e: Expected O, but got Unknown
		//IL_17b2: Unknown result type (might be due to invalid IL or missing references)
		//IL_17c8: Unknown result type (might be due to invalid IL or missing references)
		//IL_17d4: Expected O, but got Unknown
		//IL_17d4: Expected O, but got Unknown
		//IL_17fa: Unknown result type (might be due to invalid IL or missing references)
		//IL_1806: Expected O, but got Unknown
		//IL_1871: Unknown result type (might be due to invalid IL or missing references)
		//IL_187d: Expected O, but got Unknown
		//IL_18bb: Unknown result type (might be due to invalid IL or missing references)
		//IL_18c9: Expected O, but got Unknown
		//IL_18e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_18f5: Expected O, but got Unknown
		//IL_1913: Unknown result type (might be due to invalid IL or missing references)
		//IL_1921: Expected O, but got Unknown
		//IL_193f: Unknown result type (might be due to invalid IL or missing references)
		//IL_194d: Expected O, but got Unknown
		//IL_19b0: Unknown result type (might be due to invalid IL or missing references)
		//IL_19be: Expected O, but got Unknown
		//IL_19e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_19f4: Expected O, but got Unknown
		//IL_1a2f: Unknown result type (might be due to invalid IL or missing references)
		//IL_1a3c: Expected O, but got Unknown
		//IL_1a69: Unknown result type (might be due to invalid IL or missing references)
		//IL_1a76: Expected O, but got Unknown
		//IL_1ae5: Unknown result type (might be due to invalid IL or missing references)
		//IL_1af2: Expected O, but got Unknown
		//IL_196b: Unknown result type (might be due to invalid IL or missing references)
		//IL_1979: Expected O, but got Unknown
		//IL_1b4a: Unknown result type (might be due to invalid IL or missing references)
		//IL_1b5f: Unknown result type (might be due to invalid IL or missing references)
		//IL_1b6c: Expected O, but got Unknown
		//IL_1b6c: Expected O, but got Unknown
		//IL_1bb8: Unknown result type (might be due to invalid IL or missing references)
		//IL_1bc5: Expected O, but got Unknown
		//IL_1c00: Unknown result type (might be due to invalid IL or missing references)
		//IL_1c0d: Expected O, but got Unknown
		//IL_1c3a: Unknown result type (might be due to invalid IL or missing references)
		//IL_1c47: Expected O, but got Unknown
		//IL_1c81: Unknown result type (might be due to invalid IL or missing references)
		//IL_1c96: Unknown result type (might be due to invalid IL or missing references)
		//IL_1ca3: Expected O, but got Unknown
		//IL_1ca3: Expected O, but got Unknown
		//IL_1ccb: Unknown result type (might be due to invalid IL or missing references)
		//IL_1cd9: Expected O, but got Unknown
		//IL_1d02: Unknown result type (might be due to invalid IL or missing references)
		//IL_1d0f: Expected O, but got Unknown
		//IL_1d37: Unknown result type (might be due to invalid IL or missing references)
		//IL_1d45: Expected O, but got Unknown
		//IL_1d6d: Unknown result type (might be due to invalid IL or missing references)
		//IL_1d7b: Expected O, but got Unknown
		//IL_1da3: Unknown result type (might be due to invalid IL or missing references)
		//IL_1db1: Expected O, but got Unknown
		//IL_1dd9: Unknown result type (might be due to invalid IL or missing references)
		//IL_1de7: Expected O, but got Unknown
		//IL_1e21: Unknown result type (might be due to invalid IL or missing references)
		//IL_1e2f: Expected O, but got Unknown
		//IL_1eb1: Unknown result type (might be due to invalid IL or missing references)
		//IL_1ebf: Expected O, but got Unknown
		//IL_1ee7: Unknown result type (might be due to invalid IL or missing references)
		//IL_1ef5: Expected O, but got Unknown
		//IL_1f49: Unknown result type (might be due to invalid IL or missing references)
		//IL_1f57: Expected O, but got Unknown
		//IL_1f9e: Unknown result type (might be due to invalid IL or missing references)
		//IL_1fac: Expected O, but got Unknown
		//IL_1fd4: Unknown result type (might be due to invalid IL or missing references)
		//IL_1fe2: Expected O, but got Unknown
		//IL_2029: Unknown result type (might be due to invalid IL or missing references)
		//IL_2037: Expected O, but got Unknown
		//IL_207e: Unknown result type (might be due to invalid IL or missing references)
		//IL_2093: Unknown result type (might be due to invalid IL or missing references)
		//IL_20a0: Expected O, but got Unknown
		//IL_20a0: Expected O, but got Unknown
		//IL_20da: Unknown result type (might be due to invalid IL or missing references)
		//IL_20f1: Unknown result type (might be due to invalid IL or missing references)
		//IL_20fc: Expected O, but got Unknown
		//IL_20fc: Expected O, but got Unknown
		//IL_2136: Unknown result type (might be due to invalid IL or missing references)
		//IL_214d: Unknown result type (might be due to invalid IL or missing references)
		//IL_2158: Expected O, but got Unknown
		//IL_2158: Expected O, but got Unknown
		//IL_2192: Unknown result type (might be due to invalid IL or missing references)
		//IL_21a0: Expected O, but got Unknown
		//IL_21da: Unknown result type (might be due to invalid IL or missing references)
		//IL_21e8: Expected O, but got Unknown
		//IL_2214: Unknown result type (might be due to invalid IL or missing references)
		//IL_2222: Expected O, but got Unknown
		//IL_225c: Unknown result type (might be due to invalid IL or missing references)
		//IL_226a: Expected O, but got Unknown
		//IL_1e69: Unknown result type (might be due to invalid IL or missing references)
		//IL_1e77: Expected O, but got Unknown
		//IL_231d: Unknown result type (might be due to invalid IL or missing references)
		//IL_232a: Expected O, but got Unknown
		//IL_2353: Unknown result type (might be due to invalid IL or missing references)
		//IL_2360: Expected O, but got Unknown
		//IL_23a8: Unknown result type (might be due to invalid IL or missing references)
		//IL_23b5: Expected O, but got Unknown
		//IL_23fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_240a: Expected O, but got Unknown
		//IL_2452: Unknown result type (might be due to invalid IL or missing references)
		//IL_245f: Expected O, but got Unknown
		//IL_24a6: Unknown result type (might be due to invalid IL or missing references)
		//IL_24b4: Expected O, but got Unknown
		//IL_22e7: Unknown result type (might be due to invalid IL or missing references)
		//IL_22f4: Expected O, but got Unknown
		//IL_24fd: Unknown result type (might be due to invalid IL or missing references)
		//IL_250a: Expected O, but got Unknown
		//IL_253f: Unknown result type (might be due to invalid IL or missing references)
		//IL_254c: Expected O, but got Unknown
		//IL_2594: Unknown result type (might be due to invalid IL or missing references)
		//IL_25a2: Expected O, but got Unknown
		//IL_2607: Unknown result type (might be due to invalid IL or missing references)
		//IL_2612: Expected O, but got Unknown
		//IL_265a: Unknown result type (might be due to invalid IL or missing references)
		//IL_266f: Unknown result type (might be due to invalid IL or missing references)
		//IL_267c: Expected O, but got Unknown
		//IL_267c: Expected O, but got Unknown
		//IL_2729: Unknown result type (might be due to invalid IL or missing references)
		//IL_2736: Expected O, but got Unknown
		//IL_2797: Unknown result type (might be due to invalid IL or missing references)
		//IL_27a5: Expected O, but got Unknown
		//IL_27ec: Unknown result type (might be due to invalid IL or missing references)
		//IL_27fa: Expected O, but got Unknown
		//IL_2841: Unknown result type (might be due to invalid IL or missing references)
		//IL_284f: Expected O, but got Unknown
		//IL_26de: Unknown result type (might be due to invalid IL or missing references)
		//IL_26f3: Unknown result type (might be due to invalid IL or missing references)
		//IL_2700: Expected O, but got Unknown
		//IL_2700: Expected O, but got Unknown
		//IL_28f4: Unknown result type (might be due to invalid IL or missing references)
		//IL_2902: Expected O, but got Unknown
		//IL_292f: Unknown result type (might be due to invalid IL or missing references)
		//IL_293c: Expected O, but got Unknown
		//IL_2974: Unknown result type (might be due to invalid IL or missing references)
		//IL_2981: Expected O, but got Unknown
		//IL_28be: Unknown result type (might be due to invalid IL or missing references)
		//IL_28cc: Expected O, but got Unknown
		//IL_29b7: Unknown result type (might be due to invalid IL or missing references)
		//IL_29cc: Unknown result type (might be due to invalid IL or missing references)
		//IL_29d9: Expected O, but got Unknown
		//IL_29d9: Expected O, but got Unknown
		Log = ((BaseUnityPlugin)this).Logger;
		Log.LogInfo((object)"COTL Multiplayer Expansion 8P TEST8.17 Stable Dialogue Camera and Transition Menu Cleanup loading...");
		Harmony val = new Harmony("com.cotlmp.multiplayerexpansion");
		Patches.RegisterRewiredPlayerExpansionPatch(val);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "Awake", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "CoopManager_Awake", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "OnControllerConnected", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "OnControllerConnected", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "AddPlayerFromMenu", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "AddPlayerFromMenu", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(UICoopAssignController), "ConfirmSpawnButtonPress", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "ConfirmSpawnButtonPress", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "RemovePlayerFromMenu", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "RemovePlayerFromMenu", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_TempleAltar), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltar_OnInteract_Postfix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltar_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_TempleAltar), "DoCancel", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltar_DoCancel_Postfix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltar_Finalizer", (Type[])null), (HarmonyMethod)null);
		MethodInfo method = typeof(Interaction_TempleAltar).GetMethod("TryOnboardSin", BindingFlags.Instance | BindingFlags.NonPublic);
		if (method != null)
		{
			val.Patch((MethodBase)method, new HarmonyMethod(typeof(Patches), "TempleAltar_TryOnboardSin_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltar_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_TempleAltar.TryOnboardSin coop-safe guard");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_TempleAltar.TryOnboardSin not found");
		}
		MethodInfo methodInfo = AccessTools.Method(typeof(Interaction_TempleAltar), "<DoCancel>b__68_1", (Type[])null, (Type[])null);
		if (methodInfo != null)
		{
			val.Patch((MethodBase)methodInfo, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltar_CancelCleanup_Postfix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltar_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_TempleAltar.DoCancel cleanup callback finalizer");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_TempleAltar.DoCancel cleanup callback not found");
		}
		MethodInfo methodInfo2 = AccessTools.Method(typeof(Interaction_TempleAltar), "<DoCancel>b__68_0", (Type[])null, (Type[])null);
		if (methodInfo2 != null)
		{
			val.Patch((MethodBase)methodInfo2, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltar_CancelCleanup_Postfix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltar_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_TempleAltar.DoCancel main cleanup recovery");
		}
		MethodInfo methodInfo3 = Patches.FindNestedMoveNext(typeof(Interaction_TempleAltar), "DelayMenu");
		if (methodInfo3 != null)
		{
			val.Patch((MethodBase)methodInfo3, new HarmonyMethod(typeof(Patches), "TempleAltarTwoPlayerScope_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TempleAltarTwoPlayerScope_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_TempleAltar.DelayMenu player presentation scope");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_TempleAltar.DelayMenu MoveNext not found");
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(PlayerFarming), "OnEnable", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerFarming_OnEnable_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "SpawnCoopPlayer", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "SpawnCoopPlayer_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(PlayerFarming), "SetSkin", new Type[1] { typeof(bool) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "SetSkin_Recolor", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(UIPauseMenuController), "OnCoopButtonPressed", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "OnCoopButtonPressed", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(UIPauseMenuController), "RefreshCoopText", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "RefreshCoopText", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo methodInfo4 = AccessTools.Method(typeof(UIPauseMenuController), "Start", (Type[])null, (Type[])null);
		if (methodInfo4 != null)
		{
			val.Patch((MethodBase)methodInfo4, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PauseMenu_Start_Difficulty_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_Manager), "Update", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "HUD_Update", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "RefreshCoopPlayerRewired", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "RefreshCoopPlayerRewired", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(PlayerFarming), "RefreshPlayersCount", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "RefreshPlayersCount_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(PlayerFarming), "PositionAllPlayers", new Type[2]
		{
			typeof(Vector3),
			typeof(bool)
		}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PositionAllPlayers_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopIndicatorIcon), "SetUsername", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "SetUsername_Prefix", (Type[])null), new HarmonyMethod(typeof(Patches), "SetUsername_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopIndicatorIcon), "AnimateDamageOnIcons", new Type[1] { typeof(PlayerFarming) }, (Type[])null), new HarmonyMethod(typeof(Patches), "CoopIndicatorIcon_AnimateDamageOnIcons_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(PlayerFarming), "Update", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerFarming_Update_Camera", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_DLCShrine), "Update", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "DLCShrine_PlayerCapacity_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "SilentFinalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_DLCShrine), "OnDisable", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "DLCShrine_PlayerCapacity_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "SilentFinalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(WaterInteraction), "Update", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "WaterInteraction_Update_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "WaterInteraction_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(WaterInteraction), "OnTriggerExit2D", new Type[1] { typeof(Collider2D) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "WaterInteraction_OnTriggerExit2D_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "Update", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "SilentFinalizer", (Type[])null), (HarmonyMethod)null);
		Type type = AccessTools.TypeByName("SkeletonAnimationLODGlobalManager");
		if (type != null)
		{
			MethodInfo methodInfo5 = AccessTools.Method(type, "Update", (Type[])null, (Type[])null);
			if (methodInfo5 != null)
			{
				val.Patch((MethodBase)methodInfo5, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "SilentFinalizer", (Type[])null), (HarmonyMethod)null);
				Log.LogInfo((object)"[MP] Patched SkeletonAnimationLODGlobalManager.Update finalizer");
			}
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_Fishing), "Update", (Type[])null, (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerCount_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "FishingBounds_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_Fishing), "UpdatePlayer", new Type[1] { typeof(int) }, (Type[])null), new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerCount_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_Fishing), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "InteractionFishing_BlockExtraPlayers_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingBounds_Finalizer", (Type[])null), (HarmonyMethod)null);
		MethodInfo methodInfo6 = Patches.FindNestedMoveNext(typeof(Interaction_Fishing), "WaitForPlayersToArriveIE");
		if (methodInfo6 != null)
		{
			val.Patch((MethodBase)methodInfo6, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_Fishing.WaitForPlayersToArriveIE two-player scope");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_Fishing.WaitForPlayersToArriveIE MoveNext not found");
		}
		MethodInfo methodInfo7 = Patches.FindNestedMoveNext(typeof(Interaction_Fishing), "BeganFishingIE");
		if (methodInfo7 != null)
		{
			val.Patch((MethodBase)methodInfo7, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_Fishing.BeganFishingIE two-player scope");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_Fishing.BeganFishingIE MoveNext not found");
		}
		MethodInfo methodInfo8 = Patches.FindNestedMoveNext(typeof(Interaction_Fishing), "CastLineIE");
		if (methodInfo8 != null)
		{
			val.Patch((MethodBase)methodInfo8, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerCount_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_Fishing.CastLineIE two-player scope");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_Fishing.CastLineIE MoveNext not found");
		}
		MethodInfo methodInfo9 = Patches.FindNestedMoveNext(typeof(Interaction_Fishing), "FishCaughtIE");
		if (methodInfo9 != null)
		{
			val.Patch((MethodBase)methodInfo9, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_Fishing.FishCaughtIE two-player scope");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_Fishing.FishCaughtIE MoveNext not found");
		}
		MethodInfo methodInfo10 = Patches.FindNestedMoveNext(typeof(Interaction_Fishing), "NoCatch");
		if (methodInfo10 != null)
		{
			val.Patch((MethodBase)methodInfo10, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerScope_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_Fishing.NoCatch two-player scope");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_Fishing.NoCatch MoveNext not found");
		}
		MethodInfo methodInfo11 = AccessTools.Method(typeof(Fishable), "Update", (Type[])null, (Type[])null);
		if (methodInfo11 != null)
		{
			val.Patch((MethodBase)methodInfo11, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerCount_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "FishingBounds_Finalizer", (Type[])null), (HarmonyMethod)null);
		}
		MethodInfo methodInfo12 = AccessTools.Method(typeof(Fishable), "HookLanded", (Type[])null, (Type[])null);
		if (methodInfo12 != null)
		{
			val.Patch((MethodBase)methodInfo12, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FishingTwoPlayerCount_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "FishingBounds_Finalizer", (Type[])null), (HarmonyMethod)null);
		}
		MethodInfo methodInfo13 = AccessTools.Method(typeof(BiomeConstants), "BiomeGenerator_OnBiomeChangeRoom", (Type[])null, (Type[])null);
		if (methodInfo13 != null)
		{
			val.Patch((MethodBase)methodInfo13, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "BiomeConstants_BiomeGenerator_OnBiomeChangeRoom_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "SilentFinalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched BiomeConstants.BiomeGenerator_OnBiomeChangeRoom (safe particle-clear transpiler)");
		}
		MethodInfo methodInfo14 = Patches.FindNestedMoveNext(typeof(BiomeGenerator), "ChangeRoomRoutine");
		if (methodInfo14 != null)
		{
			val.Patch((MethodBase)methodInfo14, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "BiomeChangeRoomRoutine_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched BiomeGenerator.ChangeRoomRoutine transition recovery");
		}
		MethodInfo methodInfo15 = AccessTools.Method(typeof(MMTransition), "Play", new Type[7]
		{
			typeof(TransitionType),
			typeof(Effect),
			typeof(string),
			typeof(float),
			typeof(string),
			typeof(Action),
			typeof(Action)
		}, (Type[])null);
		if (methodInfo15 != null)
		{
			val.Patch((MethodBase)methodInfo15, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "MMTransition_Play_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched MMTransition.Play black-screen watchdog");
		}
		MethodInfo methodInfo16 = Patches.FindNestedMoveNext(typeof(MMTransition), "ChangeRoomRoutine");
		if (methodInfo16 != null)
		{
			val.Patch((MethodBase)methodInfo16, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "MMTransitionChangeRoomRoutine_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched MMTransition.ChangeRoomRoutine immediate exception recovery");
		}
		MethodInfo methodInfo17 = AccessTools.Method(typeof(Door), "OnTriggerEnter2D", new Type[1] { typeof(Collider2D) }, (Type[])null);
		if (methodInfo17 != null)
		{
			val.Patch((MethodBase)methodInfo17, new HarmonyMethod(typeof(Patches), "Door_OnTriggerEnter2D_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Door.OnTriggerEnter2D extra-player routing");
		}
		MethodInfo methodInfo18 = AccessTools.Method(typeof(EnterBuilding), "OnTriggerEnter2D", new Type[1] { typeof(Collider2D) }, (Type[])null);
		if (methodInfo18 != null)
		{
			val.Patch((MethodBase)methodInfo18, new HarmonyMethod(typeof(Patches), "EnterBuilding_OnTriggerEnter2D_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched EnterBuilding.OnTriggerEnter2D democratic temple/building entry");
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_BaseTeleporter), "HandleAnimationStateEvent", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "TeleporterAnimEvent_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "TeleporterAnimEvent_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_BaseTeleporter), "SpawnPlayerIE", new Type[2]
		{
			typeof(PlayerFarming),
			typeof(Vector3)
		}, (Type[])null), new HarmonyMethod(typeof(Patches), "SpawnPlayerIE_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_PlayerClearRubble), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerClearRubble_OnInteract_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubble_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_PlayerClearRubble), "Update", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerClearRubble_Update_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerClearRubble_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_PlayerClearRubble), "DoBuild", new Type[1] { typeof(PlayerFarming) }, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerClearRubble_DoBuild_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo methodInfo19 = Patches.FindNestedMoveNext(typeof(Interaction_PlayerClearRubble), "DoBuild");
		if (methodInfo19 != null)
		{
			val.Patch((MethodBase)methodInfo19, new HarmonyMethod(typeof(Patches), "PlayerClearRubble_DoBuildMoveNext_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerClearRubble_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_PlayerClearRubble.DoBuild MoveNext safety");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_PlayerClearRubble.DoBuild MoveNext not found");
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_Woodcutting), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_OnInteract_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_Woodcutting), "Update", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Update_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
		MethodInfo methodInfo20 = Patches.FindNestedMoveNext(typeof(Interaction_Woodcutting), "DoWoodCutting");
		if (methodInfo20 != null)
		{
			val.Patch((MethodBase)methodInfo20, new HarmonyMethod(typeof(Patches), "PlayerWork_MoveNext_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_Woodcutting.DoWoodCutting MoveNext safety");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_Woodcutting.DoWoodCutting MoveNext not found");
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_WoodcuttingRubble), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_OnInteract_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_WoodcuttingRubble), "Update", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Update_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
		MethodInfo methodInfo21 = Patches.FindNestedMoveNext(typeof(Interaction_WoodcuttingRubble), "DoWoodCutting");
		if (methodInfo21 != null)
		{
			val.Patch((MethodBase)methodInfo21, new HarmonyMethod(typeof(Patches), "PlayerWork_MoveNext_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_WoodcuttingRubble.DoWoodCutting MoveNext safety");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_WoodcuttingRubble.DoWoodCutting MoveNext not found");
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_Berries), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_OnInteract_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_Berries), "Update", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Update_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
		MethodInfo methodInfo22 = Patches.FindNestedMoveNext(typeof(Interaction_Berries), "PickBerries");
		if (methodInfo22 != null)
		{
			val.Patch((MethodBase)methodInfo22, new HarmonyMethod(typeof(Patches), "PlayerWork_MoveNext_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_Berries.PickBerries MoveNext safety");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_Berries.PickBerries MoveNext not found");
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_ClearToxicWaste), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_OnInteract_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_ClearToxicWaste), "Update", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Update_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
		MethodInfo methodInfo23 = Patches.FindNestedMoveNext(typeof(Interaction_ClearToxicWaste), "DoClean");
		if (methodInfo23 != null)
		{
			val.Patch((MethodBase)methodInfo23, new HarmonyMethod(typeof(Patches), "PlayerWork_MoveNext_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "PlayerClearRubblePlayerIndex_Transpiler", (Type[])null), new HarmonyMethod(typeof(Patches), "PlayerWork_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched Interaction_ClearToxicWaste.DoClean MoveNext safety");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: Interaction_ClearToxicWaste.DoClean MoveNext not found");
		}
		MethodInfo methodInfo24 = AccessTools.Method(typeof(Interaction_Ranchable), "StartFollowingPlayer", (Type[])null, (Type[])null);
		MethodInfo methodInfo25 = AccessTools.Method(typeof(Interaction_Ranchable), "EndFollowingPlayer", (Type[])null, (Type[])null);
		MethodInfo methodInfo26 = AccessTools.Method(typeof(Interaction_Ranchable), "CheckBreakingOut", new Type[1] { typeof(bool) }, (Type[])null);
		MethodInfo methodInfo27 = AccessTools.Method(typeof(PlayerFarming), "GetPlayerAnimal", new Type[1] { typeof(bool) }, (Type[])null);
		MethodInfo methodInfo28 = AccessTools.Method(typeof(BiomeBaseManager), "SpawnAnimals", (Type[])null, (Type[])null);
		MethodInfo methodInfo29 = AccessTools.PropertySetter(typeof(Interaction_Ranchable), "CurrentState");
		MethodInfo methodInfo30 = AccessTools.Method(typeof(Interaction_Ranchable), "GetLabel", (Type[])null, (Type[])null);
		MethodInfo methodInfo31 = AccessTools.Method(typeof(Interaction_Ranchable), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null);
		int num = 0;
		if (methodInfo29 != null)
		{
			val.Patch((MethodBase)methodInfo29, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "Ranchable_FurnaceNullSafety_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			num++;
		}
		if (methodInfo30 != null)
		{
			val.Patch((MethodBase)methodInfo30, new HarmonyMethod(typeof(Patches), "Ranchable_GetLabelOwner_Prefix", (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "Ranchable_FurnaceNullSafety_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			num++;
		}
		if (methodInfo31 != null)
		{
			val.Patch((MethodBase)methodInfo31, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "Ranchable_FurnaceNullSafety_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			num++;
		}
		Log.LogInfo((object)$"[MP] Registered ranch leash/furnace null-safety on {num}/3 targets");
		MethodInfo methodInfo32 = AccessTools.Method(typeof(AnimationAdorationUI), "Hide", new Type[1] { typeof(bool) }, (Type[])null);
		if (methodInfo32 != null)
		{
			val.Patch((MethodBase)methodInfo32, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "AnimationAdorationUI_Hide_Transpiler", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null);
			Log.LogInfo((object)"[MP] Patched vanilla animal adoration hide diagnostic");
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: AnimationAdorationUI.Hide(bool) not found");
		}
		if (methodInfo24 != null)
		{
			val.Patch((MethodBase)methodInfo24, new HarmonyMethod(typeof(Patches), "RanchFollowingCapacity_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		if (methodInfo25 != null)
		{
			val.Patch((MethodBase)methodInfo25, new HarmonyMethod(typeof(Patches), "RanchFollowingCapacity_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		if (methodInfo26 != null)
		{
			val.Patch((MethodBase)methodInfo26, new HarmonyMethod(typeof(Patches), "RanchFollowingCapacity_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		if (methodInfo27 != null)
		{
			val.Patch((MethodBase)methodInfo27, new HarmonyMethod(typeof(Patches), "RanchFollowingCapacity_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		if (methodInfo28 != null)
		{
			val.Patch((MethodBase)methodInfo28, new HarmonyMethod(typeof(Patches), "RanchFollowingCapacity_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		Log.LogInfo((object)"[MP8] Registered eight-slot ranch follow ownership safeguards");
		val.Patch((MethodBase)AccessTools.Method(typeof(GameManager), "NewRun", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "NewRun_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "Start", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "CoopManager_Start_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "WakeAllKnockedOutPlayersWithHealth", new Type[1] { typeof(float) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "CoopManager_WakeAllKnockedOutPlayersWithHealth_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "WakeAllKnockedOutPlayers", Type.EmptyTypes, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "CoopManager_WakeAllKnockedOutPlayers_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(CoopManager), "WakeKnockedOutPlayer", new Type[5]
		{
			typeof(PlayerFarming),
			typeof(float),
			typeof(PlayerFarming),
			typeof(HeartPickupType),
			typeof(bool)
		}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "CoopManager_WakeKnockedOutPlayer_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo method2 = typeof(CoopManager).GetMethod("ResetMainPlayerOnConversationEnd", BindingFlags.Instance | BindingFlags.NonPublic, null, new Type[2]
		{
			typeof(bool),
			typeof(bool)
		}, null);
		if (method2 != null)
		{
			val.Patch((MethodBase)method2, new HarmonyMethod(typeof(Patches), "CoopManager_ConversationFreeze_Prefix", (Type[])null), new HarmonyMethod(typeof(Patches), "CoopManager_ResetMainPlayerOnConversationEnd_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		else
		{
			Log.LogWarning((object)"[MP] Skipped patch: CoopManager.ResetMainPlayerOnConversationEnd(bool,bool) not found");
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_WeaponSelectionPodium), "SetWeapon", new Type[1] { typeof(int) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "WeaponPodium_SetWeapon_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_WeaponSelectionPodium), "SetCurse", new Type[1] { typeof(int) }, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "WeaponPodium_SetCurse_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_WeaponSelectionPodium), "OnEnable", Type.EmptyTypes, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "WeaponPodium_OnEnable_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_WeaponSelectionPodium), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "WeaponPodium_OnInteract_Prefix", (Type[])null), new HarmonyMethod(typeof(Patches), "WeaponPodium_OnInteract_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(UICoopAssignController), "OnEnable", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "CoopAssign_OnEnable_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)typeof(UICoopAssignController).GetMethod("OnShowStarted", BindingFlags.Instance | BindingFlags.NonPublic), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "CoopAssign_OnShowStarted", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(UICoopAssignController), "UpdateDisplayedConnectedGamepads", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "CoopAssign_UpdateDisplayedConnectedGamepads_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Health_Manager), "Init", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "HealthManager_Init", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_Hearts), "SetWeapon", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "HUDHearts_SetWeapon_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_Hearts), "SetCurse", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "HUDHearts_SetCurse_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_Hearts), "OnHPUpdated", new Type[1] { typeof(HealthPlayer) }, (Type[])null), new HarmonyMethod(typeof(Patches), "HUDHearts_OnHPUpdated_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo methodInfo33 = AccessTools.Method(typeof(HUD_Hearts), "lowHealthCheck", Type.EmptyTypes, (Type[])null);
		if (methodInfo33 != null)
		{
			val.Patch((MethodBase)methodInfo33, new HarmonyMethod(typeof(Patches), "HUDHearts_LowHealthCheck_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_Hearts), "OnTotalHPUpdated", new Type[1] { typeof(HealthPlayer) }, (Type[])null), new HarmonyMethod(typeof(Patches), "HUDHearts_OnTotalHPUpdated_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_Hearts), "OnEnable", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "HUDHearts_OnEnable_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_Heart), "SetSprite", new Type[3]
		{
			typeof(HeartState),
			typeof(bool),
			typeof(HeartType)
		}, (Type[])null), new HarmonyMethod(typeof(Patches), "HUDHeart_SetSprite_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_Heart), "Activate", new Type[2]
		{
			typeof(bool),
			typeof(bool)
		}, (Type[])null), new HarmonyMethod(typeof(Patches), "HUDHeart_Activate_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(FaithAmmo), "OnEnable", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "FaithAmmo_OnEnable_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(FaithAmmo), "OnGetSoul", new Type[2]
		{
			typeof(int),
			typeof(PlayerFarming)
		}, (Type[])null), new HarmonyMethod(typeof(Patches), "FaithAmmo_OnGetSoul_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(FaithAmmo), "UseAmmo", new Type[2]
		{
			typeof(float),
			typeof(bool)
		}, (Type[])null), new HarmonyMethod(typeof(Patches), "FaithAmmo_UseAmmo_Prefix", (Type[])null), new HarmonyMethod(typeof(Patches), "FaithAmmo_UseAmmo_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_ActiveTrinketsCoOp), "OnTrinketsChanged", new Type[1] { typeof(PlayerFarming) }, (Type[])null), new HarmonyMethod(typeof(Patches), "HUDActiveTrinketsCoOp_OnTrinketsChanged_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "SilentFinalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(HUD_ActiveTrinketsCoOp), "OnRomanNumeralSettingChanged", new Type[1] { typeof(bool) }, (Type[])null), new HarmonyMethod(typeof(Patches), "HUDActiveTrinketsCoOp_OnRomanNumeralSettingChanged_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "SilentFinalizer", (Type[])null), (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(interaction_FollowerInteraction), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "CoopContextInteraction_Capture_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_Cauldron), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "CoopContextInteraction_Capture_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_Kitchen), "ShowMenu", Type.EmptyTypes, (Type[])null), new HarmonyMethod(typeof(Patches), "Kitchen_ShowMenu_Capture_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction_RepairStructure), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null), new HarmonyMethod(typeof(Patches), "CoopContextInteraction_Capture_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo methodInfo34 = AccessTools.Method(typeof(UIFollowerInteractionWheelOverlayController), "Show", new Type[5]
		{
			typeof(Follower),
			typeof(List<CommandItem>),
			typeof(bool),
			typeof(bool),
			typeof(PlayerFarming)
		}, (Type[])null);
		if (methodInfo34 != null)
		{
			val.Patch((MethodBase)methodInfo34, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "FollowerWheel_Show_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(UIManager), "ShowCookingFireMenu", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "CookingFireMenu_Show_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(UIManager), "ShowKitchenMenu", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "KitchenMenu_Show_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(UICookingMinigameOverlayController), "Initialise", new Type[2]
		{
			typeof(StructuresData),
			typeof(Interaction)
		}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "CookingMinigame_Initialise_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(UIRebuildBedMinigameOverlayController), "Initialise", new Type[2]
		{
			typeof(StructuresData),
			typeof(Interaction)
		}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "RepairMinigame_Initialise_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(UIRebuildBedMinigameOverlayController), "Initialise", new Type[2]
		{
			typeof(string),
			typeof(float)
		}, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "RepairMinigame_Initialise_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Interaction), "OnHoldProgressDown", new Type[2]
		{
			typeof(Indicator),
			typeof(PlayerFarming)
		}, (Type[])null), new HarmonyMethod(typeof(Patches), "IndependentHoldAction_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo methodInfo35 = AccessTools.Method(typeof(Interaction), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null);
		if (methodInfo35 != null)
		{
			val.Patch((MethodBase)methodInfo35, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "Interaction_OnInteract_OwnerRecovery_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		MethodInfo methodInfo36 = AccessTools.PropertyGetter(typeof(Interaction), "CanMultiplePlayersInteract");
		if (methodInfo36 != null)
		{
			val.Patch((MethodBase)methodInfo36, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "Interaction_CanMultiplePlayersInteract_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		MethodInfo methodInfo37 = AccessTools.Method(typeof(Interaction_PlayerBuild), "OnInteract", new Type[1] { typeof(StateMachine) }, (Type[])null);
		if (methodInfo37 != null)
		{
			val.Patch((MethodBase)methodInfo37, new HarmonyMethod(typeof(Patches), "PlayerBuild_OnInteract_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		MethodInfo methodInfo38 = AccessTools.Method(typeof(MMControlPrompt), "AssignPrompt", new Type[3]
		{
			typeof(ActionElementMap),
			typeof(Controller),
			typeof(bool)
		}, (Type[])null);
		if (methodInfo38 != null)
		{
			val.Patch((MethodBase)methodInfo38, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "MMControlPrompt_AssignPrompt_Finalizer", (Type[])null), (HarmonyMethod)null);
			Log.LogInfo((object)"[Input] Registered safe vJoy prompt fallback");
		}
		else
		{
			Log.LogWarning((object)"[Input] MMControlPrompt.AssignPrompt overload not found; vJoy prompt fallback unavailable");
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(MMConversation), "Play", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "MMConversation_Play_Prefix", (Type[])null), new HarmonyMethod(typeof(Patches), "MMConversation_Play_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo methodInfo39 = AccessTools.Method(typeof(MMConversation), "DoClose", new Type[3]
		{
			typeof(bool),
			typeof(Action),
			typeof(bool)
		}, (Type[])null);
		if (methodInfo39 != null)
		{
			val.Patch((MethodBase)methodInfo39, new HarmonyMethod(typeof(Patches), "MMConversation_DoClose_Prefix", (Type[])null), new HarmonyMethod(typeof(Patches), "MMConversation_DoClose_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(MMConversation), "ClearConversation", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "MMConversation_ClearConversation_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(GameManager), "OnConversationNew", new Type[4]
		{
			typeof(bool),
			typeof(bool),
			typeof(bool),
			typeof(PlayerFarming)
		}, (Type[])null), new HarmonyMethod(typeof(Patches), "GameManager_ConversationPresentation_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(GameManager), "OnConversationNext", new Type[2]
		{
			typeof(GameObject),
			typeof(float)
		}, (Type[])null), new HarmonyMethod(typeof(Patches), "GameManager_ConversationPresentation_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(GameManager), "OnConversationEnd", new Type[2]
		{
			typeof(bool),
			typeof(bool)
		}, (Type[])null), new HarmonyMethod(typeof(Patches), "GameManager_ConversationPresentation_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo methodInfo40 = AccessTools.Method(typeof(CoopManager), "OnConversationNew", new Type[4]
		{
			typeof(bool),
			typeof(bool),
			typeof(bool),
			typeof(PlayerFarming)
		}, (Type[])null);
		if (methodInfo40 != null)
		{
			val.Patch((MethodBase)methodInfo40, new HarmonyMethod(typeof(Patches), "CoopManager_ConversationFreeze_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		val.Patch((MethodBase)AccessTools.Method(typeof(MMConversation), "Update", (Type[])null, (Type[])null), new HarmonyMethod(typeof(Patches), "MMConversation_Update_InputRecovery_Prefix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		val.Patch((MethodBase)AccessTools.Method(typeof(Structure), "ProgressCompleted", Type.EmptyTypes, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "Structure_ProgressCompleted_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		Log.LogInfo((object)"[QoL] Registered compact menus, non-blocking hub conversations and independent co-op actions");
		val.Patch((MethodBase)AccessTools.Method(typeof(Health), "InitHP", (Type[])null, (Type[])null), (HarmonyMethod)null, new HarmonyMethod(typeof(Patches), "EnemyHealth_InitHP_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		MethodInfo methodInfo41 = AccessTools.Method(typeof(CameraFollowTarget), "LateUpdate", (Type[])null, (Type[])null);
		if (methodInfo41 != null)
		{
			val.Patch((MethodBase)methodInfo41, new HarmonyMethod(typeof(Patches), "CameraFollowTarget_LateUpdate_Prefix", (Type[])null), new HarmonyMethod(typeof(Patches), "CameraFollowTarget_LateUpdate_Postfix", (Type[])null), (HarmonyMethod)null, (HarmonyMethod)null, (HarmonyMethod)null);
		}
		Log.LogInfo((object)"[Balance] Registered scalable enemy HP and full-group dynamic camera; enemy count is owned only by the restrained spawn addon");
		CustomSpineCompatibility.Initialize(this, val);
		Log.LogInfo((object)("All patches applied. MAX_PLAYERS = " + 8));
	}
}
internal static class TransitionVotePlayerState
{
	private sealed class HiddenPlayer
	{
		internal PlayerFarming Player;

		internal State PreviousState;

		internal bool PreviousStateLock;

		internal bool IndicatorWasActive;

		internal readonly Dictionary<Renderer, bool> Renderers = new Dictionary<Renderer, bool>();

		internal readonly Dictionary<Collider2D, bool> Colliders = new Dictionary<Collider2D, bool>();
	}

	private static readonly Dictionary<int, HiddenPlayer> Hidden = new Dictionary<int, HiddenPlayer>();

	private static readonly Dictionary<int, float> DeniedInitiatorCooldowns = new Dictionary<int, float>();

	private static readonly Dictionary<int, float> NextCooldownLogAt = new Dictionary<int, float>();

	internal static bool IsHidden(PlayerFarming player)
	{
		if ((Object)(object)player != (Object)null)
		{
			return Hidden.ContainsKey(player.playerID);
		}
		return false;
	}

	internal static void Hide(PlayerFarming player)
	{
		//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)
		if ((Object)(object)player == (Object)null || (Object)(object)((Component)player).gameObject == (Object)null || Hidden.ContainsKey(player.playerID))
		{
			return;
		}
		HiddenPlayer hiddenPlayer = new HiddenPlayer
		{
			Player = player,
			PreviousState = (State)(((Object)(object)player.state != (Object)null) ? ((int)player.state.CURRENT_STATE) : 0),
			PreviousStateLock = ((Object)(object)player.state != (Object)null && player.state.LockStateChanges),
			IndicatorWasActive = ((Object)(object)player.CoopIndicatorGoat != (Object)null && player.CoopIndicatorGoat.activeSelf)
		};
		Renderer[] componentsInChildren = ((Component)player).GetComponentsInChildren<Renderer>(true);
		foreach (Renderer val in componentsInChildren)
		{
			if ((Object)(object)val != (Object)null)
			{
				hiddenPlayer.Renderers[val] = val.enabled;
				val.enabled = false;
			}
		}
		Collider2D[] componentsInChildren2 = ((Component)player).GetComponentsInChildren<Collider2D>(true);
		foreach (Collider2D val2 in componentsInChildren2)
		{
			if ((Object)(object)val2 != (Object)null)
			{
				hiddenPlayer.Colliders[val2] = ((Behaviour)val2).enabled;
				((Behaviour)val2).enabled = false;
			}
		}
		if ((Object)(object)player.CoopIndicatorGoat != (Object)null)
		{
			player.CoopIndicatorGoat.SetActive(false);
		}
		if ((Object)(object)player.state != (Object)null)
		{
			player.state.LockStateChanges = false;
			player.state.CURRENT_STATE = (State)13;
			player.state.LockStateChanges = true;
		}
		Hidden[player.playerID] = hiddenPlayer;
		RemoveFromCamera(player);
	}

	internal static void PrepareForApprovedTransition()
	{
		foreach (HiddenPlayer value in Hidden.Values)
		{
			RestorePhysicsAndState(value);
		}
	}

	internal static void RestoreAll()
	{
		foreach (HiddenPlayer value in Hidden.Values)
		{
			RestoreSnapshot(value);
		}
		Hidden.Clear();
	}

	internal static void RestoreAndSpread(Action<PlayerFarming> spreadPlayer)
	{
		List<PlayerFarming> list = new List<PlayerFarming>();
		foreach (HiddenPlayer value in Hidden.Values)
		{
			RestoreSnapshot(value);
			if ((Object)(object)value.Player != (Object)null)
			{
				list.Add(value.Player);
			}
		}
		Hidden.Clear();
		if (spreadPlayer == null)
		{
			return;
		}
		foreach (PlayerFarming item in list)
		{
			spreadPlayer(item);
		}
	}

	internal static void KeepHiddenOutOfCamera(CameraFollowTarget camera)
	{
		if ((Object)(object)camera == (Object)null)
		{
			return;
		}
		foreach (HiddenPlayer value in Hidden.Values)
		{
			PlayerFarming player = value.Player;
			if ((Object)(object)player != (Object)null && (Object)(object)player.CameraBone != (Object)null && camera.Contains(player.CameraBone))
			{
				camera.RemoveTarget(player.CameraBone);
			}
		}
	}

	internal static void BlockDeniedInitiator(int playerSlot)
	{
		if (playerSlot >= 0 && playerSlot < 8)
		{
			DeniedInitiatorCooldowns[playerSlot] = Time.unscaledTime + 15f;
			Plugin.Log.LogInfo((object)$"[RoomVote] P{playerSlot + 1} cannot initiate another entry vote for 15 seconds after DENY.");
		}
	}

	internal static bool IsInitiatorBlocked(PlayerFarming player, out float remaining)
	{
		remaining = 0f;
		if ((Object)(object)player == (Object)null || !DeniedInitiatorCooldowns.TryGetValue(player.playerID, out var value))
		{
			return false;
		}
		remaining = value - Time.unscaledTime;
		if (remaining <= 0f)
		{
			DeniedInitiatorCooldowns.Remove(player.playerID);
			NextCooldownLogAt.Remove(player.playerID);
			remaining = 0f;
			return false;
		}
		if (!NextCooldownLogAt.TryGetValue(player.playerID, out var value2) || Time.unscaledTime >= value2)
		{
			NextCooldownLogAt[player.playerID] = Time.unscaledTime + 1f;
			Plugin.Log.LogInfo((object)$"[RoomVote] P{player.playerID + 1} entry-vote cooldown: {remaining:0.0}s (other players may still initiate).");
		}
		return true;
	}

	private static void RestoreSnapshot(HiddenPlayer snapshot)
	{
		if (snapshot == null)
		{
			return;
		}
		RestorePhysicsAndState(snapshot);
		foreach (KeyValuePair<Renderer, bool> renderer in snapshot.Renderers)
		{
			if ((Object)(object)renderer.Key != (Object)null)
			{
				renderer.Key.enabled = renderer.Value;
			}
		}
		if ((Object)(object)snapshot.Player != (Object)null && (Object)(object)snapshot.Player.CoopIndicatorGoat != (Object)null)
		{
			snapshot.Player.CoopIndicatorGoat.SetActive(snapshot.IndicatorWasActive);
		}
	}

	private static void RestorePhysicsAndState(HiddenPlayer snapshot)
	{
		//IL_0081: 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_0087: Unknown result type (might be due to invalid IL or missing references)
		//IL_008a: Invalid comparison between Unknown and I4
		//IL_0092: 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_008f: Invalid comparison between Unknown and I4
		//IL_0099: Unknown result type (might be due to invalid IL or missing references)
		if (snapshot == null)
		{
			return;
		}
		foreach (KeyValuePair<Collider2D, bool> collider in snapshot.Colliders)
		{
			if ((Object)(object)collider.Key != (Object)null)
			{
				((Behaviour)collider.Key).enabled = collider.Value;
			}
		}
		PlayerFarming player = snapshot.Player;
		if (!((Object)(object)player == (Object)null) && !((Object)(object)player.state == (Object)null))
		{
			player.state.LockStateChanges = false;
			State val = snapshot.PreviousState;
			if ((int)val == 13 || (int)val == 24)
			{
				val = (State)0;
			}
			player.state.CURRENT_STATE = val;
			player.state.LockStateChanges = snapshot.PreviousStateLock;
		}
	}

	private static void RemoveFromCamera(PlayerFarming player)
	{
		try
		{
			GameManager instance = GameManager.GetInstance();
			CameraFollowTarget val = (((Object)(object)instance != (Object)null) ? instance.CamFollowTarget : null);
			if ((Object)(object)val != (Object)null && (Object)(object)player != (Object)null && (Object)(object)player.CameraBone != (Object)null && val.Contains(player.CameraBone))
			{
				val.RemoveTarget(player.CameraBone);
			}
		}
		catch
		{
		}
	}
}
internal static class TransitionVoteSkin
{
	internal const string FileName = "vote_panel_cult.png";

	private static Sprite _panelSprite;

	private static bool _attempted;

	internal static Sprite GetPanelSprite()
	{
		//IL_00ad: 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)
		if (_attempted)
		{
			return _panelSprite;
		}
		_attempted = true;
		try
		{
			string text = Path.Combine(Path.GetDirectoryName(typeof(Plugin).Assembly.Location) ?? string.Empty, "vote_panel_cult.png");
			if (!File.Exists(text))
			{
				Plugin.Log.LogWarning((object)("[RoomVote] Cult-style panel PNG not found: " + text));
				return null;
			}
			Texture2D val = Patches.LoadPNG(text);
			if ((Object)(object)val == (Object)null)
			{
				return null;
			}
			((Object)val).name = "COTLMP Cult Vote Panel";
			((Texture)val).wrapMode = (TextureWrapMode)1;
			((Texture)val).filterMode = (FilterMode)1;
			_panelSprite = Sprite.Create(val, new Rect(0f, 0f, (float)((Texture)val).width, (float)((Texture)val).height), new Vector2(0.5f, 0.5f), 100f);
			((Object)_panelSprite).name = "COTLMP Cult Vote Panel";
			Plugin.Log.LogInfo((object)$"[RoomVote] Loaded Cult-style panel PNG {((Texture)val).width}x{((Texture)val).height}.");
		}
		catch (Exception ex)
		{
			Plugin.Log.LogWarning((object)("[RoomVote] Failed to load Cult-style panel PNG: " + ex.Message));
			_panelSprite = null;
		}
		return _panelSprite;
	}
}