diff --git a/EXILED/Exiled.API/Features/Map.cs b/EXILED/Exiled.API/Features/Map.cs
index d3950db22a..3448910b8f 100644
--- a/EXILED/Exiled.API/Features/Map.cs
+++ b/EXILED/Exiled.API/Features/Map.cs
@@ -7,6 +7,7 @@
 
 namespace Exiled.API.Features
 {
+#pragma warning disable SA1401
     using System;
     using System.Collections.Generic;
     using System.Collections.ObjectModel;
@@ -43,6 +44,11 @@ namespace Exiled.API.Features
     /// </summary>
     public static class Map
     {
+        /// <summary>
+        /// Gets a list of <see cref="PocketDimensionTeleport"/>s on the map.
+        /// </summary>
+        internal static List<PocketDimensionTeleport> TeleportsValue = new();
+
         private static AmbientSoundPlayer ambientSoundPlayer;
 
         private static SqueakSpawner squeakSpawner;
@@ -114,11 +120,6 @@ public static bool IsDecontaminationEnabled
         /// </summary>
         public static SqueakSpawner SqueakSpawner => squeakSpawner ??= Object.FindObjectOfType<SqueakSpawner>();
 
-        /// <summary>
-        /// Gets a list of <see cref="PocketDimensionTeleport"/>s on the map.
-        /// </summary>
-        internal static List<PocketDimensionTeleport> TeleportsValue { get; } = new();
-
         /// <summary>
         /// Broadcasts a message to all <see cref="Player">players</see>.
         /// </summary>
diff --git a/EXILED/Exiled.API/Features/Roles/Scp106Role.cs b/EXILED/Exiled.API/Features/Roles/Scp106Role.cs
index 48f3f04a00..067ee69647 100644
--- a/EXILED/Exiled.API/Features/Roles/Scp106Role.cs
+++ b/EXILED/Exiled.API/Features/Roles/Scp106Role.cs
@@ -168,7 +168,7 @@ public bool IsSubmerged
         public bool SinkholeState
         {
             get => StalkAbility.StalkActive;
-            set => StalkAbility.StalkActive = value;
+            set => StalkAbility.ServerSetStalk(value);
         }
 
         /// <summary>
diff --git a/EXILED/Exiled.API/Features/Window.cs b/EXILED/Exiled.API/Features/Window.cs
index 79a7f5acf9..f0765b732c 100644
--- a/EXILED/Exiled.API/Features/Window.cs
+++ b/EXILED/Exiled.API/Features/Window.cs
@@ -220,7 +220,9 @@ public void DamageWindow(float amount, DamageHandlerBase handler)
             RoomType.LczGlassBox => GlassType.GR18,
             RoomType.LczPlants => GlassType.Plants,
             RoomType.Hcz049 => GlassType.Scp049,
-            RoomType.Hcz079 => Recontainer.Base._activatorGlass == Base ? GlassType.Scp079Trigger : GlassType.Scp079,
+
+            // TODO: Recontainer.Base._activatorGlass == Base ? GlassType.Scp079Trigger : GlassType.Scp079
+            RoomType.Hcz079 => GlassType.Scp079,
             RoomType.HczHid => GlassType.MicroHid,
             RoomType.HczTestRoom => GlassType.TestRoom,
             RoomType.HczEzCheckpointA => GlassType.HczEzCheckpointA,
diff --git a/EXILED/Exiled.Events/EventArgs/Player/SpawningEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Player/SpawningEventArgs.cs
index 21221d8cd4..bc543dc586 100644
--- a/EXILED/Exiled.Events/EventArgs/Player/SpawningEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Player/SpawningEventArgs.cs
@@ -8,7 +8,6 @@
 namespace Exiled.Events.EventArgs.Player
 {
     using System;
-    using System.Runtime.CompilerServices;
 
     using Exiled.API.Features;
     using Exiled.API.Features.Roles;
@@ -76,4 +75,4 @@ public SpawningEventArgs(Player player, Vector3 position, float rotation, Player
         /// </summary>
         public Role NewRole { get; }
     }
-}
\ No newline at end of file
+}
diff --git a/EXILED/Exiled.Events/EventArgs/Scp914/UpgradingPlayerEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Scp914/UpgradingPlayerEventArgs.cs
index 9dedafb5af..cf4487eccc 100644
--- a/EXILED/Exiled.Events/EventArgs/Scp914/UpgradingPlayerEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Scp914/UpgradingPlayerEventArgs.cs
@@ -31,16 +31,16 @@ public class UpgradingPlayerEventArgs : IPlayerEvent, IDeniableEvent
         /// <param name="upgradeItems">
         /// <inheritdoc cref="UpgradeItems" />
         /// </param>
-        /// <param name="moveVector">
-        /// <inheritdoc cref="OutputPosition" />
+        /// <param name="outputPos">
+        /// <inheritdoc cref="OutputPosition"/>
         /// </param>
-        public UpgradingPlayerEventArgs(Player player, bool upgradeItems, bool heldOnly, Scp914KnobSetting setting, Vector3 moveVector)
+        public UpgradingPlayerEventArgs(Player player, bool upgradeItems, bool heldOnly, Scp914KnobSetting setting, Vector3 outputPos)
         {
             Player = player;
             UpgradeItems = upgradeItems;
             HeldOnly = heldOnly;
             KnobSetting = setting;
-            OutputPosition = player.Position + moveVector;
+            OutputPosition = outputPos;
         }
 
         /// <summary>
diff --git a/EXILED/Exiled.Events/EventArgs/Server/RespawningTeamEventArgs.cs b/EXILED/Exiled.Events/EventArgs/Server/RespawningTeamEventArgs.cs
index f475591a6f..963d06351f 100644
--- a/EXILED/Exiled.Events/EventArgs/Server/RespawningTeamEventArgs.cs
+++ b/EXILED/Exiled.Events/EventArgs/Server/RespawningTeamEventArgs.cs
@@ -29,25 +29,19 @@ public class RespawningTeamEventArgs : IDeniableEvent
         /// <param name="players">
         /// <inheritdoc cref="Players" />
         /// </param>
-        /// <param name="queue">
-        /// <inheritdoc cref="SpawnQueue" />
-        /// </param>
         /// <param name="maxRespawn">
         /// <inheritdoc cref="MaximumRespawnAmount" />
         /// </param>
-        /// <param name="nextKnownTeam">
+        /// <param name="wave">
         /// <inheritdoc cref="NextKnownTeam" />
         /// </param>
-        /// <param name="isAllowed">
-        /// <inheritdoc cref="IsAllowed" />
-        /// </param>
-        public RespawningTeamEventArgs(List<Player> players, Queue<RoleTypeId> queue, int maxRespawn, SpawnableWaveBase nextKnownTeam, bool isAllowed = true)
+        public RespawningTeamEventArgs(List<Player> players, int maxRespawn, SpawnableWaveBase wave)
         {
             Players = players;
             MaximumRespawnAmount = maxRespawn;
-            SpawnQueue = queue;
-            NextKnownTeam = nextKnownTeam;
-            IsAllowed = isAllowed;
+            SpawnQueue = WaveSpawner.SpawnQueue;
+            Wave = wave;
+            IsAllowed = true;
         }
 
         /// <summary>
@@ -74,9 +68,14 @@ public int MaximumRespawnAmount
         }
 
         /// <summary>
