diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..516f5da
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,4 @@
+[*.cs]
+
+# Default severity for all analyzer diagnostics
+dotnet_analyzer_diagnostic.severity = none
diff --git a/AdminTools.sln b/AdminTools.sln
index 794e1ee..423f08b 100644
--- a/AdminTools.sln
+++ b/AdminTools.sln
@@ -1,5 +1,8 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 17
+VisualStudioVersion = 17.8.34408.163
+MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AdminTools", "AdminTools\AdminTools.csproj", "{560DA2C9-E7A1-42C5-BBD4-5B3C28591593}"
 EndProject
 Global
@@ -13,4 +16,7 @@ Global
 		{560DA2C9-E7A1-42C5-BBD4-5B3C28591593}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{560DA2C9-E7A1-42C5-BBD4-5B3C28591593}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
 EndGlobal
diff --git a/AdminTools/AdminTools.csproj b/AdminTools/AdminTools.csproj
index 879be73..714eb18 100644
--- a/AdminTools/AdminTools.csproj
+++ b/AdminTools/AdminTools.csproj
@@ -59,67 +59,69 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Commands\AdminBroadcast\AdminBroadcast.cs" />
-    <Compile Include="Commands\Ahp\Ahp.cs" />
-    <Compile Include="Commands\Ball\Ball.cs" />
-    <Compile Include="Commands\BreakDoors\BreakDoors.cs" />
-    <Compile Include="Commands\Configuration\Configuration.cs" />
-    <Compile Include="Commands\Configuration\Reload.cs" />
-    <Compile Include="Commands\DropItem\DropItem.cs" />
-    <Compile Include="Commands\DropSize\DropSize.cs" />
-    <Compile Include="Commands\Enums\Enums.cs" />
-    <Compile Include="Commands\Explode\Explode.cs" />
-    <Compile Include="Commands\FakeSync\FakeSpawnCommand.cs" />
-    <Compile Include="Commands\Ghost\Ghost.cs" />
-    <Compile Include="Commands\Grenade\Grenade.cs" />
+    <Compile Include="Commands\Ahp.cs" />
+    <Compile Include="Commands\Ball.cs" />
+    <Compile Include="Commands\BreakDoor\BreakDoors.cs" />
+    <Compile Include="Commands\DropItem.cs" />
+    <Compile Include="Commands\DropSize.cs" />
+    <Compile Include="Commands\Enums.cs" />
+    <Compile Include="Commands\Explode.cs" />
+    <Compile Include="Commands\FakeSpawnCommand.cs" />
+    <Compile Include="Commands\Ghost.cs" />
+    <Compile Include="Commands\Grenade.cs" />
+    <Compile Include="Commands\HintBroadcast\Clear.cs" />
+    <Compile Include="Commands\HintBroadcast\Group.cs" />
     <Compile Include="Commands\HintBroadcast\HintBroadcast.cs" />
-    <Compile Include="Commands\Hp\Hp.cs" />
-    <Compile Include="Commands\Jail\Jail.cs" />
-    <Compile Include="Commands\Position\Position.cs" />
-    <Compile Include="Commands\PryGates\PryGates.cs" />
-    <Compile Include="Commands\RandomTeleport\RandomTeleport.cs" />
-    <Compile Include="Commands\Regeneration\Regeneration.cs" />
-    <Compile Include="Commands\SpawnRagdoll\SpawnRagdoll.cs" />
-    <Compile Include="Commands\Scale\Scale.cs" />
-    <Compile Include="Commands\Broadcast\Message.cs" />
-    <Compile Include="Commands\Size\Size.cs" />
-    <Compile Include="Commands\SpawnWorkbench\SpawnWorkbench.cs" />
-    <Compile Include="Commands\Tags\Hide.cs" />
-    <Compile Include="Commands\Tags\Show.cs" />
-    <Compile Include="Commands\Tags\Tags.cs" />
-    <Compile Include="Commands\Id\ID.cs" />
+    <Compile Include="Commands\HintBroadcast\User.cs" />
+    <Compile Include="Commands\InstantKill\Add.cs" />
     <Compile Include="Commands\InstantKill\InstantKill.cs" />
+    <Compile Include="Commands\InstantKill\List.cs" />
+    <Compile Include="Commands\InstantKill\Remove.cs" />
+    <Compile Include="Commands\Jail.cs" />
+    <Compile Include="Commands\Position.cs" />
+    <Compile Include="Commands\PryGate\PryGates.cs" />
+    <Compile Include="Commands\RandomTeleport.cs" />
+    <Compile Include="Commands\Regeneration.cs" />
+    <Compile Include="Commands\Rocket.cs" />
+    <Compile Include="Commands\Scale.cs" />
+    <Compile Include="Commands\Size.cs" />
+    <Compile Include="Commands\SpawnRagdoll.cs" />
+    <Compile Include="Commands\SpawnWorkbench.cs" />
     <Compile Include="Commands\Inventory\Drop.cs" />
     <Compile Include="Commands\Inventory\Inventory.cs" />
     <Compile Include="Commands\Inventory\See.cs" />
-    <Compile Include="Commands\Kill\Kill.cs" />
     <Compile Include="Commands\Mute\All.cs" />
     <Compile Include="Commands\Mute\ICom.cs" />
     <Compile Include="Commands\Mute\Mute.cs" />
     <Compile Include="Commands\Mute\RoundStart.cs" />
-    <Compile Include="Commands\Rocket\Rocket.cs" />
-    <Compile Include="Commands\Strip\Strip.cs" />
-    <Compile Include="Commands\TargetGhost\TargetGhost.cs" />
-    <Compile Include="Commands\TeleportX\TeleportX.cs" />
-    <Compile Include="Commands\Tutorial\Tutorial.cs" />
+    <Compile Include="Commands\TargetGhost.cs" />
+    <Compile Include="Commands\TeleportX.cs" />
     <Compile Include="Commands\Unmute\All.cs" />
     <Compile Include="Commands\Unmute\ICom.cs" />
     <Compile Include="Commands\Unmute\Unmute.cs" />
     <Compile Include="Commands\Unmute\RoundStart.cs" />
-    <Compile Include="Commands\Kick\Kick.cs" />
-    <Compile Include="Components\RegenerationComponent.cs" />
     <Compile Include="Config.cs" />
     <Compile Include="Enums.cs" />
     <Compile Include="EventHandlers.cs" />
-    <Compile Include="Components\InstantKillComponent.cs" />
+    <Compile Include="Extensions.cs" />
     <Compile Include="Jailed.cs" />
     <Compile Include="Main.cs" />
+    <Compile Include="Patches\DoorCommandPatche.cs" />
+    <Compile Include="Patches\RAUtilsAddon.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
     <PackageReference Include="EXILED">
-      <Version>8.5.0-beta.1</Version>
+      <Version>8.8.1</Version>
     </PackageReference>
