feat: zombie request

.gitignore

@@ -1,3 +1,4 @@
 obj/
 bin/
-packages/*/
+packages/*/
+*.user

SillySCP/API/Features/VolunteerSystem.cs

@@ -20,38 +20,50 @@ public static class VolunteerSystem
 
         public static Dictionary<string, RoleTypeId> VaildScps { get; set; } = new ()
         {
-            { "173", RoleTypeId.Scp173 },
             { "peanut", RoleTypeId.Scp173 },
+            { "173", RoleTypeId.Scp173 },
+
+            { "dog", RoleTypeId.Scp173 },
             { "939", RoleTypeId.Scp939 },
+
+            { "computer", RoleTypeId.Scp079 },
+            { "pc", RoleTypeId.Scp079 },
             { "079", RoleTypeId.Scp079 },
             { "79", RoleTypeId.Scp079 },
-            { "computer", RoleTypeId.Scp079 },
-            { "106", RoleTypeId.Scp106 },
+
             { "larry", RoleTypeId.Scp106 },
+            { "106", RoleTypeId.Scp106 },
+
+            { "shyguy", RoleTypeId.Scp096 },
             { "096", RoleTypeId.Scp096 },
             { "96", RoleTypeId.Scp096 },
-            { "shyguy", RoleTypeId.Scp096 },
+
+            { "doctor", RoleTypeId.Scp049 },
             { "049", RoleTypeId.Scp049 },
             { "49", RoleTypeId.Scp049 },
-            { "doctor", RoleTypeId.Scp049 },
+
+            { "zombie", RoleTypeId.Scp0492 },
             { "0492", RoleTypeId.Scp0492 },
             { "049-2", RoleTypeId.Scp0492 },
             { "492", RoleTypeId.Scp0492 },
-            { "zombie", RoleTypeId.Scp0492 },
         };
 
-        public static void NewVolunteer(RoleTypeId role)
+            /// <summary>
+            /// if supplied with an original player the <see cref="SillySCP.Handlers.VolunteerHandler"/> will treat this as a replacement
+            /// </summary>
+        #nullable enable
+        public static void NewVolunteer(RoleTypeId role, Player? original=null)
         {
             Volunteers volunteer = new ()
             {
                 Replacement = role,
-                Players = new()
+                Players = new(),
+                OriginalPlayer = original,
             };
-            Volunteers ??= new();
             Volunteers.Add(volunteer);
             Timing.RunCoroutine(ChooseVolunteers(volunteer));
 
-            string annoucement =                                      // if we add support for other roles this ↓ will need to be changed
+            string announcement = // TODO if we add support for other roles this will need to be changed to use something else
                 $"{role.GetFullName()} has left the game\nPlease run .volunteer {role.GetFullName().Substring(4)} to volunteer to be the SCP";
 
             if (role == RoleTypeId.Scp0492)
@@ -60,14 +72,15 @@ public static void NewVolunteer(RoleTypeId role)
                 {
                     if (player.IsAlive) continue;
 
-                    player.Broadcast(10, annoucement);
+                    player.Broadcast(10, announcement);
                 }
                 return;
             }
-            Map.Broadcast(10, annoucement);
+            Map.Broadcast(10, announcement);
 
             VolunteerCreated.InvokeSafely(new (volunteer));
         }
