Merge pull request #44 from B3none/player-join-improvements

B3none · web-flow · commit 903945b1280c · 2024-01-21T01:26:54.000Z
Player join improvements and breaker manager stability improvements
diff --git a/Modules/Managers/BreakerManager.cs b/Modules/Managers/BreakerManager.cs
@@ -71,33 +71,17 @@ public void Handle()
                 {
                     case "func_breakable":
                     case "func_breakable_surf":
+                    case "prop_dynamic":
+                    case "prop.breakable.01":
+                    case "prop.breakable.02":
                         var breakableEntity = new PointerTo<CBreakable>(pEntity.Handle).Value;
 
                         if (breakableEntity.IsValid)
                         {
                             breakableEntity.AcceptInput(action);
                         }
                         break;
-                        
-                    case "prop.breakable.01":
-                    case "prop.breakable.02":
-                        var breakableProp = new PointerTo<CBreakableProp>(pEntity.Handle).Value;
-                        
-                        if (breakableProp.IsValid)
-                        {
-                            breakableProp.AcceptInput(action);
-                        }
-                        break;
-                        
-                    case "prop_dynamic":
-                        var dynamicProp = new PointerTo<CDynamicProp>(pEntity.Handle).Value;
-                        
-                        if (dynamicProp.IsValid)
-                        {
-                            dynamicProp.AcceptInput(action);
-                        }
-                        break;
-                        
+
                     case "func_button":
                         var button = new PointerTo<CBaseButton>(pEntity.Handle).Value;
                         
diff --git a/Modules/Managers/QueueManager.cs b/Modules/Managers/QueueManager.cs
@@ -30,39 +30,40 @@ public int GetTargetNumTerrorists()
         // Ensure at least one terrorist if the calculated number is zero
         return numTerrorists > 0 ? numTerrorists : 1;
     }
-    
+
     public int GetTargetNumCounterTerrorists()
     {
         return ActivePlayers.Count - GetTargetNumTerrorists();
     }
 
-    public void PlayerJoinedTeam(CCSPlayerController player, CsTeam fromTeam, CsTeam toTeam)
+    public HookResult PlayerJoinedTeam(CCSPlayerController player, CsTeam fromTeam, CsTeam toTeam)
     {
         Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] PlayerTriedToJoinTeam called.");
-        
+
         if (
-            fromTeam == CsTeam.None && toTeam == CsTeam.Spectator 
+            fromTeam == CsTeam.None && toTeam == CsTeam.Spectator
             || fromTeam == CsTeam.Spectator && toTeam == CsTeam.None
             || fromTeam == toTeam && toTeam == CsTeam.None
         )
         {
             // This is called when a player first joins.
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] {fromTeam.ToString()} -> {toTeam.ToString()}.");
-            return;
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}[{player.PlayerName}] {fromTeam.ToString()} -> {toTeam.ToString()}.");
+            return HookResult.Continue;
         }
-        
+
         Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Checking ActivePlayers.");
         if (ActivePlayers.Contains(player))
         {
             Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Player is an active player.");
-            
+
             if (toTeam == CsTeam.Spectator)
             {
                 Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Switching to spectator.");
                 RemovePlayerFromQueues(player);
-                return;
+                return HookResult.Continue;
             }
-            
+
             if (
                 _roundTerrorists.Count > 0
                 && _roundCounterTerrorists.Count > 0
@@ -80,13 +81,13 @@ public void PlayerJoinedTeam(CCSPlayerController player, CsTeam fromTeam, CsTeam
                 {
                     player.CommitSuicide(false, true);
                 }
-
+                
                 player.ChangeTeam(CsTeam.Spectator);
-                return;
+                return HookResult.Handled;
             }
-            
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Do nothing.");
-            return;
+
+            Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] The player tried joining the team they're already on, or, there were not enough players so we don't care. Do nothing.");
+            return HookResult.Handled;
         }
 
         Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Checking QueuePlayers.");
@@ -96,63 +97,58 @@ public void PlayerJoinedTeam(CCSPlayerController player, CsTeam fromTeam, CsTeam
             {
                 Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Not found, adding to ActivePlayers (because in warmup).");
                 ActivePlayers.Add(player);
-                return;
+                return HookResult.Continue;
             }
-            
+
             Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Not found, adding to QueuePlayers.");
             player.PrintToChat($"{RetakesPlugin.MessagePrefix}{_translator["queue.joined"]}");
             QueuePlayers.Add(player);
+            return HookResult.Handled;
         }
         else
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Found in QueuePlayers, do nothing.");
+            Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Already in Queue, do nothing.");
         }
 