-        /// Gets or sets a value indicating what the next respawnable team is.
+        /// Gets or sets a value indicating what the next wave is.
+        /// </summary>
+        public SpawnableWaveBase Wave { get; set; }
+
+        /// <summary>
+        /// Gets a value indicating what the next respawnable team is.
         /// </summary>
-        public SpawnableWaveBase NextKnownTeam { get; set; }
+        public SpawnableTeamType NextKnownTeam => Wave.TargetFaction.GetSpawnableTeam();
 
         /// <summary>
         /// Gets or sets a value indicating whether the spawn can occur.
diff --git a/EXILED/Exiled.Events/Handlers/Internal/MapGenerated.cs b/EXILED/Exiled.Events/Handlers/Internal/MapGenerated.cs
index ef323edb7d..6c71d3a83e 100644
--- a/EXILED/Exiled.Events/Handlers/Internal/MapGenerated.cs
+++ b/EXILED/Exiled.Events/Handlers/Internal/MapGenerated.cs
@@ -54,52 +54,7 @@ public static void OnMapGenerated()
             PlayerRoles.RoleAssign.HumanSpawner.Handlers[PlayerRoles.Team.OtherAlive] = new PlayerRoles.RoleAssign.OneRoleHumanSpawner(PlayerRoles.RoleTypeId.Tutorial);
             PlayerRoles.RoleAssign.HumanSpawner.Handlers[PlayerRoles.Team.Dead] = new PlayerRoles.RoleAssign.OneRoleHumanSpawner(PlayerRoles.RoleTypeId.Spectator);
 
-            GenerateAttachments();
-            Timing.CallDelayed(1, GenerateCache);
-        }
-
-        private static void GenerateCache()
-        {
-            Handlers.Map.OnGenerated();
-
-            Timing.CallDelayed(0.1f, Handlers.Server.OnWaitingForPlayers);
-        }
-
-        private static void GenerateAttachments()
-        {
-            foreach (FirearmType firearmType in EnumUtils<FirearmType>.Values)
-            {
-                if (firearmType == FirearmType.None)
-                    continue;
-
-                if (Item.Create(firearmType.GetItemType()) is not Firearm firearm)
-                    continue;
-
-                Firearm.ItemTypeToFirearmInstance.Add(firearmType, firearm);
-
-                List<AttachmentIdentifier> attachmentIdentifiers = ListPool<AttachmentIdentifier>.Pool.Get();
-                HashSet<AttachmentSlot> attachmentsSlots = HashSetPool<AttachmentSlot>.Pool.Get();
-
-                uint code = 1;
-
-                foreach (Attachment attachment in firearm.Attachments)
-                {
-                    attachmentsSlots.Add(attachment.Slot);
-                    attachmentIdentifiers.Add(new(code, attachment.Name, attachment.Slot));
-                    code *= 2U;
-                }
-
-                uint baseCode = 0;
-                attachmentsSlots.ForEach(slot => baseCode += attachmentIdentifiers
-                        .Where(attachment => attachment.Slot == slot)
-                        .Min(slot => slot.Code));
-
-                Firearm.BaseCodesValue.Add(firearmType, baseCode);
-                Firearm.AvailableAttachmentsValue.Add(firearmType, attachmentIdentifiers.ToArray());
-
-                ListPool<AttachmentIdentifier>.Pool.Return(attachmentIdentifiers);
-                HashSetPool<AttachmentSlot>.Pool.Return(attachmentsSlots);
-            }
+            Timing.CallDelayed(1, Handlers.Map.OnGenerated);
         }
     }
 }
\ No newline at end of file
diff --git a/EXILED/Exiled.Events/Handlers/Internal/Round.cs b/EXILED/Exiled.Events/Handlers/Internal/Round.cs
index 5c9ff4c5fa..f1cad19a77 100644
--- a/EXILED/Exiled.Events/Handlers/Internal/Round.cs
+++ b/EXILED/Exiled.Events/Handlers/Internal/Round.cs
@@ -7,21 +7,31 @@
 
 namespace Exiled.Events.Handlers.Internal
 {
+    using System.Collections.Generic;
     using System.Linq;
 
     using CentralAuth;
+
+    using Exiled.API.Enums;
     using Exiled.API.Extensions;
     using Exiled.API.Features;
+    using Exiled.API.Features.Items;
+    using Exiled.API.Features.Pools;
     using Exiled.API.Features.Roles;
+    using Exiled.API.Structs;
     using Exiled.Events.EventArgs.Player;
     using Exiled.Events.EventArgs.Scp049;
     using Exiled.Loader;
     using Exiled.Loader.Features;
     using InventorySystem;
+    using InventorySystem.Items.Firearms.Attachments;
+    using InventorySystem.Items.Firearms.Attachments.Components;
     using InventorySystem.Items.Usables;
     using PlayerRoles;
     using PlayerRoles.RoleAssign;
 
+    using Utils.NonAllocLINQ;
+
     /// <summary>
     /// Handles some round clean-up events and some others related to players.
     /// </summary>
@@ -33,6 +43,7 @@ internal static class Round
         /// <inheritdoc cref="Handlers.Server.OnWaitingForPlayers" />
         public static void OnWaitingForPlayers()
         {
+            GenerateAttachments();
             MultiAdminFeatures.CallEvent(MultiAdminFeatures.EventType.WAITING_FOR_PLAYERS);
 
             if (Events.Instance.Config.ShouldReloadConfigsAtRoundRestart)
@@ -93,5 +104,45 @@ public static void OnVerified(VerifiedEventArgs ev)
                 ev.Player.SendFakeSyncVar(room.RoomLightControllerNetIdentity, typeof(RoomLightController), nameof(RoomLightController.NetworkLightsEnabled), false);
             }
         }
+
+        private static void GenerateAttachments()
+        {
+            foreach (FirearmType firearmType in EnumUtils<FirearmType>.Values)
+            {
+                if (firearmType == FirearmType.None)
+                    continue;
+
+                Log.Warn(firearmType.GetItemType());
+                Log.Warn(Server.Host == null);
+
+                if (Item.Create(firearmType.GetItemType()) is not Firearm firearm)
+                    continue;
+
+                Firearm.ItemTypeToFirearmInstance.Add(firearmType, firearm);
+
+                List<AttachmentIdentifier> attachmentIdentifiers = ListPool<AttachmentIdentifier>.Pool.Get();
+                HashSet<AttachmentSlot> attachmentsSlots = HashSetPool<AttachmentSlot>.Pool.Get();
+
+                uint code = 1;
+
+                foreach (Attachment attachment in firearm.Attachments)
+                {
+                    attachmentsSlots.Add(attachment.Slot);
+                    attachmentIdentifiers.Add(new(code, attachment.Name, attachment.Slot));
+                    code *= 2U;
+                }
+
+                uint baseCode = 0;
+                attachmentsSlots.ForEach(slot => baseCode += attachmentIdentifiers
+                        .Where(attachment => attachment.Slot == slot)
+                        .Min(slot => slot.Code));
+
+                Firearm.BaseCodesValue.Add(firearmType, baseCode);
+                Firearm.AvailableAttachmentsValue.Add(firearmType, attachmentIdentifiers.ToArray());
+
+                ListPool<AttachmentIdentifier>.Pool.Return(attachmentIdentifiers);
+                HashSetPool<AttachmentSlot>.Pool.Return(attachmentsSlots);
+            }
+        }
     }
 }
