using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Reflection.Emit;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Logging;
using FishNet;
using FishNet.Object.Synchronizing;
using FishNet.Transporting;
using HarmonyLib;
using Microsoft.CodeAnalysis;
using Steamworks;
using TMPro;
using UnityEngine;
using UnityEngine.Events;
using UnityEngine.SceneManagement;
using UnityEngine.UI;
using moreStrafts.Patches;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyCompany("moreStrafts")]
[assembly: AssemblyConfiguration("Release")]
[assembly: AssemblyFileVersion("0.1.0.0")]
[assembly: AssemblyInformationalVersion("0.1.0+34e216bd24532845f866566dd97ba804fddaf2b1")]
[assembly: AssemblyProduct("moreStrafts")]
[assembly: AssemblyTitle("moreStrafts")]
[assembly: AssemblyVersion("0.1.0.0")]
[module: RefSafetyRules(11)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace moreStrafts
{
	public static class Log
	{
		private static ManualLogSource? source;

		private static StreamWriter? writer;

		private static readonly object gate = new object();

		public static void Init(ManualLogSource logSource, bool perInstanceFile)
		{
			source = logSource;
			if (!perInstanceFile)
			{
				return;
			}
			try
			{
				string text = Path.Combine(Paths.BepInExRootPath, "moreStrafts_debug");
				Directory.CreateDirectory(text);
				writer = new StreamWriter(Path.Combine(text, string.Format(arg1: Process.GetCurrentProcess().Id, format: "moreStrafts_{0:yyyyMMdd_HHmmss}_pid{1}.log", arg0: DateTime.Now)), append: false)
				{
					AutoFlush = true
				};
			}
			catch (Exception ex)
			{
				logSource.LogWarning((object)("per-instance log unavailable: " + ex.Message));
			}
		}

		public static void Info(string message)
		{
			Write("INFO", message);
		}

		public static void Warn(string message)
		{
			Write("WARN", message);
		}

		public static void Error(string message)
		{
			Write("ERROR", message);
		}

		private static void Write(string level, string message)
		{
			lock (gate)
			{
				try
				{
					writer?.WriteLine($"[{DateTime.Now:HH:mm:ss.fff}] [{level}] {message}");
				}
				catch
				{
				}
			}
			if (!(level == "ERROR"))
			{
				if (level == "WARN")
				{
					ManualLogSource? obj2 = source;
					if (obj2 != null)
					{
						obj2.LogWarning((object)message);
					}
				}
				else
				{
					ManualLogSource? obj3 = source;
					if (obj3 != null)
					{
						obj3.LogInfo((object)message);
					}
				}
			}
			else
			{
				ManualLogSource? obj4 = source;
				if (obj4 != null)
				{
					obj4.LogError((object)message);
				}
			}
		}
	}
	public static class ModState
	{
		public const int MaxPlayers = 10;

		private static bool quickLoad;

		public static bool QuickLoad
		{
			get
			{
				return quickLoad;
			}
			set
			{
				if (value != quickLoad)
				{
					Log.Info($"QuickLoad {quickLoad} -> {value}");
				}
				quickLoad = value;
			}
		}
	}
	[BepInPlugin("com.nitrogenia.morestrafts", "More Strafts Players", "0.1.0")]
	public class Plugin : BaseUnityPlugin
	{
		public const string PluginGuid = "com.nitrogenia.morestrafts";

		public const string PluginName = "More Strafts Players";

		public const string PluginVersion = "0.1.0";

		private static readonly Type[] PatchClasses = new Type[16]
		{
			typeof(SteamLobbyStartPatch),
			typeof(OnLobbyCreatedPatch),
			typeof(SetMaxPlayersPatch),
			typeof(UpdateOnClientsPatch),
			typeof(QuickLoadLobbyDataPatch),
			typeof(QuickLoadTogglePatch),
			typeof(QuickLoadInterfacePatch),
			typeof(PlayerListItemUpdatePatch),
			typeof(TeamDropdownPatch),
			typeof(RunIntoLobbyPatch),
			typeof(MenuAnimationObserversPatch),
			typeof(DressAboubiObserversPatch),
			typeof(RoundEndArraysPatch),
			typeof(GamemodeFfaPatch),
			typeof(StartGameFfaPatch),
			typeof(MatchPointsHudPatch)
		};

		private void Awake()
		{
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005c: Expected O, but got Unknown
			ConfigEntry<bool> val = ((BaseUnityPlugin)this).Config.Bind<bool>("Debug", "PerInstanceLogFiles", false, "Write a small per-instance log file to BepInEx/moreStrafts_debug. Include these files in bug reports.");
			Log.Init(((BaseUnityPlugin)this).Logger, val.Value);
			SceneManager.sceneLoaded += delegate(Scene scene, LoadSceneMode mode)
			{
				//IL_000c: Unknown result type (might be due to invalid IL or missing references)
				Log.Info($"scene '{((Scene)(ref scene)).name}' ({mode})");
			};
			Harmony val2 = new Harmony("com.nitrogenia.morestrafts");
			int num = 0;
			Type[] patchClasses = PatchClasses;
			foreach (Type type in patchClasses)
			{
				try
				{
					val2.CreateClassProcessor(type).Patch();
					num++;
				}
				catch (Exception arg)
				{
					Log.Error($"patch {type.Name} failed: {arg}");
				}
			}
			Log.Info(string.Format("{0} {1}: {2}/{3} patches applied", "More Strafts Players", "0.1.0", num, PatchClasses.Length));
		}
	}
}
namespace moreStrafts.Patches
{
	[HarmonyPatch(typeof(MatchPoitnsHUD), "UpdateVisuals", new Type[]
	{
		typeof(int),
		typeof(Dictionary<int, int>)
	})]
	internal static class MatchPointsHudPatch
	{
		private static readonly FieldRef<MatchPoitnsHUD, MeshRenderer[]> SecondaryObjects = AccessTools.FieldRefAccess<MatchPoitnsHUD, MeshRenderer[]>("secondaryPointObjects");

		private static readonly FieldRef<MatchPoitnsHUD, TMP_Text[]> PointsTexts = AccessTools.FieldRefAccess<MatchPoitnsHUD, TMP_Text[]>("pointsTexts");

		private static readonly FieldRef<MatchPoitnsHUD, MeshRenderer> PrimaryMesh = AccessTools.FieldRefAccess<MatchPoitnsHUD, MeshRenderer>("primaryPointMesh");

		private static readonly FieldRef<MatchPoitnsHUD, Material[]> ActiveMaterials = AccessTools.FieldRefAccess<MatchPoitnsHUD, Material[]>("activeMaterials");

		private static readonly FieldRef<MatchPoitnsHUD, Material> InactiveMaterial = AccessTools.FieldRefAccess<MatchPoitnsHUD, Material>("inactiveMaterial");

		private static bool warned;

		private static bool Prefix(MatchPoitnsHUD __instance, int winnerTeamId, Dictionary<int, int> roundScores)
		{
			try
			{
				if (ClientInstance.playerInstances.Count <= 1)
				{
					return false;
				}
				MeshRenderer[] array = SecondaryObjects.Invoke(__instance);
				TMP_Text[] array2 = PointsTexts.Invoke(__instance);
				MeshRenderer val = PrimaryMesh.Invoke(__instance);
				int[] array3 = ScoreManager.Instance.TeamIdToPlayerIds.Keys.ToArray();
				int num = array3.Count((int teamId) => ((SyncIDictionary<int, List<int>>)(object)ScoreManager.Instance.TeamIdToPlayerIds)[teamId].Any((int playerId) => ClientInstance.playerInstances.ContainsKey(playerId)));
				int num2 = Mathf.Clamp(num - 2, 0, array.Length);
				for (int num3 = 0; num3 < array.Length; num3++)
				{
					((Component)array[num3]).gameObject.SetActive(num3 < num2);
				}
				TMP_Text[] array4 = array2;
				for (int num4 = 0; num4 < array4.Length; num4++)
				{
					array4[num4].text = "";
				}
				Material[] materials = ((Renderer)val).materials;
				int num5 = Mathf.Min(num, 2 + array.Length);
				for (int num6 = 0; num6 < num5 && num6 < array3.Length; num6++)
				{
					int num7 = array3[num6];
					roundScores.TryGetValue(num7, out var value);
					ApplyTeamVisual(__instance, num6, value, num7 == winnerTeamId, materials);
				}
				((Renderer)val).materials = materials;
				return false;
			}
			catch (Exception arg)
			{
				if (!warned)
				{
					warned = true;
					Log.Error($"MatchPointsHudPatch: {arg}");
				}
				return true;
			}
		}

		private static void ApplyTeamVisual(MatchPoitnsHUD hud, int teamNumber, int score, bool isWinner, Material[] primaryMaterials)
		{
			Material[] array = ActiveMaterials.Invoke(hud);
			if (teamNumber < 0 || teamNumber >= array.Length)
			{
				return;
			}
			Material val = ((score > 0) ? array[teamNumber] : InactiveMaterial.Invoke(hud));
			if (teamNumber < 2)
			{
				primaryMaterials[(teamNumber == 0) ? 1 : 3] = val;
			}
			else
			{
				MeshRenderer[] array2 = SecondaryObjects.Invoke(hud);
				int num = teamNumber - 2;
				if (num < array2.Length)
				{
					Material[] materials = ((Renderer)array2[num]).materials;
					materials[1] = val;
					((Renderer)array2[num]).materials = materials;
				}
			}
			TMP_Text[] array3 = PointsTexts.Invoke(hud);
			if (((score == 2 && !isWinner) || score > 2) && teamNumber < array3.Length)
			{
				array3[teamNumber].text = score.ToString();
			}
			if (isWinner)
			{
				primaryMaterials[2] = val;
			}
		}
	}
	internal static class LobbyCapacity
	{
		public static void ExpandDropdown(TMP_Dropdown? dropdown)
		{
			//IL_0045: Unknown result type (might be due to invalid IL or missing references)
			//IL_004f: Expected O, but got Unknown
			if (!((Object)(object)dropdown == (Object)null) && dropdown.options.Count < 9)
			{
				int value = dropdown.value;
				dropdown.options.Clear();
				for (int i = 2; i <= 10; i++)
				{
					dropdown.options.Add(new OptionData($"{i} Players"));
				}
				dropdown.value = value;
				dropdown.RefreshShownValue();
				Log.Info($"max-players dropdown expanded to 2-{10} (value {value})");
			}
		}

		public static void SetTransportMaxClients(int maxClients)
		{
			Transport val = InstanceFinder.TransportManager?.Transport;
			if (!((Object)(object)val == (Object)null))
			{
				val.SetMaximumClients(maxClients);
				Log.Info($"transport max clients set to {maxClients}");
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobby), "Start")]
	internal static class SteamLobbyStartPatch
	{
		private static void Postfix(SteamLobby __instance)
		{
			try
			{
				LobbyCapacity.ExpandDropdown(__instance.MaxPlayersDropdown);
				LobbyCapacity.SetTransportMaxClients(9);
			}
			catch (Exception arg)
			{
				Log.Error($"SteamLobbyStartPatch: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobby), "OnLobbyCreated")]
	internal static class OnLobbyCreatedPatch
	{
		private static void Prefix(SteamLobby __instance)
		{
			try
			{
				LobbyCapacity.ExpandDropdown(__instance.MaxPlayersDropdown);
			}
			catch (Exception arg)
			{
				Log.Error($"OnLobbyCreatedPatch prefix: {arg}");
			}
		}

		private static void Postfix(SteamLobby __instance, LobbyCreated_t callback)
		{
			//IL_0000: Unknown result type (might be due to invalid IL or missing references)
			//IL_0001: Unknown result type (might be due to invalid IL or missing references)
			//IL_0007: Invalid comparison between Unknown and I4
			//IL_000b: Unknown result type (might be due to invalid IL or missing references)
			//IL_0011: Unknown result type (might be due to invalid IL or missing references)
			//IL_003e: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if ((int)callback.m_eResult == 1)
				{
					SteamMatchmaking.SetLobbyData(new CSteamID(callback.m_ulSteamIDLobby), "QuickLoad", "0");
					ModState.QuickLoad = false;
					LobbyCapacity.SetTransportMaxClients(__instance.maxPlayers - 1);
					Log.Info($"lobby {callback.m_ulSteamIDLobby} created with maxPlayers={__instance.maxPlayers}");
				}
			}
			catch (Exception arg)
			{
				Log.Error($"OnLobbyCreatedPatch postfix: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobby), "SetMaxPlayers")]
	internal static class SetMaxPlayersPatch
	{
		private static void Postfix(SteamLobby __instance)
		{
			try
			{
				LobbyCapacity.SetTransportMaxClients(__instance.maxPlayers - 1);
			}
			catch (Exception arg)
			{
				Log.Error($"SetMaxPlayersPatch: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(ClientInstance), "RpcLogic___UpdateOnClients_3316948804")]
	internal static class UpdateOnClientsPatch
	{
		private static void Prefix(ref int maxPlayers)
		{
			maxPlayers = Mathf.Clamp(maxPlayers, 2, 10);
		}
	}
	internal static class PreviewSlots
	{
		public static bool Exists(int id)
		{
			LobbyController instance = LobbyController.Instance;
			int num;
			if ((Object)(object)instance != (Object)null && id >= 0 && id < instance.previews.Length)
			{
				num = (((Object)(object)instance.previews[id] != (Object)null) ? 1 : 0);
				if (num != 0)
				{
					goto IL_0047;
				}
			}
			else
			{
				num = 0;
			}
			Log.Info($"player {id} has no lobby preview slot, skipping preview RPC");
			goto IL_0047;
			IL_0047:
			return (byte)num != 0;
		}
	}
	[HarmonyPatch(typeof(ClientInstance), "RpcLogic___RunIntoLobby_3316948804")]
	internal static class RunIntoLobbyPatch
	{
		private static bool Prefix(int id)
		{
			return PreviewSlots.Exists(id);
		}
	}
	[HarmonyPatch(typeof(ClientInstance), "RpcLogic___MenuAnimationObservers_1692629761")]
	internal static class MenuAnimationObserversPatch
	{
		private static bool Prefix(int id)
		{
			return PreviewSlots.Exists(id);
		}
	}
	[HarmonyPatch(typeof(ClientInstance), "RpcLogic___DressAboubiObservers_2497120398")]
	internal static class DressAboubiObserversPatch
	{
		private static bool Prefix(int id)
		{
			return PreviewSlots.Exists(id);
		}
	}
	internal static class GameFields
	{
		public static readonly FieldRef<PlayerListItem, GameObject> CosmeticButton = AccessTools.FieldRefAccess<PlayerListItem, GameObject>("cosmeticbutton");

		public static readonly FieldRef<PlayerListItem, PauseManager> PauseManager = AccessTools.FieldRefAccess<PlayerListItem, PauseManager>("pauseManager");

		public static readonly FieldRef<PlayerListItem, LobbyController> LobbyController = AccessTools.FieldRefAccess<PlayerListItem, LobbyController>("lobbyController");

		public static readonly FieldRef<PlayerListItem, GameManager> GameManager = AccessTools.FieldRefAccess<PlayerListItem, GameManager>("gameManager");

		public static readonly FieldRef<PlayerListItem, TMP_Dropdown> TeamDropdown = AccessTools.FieldRefAccess<PlayerListItem, TMP_Dropdown>("teamIdDropdown");

		public static readonly FieldRef<PlayerListItem, ulong> LocalSteamId = AccessTools.FieldRefAccess<PlayerListItem, ulong>("localSteamId");

		public static readonly FieldRef<GameManager, bool> PlayingTeams = AccessTools.FieldRefAccess<GameManager, bool>("playingTeams");
	}
	[HarmonyPatch(typeof(PlayerListItem), "Update")]
	internal static class PlayerListItemUpdatePatch
	{
		private static bool warned;

		private static bool Prefix(PlayerListItem __instance)
		{
			//IL_0041: 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_00bf: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				PauseManager val = GameFields.PauseManager.Invoke(__instance);
				GameObject val2 = GameFields.CosmeticButton.Invoke(__instance);
				if ((Object)(object)val2 != (Object)null && (Object)(object)val != (Object)null)
				{
					val2.transform.localScale = (val.inMainMenu ? Vector3.one : Vector3.zero);
				}
				Transform parent = ((Component)__instance).transform.parent;
				bool flag = (Object)(object)parent != (Object)null && ((Object)((Component)parent).gameObject).name == "-- TAB SCREEN --";
				LobbyController val3 = GameFields.LobbyController.Invoke(__instance);
				if (__instance.PlayerIdNumber > 0 && (Object)(object)val3 != (Object)null)
				{
					Transform[] slots = (flag ? val3.tabclientPosition : val3.clientPosition);
					((Component)__instance).transform.position = SlotPosition(slots, __instance.PlayerIdNumber - 1);
				}
				GameManager val4 = GameFields.GameManager.Invoke(__instance);
				TMP_Dropdown val5 = GameFields.TeamDropdown.Invoke(__instance);
				if ((Object)(object)val4 != (Object)null && (Object)(object)val5 != (Object)null)
				{
					((Component)val5).gameObject.SetActive(GameFields.PlayingTeams.Invoke(val4));
					bool num = (Object)(object)InstanceFinder.NetworkManager != (Object)null && InstanceFinder.NetworkManager.IsServer;
					bool flag2 = GameFields.LocalSteamId.Invoke(__instance) == __instance.PlayerSteamID;
					if (num || flag2)
					{
						((Selectable)val5).interactable = !flag;
					}
				}
				return false;
			}
			catch (Exception arg)
			{
				if (!warned)
				{
					warned = true;
					Log.Error($"PlayerListItemUpdatePatch: {arg}");
				}
				return true;
			}
		}

		private static Vector3 SlotPosition(Transform[] slots, int index)
		{
			//IL_0016: Unknown result type (might be due to invalid IL or missing references)
			//IL_001b: Unknown result type (might be due to invalid IL or missing references)
			//IL_001c: Unknown result type (might be due to invalid IL or missing references)
			//IL_0022: Unknown result type (might be due to invalid IL or missing references)
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0009: Unknown result type (might be due to invalid IL or missing references)
			if (index < slots.Length)
			{
				return slots[index].position;
			}
			Vector3 position = slots[^1].position;
			return new Vector3(position.x, position.y - (float)(index - slots.Length + 1) * 0.5f, position.z);
		}
	}
	[HarmonyPatch(typeof(PlayerListItem), "Start")]
	internal static class TeamDropdownPatch
	{
		private static void Postfix(PlayerListItem __instance)
		{
			try
			{
				if ((Object)(object)SteamLobby.Instance == (Object)null || SteamLobby.Instance.maxPlayers <= 4)
				{
					return;
				}
				TMP_Dropdown val = GameFields.TeamDropdown.Invoke(__instance);
				if (!((Object)(object)val == (Object)null))
				{
					int maxPlayers = SteamLobby.Instance.maxPlayers;
					List<string> list = new List<string>();
					for (int i = 1; i <= maxPlayers; i++)
					{
						list.Add($"Team {i}");
					}
					val.ClearOptions();
					val.AddOptions(list);
					val.SetValueWithoutNotify(ScoreManager.Instance.GetTeamId(__instance.PlayerIdNumber));
					Log.Info($"team dropdown expanded to {maxPlayers} options for player {__instance.PlayerIdNumber}");
				}
			}
			catch (Exception arg)
			{
				Log.Error($"TeamDropdownPatch: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobby), "OnGetLobbyData")]
	internal static class QuickLoadLobbyDataPatch
	{
		private static void Postfix(LobbyDataUpdate_t result)
		{
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0021: Unknown result type (might be due to invalid IL or missing references)
			//IL_0027: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				if (!((Object)(object)SteamLobby.Instance == (Object)null) && result.m_ulSteamIDLobby == SteamLobby.Instance.CurrentLobbyID)
				{
					ModState.QuickLoad = SteamMatchmaking.GetLobbyData(new CSteamID(result.m_ulSteamIDLobby), "QuickLoad") == "1";
				}
			}
			catch (Exception arg)
			{
				Log.Error($"QuickLoadLobbyDataPatch: {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobby), "OnLobbyEntered")]
	internal static class QuickLoadTogglePatch
	{
		private static void Postfix(SteamLobby __instance, LobbyEnter_t callback)
		{
			//IL_0002: Unknown result type (might be due to invalid IL or missing references)
			//IL_000d: Unknown result type (might be due to invalid IL or missing references)
			//IL_0028: Unknown result type (might be due to invalid IL or missing references)
			try
			{
				CSteamID val = default(CSteamID);
				((CSteamID)(ref val))..ctor(callback.m_ulSteamIDLobby);
				ModState.QuickLoad = SteamMatchmaking.GetLobbyData(val, "QuickLoad") == "1";
				CreateToggle(__instance, val);
			}
			catch (Exception arg)
			{
				Log.Error($"QuickLoadTogglePatch: {arg}");
			}
		}

		private static void CreateToggle(SteamLobby lobby, CSteamID lobbyId)
		{
			//IL_0007: Unknown result type (might be due to invalid IL or missing references)
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			//IL_0088: Unknown result type (might be due to invalid IL or missing references)
			//IL_0094: Unknown result type (might be due to invalid IL or missing references)
			//IL_00a8: Unknown result type (might be due to invalid IL or missing references)
			//IL_00ad: Unknown result type (might be due to invalid IL or missing references)
			if ((Object)(object)lobby.enemyOutlineToggle == (Object)null)
			{
				return;
			}
			Transform parent = ((Component)lobby.enemyOutlineToggle).transform.parent;
			RectTransform val = (RectTransform)(object)((parent is RectTransform) ? parent : null);
			if ((Object)(object)val == (Object)null || (Object)(object)((Transform)val).parent == (Object)null)
			{
				return;
			}
			Transform val2 = ((Transform)val).parent.Find("EnableQuickLoad");
			if ((Object)(object)val2 != (Object)null)
			{
				Object.Destroy((Object)(object)((Component)val2).gameObject);
			}
			RectTransform val3 = Object.Instantiate<RectTransform>(val, ((Transform)val).parent);
			((Object)val3).name = "EnableQuickLoad";
			((Transform)val3).localScale = Vector3.one;
			((Transform)val3).localPosition = ((Transform)val3).localPosition + new Vector3(0f, -60f, 0f);
			Toggle componentInChildren = ((Component)val3).GetComponentInChildren<Toggle>();
			if ((Object)(object)componentInChildren == (Object)null)
			{
				Log.Warn("QuickLoad toggle row has no Toggle component");
				return;
			}
			for (int i = 0; i < ((UnityEventBase)componentInChildren.onValueChanged).GetPersistentEventCount(); i++)
			{
				((UnityEventBase)componentInChildren.onValueChanged).SetPersistentListenerState(i, (UnityEventCallState)0);
			}
			((UnityEventBase)componentInChildren.onValueChanged).RemoveAllListeners();
			bool flag = (Object)(object)InstanceFinder.NetworkManager != (Object)null && InstanceFinder.NetworkManager.IsServer;
			componentInChildren.SetIsOnWithoutNotify(ModState.QuickLoad);
			((Selectable)componentInChildren).interactable = flag;
			if (flag)
			{
				((UnityEvent<bool>)(object)componentInChildren.onValueChanged).AddListener((UnityAction<bool>)delegate(bool isOn)
				{
					//IL_0001: Unknown result type (might be due to invalid IL or missing references)
					SteamMatchmaking.SetLobbyData(lobbyId, "QuickLoad", isOn ? "1" : "0");
				});
			}
			TextMeshProUGUI componentInChildren2 = ((Component)val3).GetComponentInChildren<TextMeshProUGUI>();
			if ((Object)(object)componentInChildren2 != (Object)null)
			{
				((TMP_Text)componentInChildren2).text = "  Enable Quick Load";
			}
			Log.Info($"QuickLoad toggle created (host={flag}, on={ModState.QuickLoad})");
		}
	}
	[HarmonyPatch(typeof(RoundManager), "InterfaceSetup")]
	internal static class QuickLoadInterfacePatch
	{
		private static bool Prefix(ref IEnumerator __result)
		{
			if (!ModState.QuickLoad)
			{
				return true;
			}
			__result = LoadingScreenOnly();
			return false;
		}

		private static IEnumerator LoadingScreenOnly()
		{
			if ((Object)(object)SceneMotor.Instance != (Object)null)
			{
				SceneMotor.Instance.ShowLoadingScreen();
			}
			yield break;
		}
	}
	[HarmonyPatch(typeof(RoundManager), "NextRoundCall")]
	internal static class RoundEndArraysPatch
	{
		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
		{
			List<CodeInstruction> list = new List<CodeInstruction>(instructions);
			int num = 0;
			for (int i = 0; i + 1 < list.Count; i++)
			{
				if (!(list[i].opcode != OpCodes.Ldc_I4_4) && !(list[i + 1].opcode != OpCodes.Newarr))
				{
					Type type = list[i + 1].operand as Type;
					if (!(type != typeof(string)) || !(type != typeof(int)))
					{
						list[i].opcode = OpCodes.Ldc_I4_S;
						list[i].operand = (sbyte)10;
						num++;
					}
				}
			}
			if (num == 2)
			{
				Log.Info($"round-end name/score arrays extended to {10}");
			}
			else
			{
				Log.Warn($"round-end array pattern changed ({num} matches, expected 2); post-round screen limited to 4 players");
			}
			return list;
		}
	}
	internal static class FfaTeams
	{
		public static void AssignUniqueTeams(string context)
		{
			try
			{
				if (!((Object)(object)InstanceFinder.NetworkManager == (Object)null) && InstanceFinder.NetworkManager.IsServer && !((Object)(object)ScoreManager.Instance == (Object)null))
				{
					int[] array = ClientInstance.playerInstances.Keys.ToArray();
					ScoreManager.Instance.ResetTeams();
					int[] array2 = array;
					foreach (int num in array2)
					{
						ScoreManager.Instance.SetTeamId(num, num);
					}
					Log.Info(context + ": unique FFA team per player [" + string.Join(",", array) + "]");
				}
			}
			catch (Exception arg)
			{
				Log.Error($"FfaTeams({context}): {arg}");
			}
		}
	}
	[HarmonyPatch(typeof(SteamLobby), "SetGamemode", new Type[] { typeof(int) })]
	internal static class GamemodeFfaPatch
	{
		private static void Postfix(int value)
		{
			if (value == 0)
			{
				FfaTeams.AssignUniqueTeams("SetGamemode");
			}
		}
	}
	[HarmonyPatch(typeof(GameManager), "StartGame")]
	internal static class StartGameFfaPatch
	{
		private static void Postfix(GameManager __instance)
		{
			try
			{
				if (!GameFields.PlayingTeams.Invoke(__instance))
				{
					FfaTeams.AssignUniqueTeams("StartGame");
				}
			}
			catch (Exception arg)
			{
				Log.Error($"StartGameFfaPatch: {arg}");
			}
		}
	}
}