diff --git a/src/Extensions/ListExt.cs b/src/Extensions/ListExt.cs
new file mode 100644
index 0000000..25c0efc
--- /dev/null
+++ b/src/Extensions/ListExt.cs
@@ -0,0 +1,51 @@
+using RemoveMultiplayerPlayerLimit.src;
+using System.Collections.Generic;
+using System.IO;
+
+namespace RemoveMultiplayerPlayetLimit.src.Extensions
+{
+    public static class ListExt
+    {
+        public static bool TryGetNext<T>(this List<T> list, T value, out T next)
+        {
+            return TryGetAfter(list, value, 1, out next);
+        }
+
+        public static bool TryGetAfter<T>(this List<T> list, T value, int num, out T after)
+        {
+            after = default;
+
+            var index = list.IndexOf(value);
+
+            if (index != -1 && list.Count > index + num)
+            {
+                after = list[index + num];
+
+                return true;
+            }
+
+            return false;
+        }
+
+        public static bool TryGetLast<T>(this List<T> list, T value, out T last)
+        {
+            return TryGetBefore(list, value, 1, out last);
+        }
+
+        public static bool TryGetBefore<T>(this List<T> list, T value, int num, out T before)
+        {
+            before = default;
+
+            var index = list.IndexOf(value);
+
+            if (index != -1 && index - num >= 0)
+            {
+                before = list[index - num];
+
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/src/ModEntry.cs b/src/ModEntry.cs
index 003dac2..368947f 100644
--- a/src/ModEntry.cs
+++ b/src/ModEntry.cs
@@ -1,186 +1,155 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Text.Json;
+using Godot;
 using HarmonyLib;
 using MegaCrit.Sts2.Core.Context;
 using MegaCrit.Sts2.Core.Entities.RestSite;
 using MegaCrit.Sts2.Core.Logging;
 using MegaCrit.Sts2.Core.Modding;
-using MegaCrit.Sts2.Core.Nodes.Rooms;
 using MegaCrit.Sts2.Core.Nodes.RestSite;
+using MegaCrit.Sts2.Core.Nodes.Rooms;
+using MegaCrit.Sts2.Core.Runs;
+using RemoveMultiplayerPlayerLimit.src;
+using RemoveMultiplayerPlayetLimit.src;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Text.Json;
 
 namespace RemoveMultiplayerPlayerLimit;
 
 [ModInitializer("Initialize")]
 public static partial class ModEntry
 {
-	private const int DefaultPlayerLimit = 8;
+	public static Option Option { get; set; }
 
-	private const int MinSupportedPlayerLimit = 4;
+	public static Harmony Harmony { get; set; } = new("Rain156.RemoveMultiplayerPlayerLimit");
 
-	private const int MaxSupportedPlayerLimit = 16;
+    internal const int DefaultPlayerLimit = 8;
 
-	private const int VanillaSlotIdBits = 2;
+    internal const int MinSupportedPlayerLimit = 4;
 
-	private const int VanillaLobbyListLengthBits = 3;
+    internal const int MaxSupportedPlayerLimit = 16;
 
-	private const string ModFolderName = "RemoveMultiplayerPlayerLimit";
+    internal const int VanillaSlotIdBits = 2;
 
-	private const string ConfigFileName = "config.json";
+    internal const int VanillaLobbyListLengthBits = 3;
 
-	private static int TargetPlayerLimit { get; set; } = DefaultPlayerLimit;
+    internal const string ModFolderName = "RemoveMultiplayerPlayerLimit";
 
-	private static int SlotIdBits { get; set; } = RequiredBitsForExclusiveUpperBound(DefaultPlayerLimit);
+    internal const string ConfigFileName = "config.json";
 
-	private static int LobbyListLengthBits { get; set; } = RequiredBitsForExclusiveUpperBound(DefaultPlayerLimit + 1);
+    private static int SlotIdBits { get; set; }
 
-	private static int SlotIdCapacity { get; set; } = 1 << RequiredBitsForExclusiveUpperBound(DefaultPlayerLimit);
+    private static int LobbyListLengthBits { get; set; }
 
-	private static int LobbyListLengthCapacity { get; set; } = 1 << RequiredBitsForExclusiveUpperBound(DefaultPlayerLimit + 1);
+	private static int SlotIdCapacity { get; set; }
 
-	private static readonly FieldInfo? MaxPlayersField = AccessTools.Field(typeof(MegaCrit.Sts2.Core.Multiplayer.Game.Lobby.StartRunLobby), "<MaxPlayers>k__BackingField");
+	private static int LobbyListLengthCapacity { get; set; }
 
 	public static void Initialize()
 	{
-		TargetPlayerLimit = LoadOrCreatePlayerLimit();
-		SlotIdBits = RequiredBitsForExclusiveUpperBound(TargetPlayerLimit);
-		LobbyListLengthBits = RequiredBitsForExclusiveUpperBound(TargetPlayerLimit + 1);
-		SlotIdCapacity = 1 << SlotIdBits;
-		LobbyListLengthCapacity = 1 << LobbyListLengthBits;
-		if (TargetPlayerLimit > SlotIdCapacity)
+		try
 		{
-			throw new InvalidOperationException($"TargetPlayerLimit {TargetPlayerLimit} exceeds slot id capacity {SlotIdCapacity}.");
-		}
-		if (TargetPlayerLimit > LobbyListLengthCapacity)
+            LoadOptions();
+
+            SlotIdBits = RequiredBitsForExclusiveUpperBound(Option.PlayerLimit);
+
+            LobbyListLengthBits = RequiredBitsForExclusiveUpperBound(Option.PlayerLimit + 1);
+
+            SlotIdCapacity = 1 << SlotIdBits;
+
+            LobbyListLengthCapacity = 1 << LobbyListLengthBits;
+
+            Harmony.PatchAll();
+
+            Log.Info($"RemoveMultiplayerPlayerLimit loaded. Target limit: {Option.PlayerLimit}, slot capacity: {SlotIdCapacity}, lobby list capacity: {LobbyListLengthCapacity}");
+        }
+		catch (Exception e)
 		{
-			throw new InvalidOperationException($"TargetPlayerLimit {TargetPlayerLimit} exceeds lobby list capacity {LobbyListLengthCapacity}.");
-		}
-		new Harmony("cn.remove.multiplayer.playerlimit").PatchAll();
-		Log.Info($"RemoveMultiplayerPlayerLimit loaded. Target limit: {TargetPlayerLimit}, slot capacity: {SlotIdCapacity}, lobby list capacity: {LobbyListLengthCapacity}");
+            File.AppendAllText(Path.Combine(Pathes.RootPath, "logs.txt"), e.Message + e.StackTrace);
+        }
 	}
 
-	private static int LoadOrCreatePlayerLimit()
+	private static void LoadOptions()
 	{
-		string modDirectory = ResolveModDirectory();
-		Directory.CreateDirectory(modDirectory);
-		string configPath = Path.Combine(modDirectory, ConfigFileName);
+		string configPath = Pathes.ConfigPath;
+
 		if (!File.Exists(configPath))
-		{
 			WriteDefaultConfig(configPath, DefaultPlayerLimit);
-			return DefaultPlayerLimit;
-		}
+
 		try
 		{
-			using JsonDocument jsonDocument = JsonDocument.Parse(File.ReadAllText(configPath));
-			if (jsonDocument.RootElement.TryGetProperty("max_player_limit", out JsonElement value) && value.ValueKind == JsonValueKind.Number && value.TryGetInt32(out int rawLimit))
+			Option = JsonSerializer.Deserialize<Option>(File.ReadAllText(configPath));
+
+            var clampedLimit = Math.Clamp(Option.PlayerLimit, MinSupportedPlayerLimit, MaxSupportedPlayerLimit);
+
+            if (clampedLimit != Option.PlayerLimit)
 			{
-				int clampedLimit = Math.Clamp(rawLimit, MinSupportedPlayerLimit, MaxSupportedPlayerLimit);
-				if (clampedLimit != rawLimit)
-				{
-					WriteDefaultConfig(configPath, clampedLimit);
-				}
-				return clampedLimit;
-			}
-			WriteDefaultConfig(configPath, DefaultPlayerLimit);
-			return DefaultPlayerLimit;
+				Option.PlayerLimit = clampedLimit;
+
+                WriteDefaultConfig(configPath, clampedLimit);
+            }
 		}
 		catch (Exception ex)
 		{
 			Log.Warn($"Failed to parse config at {configPath}: {ex.Message}");
+
 			BackupCorruptedConfig(configPath);
 		}
-		WriteDefaultConfig(configPath, DefaultPlayerLimit);
-		return DefaultPlayerLimit;
 	}
 
-	private static string ResolveModDirectory()
-	{
-		string? assemblyLocation = Assembly.GetExecutingAssembly().Location;
-		string? assemblyDirectory = string.IsNullOrWhiteSpace(assemblyLocation) ? null : Path.GetDirectoryName(assemblyLocation);
-		if (!string.IsNullOrWhiteSpace(assemblyDirectory) && Directory.Exists(assemblyDirectory))
-		{
-			return assemblyDirectory;
-		}
-		string fallbackModDirectory = Path.Combine(AppContext.BaseDirectory, "mods", ModFolderName);
-		if (Directory.Exists(fallbackModDirectory))
-		{
-			return fallbackModDirectory;
-		}
-		return AppContext.BaseDirectory;
-	}
+	private static JsonSerializerOptions _defaultOption = new() { WriteIndented = true };
 
 	private static void WriteDefaultConfig(string configPath, int playerLimit)
 	{
-		// min_supported / max_supported are informational fields for users and are not parsed.
-		string contents = JsonSerializer.Serialize(new Dictionary<string, int>
-		{
-			["max_player_limit"] = playerLimit,
-			["min_supported"] = MinSupportedPlayerLimit,
-			["max_supported"] = MaxSupportedPlayerLimit
-		}, new JsonSerializerOptions
+        // min_player / max_player are informational fields for users and are not parsed.
+        string contents = JsonSerializer.Serialize(new Dictionary<string, int>
 		{
-			WriteIndented = true
-		});
+			["player_limit"] = playerLimit,
+            ["min_player"] = MinSupportedPlayerLimit,
+            ["max_player"] = MaxSupportedPlayerLimit
+        }, _defaultOption);
+
 		File.WriteAllText(configPath, contents);
 	}
 
 	private static void BackupCorruptedConfig(string configPath)
 	{
 		if (!File.Exists(configPath))
-		{
 			return;
-		}
+
 		string backupPath = $"{configPath}.bak";
+
 		if (File.Exists(backupPath))
-		{
 			backupPath = $"{configPath}.{DateTime.Now:yyyyMMddHHmmss}.bak";
-		}
-		File.Move(configPath, backupPath);
-	}
 
-	private static int RequiredBitsForExclusiveUpperBound(int upperBound)
-	{
-		int normalizedBound = Math.Max(1, upperBound);
-		int bitCount = 0;
-		int capacity = 1;
-		while (capacity < normalizedBound)
-		{
-			bitCount++;
-			capacity <<= 1;
-		}
-		return Math.Max(1, bitCount);
+		File.Move(configPath, backupPath);
 	}
 
-	private static int EnsureMin(int value, int min) => Math.Max(value, min);
+	private static int RequiredBitsForExclusiveUpperBound(int upperBound) => Mathf.CeilToInt(Math.Log2(upperBound));
 
-	private static bool TryGetCharacter(NRestSiteRoom room, ulong playerId, out NRestSiteCharacter character)
+    private static bool TryGetCharacter(NRestSiteRoom room, ulong playerId, out NRestSiteCharacter character)
 	{
-		NRestSiteCharacter? nRestSiteCharacter = room.Characters.FirstOrDefault((NRestSiteCharacter c) => c.Player.NetId == playerId);
-		if (nRestSiteCharacter == null)
-		{
-			character = null!;
-			return false;
-		}
-		character = nRestSiteCharacter;
-		return true;
+		character = room.Characters.FirstOrDefault(c => c.Player.NetId == playerId, null);
+
+		return character != null;
 	}
 
-	private static RestSiteOption? TryGetHoveredOption(ulong playerId)
+	private static RestSiteOption GetHoveredOption(ulong playerId)
 	{
-		int? hoveredOptionIndex = MegaCrit.Sts2.Core.Runs.RunManager.Instance.RestSiteSynchronizer.GetHoveredOptionIndex(playerId);
-		if (!hoveredOptionIndex.HasValue)
-		{
+		var hoveredOptionIndex = RunManager.Instance.RestSiteSynchronizer.GetHoveredOptionIndex(playerId);
+
+        if (!hoveredOptionIndex.HasValue)
 			return null;
-		}
-		IReadOnlyList<RestSiteOption> optionsForPlayer = MegaCrit.Sts2.Core.Runs.RunManager.Instance.RestSiteSynchronizer.GetOptionsForPlayer(playerId);
+
+		var optionsForPlayer = RunManager.Instance.RestSiteSynchronizer.GetOptionsForPlayer(playerId);
+
 		int value = hoveredOptionIndex.Value;
-		if ((uint)value >= (uint)optionsForPlayer.Count)
-		{
+
+		if (value >= optionsForPlayer.Count)
 			return null;
-		}
+
 		return optionsForPlayer[value];
 	}
 
diff --git a/src/Option.cs b/src/Option.cs
new file mode 100644
index 0000000..37c9f62
--- /dev/null
+++ b/src/Option.cs
@@ -0,0 +1,23 @@
+using RemoveMultiplayerPlayerLimit;
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+
+namespace RemoveMultiplayerPlayetLimit.src
+{
+    public class Option
+    {
+        [JsonPropertyName("player_limit")]
+        public int PlayerLimit { get; set; } = ModEntry.DefaultPlayerLimit;
+
+        [JsonPropertyName("min_player")]
+        public int MinPlayerLimit { get; set; } = ModEntry.MinSupportedPlayerLimit;
+
+        [JsonPropertyName("max_player")]
+        public int MaxPlayerLimit { get; set; } = ModEntry.MaxSupportedPlayerLimit;
+    }
+}
diff --git a/src/Patches.Merchant.cs b/src/Patches.Merchant.cs
index 7885050..dd5008a 100644
--- a/src/Patches.Merchant.cs
+++ b/src/Patches.Merchant.cs
@@ -31,21 +31,28 @@ private static void Postfix(NMerchantRoom __instance)
 	private static void RepositionMerchantVisuals(IReadOnlyList<NMerchantCharacter> visuals)
 	{
 		if (visuals.Count <= VanillaMultiplayerHolderCount)
-		{
 			return;
-		}
+
 		int rowCount = visuals.Count <= VanillaMultiplayerHolderCount * 2 ? 2 : Mathf.CeilToInt((float)visuals.Count / VanillaMultiplayerHolderCount);
+
 		int columnCount = Mathf.CeilToInt((float)visuals.Count / rowCount);
+
 		int visualIndex = 0;
+
 		for (int row = 0; row < rowCount; row++)
 		{
 			float x = MerchantForwardShiftX + MerchantRowStartOffsetX * row;
+
 			float y = MerchantForwardShiftY + MerchantRowStepY * row;
+
 			for (int column = 0; column < columnCount && visualIndex < visuals.Count; column++)
 			{
 				NMerchantCharacter nMerchantCharacter = visuals[visualIndex];
+
 				nMerchantCharacter.Position = new Vector2(x, y);
+
 				x += MerchantColumnStepX;
+
 				visualIndex++;
 			}
 		}
diff --git a/src/Patches.Network.cs b/src/Patches.Network.cs
index 4ef496e..56c6d6f 100644
--- a/src/Patches.Network.cs
+++ b/src/Patches.Network.cs
@@ -1,77 +1,74 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using System.Reflection.Emit;
 using HarmonyLib;
 using MegaCrit.Sts2.Core.Entities.Multiplayer;
+using MegaCrit.Sts2.Core.Logging;
+using MegaCrit.Sts2.Core.Models;
+using MegaCrit.Sts2.Core.Models.Characters;
+using MegaCrit.Sts2.Core.Models.Events;
+using MegaCrit.Sts2.Core.Models.Monsters;
 using MegaCrit.Sts2.Core.Multiplayer;
 using MegaCrit.Sts2.Core.Multiplayer.Game;
 using MegaCrit.Sts2.Core.Multiplayer.Game.Lobby;
 using MegaCrit.Sts2.Core.Multiplayer.Messages.Lobby;
 using MegaCrit.Sts2.Core.Multiplayer.Serialization;
 using MegaCrit.Sts2.Core.Runs;
+using MegaCrit.Sts2.Core.Unlocks;
+using RemoveMultiplayerPlayerLimit.src;
+using RemoveMultiplayerPlayetLimit.src.Extensions;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Reflection.Emit;
 
 namespace RemoveMultiplayerPlayerLimit;
 
 public static partial class ModEntry
 {
-	private static readonly MethodInfo? WriterWriteIntWithBitsMethod = AccessTools.Method(typeof(PacketWriter), nameof(PacketWriter.WriteInt), new[] { typeof(int), typeof(int) });
-
-	private static readonly MethodInfo? ReaderReadIntWithBitsMethod = AccessTools.Method(typeof(PacketReader), nameof(PacketReader.ReadInt), new[] { typeof(int) });
+	private static readonly MethodInfo WriterWriteIntWithBitsMethod = typeof(PacketWriter).GetMethod(nameof(PacketWriter.WriteInt));
 
-	private static readonly MethodInfo? WriterWriteListWithBitsMethod = typeof(PacketWriter).GetMethods(BindingFlags.Public | BindingFlags.Instance)
-		.FirstOrDefault((MethodInfo m) => m.Name == nameof(PacketWriter.WriteList) && m.IsGenericMethodDefinition && m.GetParameters().Length == 2 && m.GetParameters()[1].ParameterType == typeof(int));
+	private static readonly MethodInfo ReaderReadIntWithBitsMethod = typeof(PacketReader).GetMethod(nameof(PacketReader.ReadInt));
 
-	private static readonly MethodInfo? ReaderReadListWithBitsMethod = typeof(PacketReader).GetMethods(BindingFlags.Public | BindingFlags.Instance)
-		.FirstOrDefault((MethodInfo m) => m.Name == nameof(PacketReader.ReadList) && m.IsGenericMethodDefinition && m.GetParameters().Length == 1 && m.GetParameters()[0].ParameterType == typeof(int));
+	private static readonly MethodInfo WriterWriteListWithBitsMethod = typeof(PacketWriter).GetMethod(nameof(PacketWriter.WriteList)).MakeGenericMethod([typeof(LobbyPlayer)]);
 
-	private static readonly int LdcI4MinOpcodeValue = OpCodes.Ldc_I4_M1.Value;
+	private static readonly MethodInfo ReaderReadListWithBitsMethod = typeof(PacketReader).GetMethod(nameof(PacketReader.ReadList)).MakeGenericMethod([typeof(LobbyPlayer)]);
 
-	private static readonly int LdcI4MaxOpcodeValue = OpCodes.Ldc_I4_8.Value;
-
-	private static readonly int LdcI4SOpcodeValue = OpCodes.Ldc_I4_S.Value;
-
-	private static readonly int LdcI4OpcodeValue = OpCodes.Ldc_I4.Value;
-
-	[HarmonyPatch(typeof(NetHostGameService), nameof(NetHostGameService.StartENetHost))]
+    [HarmonyPatch(typeof(NetHostGameService), nameof(NetHostGameService.StartENetHost))]
 	private static class StartENetHostPatch
 	{
-		private static void Prefix(ref int maxClients) => maxClients = EnsureMin(maxClients, TargetPlayerLimit);
+		private static void Prefix(ref int maxClients) => maxClients = Math.Max(maxClients, Option.PlayerLimit);
 	}
 
 	[HarmonyPatch(typeof(NetHostGameService), nameof(NetHostGameService.StartSteamHost))]
 	private static class StartSteamHostPatch
 	{
-		private static void Prefix(ref int maxClients) => maxClients = EnsureMin(maxClients, TargetPlayerLimit);
+		private static void Prefix(ref int maxClients) => maxClients = Math.Max(maxClients, Option.PlayerLimit);
 	}
 
 	[HarmonyPatch(typeof(StartRunLobby), MethodType.Constructor, typeof(GameMode), typeof(INetGameService), typeof(IStartRunLobbyListener), typeof(int))]
 	private static class StartRunLobbyConstructorPatch
 	{
-		private static void Postfix(StartRunLobby __instance, INetGameService netService)
+		private static void Prefix(INetGameService netService, ref int maxPlayers)
 		{
-			if (netService.Type == NetGameType.Host && __instance.MaxPlayers < TargetPlayerLimit && MaxPlayersField != null)
-			{
-				MaxPlayersField.SetValue(__instance, TargetPlayerLimit);
-			}
+			if (netService.Type == NetGameType.Host && maxPlayers < Option.PlayerLimit)
+                maxPlayers = Option.PlayerLimit;
 		}
 	}
 
 	[HarmonyPatch(typeof(LobbyPlayer), nameof(LobbyPlayer.Serialize))]
-	private static class LobbyPlayerSerializePatch
+    private static class LobbyPlayerSerializePatch
 	{
-		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) => ReplaceBitWidthBeforeCall(instructions, WriterWriteIntWithBitsMethod, VanillaSlotIdBits, SlotIdBits, nameof(LobbyPlayerSerializePatch));
+        private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) => ReplaceBitWidthBeforeCall(instructions, WriterWriteIntWithBitsMethod, VanillaSlotIdBits, SlotIdBits, nameof(LobbyPlayerSerializePatch));
 	}
 
 	[HarmonyPatch(typeof(LobbyPlayer), nameof(LobbyPlayer.Deserialize))]
 	private static class LobbyPlayerDeserializePatch
 	{
 		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) => ReplaceBitWidthBeforeCall(instructions, ReaderReadIntWithBitsMethod, VanillaSlotIdBits, SlotIdBits, nameof(LobbyPlayerDeserializePatch));
-	}
+    }
 
 	[HarmonyPatch(typeof(ClientLobbyJoinResponseMessage), nameof(ClientLobbyJoinResponseMessage.Serialize))]