-        if (toTeam != CsTeam.Spectator)
-        {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Changing to spectator.");
-            if (player.PawnIsAlive)
-            {
-                player.CommitSuicide(false, true);
-            }
-
-            player.ChangeTeam(CsTeam.Spectator);
-            return;
-        }
-        
         Helpers.CheckRoundDone();
+        return HookResult.Handled;
     }
 
     private void RemoveDisconnectedPlayers()
     {
-        var disconnectedActivePlayers = ActivePlayers.Where(player => !Helpers.IsValidPlayer(player) || !Helpers.IsPlayerConnected(player)).ToList();
+        var disconnectedActivePlayers = ActivePlayers
+            .Where(player => !Helpers.IsValidPlayer(player) || !Helpers.IsPlayerConnected(player)).ToList();
 
         if (disconnectedActivePlayers.Count > 0)
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}Removing {disconnectedActivePlayers.Count} disconnected players from ActivePlayers.");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}Removing {disconnectedActivePlayers.Count} disconnected players from ActivePlayers.");
             ActivePlayers.RemoveWhere(player => disconnectedActivePlayers.Contains(player));
         }
-        
-        var disconnectedQueuePlayers = QueuePlayers.Where(player => !Helpers.IsValidPlayer(player) || !Helpers.IsPlayerConnected(player)).ToList();
-        
+
+        var disconnectedQueuePlayers = QueuePlayers
+            .Where(player => !Helpers.IsValidPlayer(player) || !Helpers.IsPlayerConnected(player)).ToList();
+
         if (disconnectedQueuePlayers.Count > 0)
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}Removing {disconnectedQueuePlayers.Count} disconnected players from QueuePlayers.");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}Removing {disconnectedQueuePlayers.Count} disconnected players from QueuePlayers.");
             QueuePlayers.RemoveWhere(player => disconnectedQueuePlayers.Contains(player));
         }
     }
 
     private void HandleQueuePriority()
     {
-        var vipsInQueue = QueuePlayers.Where(player => AdminManager.PlayerHasPermissions(player, "@css/vip")).ToList().Count;
+        var vipsInQueue = QueuePlayers.Where(player => AdminManager.PlayerHasPermissions(player, "@css/vip")).ToList()
+            .Count;
 
         if (vipsInQueue > 0)
         {
             Helpers.Shuffle(
-                ActivePlayers
-                .Where(player => !AdminManager.PlayerHasPermissions(player, "@css/vip"))
-                .ToList()
-            )
+                    ActivePlayers
+                        .Where(player => !AdminManager.PlayerHasPermissions(player, "@css/vip"))
+                        .ToList()
+                )
                 .ForEach(player =>
                 {
                     if (vipsInQueue <= 0)
@@ -166,12 +162,12 @@ private void HandleQueuePriority()
                 });
         }
     }