+            #nullable disable
         public static IEnumerator<float> DisableVolunteers()
         {
             yield return Timing.WaitForSeconds(120);
@@ -86,9 +99,16 @@ public static IEnumerator<float> ChooseVolunteers(Volunteers volunteer)
             Volunteers volunteerClone = new ()
             {
                 Replacement = volunteer.Replacement,
-                Players = volunteer.Players
+                Players = volunteer.Players,
+                OriginalPlayer = volunteer.OriginalPlayer,
             };
             Volunteers.Remove(volunteer);
+
+            if (volunteerClone.OriginalPlayer != null)
+            {
+                if (volunteerClone.OriginalPlayer.IsDead) yield break; // you get inconsistent and weird behavior if they're dead (like teleporting into the void and then landing on top of chaos spawn over and over)
+            }
+
             if (volunteerClone.Players.Count == 0) yield break;
             Player replacementPlayer = volunteerClone.Players.GetRandomValue();
             replacementPlayer.Role.Set(volunteerClone.Replacement);

SillySCP/API/Features/Volunteers.cs

@@ -1,11 +1,13 @@
 using Exiled.API.Features;
+using JetBrains.Annotations;
 using PlayerRoles;
 
 namespace SillySCP.API.Features
 {
     public class Volunteers
     {
         public RoleTypeId Replacement;
+        [CanBeNull] public Player OriginalPlayer;
         public List<Player> Players;
     }
 }

SillySCP/Commands/Human.cs

@@ -13,7 +13,7 @@ public class Human : ICommand
     {
         public string Command { get; } = "human";
 
-        public string[] Aliases { get; } = new [] { "h" };
+        public string[] Aliases { get; } = { "h" };
 
         public string Description { get; } = "Change into a human, if you're an SCP.";
 
@@ -23,25 +23,30 @@ public bool Execute(
             out string response
         )
         {
+            if (!Player.TryGet(sender, out Player player))
+            {
+                response = "Only Players can use this command.";
+                return false;
+            }
+
+            if (player.Role == RoleTypeId.Scp0492)
+            {
+                response = "You cannot change into a human as SCP-049-2!, try .r or .requestVolunteer to request a spectator to take your place";
+                return false;
+            }
+
             if (!VolunteerSystem.ReadyVolunteers)
             {
                 response = "You can not change into a human after the volunteer period is over!";
                 return false;
             }
 
-            Player.TryGet(sender, out Player player);
 
             if (!player.IsScp)
             {
                 response = "Only SCPs can use this command!";
                 return false;
             }
-
-            if (player.Role.Type == RoleTypeId.Scp0492)
-            {
-                response = "You can not change into a human as SCP-049-2!";
-                return false;
-            }
 
             RoleTypeId role = HumanSpawner.NextHumanRoleToSpawn;
             VolunteerSystem.NewVolunteer(player.Role);

SillySCP/Commands/RequestHuman.cs

@@ -0,0 +1,47 @@
+using CommandSystem;
+using Exiled.API.Features;
+using PlayerRoles;
+using SillySCP.API.Features;
+
+
+namespace SillySCP.Commands
+{
+    [CommandHandler(typeof(ClientCommandHandler))]
+    public class RequestHuman : ICommand
+    {
+        public string Command { get; } = "RequestHuman";
+
+        public string[] Aliases { get; } = ["r","rh","request"];
+
+        public string Description { get; } = "request to change into a human, if you're an SCP."; // no clue what the description for this should actually be tbh
+
+        public bool Execute(
+            ArraySegment<string> arguments,
+            ICommandSender sender,
+            out string response
+        )
+        {
+            if (!Player.TryGet(sender, out Player player))
+            {
+                response = "Only Players can use this command.";
+                return false; 
+            }
+
+            if (!player.IsScp)
+            {
+                response = "Only SCP's can use this command.";
+                return false;
+            }
+
+            if (player.Role != RoleTypeId.Scp0492) // change if we allow other SCPs to request volunteer swap thingy (i should really figure out that terminology I hate how inconsistent i am)
+            {
+                response = "Only Zombies can use this command.";
+                return false;
+            }
+
+            response = "Opening a volunteer request."; // I really do not know what terminology should be used, always sounds so weird
+            VolunteerSystem.NewVolunteer(player.Role,original:player);
+            return true;
+        }
+    }
+}

SillySCP/Commands/Volunteer.cs

@@ -32,27 +32,29 @@ out string response
                 response = "Only players can use this command!";
                 return false;
             }
-
-            if (player.IsScp && player.Role != RoleTypeId.Scp0492) // zombies should beable to volunteer for regular scp's 
-            {
-                response = "You are already an SCP! If they get replaced, you can swap with the person if they wish!";
-                return false;
-            }
-
 
             if(arguments.Count != 1)
             {
                 response = "Usage: .volunteer <role>";
                 return false;
             }
 
+
+
             RoleTypeId role;
 
             if (!VolunteerSystem.VaildScps.TryGetValue(arguments.At(0), out role) && !Enum.TryParse(arguments.At(0), true, out role))
             {
                 response = "Error parsing the RoleTypeId.";
                 return false;
             }
+
+            if (player.IsScp && player.Role != RoleTypeId.Scp0492 && role is not RoleTypeId.Scp0492) // zombies should beable to volunteer for regular scp's 
+            {
+                response = "You are already an SCP! If they get replaced, you can swap with the person if they wish!";
+                return false;
+            }
+
             if (player.IsAlive && role == RoleTypeId.Scp0492)
             {
                 response = "Alive Players cannot volunteer as a zombie";
@@ -67,7 +69,7 @@ out string response
                 return false;
             }
 
-            volunteer.Players ??= new ();
+
 
             if (volunteer.Players.Contains(player))
             {

SillySCP/Handlers/VolunteerHandler.cs

@@ -3,6 +3,7 @@
 using Exiled.Events.EventArgs.Player;
 using MEC;
 using PlayerRoles;
+using SillySCP.API.EventArgs;
 using SillySCP.API.Features;
 using SillySCP.API.Interfaces;
 using SillySCP.API.Modules;
@@ -19,6 +20,7 @@ public void Init()
             Exiled.Events.Handlers.Player.ChangingRole += OnChangingRole;
 
             VolunteerSystem.VolunteerPeriodEnd += OnVolunteerPeriodEnd;
+            VolunteerSystem.VolunteerChosen += OnChosenVolunteer;
         }
 
         public void Unregister()
@@ -27,6 +29,7 @@ public void Unregister()
             Exiled.Events.Handlers.Server.RoundStarted -= OnRoundStarted;
             Exiled.Events.Handlers.Player.Died -= OnDead;
             Exiled.Events.Handlers.Player.ChangingRole -= OnChangingRole;
+            VolunteerSystem.VolunteerChosen -= OnChosenVolunteer;
         }
 
         private void OnChangingRole(ChangingRoleEventArgs ev)
@@ -38,6 +41,23 @@ private void OnChangingRole(ChangingRoleEventArgs ev)
             }
         }
 