diff --git a/EXILED/Exiled.Events/Patches/Events/Map/FillingLocker.cs b/EXILED/Exiled.Events/Patches/Events/Map/FillingLocker.cs
index 2ec49178ac..a884b6c887 100644
--- a/EXILED/Exiled.Events/Patches/Events/Map/FillingLocker.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Map/FillingLocker.cs
@@ -44,7 +44,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 new[]
                 {
                     // FillingLockerEventArgs ev = new(ItemPickupBase, loockerChamber)
-                    new(OpCodes.Ldloc_S, 4),
+                    new(OpCodes.Ldloc_S, 5),
                     new(OpCodes.Ldarg_0),
                     new CodeInstruction(OpCodes.Newobj, GetDeclaredConstructors(typeof(FillingLockerEventArgs))[0]),
                     new(OpCodes.Dup),
diff --git a/EXILED/Exiled.Events/Patches/Events/Map/SpawningTeamVehicle.cs b/EXILED/Exiled.Events/Patches/Events/Map/SpawningTeamVehicle.cs
index 7ab0ccda71..08926e5bea 100644
--- a/EXILED/Exiled.Events/Patches/Events/Map/SpawningTeamVehicle.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Map/SpawningTeamVehicle.cs
@@ -35,7 +35,6 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             Label retLabel = generator.DefineLabel();
             Label continueLabel = generator.DefineLabel();
 
-            LocalBuilder ev = generator.DeclareLocal(typeof(SpawningTeamVehicleEventArgs));
             LocalBuilder msg = generator.DeclareLocal(typeof(WaveUpdateMessage));
 
             int offset = 1;
@@ -47,21 +46,19 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
                 // if (type != RespawnEffectsController.EffectType.Selection)
                 //    goto continueLabel;
-                new(OpCodes.Ldloc_S, msg.LocalIndex),
+                new(OpCodes.Ldloca_S, msg.LocalIndex),
                 new(OpCodes.Callvirt, PropertyGetter(typeof(WaveUpdateMessage), nameof(WaveUpdateMessage.IsTrigger))),
                 new(OpCodes.Brfalse_S, continueLabel),
 
-                // team
-                new(OpCodes.Ldarg_1),
+                // wave
+                new(OpCodes.Ldarg_0),
 
                 // true
                 new(OpCodes.Ldc_I4_1),
 
-                // SpawningTeamVehicleEventArgs ev = new(SpawnableTeamType, bool);
+                // SpawningTeamVehicleEventArgs ev = new(SpawnableWaveBase, bool);
                 new(OpCodes.Newobj, GetDeclaredConstructors(typeof(SpawningTeamVehicleEventArgs))[0]),
                 new(OpCodes.Dup),
-                new(OpCodes.Dup),
-                new(OpCodes.Stloc_S, ev.LocalIndex),
 
                 // Handlers.Map.OnSpawningTeamVehicle(ev);
                 new(OpCodes.Call, Method(typeof(Handlers.Map), nameof(Handlers.Map.OnSpawningTeamVehicle))),
@@ -71,11 +68,6 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 new(OpCodes.Callvirt, PropertyGetter(typeof(SpawningTeamVehicleEventArgs), nameof(SpawningTeamVehicleEventArgs.IsAllowed))),
                 new(OpCodes.Brfalse_S, retLabel),
 
-                // team = ev.Team
-                new(OpCodes.Ldloc_S, ev),
-                new(OpCodes.Callvirt, PropertyGetter(typeof(SpawningTeamVehicleEventArgs), nameof(SpawningTeamVehicleEventArgs.Team))),
-                new(OpCodes.Starg_S, 1),
-
                 new CodeInstruction(OpCodes.Ldloc_S, msg.LocalIndex).WithLabels(continueLabel),
             });
 
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/ChangingRoleAndSpawned.cs b/EXILED/Exiled.Events/Patches/Events/Player/ChangingRoleAndSpawned.cs
index 37cbdc9e7a..5e7b1d0d18 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/ChangingRoleAndSpawned.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/ChangingRoleAndSpawned.cs
@@ -18,12 +18,17 @@ namespace Exiled.Events.Patches.Events.Player
     using Exiled.Events.EventArgs.Player;
     using HarmonyLib;
     using InventorySystem;
+    using InventorySystem.Configs;
     using InventorySystem.Items;
     using InventorySystem.Items.Armor;
     using InventorySystem.Items.Pickups;
+    using InventorySystem.Items.Usables.Scp1344;
+    using Mirror;
+
     using PlayerRoles;
 
     using static HarmonyLib.AccessTools;
+    using static UnityEngine.GraphicsBuffer;
 
     using Player = Handlers.Player;
 
@@ -146,18 +151,8 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
                     // ChangingRole.ChangeInventory(changingRoleEventArgs, oldRoleType);
                     new(OpCodes.Call, Method(typeof(ChangingRoleAndSpawned), nameof(ChangeInventory))),