-	private static class ClientLobbyJoinResponseSerializePatch
+    private static class ClientLobbyJoinResponseSerializePatch
 	{
 		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) => ReplaceBitWidthBeforeCall(instructions, WriterWriteListWithBitsMethod, VanillaLobbyListLengthBits, LobbyListLengthBits, nameof(ClientLobbyJoinResponseSerializePatch));
 	}
@@ -94,83 +91,46 @@ private static class LobbyBeginRunDeserializePatch
 		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions) => ReplaceBitWidthBeforeCall(instructions, ReaderReadListWithBitsMethod, VanillaLobbyListLengthBits, LobbyListLengthBits, nameof(LobbyBeginRunDeserializePatch));
 	}
 
-	private static IEnumerable<CodeInstruction> ReplaceBitWidthBeforeCall(IEnumerable<CodeInstruction> instructions, MethodInfo? targetMethod, int sourceBitWidth, int targetBitWidth, string patchName)
+	private static IEnumerable<CodeInstruction> ReplaceBitWidthBeforeCall(IEnumerable<CodeInstruction> instructions, MethodInfo targetMethod, int sourceBitWidth, int targetBitWidth, string patchName)
 	{
-		MethodInfo resolvedTargetMethod = targetMethod ?? throw new InvalidOperationException($"{patchName}: target method is null.");
-		List<CodeInstruction> list = instructions.ToList();
-		int count = 0;
-		for (int i = 0; i < list.Count; i++)
-		{
-			if (!IsCallToMethod(list[i], resolvedTargetMethod))
-			{
-				continue;
-			}
-			int num = FindBitWidthLoadIndex(list, i, sourceBitWidth);
-			if (num < 0)
-			{
-				continue;
-			}
-			list[num] = CloneWithNewIntOperand(list[num], targetBitWidth);
-			count++;
-		}
-		if (count == 0)
-		{
-			throw new InvalidOperationException($"{patchName}: no bit-width operand replaced, game code may have changed.");
-		}
-		return list;
-	}
+		var resolvedTargetMethod = targetMethod ?? throw new InvalidOperationException($"{patchName}: target method is null.");
 
