using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Reflection;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using BepInEx;
using BepInEx.Configuration;
using BepInEx.Core.Logging.Interpolation;
using BepInEx.Logging;
using BepInEx.Unity.IL2CPP;
using HarmonyLib;
using Il2CppSystem.Collections.Generic;
using Mirror;
using MorePlayers.Configuration;
using MorePlayers.Localization;
using UnityEngine;
using UnityEngine.Localization;
using UnityEngine.Localization.Settings;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: AssemblyTitle("MorePlayers")]
[assembly: AssemblyDescription("More Players mod for Island Market Simulator by Ice Box Studio")]
[assembly: AssemblyCompany("Ice Box Studio")]
[assembly: AssemblyProduct("MorePlayers")]
[assembly: AssemblyCopyright("Copyright © 2026 Ice Box Studio All rights reserved.")]
[assembly: AssemblyTrademark("")]
[assembly: ComVisible(false)]
[assembly: Guid("B4F2A1C9-3D7E-4A5B-8C6D-1234567890EF")]
[assembly: AssemblyFileVersion("1.0.0.0")]
[assembly: TargetFramework(".NETCoreApp,Version=v6.0", FrameworkDisplayName = ".NET 6.0")]
[assembly: AssemblyVersion("1.0.0.0")]
namespace MorePlayers
{
	[BepInPlugin("IceBoxStudio.IslandMarketSimulator.MorePlayers", "MorePlayers", "1.0.0")]
	[BepInDependency(/*Could not decode attribute arguments.*/)]
	public class MorePlayers : BasePlugin
	{
		public static MorePlayers _Instance;

		private Harmony _harmony;

		private bool patchesApplied;

		private const string ModConfigManagerApiTypeName = "ModConfigManager.Api.ModConfigManagerAPI";

		private const string ModConfigManagerRegisterMethodName = "RegisterPluginInfo";

		public static MorePlayers Instance => _Instance;

		internal static ManualLogSource Logger { get; private set; }