-                });
-
-            newInstructions.InsertRange(
-                newInstructions.Count - 1,
-                new CodeInstruction[]
-                {
-                    // if (this.isLocalPlayer)
-                    //     return;
-                    new(OpCodes.Ldarg_0),
-                    new(OpCodes.Callvirt, PropertyGetter(typeof(PlayerRoleManager), nameof(PlayerRoleManager.isLocalPlayer))),
-                    new(OpCodes.Brtrue_S, returnLabel),
 
+                    // invoke OnSpawned
                     // player
                     new(OpCodes.Ldloc_S, player.LocalIndex),
 
@@ -191,59 +186,71 @@ private static void ChangeInventory(ChangingRoleEventArgs ev)
         {
             try
             {
-                if (ev.ShouldPreserveInventory || ev.Reason == API.Enums.SpawnReason.Destroyed)
+                if (!NetworkServer.active || !ev.SpawnFlags.HasFlag(RoleSpawnFlags.AssignInventory))
+                {
                     return;
+                }
 
                 Inventory inventory = ev.Player.Inventory;
-
-                if (ev.Reason == API.Enums.SpawnReason.Escaped)
+                bool flag = InventoryItemProvider.KeepItemsAfterEscaping && ev.Reason == API.Enums.SpawnReason.Escaped;
+                if (flag)
                 {
-                    List<ItemPickupBase> list = new();
+                    List<ItemPickupBase> list = new List<ItemPickupBase>();
                     if (inventory.TryGetBodyArmor(out BodyArmor bodyArmor))
+                    {
                         bodyArmor.DontRemoveExcessOnDrop = true;
+                    }
 
-                    while (inventory.UserInventory.Items.Count > 0)
+                    HashSet<ushort> hashSet = HashSetPool<ushort>.Pool.Get();
+                    foreach (KeyValuePair<ushort, ItemBase> item2 in inventory.UserInventory.Items)
                     {
-                        int startCount = inventory.UserInventory.Items.Count;
-                        ushort key = inventory.UserInventory.Items.ElementAt(0).Key;
-                        ItemPickupBase item = inventory.ServerDropItem(key);
-
-                        // If the list wasn't changed, we need to manually remove the item to avoid a softlock.
-                        if (startCount == inventory.UserInventory.Items.Count)
-                            inventory.UserInventory.Items.Remove(key);
+                        if (item2.Value is Scp1344Item scp1344Item)
+                        {
+                            scp1344Item.Status = Scp1344Status.Idle;
+                        }
                         else
-                            list.Add(item);
+                        {
+                            hashSet.Add(item2.Key);
+                        }
                     }
 
+                    foreach (ushort item3 in hashSet)
+                    {
+                        list.Add(inventory.ServerDropItem(item3));
+                    }
+
+                    HashSetPool<ushort>.Pool.Return(hashSet);
                     InventoryItemProvider.PreviousInventoryPickups[ev.Player.ReferenceHub] = list;
                 }
-                else
+
+                if (!flag)
                 {
                     while (inventory.UserInventory.Items.Count > 0)
                     {
-                        int startCount = inventory.UserInventory.Items.Count;
-                        ushort key = inventory.UserInventory.Items.ElementAt(0).Key;
-                        inventory.ServerRemoveItem(key, null);
-
-                        // If the list wasn't changed, we need to manually remove the item to avoid a softlock.
-                        if (startCount == inventory.UserInventory.Items.Count)
-                            inventory.UserInventory.Items.Remove(key);
+                        inventory.ServerRemoveItem(inventory.UserInventory.Items.ElementAt(0).Key, null);
                     }
 
                     inventory.UserInventory.ReserveAmmo.Clear();
                     inventory.SendAmmoNextFrame = true;
                 }
 
-                foreach (ItemType item in ev.Items)
-                    inventory.ServerAddItem(item, ItemAddReason.StartingItem);
+                if (!StartingInventories.DefinedInventories.TryGetValue(ev.NewRole, out InventoryRoleInfo value))
+                {
+                    return;
+                }
 
-                foreach (KeyValuePair<ItemType, ushort> keyValuePair in ev.Ammo)
-                    inventory.ServerAddAmmo(keyValuePair.Key, keyValuePair.Value);
+                foreach (KeyValuePair<ItemType, ushort> item in value.Ammo)
+                {
+                    inventory.ServerAddAmmo(item.Key, item.Value);
+                }
 
-                foreach (KeyValuePair<ushort, InventorySystem.Items.ItemBase> item in inventory.UserInventory.Items)
-                    InventoryItemProvider.OnItemProvided?.Invoke(ev.Player.ReferenceHub, item.Value);
+                for (int i = 0; i < value.Items.Length; i++)
+                {
+                    ItemBase arg = inventory.ServerAddItem(value.Items[i], ItemAddReason.StartingItem, 0);
+                    InventoryItemProvider.OnItemProvided?.Invoke(ev.Player.ReferenceHub, arg);
+                }
 
-                InventoryItemProvider.SpawnPreviousInventoryPickups(ev.Player.ReferenceHub);
+                InventoryItemProvider.InventoriesToReplenish.Enqueue(ev.Player.ReferenceHub);
             }
             catch (Exception exception)
             {
@@ -251,4 +258,4 @@ private static void ChangeInventory(ChangingRoleEventArgs ev)
             }
         }
     }
-}
\ No newline at end of file
+}
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/Joined.cs b/EXILED/Exiled.Events/Patches/Events/Player/Joined.cs
index 75fc346a87..18421e5044 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/Joined.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/Joined.cs
@@ -39,11 +39,7 @@ internal static void CallEvent(ReferenceHub hub, out Player player)
 #endif
                 Player.UnverifiedPlayers.Add(hub.gameObject, player);
 
-                if (ReferenceHub._hostHub == null)
-                {
-                    Server.Host = player;
-                }
-                else
+                if (ReferenceHub._hostHub != null)
                 {
                     Handlers.Player.OnJoined(new JoinedEventArgs(player));
                 }
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
index 3c779e7043..fc1265b8e1 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/Shooting.cs
@@ -18,8 +18,10 @@ namespace Exiled.Events.Patches.Events.Player
 
     using HarmonyLib;
 
+    using InventorySystem.Items.Firearms;
     using InventorySystem.Items.Firearms.BasicMessages;
     using InventorySystem.Items.Firearms.Modules;
+    using InventorySystem.Items.Firearms.Modules.Misc;
 
     using static HarmonyLib.AccessTools;
 
@@ -29,41 +31,33 @@ namespace Exiled.Events.Patches.Events.Player
     /// </summary>
     [EventPatch(typeof(Handlers.Player), nameof(Handlers.Player.Shooting))]
 
-    // [HarmonyPatch(typeof(FirearmBasicMessagesHandler), nameof(FirearmBasicMessagesHandler.ServerShotReceived))]
+    [HarmonyPatch(typeof(ShotBacktrackData), nameof(ShotBacktrackData.ProcessShot))]
     internal static class Shooting
     {
-        /*
         private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
         {
             List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Pool.Get(instructions);
 
-            Label isAllowedLabel = generator.DefineLabel();
             Label returnLabel = generator.DefineLabel();
 
-            LocalBuilder ev = generator.DeclareLocal(typeof(ShootingEventArgs));
-
-            int offset = -2;
-            int index = newInstructions.FindIndex(instruction => instruction.Calls(Method(typeof(IActionModule), nameof(IActionModule.ServerAuthorizeShot)))) + offset;
+            int offset = 1;
+            int index = newInstructions.FindIndex(instruction => instruction.opcode == OpCodes.Stloc_2) + offset;
 
             newInstructions.InsertRange(
                 index,
                 new[]
                 {
-                    // Player.Get(referenceHub)
-                    new CodeInstruction(OpCodes.Ldloc_0).MoveLabelsFrom(newInstructions[index]),
+                    // Player.Get(firearm.Owner)
+                    new(OpCodes.Ldarg_1),
+                    new(OpCodes.Callvirt, PropertyGetter(typeof(Firearm), nameof(Firearm.Owner))),
                     new(OpCodes.Call, Method(typeof(Player), nameof(Player.Get), new[] { typeof(ReferenceHub) })),
 
                     // firearm
-                    new(OpCodes.Ldloc_1),
-
-                    // msg
-                    new(OpCodes.Ldarg_1),
+                    new CodeInstruction(OpCodes.Ldarg_1).MoveLabelsFrom(newInstructions[index]),
 
-                    // ShootingEventArgs ev = new(Player, firearm, ShotMessage)
+                    // ShootingEventArgs ev = new(Player, firearm)
                     new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ShootingEventArgs))[0]),
                     new(OpCodes.Dup),
-                    new(OpCodes.Dup),
-                    new(OpCodes.Stloc, ev.LocalIndex),
 
                     // Handlers.Player.OnShooting(ev)
                     new(OpCodes.Call, Method(typeof(Handlers.Player), nameof(Handlers.Player.OnShooting))),
@@ -72,12 +66,6 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                     //    return;
                     new(OpCodes.Callvirt, PropertyGetter(typeof(ShootingEventArgs), nameof(ShootingEventArgs.IsAllowed))),
                     new(OpCodes.Brfalse_S, returnLabel),
-
-                    // isAllowedLabel:
-                    // msg = ev.ShotMessage
-                    new CodeInstruction(OpCodes.Ldloc_S, ev.LocalIndex).WithLabels(isAllowedLabel),
-                    new(OpCodes.Callvirt, PropertyGetter(typeof(ShootingEventArgs), nameof(ShootingEventArgs.ShotMessage))),
-                    new(OpCodes.Starg_S, 1),
                 });
 
             newInstructions[newInstructions.Count - 1].WithLabels(returnLabel);
@@ -87,6 +75,5 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
             ListPool<CodeInstruction>.Pool.Return(newInstructions);
         }
-        */
     }
 }