-	private static int FindBitWidthLoadIndex(IReadOnlyList<CodeInstruction> instructions, int callIndex, int expectedValue)
-	{
-		int num = Math.Max(0, callIndex - 4);
-		for (int i = callIndex - 1; i >= num; i--)
+        List<CodeInstruction> codes = [.. instructions];
+
+		var replace = false;
+
+        foreach (var instruction in codes)
 		{
-			if (instructions[i].opcode == OpCodes.Nop)
-			{
-				continue;
-			}
-			int? ldcI4Value = ReadLdcI4Nullable(instructions[i]);
-			if (!ldcI4Value.HasValue)
+			if (instruction.Calls(resolvedTargetMethod) && codes.TryGetLast(instruction, out var last) && TestLdcI4(last, sourceBitWidth))
 			{
-				return -1;
-			}
-			return ldcI4Value.Value == expectedValue ? i : -1;
-		}
-		return -1;
-	}
+                last.opcode = OpCodes.Ldc_I4;
 
-	private static CodeInstruction CloneWithNewIntOperand(CodeInstruction source, int newValue)
-	{
-		CodeInstruction codeInstruction = new CodeInstruction(OpCodes.Ldc_I4, newValue);
-		codeInstruction.labels.AddRange(source.labels);
-		codeInstruction.blocks.AddRange(source.blocks);
-		return codeInstruction;
-	}
+				last.operand = targetBitWidth;
 
