More methods for CustomTeams, added CustomTeams wave timers

marchellcx · marchellcx · commit f7e9cb2873c7 · 2025-07-20T13:29:34.000+02:00
diff --git a/LabExtended/API/CustomTeams/CustomTeamHandler.cs b/LabExtended/API/CustomTeams/CustomTeamHandler.cs
@@ -67,13 +67,15 @@ public override void OnUnregistered()
         WaveTimer?.Dispose();
     }
 
-    internal override void Internal_RemoveInstance(int id)
+    /// <summary>
+    /// Despawns all active instances.
+    /// </summary>
+    /// <param name="playerRole">The role to set alive players to.</param>
+    public override void DespawnAll(RoleTypeId playerRole = RoleTypeId.Spectator)
     {
-        if (Instances.TryGetValue(id, out var instance))
+        while (Instances.Count > 0)
         {
-            Instances.Remove(id);
-            
-            OnDespawned(instance);
+            Despawn(Instances.First().Value, playerRole);
         }
     }
 
@@ -102,6 +104,20 @@ public void Despawn(TInstance instance, RoleTypeId playerRole = RoleTypeId.Spect
             player.Role.Set(playerRole);
         }
 
+        for (var i = 0; i < instance.OriginalPlayers.Count; i++)
+        {
+            var player = instance.OriginalPlayers[i];
+
+            if (player?.ReferenceHub != null)
+            {
+                if (!string.IsNullOrWhiteSpace(Name))
+                {
+                    player.CustomInfo = string.Empty;
+                    player.InfoArea &= ~PlayerInfoArea.CustomInfo;
+                }
+            }
+        }
+
         instance.AlivePlayers.Clear();
         instance.OriginalPlayers.Clear();
 