-    
+
     public void Update()
     {
         RemoveDisconnectedPlayers();
         HandleQueuePriority();
-        
+
         var playersToAdd = _maxRetakesPlayers - ActivePlayers.Count;
 
         if (playersToAdd > 0 && QueuePlayers.Count > 0)
@@ -183,9 +179,9 @@ public void Update()
                 .OrderBy(player => AdminManager.PlayerHasPermissions(player, "@css/vip"))
                 .Take(playersToAdd)
                 .ToList();
-            
+
             QueuePlayers.RemoveWhere(playersToAddList.Contains);
-            
+
             // loop players to add, and set their team to CT
             foreach (var player in playersToAddList)
             {
@@ -194,9 +190,9 @@ public void Update()
                 {
                     continue;
                 }
-                
+
                 ActivePlayers.Add(player);
-                
+
                 if (player.Team != CsTeam.CounterTerrorist)
                 {
                     player.SwitchTeam(CsTeam.CounterTerrorist);
@@ -207,7 +203,7 @@ public void Update()
         if (ActivePlayers.Count == _maxRetakesPlayers && QueuePlayers.Count > 0)
         {
             var waitingMessage = _translator["queue.waiting", ActivePlayers.Count];
-            
+
             foreach (var player in QueuePlayers)
             {
                 player.PrintToChat($"{RetakesPlugin.MessagePrefix}{waitingMessage}");
@@ -221,61 +217,71 @@ public void RemovePlayerFromQueues(CCSPlayerController player)
         QueuePlayers.Remove(player);
         _roundTerrorists.Remove(player);
         _roundCounterTerrorists.Remove(player);
-        
+
         Helpers.CheckRoundDone();
     }
-    
+
     public void DebugQueues(bool isBefore)
     {
         if (!ActivePlayers.Any())
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}ActivePlayers ({(isBefore ? "BEFORE" : "AFTER")}): No active players.");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}ActivePlayers ({(isBefore ? "BEFORE" : "AFTER")}): No active players.");
         }
         else
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}ActivePlayers ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", ActivePlayers.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}ActivePlayers ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", ActivePlayers.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");
         }
 
         if (!QueuePlayers.Any())
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}QueuePlayers ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}QueuePlayers ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");
         }
         else
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}QueuePlayers ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", QueuePlayers.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}QueuePlayers ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", QueuePlayers.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");
         }
 
         if (!_roundTerrorists.Any())
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}_roundTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}_roundTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");
         }
         else
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}_roundTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", _roundTerrorists.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}_roundTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", _roundTerrorists.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");
         }
 
         if (!_roundCounterTerrorists.Any())
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}_roundCounterTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}_roundCounterTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");
         }
         else
         {
-            Console.WriteLine($"{RetakesPlugin.LogPrefix}_roundCounterTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", _roundCounterTerrorists.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");
+            Console.WriteLine(
+                $"{RetakesPlugin.LogPrefix}_roundCounterTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", _roundCounterTerrorists.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");
         }
     }
 
     private List<CCSPlayerController> _roundTerrorists = new();
     private List<CCSPlayerController> _roundCounterTerrorists = new();
-    
+
     public void ClearRoundTeams()
     {
         _roundTerrorists.Clear();
         _roundCounterTerrorists.Clear();
     }
-    
+
     public void SetRoundTeams()
     {
-        _roundTerrorists = Utilities.GetPlayers().Where(player => Helpers.IsValidPlayer(player) && player.Team == CsTeam.Terrorist).ToList();
-        _roundCounterTerrorists = Utilities.GetPlayers().Where(player => Helpers.IsValidPlayer(player) && player.Team == CsTeam.CounterTerrorist).ToList();
+        _roundTerrorists = Utilities.GetPlayers()
+            .Where(player => Helpers.IsValidPlayer(player) && player.Team == CsTeam.Terrorist).ToList();
+        _roundCounterTerrorists = Utilities.GetPlayers()
+            .Where(player => Helpers.IsValidPlayer(player) && player.Team == CsTeam.CounterTerrorist).ToList();
     }
-}
+}
diff --git a/RetakesPlugin.cs b/RetakesPlugin.cs
@@ -63,6 +63,8 @@ public override void Load(bool hotReload)
         Console.WriteLine($"{LogPrefix}Plugin loaded!");
         
         RegisterListener<Listeners.OnMapStart>(OnMapStart);
+        
+        AddCommandListener("jointeam", OnCommandJoinTeam);
 
         if (hotReload)
         {
@@ -629,28 +631,35 @@ public HookResult OnRoundEnd(EventRoundEnd @event, GameEventInfo info)
     [GameEventHandler(HookMode.Pre)]
     public HookResult OnPlayerTeam(EventPlayerTeam @event, GameEventInfo info)
     {
-        Console.WriteLine($"{LogPrefix}OnPlayerTeam event fired.");
-        
         // Ensure all team join events are silent.
         @event.Silent = true;
         
+        return HookResult.Continue;
+    }
+    
+    private HookResult OnCommandJoinTeam(CCSPlayerController? player, CommandInfo commandInfo)
+    {
         if (_gameManager == null)
         {
             Console.WriteLine($"{LogPrefix}Game manager not loaded.");
             return HookResult.Continue;
         }
         
-        var player = @event.Userid;
-
-        if (!Helpers.IsValidPlayer(player))
+        if (
+            !Helpers.IsValidPlayer(player)
+            || commandInfo.ArgCount < 2
+            || !Enum.TryParse<CsTeam>(commandInfo.GetArg(1), out var toTeam)
+        )
         {
-            return HookResult.Continue;
+            return HookResult.Handled;
         }
+
+        var fromTeam = player!.Team;
         
-        Console.WriteLine($"{LogPrefix}[{player.PlayerName}] {(CsTeam)@event.Oldteam} -> {(CsTeam)@event.Team}");
+        Console.WriteLine($"{LogPrefix}[{player.PlayerName}] {fromTeam} -> {toTeam}");
         
         _gameManager.QueueManager.DebugQueues(true);
-        _gameManager.QueueManager.PlayerJoinedTeam(player, (CsTeam)@event.Oldteam, (CsTeam)@event.Team);
+        var response = _gameManager.QueueManager.PlayerJoinedTeam(player, fromTeam, toTeam);
         _gameManager.QueueManager.DebugQueues(false);
         
         Console.WriteLine($"{LogPrefix}[{player.PlayerName}] checking to ensure we have active players");
@@ -667,8 +676,8 @@ public HookResult OnPlayerTeam(EventPlayerTeam @event, GameEventInfo info)
             
             Helpers.RestartGame();
         }
-
-        return HookResult.Continue;
+        
+        return response;
     }
     
     [GameEventHandler(HookMode.Pre)]