-	private static bool IsCallToMethod(CodeInstruction instruction, MethodInfo targetMethod)
-	{
-		if ((instruction.opcode != OpCodes.Call && instruction.opcode != OpCodes.Callvirt) || instruction.operand is not MethodInfo methodInfo)
-		{
-			return false;
+				replace = true;
+            }
 		}
-		if (methodInfo == targetMethod)
-		{
-			return true;
-		}
-		MethodInfo methodInfo2 = methodInfo.IsGenericMethod ? methodInfo.GetGenericMethodDefinition() : methodInfo;
-		MethodInfo methodInfo3 = targetMethod.IsGenericMethod ? targetMethod.GetGenericMethodDefinition() : targetMethod;
-		return methodInfo2 == methodInfo3;
-	}
 
-	private static int? ReadLdcI4Nullable(CodeInstruction instruction)
-	{
-		int opcodeValue = instruction.opcode.Value;
-		return opcodeValue switch
-		{
-			_ when opcodeValue >= LdcI4MinOpcodeValue && opcodeValue <= LdcI4MaxOpcodeValue => opcodeValue - (LdcI4MinOpcodeValue + 1),
-			_ when opcodeValue == LdcI4SOpcodeValue && instruction.operand is sbyte sb => sb,
-			_ when opcodeValue == LdcI4OpcodeValue && instruction.operand is int num => num,
-			_ => null
-		};
+		if (!replace)
+            throw new InvalidOperationException($"{patchName}: no bit-width operand replaced, game code may have changed.");
+
+        return codes.AsEnumerable();
 	}