		public override void Load()
		{
			//IL_0121: Unknown result type (might be due to invalid IL or missing references)
			//IL_0127: Expected O, but got Unknown
			//IL_0029: Unknown result type (might be due to invalid IL or missing references)
			//IL_002f: Expected O, but got Unknown
			//IL_0072: Unknown result type (might be due to invalid IL or missing references)
			//IL_0078: Expected O, but got Unknown
			//IL_00c6: Unknown result type (might be due to invalid IL or missing references)
			//IL_00cc: Expected O, but got Unknown
			_Instance = this;
			Logger = ((BasePlugin)this).Log;
			bool flag = default(bool);
			try
			{
				Logger.LogInfo((object)"=============================================");
				ManualLogSource logger = Logger;
				BepInExInfoLogInterpolatedStringHandler val = new BepInExInfoLogInterpolatedStringHandler(1, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("MorePlayers");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(LocalizationManager.Instance.GetLocalizedText("plugin.initializing"));
				}
				logger.LogInfo(val);
				ManualLogSource logger2 = Logger;
				val = new BepInExInfoLogInterpolatedStringHandler(54, 1, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(LocalizationManager.Instance.GetLocalizedText("plugin.author_prefix"));
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral("Ice Box Studio(https://steamcommunity.com/id/ibox666/)");
				}
				logger2.LogInfo(val);
				ConfigManager.Initialize(((BasePlugin)this).Config);
				RegisterToModConfigManager();
				ApplyPatches();
				ManualLogSource logger3 = Logger;
				val = new BepInExInfoLogInterpolatedStringHandler(1, 2, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("MorePlayers");
					((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" ");
					((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(LocalizationManager.Instance.GetLocalizedText("plugin.initialized"));
				}
				logger3.LogInfo(val);
				Logger.LogInfo((object)"=============================================");
			}
			catch (Exception ex)
			{
				ManualLogSource logger4 = Logger;
				BepInExErrorLogInterpolatedStringHandler val2 = new BepInExErrorLogInterpolatedStringHandler(9, 3, ref flag);
				if (flag)
				{
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>("MorePlayers");
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral(" 初始化错误: ");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.Message);
					((BepInExLogInterpolatedStringHandler)val2).AppendLiteral("\n");
					((BepInExLogInterpolatedStringHandler)val2).AppendFormatted<string>(ex.StackTrace);
				}
				logger4.LogError(val2);
			}
		}

		private void ApplyPatches()
		{
			//IL_0037: Unknown result type (might be due to invalid IL or missing references)
			//IL_003d: Expected O, but got Unknown
			//IL_000e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0018: Expected O, but got Unknown
			if (!patchesApplied)
			{
				try
				{
					_harmony = new Harmony("IceBoxStudio.IslandMarketSimulator.MorePlayers");
					_harmony.PatchAll();
					patchesApplied = true;
					return;
				}
				catch (Exception ex)
				{
					ManualLogSource logger = Logger;
					bool flag = default(bool);
					BepInExErrorLogInterpolatedStringHandler val = new BepInExErrorLogInterpolatedStringHandler(10, 3, ref flag);
					if (flag)
					{
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>("MorePlayers");
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral(" 应用补丁错误: ");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.Message);
						((BepInExLogInterpolatedStringHandler)val).AppendLiteral("\n");
						((BepInExLogInterpolatedStringHandler)val).AppendFormatted<string>(ex.StackTrace);
					}
					logger.LogError(val);
					return;
				}
			}
			Logger.LogInfo((object)LocalizationManager.Instance.GetLocalizedText("plugin.patches_skipped"));
		}

		private void RegisterToModConfigManager()
		{
			Type type = AppDomain.CurrentDomain.GetAssemblies().FirstOrDefault((Assembly assembly) => assembly.GetType("ModConfigManager.Api.ModConfigManagerAPI") != null)?.GetType("ModConfigManager.Api.ModConfigManagerAPI");
			if (!(type == null))
			{
				MethodInfo method = type.GetMethod("RegisterPluginInfo", BindingFlags.Static | BindingFlags.Public);
				if (!(method == null))
				{
					method.Invoke(null, new object[5]
					{
						"IceBoxStudio.IslandMarketSimulator.MorePlayers",
						LocalizationManager.Instance.GetLocalizedText("plugin.name"),
						"1.0.0",
						"Ice Box Studio",
						LocalizationManager.Instance.GetLocalizedText("plugin.description")
					});
				}
			}
		}
	}
	public static class PluginInfo
	{
		public const string PLUGIN_GUID = "IceBoxStudio.IslandMarketSimulator.MorePlayers";

		public const string PLUGIN_NAME = "MorePlayers";

		public const string PLUGIN_VERSION = "1.0.0";
	}
}
namespace MorePlayers.Patches
{
	[HarmonyPatch(typeof(NetworkManager), "Start")]
	public static class NetworkManager_Start_Patch
	{
		public static void Postfix(NetworkManager __instance)
		{
			NetworkManagerPatchHelpers.ApplyConfiguredConnectionLimit(__instance, "Start");
		}
	}
	[HarmonyPatch(typeof(NetworkManager), "StartHost")]
	public static class NetworkManager_StartHost_Patch
	{
		public static void Prefix(NetworkManager __instance)
		{
			NetworkManagerPatchHelpers.ApplyConfiguredConnectionLimit(__instance, "StartHost");
		}
	}
	[HarmonyPatch(typeof(NetworkManager), "StartServer")]
	public static class NetworkManager_StartServer_Patch
	{
		public static void Prefix(NetworkManager __instance)
		{
			NetworkManagerPatchHelpers.ApplyConfiguredConnectionLimit(__instance, "StartServer");
		}
	}
	[HarmonyPatch(typeof(CustomNetworkManager), "OnServerAddPlayer")]
	public static class CustomNetworkManager_OnServerAddPlayer_Patch
	{
		public static void Postfix(CustomNetworkManager __instance, NetworkConnectionToClient conn)
		{
			//IL_0051: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_0058: 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_0060: 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_0067: Unknown result type (might be due to invalid IL or missing references)
			//IL_007d: Unknown result type (might be due to invalid IL or missing references)
			GameObject val = (((Object)(object)((conn != null) ? ((NetworkConnection)conn).identity : null) != (Object)null) ? ((Component)((NetworkConnection)conn).identity).gameObject : null);
			if (!((Object)(object)val == (Object)null))
			{
				int playerIndex = (((Object)(object)__instance != (Object)null && ((NetworkManager)__instance).numPlayers > 0) ? (((NetworkManager)__instance).numPlayers - 1) : 0);
				Vector3 position = val.transform.position;
				Vector3 adjustedSpawnPosition = NetworkManagerPatchHelpers.GetAdjustedSpawnPosition((NetworkManager)(object)__instance, position, playerIndex);
				Vector3 val2 = adjustedSpawnPosition - position;
				if (((Vector3)(ref val2)).sqrMagnitude > 0.0001f)
				{
					val.transform.position = adjustedSpawnPosition;
				}
				if (conn != null)
				{
					_ = conn.connectionId;
				}
				if ((Object)(object)__instance != (Object)null)
				{
					_ = ((NetworkManager)__instance).numPlayers;
				}
			}
		}
	}
	internal static class NetworkManagerPatchHelpers
	{
		internal static void ApplyConfiguredConnectionLimit(NetworkManager networkManager, string source)
		{
			if (networkManager is CustomNetworkManager && ConfigManager.Instance != null)
			{
				int value = ConfigManager.Instance.MaxPlayers.Value;
				if (networkManager.maxConnections != value)
				{
					networkManager.maxConnections = value;
				}
			}
		}