Original file line number	Diff line number	Diff line change
`@@ -30,39 +30,40 @@ public int GetTargetNumTerrorists()`
`30`	`30`	`// Ensure at least one terrorist if the calculated number is zero`
`31`	`31`	`return numTerrorists > 0 ? numTerrorists : 1;`
`32`	`32`	`}`
`33`		`-`
	`33`	`+`
`34`	`34`	`public int GetTargetNumCounterTerrorists()`
`35`	`35`	`{`
`36`	`36`	`return ActivePlayers.Count - GetTargetNumTerrorists();`
`37`	`37`	`}`
`38`	`38`
`39`		`- public void PlayerJoinedTeam(CCSPlayerController player, CsTeam fromTeam, CsTeam toTeam)`
	`39`	`+ public HookResult PlayerJoinedTeam(CCSPlayerController player, CsTeam fromTeam, CsTeam toTeam)`
`40`	`40`	`{`
`41`	`41`	`Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] PlayerTriedToJoinTeam called.");`
`42`		`-`
	`42`	`+`
`43`	`43`	`if (`
`44`		`- fromTeam == CsTeam.None && toTeam == CsTeam.Spectator`
	`44`	`+ fromTeam == CsTeam.None && toTeam == CsTeam.Spectator`
`45`	`45`	`\|\| fromTeam == CsTeam.Spectator && toTeam == CsTeam.None`
`46`	`46`	`\|\| fromTeam == toTeam && toTeam == CsTeam.None`
`47`	`47`	`)`
`48`	`48`	`{`
`49`	`49`	`// This is called when a player first joins.`
`50`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] {fromTeam.ToString()} -> {toTeam.ToString()}.");`
`51`		`- return;`
	`50`	`+ Console.WriteLine(`
	`51`	`+ $"{RetakesPlugin.LogPrefix}[{player.PlayerName}] {fromTeam.ToString()} -> {toTeam.ToString()}.");`
	`52`	`+ return HookResult.Continue;`
`52`	`53`	`}`
`53`		`-`
	`54`	`+`
`54`	`55`	`Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Checking ActivePlayers.");`
`55`	`56`	`if (ActivePlayers.Contains(player))`
`56`	`57`	`{`
`57`	`58`	`Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Player is an active player.");`
`58`		`-`
	`59`	`+`
`59`	`60`	`if (toTeam == CsTeam.Spectator)`
`60`	`61`	`{`
`61`	`62`	`Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Switching to spectator.");`
`62`	`63`	`RemovePlayerFromQueues(player);`
`63`		`- return;`
	`64`	`+ return HookResult.Continue;`
`64`	`65`	`}`
`65`		`-`
	`66`	`+`
`66`	`67`	`if (`
`67`	`68`	`_roundTerrorists.Count > 0`
`68`	`69`	`&& _roundCounterTerrorists.Count > 0`
`@@ -80,13 +81,13 @@ public void PlayerJoinedTeam(CCSPlayerController player, CsTeam fromTeam, CsTeam`
`80`	`81`	`{`
`81`	`82`	`player.CommitSuicide(false, true);`
`82`	`83`	`}`
`83`		`-`
	`84`	`+`
`84`	`85`	`player.ChangeTeam(CsTeam.Spectator);`
`85`		`- return;`
	`86`	`+ return HookResult.Handled;`
