Merge pull request #2 from UncomplicatedCustomServer/Pre-UCT

Pre-UCT -> Main

Author: PiwnicaUwU

UncomplicatedCustomTeams/API/Enums/RolePriority.cs

@@ -0,0 +1,17 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace UncomplicatedCustomTeams.API.Enums
+{
+    public enum RolePriority
+    {
+        First,
+        Second,
+        Third,
+        Fourth,
+        Fifth
+    }
+}

UncomplicatedCustomTeams/API/Features/CustomRole.cs

@@ -1,4 +1,5 @@
 using System.ComponentModel;
+using UncomplicatedCustomTeams.API.Enums;
 
 namespace UncomplicatedCustomTeams.API.Features
 {
@@ -9,5 +10,12 @@ public class CustomRole : UncomplicatedCustomRoles.API.Features.CustomRole
         /// </summary>
         [Description("The maximum number of players that can have this role in this wave")]
         public int MaxPlayers { get; set; }
+
+        /// <summary>
+        /// The priority of assigning this role in the wave (First -> Fourth).
+        /// The lower the value, the higher the priority.
+        /// </summary>
+        [Description("Priority of assigning custom role in Team (First -> Fourth). The lower the value, the higher the priority.")]
+        public RolePriority Priority { get; set; } = RolePriority.First;
     }
 }

UncomplicatedCustomTeams/API/Features/SummonedCustomRole.cs

@@ -40,17 +40,45 @@ public void Destroy()
         }
 
 #pragma warning disable CS0618 // A class member was marked with the Obsolete attribute -> the [Obsolete()] attribute is only there to avoid users to use this in a wrong way!
-        public void AddRole(RoleTypeId proposed)
+        public void AddRole(RoleTypeId? proposed = null)
         {
-            LogManager.Debug($"Changing role to player {Player.Nickname} ({Player.Id}) to {CustomRole.Name} ({CustomRole.Id}) from team {Team.Team.Name}");
+            RoleTypeId finalRole = proposed ?? RoleTypeId.ChaosConscript;
+            LogManager.Debug($"Changing role to {finalRole} for player {Player.Nickname} ({Player.Id})");
 
             Player.Role.Set(CustomRole.Role, Exiled.API.Enums.SpawnReason.Respawn, RoleSpawnFlags.None);
 
-            if (Team.Team.SpawnPosition == Vector3.zero || Team.Team.SpawnPosition == Vector3.one)
-                Player.Position = proposed.GetRandomSpawnLocation().Position;
+            if (Player.Role != CustomRole.Role)
+            {
+                LogManager.Debug($"Role assignment failed! Falling back to {finalRole}.");
+                Player.Role.Set(finalRole, Exiled.API.Enums.SpawnReason.ForceClass, RoleSpawnFlags.AssignInventory);
+            }
+            Vector3 spawnPos;
+            if (Team.Team.SpawnConditions.SpawnPosition != Vector3.zero)
+            {
+                spawnPos = Team.Team.SpawnConditions.SpawnPosition;
+                LogManager.Debug($"Using custom Vector3 spawn position: {spawnPos}");
+            }
             else
-                Player.Position = Team.Team.SpawnPosition;
+            {
+                switch (Team.Team.SpawnConditions.SpawnWave)
+                {
+                    case "NtfWave":
+                        spawnPos = RoleTypeId.NtfCaptain.GetRandomSpawnLocation().Position;
+                        LogManager.Debug($"Using NTF spawn position for role: {CustomRole.Role}");
+                        break;
 
+                    case "ChaosWave":
+                        spawnPos = RoleTypeId.ChaosConscript.GetRandomSpawnLocation().Position;
+                        LogManager.Debug($"Using Chaos spawn position for role: {CustomRole.Role}");
+                        break;
+
+                    default:
+                        spawnPos = finalRole.GetRandomSpawnLocation().Position;
+                        LogManager.Debug($"Using fallback spawn for role: {CustomRole.Role}");
+                        break;
+                }
+            }
+            Player.Position = spawnPos;
             Player.SetCustomRoleAttributes(CustomRole);
             IsRoleSet = true;
         }

UncomplicatedCustomTeams/API/Features/SummonedTeam.cs

@@ -1,8 +1,11 @@
-using Exiled.API.Features;
+using Exiled.API.Enums;
+using Exiled.API.Features;
 using PlayerRoles;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using UncomplicatedCustomTeams.Utilities;