		internal static Vector3 GetAdjustedSpawnPosition(NetworkManager networkManager, Vector3 basePosition, int playerIndex)
		{
			//IL_000a: Unknown result type (might be due to invalid IL or missing references)
			//IL_0050: Unknown result type (might be due to invalid IL or missing references)
			//IL_0056: Unknown result type (might be due to invalid IL or missing references)
			//IL_005b: Unknown result type (might be due to invalid IL or missing references)
			//IL_005d: Unknown result type (might be due to invalid IL or missing references)
			//IL_005e: Unknown result type (might be due to invalid IL or missing references)
			//IL_0060: Unknown result type (might be due to invalid IL or missing references)
			//IL_0017: Unknown result type (might be due to invalid IL or missing references)
			int spawnAnchorCount = GetSpawnAnchorCount();
			if (spawnAnchorCount <= 0)
			{
				return basePosition;
			}
			if (playerIndex < 0)
			{
				playerIndex = 0;
			}
			if (playerIndex < spawnAnchorCount)
			{
				return basePosition;
			}
			int num = playerIndex / spawnAnchorCount;
			int num2 = playerIndex % spawnAnchorCount;
			float num3 = 1.75f * (float)num;
			float num4 = 360f / (float)spawnAnchorCount * (float)num2 * Mathf.Deg2Rad;
			Vector3 val = new Vector3(Mathf.Cos(num4), 0f, Mathf.Sin(num4)) * num3;
			return basePosition + val;
		}