+        private void OnChosenVolunteer(VolunteerChosenEventArgs ev)
+        {
+            if (ev.Volunteer.OriginalPlayer != null) // If a Volunteer specified a player, for sake of sanity and simplicity, its treated as a replacement
+            {
+                // lumi before you chop my balls off, I elected to handle canceling the volunteer entirely if the player is dead in the VolunteerSystem
+                Exiled.API.Features.Player originalPlayer = ev.Volunteer.OriginalPlayer;
+                ev.Player.MaxHealth = originalPlayer.MaxHealth;
+                ev.Player.Health = originalPlayer.Health;
+
+                ev.Player.Position = originalPlayer.Position;
+
+                ev.Player.MaxHumeShield = originalPlayer.MaxHumeShield;
+                ev.Player.HumeShield = originalPlayer.HumeShield;
+                originalPlayer.Role.Set(RoleTypeId.Spectator,SpawnReason.None);
+            }
+
+        }
 
         private void OnDead(DiedEventArgs ev)
         {
@@ -68,6 +88,7 @@ private void OnVolunteerPeriodEnd()
         {
             // only doing this to save some resources, don't come at me
             List<Exiled.API.Features.Player> scps = Exiled.API.Features.Player.List.Where(p => p.IsScp).ToList();
+            if (scps.Count == 0) return;
             List<string> scpNames = scps.Select(scp => scp.Role.Name).ToList();
             List<string> scpNamesCopy = new(scpNames);
             scpNamesCopy.RemoveAt(scpNamesCopy.Count-1);