`86`	`87`	`}`
`87`		`-`
`88`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Do nothing.");`
`89`		`- return;`
	`88`	`+`
	`89`	`+ Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] The player tried joining the team they're already on, or, there were not enough players so we don't care. Do nothing.");`
	`90`	`+ return HookResult.Handled;`
`90`	`91`	`}`
`91`	`92`
`92`	`93`	`Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Checking QueuePlayers.");`
`@@ -96,63 +97,58 @@ public void PlayerJoinedTeam(CCSPlayerController player, CsTeam fromTeam, CsTeam`
`96`	`97`	`{`
`97`	`98`	`Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Not found, adding to ActivePlayers (because in warmup).");`
`98`	`99`	`ActivePlayers.Add(player);`
`99`		`- return;`
	`100`	`+ return HookResult.Continue;`
`100`	`101`	`}`
`101`		`-`
	`102`	`+`
`102`	`103`	`Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Not found, adding to QueuePlayers.");`
`103`	`104`	`player.PrintToChat($"{RetakesPlugin.MessagePrefix}{_translator["queue.joined"]}");`
`104`	`105`	`QueuePlayers.Add(player);`
	`106`	`+ return HookResult.Handled;`
`105`	`107`	`}`
`106`	`108`	`else`
`107`	`109`	`{`
`108`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Found in QueuePlayers, do nothing.");`
	`110`	`+ Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Already in Queue, do nothing.");`
`109`	`111`	`}`
`110`	`112`
`111`		`- if (toTeam != CsTeam.Spectator)`
`112`		`- {`
`113`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}[{player.PlayerName}] Changing to spectator.");`
`114`		`- if (player.PawnIsAlive)`
`115`		`- {`
`116`		`- player.CommitSuicide(false, true);`
`117`		`- }`
`118`		`-`
`119`		`- player.ChangeTeam(CsTeam.Spectator);`
`120`		`- return;`
`121`		`- }`
`122`		`-`
`123`	`113`	`Helpers.CheckRoundDone();`
	`114`	`+ return HookResult.Handled;`
`124`	`115`	`}`
`125`	`116`
`126`	`117`	`private void RemoveDisconnectedPlayers()`
`127`	`118`	`{`
`128`		`- var disconnectedActivePlayers = ActivePlayers.Where(player => !Helpers.IsValidPlayer(player) \|\| !Helpers.IsPlayerConnected(player)).ToList();`
	`119`	`+ var disconnectedActivePlayers = ActivePlayers`
	`120`	`+ .Where(player => !Helpers.IsValidPlayer(player) \|\| !Helpers.IsPlayerConnected(player)).ToList();`
`129`	`121`
`130`	`122`	`if (disconnectedActivePlayers.Count > 0)`
`131`	`123`	`{`
`132`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}Removing {disconnectedActivePlayers.Count} disconnected players from ActivePlayers.");`
	`124`	`+ Console.WriteLine(`
	`125`	`+ $"{RetakesPlugin.LogPrefix}Removing {disconnectedActivePlayers.Count} disconnected players from ActivePlayers.");`
`133`	`126`	`ActivePlayers.RemoveWhere(player => disconnectedActivePlayers.Contains(player));`
`134`	`127`	`}`
`135`		`-`
`136`		`- var disconnectedQueuePlayers = QueuePlayers.Where(player => !Helpers.IsValidPlayer(player) \|\| !Helpers.IsPlayerConnected(player)).ToList();`
`137`		`-`
	`128`	`+`
	`129`	`+ var disconnectedQueuePlayers = QueuePlayers`
	`130`	`+ .Where(player => !Helpers.IsValidPlayer(player) \|\| !Helpers.IsPlayerConnected(player)).ToList();`
	`131`	`+`
`138`	`132`	`if (disconnectedQueuePlayers.Count > 0)`
`139`	`133`	`{`
`140`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}Removing {disconnectedQueuePlayers.Count} disconnected players from QueuePlayers.");`
	`134`	`+ Console.WriteLine(`
	`135`	`+ $"{RetakesPlugin.LogPrefix}Removing {disconnectedQueuePlayers.Count} disconnected players from QueuePlayers.");`