+    <PackageReference Include="Lib.Harmony">
+      <Version>2.2.2</Version>
+    </PackageReference>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="..\.editorconfig">
+      <Link>.editorconfig</Link>
+    </None>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/AdminTools/Commands/AdminBroadcast/AdminBroadcast.cs b/AdminTools/Commands/AdminBroadcast/AdminBroadcast.cs
deleted file mode 100644
index a613818..0000000
--- a/AdminTools/Commands/AdminBroadcast/AdminBroadcast.cs
+++ /dev/null
@@ -1,52 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using RemoteAdmin;
-using System;
-
-namespace AdminTools.Commands.AdminBroadcast
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class AdminBroadcast : ParentCommand
-    {
-        public AdminBroadcast() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "adminbroadcast";
-
-        public override string[] Aliases { get; } = new string[] { "abc" };
-
-        public override string Description { get; } = "Sends a message to all currently online staff on the server";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!CommandProcessor.CheckPermissions(((CommandSender)sender), "broadcast", PlayerPermissions.Broadcasting, "AdminTools", false))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 2)
-            {
-                response = "Usage: adminbroadcast (time) (message)";
-                return false;
-            }
-
-            if (!ushort.TryParse(arguments.At(0), out ushort t))
-            {
-                response = $"Invalid value for broadcast time: {arguments.At(0)}";
-                return false;
-            }
-
-            foreach (Player pl in Player.List)
-            {
-                if (pl.ReferenceHub.serverRoles.RemoteAdmin)
-                    pl.Broadcast(t, EventHandlers.FormatArguments(arguments, 1) + $" ~{((CommandSender)sender).Nickname}", Broadcast.BroadcastFlags.AdminChat);
-            }
-
-            response = $"Message sent to all currently online staff";
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Ahp.cs b/AdminTools/Commands/Ahp.cs
new file mode 100644
index 0000000..ccd425c
--- /dev/null
+++ b/AdminTools/Commands/Ahp.cs
@@ -0,0 +1,64 @@
+using CommandSystem;
+using Exiled.API.Features;
+using RemoteAdmin;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Ahp : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "ahp";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Sets a user or users Artificial HP to a specified value";
+
+        public string[] Usage { get; } = new string[] { "%player%", "Value", "[decay = 1.2]", "[efficacy = 0.7]", "[sustain = 0]", "[IsPersistant = false]" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission(PlayerPermissions.PlayersManagement, out response))
+                return false;
+
+            if (arguments.Count < 2)
+            {
+                response = "Usage: ahp ((player id / name) or (all / *)) (value) [decay = 1.2] [efficacy = 0.7] [sustain = 0] [persistant = false]";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            if (!float.TryParse(arguments.At(1), out float value))
+            {
+                response = $"Invalid value for AHP: {value}";
+                return false;
+            }
+
+            if (!float.TryParse(arguments.ElementAtOrDefault(3), out float decay))
+                decay = 1.2f;
+
+            if (!float.TryParse(arguments.ElementAtOrDefault(4), out float efficacy))
+                efficacy = 0.7f;
+
+            float.TryParse(arguments.ElementAtOrDefault(5), out float sustain);
+
+            bool.TryParse(arguments.ElementAtOrDefault(6), out bool persistant);
+
+            foreach (Player p in players)
+            {
+                p.AddAhp(value, value, decay, efficacy, sustain, persistant);
+            }
+            response = $"AHP has been set to {value} for all the followed players:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/Ahp/Ahp.cs b/AdminTools/Commands/Ahp/Ahp.cs
deleted file mode 100644
index 608a25f..0000000
--- a/AdminTools/Commands/Ahp/Ahp.cs
+++ /dev/null
@@ -1,73 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using RemoteAdmin;
-using System;
-
-namespace AdminTools.Commands.Ahp
-{
-    using System.Collections.Generic;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Ahp : ParentCommand
-    {
-        public Ahp() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "ahp";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Sets a user or users Artificial HP to a specified value";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!CommandProcessor.CheckPermissions(((CommandSender)sender), "ahp", PlayerPermissions.PlayersManagement, "AdminTools", false))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 2)
-            {
-                response = "Usage: ahp ((player id / name) or (all / *)) (value)";
-                return false;
-            }
-
-            List<Player> players = new();
-            if (!float.TryParse(arguments.At(1), out float value))
-            {
-                response = $"Invalid value for AHP: {value}";
-                return false;
-            }
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    foreach (Player ply in Player.List)
-                        players.Add(ply);
-                    break;
-                default:
-                    Player player = Player.Get(arguments.At(0));
-                    if (player == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    players.Add(player);
-                    break;
-            }
-
-            response = string.Empty;
-            foreach (Player p in players)
-            {
-                p.ArtificialHealth = value;
-                response += $"\n{p.Nickname}'s AHP has been set to {value}";
-            }
-
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Ball.cs b/AdminTools/Commands/Ball.cs
new file mode 100644
index 0000000..5e3e675
--- /dev/null
+++ b/AdminTools/Commands/Ball.cs
@@ -0,0 +1,60 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Exiled.API.Enums;
+using Exiled.API.Features.Pickups.Projectiles;
+using PlayerRoles.FirstPersonControl;
+using Random = UnityEngine.Random;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Ball : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "ball";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Spawns a bouncy ball (SCP-018) on a user or all users";
+
+        public string[] Usage { get; } = new string[] { "%player%", "[Speed = 5]","[IsMute = false]"};
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission(PlayerPermissions.GivingItems, out response))
+                return false;
+
+            if (arguments.Count < 1)
+            {
+                response = "Usage: ball ((player id/ name) or (all / *)) [Speed] [IsMute]";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            if (!float.TryParse(arguments.ElementAtOrDefault(1), out float speed) || speed >= 200)
+                speed = 5;
+
+            if (!bool.TryParse(arguments.ElementAtOrDefault(2), out bool isMute) || !isMute)
+                Cassie.Message("pitch_1.5 xmas_bouncyballs");
+
+            foreach (Player p in players)
+            {
+                Scp018Projectile scp018 = Projectile.CreateAndSpawn(ProjectileType.Scp018, p.Position, p.Transform.rotation).As<Scp018Projectile>();
+                scp018.Rigidbody.velocity = p.ReferenceHub.GetVelocity() + Random.onUnitSphere * speed;
+            }
+
+            response = $"Ball has been spawn for all the followed player:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/Ball/Ball.cs b/AdminTools/Commands/Ball/Ball.cs
deleted file mode 100644
index ca8293f..0000000
--- a/AdminTools/Commands/Ball/Ball.cs
+++ /dev/null
@@ -1,86 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.Ball
-{
-    using System.Collections.Generic;
-    using Exiled.API.Enums;
-    using Exiled.API.Features.Items;
-    using Exiled.API.Features.Pickups;
-    using Exiled.API.Features.Pickups.Projectiles;
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Ball : ParentCommand
-    {
-        public Ball() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "ball";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Spawns a bouncy ball (SCP-018) on a user or all users";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.ball"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 1)
-            {
-                response = "Usage: ball ((player id/ name) or (all / *))";
-                return false;
-            }
-
-            List<Player> players = new();
-            switch (arguments.At(0)) 
-            {
-                case "*":
-                case "all":
-                    foreach (Player pl in Player.List)
-                    {
-                        if (pl.Role == RoleTypeId.Spectator || pl.Role == RoleTypeId.None)
-                            continue;
-
-                        players.Add(pl);
-                    }
-
-                    break;
-                default:
-                    Player ply = Player.Get(arguments.At(0));
-                    if (ply == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (ply.Role == RoleTypeId.Spectator || ply.Role == RoleTypeId.None)
-                    {
-                        response = $"You cannot spawn a ball on that player right now";
-                        return false;
-                    }
-
-                    players.Add(ply);
-                    break;
-            }
-
-            response = players.Count == 1
-                ? $"{players[0].Nickname} has received a bouncing ball!"
-                : $"The balls are bouncing for {players.Count} players!";
-
-            Cassie.Message("pitch_1.5 xmas_bouncyballs");
-
-            foreach (Player p in players)
-                Projectile.CreateAndSpawn(ProjectileType.Scp018, p.Position, p.Transform.rotation);
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/BreakDoor/BreakDoors.cs b/AdminTools/Commands/BreakDoor/BreakDoors.cs
new file mode 100644
index 0000000..a904211
--- /dev/null
+++ b/AdminTools/Commands/BreakDoor/BreakDoors.cs
@@ -0,0 +1,68 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class BreakDoors : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "breakdoors";
+
+        public string[] Aliases { get; } = new string[] { "bd" };
+
+        public string Description { get; } = "Manage breaking door/gate properties for players";
+
+        public string[] Usage { get; } = new string[] { "%player%", "IsEnable" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.bd"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count > 0)
+            {
+                response = "Usage: breakdoors (all / *) [IsEnable]";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.ElementAtOrDefault(0)}";
+                return false;
+            }
+
+            bool? isJail = null;
+            if (bool.TryParse(arguments.ElementAtOrDefault(1), out bool result))
+                isJail = result;
+
+            foreach (Player player in players)
+                if (isJail is true)
+                {
+                    if (Main.BreakDoors.Contains(player))
+                        Main.BreakDoors.Add(player);
+                }
+                else if (isJail is false)
+                {
+                    Main.BreakDoors.Remove(player);
+                }
+                else
+                {
+                    if (!Main.BreakDoors.Remove(player))
+                        Main.BreakDoors.Add(player);
+                }
+
+            response = $"BreakDoor has been enable for all the followed player:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/BreakDoors/BreakDoors.cs b/AdminTools/Commands/BreakDoors/BreakDoors.cs
deleted file mode 100644
index 47f1f64..0000000
--- a/AdminTools/Commands/BreakDoors/BreakDoors.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using NorthwoodLib.Pools;
-using System;
-using System.Text;
-
-namespace AdminTools.Commands.BreakDoors
-{
-    using System.Collections.Generic;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class BreakDoors : ParentCommand
-    {
-        public BreakDoors() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "breakdoors";
-
-        public override string[] Aliases { get; } = new string[] { "bd" };
-
-        public override string Description { get; } = "Manage breaking door/gate properties for players";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.bd"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            List<Player> players = new();
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    foreach (Player player in Player.List) 
-                        players.Add(player);
-
-                    break;
-                default:
-                    Player ply = Player.Get(arguments.At(0));
-                    if (ply is null)
-                    {
-                        response = $"Player {arguments.At(0)} not found.";
-                        return false;
-                    }
-
-                    players.Add(ply);
-
-                    break;
-            }
-
-            foreach (Player player in players)
-                if (EventHandlers.BreakDoorsList.Contains(player))
-                    EventHandlers.BreakDoorsList.Remove(player);
-                else
-                    EventHandlers.BreakDoorsList.Add(player);
-
-            response =
-                $"{players.Count} players have been updated. (Players with BD were removed, those without it were added)";
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Broadcast/Message.cs b/AdminTools/Commands/Broadcast/Message.cs
deleted file mode 100644
index 2d04eaf..0000000
--- a/AdminTools/Commands/Broadcast/Message.cs
+++ /dev/null
@@ -1,317 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using NorthwoodLib.Pools;
-using RemoteAdmin;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-
-namespace AdminTools.Commands.Message
-{
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Message : ParentCommand
-    {
-        public Message() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "atbroadcast";
-
-        public override string[] Aliases { get; } = new string[] { "atbc" };
-
-        public override string Description { get; } = "Broadcasts a message to either a user, a group, a role, all staff, or everyone";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!CommandProcessor.CheckPermissions(((CommandSender)sender), "broadcast", PlayerPermissions.Broadcasting, "AdminTools", false))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 1)
-            {
-                response = "Usage:\nbroadcast (time) (message)" +
-                    "\nbroadcast user (player id / name) (time) (message)" +
-                    "\nbroadcast users (player id / name group (i.e.: 1,2,3 or hello,there,hehe)) (time) (message)" +
-                    "\nbroadcast group (group name) (time) (message)" +
-                    "\nbroadcast groups (list of groups (i.e.: owner,admin,moderator)) (time) (message)" +
-                    "\nbroadcast role (RoleTypeId) (time) (message)" +
-                    "\nbroadcast roles (RoleTypeId group (i.e.: ClassD,Scientist,NtfCadet)) (time) (message)" +
-                    "\nbroadcast (random / someone) (time) (message)" +
-                    "\nbroadcast (staff / admin) (time) (message)" +
-                    "\nbroadcast clearall";
-                return false;
-            }
-            
-            switch (arguments.At(0))
-            {
-                case "user":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: broadcast user (player id / name) (time) (message)";
-                        return false;
-                    }
-
-                    Player ply = Player.Get(arguments.At(1));
-                    if (ply == null)
-                    {
-                        response = $"Player not found: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort time) && time <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    ply.Broadcast(time, EventHandlers.FormatArguments(arguments, 3));
-                    response = $"Message sent to {ply.Nickname}";
-                    return true;
-                case "users":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: broadcast users (player id / name group (i.e.: 1,2,3 or hello,there,hehe)) (time) (message)";
-                        return false;
-                    }
-
-                    string[] users = arguments.At(1).Split(',');
-                    List<Player> plyList = new();
-                    foreach (string s in users)
-                    {
-                        if (int.TryParse(s, out int id) && Player.Get(id) != null)
-                            plyList.Add(Player.Get(id));
-                        else if (Player.Get(s) != null)
-                            plyList.Add(Player.Get(s));
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort tme) && tme <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player p in plyList)
-                        p.Broadcast(tme, EventHandlers.FormatArguments(arguments, 3));
-
-
-                    StringBuilder builder = StringBuilderPool.Shared.Rent("Message sent to players: ");
-                    foreach (Player p in plyList)
-                    {
-                        builder.Append("\"");
-                        builder.Append(p.Nickname);
-                        builder.Append("\"");
-                        builder.Append(" ");
-                    }
-                    string message = builder.ToString();
-                    StringBuilderPool.Shared.Return(builder);
-                    response = message;
-                    return true;
-                case "group":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: broadcast group (group) (time) (message)";
-                        return false;
-                    }
-
-                    UserGroup broadcastGroup = ServerStatic.PermissionsHandler.GetGroup(arguments.At(1));
-                    if (broadcastGroup == null)
-                    {
-                        response = $"Invalid group: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort tim) && tim <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player player in Player.List)
-                    {
-                        if (player.Group.BadgeText.Equals(broadcastGroup.BadgeText))
-                            player.Broadcast(tim, EventHandlers.FormatArguments(arguments, 3));
-                    }
-
-                    response = $"Message sent to all members of \"{arguments.At(1)}\"";
-                    return true;
-                case "groups":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: broadcast groups (list of groups (i.e.: owner,admin,moderator)) (time) (message)";
-                        return false;
-                    }
-
-                    string[] groups = arguments.At(1).Split(',');
-                    List<string> groupList = new();
-                    foreach (string s in groups)
-                    {
-                        UserGroup broadGroup = ServerStatic.PermissionsHandler.GetGroup(s);
-                        if (broadGroup != null)
-                            groupList.Add(broadGroup.BadgeText);
-
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort e) && e <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player p in Player.List)
-                        if (groupList.Contains(p.Group.BadgeText))
-                            p.Broadcast(e, EventHandlers.FormatArguments(arguments, 3));
-
-
-                    StringBuilder bdr = StringBuilderPool.Shared.Rent("Message sent to groups with badge text: ");
-                    foreach (string p in groupList)
-                    {
-                        bdr.Append("\"");
-                        bdr.Append(p);
-                        bdr.Append("\"");
-                        bdr.Append(" ");
-                    }
-                    string ms = bdr.ToString();
-                    StringBuilderPool.Shared.Return(bdr);
-                    response = ms;
-                    return true;
-                case "role":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: broadcast role (RoleTypeId) (time) (message)";
-                        return false;
-                    }
-
-                    if (!Enum.TryParse(arguments.At(1), true, out RoleTypeId role))
-                    {
-                        response = $"Invalid value for RoleTypeId: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort te) && te <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player player in Player.List)
-                    {
-                        if (player.Role == role)
-                            player.Broadcast(te, EventHandlers.FormatArguments(arguments, 3));
-                    }
-
-                    response = $"Message sent to all members of \"{arguments.At(1)}\"";
-                    return true;
-                case "roles":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: broadcast roles (RoleTypeId group (i.e.: ClassD, Scientist, NtfCadet)) (time) (message)";
-                        return false;
-                    }
-
-                    string[] roles = arguments.At(1).Split(',');
-                    List<RoleTypeId> roleList = new();
-                    foreach (string s in roles)
-                    {
-                        if (Enum.TryParse(s, true, out RoleTypeId r))
-                            roleList.Add(r);
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort ti) && ti <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player p in Player.List)
-                        if (roleList.Contains(p.Role) && p.ReferenceHub.queryProcessor._ipAddress != "127.0.0.1")
-                            p.Broadcast(ti, EventHandlers.FormatArguments(arguments, 3));
-
-                    StringBuilder build = StringBuilderPool.Shared.Rent("Message sent to roles: ");
-                    foreach (RoleTypeId ro in roleList)
-                    {
-                        build.Append("\"");
-                        build.Append(ro.ToString());
-                        build.Append("\"");
-                        build.Append(" ");
-                    }
-                    string msg = build.ToString();
-                    StringBuilderPool.Shared.Return(build);
-                    response = msg;
-                    return true;
-                case "random":
-                case "someone":
-                    if (arguments.Count < 3)
-                    {
-                        response = "Usage: broadcast (random / someone) (time) (message)";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(1), out ushort me) && me <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    Player plyr = Player.List.ToList()[Main.NumGen.Next(0, Player.List.Count())];
-                    if (plyr.ReferenceHub.queryProcessor._ipAddress != "127.0.0.1")
-                        plyr.Broadcast(me, EventHandlers.FormatArguments(arguments, 2));
-                    response = $"Message sent to {plyr.Nickname}";
-                    return true;
-                case "staff":
-                case "admin":
-                    if (arguments.Count < 3)
-                    {
-                        response = "Usage: broadcast (staff / admin) (time) (message)";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(1), out ushort t))
-                    {
-                        response = $"Invalid value for broadcast time: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    foreach (Player pl in Player.List)
-                    {
-                        if (pl.ReferenceHub.serverRoles.RemoteAdmin)
-                            pl.Broadcast(t, EventHandlers.FormatArguments(arguments, 2) + $" - {((CommandSender)sender).Nickname}", Broadcast.BroadcastFlags.AdminChat);
-                    }
-
-                    response = $"Message sent to all currently online staff";
-                    return true;
-                case "clearall":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: broadcast clearall";
-                        return false;
-                    }
-
-                    Map.ClearBroadcasts();
-                    response = "All current broadcasts have been cleared";
-                    return true;
-                default:
-                    if (arguments.Count < 2)
-                    {
-                        response = "Usage: broadcast (time) (message)";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(0), out ushort tm))
-                    {
-                        response = $"Invalid value for broadcast time: {arguments.At(0)}";
-                        return false;
-                    }
-                    Map.Broadcast(tm, EventHandlers.FormatArguments(arguments, 1));
-                    break;
-            }
-            response = "";
-            return false;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Configuration/Configuration.cs b/AdminTools/Commands/Configuration/Configuration.cs
deleted file mode 100644
index 303a657..0000000
--- a/AdminTools/Commands/Configuration/Configuration.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using CommandSystem;
-using System;
-
-namespace AdminTools.Commands.Configuration
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Configuration : ParentCommand
-    {
-        public Configuration() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "cfig";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Manages reloading permissions and configs";
-
-        public override void LoadGeneratedCommands() 
-        {
-            RegisterCommand(new Reload());
-        }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            response = "Invalid subcommmand. Available ones: reload";
-            return false;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Configuration/Reload.cs b/AdminTools/Commands/Configuration/Reload.cs
deleted file mode 100644
index 31d052e..0000000
--- a/AdminTools/Commands/Configuration/Reload.cs
+++ /dev/null
@@ -1,29 +0,0 @@
-using CommandSystem;
-using GameCore;
-using System;
-
-namespace AdminTools.Commands.Configuration
-{
-    public class Reload : ICommand
-    {
-        public string Command { get; } = "reload";
-
-        public string[] Aliases { get; } = new string[] { "rld" };
-
-        public string Description { get; } = "Reloads all permissions and configs";
-
-        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (arguments.Count != 0)
-            {
-                response = "Usage: cfig reload";
-                return false;
-            }
-
-            ServerStatic.PermissionsHandler.RefreshPermissions();
-            ConfigFile.ReloadGameConfigs();
-            response = "Configuration files reloaded!";
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/DropItem.cs b/AdminTools/Commands/DropItem.cs
new file mode 100644
index 0000000..ed89762
--- /dev/null
+++ b/AdminTools/Commands/DropItem.cs
@@ -0,0 +1,57 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using Exiled.API.Features.Pickups;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class DropItem : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "dropitem";
+
+        public string[] Aliases { get; } = new string[] { "drop", "dropi" };
+
+        public string Description { get; } = "Drops a specified amount of a specified item on either all users or a specific user";
+
+        public string[] Usage { get; } = new string[] { "%player%", "%item%", "[amount = 1]" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission(PlayerPermissions.GivingItems, out response))
+                return false;
+
+            if (arguments.Count < 2)
+            {
+                response = "Usage: dropitem (all / *) (ItemType) [amount = 1]";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+            if (!Enum.TryParse(arguments.At(1), true, out ItemType item))
+            {
+                response = $"Invalid value for item type: {arguments.At(1)}";
+                return false;
+            }
+
+            if (!uint.TryParse(arguments.ElementAtOrDefault(2), out uint amount))
+                amount = 1;
+
+            foreach (Player ply in players)
+                for (int i = 0; i < amount; i++)
+                    Pickup.CreateAndSpawn(item, ply.Position, ply.Rotation, ply);
+
+            response = $"{amount} of {item} was spawned on all the following player:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/DropItem/DropItem.cs b/AdminTools/Commands/DropItem/DropItem.cs
deleted file mode 100644
index 8aafb0d..0000000
--- a/AdminTools/Commands/DropItem/DropItem.cs
+++ /dev/null
@@ -1,101 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-using UnityEngine;
-
-namespace AdminTools.Commands.DropItem
-{
-    using Exiled.API.Features.Items;
-    using Exiled.API.Features.Pickups;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class DropItem : ParentCommand
-    {
-        public DropItem() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "dropitem";
-
-        public override string[] Aliases { get; } = new string[] { "drop", "dropi" };
-
-        public override string Description { get; } = "Drops a specified amount of a specified item on either all users or a user";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.items"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 3)
-            {
-                response = "Usage: dropitem ((player id/ name) or (all / *)) (ItemType) (amount (200 max for one user, 15 max for all users))";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    if (arguments.Count != 3)
-                    {
-                        response = "Usage: dropitem (all / *) (ItemType) (amount (15 max))";
-                        return false;
-                    }
-
-                    if (!Enum.TryParse(arguments.At(1), true, out ItemType item))
-                    {
-                        response = $"Invalid value for item type: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!uint.TryParse(arguments.At(2), out uint amount) || amount > 15)
-                    {
-                        response = $"Invalid amount of item to drop: {arguments.At(2)} {(amount > 15 ? "(\"Try a lower number that won't crash my servers, ty.\" - Galaxy119)" : "")}";
-                        return false;
-                    }
-
-                    foreach (Player ply in Player.List)
-                        for (int i = 0; i < amount; i++)
-                            Pickup.CreateAndSpawn(item, ply.Position, default, ply);
-
-                    response = $"{amount} of {item.ToString()} was spawned on everyone (\"Hehexd\" - Galaxy119)";
-                    return true;
-                default:
-                    if (arguments.Count != 3)
-                    {
-                        response = "Usage: dropitem (player id / name) (ItemType) (amount (200 max))";
-                        return false;
-                    }
-
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (!Enum.TryParse(arguments.At(1), true, out ItemType it))
-                    {
-                        response = $"Invalid value for item type: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!uint.TryParse(arguments.At(2), out uint am) || am > 200)
-                    {
-                        response = $"Invalid amount of item to drop: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    for (int i = 0; i < am; i++)
-                        Pickup.CreateAndSpawn(it, pl.Position, default, pl);
-                    response = $"{am} of {it.ToString()} was spawned on {pl.Nickname} (\"Hehexd\" - Galaxy119)";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/DropSize.cs b/AdminTools/Commands/DropSize.cs
new file mode 100644
index 0000000..4ea8df5
--- /dev/null
+++ b/AdminTools/Commands/DropSize.cs
@@ -0,0 +1,97 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using Exiled.API.Features.Pickups;
+using System.Collections.Generic;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class DropSize : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "dropsize";
+
+        public string[] Aliases { get; } = new string[] { "drops" };
+
+        public string Description { get; } = "Drops a selected amount of a selected item on a specific user or all users";
+
+        public string[] Usage { get; } = new string[] { "%player%", "%item%", "size", "[size]", "[size]" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission(PlayerPermissions.GivingItems, out response))
+                return false;
+
+            if (arguments.Count < 3)
+            {
+                response = "Usage:\ndropsize ((player id / name) or (all / *)) (ItemType) (size)\ndropsize ((player id / name) or (all / *)) (ItemType) (x size) (y size) (z size)";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            if (!Enum.TryParse(arguments.At(1), true, out ItemType type))
+            {
+                response = $"Invalid value for item name: {arguments.At(1)}";
+                return false;
+            }
+
+            switch (arguments.Count)
+            {
+                case 3:
+                    if (!float.TryParse(arguments.At(2), out float size))
+                    {
+                        response = $"Invalid value for item scale: {arguments.At(2)}";
+                        return false;
+                    }
+                    SpawnItem(players, type, size, out response);
+                    return true;
+                case 5:
+                    if (!float.TryParse(arguments.At(2), out float xval))
+                    {
+                        response = $"Invalid value for item scale: {arguments.At(2)}";
+                        return false;
+                    }
+
+                    if (!float.TryParse(arguments.At(3), out float yval))
+                    {
+                        response = $"Invalid value for item scale: {arguments.At(3)}";
+                        return false;
+                    }
+
+                    if (!float.TryParse(arguments.At(4), out float zval))
+                    {
+                        response = $"Invalid value for item scale: {arguments.At(4)}";
+                        return false;
+                    }
+                    SpawnItem(players, type, xval, yval, zval, out response);
+                    return true;
+                default:
+                    response = "\nUsage:\ndrops (all / *) (ItemType) (size) \ndrops (all / *) (ItemType) (x size) (y size) (z size)";
+                    return false;
+            }
+        }
+
+        private void SpawnItem(IEnumerable<Player> players, ItemType type, float size, out string message)
+            => SpawnItem(players, type, size, size, size, out message);
+
+        private void SpawnItem(IEnumerable<Player> players, ItemType type, float x, float y, float z, out string message)
+        {
+            foreach (Player ply in players)
+            {
+                if (ply.IsDead)
+                    continue;
+
+                Pickup.CreateAndSpawn(type, ply.Position, default, ply).Scale = new(x, y, z);
+            }
+            message = $"Spawned a {type} that is ({x}, {y}, {z}) at all the following player:\n{players.LogPlayers()}";
+        }
+    }
+}
diff --git a/AdminTools/Commands/DropSize/DropSize.cs b/AdminTools/Commands/DropSize/DropSize.cs
deleted file mode 100644
index 3345d5d..0000000
--- a/AdminTools/Commands/DropSize/DropSize.cs
+++ /dev/null
@@ -1,189 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using Mirror;
-using System;
-using UnityEngine;
-
-namespace AdminTools.Commands.DropSize
-{
-    using Exiled.API.Features.Items;
-    using Exiled.API.Features.Pickups;
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class DropSize : ParentCommand
-    {
-        public DropSize() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "dropsize";
-
-        public override string[] Aliases { get; } = new string[] { "drops" };
-
-        public override string Description { get; } = "Drops a selected amount of a selected item on a user or all users";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.items"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 3)
-            {
-                response = "Usage:\ndropsize ((player id / name) or (all / *)) (ItemType) (size)\ndropsize ((player id / name) or (all / *)) (ItemType) (x size) (y size) (z size)";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    if (arguments.Count < 3)
-                    {
-                        response = "Usage: dropsize (all / * id) (ItemType) ((size) or (x size) (y size) (z size))";
-                        return false;
-                    }
-
-                    if (!Enum.TryParse(arguments.At(1), true, out ItemType type))
-                    {
-                        response = $"Invalid value for item name: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    switch (arguments.Count)
-                    {
-                        case 3:
-                            if (!float.TryParse(arguments.At(2), out float size))
-                            {
-                                response = $"Invalid value for item scale: {arguments.At(2)}";
-                                return false;
-                            }
-                            SpawnItem(type, size, out string msg);
-                            response = msg;
-                            return true;
-                        case 5:
-                            if (!float.TryParse(arguments.At(2), out float xval))
-                            {
-                                response = $"Invalid value for item scale: {arguments.At(2)}";
-                                return false;
-                            }
-
-                            if (!float.TryParse(arguments.At(3), out float yval))
-                            {
-                                response = $"Invalid value for item scale: {arguments.At(3)}";
-                                return false;
-                            }
-
-                            if (!float.TryParse(arguments.At(4), out float zval))
-                            {
-                                response = $"Invalid value for item scale: {arguments.At(4)}";
-                                return false;
-                            }
-                            SpawnItem(type, xval, yval, zval, out string message);
-                            response = message;
-                            return true;
-                        default:
-                            response = "\nUsage:\ndrops (all / *) (ItemType) (size) \ndrops (all / *) (ItemType) (x size) (y size) (z size)";
-                            return false;
-                    }
-                default:
-                    if (arguments.Count < 3)
-                    {
-                        response = "Usage: dropsize (player id / name) (ItemType) ((size) or (x size) (y size) (z size))";
-                        return false;
-                    }
-
-                    Player ply = Player.Get(arguments.At(0));
-                    if (ply == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return true;
-                    }
-
-                    if (!Enum.TryParse(arguments.At(1), true, out ItemType T))
-                    {
-                        response = $"Invalid value for item name: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    switch (arguments.Count)
-                    {
-                        case 3:
-                            if (!float.TryParse(arguments.At(2), out float size))
-                            {
-                                response = $"Invalid value for item scale: {arguments.At(2)}";
-                                return false;
-                            }
-                            SpawnItem(ply, T, size, out string msg);
-                            response = msg;
-                            return true;
-                        case 5:
-                            if (!float.TryParse(arguments.At(2), out float xval))
-                            {
-                                response = $"Invalid value for item scale: {arguments.At(2)}";
-                                return false;
-                            }
-
-                            if (!float.TryParse(arguments.At(3), out float yval))
-                            {
-                                response = $"Invalid value for item scale: {arguments.At(3)}";
-                                return false;
-                            }
-
-                            if (!float.TryParse(arguments.At(4), out float zval))
-                            {
-                                response = $"Invalid value for item scale: {arguments.At(4)}";
-                                return false;
-                            }
-                            SpawnItem(ply, T, xval, yval, zval, out string message);
-                            response = message;
-                            return true;
-                        default:
-                            response = "\nUsage:\ndropsize (player id / name) (ItemType) (size) \ndropsize (player id / name) (ItemType) (x size) (y size) (z size)";
-                            return false;
-                    }
-            }
-        }
-
-        private void SpawnItem(ItemType type, float size, out string message)
-        {
-            foreach (Player ply in Player.List)
-            {
-                if (ply.Role == RoleTypeId.Spectator || ply.Role == RoleTypeId.None)
-                    continue;
-
-                Pickup.CreateAndSpawn(type, ply.Position, default, ply).Scale = Vector3.one * size;
-            }
-            message = $"Spawned in a {type.ToString()} that is a size of {size} at every player's position (\"Yay! Items with sizes!\" - Galaxy119)";
-        }
-
-        private void SpawnItem(ItemType type, float x, float y, float z, out string message)
-        {
-            foreach (Player ply in Player.List)
-            {
-                if (ply.Role == RoleTypeId.Spectator || ply.Role == RoleTypeId.None)
-                    continue;
-
-                Pickup.CreateAndSpawn(type, ply.Position, default, ply).Scale = new(x, y, z);
-            }
-            message = $"Spawned in a {type.ToString()} that is {x}x{y}x{z} at every player's position (\"Yay! Items with sizes!\" - Galaxy119)";
-        }
-
-        private void SpawnItem(Player ply, ItemType type, float size, out string message)
-        {
-            Pickup.CreateAndSpawn(type, ply.Position, default, ply).Scale = Vector3.one * size;
-            message = $"Spawned in a {type.ToString()} that is a size of {size} at {ply.Nickname}'s position (\"Yay! Items with sizes!\" - Galaxy119)";
-        }
-
-        private void SpawnItem(Player ply, ItemType type, float x, float y, float z, out string message)
-        {
-            Pickup.CreateAndSpawn(type, ply.Position, default, ply).Scale = new(x, y, z);
-            message = $"Spawned in a {type.ToString()} that is {x}x{y}x{z} at {ply.Nickname}'s position (\"Yay! Items with sizes!\" - Galaxy119)";
-        }
-    }
-}
diff --git a/AdminTools/Commands/Enums.cs b/AdminTools/Commands/Enums.cs
new file mode 100644
index 0000000..15b93a4
--- /dev/null
+++ b/AdminTools/Commands/Enums.cs
@@ -0,0 +1,43 @@
+using CommandSystem;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Enums : ICommand, IUsageProvider
+    {
+        private IEnumerable<Type> types;
+        public string Command { get; } = "enums";
+
+        public string[] Aliases { get; } = new string[] { "enum" };
+
+        public string Description { get; } = "Lists all enums";
+
+        public string[] Usage { get; } = new string[] { "EnumName", };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (arguments.Count > 1)
+            {
+                response = "Give an Enum name (ProjectileType, RoleTypeId, ItemType, VectorAxis, PositionModifier)";
+                return false;
+            }
+
+            if (types == null)
+                types = AppDomain.CurrentDomain.GetAssemblies().SelectMany(assembly => assembly.GetTypes()).Where(y => y.IsEnum);
+
+            Type enumType = types.FirstOrDefault(t => t.Name.Contains(arguments.At(0)));
+            if (enumType == null)
+            {
+                response = "Invalid Enum name";
+                return false;
+            }
+            response = $"<b>{enumType.Name}<\b>\n - ";
+            response += string.Join("\n - ", Enum.GetNames(enumType));
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/Enums/Enums.cs b/AdminTools/Commands/Enums/Enums.cs
deleted file mode 100644
index f49f893..0000000
--- a/AdminTools/Commands/Enums/Enums.cs
+++ /dev/null
@@ -1,63 +0,0 @@
-using CommandSystem;
-using NorthwoodLib.Pools;
-using System;
-using System.Text;
-
-namespace AdminTools.Commands.Enums
-{
-    using Exiled.API.Enums;
-    using Exiled.API.Features.Pickups;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Enums : ParentCommand
-    {
-        public Enums() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "enums";
-
-        public override string[] Aliases { get; } = new string[] { "enum" };
-
-        public override string Description { get; } = "Lists all enums AdminTools uses";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            StringBuilder listBuilder = StringBuilderPool.Shared.Rent();
-            listBuilder.Append("Here are the following enums you can use in commands:");
-            listBuilder.AppendLine();
-            listBuilder.Append("ItemType: ");
-            foreach (ItemType type in Enum.GetValues(typeof(ItemType)))
-            {
-                listBuilder.Append(type.ToString());
-                listBuilder.Append(" ");
-            }
-            listBuilder.AppendLine();
-            listBuilder.Append("ProjectileType: ");
-            foreach (ProjectileType gt in Enum.GetValues(typeof(ProjectileType)))
-            {
-                listBuilder.Append(gt.ToString());
-                listBuilder.Append(" ");
-            }
-            listBuilder.AppendLine();
-            listBuilder.Append("VectorAxis: ");
-            foreach (VectorAxis va in Enum.GetValues(typeof(VectorAxis)))
-            {
-                listBuilder.Append(va.ToString());
-                listBuilder.Append(" ");
-            }
-            listBuilder.AppendLine();
-            listBuilder.Append("PositionModifier: ");
-            foreach (PositionModifier pm in Enum.GetValues(typeof(PositionModifier)))
-            {
-                listBuilder.Append(pm.ToString());
-                listBuilder.Append(" ");
-            }
-            string message = listBuilder.ToString();
-            StringBuilderPool.Shared.Return(listBuilder);
-            response = message;
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Explode.cs b/AdminTools/Commands/Explode.cs
new file mode 100644
index 0000000..3a97663
--- /dev/null
+++ b/AdminTools/Commands/Explode.cs
@@ -0,0 +1,54 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using System.Collections.Generic;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Explode : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "explode";
+
+        public string[] Aliases { get; } = new string[] { "expl", "boom" };
+
+        public string Description { get; } = "Explodes a specified user or everyone instantly";
+
+        public string[] Usage { get; } = new string[] { "%player%", };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.explode"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count != 1)
+            {
+                response = "Usage: expl ((player id / name) or (all / *))";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            foreach (Player ply in players)
+            {
+                if (ply.IsDead)
+                    continue;
+
+                ply.Explode();
+                ply.Kill("Exploded by admin.");
+            }
+            response = $"The following players have been exploded:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/Explode/Explode.cs b/AdminTools/Commands/Explode/Explode.cs
deleted file mode 100644
index ce0e598..0000000
--- a/AdminTools/Commands/Explode/Explode.cs
+++ /dev/null
@@ -1,90 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.Explode
-{
-    using Exiled.API.Features.Items;
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Explode : ParentCommand
-    {
-        public Explode() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "expl";
-
-        public override string[] Aliases { get; } = new string[] { "boom" };
-
-        public override string Description { get; } = "Explodes a specified user or everyone instantly";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.explode"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 1)
-            {
-                response = "Usage: expl ((player id / name) or (all / *))";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: expl (all / *)";
-                        return false;
-                    }
-
-                    foreach (Player ply in Player.List)
-                    {
-                        if (ply.Role == RoleTypeId.Spectator || ply.Role == RoleTypeId.None)
-                            continue;
-
-                        ply.Kill("Exploded by admin.");
-                        ExplosiveGrenade grenade = (ExplosiveGrenade)Item.Create(ItemType.GrenadeHE);
-                        grenade.FuseTime = 0.5f;
-                        grenade.SpawnActive(ply.Position, ply);
-                    }
-                    response = "Everyone exploded, Hubert cannot believe you have done this";
-                    return true;
-                default:
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: expl (player id / name)";
-                        return false;
-                    }
-
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Invalid target to explode: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (pl.Role == RoleTypeId.Spectator || pl.Role == RoleTypeId.None)
-                    {
-                        response = $"Player \"{pl.Nickname}\" is not a valid class to explode";
-                        return false;
-                    }
-
-                    pl.Kill("Exploded by admin.");
-                    ExplosiveGrenade gr = (ExplosiveGrenade)Item.Create(ItemType.GrenadeHE);
-                    gr.FuseTime = 0.5f;
-                    gr.SpawnActive(pl.Position, pl);
-                    response = $"Player \"{pl.Nickname}\" game ended (exploded)";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/FakeSpawnCommand.cs b/AdminTools/Commands/FakeSpawnCommand.cs
new file mode 100644
index 0000000..490e87e
--- /dev/null
+++ b/AdminTools/Commands/FakeSpawnCommand.cs
@@ -0,0 +1,70 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using Exiled.API.Extensions;
+using PlayerRoles;
+using Respawning;
+using Respawning.NamingRules;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class FakeSpawnCommand : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "fakespawn";
+
+        public string[] Aliases { get; } = new[] { "fakesync", "fakerole" };
+
+        public string Description { get; } = "Sets everyone or a specific user to be invisible";
+
+        public string[] Usage { get; } = new string[] { "%player%", "%player%", "%role%" ,"[id]"};
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.ghost"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count < 2)
+            {
+                response = "Usage: fakespawn ((player id / name) or (all / *)) ((player id / name) or (all / *)) (RoleTypeId) [id]";
+                return false;
+            }
+
+            if (!Enum.TryParse(arguments.At(2), true, out RoleTypeId roletype))
+            {
+                response = $"Invalid value for RoleTypeId: {arguments.At(2)}\n{string.Join(", ", Enum.GetNames(typeof(RoleTypeId)))}.";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            IEnumerable<Player> playersToAffect = Player.GetProcessedData(arguments, 1);
+            if (playersToAffect.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(1)}";
+                return false;
+            }
+            byte id = (byte)(UnitNameMessageHandler.ReceivedNames.Count - 1);
+            if (roletype.TryGetAssignedSpawnableTeam(out SpawnableTeamType _) && byte.TryParse(arguments.ElementAtOrDefault(2), out id) && UnitNameMessageHandler.ReceivedNames.Count > id)
+                id = (byte)(UnitNameMessageHandler.ReceivedNames.Count - 1);
+
+            foreach (Player player in players)
+                player.ChangeAppearance(roletype, playersToAffect, false, id);
+
+            response = $"The following players have been changed to '{roletype}':\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/FakeSync/FakeSpawnCommand.cs b/AdminTools/Commands/FakeSync/FakeSpawnCommand.cs
deleted file mode 100644
index 14fc761..0000000
--- a/AdminTools/Commands/FakeSync/FakeSpawnCommand.cs
+++ /dev/null
@@ -1,78 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.FakeSync
-{
-    using CustomPlayerEffects;
-    using Exiled.API.Extensions;
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class FakeSpawnCommand : ParentCommand
-    {
-        public FakeSpawnCommand() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "fakesync";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Sets everyone or a user to be invisible";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.ghost"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (!Enum.TryParse(arguments.At(1), out RoleTypeId roletype))
-            {
-                response = "Usage:\nghost ((player id / name) or (all / *))" +
-                    "\nghost clear";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "clear":
-                    foreach (Player pl in Player.List)
-                        pl.ChangeAppearance(roletype, Player.List, true, 0);
-
-                    response = "Everyone is no longer invisible";
-                    return true;
-                case "*":
-                case "all":
-                    foreach (Player pl in Player.List)
-                        pl.EnableEffect<Invisible>();
-
-                    response = "Everyone is now invisible";
-                    return true;
-                default:
-                    Player ply = Player.Get(arguments.At(0));
-                    if (ply == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (!ply.IsEffectActive<Invisible>())
-                    {
-                        ply.EnableEffect<Invisible>();
-                        response = $"Player {ply.Nickname} is now invisible";
-                    }
-                    else
-                    {
-                        ply.DisableEffect<Invisible>();
-                        response = $"Player {ply.Nickname} is no longer invisible";
-                    }
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Ghost.cs b/AdminTools/Commands/Ghost.cs
new file mode 100644
index 0000000..1beb672
--- /dev/null
+++ b/AdminTools/Commands/Ghost.cs
@@ -0,0 +1,67 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using Exiled.API.Features.Roles;
+using System.Collections.Generic;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Ghost : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "ghost";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Sets everyone or a user to be invisible";
+
+        public string[] Usage { get; } = new string[] { "%player% / Clear", };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.ghost"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count != 1)
+            {
+                response = "Usage:\nghost ((player id / name) or (all / *))" +
+                    "\nghost clear";
+                return false;
+            }
+
+            switch (arguments.At(0))
+            {
+                case "clear":
+                    {
+                        foreach (Player pl in Player.List)
+                            if (pl.Role is FpcRole fpc)
+                                fpc.IsInvisible = false;
+
+                        response = "Everyone is no longer invisible";
+                        return true;
+                    }
+                default:
+                    {
+                        IEnumerable<Player> players = Player.GetProcessedData(arguments);
+                        if (players.IsEmpty())
+                        {
+                            response = $"Player not found: {arguments.At(0)}";
+                            return false;
+                        }
+                        foreach (Player pl in players)
+                            if (pl.Role is FpcRole fpc)
+                                fpc.IsInvisible = !fpc.IsInvisible;
+                        
+                        response = $"The following player has been ghosted:\n{Extensions.LogPlayers(players)}";
+                        return true;
+                    }
+            }
+        }
+    }
+}
+
diff --git a/AdminTools/Commands/Ghost/Ghost.cs b/AdminTools/Commands/Ghost/Ghost.cs
deleted file mode 100644
index 4d69680..0000000
--- a/AdminTools/Commands/Ghost/Ghost.cs
+++ /dev/null
@@ -1,76 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.Ghost
-{
-    using CustomPlayerEffects;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Ghost : ParentCommand
-    {
-        public Ghost() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "ghost";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Sets everyone or a user to be invisible";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.ghost"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 1)
-            {
-                response = "Usage:\nghost ((player id / name) or (all / *))" +
-                    "\nghost clear";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "clear":
-                    foreach (Player pl in Player.List)
-                        pl.DisableEffect<Invisible>();
-
-                    response = "Everyone is no longer invisible";
-                    return true;
-                case "*":
-                case "all":
-                    foreach (Player pl in Player.List)
-                        pl.EnableEffect<Invisible>();
-
-                    response = "Everyone is now invisible";
-                    return true;
-                default:
-                    Player ply = Player.Get(arguments.At(0));
-                    if (ply == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (!ply.IsEffectActive<Invisible>())
-                    {
-                        ply.EnableEffect<Invisible>();
-                        response = $"Player {ply.Nickname} is now invisible";
-                    }
-                    else
-                    {
-                        ply.DisableEffect<Invisible>();
-                        response = $"Player {ply.Nickname} is no longer invisible";
-                    }
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Grenade.cs b/AdminTools/Commands/Grenade.cs
new file mode 100644
index 0000000..aa351a0
--- /dev/null
+++ b/AdminTools/Commands/Grenade.cs
@@ -0,0 +1,66 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using Exiled.API.Enums;
+using System.Collections.Generic;
+using Exiled.API.Features.Pickups.Projectiles;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Grenade : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "grenade";
+
+        public string[] Aliases { get; } = new string[] { "gn" };
+
+        public string Description { get; } = $"Spawns a {string.Join("/", Enum.GetNames(typeof(ProjectileType)))} grenade on a user or users";
+
+        public string[] Usage { get; } = new string[] { "%player%", string.Join(", ", Enum.GetNames(typeof(ProjectileType))), "FuseTime" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.grenade"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count < 2 || arguments.Count > 3)
+            {
+                response = "Usage: grenade ((player id / name) or (all / *)) (ProjectileType) [grenade time = default]";
+                return false;
+            }
+
+            if (!Enum.TryParse(arguments.At(1), true, out ProjectileType type))
+            {
+                response = $"Invalid value for projectile type: {arguments.At(1)}\n{string.Join(", ",Enum.GetNames(typeof(ProjectileType)))}.";
+                return false;
+            }
+
+            float? fusetime = null;
+            if (float.TryParse(arguments.At(2), out float value))
+                fusetime = value;
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            foreach (Player player in players)
+            {
+                if (player.IsDead)
+                    continue;
+                if (Projectile.CreateAndSpawn(type, player.Position, player.Rotation).Is(out TimeGrenadeProjectile timeGrenadeProjectile) && fusetime.HasValue)
+                    fusetime = timeGrenadeProjectile.FuseTime = fusetime.Value;
+            }
+
+            response = $"A grenade ({type}) has been sent to the following player: {(fusetime.HasValue ? $". The grenade will explode in {fusetime} seconds." : string.Empty)}: \n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/Grenade/Grenade.cs b/AdminTools/Commands/Grenade/Grenade.cs
deleted file mode 100644
index 5657104..0000000
--- a/AdminTools/Commands/Grenade/Grenade.cs
+++ /dev/null
@@ -1,105 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.Grenade
-{
-    using Exiled.API.Enums;
-    using Exiled.API.Features.Items;
-    using Exiled.API.Extensions;
-    using InventorySystem.Items.ThrowableProjectiles;
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Grenade : ParentCommand
-    {
-        public Grenade() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "grenade";
-
-        public override string[] Aliases { get; } = new string[] { "gn" };
-
-        public override string Description { get; } = "Spawns a frag/flash/scp018 grenade on a user or users";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.grenade"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 2 || arguments.Count > 3)
-            {
-                response = "Usage: grenade ((player id / name) or (all / *)) (ProjectileType) (grenade time)";
-                return false;
-            }
-
-            if (!Enum.TryParse(arguments.At(1), true, out ProjectileType type))
-            {
-                response = $"Invalid value for projectile type: {arguments.At(1)}\n{string.Join(", ",Enum.GetNames(typeof(ProjectileType)))}.";
-                return false;
-            }
-
-            if (!float.TryParse(arguments.At(2), out float fuseTime))
-            {
-                response = $"Invalid fuse time for grenade: {arguments.At(2)}";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":                
-                    foreach (Player player in Player.List)
-                    {
-                        if (player.Role != RoleTypeId.Spectator) 
-                            SpawnGrenade(player, type, fuseTime);
-                    }
-
-                    break;
-                default:
-                    Player ply = Player.Get(arguments.At(0));
-                    if (ply is null)
-                    {
-                        response = $"Player {arguments.At(0)} not found.";
-                        return false;
-                    }
-
-                    SpawnGrenade(ply, type, fuseTime);
-                    break;
-            }
-
-            response = $"Grenade has been sent to {arguments.At(0)}";
-            return true;
-        }
-
-        private void SpawnGrenade(Player player, ProjectileType type, float fuseTime)
-        {
-            switch (type)
-            {
-                case ProjectileType.Flashbang:
-                    FlashGrenade flash = (FlashGrenade) Item.Create(ItemType.GrenadeFlash);
-                    flash.FuseTime = fuseTime;
-                    flash.SpawnActive(player.Position);
-
-                    break;
-                case ProjectileType.Scp2176:
-                    Scp2176 scp2176 = (Scp2176)Item.Create(ItemType.SCP2176);
-                    scp2176.FuseTime = fuseTime;
-                    scp2176.SpawnActive(player.Position);
-
-                    break;
-                default:
-                    ExplosiveGrenade grenade = (ExplosiveGrenade) Item.Create(type.GetItemType());
-                    grenade.FuseTime = fuseTime;
-                    grenade.SpawnActive(player.Position);
-                    break;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/HintBroadcast/Clear.cs b/AdminTools/Commands/HintBroadcast/Clear.cs
new file mode 100644
index 0000000..d9a6ae5
--- /dev/null
+++ b/AdminTools/Commands/HintBroadcast/Clear.cs
@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using CommandSystem;
+using Exiled.API.Features;
+
+namespace AdminTools.Commands.HintBroadcast
+{
+    internal class Clear : ICommand
+    {
+        public string Command { get; } = "clear";
+        public string[] Aliases { get; } = Array.Empty<string>();
+        public string Description { get; } = "Clears a user's hints";
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (arguments.Count < 1)
+            {
+                response = "Usage: hbc clear (user ids / usernames)";
+                return false;
+            }
+
+            IEnumerable<Player> ply = Player.GetProcessedData(arguments);
+            if (ply.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            foreach (Player player in ply)
+            {
+                player.ShowHint(string.Empty);
+            }
+            response = "Cleared hints of users";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/HintBroadcast/Group.cs b/AdminTools/Commands/HintBroadcast/Group.cs
new file mode 100644
index 0000000..586715c
--- /dev/null
+++ b/AdminTools/Commands/HintBroadcast/Group.cs
@@ -0,0 +1,59 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using CommandSystem;
+using Exiled.API.Features;
+using NorthwoodLib.Pools;
+
+namespace AdminTools.Commands.HintBroadcast
+{
+    internal class Group : ICommand
+    {
+        public string Command { get; } = "group";
+        public string[] Aliases { get; } = Array.Empty<string>();
+        public string Description { get; } = "Sends a broadcast to multiple groups";
+    
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (arguments.Count < 3)
+            {
+                response = "Usage: hbc groups (list of groups (i.e.: owner,admin,moderator)) (time) (message)";
+                return false;
+            }
+    
+            string[] groups = arguments.At(0).Split(',');
+            List<string> groupList = new();
+            foreach (string s in groups)
+            {
+                UserGroup broadGroup = ServerStatic.PermissionsHandler.GetGroup(s);
+                if (broadGroup != null)
+                    groupList.Add(broadGroup.BadgeText);
+            }
+    
+            if (!ushort.TryParse(arguments.At(1), out ushort e) && e <= 0)
+            {
+                response = $"Invalid value for duration: {arguments.At(1)}";
+                return false;
+            }
+    
+            foreach (Player p in Player.List)
+            {
+                if (groupList.Contains(p.Group.BadgeText))
+                    p.ShowHint(Extensions.FormatArguments(arguments, 2), e);
+            }
+    
+            StringBuilder bdr = StringBuilderPool.Shared.Rent("Hint sent to groups with badge text: ");
+            foreach (string p in groupList)
+            {
+                bdr.Append("\"");
+                bdr.Append(p);
+                bdr.Append("\"");
+                bdr.Append(" ");
+            }
+    
+            response = bdr.ToString();
+            StringBuilderPool.Shared.Return(bdr);
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/AdminTools/Commands/HintBroadcast/HintBroadcast.cs b/AdminTools/Commands/HintBroadcast/HintBroadcast.cs
index 1448449..ab8eaa6 100644
--- a/AdminTools/Commands/HintBroadcast/HintBroadcast.cs
+++ b/AdminTools/Commands/HintBroadcast/HintBroadcast.cs
@@ -1,319 +1,28 @@
 using CommandSystem;
-using Exiled.API.Features;
-using NorthwoodLib.Pools;
-using RemoteAdmin;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 
 namespace AdminTools.Commands.HintBroadcast
 {
-    using PlayerRoles;
-
     [CommandHandler(typeof(RemoteAdminCommandHandler))]
     [CommandHandler(typeof(GameConsoleCommandHandler))]
     public class HintBroadcast : ParentCommand
     {
         public HintBroadcast() => LoadGeneratedCommands();
 
-        public override string Command { get; } = "hbc";
-
-        public override string[] Aliases { get; } = new string[] { "broadcasthint" };
-
+        public override string Command { get; } = "hintbroadcast";
+        public override string[] Aliases { get; } = new string[] { "hint" , "hbc" };
         public override string Description { get; } = "Broadcasts a message to either a user, a group, a role, all staff, or everyone";
 
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        public override void LoadGeneratedCommands()
         {
-            if (!CommandProcessor.CheckPermissions(((CommandSender)sender), "hints", PlayerPermissions.Broadcasting, "AdminTools", false))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 1)
-            {
-                response = "Usage:\nhint (time) (message)" +
-                    "\nhbc user (player id / name) (time) (message)" +
-                    "\nhbc users (player id / name group (i.e.: 1,2,3 or hello,there,hehe)) (time) (message)" +
-                    "\nhbc group (group name) (time) (message)" +
-                    "\nhbc groups (list of groups (i.e.: owner,admin,moderator)) (time) (message)" +
-                    "\nhbc role (RoleTypeId) (time) (message)" +
-                    "\nhbc roles (RoleTypeId group (i.e.: ClassD,Scientist,NtfCadet)) (time) (message)" +
-                    "\nhbc (random / someone) (time) (message)" +
-                    "\nhbc (staff / admin) (time) (message)" +
-                    "\nhbc clearall";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "user":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: hbc user (player id / name) (time) (message)";
-                        return false;
-                    }
-
-                    Player ply = Player.Get(arguments.At(1));
-                    if (ply == null)
-                    {
-                        response = $"Player not found: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort time) && time <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    ply.ShowHint(EventHandlers.FormatArguments(arguments, 3), time);
-                    response = $"Hint sent to {ply.Nickname}";
-                    return true;
-                case "users":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: hbc users (player id / name group (i.e.: 1,2,3 or hello,there,hehe)) (time) (message)";
-                        return false;
-                    }
-
-                    string[] users = arguments.At(1).Split(',');
-                    List<Player> plyList = new();
-                    foreach (string s in users)
-                    {
-                        if (int.TryParse(s, out int id) && Player.Get(id) != null)
-                            plyList.Add(Player.Get(id));
-                        else if (Player.Get(s) != null)
-                            plyList.Add(Player.Get(s));
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort tme) && tme <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player p in plyList)
-                        p.ShowHint(EventHandlers.FormatArguments(arguments, 3), tme);
-
-
-                    StringBuilder builder = StringBuilderPool.Shared.Rent("Hint sent to players: ");
-                    foreach (Player p in plyList)
-                    {
-                        builder.Append("\"");
-                        builder.Append(p.Nickname);
-                        builder.Append("\"");
-                        builder.Append(" ");
-                    }
-                    string message = builder.ToString();
-                    StringBuilderPool.Shared.Return(builder);
-                    response = message;
-                    return true;
-                case "group":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: hbc group (group) (time) (message)";
-                        return false;
-                    }
-
-                    UserGroup broadcastGroup = ServerStatic.PermissionsHandler.GetGroup(arguments.At(1));
-                    if (broadcastGroup == null)
-                    {
-                        response = $"Invalid group: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort tim) && tim <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player player in Player.List)
-                    {
-                        if (player.Group.BadgeText.Equals(broadcastGroup.BadgeText))
-                            player.ShowHint(EventHandlers.FormatArguments(arguments, 3), tim);
-                    }
-
-                    response = $"Hint sent to all members of \"{arguments.At(1)}\"";
-                    return true;
-                case "groups":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: hbc groups (list of groups (i.e.: owner,admin,moderator)) (time) (message)";
-                        return false;
-                    }
-
-                    string[] groups = arguments.At(1).Split(',');
-                    List<string> groupList = new();
-                    foreach (string s in groups)
-                    {
-                        UserGroup broadGroup = ServerStatic.PermissionsHandler.GetGroup(s);
-                        if (broadGroup != null)
-                            groupList.Add(broadGroup.BadgeText);
-
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort e) && e <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player p in Player.List)
-                        if (groupList.Contains(p.Group.BadgeText))
-                            p.ShowHint(EventHandlers.FormatArguments(arguments, 3), e);
-
-
-                    StringBuilder bdr = StringBuilderPool.Shared.Rent("Hint sent to groups with badge text: ");
-                    foreach (string p in groupList)
-                    {
-                        bdr.Append("\"");
-                        bdr.Append(p);
-                        bdr.Append("\"");
-                        bdr.Append(" ");
-                    }
-                    string ms = bdr.ToString();
-                    StringBuilderPool.Shared.Return(bdr);
-                    response = ms;
-                    return true;
-                case "role":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: hbc role (RoleTypeId) (time) (message)";
-                        return false;
-                    }
-
-                    if (!Enum.TryParse(arguments.At(1), true, out RoleTypeId role))
-                    {
-                        response = $"Invalid value for RoleTypeId: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort te) && te <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player player in Player.List)
-                    {
-                        if (player.Role == role)
-                            player.ShowHint(EventHandlers.FormatArguments(arguments, 3), te);
-                    }
-
-                    response = $"Hint sent to all members of \"{arguments.At(1)}\"";
-                    return true;
-                case "roles":
-                    if (arguments.Count < 4)
-                    {
-                        response = "Usage: hbc roles (RoleTypeId group (i.e.: ClassD, Scientist, NtfCadet)) (time) (message)";
-                        return false;
-                    }
-
-                    string[] roles = arguments.At(1).Split(',');
-                    List<RoleTypeId> roleList = new();
-                    foreach (string s in roles)
-                    {
-                        if (Enum.TryParse(s, true, out RoleTypeId r))
-                            roleList.Add(r);
-                    }
-
-                    if (!ushort.TryParse(arguments.At(2), out ushort ti) && ti <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    foreach (Player p in Player.List)
-                        if (roleList.Contains(p.Role))
-                            p.ShowHint(EventHandlers.FormatArguments(arguments, 3), ti);
-
-                    StringBuilder build = StringBuilderPool.Shared.Rent("Hint sent to roles: ");
-                    foreach (RoleTypeId ro in roleList)
-                    {
-                        build.Append("\"");
-                        build.Append(ro.ToString());
-                        build.Append("\"");
-                        build.Append(" ");
-                    }
-                    string msg = build.ToString();
-                    StringBuilderPool.Shared.Return(build);
-                    response = msg;
-                    return true;
-                case "random":
-                case "someone":
-                    if (arguments.Count < 3)
-                    {
-                        response = "Usage: hbc (random / someone) (time) (message)";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(1), out ushort me) && me <= 0)
-                    {
-                        response = $"Invalid value for duration: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    Player plyr = Player.List.ToList()[Main.NumGen.Next(0, Player.List.Count())];
-                    plyr.ShowHint(EventHandlers.FormatArguments(arguments, 2), me);
-                    response = $"Hint sent to {plyr.Nickname}";
-                    return true;
-                case "staff":
-                case "admin":
-                    if (arguments.Count < 3)
-                    {
-                        response = "Usage: hbc (staff / admin) (time) (message)";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(1), out ushort t))
-                    {
-                        response = $"Invalid value for hint broadcast time: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    foreach (Player pl in Player.List)
-                    {
-                        if (pl.ReferenceHub.serverRoles.RemoteAdmin)
-                            pl.ShowHint($"<color=orange>[Admin Hint]</color> <color=green>{EventHandlers.FormatArguments(arguments, 2)} - {((CommandSender)sender).Nickname}</color>", t);
-                    }
-
-                    response = $"Hint sent to all currently online staff";
-                    return true;
-                case "clearall":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: hbc clearall";
-                        return false;
-                    }
-
-                    foreach (Player py in Player.List)
-                        py.ShowHint(" ");
-                    response = "All hints have been cleared";
-                    return true;
-                default:
-                    if (arguments.Count < 3)
-                    {
-                        response = "Usage: hbc (time) (message)";
-                        return false;
-                    }
-
-                    if (!ushort.TryParse(arguments.At(1), out ushort tm))
-                    {
-                        response = $"Invalid value for hint broadcast time: {arguments.At(0)}";
-                        return false;
-                    }
+            RegisterCommand(new Clear());
+            RegisterCommand(new Group());
+            RegisterCommand(new User());
+        }
 
-                    foreach (Player py in Player.List)
-                        if (py.ReferenceHub.queryProcessor._ipAddress != "127.0.0.1")
-                            py.ShowHint(EventHandlers.FormatArguments(arguments, 2), tm);
-                    break;
-            }
-            response = "";
+        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response) // TODO: Make it ParentCommand
+        {
+            response = "Not a valid subcommand. Available subcommands: user, group, clear";
             return false;
         }
     }
diff --git a/AdminTools/Commands/HintBroadcast/User.cs b/AdminTools/Commands/HintBroadcast/User.cs
new file mode 100644
index 0000000..44ecc73
--- /dev/null
+++ b/AdminTools/Commands/HintBroadcast/User.cs
@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using CommandSystem;
+using Exiled.API.Features;
+
+namespace AdminTools.Commands.HintBroadcast
+{
+    internal class User : ICommand
+    {
+        public string Command { get; } = "user";
+        public string[] Aliases { get; } = Array.Empty<string>();
+        public string Description { get; } = "Sends a broadcast to multiple users";
+        
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, [UnscopedRef] out string response)
+        {
+            if (arguments.Count < 3)
+            {
+                response = "Usage: hbc user (player ids / usernames) (time) (message)";
+                return false;
+            }
+
+            IEnumerable<Player> ply = Player.GetProcessedData(arguments);
+            if (ply.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            if (!ushort.TryParse(arguments.At(1), out ushort time) && time <= 0)
+            {
+                response = $"Invalid value for duration: {arguments.At(1)}";
+                return false;
+            }
+
+            foreach (Player player in ply)
+            {
+                player.ShowHint(Extensions.FormatArguments(arguments, 2), time);
+            }
+
+            response = $"Hint sent to players";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/Hp/Hp.cs b/AdminTools/Commands/Hp/Hp.cs
deleted file mode 100644
index 042479f..0000000
--- a/AdminTools/Commands/Hp/Hp.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using RemoteAdmin;
-using System;
-
-namespace AdminTools.Commands.Hp
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Hp : ParentCommand
-    {
-        public Hp() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "athp";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Sets a user or users HP to a specified value";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!CommandProcessor.CheckPermissions(((CommandSender)sender), "hp", PlayerPermissions.PlayersManagement, "AdminTools", false))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 2)
-            {
-                response = "Usage: hp ((player id / name) or (all / *)) (value)";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    if (!int.TryParse(arguments.At(1), out int value))
-                    {
-                        response = $"Invalid value for HP: {value}";
-                        return false;
-                    }
-
-                    foreach (Player pl in Player.List)
-                    {
-                        if (value <= 0)
-                            pl.Kill("Killed by admin.");
-                        else
-                            pl.Health = value;
-                    }
-
-                    response = $"Everyone's HP was set to {value}";
-                    return true;
-                default:
-                    Player ply = Player.Get(arguments.At(0));
-                    if (ply == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (!int.TryParse(arguments.At(1), out int val))
-                    {
-                        response = $"Invalid value for HP: {val}";
-                        return false;
-                    }
-
-                    if (val <= 0)
-                        ply.Kill("Killed by admin.");
-                    else
-                        ply.Health = val;
-                    response = $"Player {ply.Nickname}'s HP was set to {val}";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Id/ID.cs b/AdminTools/Commands/Id/ID.cs
deleted file mode 100644
index f29f0b6..0000000
--- a/AdminTools/Commands/Id/ID.cs
+++ /dev/null
@@ -1,89 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using NorthwoodLib.Pools;
-using RemoteAdmin;
-using System;
-using System.Linq;
-using System.Text;
-
-namespace AdminTools.Commands.Id
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class ID : ParentCommand
-    {
-        public ID() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "atid";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Gets the player ID of a selected user";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (arguments.Count != 1)
-            {
-                response = "Usage: id ((player id / name) or (all / *))";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    StringBuilder builder = StringBuilderPool.Shared.Rent();
-                    if (Player.List.Count() == 0)
-                    {
-                        builder.AppendLine("There are no players currently online in the server");
-                        string msg = builder.ToString();
-                        StringBuilderPool.Shared.Return(builder);
-                        response = msg;
-                        return true;
-                    }
-                    else
-                    {
-                        builder.AppendLine("List of ID's on the server:");
-                        foreach (Player ply in Player.List)
-                        {
-                            builder.Append(ply.Nickname);
-                            builder.Append(" - ");
-                            builder.Append(ply.UserId);
-                            builder.Append(" - ");
-                            builder.AppendLine(ply.Id.ToString());
-                        }
-                        string msg = builder.ToString();
-                        StringBuilderPool.Shared.Return(builder);
-                        response = msg;
-                        return true;
-                    }
-                default:
-                    Player pl;
-                    if (String.IsNullOrWhiteSpace(arguments.At(0)))
-                    {
-                        if (!(sender is PlayerCommandSender plysend))
-                        {
-                            response = "You must be in-game to run this command if you specify yourself!";
-                            return false;
-                        }
-
-                        pl = Player.Get(plysend.ReferenceHub);
-                    }
-                    else
-                    {
-                        pl = Player.Get(arguments.At(0));
-                        if (pl == null)
-                        {
-                            response = "Player not found";
-                            return false;
-                        }
-                    }
-
-                    response = $"{pl.Nickname} - {pl.UserId} - {pl.Id}";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/InstantKill/Add.cs b/AdminTools/Commands/InstantKill/Add.cs
new file mode 100644
index 0000000..a39614a
--- /dev/null
+++ b/AdminTools/Commands/InstantKill/Add.cs
@@ -0,0 +1,46 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using System.Collections.Generic;
+
+namespace AdminTools.Commands.InstantKill
+{
+    public class Add : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "add";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "add instantkill to this player";
+
+        public string[] Usage { get; } = new string[] { "%player%", };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.instakill"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count != 1)
+            {
+                response = "Usage: instakill add ((player id / name) or (all / *))";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            Main.InstantKill.AddRange(players);
+
+            response = $"All the followed player have been added to InstantKill:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/InstantKill/InstantKill.cs b/AdminTools/Commands/InstantKill/InstantKill.cs
index 1ccb088..a6aba58 100644
--- a/AdminTools/Commands/InstantKill/InstantKill.cs
+++ b/AdminTools/Commands/InstantKill/InstantKill.cs
@@ -1,145 +1,42 @@
 using CommandSystem;
-using Exiled.API.Features;
 using Exiled.Permissions.Extensions;
-using NorthwoodLib.Pools;
 using System;
-using System.Text;
 
 namespace AdminTools.Commands.InstantKill
 {
     [CommandHandler(typeof(RemoteAdminCommandHandler))]
     [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class InstantKill : ParentCommand
+    public class InstantKill : ParentCommand, IUsageProvider
     {
-        public InstantKill() => LoadGeneratedCommands();
+        public override string Command { get; } = "instantkill";
 
-        public override string Command { get; } = "instakill";
-
-        public override string[] Aliases { get; } = new string[] { "ik" };
+        public override string[] Aliases { get; } = new string[] { "ik", "instakill" };
 
         public override string Description { get; } = "Manage instant kill properties for users";
 
-        public override void LoadGeneratedCommands() { }
+        public string[] Usage { get; } = new string[] { "Add or Remove or List", };
+
+        public override void LoadGeneratedCommands()
+        {
+            RegisterCommand(new Add());
+            RegisterCommand(new Remove());
+            RegisterCommand(new List());
+        }
 
         protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.ik"))
+            if (!sender.CheckPermission("at.instakill"))
             {
                 response = "You do not have permission to use this command";
                 return false;
             }
 
-            if (arguments.Count < 1)
-            {
-                response = "Usage:\ninstakill ((player id / name) or (all / *))" +
-                    "\ninstakill clear" +
-                    "\ninstakill list" +
-                    "\ninstakill remove (player id / name)";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "clear":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: instakill clear";
-                        return false;
-                    }
-
-                    foreach (Player ply in Main.IkHubs.Keys)
-                        if (ply.ReferenceHub.TryGetComponent(out InstantKillComponent ikCom))
-                            UnityEngine.Object.Destroy(ikCom);
+            response = "Usage:" +
+                "\nInstantKill add ((player id / name) or (all / *))" +
+                "\nInstantKill list" +
+                "\nInstantKill remove (player id / name) or (all / *))";
+            return false;
 
-                    response = "Instant killing has been removed from everyone";
-                    return true;
-                case "list":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: instakill clear";
-                        return false;
-                    }
-
-                    StringBuilder playerLister = StringBuilderPool.Shared.Rent(Main.IkHubs.Count != 0 ? "Players with instant killing on:\n" : "No players currently online have instant killing on");
-                    if (Main.IkHubs.Count == 0)
-                    {
-                        response = playerLister.ToString();
-                        return true;
-                    }
-
-                    foreach (Player ply in Main.IkHubs.Keys)
-                    {
-                        playerLister.Append(ply.Nickname);
-                        playerLister.Append(", ");
-                    }
-
-                    string msg = playerLister.ToString().Substring(0, playerLister.ToString().Length - 2);
-                    StringBuilderPool.Shared.Return(playerLister);
-                    response = msg;
-                    return true;
-                case "remove":
-                    if (arguments.Count != 2)
-                    {
-                        response = "Usage: instakill remove (player id / name)";
-                        return false;
-                    }
-
-                    Player pl = Player.Get(arguments.At(1));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (pl.ReferenceHub.TryGetComponent(out InstantKillComponent ikComponent))
-                    {
-                        Main.IkHubs.Remove(pl);
-                        UnityEngine.Object.Destroy(ikComponent);
-                        response = $"Instant killing is off for {pl.Nickname} now";
-                    }
-                    else
-                        response = $"Player {pl.Nickname} does not have the ability to instantly kill others";
-                    return true;
-                case "*":
-                case "all":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: instakill all / *";
-                        return false;
-                    }
-
-                    foreach (Player ply in Player.List)
-                        if (!ply.ReferenceHub.TryGetComponent(out InstantKillComponent _))
-                            ply.ReferenceHub.gameObject.AddComponent<InstantKillComponent>();
-
-                    response = "Everyone on the server can instantly kill other users now";
-                    return true;
-                default:
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: instakill (player id / name)";
-                        return false;
-                    }
-
-                    Player plyr = Player.Get(arguments.At(0));
-                    if (plyr == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (!plyr.ReferenceHub.TryGetComponent(out InstantKillComponent ikComp))
-                    {
-                        plyr.GameObject.AddComponent<InstantKillComponent>();
-                        response = $"Instant killing is on for {plyr.Nickname}";
-                    }
-                    else
-                    {
-                        UnityEngine.Object.Destroy(ikComp);
-                        response = $"Instant killing is off for {plyr.Nickname}";
-                    }
-                    return true;
-            }
         }
     }
 }
diff --git a/AdminTools/Commands/InstantKill/List.cs b/AdminTools/Commands/InstantKill/List.cs
new file mode 100644
index 0000000..7bbae12
--- /dev/null
+++ b/AdminTools/Commands/InstantKill/List.cs
@@ -0,0 +1,35 @@
+using CommandSystem;
+using Exiled.API.Features.Pools;
+using Exiled.Permissions.Extensions;
+using System;
+using System.Linq;
+using System.Text;
+
+namespace AdminTools.Commands.InstantKill
+{
+    public class List : ICommand
+    {
+        public string Command { get; } = "list";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Get a list of every player with InstantKill enabled.";
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.instakill"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            StringBuilder playerLister = StringBuilderPool.Pool.Get();
+
+            playerLister.Append(Main.InstantKill.Any() ? "Players with InstantKill enabled:\n" : "No players currently online have instant killing on");
+            playerLister.Append(Extensions.LogPlayers(Main.InstantKill));
+
+            response = StringBuilderPool.Pool.ToStringReturn(playerLister);
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/InstantKill/Remove.cs b/AdminTools/Commands/InstantKill/Remove.cs
new file mode 100644
index 0000000..8330836
--- /dev/null
+++ b/AdminTools/Commands/InstantKill/Remove.cs
@@ -0,0 +1,52 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace AdminTools.Commands.InstantKill
+{
+    internal class Remove : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "remove";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Disable InstantKill from this player.";
+
+        public string[] Usage { get; } = new string[] { "%player%", };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.instakill"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count != 1)
+            {
+                response = "Usage: instakill remove ((player id / name) or (all / *))";
+                return false;
+            }
+
+            List<Player> players = Player.GetProcessedData(arguments).ToList();
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            for (int i = players.Count; i < 0; i--)
+            {
+                Player ply = players[i];
+                if (!Main.InstantKill.Remove(ply))
+                    players.Remove(ply);
+            }
+
+            response = $"Every player has been removed from InstantKill:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/Inventory/Drop.cs b/AdminTools/Commands/Inventory/Drop.cs
index c8242b0..2f09dc5 100644
--- a/AdminTools/Commands/Inventory/Drop.cs
+++ b/AdminTools/Commands/Inventory/Drop.cs
@@ -2,30 +2,26 @@
 using Exiled.API.Features;
 using Exiled.Permissions.Extensions;
 using System;
+using System.Collections.Generic;
 
 namespace AdminTools.Commands.Inventory
 {
     [CommandHandler(typeof(RemoteAdminCommandHandler))]
     [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Drop : ParentCommand
+    public class Drop : ICommand, IUsageProvider
     {
-        public Drop() => LoadGeneratedCommands();
+        public string Command { get; } = "drop";
 
-        public override string Command { get; } = "drop";
+        public string[] Aliases { get; } = Array.Empty<string>();
 
-        public override string[] Aliases { get; } = new string[] { };
+        public string Description { get; } = "Drops the items in a players inventory";
 
-        public override string Description { get; } = "Drops the items in a players inventory";
+        public string[] Usage { get; } = new string[] { "%player%", };
 
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.inv"))
-            {
-                response = "You do not have permission to use this command";
+            if (!sender.CheckPermission(PlayerPermissions.GivingItems, out response))
                 return false;
-            }
 
             if (arguments.Count != 1)
             {
@@ -33,27 +29,18 @@ protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSe
                 return false;
             }
 
-            switch (arguments.At(0))
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
             {
-                case "*":
-                case "all":
-                    foreach (Player ply in Player.List)
-                        ply.DropItems();
-
-                    response = "All items from everyones inventories has been dropped";
-                    return true;
-                default:
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    pl.DropItems();
-                    response = $"All items from {pl.Nickname}'s inventory has been dropped";
-                    return true;
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
             }
+
+            foreach (Player p in players)
+                p.DropItems();
+
+            response = $"All items have been dropped from the following players: \n{Extensions.LogPlayers(players)}";
+            return true;
         }
     }
 }
\ No newline at end of file
diff --git a/AdminTools/Commands/Inventory/Inventory.cs b/AdminTools/Commands/Inventory/Inventory.cs
index 39fe861..42ae791 100644
--- a/AdminTools/Commands/Inventory/Inventory.cs
+++ b/AdminTools/Commands/Inventory/Inventory.cs
@@ -6,7 +6,7 @@ namespace AdminTools.Commands.Inventory
 {
     [CommandHandler(typeof(RemoteAdminCommandHandler))]
     [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Inventory : ParentCommand
+    public class Inventory : ParentCommand, IUsageProvider
     {
         public Inventory() => LoadGeneratedCommands();
 
@@ -16,6 +16,8 @@ public class Inventory : ParentCommand
 
         public override string Description { get; } = "Manages player inventories";
 
+        public string[] Usage { get; } = new string[] { "drop / see", };
+
         public override void LoadGeneratedCommands()
         {
             RegisterCommand(new Drop());
@@ -24,11 +26,8 @@ public override void LoadGeneratedCommands()
 
         protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.inv"))
-            {
-                response = "You do not have permission to use this command";
+            if (!sender.CheckPermission(PlayerPermissions.GivingItems, out response))
                 return false;
-            }
 
             response = "Invalid subcommand. Available ones: drop, see";
             return false;
diff --git a/AdminTools/Commands/Inventory/See.cs b/AdminTools/Commands/Inventory/See.cs
index d8fa1eb..e59d407 100644
--- a/AdminTools/Commands/Inventory/See.cs
+++ b/AdminTools/Commands/Inventory/See.cs
@@ -13,17 +13,16 @@ public class See : ICommand
     {
         public string Command { get; } = "see";
 
-        public string[] Aliases { get; } = new string[] { };
+        public string[] Aliases { get; } = Array.Empty<string>();
 
         public string Description { get; } = "Sees the inventory items a user has";
 
+        public string[] Usage { get; } = new string[] { "%player%", };
+
         public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.inv"))
-            {
-                response = "You do not have permission to use this command";
+            if (!sender.CheckPermission(PlayerPermissions.GivingItems, out response))
                 return false;
-            }
 
             if (arguments.Count != 1)
             {
diff --git a/AdminTools/Commands/Jail.cs b/AdminTools/Commands/Jail.cs
new file mode 100644
index 0000000..1297345
--- /dev/null
+++ b/AdminTools/Commands/Jail.cs
@@ -0,0 +1,127 @@
+using CommandSystem;
+using Exiled.API.Enums;
+using Exiled.API.Extensions;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using PlayerRoles;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Jail : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "jail";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Jails or unjails a user";
+
+        public string[] Usage { get; } = new string[] { "%player%", "[IsJail]"};
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.jail"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count < 1)
+            {
+                response = "Usage: jail (player id / name) [true/false]";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+            
+            bool? isJail = null;
+            if (bool.TryParse(arguments.ElementAtOrDefault(1), out bool result))
+                isJail = result;
+
+            foreach (Player ply in players)
+            {
+                
+                if (isJail is true)
+                    DoJail(ply);
+                else if (isJail is false)
+                    DoUnJail(ply);
+                else
+                {
+                    if (Main.JailedPlayers.ContainsKey(ply.UserId))
+                        DoUnJail(ply);
+                    else
+                        DoJail(ply);
+                }
+            }
+            response = $"Jail command has run successfully.\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+        public static void DoJail(Player player, bool skipadd = false)
+        {
+            if (Main.JailedPlayers.ContainsKey(player.UserId))
+                return;
+            if (!skipadd)
+            {
+                Main.JailedPlayers.Add(player.UserId, new Jailed
+                {
+                    Health = player.Health,
+                    RelativePosition = player.RelativePosition,
+                    Items = player.Items.ToList(),
+                    Effects = player.ActiveEffects.Select(x => new Effect(x)).ToList(),
+                    Name = player.Nickname,
+                    Role = player.Role.Type,
+                    CurrentRound = true,
+                    Ammo = player.Ammo.ToDictionary(x => x.Key.GetAmmoType(), x => x.Value),
+                });
+            }
+
+            if (player.IsOverwatchEnabled)
+                player.IsOverwatchEnabled = false;
+            player.Ammo.Clear();
+            player.Inventory.SendAmmoNextFrame = true;
+
+            player.ClearInventory(false);
+            player.Role.Set(RoleTypeId.Tutorial, RoleSpawnFlags.UseSpawnpoint);
+        }
+
+        public static void DoUnJail(Player player)
+        {
+            if (!Main.JailedPlayers.TryGetValue(player.UserId, out Jailed jail))
+                return;
+            if (jail.CurrentRound)
+            {
+                player.Role.Set(jail.Role, RoleSpawnFlags.None);
+                try
+                {
+                    player.ResetInventory(jail.Items);
+                    player.Health = jail.Health;
+                    player.Position = jail.RelativePosition.Position;
+                    foreach (KeyValuePair<AmmoType, ushort> kvp in jail.Ammo)
+                        player.Ammo[kvp.Key.GetItemType()] = kvp.Value;
+                    player.SyncEffects(jail.Effects);
+
+                    player.Inventory.SendItemsNextFrame = true;
+                    player.Inventory.SendAmmoNextFrame = true;
+                }
+                catch (Exception e)
+                {
+                    Log.Error($"{nameof(DoUnJail)}: {e}");
+                }
+            }
+            else
+            {
+                player.Role.Set(RoleTypeId.Spectator);
+            }
+            Main.JailedPlayers.Remove(player.UserId);
+        }
+    }
+}
diff --git a/AdminTools/Commands/Jail/Jail.cs b/AdminTools/Commands/Jail/Jail.cs
deleted file mode 100644
index 5784dc7..0000000
--- a/AdminTools/Commands/Jail/Jail.cs
+++ /dev/null
@@ -1,67 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using MEC;
-using System;
-using System.Linq;
-
-namespace AdminTools.Commands.Jail
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Jail : ParentCommand
-    {
-        public Jail() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "jail";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Jails or unjails a user";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.jail"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 1)
-            {
-                response = "Usage: jail (player id / name)";
-                return false;
-            }
-
-            Player ply = Player.Get(arguments.At(0));
-            if (ply == null)
-            {
-                response = $"Player not found: {arguments.At(0)}";
-                return false;
-            }
-
-            if (Main.JailedPlayers.Any(j => j.Userid == ply.UserId))
-            {
-                try
-                {
-                    EventHandlers.DoUnJail(ply);
-                    response = $"Player {ply.Nickname} has been unjailed now";
-                }
-                catch (Exception e)
-                {
-                    Log.Error($"{e}");
-                    response = "Command failed. Check server log.";
-                    return false;
-                }
-            }
-            else
-            {
-                EventHandlers.DoJail(ply);
-                response = $"Player {ply.Nickname} has been jailed now";
-            }
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Kick/Kick.cs b/AdminTools/Commands/Kick/Kick.cs
deleted file mode 100644
index 6256635..0000000
--- a/AdminTools/Commands/Kick/Kick.cs
+++ /dev/null
@@ -1,56 +0,0 @@
-using CommandSystem;
-using Exiled.Permissions.Extensions;
-using System;
-using UnityEngine;
-
-namespace AdminTools.Commands.Kick
-{
-    using Exiled.API.Features;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Kick : ParentCommand
-    {
-        public Kick() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "kick";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Kicks a player from the game with a custom reason";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.kick"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 2)
-            {
-                response = "Usage: kick (player id / name) (reason)";
-                return false;
-            }
-
-            Player ply = Player.Get(arguments.At(0));
-            if (ply == null)
-            {
-                response = $"Player not found: {arguments.At(0)}";
-                return false;
-            }
-
-            if(ply.ReferenceHub.serverRoles.Group != null && ply.ReferenceHub.serverRoles.Group.RequiredKickPower > ((CommandSender)sender).KickPower)
-            {
-                response = $"You do not have permission to kick the specified player";
-                return false;
-            }
-
-            ply.Kick(EventHandlers.FormatArguments(arguments, 1));
-            response = $"Player {ply.Nickname} has been kicked for \"{EventHandlers.FormatArguments(arguments, 1)}\"";
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Kill/Kill.cs b/AdminTools/Commands/Kill/Kill.cs
deleted file mode 100644
index db3e0d4..0000000
--- a/AdminTools/Commands/Kill/Kill.cs
+++ /dev/null
@@ -1,71 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.Kill
-{
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Kill : ParentCommand
-    {
-        public Kill() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "atkill";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Kills everyone or a user instantly";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.kill"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 1)
-            {
-                response = "Usage: kill ((player id / name) or (all / *))";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    foreach (Player ply in Player.List)
-                    {
-                        if (ply.Role == RoleTypeId.Spectator || ply.Role == RoleTypeId.None)
-                            continue;
-
-                        ply.Kill("Killed by admin.");
-                    }
-
-                    response = "Everyone has been game ended (killed) now";
-                    return true;
-                default:
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-                    else if (pl.Role == RoleTypeId.Spectator || pl.Role == RoleTypeId.None)
-                    {
-                        response = $"Player {pl.Nickname} is not a valid class to kill";
-                        return false;
-                    }
-
-                    pl.Kill("Killed by admin.");
-                    response = $"Player {pl.Nickname} has been game ended (killed) now";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Mute/All.cs b/AdminTools/Commands/Mute/All.cs
index 17f98f2..dccad60 100644
--- a/AdminTools/Commands/Mute/All.cs
+++ b/AdminTools/Commands/Mute/All.cs
@@ -15,7 +15,7 @@ public class All : ICommand
 
         public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.mute"))
+            if (!sender.CheckPermission("at.mute"))
             {
                 response = "You do not have permission to use this command";
                 return false;
diff --git a/AdminTools/Commands/Mute/ICom.cs b/AdminTools/Commands/Mute/ICom.cs
index 2258ed3..f53cf1e 100644
--- a/AdminTools/Commands/Mute/ICom.cs
+++ b/AdminTools/Commands/Mute/ICom.cs
@@ -9,13 +9,13 @@ public class Com : ICommand
     {
         public string Command { get; } = "icom";
 
-        public string[] Aliases { get; } = new string[] { };
+        public string[] Aliases { get; } = Array.Empty<string>();
 
         public string Description { get; } = "Intercom mutes everyone in the server";
 
         public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.mute"))
+            if (!sender.CheckPermission("at.mute"))
             {
                 response = "You do not have permission to use this command";
                 return false;
diff --git a/AdminTools/Commands/Mute/Mute.cs b/AdminTools/Commands/Mute/Mute.cs
index e2c3f19..433ded0 100644
--- a/AdminTools/Commands/Mute/Mute.cs
+++ b/AdminTools/Commands/Mute/Mute.cs
@@ -12,7 +12,7 @@ public class Mute : ParentCommand
 
         public override string Command { get; } = "pmute";
 
-        public override string[] Aliases { get; } = new string[] { };
+        public override string[] Aliases { get; } = Array.Empty<string>();
 
         public override string Description { get; } = "Mutes everyone from speaking or by intercom in the server";
 
@@ -25,7 +25,7 @@ public override void LoadGeneratedCommands()
 
         protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.mute"))
+            if (!sender.CheckPermission("at.mute"))
             {
                 response = "You do not have permission to use this command";
                 return false;
diff --git a/AdminTools/Commands/Mute/RoundStart.cs b/AdminTools/Commands/Mute/RoundStart.cs
index 9d04250..1dff2c2 100644
--- a/AdminTools/Commands/Mute/RoundStart.cs
+++ b/AdminTools/Commands/Mute/RoundStart.cs
@@ -15,7 +15,7 @@ public class RoundStart : ICommand
 
         public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.mute"))
+            if (!sender.CheckPermission("at.mute"))
             {
                 response = "You do not have permission to use this command";
                 return false;
@@ -35,7 +35,7 @@ public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out s
 
             foreach (Player player in Player.List)
             {
-                if(!player.IsMuted && !player.ReferenceHub.serverRoles.RemoteAdmin)
+                if (!player.IsMuted && !player.ReferenceHub.serverRoles.RemoteAdmin)
                 {
                     player.IsMuted = true;
                     Main.RoundStartMutes.Add(player);
diff --git a/AdminTools/Commands/Position.cs b/AdminTools/Commands/Position.cs
new file mode 100644
index 0000000..257b0d0
--- /dev/null
+++ b/AdminTools/Commands/Position.cs
@@ -0,0 +1,160 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using NorthwoodLib.Pools;
+using System;
+using System.Collections.Generic;
+using System.Text;
+using UnityEngine;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Position : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "position";
+
+        public string[] Aliases { get; } = new string[] { "pos" };
+
+        public string Description { get; } = "Modifies or retrieves the position of a user or all users";
+
+        public string[] Usage { get; } = new string[] { "%player%", string.Join(", ", Enum.GetNames(typeof(PositionModifier))), };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response) // TODO: Make it ParentCommand
+        {
+            if (!sender.CheckPermission("at.tp"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count < 1)
+            {
+                response = response = "\nUsage:\nposition ((player id / name) or (all / *)) (set) (x position) (y position) (z position)\nposition ((player id / name) or (all / *)) (get)\nposition ((player id / name) or (all / *))(add) (x, y, or z) (value)";
+                return false;
+            }
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+            if (!Enum.TryParse(arguments.At(1), true, out PositionModifier mod))
+            {
+                response = $"Invalid position modifier: {arguments.At(0)}";
+                return false;
+            }
+
+            switch (mod)
+            {
+                case PositionModifier.Set:
+                    if (arguments.Count != 5)
+                    {
+                        response = "Usage: position (all / *) (set) (x position) (y position) (z position)";
+                        return false;
+                    }
+                    if (!float.TryParse(arguments.At(2), out float xval))
+                    {
+                        response = $"Invalid value for x position: {arguments.At(2)}";
+                        return false;
+                    }
+                    if (!float.TryParse(arguments.At(3), out float yval))
+                    {
+                        response = $"Invalid value for y position: {arguments.At(3)}";
+                        return false;
+                    }
+                    if (!float.TryParse(arguments.At(4), out float zval))
+                    {
+                        response = $"Invalid value for z position: {arguments.At(4)}";
+                        return false;
+                    }
+                    if (players.IsEmpty())
+                    {
+                        response = "There are no players found";
+                        return false;
+                    }
+                    foreach (Player ply in players)
+                    {
+                        ply.Position = new Vector3(xval, yval, zval);
+                    }
+                    response = $"All player's positions have been set to {xval} {yval} {zval}";
+                    return true;
+                case PositionModifier.Get:
+                    if (arguments.Count != 2)
+                    {
+                        response = "Usage: position (all / *) (get)";
+                        return false;
+                    }
+                    StringBuilder positionBuilder = StringBuilderPool.Shared.Rent();
+                    if (players.IsEmpty())
+                    {
+                        response = "No players match your query.";
+                        return false;
+                    }
+                    positionBuilder.Append("\n");
+                    foreach (Player ply in players)
+                    {
+                        positionBuilder.Append(ply.Nickname);
+                        positionBuilder.Append("'s (");
+                        positionBuilder.Append(ply.Id);
+                        positionBuilder.Append(")");
+                        positionBuilder.Append(" position: ");
+                        positionBuilder.Append(ply.Position.x);
+                        positionBuilder.Append(" ");
+                        positionBuilder.Append(ply.Position.y);
+                        positionBuilder.Append(" ");
+                        positionBuilder.AppendLine(ply.Position.z.ToString());
+                    }
+                    string message = positionBuilder.ToString();
+                    StringBuilderPool.Shared.Return(positionBuilder);
+                    response = message;
+                    return true;
+                case PositionModifier.Add:
+                    if (arguments.Count != 4)
+                    {
+                        response = "Usage: position (all / *) (add) (x, y, or z) (value)";
+                        return false;
+                    }
+                    if (!Enum.TryParse(arguments.At(2), true, out VectorAxis axis))
+                    {
+                        response = $"Invalid value for vector axis ({string.Join(", ", Enum.GetNames(typeof(PositionModifier)))}): {arguments.At(2)}";
+                        return false;
+                    }
+                    if (!float.TryParse(arguments.At(3), out float val))
+                    {
+                        response = $"Invalid value for position: {arguments.At(3)}";
+                        return false;
+                    }
+                    switch (axis)
+                    {
+                        case VectorAxis.X:
+                            foreach (Player ply in players)
+                                ply.Position = new Vector3(ply.Position.x + val, ply.Position.y, ply.Position.z);
+
+                            response = $"Every player's x position has been nudged by {val}";
+                            return true;
+                        case VectorAxis.Y:
+                            foreach (Player ply in players)
+                                ply.Position = new Vector3(ply.Position.x, ply.Position.y + val, ply.Position.z);
+
+                            response = $"Every player's y position has been nudge by {val}";
+                            return true;
+                        case VectorAxis.Z:
+                            foreach (Player ply in players)
+                                ply.Position = new Vector3(ply.Position.x, ply.Position.y, ply.Position.z + val);
+
+                            response = $"Every player's z position has been nudged by {val}";
+                            return true;
+                        default:
+                            response = "\nUsage:\nposition (all / *) (set) (x position) (y position) (z position)\nposition (all / *) (get)\nposition (all / *) (add) (x, y, or z) (value)";
+                            return false;
+                    }
+                    
+                default:
+                    response = "\nUsage:\nposition (all / *) (set) (x position) (y position) (z position)\nposition (all / *) (get)\nposition (all / *) (add) (x, y, or z) (value)";
+                    return false;
+            }
+        }
+    }
+}
diff --git a/AdminTools/Commands/Position/Position.cs b/AdminTools/Commands/Position/Position.cs
deleted file mode 100644
index 093c711..0000000
--- a/AdminTools/Commands/Position/Position.cs
+++ /dev/null
@@ -1,249 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using NorthwoodLib.Pools;
-using System;
-using System.Linq;
-using System.Text;
-using UnityEngine;
-
-namespace AdminTools.Commands.Position
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Position : ParentCommand
-    {
-        public Position() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "positon";
-
-        public override string[] Aliases { get; } = new string[] { "pos" };
-
-        public override string Description { get; } = "Modifies or retrieves the position of a user or all users";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.tp"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 1)
-            {
-                response = response = "\nUsage:\nposition ((player id / name) or (all / *)) (set) (x position) (y position) (z position)\nposition ((player id / name) or (all / *)) (get)\nposition ((player id / name) or (all / *))(add) (x, y, or z) (value)";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    if (!Enum.TryParse(arguments.At(1), true, out PositionModifier mod))
-                    {
-                        response = $"Invalid position modifier: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    switch (mod)
-                    {
-                        case PositionModifier.Set:
-                            if (arguments.Count != 5)
-                            {
-                                response = "Usage: position (all / *) (set) (x position) (y position) (z position)";
-                                return false;
-                            }
-                            if (!float.TryParse(arguments.At(2), out float xval))
-                            {
-                                response = $"Invalid value for x position: {arguments.At(2)}";
-                                return false;
-                            }
-                            if (!float.TryParse(arguments.At(3), out float yval))
-                            {
-                                response = $"Invalid value for x position: {arguments.At(3)}";
-                                return false;
-                            }
-                            if (!float.TryParse(arguments.At(4), out float zval))
-                            {
-                                response = $"Invalid value for x position: {arguments.At(4)}";
-                                return false;
-                            }
-                            if (Player.List.Count() == 0)
-                            {
-                                response = "There are no players currently online";
-                                return true;
-                            }
-                            foreach (Player ply in Player.List)
-                            {
-                                ply.Position = new Vector3(xval, yval, zval);
-                            }
-                            response = $"All player's positions have been set to {xval} {yval} {zval}";
-                            return true;
-                        case PositionModifier.Get:
-                            if (arguments.Count != 2)
-                            {
-                                response = "Usage: position (all / *) (get)";
-                                return false;
-                            }
-                            StringBuilder positionBuilder = StringBuilderPool.Shared.Rent();
-                            if (Player.List.Count() == 0)
-                            {
-                                response = "There are no players currently online";
-                                return true;
-                            }
-                            positionBuilder.Append("\n");
-                            foreach (Player ply in Player.List)
-                            {
-                                positionBuilder.Append(ply.Nickname);
-                                positionBuilder.Append("'s (");
-                                positionBuilder.Append(ply.Id);
-                                positionBuilder.Append(")");
-                                positionBuilder.Append(" position: ");
-                                positionBuilder.Append(ply.Position.x);
-                                positionBuilder.Append(" ");
-                                positionBuilder.Append(ply.Position.y);
-                                positionBuilder.Append(" ");
-                                positionBuilder.AppendLine(ply.Position.z.ToString());
-                            }
-                            string message = positionBuilder.ToString();
-                            StringBuilderPool.Shared.Return(positionBuilder);
-                            response = message;
-                            return true;
-                        case PositionModifier.Add:
-                            if (arguments.Count != 4)
-                            {
-                                response = "Usage: position (all / *) (add) (x, y, or z) (value)";
-                                return false;
-                            }
-                            if (!Enum.TryParse(arguments.At(2), true, out VectorAxis axis))
-                            {
-                                response = $"Invalid value for vector axis: {arguments.At(2)}";
-                                return false;
-                            }
-                            if (!float.TryParse(arguments.At(3), out float val))
-                            {
-                                response = $"Invalid value for position: {arguments.At(3)}";
-                                return false;
-                            }
-                            switch (axis)
-                            {
-                                case VectorAxis.X:
-                                    foreach (Player ply in Player.List)
-                                        ply.Position = new Vector3(ply.Position.x + val, ply.Position.y, ply.Position.z);
-
-                                    response = $"Every player's x position has been added by {val}";
-                                    return true;
-                                case VectorAxis.Y:
-                                    foreach (Player ply in Player.List)
-                                        ply.Position = new Vector3(ply.Position.x, ply.Position.y + val, ply.Position.z);
-
-                                    response = $"Every player's y position has been added by {val}";
-                                    return true;
-                                case VectorAxis.Z:
-                                    foreach (Player ply in Player.List)
-                                        ply.Position = new Vector3(ply.Position.x, ply.Position.y, ply.Position.z + val);
-
-                                    response = $"Every player's z position has been added by {val}";
-                                    return true;
-                            }
-                            break;
-                        default:
-                            response = "\nUsage:\nposition (all / *) (set) (x position) (y position) (z position)\nposition (all / *) (get)\nposition (all / *) (add) (x, y, or z) (value)";
-                            return false;
-                    }
-                    break;
-                default:
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (!Enum.TryParse(arguments.At(1), true, out PositionModifier modf))
-                    {
-                        response = $"Invalid position modifier: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    switch (modf)
-                    {
-                        case PositionModifier.Set:
-                            if (arguments.Count != 5)
-                            {
-                                response = "Usage: position (player id / name) (set) (x position) (y position) (z position)";
-                                return false;
-                            }
-                            if (!float.TryParse(arguments.At(2), out float xval))
-                            {
-                                response = $"Invalid value for x position: {arguments.At(2)}";
-                                return false;
-                            }
-                            if (!float.TryParse(arguments.At(3), out float yval))
-                            {
-                                response = $"Invalid value for x position: {arguments.At(3)}";
-                                return false;
-                            }
-                            if (!float.TryParse(arguments.At(4), out float zval))
-                            {
-                                response = $"Invalid value for x position: {arguments.At(4)}";
-                                return false;
-                            }
-
-                            pl.Position = new Vector3(xval, yval, zval);
-                            response = $"Player {pl.Nickname}'s positions have been set to {xval} {yval} {zval}";
-                            return true;
-                        case PositionModifier.Get:
-                            if (arguments.Count != 2)
-                            {
-                                response = "Usage: position (player id / name) (get)";
-                                return false;
-                            }
-
-                            response = $"Player {pl.Nickname}'s ({pl.Id}) position is {pl.Position.x} {pl.Position.y} {pl.Position.z}";
-                            return true;
-                        case PositionModifier.Add:
-                            if (arguments.Count != 4)
-                            {
-                                response = "Usage: position (player id / name) (add) (x, y, or z) (value)";
-                                return false;
-                            }
-                            if (!Enum.TryParse(arguments.At(2), true, out VectorAxis axis))
-                            {
-                                response = $"Invalid value for vector axis: {arguments.At(2)}";
-                                return false;
-                            }
-                            if (!float.TryParse(arguments.At(3), out float val))
-                            {
-                                response = $"Invalid value for position: {arguments.At(2)}";
-                                return false;
-                            }
-                            switch (axis)
-                            {
-                                case VectorAxis.X:
-                                    pl.Position = new Vector3(pl.Position.x + val, pl.Position.y, pl.Position.z);
-                                    response = $"Player {pl.Nickname}'s x position has been added by {val}";
-                                    return true;
-                                case VectorAxis.Y:
-                                    pl.Position = new Vector3(pl.Position.x, pl.Position.y + val, pl.Position.z);
-                                    response = $"Player {pl.Nickname}'s y position has been added by {val}";
-                                    return true;
-                                case VectorAxis.Z:
-                                    pl.Position = new Vector3(pl.Position.x, pl.Position.y, pl.Position.z + val);
-                                    response = $"Player {pl.Nickname}'s z position has been added by {val}";
-                                    return true;
-                            }
-                            break;
-                        default:
-                            response = "\nUsage:\nposition (player id / name) (set) (x position) (y position) (z position)\nposition (player id / name) (get)\nposition (player id / name) (add) (x, y, or z) (value)";
-                            return false;
-                    }
-                    break;
-            }
-            response = "Something did not go right, the command should not reach this point";
-            return false;
-        }
-    }
-}
diff --git a/AdminTools/Commands/PryGates/PryGates.cs b/AdminTools/Commands/PryGate/PryGates.cs
similarity index 51%
rename from AdminTools/Commands/PryGates/PryGates.cs
rename to AdminTools/Commands/PryGate/PryGates.cs
index aa0c4c7..185d78a 100644
--- a/AdminTools/Commands/PryGates/PryGates.cs
+++ b/AdminTools/Commands/PryGate/PryGates.cs
@@ -3,27 +3,26 @@
 using Exiled.Permissions.Extensions;
 using NorthwoodLib.Pools;
 using System;
+using System.Collections.Generic;
 using System.Text;
 
-namespace AdminTools.Commands.PryGates
+namespace AdminTools.Commands.PryGate
 {
     [CommandHandler(typeof(RemoteAdminCommandHandler))]
     [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class PryGates : ParentCommand
+    public class PryGates : ICommand, IUsageProvider
     {
-        public PryGates() => LoadGeneratedCommands();
+        public string Command { get; } = "prygate";
 
-        public override string Command { get; } = "prygate";
+        public string[] Aliases { get; } = Array.Empty<string>();
 
-        public override string[] Aliases { get; } = new string[] { };
+        public string Description { get; } = "Gives the ability to pry gates to players, clear the ability from players, and shows who has the ability";
 
-        public override string Description { get; } = "Gives the ability to pry gates to players, clear the ability from players, and shows who has the ability";
+        public string[] Usage { get; } = new string[] { "%player%", };
 
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.prygate"))
+            if (!sender.CheckPermission("at.prygate"))
             {
                 response = "You do not have permission to use this command";
                 return false;
@@ -38,6 +37,8 @@ protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSe
                 return false;
             }
 
+            IEnumerable<Player> players;
+
             switch (arguments.At(0))
             {
                 case "clear":
@@ -47,7 +48,7 @@ protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSe
                         return false;
                     }
 
-                    Main.PryGateHubs.Clear();
+                    Main.PryGate.Clear();
                     response = "The ability to pry gates is cleared from all players now";
                     return true;
                 case "list":
@@ -57,10 +58,10 @@ protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSe
                         return false;
                     }
 
-                    StringBuilder playerLister = StringBuilderPool.Shared.Rent(Main.PryGateHubs.Count != 0 ? "Players with the ability to pry gates:\n" : "No players currently online have the ability to pry gates");
-                    if (Main.PryGateHubs.Count > 0)
+                    StringBuilder playerLister = StringBuilderPool.Shared.Rent(Main.PryGate.Count != 0 ? "Players with the ability to pry gates:\n" : "No players currently online have the ability to pry gates");
+                    if (Main.PryGate.Count > 0)
                     {
-                        foreach (Player ply in Main.PryGateHubs)
+                        foreach (Player ply in Main.PryGate)
                             playerLister.Append(ply.Nickname + ", ");
 
                         int length = playerLister.ToString().Length;
@@ -81,63 +82,43 @@ protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSe
                         return false;
                     }
 
-                    Player plyr = Player.Get(arguments.At(1));
-                    if (plyr == null)
+                    players = Player.GetProcessedData(arguments, 1);
+
+                    if (players.IsEmpty())
                     {
                         response = $"Player not found: {arguments.At(1)}";
                         return false;
                     }
-
-                    if (Main.PryGateHubs.Contains(plyr))
+                    response = string.Empty;
+                    foreach (Player ply in players)
                     {
-                        Main.PryGateHubs.Remove(plyr);
-                        response = $"Player \"{plyr.Nickname}\" cannot pry gates open now";
+                        if (Main.PryGate.Remove(ply))
+                        {
+                            response += $"Player \"{ply.Nickname}\" can no longer pry gates open";
+                            continue;
+                        }
+                        response += $"Player {ply.Nickname} doesn't have the ability to pry gates open";
                     }
-                    else
-                        response = $"Player {plyr.Nickname} does not have the ability to pry gates open";
                     return true;
-                case "*":
-                case "all":
+                default:
                     if (arguments.Count != 1)
                     {
                         response = "Usage: prygates (all / *)";
                         return false;
                     }
+                    players = Player.GetProcessedData(arguments);
 
-                    foreach (Player ply in Player.List)
-                    {
-                        if (!Main.PryGateHubs.Contains(ply))
-                            Main.PryGateHubs.Add(ply);
-                    }
-
-                    response = "The ability to pry gates open is on for all players now";
-                    return true;
-                default:
-                    if (arguments.Count != 1)
+                    if (players.IsEmpty())
                     {
-                        response = "Usage: prygate (player id / name)";
+                        response = $"Player not found: {arguments.At(0)}";
                         return false;
                     }
 
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player \"{arguments.At(0)}\" not found";
-                        return false;
-                    }
+                    foreach (Player ply in players)
+                        Main.PryGate.Add(ply);
 
-                    if (!Main.PryGateHubs.Contains(pl))
-                    {
-                        Main.PryGateHubs.Add(pl);
-                        response = $"Player \"{pl.Nickname}\" can now pry gates open";
-                        return true;
-                    }
-                    else
-                    {
-                        Main.PryGateHubs.Remove(pl);
-                        response = $"Player \"{pl.Nickname}\" cannot pry gates open now";
-                        return true;
-                    }
+                    response = "Every player can now pry gates open.";
+                    return true;
             }
         }
     }
diff --git a/AdminTools/Commands/RandomTeleport.cs b/AdminTools/Commands/RandomTeleport.cs
new file mode 100644
index 0000000..178d39f
--- /dev/null
+++ b/AdminTools/Commands/RandomTeleport.cs
@@ -0,0 +1,51 @@
+using CommandSystem;
+using Exiled.API.Features;
+using RemoteAdmin;
+using System;
+using System.Collections.Generic;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class RandomTeleport : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "randomtp";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Randomly teleports a user or all users to a random room in the facility";
+
+        public string[] Usage { get; } = new string[] { "%player%", };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!CommandProcessor.CheckPermissions(((CommandSender)sender), "randomtp", PlayerPermissions.PlayersManagement, "AdminTools", false))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count != 1)
+            {
+                response = "Usage: randomtp ((player id / name) or (all / *))";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            foreach (Player ply in players)
+            {
+                ply.RandomTeleport(typeof(Room));
+            }
+
+            response = $"All specified players have been teleported to a random room in the facility:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/RandomTeleport/RandomTeleport.cs b/AdminTools/Commands/RandomTeleport/RandomTeleport.cs
deleted file mode 100644
index 9c4821c..0000000
--- a/AdminTools/Commands/RandomTeleport/RandomTeleport.cs
+++ /dev/null
@@ -1,66 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using RemoteAdmin;
-using System;
-using System.Linq;
-using UnityEngine;
-
-namespace AdminTools.Commands.RandomTeleport
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class RandomTeleport : ParentCommand
-    {
-        public RandomTeleport() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "randomtp";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Randomly teleports a user or all users to a random room in the facility";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!CommandProcessor.CheckPermissions(((CommandSender)sender), "randomtp", PlayerPermissions.PlayersManagement, "AdminTools", false))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 1)
-            {
-                response = "Usage: randomtp ((player id / name) or (all / *))";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    foreach (Player ply in Player.List)
-                    {
-                        Room randRoom = Room.List.ElementAt(Main.NumGen.Next(0, Room.List.Count()));
-                        ply.Position = randRoom.Position + Vector3.up;
-                    }
-
-                    response = $"Everyone was teleported to a random room in the facility";
-                    return true;
-                default:
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    Room rand = Room.List.ElementAt(Main.NumGen.Next(0, Room.List.Count()));
-                    pl.Position = rand.Position + Vector3.up;
-
-                    response = $"Player {pl.Nickname} was teleported to {rand.Name}";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Regeneration.cs b/AdminTools/Commands/Regeneration.cs
new file mode 100644
index 0000000..cc5741f
--- /dev/null
+++ b/AdminTools/Commands/Regeneration.cs
@@ -0,0 +1,63 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using InventorySystem.Items.Usables;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Regeneration : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "regeneration";
+
+        public string[] Aliases { get; } = new string[] { "reg" };
+
+        public string Description { get; } = "Manages regeneration properties for users";
+        public string[] Usage { get; } = new string[] { "%player%", "duration", "rate" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.reg"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count < 3)
+            {
+                response = "Usage: regeneration ((player id / name) or (all / *)) (duration) (rate)";
+                return false;
+            }
+
+            if (float.TryParse(arguments.At(1), out float duration))
+            {
+                response = $"Duration should be a float number: {arguments.At(1)}";
+                return false;
+            }
+
+            if (float.TryParse(arguments.At(2), out float rate))
+            {
+                response = $"Rate should be a float number: {arguments.At(1)}";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            AnimationCurve animationCurve = AnimationCurve.Constant(0f, duration, rate);
+            RegenerationProcess reg = new(animationCurve, 1f, 1f);
+            foreach (Player player in players)
+                UsableItemsController.GetHandler(player.ReferenceHub).ActiveRegenerations.Add(reg);
+            response = $"The specified player has been regenerated:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/AdminTools/Commands/Regeneration/Regeneration.cs b/AdminTools/Commands/Regeneration/Regeneration.cs
deleted file mode 100644
index 059e4da..0000000
--- a/AdminTools/Commands/Regeneration/Regeneration.cs
+++ /dev/null
@@ -1,155 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using NorthwoodLib.Pools;
-using System;
-using System.Text;
-
-namespace AdminTools.Commands.Regeneration
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Regeneration : ParentCommand
-    {
-        public Regeneration() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "reg";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Manages regeneration properties for users";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.reg"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 1)
-            {
-                response = "Usage:\nreg ((player id / name) or (all / *)) ((doors) or (all))" +
-                    "\nreg clear" +
-                    "\nreg list" +
-                    "\nreg health (value)" +
-                    "\nreg time (value)";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "clear":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: reg clear";
-                        return false;
-                    }
-
-                    foreach (Player ply in Main.RgnHubs.Keys)
-                        if (ply.ReferenceHub.TryGetComponent(out RegenerationComponent rgCom))
-                            UnityEngine.Object.Destroy(rgCom);
-
-                    response = "Regeneration has been removed from everyone";
-                    return true;
-                case "list":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: regen list";
-                        return false;
-                    }
-
-                    StringBuilder playerLister = StringBuilderPool.Shared.Rent(Main.RgnHubs.Count != 0 ? "Players with regeneration on:\n" : "No players currently online have regeneration on");
-                    if (Main.RgnHubs.Count == 0)
-                    {
-                        response = playerLister.ToString();
-                        return true;
-                    }
-
-                    foreach (Player ply in Main.RgnHubs.Keys)
-                    {
-                        playerLister.Append(ply.Nickname);
-                        playerLister.Append(", ");
-                    }
-
-                    string msg = playerLister.ToString().Substring(0, playerLister.ToString().Length - 2);
-                    StringBuilderPool.Shared.Return(playerLister);
-                    response = msg;
-                    return true;
-                case "heal":
-                    if (arguments.Count != 2)
-                    {
-                        response = "Usage: reg heal (value)";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(1), out float healvalue) || healvalue < 0.05)
-                    {
-                        response = $"Invalid value for healing: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    Main.HealthGain = healvalue;
-                    response = $"Players with regeneration will heal {healvalue} HP per interval";
-                    return true;
-                case "time":
-                    if (arguments.Count != 2)
-                    {
-                        response = "Usage: reg time (value)";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(1), out float healtime) || healtime < 0.05)
-                    {
-                        response = $"Invalid value for healing time interval: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    Main.HealthInterval = healtime;
-                    response = $"Players with regeneration will heal every {healtime} seconds";
-                    return true;
-                case "*":
-                case "all":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: reg (all / *)";
-                        return false;
-                    }
-
-                    foreach (Player ply in Player.List)
-                        if (!ply.ReferenceHub.TryGetComponent(out RegenerationComponent _))
-                            ply.ReferenceHub.gameObject.AddComponent<RegenerationComponent>();
-
-                    response = "Everyone on the server can regenerate health now";
-                    return true;
-                default:
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: reg (player id / name)";
-                        return false;
-                    }
-
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (!pl.ReferenceHub.TryGetComponent(out RegenerationComponent rgnComponent))
-                    {
-                        pl.GameObject.AddComponent<RegenerationComponent>();
-                        response = $"Regeneration is on for {pl.Nickname}";
-                    }
-                    else
-                    {
-                        UnityEngine.Object.Destroy(rgnComponent);
-                        response = $"Regeneration is off for {pl.Nickname}";
-                    }
-                    return true;
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/AdminTools/Commands/Rocket.cs b/AdminTools/Commands/Rocket.cs
new file mode 100644
index 0000000..c3a044d
--- /dev/null
+++ b/AdminTools/Commands/Rocket.cs
@@ -0,0 +1,75 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using MEC;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Rocket : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "rocket";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Turns the player into a firework.";
+
+        public string[] Usage { get; } = new string[] { "%player%", "speed" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.rocket"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count < 2)
+            {
+                response = "Usage: rocket ((player id / name) or (all / *)) (speed)";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            if (!float.TryParse(arguments.At(1), out float speed) && speed <= 0)
+            {
+                response = $"Speed argument should be a positive number : {arguments.At(1)}";
+                return false;
+            }
+
+            foreach (Player ply in players)
+                Timing.RunCoroutine(DoRocket(ply, speed));
+
+            response = $"The specified players have been turned into fireworks\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+        public static IEnumerator<float> DoRocket(Player player, float speed)
+        {
+            const int maxAmnt = 50;
+            int amnt = 0;
+            while (player.IsAlive)
+            {
+                player.Position += Vector3.up * speed;
+                amnt++;
+                if (amnt >= maxAmnt)
+                {
+                    player.IsGodModeEnabled = false;
+                    player.Explode();
+                    player.Kill("Went on a trip in their favorite rocket ship.");
+                }
+
+                yield return Timing.WaitForOneFrame;
+            }
+        }
+    }
+}
diff --git a/AdminTools/Commands/Rocket/Rocket.cs b/AdminTools/Commands/Rocket/Rocket.cs
deleted file mode 100644
index a8171a4..0000000
--- a/AdminTools/Commands/Rocket/Rocket.cs
+++ /dev/null
@@ -1,79 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using MEC;
-using System;
-
-namespace AdminTools.Commands.Rocket
-{
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Rocket : ParentCommand
-    {
-        public Rocket() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "rocket";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Sends players high in the sky and explodes them";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.rocket"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 2)
-            {
-                response = "Usage: rocket ((player id / name) or (all / *)) (speed)";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    if (!float.TryParse(arguments.At(1), out float speed) && speed <= 0)
-                    {
-                        response = $"Speed argument invalid: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    foreach (Player ply in Player.List)
-                        Timing.RunCoroutine(EventHandlers.DoRocket(ply, speed));
-
-                    response = "Everyone has been rocketed into the sky (We're going on a trip, in our favorite rocketship)";
-                    return true;
-                default:
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-                    else if (pl.Role == RoleTypeId.Spectator || pl.Role == RoleTypeId.None)
-                    {
-                        response = $"Player {pl.Nickname} is not a valid class to rocket";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(1), out float spd) && spd <= 0)
-                    {
-                        response = $"Speed argument invalid: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    Timing.RunCoroutine(EventHandlers.DoRocket(pl, spd));
-                    response = $"Player {pl.Nickname} has been rocketed into the sky (We're going on a trip, in our favorite rocketship)";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Scale.cs b/AdminTools/Commands/Scale.cs
new file mode 100644
index 0000000..9716fa7
--- /dev/null
+++ b/AdminTools/Commands/Scale.cs
@@ -0,0 +1,58 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Scale : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "scale";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Scales a specific player or all players.";
+
+        public string[] Usage { get; } = new string[] { "%player%", "size" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.size"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count < 2)
+            {
+                response = "Usage:\nscale ((player id / name) or (all / *)) (value)" +
+                    "\nscale reset";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            if (!float.TryParse(arguments.At(1), out float scale))
+            {
+                response = $"Invalid value for scale: {arguments.At(1)}";
+                return false;
+            }
+
+            Vector3 size = Vector3.one * scale;
+            foreach (Player ply in players)
+                ply.Scale = size;
+
+            response = $"The specified player's size has been set to {size}:\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/Scale/Scale.cs b/AdminTools/Commands/Scale/Scale.cs
deleted file mode 100644
index d0c756a..0000000
--- a/AdminTools/Commands/Scale/Scale.cs
+++ /dev/null
@@ -1,95 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.Scale
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Scale : ParentCommand
-    {
-        public Scale() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "scale";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Scales all users or a user by a specified value";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.size"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 1)
-            {
-                response = "Usage:\nscale ((player id / name) or (all / *)) (value)" +
-                    "\nscale reset";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "reset":
-                    if (arguments.Count != 1)
-                    {
-                        response = "Usage: scale reset";
-                        return false;
-                    }
-                    foreach (Player plyr in Player.List)
-                        EventHandlers.SetPlayerScale(plyr, 1);
-
-                    response = $"Everyone's scale has been reset";
-                    return true;
-                case "*":
-                case "all":
-                    if (arguments.Count != 2)
-                    {
-                        response = "Usage: scale (all / *) (value)";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(1), out float value))
-                    {
-                        response = $"Invalid value for scale: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    foreach (Player ply in Player.List)
-                        EventHandlers.SetPlayerScale(ply, value);
-
-                    response = $"Everyone's scale has been set to {value}";
-                    return true;
-                default:
-                    if (arguments.Count != 2)
-                    {
-                        response = "Usage: scale (player id / name) (value)";
-                        return false;
-                    }
-
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return true;
-                    }
-
-                    if (!float.TryParse(arguments.At(1), out float val))
-                    {
-                        response = $"Invalid value for scale: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    EventHandlers.SetPlayerScale(pl, val);
-                    response = $"Player {pl.Nickname}'s scale has been set to {val}";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Size.cs b/AdminTools/Commands/Size.cs
new file mode 100644
index 0000000..3cceae8
--- /dev/null
+++ b/AdminTools/Commands/Size.cs
@@ -0,0 +1,78 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class Size : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "size";
+
+        public string[] Aliases { get; } = Array.Empty<string>();
+
+        public string Description { get; } = "Sets the size of all users or a user";
+
+        public string[] Usage { get; } = new string[] { "%player%", "x", "y", "z" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.size"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count < 1)
+            {
+                response = "Usage:\nsize (player id / name) or (all / *)) (x value) (y value) (z value)" +
+                    "\nsize reset";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            if (arguments.Count != 4)
+            {
+                response = "Usage: size (all / *) (x) (y) (z)";
+                return false;
+            }
+
+            if (!float.TryParse(arguments.At(1), out float x))
+            {
+                response = $"Invalid value for x size: {arguments.At(1)}";
+                return false;
+            }
+
+            if (!float.TryParse(arguments.At(2), out float y))
+            {
+                response = $"Invalid value for y size: {arguments.At(2)}";
+                return false;
+            }
+
+            if (!float.TryParse(arguments.At(3), out float z))
+            {
+                response = $"Invalid value for z size: {arguments.At(3)}";
+                return false;
+            }
+            Vector3 size = new(x, y, z);
+            foreach (Player ply in players)
+            {
+                ply.Scale = size;
+            }
+
+            response = $"The specified player's size has been set to {size}:\n{Extensions.LogPlayers(players)}";
+            return true;
+
+        }
+    }
+}
diff --git a/AdminTools/Commands/Size/Size.cs b/AdminTools/Commands/Size/Size.cs
deleted file mode 100644
index e937ca1..0000000
--- a/AdminTools/Commands/Size/Size.cs
+++ /dev/null
@@ -1,126 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.Size
-{
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    class Size : ParentCommand
-    {
-        public Size() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "size";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Sets the size of all users or a user";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.size"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 1)
-            {
-                response = "Usage:\nsize (player id / name) or (all / *)) (x value) (y value) (z value)" +
-                    "\nsize reset";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "reset":
-                    foreach (Player ply in Player.List)
-                    {
-                        if (ply.Role == RoleTypeId.Spectator || ply.Role == RoleTypeId.None)
-                            continue;
-
-                        EventHandlers.SetPlayerScale(ply, 1, 1, 1);
-                    }
-
-                    response = $"Everyone's size has been reset";
-                    return true;
-                case "*":
-                case "all":
-                    if (arguments.Count != 4)
-                    {
-                        response = "Usage: size (all / *) (x) (y) (z)";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(1), out float xval))
-                    {
-                        response = $"Invalid value for x size: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(2), out float yval))
-                    {
-                        response = $"Invalid value for y size: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(3), out float zval))
-                    {
-                        response = $"Invalid value for z size: {arguments.At(3)}";
-                        return false;
-                    }
-
-                    foreach (Player ply in Player.List)
-                    {
-                        if (ply.Role == RoleTypeId.Spectator || ply.Role == RoleTypeId.None)
-                            continue;
-
-                        EventHandlers.SetPlayerScale(ply, xval, yval, zval);
-                    }
-
-                    response = $"Everyone's scale has been set to {xval} {yval} {zval}";
-                    return true;
-                default:
-                    if (arguments.Count != 4)
-                    {
-                        response = "Usage: size (player id / name) (x) (y) (z)";
-                        return false;
-                    }
-
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(1), out float x))
-                    {
-                        response = $"Invalid value for x size: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(2), out float y))
-                    {
-                        response = $"Invalid value for y size: {arguments.At(2)}";
-                        return false;
-                    }
-
-                    if (!float.TryParse(arguments.At(3), out float z))
-                    {
-                        response = $"Invalid value for z size: {arguments.At(3)}";
-                        return false;
-                    }
-
-                    EventHandlers.SetPlayerScale(pl, x, y, z);
-                    response = $"Player {pl.Nickname}'s scale has been set to {x} {y} {z}";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/SpawnRagdoll.cs b/AdminTools/Commands/SpawnRagdoll.cs
new file mode 100644
index 0000000..eeecc38
--- /dev/null
+++ b/AdminTools/Commands/SpawnRagdoll.cs
@@ -0,0 +1,98 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using MEC;
+using System;
+using System.Collections.Generic;
+using PlayerRoles;
+using System.Text.RegularExpressions;
+using System.Linq;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class SpawnRagdoll : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "spawnragdoll";
+
+        public string[] Aliases { get; } = new string[] { "ragdoll", "rd", "rag", "doll" };
+
+        public string Description { get; } = "Spawns a specified number of ragdolls on a user";
+
+        public string[] Usage { get; } = new string[] { "%player%", "%role%", "amount", "\"name\"", "\"death reason\"" };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            string[] quotedArgs = Regex.Matches(string.Join(" ", arguments), "[^\\s\"\']+|\"([^\"]*)\"|\'([^\']*)\'")
+                .Cast<Match>()
+                .Select(m => m.Value)
+                .ToArray()
+                .ToArray();
+
+            if (!sender.CheckPermission("at.dolls"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (quotedArgs.Count() != 5 || quotedArgs.Count() != 3)
+            {
+                response = "Usage: spawnragdoll ((player id / name) or (all / *)) (RoleTypeId) (amount) (nameRagdoll) (deathReason)";
+                return false;
+            }
+
+            if (!Enum.TryParse(arguments.At(1), true, out RoleTypeId type))
+            {
+                response = $"Invalid RoleTypeId for ragdoll: {arguments.At(1)}";
+                return false;
+            }
+
+            if (!int.TryParse(arguments.At(2), out int amount))
+            {
+                response = $"Invalid amount of ragdolls to spawn: {arguments.At(2)}";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            string ragdollName = "SCP-343";
+            string deathReason = "End of the Universe";
+
+            if (quotedArgs.Count() == 5)
+            {
+                ragdollName = quotedArgs.ElementAt(3).Trim('\"');
+                deathReason = quotedArgs.ElementAt(4).Trim('\"');
+            }    
+
+            if(string.IsNullOrEmpty(ragdollName) || string.IsNullOrEmpty(deathReason))
+            {
+                ragdollName = "SCP-343";
+                deathReason = "End of the universe";
+            }
+
+            foreach (Player player in players)
+            {
+                Timing.RunCoroutine(SpawnDolls(player, type, amount, ragdollName, deathReason));
+            }
+
+            response = $"{amount} {type} ragdoll(s) have been spawned on {arguments.At(0)}.";
+            return true;
+        }
+
+        private IEnumerator<float> SpawnDolls(Player player, RoleTypeId type, int amount, string ragdollName, string deathReason)
+        {
+            for (int i = 0; i < amount; i++)
+            {
+                if (player.IsAlive)
+                    Ragdoll.CreateAndSpawn(type, ragdollName, deathReason, player.Position, default);
+                yield return Timing.WaitForSeconds(0.5f);
+            }
+        }
+    }
+}
diff --git a/AdminTools/Commands/SpawnRagdoll/SpawnRagdoll.cs b/AdminTools/Commands/SpawnRagdoll/SpawnRagdoll.cs
deleted file mode 100644
index d67eadb..0000000
--- a/AdminTools/Commands/SpawnRagdoll/SpawnRagdoll.cs
+++ /dev/null
@@ -1,93 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using MEC;
-using System;
-
-namespace AdminTools.Commands.SpawnRagdoll
-{
-    using System.Collections.Generic;
-    using Mirror;
-    using PlayerRoles;
-    using PlayerStatsSystem;
-    using UnityEngine;
-    using Ragdoll = Exiled.API.Features.Ragdoll;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class SpawnRagdoll : ParentCommand
-    {
-        public SpawnRagdoll() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "spawnragdoll";
-
-        public override string[] Aliases { get; } = new string[] { "ragdoll", "rd", "rag", "doll" };
-
-        public override string Description { get; } = "Spawns a specified number of ragdolls on a user";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.dolls"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 3)
-            {
-                response = "Usage: spawnragdoll ((player id / name) or (all / *)) (RoleTypeId) (amount)";
-                return false;
-            }
-
-            if (!Enum.TryParse(arguments.At(1), true, out RoleTypeId type))
-            {
-                response = $"Invalid RoleTypeId for ragdoll: {arguments.At(1)}";
-                return false;
-            }
-
-            if (!int.TryParse(arguments.At(2), out int amount))
-            {
-                response = $"Invalid amount of ragdolls to spawn: {arguments.At(2)}";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    foreach (Player player in Player.List)
-                    {
-                        if (player.Role != RoleTypeId.Spectator) 
-                            Timing.RunCoroutine(SpawnDolls(player, type, amount));
-                    }
-
-                    break;
-                default:
-                    Player ply = Player.Get(arguments.At(0));
-                    if (ply is null)
-                    {
-                        response = $"Player {arguments.At(0)} not found.";
-                        return false;
-                    }
-
-                    Timing.RunCoroutine(SpawnDolls(ply, type, amount));
-
-                    break;
-            }
-
-            response = $"{amount} {type} ragdoll(s) have been spawned on {arguments.At(0)}.";
-            return true;
-        }
-
-        private IEnumerator<float> SpawnDolls(Player player, RoleTypeId type, int amount)
-        {
-            for (int i = 0; i < amount; i++)
-            {
-                Ragdoll.CreateAndSpawn(type, "SCP-343", "End of the Universe", player.Position, default);
-                yield return Timing.WaitForSeconds(0.5f);
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/SpawnWorkbench/SpawnWorkbench.cs b/AdminTools/Commands/SpawnWorkbench.cs
similarity index 87%
rename from AdminTools/Commands/SpawnWorkbench/SpawnWorkbench.cs
rename to AdminTools/Commands/SpawnWorkbench.cs
index 3be7d7f..e5fd874 100644
--- a/AdminTools/Commands/SpawnWorkbench/SpawnWorkbench.cs
+++ b/AdminTools/Commands/SpawnWorkbench.cs
@@ -6,27 +6,24 @@
 using System.Collections.Generic;
 using System.Linq;
 using UnityEngine;
+using PlayerRoles;
 
-namespace AdminTools.Commands.SpawnWorkbench
+namespace AdminTools.Commands
 {
-    using PlayerRoles;
-
     [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    public class SpawnWorkbench : ParentCommand
+    public class SpawnWorkbench : ICommand, IUsageProvider
     {
-        public SpawnWorkbench() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "bench";
+        public string Command { get; } = "bench";
 
-        public override string[] Aliases { get; } = new string[] { "sw", "wb", "workbench" };
+        public string[] Aliases { get; } = new string[] { "sw", "wb", "workbench" };
 
-        public override string Description { get; } = "Spawns a workbench on all users or a user";
+        public string Description { get; } = "Spawns a workbench on all users or a user";
 
-        public override void LoadGeneratedCommands() { }
+        public string[] Usage { get; } = new string[] { "%player%", };
 
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.benches"))
+            if (!sender.CheckPermission("at.benches"))
             {
                 response = "You do not have permission to use this command";
                 return false;
@@ -184,7 +181,7 @@ protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSe
                         if (p.Role == RoleTypeId.Spectator || p.Role == RoleTypeId.None)
                             continue;
 
-                        EventHandlers.SpawnWorkbench(player, p.Position + p.ReferenceHub.PlayerCameraReference.forward * 2, p.GameObject.transform.rotation.eulerAngles, new Vector3(xval, yval, zval), out int benchIndex);
+                        Extensions.SpawnWorkbench(player, p.Position + p.ReferenceHub.PlayerCameraReference.forward * 2, p.GameObject.transform.rotation.eulerAngles, new Vector3(xval, yval, zval), out int benchIndex);
                         index = benchIndex;
                     }
 
@@ -203,7 +200,7 @@ protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSe
                         response = $"Player not found: {arguments.At(0)}";
                         return false;
                     }
-                    else if (pl.Role == RoleTypeId.Spectator || pl.Role == RoleTypeId.None)
+                    else if (pl.Role.IsDead)
                     {
                         response = $"This player is not a valid class to spawn a workbench on";
                         return false;
@@ -227,7 +224,7 @@ protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSe
                         return false;
                     }
 
-                    EventHandlers.SpawnWorkbench(player, pl.Position + pl.ReferenceHub.PlayerCameraReference.forward * 2, pl.GameObject.transform.rotation.eulerAngles, new Vector3(x, y, z), out int benchI);
+                    Extensions.SpawnWorkbench(player, pl.Position + pl.ReferenceHub.PlayerCameraReference.forward * 2, pl.GameObject.transform.rotation.eulerAngles, new Vector3(x, y, z), out int benchI);
                     response = $"A workbench has spawned on Player {pl.Nickname}, you now spawned in a total of {(benchI != 1 ? $"{benchI} workbenches" : $"{benchI} workbench")}";
                     return true;
             }
diff --git a/AdminTools/Commands/Strip/Strip.cs b/AdminTools/Commands/Strip/Strip.cs
deleted file mode 100644
index 8444134..0000000
--- a/AdminTools/Commands/Strip/Strip.cs
+++ /dev/null
@@ -1,59 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using RemoteAdmin;
-using System;
-
-namespace AdminTools.Commands.Strip
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Strip : ParentCommand
-    {
-        public Strip() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "atstrip";
-
-        public override string[] Aliases { get; } = new string[] { "stp" };
-
-        public override string Description { get; } = "Clears a user or users inventories instantly";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!CommandProcessor.CheckPermissions(((CommandSender)sender), "strip", PlayerPermissions.PlayersManagement, "AdminTools", false))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 1)
-            {
-                response = "Usage: strip ((player id / name) or (all / *))";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    foreach (Player ply in Player.List)
-                        ply.ClearInventory();
-
-                    response = "Everyone's inventories have been cleared now";
-                    return true;
-                default:
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    pl.ClearInventory();
-                    response = $"Player {pl.Nickname}'s inventory have been cleared now";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Tags/Hide.cs b/AdminTools/Commands/Tags/Hide.cs
deleted file mode 100644
index 8c5e4cf..0000000
--- a/AdminTools/Commands/Tags/Hide.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.Tags
-{
-    public class Hide : ICommand
-    {
-        public string Command { get; } = "hide";
-
-        public string[] Aliases { get; } = new string[] { };
-
-        public string Description { get; } = "Hides staff tags on the server";
-
-        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.tags"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 0)
-            {
-                response = "Usage: tags hide";
-                return false;
-            }
-
-            foreach (Player player in Player.List)
-                if (player.ReferenceHub.serverRoles.RemoteAdmin)
-                    player.BadgeHidden = true;
-
-            response = "All staff tags are hidden now";
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Tags/Show.cs b/AdminTools/Commands/Tags/Show.cs
deleted file mode 100644
index 92fa754..0000000
--- a/AdminTools/Commands/Tags/Show.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-
-namespace AdminTools.Commands.Tags
-{
-    public class Show : ICommand
-    {
-        public string Command { get; } = "show";
-
-        public string[] Aliases { get; } = Array.Empty<string>();
-
-        public string Description { get; } = "Shows staff tags on the server";
-
-        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.tags"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 0)
-            {
-                response = "Usage: tags show";
-                return false;
-            }
-
-            foreach (Player player in Player.List)
-                if (player.ReferenceHub.serverRoles.RemoteAdmin && !player.IsNorthwoodStaff)
-                    player.BadgeHidden = false;
-
-            response = "All staff tags are now visible";
-            return true;
-        }
-    }
-}
diff --git a/AdminTools/Commands/Tags/Tags.cs b/AdminTools/Commands/Tags/Tags.cs
deleted file mode 100644
index cbeaa95..0000000
--- a/AdminTools/Commands/Tags/Tags.cs
+++ /dev/null
@@ -1,38 +0,0 @@
-using System;
-using CommandSystem;
-using Exiled.Permissions.Extensions;
-using Exiled.API.Features;
-
-namespace AdminTools.Commands.Tags
-{
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Tags : ParentCommand
-    {
-        public Tags() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "tags";
-
-        public override string[] Aliases { get; } = new string[] { };
-
-        public override string Description { get; } = "Hides staff tags in the server";
-
-        public override void LoadGeneratedCommands() 
-        {
-            RegisterCommand(new Hide());
-            RegisterCommand(new Show());
-        }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.tags"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            response = "Invalid subcommand. Available ones: hide, show";
-            return false;
-        }
-    }
-}
diff --git a/AdminTools/Commands/TargetGhost.cs b/AdminTools/Commands/TargetGhost.cs
new file mode 100644
index 0000000..3e18883
--- /dev/null
+++ b/AdminTools/Commands/TargetGhost.cs
@@ -0,0 +1,69 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using Exiled.API.Features.Roles;
+using System.Collections.Generic;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class TargetGhost : ICommand
+    {
+        public const string HelpStr = "Usage: targetghost (player id / name) (player id / name) ...";
+
+        public string Command { get; } = "targetghost";
+
+        public string[] Aliases { get; } = new string[] { "tg" };
+
+        public string Description { get; } = "Sets a user to be invisible to another user";
+
+        public string[] Usage { get; } = new string[] { "%player%", "%player%", };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission("at.targetghost"))
+            {
+                response = "You do not have permission to use this command";
+                return false;
+            }
+
+            if (arguments.Count < 2)
+            {
+                response = HelpStr;
+                return false;
+            }
+
+            IEnumerable<Player> sourcePlayers = Player.GetProcessedData(arguments);
+
+            if (sourcePlayers.IsEmpty())
+            {
+                response = $"Invalid source player: {arguments.At(0)}";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments, 1);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(1)}";
+                return false;
+            }
+
+            foreach (Player sourcePlayer in sourcePlayers)
+            {
+                foreach (Player victim in players)
+                {
+                    if (sourcePlayer.Role.Is(out FpcRole role))
+                    {
+                        if (!role.IsInvisibleFor.Add(victim))
+                            role.IsInvisibleFor.Remove(victim);
+                    }
+                }
+            }
+
+            response = $"Finshed Ghostbusting.";
+            return true;
+        }
+    }
+}
\ No newline at end of file
diff --git a/AdminTools/Commands/TargetGhost/TargetGhost.cs b/AdminTools/Commands/TargetGhost/TargetGhost.cs
deleted file mode 100644
index 933c973..0000000
--- a/AdminTools/Commands/TargetGhost/TargetGhost.cs
+++ /dev/null
@@ -1,70 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using NorthwoodLib.Pools;
-using System;
-using System.Linq;
-using System.Text;
-
-namespace AdminTools.Commands.TargetGhost
-{
-    using Exiled.API.Features.Roles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class TargetGhost : ParentCommand
-    {
-        public const string HelpStr = "Usage: targetghost (player id / name) (player id / name) ...";
-
-        public TargetGhost() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "targetghost";
-
-        public override string[] Aliases { get; } = new string[] { "tg" };
-
-        public override string Description { get; } = "Sets a user to be invisible to another user";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.targetghost"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count < 2)
-            {
-                response = HelpStr;
-                return false;
-            }
-
-            if (!GetPlayer(arguments.At(0), out Player sourcePlayer))
-            {
-                response = $"Invalid source player: {arguments.At(0)}";
-                return false;
-            }
-
-            foreach (string arg in arguments.Skip(1))
-            {
-                if (!GetPlayer(arg, out Player victim))
-                    continue;
-
-                if (sourcePlayer.Role.Is(out FpcRole role))
-                {
-                    if (!role.IsInvisibleFor.Add(victim))
-                        role.IsInvisibleFor.Remove(victim);
-                }
-            }
-            response = $"Done modifying who can see {sourcePlayer.Nickname}";
-            return true;
-        }
-
-        private bool GetPlayer(string str, out Player player)
-        {
-            player = Player.Get(str);
-            return player != null;
-        }
-    }
-}
\ No newline at end of file
diff --git a/AdminTools/Commands/TeleportX.cs b/AdminTools/Commands/TeleportX.cs
new file mode 100644
index 0000000..fdbe2e9
--- /dev/null
+++ b/AdminTools/Commands/TeleportX.cs
@@ -0,0 +1,56 @@
+using CommandSystem;
+using Exiled.API.Features;
+using Exiled.Permissions.Extensions;
+using System;
+using Exiled.API.Extensions;
+using System.Collections.Generic;
+
+namespace AdminTools.Commands
+{
+    [CommandHandler(typeof(RemoteAdminCommandHandler))]
+    [CommandHandler(typeof(GameConsoleCommandHandler))]
+    public class TeleportX : ICommand, IUsageProvider
+    {
+        public string Command { get; } = "teleportx";
+
+        public string[] Aliases { get; } = new string[] { "tpx", "tpto" };
+
+        public string Description { get; } = "Teleports all users or a user to another user";
+
+        public string[] Usage { get; } = new string[] { "%player%", "%player%", };
+
+        public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
+        {
+            if (!sender.CheckPermission(PlayerPermissions.PlayersManagement, out response))
+                return false;
+
+            if (arguments.Count != 2)
+            {
+                response = "Usage: teleportx (People teleported: (player id / name) or (all / *)) (Teleported to: (player id / name))";
+                return false;
+            }
+
+            Player ply = Player.GetProcessedData(arguments, 1).GetRandomValue();
+            if (ply == null)
+            {
+                response = $"Player not found: {arguments.At(1)}";
+                return false;
+            }
+
+            IEnumerable<Player> players = Player.GetProcessedData(arguments);
+            if (players.IsEmpty())
+            {
+                response = $"Player not found: {arguments.At(0)}";
+                return false;
+            }
+
+            foreach (Player plyr in players)
+            {
+                plyr.Position = ply.Position;
+            }
+
+            response = $"The specified players has been teleported to {ply.Nickname}({ply.Id}):\n{Extensions.LogPlayers(players)}";
+            return true;
+        }
+    }
+}
diff --git a/AdminTools/Commands/TeleportX/TeleportX.cs b/AdminTools/Commands/TeleportX/TeleportX.cs
deleted file mode 100644
index 4377c4b..0000000
--- a/AdminTools/Commands/TeleportX/TeleportX.cs
+++ /dev/null
@@ -1,81 +0,0 @@
-using CommandSystem;
-using Exiled.API.Features;
-using Exiled.Permissions.Extensions;
-using System;
-
-namespace AdminTools.Commands.TeleportX
-{
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class TeleportX : ParentCommand
-    {
-        public TeleportX() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "teleportx";
-
-        public override string[] Aliases { get; } = new string[] { "tpx" };
-
-        public override string Description { get; } = "Teleports all users or a user to another user";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.tp"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            if (arguments.Count != 2)
-            {
-                response = "Usage: teleportx (People teleported: (player id / name) or (all / *)) (Teleported to: (player id / name) or (all / *))";
-                return false;
-            }
-
-            switch (arguments.At(0))
-            {
-                case "*":
-                case "all":
-                    Player ply = Player.Get(arguments.At(1));
-                    if (ply == null)
-                    {
-                        response = $"Player not found: {arguments.At(1)}";
-                        return false;
-                    }
-
-
-                    foreach (Player plyr in Player.List)
-                    {
-                        if (plyr.Role == RoleTypeId.Spectator || ply.Role == RoleTypeId.None)
-                            continue;
-
-                        plyr.Position = ply.Position;
-                    }
-
-                    response = $"Everyone has been teleported to Player {ply.Nickname}";
-                    return true;
-                default:
-                    Player pl = Player.Get(arguments.At(0));
-                    if (pl == null)
-                    {
-                        response = $"Player not found: {arguments.At(0)}";
-                        return false;
-                    }
-
-                    Player plr = Player.Get(arguments.At(1));
-                    if (plr == null)
-                    {
-                        response = $"Player not found: {arguments.At(1)}";
-                        return false;
-                    }
-
-                    pl.Position = plr.Position;
-                    response = $"Player {pl.Nickname} has been teleported to Player {plr.Nickname}";
-                    return true;
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Tutorial/Tutorial.cs b/AdminTools/Commands/Tutorial/Tutorial.cs
deleted file mode 100644
index f9b062d..0000000
--- a/AdminTools/Commands/Tutorial/Tutorial.cs
+++ /dev/null
@@ -1,98 +0,0 @@
-using CommandSystem;
-using Exiled.Permissions.Extensions;
-using Exiled.API.Features;
-using MEC;
-using System;
-using System.Collections.Generic;
-using UnityEngine;
-using RemoteAdmin;
-
-namespace AdminTools.Commands.Tutorial
-{
-    using PlayerRoles;
-
-    [CommandHandler(typeof(RemoteAdminCommandHandler))]
-    [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Tutorial : ParentCommand
-    {
-        Player _ply;
-
-        public Tutorial() => LoadGeneratedCommands();
-
-        public override string Command { get; } = "tutorial";
-
-        public override string[] Aliases { get; } = new string[] { "tut" };
-
-        public override string Description { get; } = "Sets a player as a tutorial conveniently";
-
-        public override void LoadGeneratedCommands() { }
-
-        protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
-        {
-            if (!((CommandSender)sender).CheckPermission("at.tut"))
-            {
-                response = "You do not have permission to use this command";
-                return false;
-            }
-
-            switch (arguments.Count)
-            {
-                case 0:
-                case 1:
-                    if (arguments.Count == 0)
-                    {
-                        if (!(sender is PlayerCommandSender plysend))
-                        {
-                            response = "You must be in-game to run this command if you specify yourself!";
-                            return false;
-                        }
-
-                        _ply = Player.Get(plysend.ReferenceHub);
-                    }
-                    else
-                    {
-                        if (String.IsNullOrWhiteSpace(arguments.At(0)))
-                        {
-                            response = "Please do not try to put a space as tutorial";
-                            return false;
-                        }
-
-                        _ply = Player.Get(arguments.At(0));
-                        if (_ply == null)
-                        {
-                            response = $"Player not found: {arguments.At(0)}";
-                            return false;
-                        }
-                    }
-
-                    DoTutorialFunction(_ply, out response);
-                    return true;
-                default:
-                    response = "Usage: tutorial (optional: id / name)";
-                    return false;
-            }
-        }
-
-        private IEnumerator<float> SetClassAsTutorial(Player ply) 
-        {
-            Vector3 oldPos = ply.Position;
-            ply.Role.Set(RoleTypeId.Tutorial);
-            yield return Timing.WaitForSeconds(0.5f);
-            ply.Position = oldPos;
-        }
-
-        private void DoTutorialFunction(Player ply, out string response)
-        {
-            if (ply.Role != RoleTypeId.Tutorial)
-            {
-                Timing.RunCoroutine(SetClassAsTutorial(ply));
-                response = $"Player {ply.Nickname} is now set to tutorial";
-            }
-            else
-            {
-                ply.Role.Set(RoleTypeId.Spectator);
-                response = $"Player {ply.Nickname} is now set to spectator";
-            }
-        }
-    }
-}
diff --git a/AdminTools/Commands/Unmute/All.cs b/AdminTools/Commands/Unmute/All.cs
index c2e5a5e..e51e4d4 100644
--- a/AdminTools/Commands/Unmute/All.cs
+++ b/AdminTools/Commands/Unmute/All.cs
@@ -15,7 +15,7 @@ public class All : ICommand
 
         public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.mute"))
+            if (!sender.CheckPermission("at.mute"))
             {
                 response = "You do not have permission to use this command";
                 return false;
diff --git a/AdminTools/Commands/Unmute/ICom.cs b/AdminTools/Commands/Unmute/ICom.cs
index 7d6e4be..3403d0d 100644
--- a/AdminTools/Commands/Unmute/ICom.cs
+++ b/AdminTools/Commands/Unmute/ICom.cs
@@ -9,13 +9,13 @@ public class Com : ICommand
     {
         public string Command { get; } = "icom";
 
-        public string[] Aliases { get; } = new string[] { };
+        public string[] Aliases { get; } = Array.Empty<string>();
 
         public string Description { get; } = "Removes intercom mutes everyone in the server";
 
         public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.mute"))
+            if (!sender.CheckPermission("at.mute"))
             {
                 response = "You do not have permission to use this command";
                 return false;
diff --git a/AdminTools/Commands/Unmute/RoundStart.cs b/AdminTools/Commands/Unmute/RoundStart.cs
index e1fd63d..f12e396 100644
--- a/AdminTools/Commands/Unmute/RoundStart.cs
+++ b/AdminTools/Commands/Unmute/RoundStart.cs
@@ -15,7 +15,7 @@ public class RoundStart : ICommand
 
         public bool Execute(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.mute"))
+            if (!sender.CheckPermission("at.mute"))
             {
                 response = "You do not have permission to use this command";
                 return false;
diff --git a/AdminTools/Commands/Unmute/Unmute.cs b/AdminTools/Commands/Unmute/Unmute.cs
index e89d86f..3136f44 100644
--- a/AdminTools/Commands/Unmute/Unmute.cs
+++ b/AdminTools/Commands/Unmute/Unmute.cs
@@ -6,16 +6,18 @@ namespace AdminTools.Commands.Unmute
 {
     [CommandHandler(typeof(RemoteAdminCommandHandler))]
     [CommandHandler(typeof(GameConsoleCommandHandler))]
-    public class Unmute : ParentCommand
+    public class Unmute : ParentCommand, IUsageProvider
     {
         public Unmute() => LoadGeneratedCommands();
 
         public override string Command { get; } = "punmute";
 
-        public override string[] Aliases { get; } = new string[] { };
+        public override string[] Aliases { get; } = Array.Empty<string>();
 
         public override string Description { get; } = "Unmutes everyone from speaking or by intercom in the server";
 
+        public string[] Usage { get; } = new string[] { "all/icom/roundstart" };
+
         public override void LoadGeneratedCommands()
         {
             RegisterCommand(new All());
@@ -25,7 +27,7 @@ public override void LoadGeneratedCommands()
 
         protected override bool ExecuteParent(ArraySegment<string> arguments, ICommandSender sender, out string response)
         {
-            if (!((CommandSender)sender).CheckPermission("at.mute"))
+            if (!sender.CheckPermission("at.mute"))
             {
                 response = "You do not have permission to use this command";
                 return false;
diff --git a/AdminTools/Components/InstantKillComponent.cs b/AdminTools/Components/InstantKillComponent.cs
deleted file mode 100644
index 517a3c4..0000000
--- a/AdminTools/Components/InstantKillComponent.cs
+++ /dev/null
@@ -1,41 +0,0 @@
-using Exiled.API.Features;
-using Exiled.Events.EventArgs;
-using UnityEngine;
-using Handlers = Exiled.Events.Handlers;
-
-namespace AdminTools
-{
-    using Exiled.Events.EventArgs.Player;
-    using PlayerStatsSystem;
-
-    public class InstantKillComponent : MonoBehaviour
-    {
-        public Player Player;
-        public void Awake()
-        {
-            Player = Player.Get(gameObject);
-            Handlers.Player.Hurting += RunWhenPlayerIsHurt;
-            Handlers.Player.Left += OnLeave;
-            Main.IkHubs.Add(Player, this);
-        }
-
-        private void OnLeave(LeftEventArgs ev)
-        {
-            if (ev.Player == Player)
-                Destroy(this);
-        }
-
-        public void OnDestroy()
-        {
-            Handlers.Player.Hurting -= RunWhenPlayerIsHurt;
-            Handlers.Player.Left -= OnLeave;
-            Main.IkHubs.Remove(Player);
-        }
-
-        public void RunWhenPlayerIsHurt(HurtingEventArgs ev)
-        {
-            if (ev.Attacker != ev.Player && ev.Attacker == Player)
-                ev.Amount = StandardDamageHandler.KillValue;
-        }
-    }
-}
\ No newline at end of file
diff --git a/AdminTools/Components/RegenerationComponent.cs b/AdminTools/Components/RegenerationComponent.cs
deleted file mode 100644
index dc997e7..0000000
--- a/AdminTools/Components/RegenerationComponent.cs
+++ /dev/null
@@ -1,39 +0,0 @@
-using System;
-using UnityEngine;
-using MEC;
-using System.Collections.Generic;
-using Exiled.API.Features;
-
-namespace AdminTools
-{
-    public class RegenerationComponent : MonoBehaviour
-    {
-        private Player _player;
-        CoroutineHandle _handle;
-        public void Awake()
-        {
-            _player = Player.Get(gameObject);
-            _handle = Timing.RunCoroutine(HealHealth(_player));
-            Main.RgnHubs.Add(_player, this);
-        }
-
-        public void OnDestroy()
-        {
-            Timing.KillCoroutines(_handle);
-            Main.RgnHubs.Remove(_player);
-        }
-
-        public IEnumerator<float> HealHealth(Player ply)
-        {
-            while (true)
-            {
-                if (ply.Health < ply.MaxHealth)
-                    ply.Health += Main.HealthGain;
-                else
-                    ply.Health = ply.MaxHealth;
-
-                yield return Timing.WaitForSeconds(Main.HealthInterval);
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/AdminTools/Config.cs b/AdminTools/Config.cs
index 29edb86..4e39d26 100644
--- a/AdminTools/Config.cs
+++ b/AdminTools/Config.cs
@@ -1,5 +1,4 @@
 using Exiled.API.Interfaces;
-using Exiled.Loader;
 using System.ComponentModel;
 
 namespace AdminTools
@@ -9,9 +8,19 @@ public class Config : IConfig
         [Description("Enable/Disable AdminTools.")]
         public bool IsEnabled { get; set; } = true;
 
-        public bool Debug { get; set; }
+        [Description("Whether or not to show logs used for debugging.")]
+        public bool Debug { get; set; } = false;
 
-        [Description("Should the tutorial class be in God Mode? Default: false")]
+        [Description("Should Staff be in God Mode when they forceclass to Tutorial?? Default: false")]
         public bool GodTuts { get; set; } = false;
+
+        [Description("Extending Command use for Getting a player (such as candy command and other parts of AdminTools). View the README on github for more info.")]
+        public bool ExtendedCommandUsage { get; set; } = true;
+
+        [Description("Unjail all jailed players automatically when the round restarts? Default: false")]
+        public bool ClearJailsOnRestart { get; set; } = false;
+
+        [Description("Whether or not to disable RoundLock & LobbyLock when Waiting For Players")]
+        public bool DisableLockOnWaiting { get; set; } = false;
     }
 }
\ No newline at end of file
diff --git a/AdminTools/EventHandlers.cs b/AdminTools/EventHandlers.cs
index a6b9bec..9cf5453 100644
--- a/AdminTools/EventHandlers.cs
+++ b/AdminTools/EventHandlers.cs
@@ -1,227 +1,99 @@
 namespace AdminTools
 {
-    using System;
-    using System.Collections.Generic;
     using System.IO;
-    using System.Linq;
-    using System.Text;
-    using Exiled.API.Enums;
     using Exiled.API.Features;
     using MEC;
-    using Mirror;
-    using UnityEngine;
-    using Exiled.API.Extensions;
-    using Exiled.API.Features.Items;
     using Exiled.API.Features.Doors;
     using Exiled.Events.EventArgs.Player;
     using Exiled.Events.EventArgs.Server;
-    using InventorySystem.Items.Firearms.Attachments;
     using PlayerRoles;
-    using Utils.NonAllocLINQ;
     using Exiled.API.Interfaces;
     using Log = Exiled.API.Features.Log;
-    using Object = UnityEngine.Object;
+    using PlayerStatsSystem;
+    using Handlers = Exiled.Events.Handlers;
+    using Exiled.API.Enums;
 
     public class EventHandlers
 	{
 		private readonly Main plugin;
-		public EventHandlers(Main main) => plugin = main;
-		public static List<Player> BreakDoorsList { get; } = new();
 
-		public void OnDoorOpen(InteractingDoorEventArgs ev)
+		public EventHandlers(Main main)
 		{
-			if (Main.PryGateHubs.Contains(ev.Player) && ev.Door is Gate gate)
-                gate.TryPry();
+			plugin = main;
+			
+			Handlers.Player.Verified += OnPlayerVerified;
+			Handlers.Server.RoundEnded += OnRoundEnded;
+			Handlers.Player.TriggeringTesla += OnTriggeringTesla;
+			Handlers.Server.WaitingForPlayers += OnWaitingForPlayers;
+			Handlers.Player.InteractingDoor += OnInteractingDoor;
+			Handlers.Server.RoundStarted += OnRoundStarted;
+			Handlers.Player.Destroying += OnPlayerDestroying;
+			Handlers.Player.InteractingDoor += OnPlayerInteractingDoor;
+			Handlers.Player.ChangingRole += OnChangingRole;
 		}
 
-		public static string FormatArguments(ArraySegment<string> sentence, int index)
+		~EventHandlers()
 		{
-			StringBuilder sb = new();
-			foreach (string word in sentence.Segment(index))
-			{
-				sb.Append(word);
-				sb.Append(" ");
-			}
-			string msg = sb.ToString();
-			return msg;
+			Handlers.Player.Verified -= OnPlayerVerified;
+			Handlers.Server.RoundEnded -= OnRoundEnded;
+			Handlers.Player.TriggeringTesla -= OnTriggeringTesla;
+			Handlers.Player.ChangingRole -= OnChangingRole;
+			Handlers.Server.WaitingForPlayers -= OnWaitingForPlayers;
+			Handlers.Player.InteractingDoor -= OnInteractingDoor;
+			Handlers.Server.RoundStarted -= OnRoundStarted;
+			Handlers.Player.Destroying -= OnPlayerDestroying;
+			Handlers.Player.InteractingDoor -= OnPlayerInteractingDoor;
+			Handlers.Player.ChangingRole -= OnChangingRole;
 		}
 
-		public static IEnumerator<float> SpawnBodies(Player player, RoleTypeId role, int count)
+		public void OnInteractingDoor(InteractingDoorEventArgs ev)
 		{
-			for (int i = 0; i < count; i++)
-			{
-				Ragdoll.CreateAndSpawn(role, "SCP-343", "End of the Universe", player.Position, default, null);
-				yield return Timing.WaitForSeconds(0.15f);
-			}
+			if (Main.PryGate.Contains(ev.Player) && ev.Door is Gate gate)
+                gate.TryPry();
 		}
 
-        public void OnPlayerDestroyed(DestroyingEventArgs ev)
+        public static void OnHurting(HurtingEventArgs ev)
+        {
+            if (ev.Attacker != ev.Player && Main.InstantKill.Contains(ev.Attacker))
+                ev.Amount = StandardDamageHandler.KillValue;
+        }
+
+        public void OnPlayerDestroying(DestroyingEventArgs ev)
         {
-			if (Main.RoundStartMutes.Contains(ev.Player))
+			if (Main.RoundStartMutes.Remove(ev.Player))
             {
 				ev.Player.IsMuted = false;
-				Main.RoundStartMutes.Remove(ev.Player);
             }
+			if (!Round.IsEnded)
+				Extensions.SavingPlayerData(ev.Player);
         }
 
-        public static void SpawnWorkbench(Player ply, Vector3 position, Vector3 rotation, Vector3 size, out int benchIndex)
-		{
-			try
-			{
-				Log.Debug($"Spawning workbench");
-				benchIndex = 0;
-				GameObject bench =
-					Object.Instantiate(
-						NetworkManager.singleton.spawnPrefabs.Find(p => p.gameObject.name == "Work Station"));
-				rotation.x += 180;
-				rotation.z += 180;
-                Offset offset = new()
-                {
-                    position = position,
-                    rotation = rotation,
-                    scale = Vector3.one,
-                };
-                bench.gameObject.transform.localScale = size;
-				NetworkServer.Spawn(bench);
-				if (Main.BchHubs.TryGetValue(ply, out List<GameObject> objs))
-				{
-					objs.Add(bench);
-				}
-				else
-				{
-					Main.BchHubs.Add(ply, new());
-					Main.BchHubs[ply].Add(bench);
-					benchIndex = Main.BchHubs[ply].Count();
-				}
-
-				if (benchIndex != 1)
-					benchIndex = objs.Count();
-				bench.transform.localPosition = offset.position;
-				bench.transform.localRotation = Quaternion.Euler(offset.rotation);
-				bench.AddComponent<WorkstationController>();
-			}
-			catch (Exception e)
-			{
-				Log.Error($"{nameof(SpawnWorkbench)}: {e}");
-				benchIndex = -1;
-			}
-		}
-
-        public static void SetPlayerScale(Player target, float x, float y, float z) => target.Scale = new Vector3(x, y, z);
-
-        public static void SetPlayerScale(Player target, float scale) => target.Scale = Vector3.one * scale;
-
-        public static IEnumerator<float> DoRocket(Player player, float speed)
-		{
-			const int maxAmnt = 50;
-			int amnt = 0;
-			while (player.Role != RoleTypeId.Spectator)
-			{
-				player.Position += Vector3.up * speed;
-				amnt++;
-				if (amnt >= maxAmnt)
-				{
-					player.IsGodModeEnabled = false;
-					ExplosiveGrenade grenade = (ExplosiveGrenade)Item.Create(ItemType.GrenadeHE);
-					grenade.FuseTime = 0.5f;
-					grenade.SpawnActive(player.Position, player);
-					player.Kill("Went on a trip in their favorite rocket ship.");
-				}
-
-				yield return Timing.WaitForOneFrame;
-			}
-		}
-
-		public static void DoJail(Player player, bool skipadd = false)
-		{
-			if (!skipadd)
-            {
-                Main.JailedPlayers.Add(new Jailed
-				{
-					Health = player.Health,
-                    RelativePosition = player.RelativePosition,
-					Items = player.Items.ToList(),
-					Effects = player.ActiveEffects.Select(x => new Effect(x)).ToList(),
-					Name = player.Nickname,
-					Role = player.Role,
-					Userid = player.UserId,
-					CurrentRound = true,
-					Ammo = player.Ammo.ToDictionary(x => x.Key.GetAmmoType(), x => x.Value),
-                });
-			}
-
-			if (player.IsOverwatchEnabled)
-				player.IsOverwatchEnabled = false;
-			player.Ammo.Clear();
-			player.Inventory.SendAmmoNextFrame = true;
-
-            player.ClearInventory(false);
-			player.Role.Set(RoleTypeId.Tutorial, RoleSpawnFlags.UseSpawnpoint);
-		}
-
-		public static void DoUnJail(Player player)
-		{
-			Jailed jail = Main.JailedPlayers.Find(j => j.Userid == player.UserId);
-			if (jail.CurrentRound)
-			{
-				player.Role.Set(jail.Role, RoleSpawnFlags.None);
-				try
-				{
-					player.ResetInventory(jail.Items);
-                    player.Health = jail.Health;
-					player.Position = jail.RelativePosition.Position;
-					foreach (KeyValuePair<AmmoType, ushort> kvp in jail.Ammo)
-						player.Ammo[kvp.Key.GetItemType()] = kvp.Value;
-					player.SyncEffects(jail.Effects);
-
-                    player.Inventory.SendItemsNextFrame = true;
-                    player.Inventory.SendAmmoNextFrame = true;
-                }
-                catch (Exception e)
-				{
-					Log.Error($"{nameof(DoUnJail)}: {e}");
-				}
-			}
-			else
-			{
-				player.Role.Set(RoleTypeId.Spectator, RoleSpawnFlags.UseSpawnpoint);
-			}
-			Main.JailedPlayers.Remove(jail);
-		}
-
 		public void OnPlayerVerified(VerifiedEventArgs ev)
 		{
-			try
-			{
-				if (Main.JailedPlayers.Any(j => j.Userid == ev.Player.UserId))
-					DoJail(ev.Player, true);
+            if (Main.JailedPlayers.ContainsKey(ev.Player.UserId))
+                Commands.Jail.DoJail(ev.Player, true);
 
-				if (File.ReadAllText(plugin.OverwatchFilePath).Contains(ev.Player.UserId))
-				{
-					Log.Debug($"Putting {ev.Player.UserId} into overwatch.");
-					ev.Player.IsOverwatchEnabled = true;
-				}
+            if (ev.Player.RemoteAdminPermissions.HasFlag(PlayerPermissions.Overwatch) && Main.Overwatch.Contains(ev.Player.UserId))
+            {
+                Log.Debug($"Putting {ev.Player.UserId} into overwatch.");
+                ev.Player.IsOverwatchEnabled = true;
+            }
 
-				if (File.ReadAllText(plugin.HiddenTagsFilePath).Contains(ev.Player.UserId))
-				{
-					Log.Debug($"Hiding {ev.Player.UserId}'s tag.");
-					Timing.CallDelayed(Timing.WaitForOneFrame, () => ev.Player.BadgeHidden = true);
-				}
+            if (Main.HiddenTags.Contains(ev.Player.UserId))
+            {
+                Log.Debug($"Hiding {ev.Player.UserId}'s tag.");
+                Timing.CallDelayed(Timing.WaitForOneFrame, () => ev.Player.BadgeHidden = true);
+            }
 
-				if (Main.RoundStartMutes.Count != 0 && !ev.Player.ReferenceHub.serverRoles.RemoteAdmin && !Main.RoundStartMutes.Contains(ev.Player))
-                {
-					Log.Debug($"Muting {ev.Player.UserId} (no RA).");
-					ev.Player.IsMuted = true;
-					Main.RoundStartMutes.Add(ev.Player);
-                }
-			}
-			catch (Exception e)
-			{
-				Log.Error($"Player Join: {e}");
-			}
-		}
+            if (Main.RoundStartMutes.Count != 0 && !ev.Player.RemoteAdminAccess && !Main.RoundStartMutes.Contains(ev.Player))
+            {
+                Log.Debug($"Muting {ev.Player.UserId} (no RA).");
+                ev.Player.IsMuted = true;
+                Main.RoundStartMutes.Add(ev.Player);
+            }
+        }
 
-		public void OnRoundStart()
+		public void OnRoundStarted()
 		{
 			foreach (Player ply in Main.RoundStartMutes)
 			{
@@ -233,75 +105,50 @@ public void OnRoundStart()
 			Main.RoundStartMutes.Clear();
 		}
 
-		public void OnRoundEnd(RoundEndedEventArgs ev)
-		{
-			try
-			{
-				List<string> overwatchRead = File.ReadAllLines(plugin.OverwatchFilePath).ToList();
-				List<string> tagsRead = File.ReadAllLines(plugin.HiddenTagsFilePath).ToList();
-
-				foreach (Player player in Player.List)
-				{
-					string userId = player.UserId;
-
-					if (player.IsOverwatchEnabled && !overwatchRead.Contains(userId))
-						overwatchRead.Add(userId);
-					else if (!player.IsOverwatchEnabled && overwatchRead.Contains(userId))
-						overwatchRead.Remove(userId);
-
-					if (player.BadgeHidden && !tagsRead.Contains(userId))
-						tagsRead.Add(userId);
-					else if (!player.BadgeHidden && tagsRead.Contains(userId))
-						tagsRead.Remove(userId);
-				}
+		public void OnRoundEnded(RoundEndedEventArgs ev)
+        {
+			// Update all the jails that it is no longer the current round, so when they are unjailed they don't teleport into the void.
+            foreach (Jailed jail in Main.JailedPlayers.Values)
+            {
+                if (jail.CurrentRound)
+                    jail.CurrentRound = false;
+            }
 
-				foreach (string s in overwatchRead)
-					Log.Debug($"{s} is in overwatch.");
-				foreach (string s in tagsRead)
-					Log.Debug($"{s} has their tag hidden.");
-				File.WriteAllLines(plugin.OverwatchFilePath, overwatchRead);
-				File.WriteAllLines(plugin.HiddenTagsFilePath, tagsRead);
+            foreach (Player player in Player.List)
+                Extensions.SavingPlayerData(player);
 
-				// Update all the jails that it is no longer the current round, so when they are unjailed they don't teleport into the void.
-				foreach (Jailed jail in Main.JailedPlayers)
-				{
-					if(jail.CurrentRound)
-						jail.CurrentRound = false;
-				}
-			}
-			catch (Exception e)
-			{
-				Log.Error($"Round End: {e}");
-			}
-
-			if (Main.RestartOnEnd)
-			{
-				Log.Info("Restarting server....");
-				Round.Restart(false, true, ServerStatic.NextRoundAction.Restart);
-			}
-		}
+            File.WriteAllLines(plugin.OverwatchFilePath, Main.Overwatch);
+        }
 
-		public void OnTriggerTesla(TriggeringTeslaEventArgs ev)
+        public void OnTriggeringTesla(TriggeringTeslaEventArgs ev)
 		{
 			if (ev.Player.IsGodModeEnabled)
 				ev.IsAllowed = false;
 		}
 
-		public void OnSetClass(ChangingRoleEventArgs ev)
+		public void OnChangingRole(ChangingRoleEventArgs ev)
 		{
-			if (plugin.Config.GodTuts)
+			if (plugin.Config.GodTuts && ev.Player.RemoteAdminAccess && ev.Reason == SpawnReason.ForceClass)
 				ev.Player.IsGodModeEnabled = ev.NewRole == RoleTypeId.Tutorial;
 		}
 
-		public void OnWaitingForPlayers()
+        public void OnWaitingForPlayers()
 		{
-			Main.IkHubs.Clear();
-			BreakDoorsList.Clear();
-		}
+			Main.InstantKill.Clear();
+            Main.BreakDoors.Clear();
+            Main.PryGate.Clear();
+            if (plugin.Config.ClearJailsOnRestart)
+                Main.JailedPlayers.Clear();
+            if (plugin.Config.DisableLockOnWaiting)
+            {
+	            Round.IsLobbyLocked = false;
+	            Round.IsLocked = false;
+            }
+        }
 
-		public void OnPlayerInteractingDoor(InteractingDoorEventArgs ev)
+        public void OnPlayerInteractingDoor(InteractingDoorEventArgs ev)
 		{
-			if (BreakDoorsList.Contains(ev.Player) && ev.Door is IDamageableDoor damageableDoor)
+			if (Main.BreakDoors.Contains(ev.Player) && ev.Door is IDamageableDoor damageableDoor)
                 damageableDoor.Break();
         }
 	}
diff --git a/AdminTools/Extensions.cs b/AdminTools/Extensions.cs
new file mode 100644
index 0000000..f515058
--- /dev/null
+++ b/AdminTools/Extensions.cs
@@ -0,0 +1,94 @@
+using Exiled.API.Features;
+using InventorySystem.Items.Firearms.Attachments;
+using Mirror;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using UnityEngine;
+
+namespace AdminTools
+{
+    public static class Extensions
+    {
+        public static string FormatArguments(this ArraySegment<string> sentence, int index)
+        {
+            StringBuilder sb = new();
+            foreach (string word in sentence.Segment(index))
+            {
+                sb.Append(word);
+                sb.Append(" ");
+            }
+            string msg = sb.ToString();
+            return msg;
+        }
+
+        public static string LogPlayers(this IEnumerable<Player> players) => string.Join("\n - ", players.Select(x => $"{x.Nickname}({x.Id})"));
+
+        public static void SavingPlayerData(this Player player)
+        {
+            List<string> overwatchRead = Main.Overwatch;
+            List<string> tagsRead = Main.HiddenTags;
+
+            string userId = player.UserId;
+
+            if (player.IsOverwatchEnabled && !overwatchRead.Contains(userId))
+            {
+                overwatchRead.Add(userId);
+                Log.Debug($"{player.Nickname}({player.UserId}) has added their overwatch.");
+            }
+            else if (!player.IsOverwatchEnabled && overwatchRead.Remove(userId))
+                Log.Debug($"{player.Nickname}({player.UserId}) has remove their overwatch.");
+
+            if (player.BadgeHidden && !tagsRead.Contains(userId))
+            {
+                tagsRead.Add(userId);
+                Log.Debug($"{player.Nickname}({player.UserId}) has added their tag hidden.");
+            }
+            else if (!player.BadgeHidden && tagsRead.Remove(userId))
+                Log.Debug($"{player.Nickname}({player.UserId}) has remove their tag hidden.");
+        }
+        public static void SpawnWorkbench(Player ply, Vector3 position, Vector3 rotation, Vector3 size, out int benchIndex)
+        {
+            try
+            {
+                Log.Debug($"Spawning workbench");
+                benchIndex = 0;
+                GameObject bench =
+                    UnityEngine.Object.Instantiate(
+                        NetworkClient.prefabs.Values.First(x => x.name.Contains("Work Station")));
+                rotation.x += 180;
+                rotation.z += 180;
+                Offset offset = new()
+                {
+                    position = position,
+                    rotation = rotation,
+                    scale = Vector3.one,
+                };
+                bench.gameObject.transform.localScale = size;
+                NetworkServer.Spawn(bench);
+                if (Main.BchHubs.TryGetValue(ply, out List<GameObject> objs))
+                {
+                    objs.Add(bench);
+                }
+                else
+                {
+                    Main.BchHubs.Add(ply, new());
+                    Main.BchHubs[ply].Add(bench);
+                    benchIndex = Main.BchHubs[ply].Count();
+                }
+
+                if (benchIndex != 1)
+                    benchIndex = objs.Count();
+                bench.transform.localPosition = offset.position;
+                bench.transform.localRotation = Quaternion.Euler(offset.rotation);
+                bench.AddComponent<WorkstationController>();
+            }
+            catch (Exception e)
+            {
+                Log.Error($"{nameof(SpawnWorkbench)}: {e}");
+                benchIndex = -1;
+            }
+        }
+    }
+}
diff --git a/AdminTools/Jailed.cs b/AdminTools/Jailed.cs
index 0102d83..91af7be 100644
--- a/AdminTools/Jailed.cs
+++ b/AdminTools/Jailed.cs
@@ -1,16 +1,14 @@
 using Exiled.API.Enums;
 using System.Collections.Generic;
+using Exiled.API.Features.Items;
+using PlayerRoles;
+using RelativePositioning;
+using Exiled.API.Features;
 
 namespace AdminTools
 {
-    using Exiled.API.Features.Items;
-	using PlayerRoles;
-    using RelativePositioning;
-    using Exiled.API.Features;
-
     public class Jailed
 	{
-		public string Userid;
 		public string Name;
 		public List<Item> Items;
 		public List<Effect> Effects;
diff --git a/AdminTools/Main.cs b/AdminTools/Main.cs
index a5aa1fa..026570f 100644
--- a/AdminTools/Main.cs
+++ b/AdminTools/Main.cs
@@ -2,86 +2,77 @@
 using System.Collections.Generic;
 using System.IO;
 using Exiled.API.Features;
-using Handlers = Exiled.Events.Handlers;
 using UnityEngine;
+using HarmonyLib;
+using Utils;
+using System.Linq;
+using AdminTools.Patches;
+using CommandSystem.Commands.RemoteAdmin.Doors;
+using Exiled.API.Enums;
 
 namespace AdminTools
 {
 	public class Main : Plugin<Config>
 	{
-		public override string Author { get; } = "Exiled-Team";
-		public override string Name { get; } = "Admin Tools";
-		public override string Prefix { get; } = "AT";
-        public override Version Version { get; } = new(7, 1, 0);
+		public static List<string> Overwatch { get; internal set; }
+		public static List<string> HiddenTags { get; internal set; }
+		public static Dictionary<string, Jailed> JailedPlayers { get; } = new();
+		public static List<Player> PryGate { get; } = new();
+		public static List<Player> InstantKill { get; } = new();
+		public static List<Player> BreakDoors { get; } = new();
+		public static List<Player> RoundStartMutes { get; } = new();
+		public static Dictionary<Player, List<GameObject>> BchHubs { get; } = new();
 
-        public override Version RequiredExiledVersion { get; } = new(8, 5, 0);
+		public string OverwatchFilePath { get; private set; }
 
-        public EventHandlers EventHandlers;
-		public static System.Random NumGen = new();
-		public static List<Jailed> JailedPlayers = new();
-		public static Dictionary<Player, InstantKillComponent> IkHubs = new();
-		public static Dictionary<Player, RegenerationComponent> RgnHubs = new();
-		public static HashSet<Player> PryGateHubs = new();
-		public static Dictionary<Player, List<GameObject>> BchHubs = new();
-		public static Dictionary<Player, List<GameObject>> DumHubs = new();
-		public static float HealthGain = 5;
-		public static float HealthInterval = 1;
-		public string OverwatchFilePath;
-		public string HiddenTagsFilePath;
-		public static bool RestartOnEnd = false;
-		public static HashSet<Player> RoundStartMutes = new();
+		public Harmony Harmony { get; } = new("Exiled-AdminTools");
+		public EventHandlers EventHandlers { get; private set; }
+		
+		public override string Author { get; } = "Exiled-Team";
+		public override string Name { get; } = "Admin Tools";
+		public override string Prefix { get; } = "AdminTools";
+		public override PluginPriority Priority { get; } = (PluginPriority)1;
+		public override Version Version { get; } = new(8, 0, 0);
+        public override Version RequiredExiledVersion { get; } = new(8, 8, 0);
 
-		public override void OnEnabled()
+        public override void OnEnabled()
 		{
 			try
 			{
-				string appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
-				string pluginPath = Path.Combine(appData, "Plugins");
-				string path = Path.Combine(Paths.Plugins, "AdminTools");
+				string path = Path.Combine(Paths.Configs, "AdminTools");
 				string overwatchFileName = Path.Combine(path, "AdminTools-Overwatch.txt");
-				string hiddenTagFileName = Path.Combine(path, "AdminTools-HiddenTags.txt");
+                OverwatchFilePath = overwatchFileName;
 
-				if (!Directory.Exists(path))
+                if (!Directory.Exists(path))
 					Directory.CreateDirectory(path);
 
 				if (!File.Exists(overwatchFileName))
 					File.Create(overwatchFileName).Close();
-
-				if (!File.Exists(hiddenTagFileName))
-					File.Create(hiddenTagFileName).Close();
-
-				OverwatchFilePath = overwatchFileName;
-				HiddenTagsFilePath = hiddenTagFileName;
+				else
+                    Overwatch = File.ReadAllLines(overwatchFileName).ToList();
             }
             catch (Exception e)
             {
                 Log.Error($"Loading error: {e}");
             }
 
-            EventHandlers = new EventHandlers(this);
-            Handlers.Player.Verified += EventHandlers.OnPlayerVerified;
-            Handlers.Server.RoundEnded += EventHandlers.OnRoundEnd;
-            Handlers.Player.TriggeringTesla += EventHandlers.OnTriggerTesla;
-            Handlers.Player.ChangingRole += EventHandlers.OnSetClass;
-            Handlers.Server.WaitingForPlayers += EventHandlers.OnWaitingForPlayers;
-            Handlers.Player.InteractingDoor += EventHandlers.OnDoorOpen;
-            Handlers.Server.RoundStarted += EventHandlers.OnRoundStart;
-            Handlers.Player.Destroying += EventHandlers.OnPlayerDestroyed;
-            Handlers.Player.InteractingDoor += EventHandlers.OnPlayerInteractingDoor;
+            EventHandlers = new(this);
+
+            if (Config.ExtendedCommandUsage)
+            {
+	            Harmony.Patch(AccessTools.Method(typeof(RAUtils), nameof(RAUtils.ProcessPlayerIdOrNamesList)), new(AccessTools.Method(typeof(CustomRAUtilsAddon), nameof(CustomRAUtilsAddon.Prefix))));
+	            Harmony.Patch(AccessTools.Method(typeof(BaseDoorCommand), nameof(BaseDoorCommand.Execute)), transpiler: new(AccessTools.Method(typeof(DoorCommandPatch), nameof(DoorCommandPatch.Transpiler))));
+            }
+
+            base.OnEnabled();
 		}
 
 		public override void OnDisabled()
 		{
-			Handlers.Player.InteractingDoor -= EventHandlers.OnDoorOpen;
-			Handlers.Player.Verified -= EventHandlers.OnPlayerVerified;
-			Handlers.Server.RoundEnded -= EventHandlers.OnRoundEnd;
-			Handlers.Player.TriggeringTesla -= EventHandlers.OnTriggerTesla;
-			Handlers.Player.ChangingRole -= EventHandlers.OnSetClass;
-			Handlers.Server.WaitingForPlayers -= EventHandlers.OnWaitingForPlayers;
-			Handlers.Server.RoundStarted -= EventHandlers.OnRoundStart;
-			Handlers.Player.Destroying -= EventHandlers.OnPlayerDestroyed;
-			EventHandlers = null;
-			NumGen = null;
+			Harmony?.UnpatchAll(Harmony.Id);
+            EventHandlers = null;
+            
+            base.OnDisabled();
 		}
 	}
 }
\ No newline at end of file
diff --git a/AdminTools/Patches/DoorCommandPatche.cs b/AdminTools/Patches/DoorCommandPatche.cs
new file mode 100644
index 0000000..3c52eee
--- /dev/null
+++ b/AdminTools/Patches/DoorCommandPatche.cs
@@ -0,0 +1,66 @@
+using static HarmonyLib.AccessTools;
+using HarmonyLib;
+using System;
+using System.Collections.Generic;
+using System.Reflection.Emit;
+using Exiled.API.Features.Pools;
+using Interactables.Interobjects.DoorUtils;
+using Exiled.API.Features.Doors;
+using Exiled.API.Enums;
+using Exiled.API.Features;
+
+namespace AdminTools.Patches
+{
+    internal static class DoorCommandPatch
+    {
+        internal static IEnumerable<CodeInstruction> Transpiler(IEnumerable<CodeInstruction> instructions, ILGenerator generator)
+        {
+            List<CodeInstruction> newInstructions = ListPool<CodeInstruction>.Pool.Get(instructions);
+            
+            Label found = generator.DefineLabel();
+
+            int offset = -1;
+            int index = newInstructions.FindLastIndex(x => x.opcode == OpCodes.Ldloc_S && ((System.Reflection.Emit.LocalBuilder)x.operand).LocalIndex is 10) + offset;
+
+            newInstructions.InsertRange(index, new CodeInstruction[]
+            {
+                // doorVariant
+                new CodeInstruction(OpCodes.Ldloc_S, 6).MoveLabelsFrom(newInstructions[index]),
+
+                // array[]
+                new(OpCodes.Ldloc_2),
+                
+                // text2
+                new(OpCodes.Ldloca_S, 9),
+
+                // DoorCommandPatche.GetExiledDoor(doorvariant, array, ref text)
+                new(OpCodes.Call, Method(typeof(DoorCommandPatch), nameof(GetExiledDoor))),
+                new(OpCodes.Brtrue_S, found),
+            });
+
+            offset = 2;
+            index = newInstructions.FindIndex(x => x.operand == (object)PropertyGetter(typeof(DoorNametagExtension), nameof(DoorNametagExtension.GetName))) + offset;
+
+            newInstructions[index].labels.Add(found);
+
+            for (int z = 0; z < newInstructions.Count; z++)
+                yield return newInstructions[z];
+
+            ListPool<CodeInstruction>.Pool.Return(newInstructions);
+        }
+        
+        private static bool GetExiledDoor(DoorVariant doorVariant, string[] doors, ref string text)
+        {
+            DoorType searchdoortype = Door.Get(doorVariant).Type;
+            foreach (string door in doors)
+            {
+                if (string.IsNullOrEmpty(door) || !Enum.TryParse(door, true, out DoorType doorType) || doorType != searchdoortype)
+                    continue;
+                text = ", " + doorType.ToString();
+                return true;
+            }
+
+            return false;
+        }
+    }
+}
diff --git a/AdminTools/Patches/RAUtilsAddon.cs b/AdminTools/Patches/RAUtilsAddon.cs
new file mode 100644
index 0000000..5ce37eb
--- /dev/null
+++ b/AdminTools/Patches/RAUtilsAddon.cs
@@ -0,0 +1,131 @@
+using Exiled.API.Enums;
+using Exiled.API.Features;
+using NorthwoodLib.Pools;
+using PlayerRoles;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using Utils;
+
+namespace AdminTools.Patches
+{
+    public static class CustomRAUtilsAddon
+    {
+        public static bool Prefix(ref List<ReferenceHub> __result, ArraySegment<string> args, int startindex, out string[] newargs, bool keepEmptyEntries = false)
+        {
+            Log.Debug("BetterCommands::CustomRAUtilsAddon was called.");
+            string text = RAUtils.FormatArguments(args, startindex);
+            List<ReferenceHub> list = ListPool<ReferenceHub>.Shared.Rent();
+            
+            if (text.StartsWith("@", StringComparison.Ordinal))
+            {
+                foreach (object obj in new Regex("@\"(.*?)\".|@[^\\s.]+\\.").Matches(text))
+                {
+                    Match match = (Match)obj;
+                    text = RAUtils.ReplaceFirst(text, match.Value, "");
+                    string name = match.Value.Substring(1).Replace("\"", "").Replace(".", "");
+                    List<ReferenceHub> list2 = (from ply in ReferenceHub.AllHubs
+                                                where ply.nicknameSync.MyNick.Equals(name)
+                                                select ply).ToList();
+                    if (list2.Count == 1 && !list.Contains(list2[0]))
+                    {
+                        list.Add(list2[0]);
+                    }
+                }
+                newargs = text.Split(new char[]
+                {
+                        ' '
+                }, keepEmptyEntries ? StringSplitOptions.None : StringSplitOptions.RemoveEmptyEntries);
+                __result = list;
+            }
+            else
+            {
+                if (args.At(startindex).Length > 0)
+                {
+                    string[] array = args.At(startindex).Split('.');
+                    for (int i = 0; i < array.Length; i++)
+                    {
+                        if (array[i].ToLower() is "all" or "*")
+                        {
+                            list.AddRange(Player.List.Select(x => x.ReferenceHub));
+                            break;
+                        }
+                        if (int.TryParse(array[i], out int playerId))
+                        {
+                            if (playerId < 1)
+                                continue;
+
+                            if (ReferenceHub.TryGetHub(playerId, out ReferenceHub item))
+                                list.Add(item);
+                        }
+                        else if (Enum.TryParse(array[i], true, out SimplifyTeam simplifyTeam))
+                        {
+                            switch (simplifyTeam)
+                            {
+                                case SimplifyTeam.ALIVE:
+                                    list.AddRange(Player.List.Where(p => p.IsAlive).Select(x => x.ReferenceHub));
+                                    break;
+                                case SimplifyTeam.HUMAN:
+                                    list.AddRange(Player.List.Where(p => p.IsHuman).Select(x => x.ReferenceHub));
+                                    break;
+                                case SimplifyTeam.CIVILIAN:
+                                    list.AddRange(Player.List.Where(p => p.Role.Team is Team.Scientists or Team.ClassD).Select(x => x.ReferenceHub));
+                                    break;
+                                case SimplifyTeam.MILITARY:
+                                    list.AddRange(Player.List.Where(p => p.Role.Team is Team.FoundationForces or Team.ChaosInsurgency).Select(p => p.ReferenceHub));
+                                    break;
+                                case SimplifyTeam.STAFF:
+                                    list.AddRange(Player.List.Where(p => p.RemoteAdminAccess).Select(p => p.ReferenceHub));
+                                    break;
+                                case SimplifyTeam.NOSTAFF:
+                                    list.AddRange(Player.List.Where(p => !p.RemoteAdminAccess).Select(p => p.ReferenceHub));
+                                    break;
+                                default:
+                                    list.AddRange(Player.Get((Team)simplifyTeam).Select(x => x.ReferenceHub));
+                                    break;
+                            }
+                        }
+                        else if (Enum.TryParse(array[i], true, out RoleTypeId roleType))
+                        {
+                            list.AddRange(Player.Get(roleType).Select(x => x.ReferenceHub));
+                        }
+                        else if (Enum.TryParse(array[i], true, out Side side))
+                        {
+                            list.AddRange(Player.Get(side).Select(x => x.ReferenceHub));
+                        }
+                        else if (Enum.TryParse(array[i], true, out Team team))
+                        {
+                            list.AddRange(Player.Get(team).Select(x => x.ReferenceHub));
+                        }
+                    }
+                }
+                newargs = args.Count > 1 ? RAUtils.FormatArguments(args, startindex + 1).Split(new char[]
+                {
+                        ' '
+                }, keepEmptyEntries ? StringSplitOptions.None : StringSplitOptions.RemoveEmptyEntries) : null;
+                __result = list;
+            }
+            return false;
+        }
+
+        public enum SimplifyTeam
+        {
+            // Team but simple enum
+            SCP,
+            MTF,
+            CI,
+            SCI,
+            CLD,
+            RIP,
+            TUT,
+            // Additional (Not Team)
+            ALIVE,
+            HUMAN,
+            CIVILIAN,
+            MILITARY,
+            NOSTAFF,
+            STAFF,
+        }
+    }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 1fe5915..b1ebb3f 100644
--- a/README.md
+++ b/README.md
@@ -3,6 +3,7 @@ An SCP:SL EXILED plugin that gives server owners fun commands and logging functi
 
 ### Features
 ```
+- Command extensions (View ExtendedCommandUsage for details)
 - Log commands in your server files!
 - Quickly send a message to all staff
 - Set AHP of players with ease
@@ -42,20 +43,17 @@ An SCP:SL EXILED plugin that gives server owners fun commands and logging functi
 
 ### Permissions
 ```
-abc - PlayerPermissions.Broadcasting (config_remoteadmin.txt)
 ahp - PlayerPermissions.PlayersManagement (config_remoteadmin.txt)
-ball - at.ball
-breakdoors - at.bd
-dropitem - at.items
-dropsize - at.items
+ball - PlayerPermissions.GivingItems (config_remoteadmin.txt)
+dropitem - PlayerPermissions.GivingItems (config_remoteadmin.txt)
+dropsize - PlayerPermissions.GivingItems (config_remoteadmin.txt)
 dummy - at.dummy
 expl - at.explode
 ghost - at.ghost
 grenade - at.grenade
-hbc - PlayerPermissions.Broadcasting (config_remoteadmin.txt)
-hp - PlayerPermissions.PlayersManagement (config_remoteadmin.txt)
-instantkill - at.ik
-inventory - at.inv
+hintbroadcast - PlayerPermissions.Broadcasting (config_remoteadmin.txt)
+instantkill - at.instakill
+inventory - PlayerPermissions.GivingItems (config_remoteadmin.txt)
 jail - at.jail
 kick - at.kick
 kill - at.kill
@@ -63,16 +61,22 @@ pbc - PlayerPermissions.Broadcasting (config_remoteadmin.txt)
 position - at.tp
 prygate - at.prygate
 randomtp - PlayerPermissions.PlayersManagement (config_remoteadmin.txt) 
-reg - at.reg
+regeneration - at.reg
 rocket - at.rocket
 scale - at.size
-sendmessage - at.sm
 size - at.size
 spawnragdoll - at.dolls
 spawnworkbench - at.benches
-strip - PlayerPermissions.PlayersManagement (config_remoteadmin.txt)
-tags - at.tags
 targetghost - at.targetghost
-teleportx - at.tp
-tutorial - at.tut
+teleportx - PlayerPermissions.PlayersManagement (config_remoteadmin.txt)
 ```
+### ExtendedCommandUsage
+```
+Enabling this will make it easier to specify multiple people in command usage.
+New options:
+All & * for selecting all players currently on the server.
+RoleTypeId enum for selecting players currently part of that role
+Team enum for selecting players currently part of that team
+SimplifiedTeam: Scp, Mtf, Ci (Chaos Insurgency), Sci (Scientists), Cld (Class D), Rip (Dead), Tut (Tutorial)
+Additional: Alive, Human, Civilian, Military, Staff, NoStaff
+```
\ No newline at end of file