+
+    private static bool TryReadLdcI4(CodeInstruction instruction, out int? value)
+    {
+        var v = instruction.opcode.Value;
+
+        value = v switch
+        {
+            >= 21 and <= 30 => v - 22,
+            31 => (sbyte)instruction.operand,
+            32 => (int)instruction.operand,
+            _ => null
+        };
+
+        return value != null;
+    }
+
+	private static bool TestLdcI4(CodeInstruction instruction, int value) => TryReadLdcI4(instruction, out var v) && v == value;
 }
diff --git a/src/Patches.RestSite.cs b/src/Patches.RestSite.cs
index 4641a9b..98671e9 100644
--- a/src/Patches.RestSite.cs
+++ b/src/Patches.RestSite.cs
@@ -5,6 +5,7 @@
 using Godot;
 using HarmonyLib;
 using MegaCrit.Sts2.Core.Entities.RestSite;
+using MegaCrit.Sts2.Core.Helpers;
 using MegaCrit.Sts2.Core.Logging;
 using MegaCrit.Sts2.Core.Nodes.Rooms;
 
@@ -12,26 +13,26 @@ namespace RemoveMultiplayerPlayerLimit;
 
 public static partial class ModEntry
 {
-	private static readonly Vector2 LeftExtraFrontOffset = new Vector2(-250f, 35f);
+	private static readonly Vector2 LeftExtraFrontOffset = new(-250f, 35f);
 
-	private static readonly Vector2 LeftExtraBackOffset = new Vector2(-240f, -20f);
+	private static readonly Vector2 LeftExtraBackOffset = new(-240f, -20f);
 
-	private static readonly Vector2 RightExtraFrontOffset = new Vector2(250f, 35f);
+	private static readonly Vector2 RightExtraFrontOffset = new(250f, 35f);
 
-	private static readonly Vector2 RightExtraBackOffset = new Vector2(240f, -20f);
+	private static readonly Vector2 RightExtraBackOffset = new(240f, -20f);
 
-	private static readonly Vector2 LogXOffsetLeft = new Vector2(-250f, 0f);
+	private static readonly Vector2 LogXOffsetLeft = new(-250f, 0f);
 
-	private static readonly Vector2 LogXOffsetRight = new Vector2(250f, 0f);
+	private static readonly Vector2 LogXOffsetRight = new(250f, 0f);
 
-	private static readonly Vector2 ExtraSeatStep = new Vector2(70f, -45f);
+	private static readonly Vector2 ExtraSeatStep = new(70f, -45f);
 
 	[HarmonyPatch(typeof(NRestSiteRoom), nameof(NRestSiteRoom._Ready))]
 	private static class NRestSiteRoomReadyPatch
 	{
-		private static readonly MethodInfo? CharacterContainerGetter = AccessTools.PropertyGetter(typeof(List<Control>), "Item");
+		private static readonly MethodInfo CharacterContainerGetter = AccessTools.PropertyGetter(typeof(List<Control>), "Item");
 
-		private static readonly MethodInfo? SafeContainerGetter = AccessTools.Method(typeof(NRestSiteRoomReadyPatch), nameof(GetContainerSafe));
+		private static readonly MethodInfo SafeContainerGetter = AccessTools.Method(typeof(NRestSiteRoomReadyPatch), nameof(GetContainerSafe));
 
 		private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions)
 		{
@@ -48,133 +49,152 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
 		private static Control GetContainerSafe(List<Control> containers, int index)
 		{
-			if (containers.Count == 0)
-			{
+			var count = containers.Count;
+
+			if (count == 0)
 				throw new InvalidOperationException("No character containers found in rest site room.");
-			}
+
 			EnsureRestSiteContainers(containers, index + 1);
-			return containers[NormalizeWrappedIndex(index, containers.Count)];
-		}
 
-		private static int NormalizeWrappedIndex(int index, int count)
-		{
-			int num = index % count;
-			return num >= 0 ? num : num + count;
+			return containers[((index % count) + count) % count];
 		}
 
 		private static void EnsureRestSiteContainers(List<Control> containers, int requiredCount)
 		{
-			if (requiredCount <= containers.Count)
-			{
+			var templateCount = containers.Count;
+
+            if (requiredCount <= templateCount)
 				return;
-			}
-			Control parent = containers[0].GetParent<Control>();
+
+			var parent = containers[0].GetParent<Control>();
+
 			if (parent == null)
-			{
 				return;
-			}
+
 			EnsureExtraLogs(parent);
-			int templateCount = containers.Count;
+
 			while (containers.Count < requiredCount)
 			{
-				int count = containers.Count;
+				var count = containers.Count;
+
 				Control source = containers[count % templateCount];
+
 				Control control = source.Duplicate() as Control ?? new Control();
+
 				RemoveAllChildren(control);
+
 				control.Name = $"Character_Auto_{count + 1}";
+
 				control.Position = GetExtraContainerPosition(containers, count);
+
 				parent.AddChild(control);
+
 				containers.Add(control);
 			}
 		}
 
 		private static void RemoveAllChildren(Node node)
 		{
-			for (int i = node.GetChildCount() - 1; i >= 0; i--)
+			foreach (var child in node.GetChildren())
 			{
-				Node child = node.GetChild(i);
 				node.RemoveChild(child);
+
 				child.QueueFree();
-			}
+            }
 		}
 
 		private static Vector2 GetExtraContainerPosition(List<Control> containers, int index)
 		{
 			if (containers.Count < 4)
-			{
-				return containers[containers.Count - 1].Position;
-			}
-			if (index >= TargetPlayerLimit)
-			{
-				Log.Warn($"Rest site character index {index} exceeds configured target limit {TargetPlayerLimit}.");
-			}
+				return containers[^1].Position;
+
+			if (index >= Option.PlayerLimit)
+				Log.Warn($"Rest site character index {index} exceeds configured target limit {Option.PlayerLimit}.");
+
 			if (index < 4)
-			{
 				return containers[index].Position;
-			}
+
 			int extraSeatIndex = index - 4;
+
 			bool isLeftSide = extraSeatIndex % 2 == 0;
+
 			int depthLevel = extraSeatIndex / 2;
+
 			Vector2 frontSeatPosition = isLeftSide ? containers[0].Position + LeftExtraFrontOffset : containers[1].Position + RightExtraFrontOffset;
+
 			Vector2 backSeatPosition = isLeftSide ? containers[2].Position + LeftExtraBackOffset : containers[3].Position + RightExtraBackOffset;
+
 			if (depthLevel == 0)
-			{
 				return frontSeatPosition;
-			}
+
 			if (depthLevel == 1)
-			{
 				return backSeatPosition;
-			}
+
 			int extraDepth = depthLevel - 1;
-			Vector2 extraOffset = new Vector2((isLeftSide ? -1f : 1f) * ExtraSeatStep.X * extraDepth, ExtraSeatStep.Y * extraDepth);
+
+			Vector2 extraOffset = new((isLeftSide ? -1f : 1f) * ExtraSeatStep.X * extraDepth, ExtraSeatStep.Y * extraDepth);
+
 			return backSeatPosition + extraOffset;
 		}
 
 		private static void EnsureExtraLogs(Control parent)
 		{
-			Node? background = parent.GetChildCount() > 0 ? parent.GetChild(0) : null;
+			var background = parent.GetChildCount() > 0 ? parent.GetChild(0) : null;
+
 			if (background == null || background.GetNodeOrNull<Node>("AutoExtraLogsMarker") != null)
-			{
 				return;
-			}
-			Node marker = new Node();
-			marker.Name = "AutoExtraLogsMarker";
-			background.AddChild(marker);
+
+            Node marker = new()
+            {
+                Name = "AutoExtraLogsMarker"
+            };
+
+            background.AddChild(marker);
+
 			bool leftLogOk = DuplicateShiftedNode(background, "RestSiteLLog", LogXOffsetLeft, "AutoL");
+
 			bool rightLogOk = DuplicateShiftedNode(background, "RestSiteRLog", LogXOffsetRight, "AutoR");
+
 			bool leftLogLayer2Ok = DuplicateShiftedNode(background, "RestSiteLighting/RestSiteLLog2", LogXOffsetLeft, "AutoL");
+
 			bool rightLogLayer2Ok = DuplicateShiftedNode(background, "RestSiteLighting/RestSiteRLog2", LogXOffsetRight, "AutoR");
+
 			if (!leftLogOk && !rightLogOk && !leftLogLayer2Ok && !rightLogLayer2Ok)
-			{
 				Log.Warn("No rest site log nodes found for duplication. Scene tree may have changed.");
-			}
 		}
 
 		private static bool DuplicateShiftedNode(Node root, string nodePath, Vector2 offset, string suffix)
 		{
-			Node node = root.GetNodeOrNull<Node>(nodePath);
+			var node = root.GetNodeOrNull<Node>(nodePath);
+
 			if (node == null)
 			{
 				Log.Warn($"Rest site node not found: {nodePath}");
+
 				return false;
 			}
-			Node parent = node.GetParent();
+
+			var parent = node.GetParent();
+
 			if (parent == null)
 			{
 				Log.Warn($"Rest site node has no parent: {nodePath}");
+
 				return false;
 			}
-			Node node2 = node.Duplicate();
+
+			var node2 = node.Duplicate();
+
 			node2.Name = $"{node.Name}_{suffix}";
+
 			parent.AddChild(node2);
+
 			if (node is Control control && node2 is Control control2)
-			{
 				control2.Position = control.Position + offset;
-			}
+
 			if (node is Node2D node3 && node2 is Node2D node4)
-			{
 				node4.Position = node3.Position + offset;
-			}
+
 			return true;
 		}
 	}