`141`	`136`	`QueuePlayers.RemoveWhere(player => disconnectedQueuePlayers.Contains(player));`
`142`	`137`	`}`
`143`	`138`	`}`
`144`	`139`
`145`	`140`	`private void HandleQueuePriority()`
`146`	`141`	`{`
`147`		`- var vipsInQueue = QueuePlayers.Where(player => AdminManager.PlayerHasPermissions(player, "@css/vip")).ToList().Count;`
	`142`	`+ var vipsInQueue = QueuePlayers.Where(player => AdminManager.PlayerHasPermissions(player, "@css/vip")).ToList()`
	`143`	`+ .Count;`
`148`	`144`
`149`	`145`	`if (vipsInQueue > 0)`
`150`	`146`	`{`
`151`	`147`	`Helpers.Shuffle(`
`152`		`- ActivePlayers`
`153`		`- .Where(player => !AdminManager.PlayerHasPermissions(player, "@css/vip"))`
`154`		`- .ToList()`
`155`		`- )`
	`148`	`+ ActivePlayers`
	`149`	`+ .Where(player => !AdminManager.PlayerHasPermissions(player, "@css/vip"))`
	`150`	`+ .ToList()`
	`151`	`+ )`
`156`	`152`	`.ForEach(player =>`
`157`	`153`	`{`
`158`	`154`	`if (vipsInQueue <= 0)`
`@@ -166,12 +162,12 @@ private void HandleQueuePriority()`
`166`	`162`	`});`
`167`	`163`	`}`
`168`	`164`	`}`
`169`		`-`
	`165`	`+`
`170`	`166`	`public void Update()`
`171`	`167`	`{`
`172`	`168`	`RemoveDisconnectedPlayers();`
`173`	`169`	`HandleQueuePriority();`
`174`		`-`
	`170`	`+`
`175`	`171`	`var playersToAdd = _maxRetakesPlayers - ActivePlayers.Count;`
`176`	`172`
`177`	`173`	`if (playersToAdd > 0 && QueuePlayers.Count > 0)`
`@@ -183,9 +179,9 @@ public void Update()`
`183`	`179`	`.OrderBy(player => AdminManager.PlayerHasPermissions(player, "@css/vip"))`
`184`	`180`	`.Take(playersToAdd)`
`185`	`181`	`.ToList();`
`186`		`-`
	`182`	`+`
`187`	`183`	`QueuePlayers.RemoveWhere(playersToAddList.Contains);`
`188`		`-`
	`184`	`+`
`189`	`185`	`// loop players to add, and set their team to CT`
`190`	`186`	`foreach (var player in playersToAddList)`
`191`	`187`	`{`
`@@ -194,9 +190,9 @@ public void Update()`
`194`	`190`	`{`
`195`	`191`	`continue;`
`196`	`192`	`}`
`197`		`-`
	`193`	`+`
`198`	`194`	`ActivePlayers.Add(player);`
`199`		`-`
	`195`	`+`
`200`	`196`	`if (player.Team != CsTeam.CounterTerrorist)`
`201`	`197`	`{`
`202`	`198`	`player.SwitchTeam(CsTeam.CounterTerrorist);`
`@@ -207,7 +203,7 @@ public void Update()`
`207`	`203`	`if (ActivePlayers.Count == _maxRetakesPlayers && QueuePlayers.Count > 0)`
`208`	`204`	`{`
`209`	`205`	`var waitingMessage = _translator["queue.waiting", ActivePlayers.Count];`
`210`		`-`
	`206`	`+`
`211`	`207`	`foreach (var player in QueuePlayers)`
`212`	`208`	`{`
`213`	`209`	`player.PrintToChat($"{RetakesPlugin.MessagePrefix}{waitingMessage}");`
`@@ -221,61 +217,71 @@ public void RemovePlayerFromQueues(CCSPlayerController player)`
`221`	`217`	`QueuePlayers.Remove(player);`
`222`	`218`	`_roundTerrorists.Remove(player);`
`223`	`219`	`_roundCounterTerrorists.Remove(player);`
`224`		`-`
	`220`	`+`
`225`	`221`	`Helpers.CheckRoundDone();`
`226`	`222`	`}`
`227`		`-`
	`223`	`+`
`228`	`224`	`public void DebugQueues(bool isBefore)`
`229`	`225`	`{`
`230`	`226`	`if (!ActivePlayers.Any())`
`231`	`227`	`{`
`232`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}ActivePlayers ({(isBefore ? "BEFORE" : "AFTER")}): No active players.");`
	`228`	`+ Console.WriteLine(`
	`229`	`+ $"{RetakesPlugin.LogPrefix}ActivePlayers ({(isBefore ? "BEFORE" : "AFTER")}): No active players.");`