@@ -117,11 +133,12 @@ public void Despawn(TInstance instance, RoleTypeId playerRole = RoleTypeId.Spect
     /// </summary>
     /// <param name="maxPlayerCount">The maximum amount of players to spawn.</param>
     /// <param name="throwIfNotEnoughPlayers">Whether or not to throw an exception if there aren't enough players to match <paramref name="maxPlayerCount"/></param>
-    /// <param name="additionalChecks">Delegate used to check potential players, called after <see cref="IsSpawnable"/>.</param>
+    /// <param name="assignInventory">Whether or not to assign inventory to players with game roles, has no effect on players with custom roles.</param>
+    /// <param name="additionalChecks">Delegate used to check potential players, called after <see cref="CustomTeamHandlerBase.IsSpawnable"/>.</param>
     /// <returns>The spawned team instance (if spawned, null if there weren't enough players).</returns>
     /// <exception cref="ArgumentOutOfRangeException"></exception>
     /// <exception cref="Exception"></exception>
-    public TInstance? Spawn(int maxPlayerCount, bool throwIfNotEnoughPlayers = false, Predicate<ExPlayer>? additionalChecks = null)
+    public TInstance? Spawn(int maxPlayerCount, bool throwIfNotEnoughPlayers = false, bool assignInventory = true, Predicate<ExPlayer>? additionalChecks = null)
     {
         if (maxPlayerCount < 1)
             throw new ArgumentOutOfRangeException(nameof(maxPlayerCount));
@@ -153,7 +170,7 @@ public void Despawn(TInstance instance, RoleTypeId playerRole = RoleTypeId.Spect
             return null;
         }
 
-        var instance = Spawn(spawnablePlayers);
+        var instance = Spawn(spawnablePlayers, assignInventory);
         
         ListPool<ExPlayer>.Shared.Return(spawnablePlayers);
         return instance;
@@ -163,8 +180,9 @@ public void Despawn(TInstance instance, RoleTypeId playerRole = RoleTypeId.Spect
     /// Spawns a new team instance.
     /// </summary>
     /// <param name="players">The list of players to spawn.</param>
+    /// <param name="assignInventory">Whether or not to assign inventory to players with game roles, has no effect on players with custom roles.</param>
     /// <returns>The spawned team instance (if spawned, null if there weren't enough players).</returns>
-    public TInstance? Spawn(IList<ExPlayer> players)
+    public TInstance? Spawn(IList<ExPlayer> players, bool assignInventory = true)
     {
         if (players is null)
             throw new ArgumentNullException(nameof(players));
@@ -199,8 +217,12 @@ public void Despawn(TInstance instance, RoleTypeId playerRole = RoleTypeId.Spect
             if (pair.Value is RoleTypeId roleType)
             {
                 pair.Key.Role.Set(roleType, RoleChangeReason.Respawn, spawnPosition.HasValue 
-                                                        ? RoleSpawnFlags.AssignInventory
-                                                        : RoleSpawnFlags.All);
+                                                        ? (assignInventory 
+                                                            ? RoleSpawnFlags.AssignInventory
+                                                            : RoleSpawnFlags.None)
+                                                        : (assignInventory 
+                                                            ? RoleSpawnFlags.AssignInventory
+                                                            : RoleSpawnFlags.UseSpawnpoint));
             }
             else if (pair.Value is CustomRoleData customRoleData)
             {
@@ -212,7 +234,7 @@ public void Despawn(TInstance instance, RoleTypeId playerRole = RoleTypeId.Spect
 
             if (!string.IsNullOrWhiteSpace(Name))
             {
-                pair.Key.CustomInfo = Name;
+                pair.Key.CustomInfo = Name!;
 
                 if ((pair.Key.InfoArea & PlayerInfoArea.CustomInfo) != PlayerInfoArea.CustomInfo)
                     pair.Key.InfoArea |= PlayerInfoArea.CustomInfo;
@@ -233,4 +255,35 @@ public void Despawn(TInstance instance, RoleTypeId playerRole = RoleTypeId.Spect
         teamInstance.OnSpawned();
         return teamInstance;
     }
+    
+    internal override void Internal_RemoveInstance(int id)
+    {
+        if (Instances.TryGetValue(id, out var instance))
+        {
+            Instances.Remove(id);
+            
+            OnDespawned(instance);
+        }
+    }
+
+    internal override bool Internal_DespawnInstance(int id)
+    {
+        if (Instances.TryGetValue(id, out var instance))
+        {
+            Despawn(instance);
+            return true;
+        }
+
+        return false;
+    }
+
+    internal override IEnumerable<CustomTeamInstance> Internal_GetInstances()
+    {
+        return Instances.Values;
+    }
+
+    internal override CustomTeamInstance Internal_SpawnInstance(int playerCount)
+    {
+        return Spawn(playerCount)!;
+    }
 }
diff --git a/LabExtended/API/CustomTeams/CustomTeamInstance.cs b/LabExtended/API/CustomTeams/CustomTeamInstance.cs
@@ -42,7 +42,7 @@ public abstract class CustomTeamInstance
     /// <summary>
     /// Gets the amounts of seconds passed since the team spawned.
     /// </summary>
-    public float PassedTime => UnityEngine.Time.realtimeSinceStartup - SpawnTime;
+    public float PassedTime => Time.realtimeSinceStartup - SpawnTime;
     
     /// <summary>
     /// Whether or not this wave was spawned by the timer.
diff --git a/LabExtended/API/CustomTeams/Internal/CustomTeamHandlerBase.cs b/LabExtended/API/CustomTeams/Internal/CustomTeamHandlerBase.cs
@@ -61,8 +61,21 @@ public virtual void OnUnregistered() { }
     /// <param name="target">The player being attacked.</param>
     /// <returns>true if the friendly fire should be allowed</returns>
     public virtual bool CanDamage(ExPlayer attacker, ExPlayer target) => true;
+
+    /// <summary>
+    /// Despawns all active instances.
+    /// </summary>
+    /// <param name="playerRole">The role to set alive players to.</param>
+    public abstract void DespawnAll(RoleTypeId playerRole = RoleTypeId.Spectator);
+    
+    // I realize that this way of doings things may be a bit stupid, but it works.
     
     internal abstract void Internal_RemoveInstance(int id);
+    internal abstract bool Internal_DespawnInstance(int id);
+
+    internal abstract IEnumerable<CustomTeamInstance> Internal_GetInstances();
+
+    internal abstract CustomTeamInstance Internal_SpawnInstance(int playerCount);
 
     private static void Internal_OnLeft(ExPlayer player)
     {
diff --git a/LabExtended/Commands/Custom/CustomTeams/CustomTeamsCommand.cs b/LabExtended/Commands/Custom/CustomTeams/CustomTeamsCommand.cs
@@ -0,0 +1,166 @@
+using LabExtended.API.CustomTeams;
+using LabExtended.API.CustomTeams.Internal;
+
+using LabExtended.Commands.Attributes;
+using LabExtended.Commands.Interfaces;
+
+using LabExtended.Extensions;
+
+using UnityEngine;
+
+namespace LabExtended.Commands.Custom.CustomTeams;
+
+[Command("customteam", "Manages the CustomTeams API", "ct")]
+public class CustomTeamsCommand : CommandBase, IServerSideCommand
+{
+    [CommandOverload("list", "Lists all custom teams.")]
+    public void List()
+    {
+        if (CustomTeamRegistry.RegisteredHandlers.Count == 0)
+        {
+            Fail("No CustomTeams registered.");
+            return;
+        }
+        
+        Ok(x =>
+        {
+            foreach (var pair in CustomTeamRegistry.RegisteredHandlers)
+            {
+                x.AppendLine($"- {pair.Key}: {pair.Value.Name ?? "(null)"}");
+            }
+        });
+    }
+
+    [CommandOverload("waves", "Lists all spawned waves of a team.")]
+    public void Waves(
+        [CommandParameter("Name", "Name of the team.")] string name)
+    {
+        if (!CustomTeamRegistry.TryGet(name, out CustomTeamHandlerBase handler))
+        {
+            Fail($"Could not find custom team '{name}'");
+            return;
+        }
+
+        var instances = handler.Internal_GetInstances();
+
+        if (instances.Count() == 0)
+        {
+            Fail($"Team '{handler.GetType().Name}' has no active waves.");
+            return;
+        }
+        
+        Ok(x =>
+        {
+            foreach (var instance in instances)
+            {
+                x.AppendLine($"- {instance.Id}: Remaining players: {instance.AlivePlayers.Count} (spawned {Mathf.CeilToInt(instance.PassedTime)} seconds ago)");
+            }
+        });
+    }
+
+    [CommandOverload("wave", "Shows information about an active wave.")]
+    public void Wave(
+        [CommandParameter("Name", "Name of the team.")] string name,
+        [CommandParameter("ID", "ID of the wave.")] int id)
+    {
+        if (!CustomTeamRegistry.TryGet(name, out CustomTeamHandlerBase handler))
+        {
+            Fail($"Could not find custom team '{name}'");
+            return;
+        }
+
+        var instances = handler.Internal_GetInstances();
+
+        if (instances.Count() == 0)
+        {
+            Fail($"Team '{handler.GetType().Name}' has no active waves.");
+            return;
+        }
+
+        if (!instances.TryGetFirst(x => x.Id == id, out var instance))
+        {
+            Fail($"Could not find active wave '{id}' in team '{handler.GetType().Name}'");
+            return;
+        }
+        
+        Ok(x =>
+        {
+            x.AppendLine($"ID: {instance.Id}");
+            x.AppendLine($"Spawned At: {DateTime.Now.ToLocalTime().Subtract(TimeSpan.FromSeconds(instance.PassedTime)).ToString("HH:mm:ss zz")}");
+            x.AppendLine($"Active For: {Mathf.CeilToInt(instance.PassedTime)} seconds");
+            x.AppendLine($"Is By Timer: {instance.IsByTimer}");
+            
+            x.AppendLine($"Alive Players ({instance.AlivePlayers.Count}):");
+
+            foreach (var ply in instance.AlivePlayers)
+            {
+                if (ply?.ReferenceHub != null)
+                {
+                    x.AppendLine($" - [{ply.Role.Name}] |{ply.PlayerId}| {ply.Nickname} ({ply.UserId})");
+                }
+            }
+
+            x.AppendLine($"Original Players ({instance.OriginalPlayers.Count}):");
+            
+            foreach (var ply in instance.OriginalPlayers)
+            {
+                if (ply?.ReferenceHub != null)
+                {
+                    x.AppendLine($" - [{ply.Role.Name}] |{ply.PlayerId}| {ply.Nickname} ({ply.UserId})");
+                }
+            }
+        });
+    }
+
+    [CommandOverload("spawn", "Spawns a new wave of a custom team.")]
+    public void Spawn(
+        [CommandParameter("Name", "Name of the team to spawn.")] string name,
+        [CommandParameter("Players", "The maximum amount of players to spawn.")] int players)
+    {
+        if (!CustomTeamRegistry.TryGet(name, out CustomTeamHandlerBase handler))
+        {
+            Fail($"Could not find custom team '{name}'");
+            return;
+        }
+
+        var instance = handler.Internal_SpawnInstance(players);
+
+        if (instance is null)
+        {
+            Fail($"Could not spawn a new wave.");
+            return;
+        }
+        
+        Ok($"Spawned a new wave of '{handler.GetType().Name}' with '{instance.AlivePlayers.Count}' player(s) (ID: {instance.Id})");
+    }
+
+    [CommandOverload("despawn", "Despawns an active wave of a custom team.")]
+    public void Despawn(
+        [CommandParameter("Name", "Name of the team to despawn.")] string name,
+        [CommandParameter("ID", "ID of the instance to despawn (or * for all).")] string id)
+    {
+        if (!CustomTeamRegistry.TryGet(name, out CustomTeamHandlerBase handler))
+        {
+            Fail($"Could not find custom team '{name}'");
+            return;
+        }
+
+        if (int.TryParse(id, out var instanceId))
+        {
+            if (!handler.Internal_DespawnInstance(instanceId))
+            {
+                Fail($"Could not despawn team instance '{instanceId}' of team '{handler.GetType().Name}'");
+            }
+            else
+            {
+                Ok($"Despawned team instance '{instanceId}' of team '{handler.GetType().Name}'");
+            }
+        }
+        else
+        {
+            handler.DespawnAll();
+            
+            Ok($"Despawned all active team instances of '{handler.GetType().Name}'");
+        }
+    }
+}