		private static int GetSpawnAnchorCount()
		{
			if (NetworkManager.startPositions != null && NetworkManager.startPositions.Count > 0)
			{
				return NetworkManager.startPositions.Count;
			}
			return 0;
		}
	}
	[HarmonyPatch(typeof(SteamLobby), "Start")]
	public static class SteamLobby_Start_Patch
	{
		public static void Prefix(SteamLobby __instance)
		{
			SteamLobbyPatchHelpers.ApplyConfiguredLobbyLimit(__instance, "Start");
		}
	}
	[HarmonyPatch(typeof(SteamLobby), "StartImmediateHost")]
	public static class SteamLobby_StartImmediateHost_Patch
	{
		public static void Prefix(SteamLobby __instance)
		{
			SteamLobbyPatchHelpers.ApplyConfiguredLobbyLimit(__instance, "StartImmediateHost");
		}
	}
	[HarmonyPatch(typeof(SteamLobby), "CreateLobbyAfterTutorial")]
	public static class SteamLobby_CreateLobbyAfterTutorial_Patch
	{
		public static void Prefix(SteamLobby __instance)
		{
			SteamLobbyPatchHelpers.ApplyConfiguredLobbyLimit(__instance, "CreateLobbyAfterTutorial");
		}
	}
	internal static class SteamLobbyPatchHelpers
	{
		internal static void ApplyConfiguredLobbyLimit(SteamLobby steamLobby, string source)
		{
			if (!((Object)(object)steamLobby == (Object)null) && ConfigManager.Instance != null)
			{
				int value = ConfigManager.Instance.MaxPlayers.Value;
				if (steamLobby.maxPlayers != value)
				{
					steamLobby.maxPlayers = value;
				}
				CustomNetworkManager val = Object.FindObjectOfType<CustomNetworkManager>();
				if ((Object)(object)val != (Object)null)
				{
					NetworkManagerPatchHelpers.ApplyConfiguredConnectionLimit((NetworkManager)(object)val, "SteamLobby." + source);
				}
			}
		}
	}
}
namespace MorePlayers.Localization
{
	public static class LocalizationHelper
	{
		public static Dictionary<string, string> GetDefaultTranslations(string language)
		{
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			switch (language)
			{
			case "zh":
				dictionary.Add("plugin.initializing", "开始初始化...");
				dictionary.Add("plugin.author_prefix", "作者：");
				dictionary.Add("plugin.initialized", "初始化成功！");
				dictionary.Add("plugin.patches_skipped", "补丁已应用，跳过...");
				dictionary.Add("plugin.name", "更多玩家");
				dictionary.Add("plugin.description", "提高玩家数量上限。");
				dictionary.Add("config.max_players", "最大玩家数量限制");
				break;
			case "zh-TW":
				dictionary.Add("plugin.initializing", "開始初始化...");
				dictionary.Add("plugin.author_prefix", "作者：");
				dictionary.Add("plugin.initialized", "初始化成功！");
				dictionary.Add("plugin.patches_skipped", "補丁已套用，略過...");
				dictionary.Add("plugin.name", "更多玩家");
				dictionary.Add("plugin.description", "提高玩家數量上限。");
				dictionary.Add("config.max_players", "最大玩家數量限制");
				break;
			case "en":
				dictionary.Add("plugin.initializing", "Initializing...");
				dictionary.Add("plugin.author_prefix", "Author: ");
				dictionary.Add("plugin.initialized", "Initialized successfully!");
				dictionary.Add("plugin.patches_skipped", "Patches already applied, skipping...");
				dictionary.Add("plugin.name", "More Players");
				dictionary.Add("plugin.description", "Increases the maximum number of players that can be in the game.");
				dictionary.Add("config.max_players", "Max Player Limit");
				break;
			case "ja":
				dictionary.Add("plugin.initializing", "初期化中...");
				dictionary.Add("plugin.author_prefix", "作者: ");
				dictionary.Add("plugin.initialized", "初期化に成功しました！");
				dictionary.Add("plugin.patches_skipped", "パッチは適用済みです。スキップします...");
				dictionary.Add("plugin.name", "より多くのプレイヤー");
				dictionary.Add("plugin.description", "ゲームに参加できるプレイヤー数の上限を増加します。");
				dictionary.Add("config.max_players", "最大プレイヤー数");
				break;
			}
			return dictionary;
		}
	}
	public class LocalizationManager
	{
		private static LocalizationManager _instance;

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

		private string _currentLocale = "en";

		public static readonly string[] SupportedLanguages = new string[4] { "en", "zh", "zh-TW", "ja" };

		public static LocalizationManager Instance => _instance ?? (_instance = new LocalizationManager());

		private LocalizationManager()
		{
			string[] supportedLanguages = SupportedLanguages;
			foreach (string text in supportedLanguages)
			{
				Dictionary<string, string> defaultTranslations = LocalizationHelper.GetDefaultTranslations(text);
				if (defaultTranslations != null && defaultTranslations.Count > 0)
				{
					_localizations[text] = defaultTranslations;
				}
			}
		}

		private string GetCurrentLocale()
		{
			if (!PlayerPrefs.HasKey("Lang"))
			{
				return _currentLocale;
			}
			int @int = PlayerPrefs.GetInt("Lang");
			ILocalesProvider availableLocales = LocalizationSettings.AvailableLocales;
			List<Locale> val = ((availableLocales != null) ? availableLocales.Locales : null);
			if (val == null || @int < 0 || @int >= val.Count)
			{
				return _currentLocale;
			}
			string code = val[@int].Identifier.Code;
			_currentLocale = (_localizations.ContainsKey(code) ? code : "en");
			return _currentLocale;
		}