\ No newline at end of file
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/Spawning.cs b/EXILED/Exiled.Events/Patches/Events/Player/Spawning.cs
index f740e1637b..af8b3a6c20 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/Spawning.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/Spawning.cs
@@ -15,7 +15,6 @@ namespace Exiled.Events.Patches.Events.Player
     using Exiled.API.Features.Pools;
     using Exiled.Events.Attributes;
     using Exiled.Events.EventArgs.Player;
-    using Exiled.Events.EventArgs.Server;
     using HarmonyLib;
 
     using PlayerRoles.FirstPersonControl.Spawnpoints;
@@ -39,9 +38,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             int offset = -1;
 
             // Locate the call to `Transform.position` setter to determine where to insert new instructions.
-            MethodInfo setPositionMethod = PropertySetter(typeof(Transform), nameof(Transform.position));
-            int index = newInstructions.FindIndex(instr =>
-                instr.opcode == OpCodes.Callvirt && instr.operand as MethodInfo == setPositionMethod) + offset;
+            int index = newInstructions.FindIndex(instr => instr.Calls(PropertySetter(typeof(Transform), nameof(Transform.position)))) + offset;
 
             // Declare the `SpawningEventArgs` local variable.
             LocalBuilder ev = generator.DeclareLocal(typeof(SpawningEventArgs));
@@ -90,4 +87,4 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             ListPool<CodeInstruction>.Pool.Return(newInstructions);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/EXILED/Exiled.Events/Patches/Events/Player/SpawningRagdoll.cs b/EXILED/Exiled.Events/Patches/Events/Player/SpawningRagdoll.cs
index 2f9651160f..d38f915959 100644
--- a/EXILED/Exiled.Events/Patches/Events/Player/SpawningRagdoll.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Player/SpawningRagdoll.cs
@@ -45,17 +45,19 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
             LocalBuilder ev = generator.DeclareLocal(typeof(SpawningRagdollEventArgs));
 
-            int offset = 0;
+            int offset = 1;
             int index = newInstructions.FindIndex(instruction => instruction.Calls(PropertySetter(typeof(BasicRagdoll), nameof(BasicRagdoll.NetworkInfo)))) + offset;
 
             newInstructions.InsertRange(index, new CodeInstruction[]
             {
-                // RagdollInfo loads into stack before il inject
+                // ragdoll.NetworkInfo
+                new(OpCodes.Ldloc_1),
+                new(OpCodes.Callvirt, PropertyGetter(typeof(BasicRagdoll), nameof(BasicRagdoll.NetworkInfo))),
 
                 // true
                 new(OpCodes.Ldc_I4_1),
 
-                // SpawningRagdollEventArgs ev = new(RagdollInfo, bool)
+                // SpawningRagdollEventArgs ev = new(ragdoll, RagdollInfo, bool)
                 new(OpCodes.Newobj, GetDeclaredConstructors(typeof(SpawningRagdollEventArgs))[0]),
                 new(OpCodes.Dup),
                 new(OpCodes.Dup),
@@ -71,7 +73,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 new(OpCodes.Callvirt, PropertyGetter(typeof(SpawningRagdollEventArgs), nameof(SpawningRagdollEventArgs.IsAllowed))),
                 new(OpCodes.Brtrue_S, cnt),
 
-                // gameobject loads into stack before il inject
+                // destroy ragdoll and ret null
                 new(OpCodes.Ldloc_1),
                 new(OpCodes.Callvirt, PropertyGetter(typeof(BasicRagdoll), nameof(BasicRagdoll.gameObject))),
                 new(OpCodes.Call, Method(typeof(Object), nameof(Object.Destroy), new[] { typeof(Object) })),
@@ -96,10 +98,6 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
                 // ragdoll.gameObject.transform.localScale = targetScale
                 new(OpCodes.Callvirt, PropertySetter(typeof(Transform), nameof(Transform.localScale))),
-
-                // load ragdollInfo into stack*/
-                new(OpCodes.Ldloc_S, ev.LocalIndex),
-                new(OpCodes.Callvirt, PropertyGetter(typeof(SpawningRagdollEventArgs), nameof(SpawningRagdollEventArgs.Info))),
             });
 
             newInstructions.InsertRange(newInstructions.Count - 2, new CodeInstruction[]
diff --git a/EXILED/Exiled.Events/Patches/Events/Scp106/ExitStalking.cs b/EXILED/Exiled.Events/Patches/Events/Scp106/ExitStalking.cs
index d98ce08c8e..4265abef8b 100644
--- a/EXILED/Exiled.Events/Patches/Events/Scp106/ExitStalking.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Scp106/ExitStalking.cs
@@ -25,7 +25,7 @@ namespace Exiled.Events.Patches.Events.Scp106
     /// To add the <see cref="Handlers.Scp106.ExitStalking"/> event.
     /// </summary>
     [EventPatch(typeof(Handlers.Scp106), nameof(Handlers.Scp106.ExitStalking))]
-    [HarmonyPatch(typeof(Scp106StalkAbility), nameof(Scp106StalkAbility.StalkActive), MethodType.Setter)]
+    [HarmonyPatch(typeof(Scp106StalkAbility), nameof(Scp106StalkAbility.ServerSetStalk))]
     public class ExitStalking
     {
         private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
@@ -36,20 +36,22 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
             Label continueLabel = generator.DefineLabel();
             Label returnLabel = generator.DefineLabel();
-            int offset = -3;
-            int index = newInstructions.FindIndex(instruction => instruction.opcode == OpCodes.Newobj) + offset;
+
+            int offset = -2;
+            int index = newInstructions.FindIndex(instruction => instruction.Calls(PropertySetter(typeof(Scp106StalkAbility), nameof(Scp106StalkAbility.StalkActive)))) + offset;
+
             newInstructions.InsertRange(
                 index,
                 new CodeInstruction[]
                 {
                     // if (value is false) continue;
                     new CodeInstruction(OpCodes.Ldarg_1).MoveLabelsFrom(newInstructions[index]),
-                    new(OpCodes.Ldc_I4_0),
+                    new(OpCodes.Ldc_I4_1),
                     new(OpCodes.Beq_S, continueLabel),
 
                     // Player.Get(this.Owner);
                     new(OpCodes.Ldarg_0),
-                    new(OpCodes.Callvirt, PropertyGetter(typeof(Scp106HuntersAtlasAbility), nameof(Scp106HuntersAtlasAbility.Owner))),
+                    new(OpCodes.Callvirt, PropertyGetter(typeof(Scp106StalkAbility), nameof(Scp106StalkAbility.Owner))),
                     new(OpCodes.Call, Method(typeof(Player), nameof(Player.Get), new[] { typeof(ReferenceHub) })),
 
                     // true
@@ -58,8 +60,6 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                     // ExitStalking ev = new(Player, isAllowed)
                     new(OpCodes.Newobj, GetDeclaredConstructors(typeof(ExitStalkingEventArgs))[0]),
                     new(OpCodes.Dup),
-                    new(OpCodes.Dup),
-                    new(OpCodes.Stloc_S, ev.LocalIndex),
 
                     // Handlers.Scp106.OnExitStalking(ev)
                     new(OpCodes.Call, Method(typeof(Handlers.Scp106), nameof(Handlers.Scp106.OnExitStalking))),
@@ -68,11 +68,9 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                     //    return;
                     new(OpCodes.Callvirt, PropertyGetter(typeof(ExitStalkingEventArgs), nameof(ExitStalkingEventArgs.IsAllowed))),
                     new(OpCodes.Brfalse_S, returnLabel),
-                });
 
-            offset = -3;
-            index = newInstructions.FindIndex(instruction => instruction.opcode == OpCodes.Newobj) + offset;
-            newInstructions[index].labels.Add(continueLabel);
+                    new CodeInstruction(OpCodes.Nop).WithLabels(continueLabel),
+                });
 
             newInstructions[newInstructions.Count - 1].labels.Add(returnLabel);
 