@@ -184,11 +204,9 @@ private static class NRestSiteRoomHoverPatch
 	{
 		private static bool Prefix(NRestSiteRoom __instance, ulong playerId)
 		{
-			if (!TryGetCharacter(__instance, playerId, out var nRestSiteCharacter))
-			{
-				return false;
-			}
-			nRestSiteCharacter.ShowHoveredRestSiteOption(TryGetHoveredOption(playerId));
+			if (TryGetCharacter(__instance, playerId, out var nRestSiteCharacter))
+				nRestSiteCharacter.ShowHoveredRestSiteOption(GetHoveredOption(playerId));
+
 			return false;
 		}
 	}
@@ -199,9 +217,8 @@ private static class NRestSiteRoomBeforeSelectPatch
 		private static bool Prefix(NRestSiteRoom __instance, RestSiteOption option, ulong playerId)
 		{
 			if (TryGetCharacter(__instance, playerId, out var nRestSiteCharacter))
-			{
 				nRestSiteCharacter.SetSelectingRestSiteOption(option);
-			}
+
 			return false;
 		}
 	}
@@ -211,19 +228,19 @@ private static class NRestSiteRoomAfterSelectPatch
 	{
 		private static bool Prefix(NRestSiteRoom __instance, RestSiteOption option, bool success, ulong playerId)
 		{
-			if (!TryGetCharacter(__instance, playerId, out var nRestSiteCharacter))
-			{
-				return false;
-			}
-			nRestSiteCharacter.SetSelectingRestSiteOption(null);
-			if (success)
+			if (TryGetCharacter(__instance, playerId, out var nRestSiteCharacter))
 			{
-				nRestSiteCharacter.ShowSelectedRestSiteOption(option);
-				if (IsRemote(nRestSiteCharacter))
-				{
-					MegaCrit.Sts2.Core.Helpers.TaskHelper.RunSafely(option.DoRemotePostSelectVfx());
-				}
-			}
+                nRestSiteCharacter.SetSelectingRestSiteOption(null);
+
+                if (success)
+                {
+                    nRestSiteCharacter.ShowSelectedRestSiteOption(option);
+
+                    if (IsRemote(nRestSiteCharacter))
+                        TaskHelper.RunSafely(option.DoRemotePostSelectVfx());
+                }
+            }
+
 			return false;
 		}
 	}