`233`	`230`	`}`
`234`	`231`	`else`
`235`	`232`	`{`
`236`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}ActivePlayers ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", ActivePlayers.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");`
	`233`	`+ Console.WriteLine(`
	`234`	`+ $"{RetakesPlugin.LogPrefix}ActivePlayers ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", ActivePlayers.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");`
`237`	`235`	`}`
`238`	`236`
`239`	`237`	`if (!QueuePlayers.Any())`
`240`	`238`	`{`
`241`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}QueuePlayers ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");`
	`239`	`+ Console.WriteLine(`
	`240`	`+ $"{RetakesPlugin.LogPrefix}QueuePlayers ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");`
`242`	`241`	`}`
`243`	`242`	`else`
`244`	`243`	`{`
`245`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}QueuePlayers ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", QueuePlayers.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");`
	`244`	`+ Console.WriteLine(`
	`245`	`+ $"{RetakesPlugin.LogPrefix}QueuePlayers ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", QueuePlayers.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");`
`246`	`246`	`}`
`247`	`247`
`248`	`248`	`if (!_roundTerrorists.Any())`
`249`	`249`	`{`
`250`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}_roundTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");`
	`250`	`+ Console.WriteLine(`
	`251`	`+ $"{RetakesPlugin.LogPrefix}_roundTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");`
`251`	`252`	`}`
`252`	`253`	`else`
`253`	`254`	`{`
`254`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}_roundTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", _roundTerrorists.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");`
	`255`	`+ Console.WriteLine(`
	`256`	`+ $"{RetakesPlugin.LogPrefix}_roundTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", _roundTerrorists.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");`
`255`	`257`	`}`
`256`	`258`
`257`	`259`	`if (!_roundCounterTerrorists.Any())`
`258`	`260`	`{`
`259`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}_roundCounterTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");`
	`261`	`+ Console.WriteLine(`
	`262`	`+ $"{RetakesPlugin.LogPrefix}_roundCounterTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): No players in the queue.");`
`260`	`263`	`}`
`261`	`264`	`else`
`262`	`265`	`{`
`263`		`- Console.WriteLine($"{RetakesPlugin.LogPrefix}_roundCounterTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", _roundCounterTerrorists.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");`
	`266`	`+ Console.WriteLine(`
	`267`	`+ $"{RetakesPlugin.LogPrefix}_roundCounterTerrorists ({(isBefore ? "BEFORE" : "AFTER")}): {string.Join(", ", _roundCounterTerrorists.Where(Helpers.IsValidPlayer).Select(player => player.PlayerName))}");`
`264`	`268`	`}`
`265`	`269`	`}`
`266`	`270`
`267`	`271`	`private List<CCSPlayerController> _roundTerrorists = new();`
`268`	`272`	`private List<CCSPlayerController> _roundCounterTerrorists = new();`
`269`		`-`
	`273`	`+`
`270`	`274`	`public void ClearRoundTeams()`
`271`	`275`	`{`
`272`	`276`	`_roundTerrorists.Clear();`
`273`	`277`	`_roundCounterTerrorists.Clear();`
`274`	`278`	`}`
`275`		`-`
	`279`	`+`
`276`	`280`	`public void SetRoundTeams()`
`277`	`281`	`{`
`278`		`- _roundTerrorists = Utilities.GetPlayers().Where(player => Helpers.IsValidPlayer(player) && player.Team == CsTeam.Terrorist).ToList();`
`279`		`- _roundCounterTerrorists = Utilities.GetPlayers().Where(player => Helpers.IsValidPlayer(player) && player.Team == CsTeam.CounterTerrorist).ToList();`
	`282`	`+ _roundTerrorists = Utilities.GetPlayers()`
	`283`	`+ .Where(player => Helpers.IsValidPlayer(player) && player.Team == CsTeam.Terrorist).ToList();`
	`284`	`+ _roundCounterTerrorists = Utilities.GetPlayers()`
	`285`	`+ .Where(player => Helpers.IsValidPlayer(player) && player.Team == CsTeam.CounterTerrorist).ToList();`
`280`	`286`	`}`
`281`		`-}`
	`287`	`+}`