+using Utils.NonAllocLINQ;
 
 namespace UncomplicatedCustomTeams.API.Features
 {
@@ -21,6 +24,9 @@ public class SummonedTeam
 
         public long Time { get; }
 
+        /// <summary>
+        /// Creates a new summoned team and adds it to the list.
+        /// </summary>
         public SummonedTeam(Team team)
         {
             Team = team;
@@ -30,6 +36,9 @@ public SummonedTeam(Team team)
             List.Add(this);
         }
 
+        /// <summary>
+        /// Spawns all players assigned to this team.
+        /// </summary>
         public void SpawnAll()
         {
             foreach (SummonedCustomRole Role in Players)
@@ -42,77 +51,171 @@ public void SpawnAll()
 
                 RoleTypeId SpawnType = RoleTypeId.ChaosConscript;
 
-                if (Team.SpawnWave  == Exiled.API.Enums.SpawnableFaction.NtfWave)
+                if (Team.SpawnConditions?.SpawnWave == "NtfWave")
                     SpawnType = RoleTypeId.NtfPrivate;
 
                 Role.AddRole(SpawnType);
             }
         }
 
+        /// <summary>
+        /// Checks if any players assigned to this team are still alive.
+        /// </summary>
         public void CheckPlayers()
         {
             foreach (SummonedCustomRole Role in Players)
                 if (Role.Player.IsAlive)
                     Players.Remove(Role);
         }
 
+        /// <summary>
+        /// Checks if the given team is a custom team.
+        /// </summary>
+        public static bool IsCustomTeam(PlayerRoles.Team team)
+        {
+            return Team.List.Any(t => t.Name == team.ToString());
+        }
+
+        /// <summary>
+        /// Checks if the round should end based on the alive teams and winning conditions.
+        /// </summary>
+        public static void CheckRoundEndCondition()
+        {
+            var aliveTeams = Player.List.Where(p => p.IsAlive)
+                .Select(p => p.Role.Team)
+                .Where(t => !IsCustomTeam(t))
+                .Distinct()
+                .ToList();
+
+            var winningTeams = Team.GetWinningTeams();
+            bool hasWinningTeamAlive = aliveTeams.Any(team => winningTeams.Contains(team));
+            bool onlyWinningTeamsRemain = aliveTeams.All(team => winningTeams.Contains(team));
+            bool hasAliveCustomTeam = SummonedTeam.List.Any(team => team.HasAlivePlayers());
+
+            if (hasWinningTeamAlive && onlyWinningTeamsRemain && hasAliveCustomTeam)
+            {
+                if (!Round.IsLocked)
+                {
+                    Round.EndRound();
+                }
+            }
+        }
+
+        /// <summary>
+        /// Checks if this summoned team has any alive players.
+        /// </summary>
+        public bool HasAlivePlayers()
+        {
+            return Players.Any(role => role.Player.IsAlive);
+        }
+
+        /// <summary>
+        /// Destroys this summoned team and removes it from the list.
+        /// </summary>
         public void Destroy()
         {
             foreach (SummonedCustomRole role in Players) { role.Destroy(); }
             Players.Clear();
             List.Remove(this);
         }
 
+        /// <summary>
+        /// Clamps a value between the given minimum and maximum.
+        /// </summary>
         public static float Clamp(float value, float min, float max)
         {
             return (value < min) ? min : (value > max) ? max : value;
         }
 
+        public void ForceSpawnPlayer(Player player, RoleTypeId fallbackRole = RoleTypeId.ClassD)
+        {
+            LogManager.Debug($"Force spawning player {player.Nickname} for team {Team.Name}...");
+
+            SummonedCustomRole summonedRole = SummonedPlayersGet(player);
+
+            if (summonedRole != null)
+            {
+                LogManager.Debug($"Found custom role for {player.Nickname}: {summonedRole.CustomRole.Name}");
+                summonedRole.AddRole();
+            }
+            else
+            {
+                LogManager.Debug($"No assigned custom role found for {player.Nickname}, using fallback role: {fallbackRole}");
+                player.Role.Set(fallbackRole, SpawnReason.ForceClass, RoleSpawnFlags.AssignInventory);
+            }
+        }
+
+        /// <summary>
+        /// Summons a new team and assigns players to available roles.
+        /// </summary>
         public static SummonedTeam Summon(Team team, IEnumerable<Player> players)
         {
+            if (team == null)
+            {
+                return null;
+            }
             SummonedTeam SummonedTeam = new(team);
 
             foreach (Player Player in players)
             {
-                foreach (CustomRole Role in team.Roles)
+                foreach (CustomRole role in team.Roles.OrderBy(r => r.Priority))
                 {
-                    if (SummonedTeam.SummonedPlayersCount(Role) < Role.MaxPlayers)
+                    if (SummonedTeam.SummonedPlayersCount(role) < role.MaxPlayers)
                     {
-                        SummonedTeam.Players.Add(new(SummonedTeam, Player, Role));
+                        SummonedTeam.Players.Add(new(SummonedTeam, Player, role));
+                        LogManager.Debug($"{Player.Nickname} -> {role.Name} (Priority: {role.Priority})");
                         break;
                     }
                 }
             }
             if (!string.IsNullOrEmpty(team.CassieTranslation))
             {
-                Cassie.Message(team.CassieTranslation, isSubtitles: true, isNoisy: team.IsNoisy, isHeld: false);
+                Cassie.MessageTranslated(team.CassieMessage, team.CassieTranslation, isNoisy: team.IsNoisy, isSubtitles: true);
             }
-            else if (!string.IsNullOrEmpty(team.CassieMessage))
-            {
-                Cassie.Message(team.CassieMessage, isSubtitles: true, isNoisy: team.IsNoisy, isHeld: false);
-            }
-
-            
             if (!string.IsNullOrEmpty(team.SoundPath))
             {
                 AudioPlayer audioPlayer = AudioPlayer.CreateOrGet($"Global_Audio_{team.Id}", onIntialCreation: (p) =>
                 {
                     Speaker speaker = p.AddSpeaker("Main", isSpatial: false, maxDistance: 5000f);
                 });
-
                 float volume = Clamp(team.SoundVolume, 1f, 100f);
-
                 audioPlayer.AddClip($"sound_{team.Id}", volume);
             }
-
             return SummonedTeam;
         }
 