diff --git a/src/Patches.Treasure.cs b/src/Patches.Treasure.cs
index 651f08c..13e8cce 100644
--- a/src/Patches.Treasure.cs
+++ b/src/Patches.Treasure.cs
@@ -15,88 +15,111 @@ public static partial class ModEntry
 
 	private const float FallbackRelicHolderXStep = 220f;
 
-	private static readonly System.Reflection.FieldInfo? HoldersInUseField = AccessTools.Field(typeof(NTreasureRoomRelicCollection), "_holdersInUse");
+	private static readonly System.Reflection.FieldInfo HoldersInUseField = AccessTools.Field(typeof(NTreasureRoomRelicCollection), "_holdersInUse");
 
-	private static readonly System.Reflection.FieldInfo? MultiplayerHoldersField = AccessTools.Field(typeof(NTreasureRoomRelicCollection), "_multiplayerHolders");
+	private static readonly System.Reflection.FieldInfo MultiplayerHoldersField = AccessTools.Field(typeof(NTreasureRoomRelicCollection), "_multiplayerHolders");
 
-	private static readonly System.Reflection.FieldInfo? RunStateField = AccessTools.Field(typeof(NTreasureRoomRelicCollection), "_runState");
+	private static readonly System.Reflection.FieldInfo RunStateField = AccessTools.Field(typeof(NTreasureRoomRelicCollection), "_runState");
 
 	[HarmonyPatch(typeof(NTreasureRoomRelicCollection), nameof(NTreasureRoomRelicCollection.InitializeRelics))]
 	private static class NTreasureRoomRelicCollectionInitializePatch
 	{
 		private static void Prefix(NTreasureRoomRelicCollection __instance)
 		{
-			List<NTreasureRoomRelicHolder>? holdersInUse = GetHoldersInUse(__instance);
+			var holdersInUse = GetHoldersInUse(__instance);
+
 			holdersInUse?.Clear();
-			List<NTreasureRoomRelicHolder>? multiplayerHolders = GetMultiplayerHolders(__instance);
+
+			var multiplayerHolders = GetMultiplayerHolders(__instance);
+
 			if (multiplayerHolders != null && multiplayerHolders.Count > VanillaMultiplayerHolderCount)
 			{
 				for (int i = multiplayerHolders.Count - 1; i >= VanillaMultiplayerHolderCount; i--)
 				{
 					NTreasureRoomRelicHolder nTreasureRoomRelicHolder = multiplayerHolders[i];
+
 					multiplayerHolders.RemoveAt(i);
+
 					nTreasureRoomRelicHolder.QueueFree();
 				}
 			}
-			IReadOnlyList<RelicModel>? currentRelics = RunManager.Instance.TreasureRoomRelicSynchronizer.CurrentRelics;
+
+			var currentRelics = RunManager.Instance.TreasureRoomRelicSynchronizer.CurrentRelics;
+
 			if (multiplayerHolders == null || currentRelics == null || currentRelics.Count <= multiplayerHolders.Count || multiplayerHolders.Count == 0)
-			{
 				return;
-			}
-			NTreasureRoomRelicHolder template = multiplayerHolders[multiplayerHolders.Count - 1];
+
+			var template = multiplayerHolders[^1];
+
 			Node parent = template.GetParent();
+
 			for (int i = multiplayerHolders.Count; i < currentRelics.Count; i++)
 			{
 				if (template.Duplicate() is not NTreasureRoomRelicHolder holder)
-				{
 					continue;
-				}
+
 				holder.Name = $"AutoHolder_{i + 1}";
+
 				holder.Visible = false;
+
 				parent.AddChild(holder);
+
 				multiplayerHolders.Add(holder);
 			}
 		}
 		private static void Postfix(NTreasureRoomRelicCollection __instance)
 		{
-			List<NTreasureRoomRelicHolder>? holdersInUse = GetHoldersInUse(__instance);
+			var holdersInUse = GetHoldersInUse(__instance);
+
 			if (holdersInUse == null || holdersInUse.Count <= VanillaMultiplayerHolderCount)
-			{
 				return;
-			}
-			int referenceHolderSampleCount = VanillaMultiplayerHolderCount;
-			float minX = float.MaxValue;
-			float maxX = float.MinValue;
-			float topY = float.MaxValue;
-			float bottomY = float.MinValue;
-			for (int i = 0; i < referenceHolderSampleCount; i++)
+
+			var referenceHolderSampleCount = VanillaMultiplayerHolderCount;
+
+			var minX = float.MaxValue;
+
+			var maxX = float.MinValue;
+
+			var topY = float.MaxValue;
+
+			var bottomY = float.MinValue;
+
+			for (var i = 0; i < referenceHolderSampleCount; i++)
 			{
-				Vector2 position = holdersInUse[i].Position;
+				var position = holdersInUse[i].Position;
+
 				minX = Math.Min(minX, position.X);
+
 				maxX = Math.Max(maxX, position.X);
+
 				topY = Math.Min(topY, position.Y);
+
 				bottomY = Math.Max(bottomY, position.Y);
 			}
-			float centerX = (minX + maxX) * 0.5f;
+
+			var centerX = (minX + maxX) * 0.5f;
+
 			// 基于原始4个holder，满8人使用3段间距，5-7人使用2段间距。
-			float xStep = holdersInUse.Count >= TargetPlayerLimit ? (maxX - minX) / 3f : (maxX - minX) / 2f;
-			int firstRowCount = Math.Min(VanillaMultiplayerHolderCount, (int)Math.Ceiling(holdersInUse.Count / 2f));
+			var xStep = holdersInUse.Count >= Option.PlayerLimit ? (maxX - minX) / 3f : (maxX - minX) / 2f;
+
+			var firstRowCount = Math.Min(VanillaMultiplayerHolderCount, (int)Math.Ceiling(holdersInUse.Count / 2f));
+
 			xStep = xStep > 0f ? xStep : FallbackRelicHolderXStep;
+
 			LayoutRow(holdersInUse, 0, firstRowCount, topY, centerX, xStep);
-			int secondRowCount = holdersInUse.Count - firstRowCount;
+
+			var secondRowCount = holdersInUse.Count - firstRowCount;
+
 			if (secondRowCount > 0)
-			{
 				LayoutRow(holdersInUse, firstRowCount, secondRowCount, bottomY, centerX, xStep);
-			}
 		}
 
 		private static void LayoutRow(List<NTreasureRoomRelicHolder> holders, int startIndex, int count, float y, float centerX, float xStep)
 		{
-			float startX = centerX - (count - 1) * xStep * 0.5f;
+			var startX = centerX - (count - 1) * xStep * 0.5f;
+
 			for (int i = 0; i < count; i++)
-			{
 				holders[startIndex + i].Position = new Vector2(startX + i * xStep, y);
-			}
 		}
 	}
 