diff --git a/EXILED/Exiled.Events/Patches/Events/Scp914/UpgradingPlayer.cs b/EXILED/Exiled.Events/Patches/Events/Scp914/UpgradingPlayer.cs
index 79fdb2a4ea..18394fda42 100644
--- a/EXILED/Exiled.Events/Patches/Events/Scp914/UpgradingPlayer.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Scp914/UpgradingPlayer.cs
@@ -36,27 +36,21 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
         {
             List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Pool.Get(instructions);
 
-            // Find override position
-            const int offset = -3;
-            int index = newInstructions.FindIndex(instruction => instruction.Calls(Method(typeof(FpcExtensionMethods), nameof(FpcExtensionMethods.TryOverridePosition)))) + offset;
-
             Label returnLabel = generator.DefineLabel();
 
             LocalBuilder curSetting = generator.DeclareLocal(typeof(Scp914KnobSetting));
             LocalBuilder ev = generator.DeclareLocal(typeof(UpgradingPlayerEventArgs));
 
-            // Move labels from override - 3 position (Right after a branch)
-            List<Label> labels = newInstructions[index].labels;
-
-            // Remove TryOverride, and !upgradeInventory
-            newInstructions.RemoveRange(index, 5);
+            // Find override position
+            const int offset = -3;
+            int index = newInstructions.FindIndex(instruction => instruction.Calls(Method(typeof(FpcExtensionMethods), nameof(FpcExtensionMethods.TryOverridePosition)))) + offset;
 
             newInstructions.InsertRange(
                 index,
                 new[]
                 {
                     // Player.Get(ply)
-                    new CodeInstruction(OpCodes.Ldarg_0).WithLabels(labels),
+                    new CodeInstruction(OpCodes.Ldarg_0),
                     new(OpCodes.Call, Method(typeof(Player), nameof(Player.Get), new[] { typeof(ReferenceHub) })),
 
                     // upgradeInventory
@@ -66,9 +60,9 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                     new(OpCodes.Ldarg_2),
 
                     // setting
-                    new(OpCodes.Ldarg_S, 3),
+                    new(OpCodes.Ldarg_3),
 
-                    // moveVector
+                    // outputPosition
                     new(OpCodes.Ldloc_0),
 
                     // UpgradingPlayerEventArgs ev = new(player, upgradeInventory, heldonly, setting, moveVector);
@@ -89,6 +83,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                     new(OpCodes.Ldloc_S, ev.LocalIndex),
                     new(OpCodes.Dup),
                     new(OpCodes.Dup),
+                    new(OpCodes.Dup),
 
                     // upgradeInventory = ev.UpgradeItems
                     new(OpCodes.Callvirt, PropertyGetter(typeof(UpgradingPlayerEventArgs), nameof(UpgradingPlayerEventArgs.UpgradeItems))),
@@ -102,16 +97,13 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                     new(OpCodes.Callvirt, PropertyGetter(typeof(UpgradingPlayerEventArgs), nameof(UpgradingPlayerEventArgs.KnobSetting))),
                     new(OpCodes.Starg_S, 3),
 
+                    // outputPosition = ev.OutputPosition
+                    new(OpCodes.Callvirt, PropertyGetter(typeof(UpgradingPlayerEventArgs), nameof(UpgradingPlayerEventArgs.OutputPosition))),
+                    new(OpCodes.Stloc_0),
+
                     // curSetting = setting;
                     new(OpCodes.Ldarg_S, 3),
                     new(OpCodes.Stloc_S, curSetting.LocalIndex),
-
-                    // ev.Player.Teleport(ev.OutputPosition);
-                    new(OpCodes.Ldloc_S, ev.LocalIndex),
-                    new(OpCodes.Callvirt, PropertyGetter(typeof(UpgradingPlayerEventArgs), nameof(UpgradingPlayerEventArgs.Player))),
-                    new(OpCodes.Ldloc_S, ev.LocalIndex),
-                    new(OpCodes.Callvirt, PropertyGetter(typeof(UpgradingPlayerEventArgs), nameof(UpgradingPlayerEventArgs.OutputPosition))),
-                    new(OpCodes.Callvirt, Method(typeof(Player), nameof(Player.Teleport), new[] { typeof(Vector3) })),
                 });
 
             // Find InventoryUpgrade, and set position there.
@@ -144,6 +136,8 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
                     // setting
                     new(OpCodes.Ldarg_S, 3),
+
+                    // true
                     new(OpCodes.Ldc_I4_1),
 
                     // UpgradingInventoryItemEventArgs ev = new(player, itemBase, setting)
@@ -174,4 +168,4 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
             ListPool<CodeInstruction>.Pool.Return(newInstructions);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/EXILED/Exiled.Events/Patches/Events/Server/RespawningTeam.cs b/EXILED/Exiled.Events/Patches/Events/Server/RespawningTeam.cs
index ea2f3546ff..50baf6384e 100644
--- a/EXILED/Exiled.Events/Patches/Events/Server/RespawningTeam.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Server/RespawningTeam.cs
@@ -7,12 +7,15 @@
 
 namespace Exiled.Events.Patches.Events.Server
 {
+    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Reflection;
     using System.Reflection.Emit;
 
     using API.Features.Pools;
+
+    using Exiled.API.Extensions;
     using Exiled.Events.Attributes;
     using Exiled.Events.EventArgs.Server;
     using Exiled.Events.Handlers;
@@ -50,23 +53,20 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 new[]
                 {
                     // GetPlayers(list);
-                    new CodeInstruction(OpCodes.Ldloc_2).MoveLabelsFrom(newInstructions[index]),
+                    new CodeInstruction(OpCodes.Ldloc_S, 2).MoveLabelsFrom(newInstructions[index]),
                     new(OpCodes.Call, Method(typeof(RespawningTeam), nameof(GetPlayers))),
 
                     // maxWaveSize
-                    new(OpCodes.Ldloc_2),
-
-                    // this.NextKnownTeam
-                    new(OpCodes.Ldarg_1),
+                    new(OpCodes.Ldloc_3),
 
-                    // true
-                    new(OpCodes.Ldc_I4_1),
+                    // wave
+                    new(OpCodes.Ldarg_0),
 
-                    // RespawningTeamEventArgs ev = new(players, num, this.NextKnownTeam)
+                    // RespawningTeamEventArgs ev = new(players, num, wave)
                     new(OpCodes.Newobj, GetDeclaredConstructors(typeof(RespawningTeamEventArgs))[0]),
                     new(OpCodes.Dup),
                     new(OpCodes.Dup),
-                    new(OpCodes.Stloc, ev.LocalIndex),
+                    new(OpCodes.Stloc_S, ev.LocalIndex),
 
                     // Handlers.Server.OnRespawningTeam(ev)
                     new(OpCodes.Call, Method(typeof(Server), nameof(Server.OnRespawningTeam))),
@@ -77,33 +77,29 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                     new(OpCodes.Brtrue_S, continueLabel),
 
                     // this.NextKnownTeam == null
-                    //    return;
-                    new(OpCodes.Ldnull),
-                    new(OpCodes.Stsfld, Field(typeof(WaveManager), nameof(WaveManager._nextWave))),
+                    // return;
+                    new(OpCodes.Ldsfld, Field(typeof(WaveSpawner), nameof(WaveSpawner.SpawnQueue))),
+                    new(OpCodes.Callvirt, Method(typeof(Queue<RoleTypeId>), nameof(Queue<RoleTypeId>.Clear))),
+                    new(OpCodes.Newobj, Constructor(typeof(List<ReferenceHub>), new Type[0])),
                     new(OpCodes.Ret),
 
                     // load "ev" four times
                     new CodeInstruction(OpCodes.Ldloc_S, ev.LocalIndex).WithLabels(continueLabel),
                     new(OpCodes.Dup),
                     new(OpCodes.Dup),
-                    new(OpCodes.Dup),
 
                     // num = ev.MaximumRespawnAmount
                     new(OpCodes.Callvirt, PropertyGetter(typeof(RespawningTeamEventArgs), nameof(RespawningTeamEventArgs.MaximumRespawnAmount))),
-                    new(OpCodes.Stloc_S, 4),
+                    new(OpCodes.Stloc_3),
 
                     // list = GetHubs(ev.Players)
                     new(OpCodes.Callvirt, PropertyGetter(typeof(RespawningTeamEventArgs), nameof(RespawningTeamEventArgs.Players))),
                     new(OpCodes.Call, Method(typeof(RespawningTeam), nameof(GetHubs))),
-                    new(OpCodes.Stloc_1),
-
-                    // queueToFill = ev.SpawnQueue;
-                    new CodeInstruction(OpCodes.Callvirt, PropertyGetter(typeof(RespawningTeamEventArgs), nameof(RespawningTeamEventArgs.SpawnQueue))),
-                    new(OpCodes.Call, Method(typeof(RespawningTeam), nameof(RefillQueue))),
+                    new(OpCodes.Stloc_S, 2),
 
-                    // wave = ev.NextKnownTeam;
-                    new(OpCodes.Callvirt, PropertyGetter(typeof(RespawningTeamEventArgs), nameof(RespawningTeamEventArgs.NextKnownTeam))),
-                    new(OpCodes.Starg_S, 1),
+                    // wave = ev.Wave;
+                    new(OpCodes.Callvirt, PropertyGetter(typeof(RespawningTeamEventArgs), nameof(RespawningTeamEventArgs.Wave))),
+                    new(OpCodes.Starg_S, 0),
                 });
 
             for (int z = 0; z < newInstructions.Count; z++)
diff --git a/EXILED/Exiled.Events/Patches/Events/Server/RoundEnd.cs b/EXILED/Exiled.Events/Patches/Events/Server/RoundEnd.cs
index e9295a33c7..9412f3fb92 100644
--- a/EXILED/Exiled.Events/Patches/Events/Server/RoundEnd.cs
+++ b/EXILED/Exiled.Events/Patches/Events/Server/RoundEnd.cs
@@ -12,6 +12,7 @@ namespace Exiled.Events.Patches.Events.Server
     using System.Reflection;
     using System.Reflection.Emit;
 
+    using Exiled.API.Extensions;
     using Exiled.API.Features;
     using Exiled.API.Features.Pools;
     using Exiled.Events.EventArgs.Server;
@@ -35,7 +36,7 @@ internal static class RoundEnd
 
         private static MethodInfo TargetMethod()
         {
-            PrivateType = typeof(RoundSummary).GetNestedTypes(all)[5];
+            PrivateType = typeof(RoundSummary).GetNestedTypes(all)[6];
             return Method(PrivateType, "MoveNext");
         }
 
@@ -58,7 +59,7 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
                 new CodeInstruction[]
                 {
                     new(OpCodes.Call, PropertyGetter(typeof(Round), nameof(Round.IgnoredPlayers))),
-                    new(OpCodes.Ldloc_S, 10),
+                    new(OpCodes.Ldloc_S, 11),
                     new(OpCodes.Call, Method(typeof(HashSet<ReferenceHub>), nameof(HashSet<ReferenceHub>.Contains))),
                     new(OpCodes.Brtrue_S, jmp),
                 });