+        /// <summary>
+        /// Checks if a team can spawn based on the number of spectators.
+        /// </summary>
+        public static List<Player> CanSpawnTeam(Team team)
+        {
+            if (team == null)
+                return new List<Player>();
+
+            List<Player> allPlayers = Player.List.ToList();
+            int totalPlayers = allPlayers.Count;
+            LogManager.Debug($"Total players: {totalPlayers}, MinPlayers required: {team.MinPlayers}");
+            if (totalPlayers < team.MinPlayers)
+            {
+                LogManager.Debug($"Not enough players on the server to spawn team {team.Name}.");
+                return new List<Player>();
+            }
+            List<Player> spectators = allPlayers
+                .Where(p => !p.IsAlive && p.Role.Type == RoleTypeId.Spectator && !p.IsOverwatchEnabled)
+                .ToList();
+            LogManager.Debug($"Spectators available: {spectators.Count}");
+            LogManager.Debug($"Spawning all {spectators.Count} spectators for team {team.Name}.");
+            return spectators;
+        }
+
+        /// <summary>
+        /// Refreshes the players list, ensuring that the maximum allowed players per role is respected.
+        /// </summary>
         public void RefreshPlayers(IEnumerable<Player> players)
         {
             foreach (Player Player in players)
             {
-                foreach (CustomRole Role in Team.Roles)
+                foreach (CustomRole Role in Team.Roles.OrderBy(r => r.Priority))
                 {
                     if (SummonedPlayersCount(Role) < Role.MaxPlayers)
                     {
@@ -123,25 +226,46 @@ public void RefreshPlayers(IEnumerable<Player> players)
             }
         }
 
+        /// <summary>
+        /// Counts the number of players assigned to a specific custom role.
+        /// </summary>
         public int SummonedPlayersCount(CustomRole role)
         {
             return Players.Where(cr => cr.CustomRole == role).Count();
         }
 
+        /// <summary>
+        /// Gets the list of summoned players for a specific custom role.
+        /// </summary>
         public IEnumerable<SummonedCustomRole> SummonedPlayersGet(CustomRole role) => Players.Where(cr => cr.CustomRole == role);
 
+        /// <summary>
+        /// Gets the summoned player role for a specific player.
+        /// </summary>
         public SummonedCustomRole SummonedPlayersGet(Player player) => Players.Where(cr => cr.Player.Id == player.Id).FirstOrDefault();
 
+        /// <summary>
+        /// Tries to get a summoned player role for a specific player.
+        /// </summary>
         public bool SummonedPlayersTryGet(Player player, out SummonedCustomRole role)
         {
             role = SummonedPlayersGet(player);
             return role != null;
         }
 
+        /// <summary>
+        /// Attempts to spawn a player with the given role.
+        /// </summary>
         public void TrySpawnPlayer(Player player, RoleTypeId role) => SummonedPlayersGet(player)?.AddRole(role);
 
+        /// <summary>
+        /// Finds a summoned team by its ID.
+        /// </summary>
         public static SummonedTeam Get(string Id) => List.Where(st => st.Id == Id).FirstOrDefault();
 
+        /// <summary>
+        /// Tries to find a summoned team by its ID.
+        /// </summary>
         public static bool TryGet(string Id, out SummonedTeam team)
         {
             team = Get(Id);