@@ -105,35 +128,39 @@ private static class NTreasureRoomRelicCollectionDefaultFocusPatch
 	{
 		private static bool Prefix(NTreasureRoomRelicCollection __instance, ref Control __result)
 		{
-			List<NTreasureRoomRelicHolder>? holdersInUse = GetHoldersInUse(__instance);
+			var holdersInUse = GetHoldersInUse(__instance);
+
 			if (holdersInUse == null || holdersInUse.Count == 0)
-			{
 				return true;
-			}
-			IRunState? runState = GetRunState(__instance);
-			int playerSlotIndex = 0;
+
+			var runState = GetRunState(__instance);
+
+			var playerSlotIndex = 0;
+
 			var me = runState != null ? LocalContext.GetMe(runState.Players) : null;
+
 			if (me != null && runState != null)
-			{
 				playerSlotIndex = runState.GetPlayerSlotIndex(me);
-			}
+
 			playerSlotIndex = Math.Clamp(playerSlotIndex, 0, holdersInUse.Count - 1);
+
 			__result = holdersInUse[playerSlotIndex];
+
 			return false;
 		}
 	}
 
-	private static List<NTreasureRoomRelicHolder>? GetHoldersInUse(NTreasureRoomRelicCollection collection)
+	private static List<NTreasureRoomRelicHolder> GetHoldersInUse(NTreasureRoomRelicCollection collection)
 	{
 		return HoldersInUseField?.GetValue(collection) as List<NTreasureRoomRelicHolder>;
 	}
 
-	private static List<NTreasureRoomRelicHolder>? GetMultiplayerHolders(NTreasureRoomRelicCollection collection)
+	private static List<NTreasureRoomRelicHolder> GetMultiplayerHolders(NTreasureRoomRelicCollection collection)
 	{
 		return MultiplayerHoldersField?.GetValue(collection) as List<NTreasureRoomRelicHolder>;
 	}
 
-	private static IRunState? GetRunState(NTreasureRoomRelicCollection collection)
+	private static IRunState GetRunState(NTreasureRoomRelicCollection collection)
 	{
 		return RunStateField?.GetValue(collection) as IRunState;
 	}
diff --git a/src/Pathes.cs b/src/Pathes.cs
new file mode 100644
index 0000000..016b791
--- /dev/null
+++ b/src/Pathes.cs
@@ -0,0 +1,21 @@
+using Godot;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RemoveMultiplayerPlayerLimit.src
+{
+    public static class Pathes
+    {
+        public static string RootPath = Path.GetDirectoryName(OS.GetExecutablePath());
+
+        public static string ModsPath = Path.Combine(RootPath, "mods");
+
+        public static string ProjectPath = Path.Combine(ModsPath, ModEntry.ModFolderName);
+
+        public static string ConfigPath = Path.Combine(ProjectPath, ModEntry.ConfigFileName);
+    }
+}