		public string GetLocalizedText(string key, params object[] args)
		{
			string currentLocale = GetCurrentLocale();
			if (_localizations.TryGetValue(currentLocale, out var value) && value.TryGetValue(key, out var value2))
			{
				return string.Format(value2, args);
			}
			if (currentLocale != "en" && _localizations.TryGetValue("en", out var value3) && value3.TryGetValue(key, out var value4))
			{
				return string.Format(value4, args);
			}
			return key;
		}
	}
}
namespace MorePlayers.Configuration
{
	public class ConfigManager
	{
		private static ConfigManager _instance;

		private readonly ConfigFile _configFile;

		private readonly Dictionary<string, ConfigEntry<bool>> _boolConfigs = new Dictionary<string, ConfigEntry<bool>>();

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

		private readonly Dictionary<string, ConfigEntry<int>> _intConfigs = new Dictionary<string, ConfigEntry<int>>();

		private readonly Dictionary<string, ConfigEntry<float>> _floatConfigs = new Dictionary<string, ConfigEntry<float>>();

		private readonly Dictionary<string, ConfigEntry<KeyCode>> _keyCodeConfigs = new Dictionary<string, ConfigEntry<KeyCode>>();

		public static ConfigManager Instance => _instance;

		public ConfigEntry<int> MaxPlayers { get; private set; }

		private ConfigManager(ConfigFile configFile)
		{
			_configFile = configFile;
			InitializeDefaultConfigs();
		}

		public static void Initialize(ConfigFile configFile)
		{
			if (_instance == null)
			{
				_instance = new ConfigManager(configFile);
			}
		}

		private void InitializeDefaultConfigs()
		{
			MaxPlayers = RegisterIntMax("General", "MaxPlayers", GetLocalizedDescription("config.max_players"), 10, 2, 10);
		}

		private string GetLocalizedDescription(string key)
		{
			return LocalizationManager.Instance?.GetLocalizedText(key) ?? key;
		}

		public ConfigEntry<bool> RegisterBool(string section, string key, string description, bool defaultValue)
		{
			ConfigEntry<bool> val = _configFile.Bind<bool>(section, key, defaultValue, description);
			_boolConfigs[key] = val;
			return val;
		}

		public ConfigEntry<string> RegisterString(string section, string key, string description, string defaultValue)
		{
			ConfigEntry<string> val = _configFile.Bind<string>(section, key, defaultValue, description);
			_stringConfigs[key] = val;
			return val;
		}

		public ConfigEntry<KeyCode> RegisterKeyCode(string section, string key, string description, KeyCode defaultValue)
		{
			//IL_0008: Unknown result type (might be due to invalid IL or missing references)
			ConfigEntry<KeyCode> val = _configFile.Bind<KeyCode>(section, key, defaultValue, description);
			_keyCodeConfigs[key] = val;
			return val;
		}

		public ConfigEntry<int> RegisterInt(string section, string key, string description, int defaultValue)
		{
			ConfigEntry<int> val = _configFile.Bind<int>(section, key, defaultValue, description);
			_intConfigs[key] = val;
			return val;
		}

		public ConfigEntry<int> RegisterIntMax(string section, string key, string description, int defaultValue, int minValue, int maxValue)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ConfigEntry<int> val = _configFile.Bind<int>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<int>(minValue, maxValue), Array.Empty<object>()));
			_intConfigs[key] = val;
			return val;
		}

		public ConfigEntry<float> RegisterFloat(string section, string key, string description, float defaultValue)
		{
			ConfigEntry<float> val = _configFile.Bind<float>(section, key, defaultValue, description);
			_floatConfigs[key] = val;
			return val;
		}

		public ConfigEntry<float> RegisterFloatMax(string section, string key, string description, float defaultValue, float minValue, float maxValue)
		{
			//IL_0019: Unknown result type (might be due to invalid IL or missing references)
			//IL_0023: Expected O, but got Unknown
			ConfigEntry<float> val = _configFile.Bind<float>(section, key, defaultValue, new ConfigDescription(description, (AcceptableValueBase)(object)new AcceptableValueRange<float>(minValue, maxValue), Array.Empty<object>()));
			_floatConfigs[key] = val;
			return val;
		}
	}
}