@@ -68,20 +69,6 @@ private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstructi
 
             newInstructions[index].labels.Add(jmp);
 
-            // Replace Network_extraTargets == 0 with Network_extraTargets <= 0 // TODO VERIFY THAN this still exist
-            offset = 1;
-            index = newInstructions.FindIndex(x => x.Calls(PropertyGetter(typeof(RoundSummary), nameof(RoundSummary.Network_extraTargets)))) + offset;
-            Label label = (Label)newInstructions[index].operand;
-            newInstructions.RemoveAt(index);
-
-            newInstructions.InsertRange(
-                index,
-                new CodeInstruction[]
-                {
-                    new(OpCodes.Ldc_I4_0),
-                    new(OpCodes.Bgt_S, label),
-                });
-
             offset = -1;
             index = newInstructions.FindIndex(x => x.opcode == OpCodes.Ldfld && x.operand == (object)Field(typeof(RoundSummary), nameof(RoundSummary._roundEnded))) + offset;
 
diff --git a/EXILED/Exiled.Events/Patches/Fixes/Fix106RegenerationWithScp244.cs b/EXILED/Exiled.Events/Patches/Fixes/Fix106RegenerationWithScp244.cs
deleted file mode 100644
index 7cc7da66ca..0000000000
--- a/EXILED/Exiled.Events/Patches/Fixes/Fix106RegenerationWithScp244.cs
+++ /dev/null
@@ -1,72 +0,0 @@
-// -----------------------------------------------------------------------
-// <copyright file="Fix106RegenerationWithScp244.cs" company="ExMod Team">
-// Copyright (c) ExMod Team. All rights reserved.
-// Licensed under the CC BY-SA 3.0 license.
-// </copyright>
-// -----------------------------------------------------------------------
-
-namespace Exiled.Events.Patches.Fixes
-{
-    using System.Collections.Generic;
-    using System.Reflection.Emit;
-
-    using API.Features.Pools;
-    using CustomPlayerEffects;
-    using Exiled.API.Features;
-    using Exiled.API.Features.Roles;
-    using HarmonyLib;
-    using InventorySystem.Items.Usables.Scp244.Hypothermia;
-
-    using static HarmonyLib.AccessTools;
-
-    /// <summary>
-    /// Patches the <see cref="Hypothermia.Update()"/> delegate.
-    /// Fix than SCP-106 regenerates slower in SCP-244 even if they are in stalk.
-    /// Bug reported to NW (https://git.scpslgame.com/northwood-qa/scpsl-bug-reporting/-/issues/367).
-    /// </summary>
-    [HarmonyPatch(typeof(Hypothermia), nameof(Hypothermia.Update))]
-    internal class Fix106RegenerationWithScp244
-    {
-        private static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
-        {
-            List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Pool.Get(instructions);
-
-            LocalBuilder scp106Role = generator.DeclareLocal(typeof(Scp106Role));
-            Label continueLabel = generator.DefineLabel();
-
-            int offset = 1;
-            int index = newInstructions.FindLastIndex(x => x.operand == (object)Method(typeof(SpawnProtected), nameof(SpawnProtected.CheckPlayer))) + offset;
-
-            Label skip = (Label)newInstructions[index].operand;
-
-            index += offset;
-
-            newInstructions[index].labels.Add(continueLabel);
-
-            newInstructions.InsertRange(index, new[]
-            {
-                // Scp106Role scp106Role = base.Hub.roleManager.CurrentRole as Scp106Role;
-                new CodeInstruction(OpCodes.Ldarg_0),
-                new CodeInstruction(OpCodes.Callvirt, PropertyGetter(typeof(StatusEffectBase), nameof(StatusEffectBase.Hub))),
-                new CodeInstruction(OpCodes.Call, Method(typeof(Player), nameof(Player.Get), new[] { typeof(ReferenceHub) })),
-                new CodeInstruction(OpCodes.Callvirt, PropertyGetter(typeof(Player), nameof(Player.Role))),
-                new CodeInstruction(OpCodes.Isinst, typeof(Scp106Role)),
-                new CodeInstruction(OpCodes.Stloc_S, scp106Role.LocalIndex),
-
-                // if (scp106Role is null) goto continueLabel
-                new CodeInstruction(OpCodes.Ldloc_S, scp106Role.LocalIndex),
-                new CodeInstruction(OpCodes.Brfalse_S, continueLabel),
-
-                // if (!scp106Role.IsSubmerged) goto skip
-                new CodeInstruction(OpCodes.Ldloc_S, scp106Role.LocalIndex),
-                new CodeInstruction(OpCodes.Callvirt, PropertyGetter(typeof(Scp106Role), nameof(Scp106Role.IsSubmerged))),
-                new CodeInstruction(OpCodes.Brtrue_S, skip),
-            });
-
-            for (int z = 0; z < newInstructions.Count; z++)
-                yield return newInstructions[z];
-
-            ListPool<CodeInstruction>.Pool.Return(newInstructions);
-        }
-    }
-}
diff --git a/EXILED/Exiled.Events/Patches/Generic/PocketDimensionTeleportList.cs b/EXILED/Exiled.Events/Patches/Generic/PocketDimensionTeleportList.cs
index f537907649..91a54a9c4f 100644
--- a/EXILED/Exiled.Events/Patches/Generic/PocketDimensionTeleportList.cs
+++ b/EXILED/Exiled.Events/Patches/Generic/PocketDimensionTeleportList.cs
@@ -20,7 +20,7 @@ internal class PocketDimensionTeleportList
     {
         [HarmonyPatch(typeof(PocketDimensionTeleport), nameof(PocketDimensionTeleport.Awake))]
         [HarmonyPostfix]
-        private static void Adding(PocketDimensionTeleport __instance) => _ = Map.TeleportsValue.AddItem(__instance);
+        private static void Adding(PocketDimensionTeleport __instance) => Map.TeleportsValue.Add(__instance);
 
         [HarmonyPatch(typeof(PocketDimensionTeleport), nameof(PocketDimensionTeleport.OnDestroy))]
         [HarmonyPostfix]
diff --git a/Exiled/Exiled.Events/Patches/Events/Server/WaitingForPlayers.cs b/Exiled/Exiled.Events/Patches/Events/Server/WaitingForPlayers.cs
new file mode 100644
index 0000000000..ec2d14a980
--- /dev/null
+++ b/Exiled/Exiled.Events/Patches/Events/Server/WaitingForPlayers.cs
@@ -0,0 +1,31 @@
+// -----------------------------------------------------------------------
+// <copyright file="WaitingForPlayers.cs" company="ExMod Team">
+// Copyright (c) ExMod Team. All rights reserved.
+// Licensed under the CC BY-SA 3.0 license.
+// </copyright>
+// -----------------------------------------------------------------------
+
+namespace Exiled.Events.Patches.Events.Server
+{
+#pragma warning disable SA1313 // Parameter names should begin with lower-case letter
+
+    using API.Features;
+    using HarmonyLib;
+
+    /// <summary>
+    ///     Patches <see cref="CharacterClassManager.Start" />.
+    ///     Adds the <see cref="Handlers.Server.WaitingForPlayers" /> event.
+    /// </summary>
+    [HarmonyPatch(typeof(ReferenceHub), nameof(ReferenceHub.Start))]
+    internal static class WaitingForPlayers
+    {
+        private static void Postfix(ReferenceHub __instance)
+        {
+            if (!__instance.isLocalPlayer)
+                return;
+
+            Server.Host = new Player(__instance);
+            Handlers.Server.OnWaitingForPlayers();
+        }
+    }
+}