How to make a Rust admin entity remover plugin (raycast kill and prefab killall)

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Admin Entity Remover", "RustPluginGenerator", "1.0.0")]
    [Description("Gives admins raycast /kill and prefab-based /killall entity removal with a confirmation window")]
    public class AdminEntityRemover : RustPlugin
    {
        private const string PermUse = "adminentityremover.use";
        private const int PlayerLayer = 1 << 0;

        private PluginConfig config;
        private readonly Dictionary<ulong, PendingBatch> pending = new Dictionary<ulong, PendingBatch>();

        private class PendingBatch
        {
            public List<BaseNetworkable> Entities = new List<BaseNetworkable>();
            public string Prefab;
            public float ExpiresAt;
            public Timer Timeout;
        }

        private class PluginConfig
        {
            [JsonProperty("Maximum ray distance")]
            public float MaxRayDistance = 10f;

            [JsonProperty("Confirmation window (seconds)")]
            public float ConfirmSeconds = 10f;

            [JsonProperty("Maximum entities per batch")]
            public int MaxBatchSize = 500;

            [JsonProperty("Excluded prefabs")]
            public List<string> ExcludedPrefabs = new List<string> { "player", "santasleepingbag" };
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["NoPermission"] = "You do not have permission to use this command.",
                ["NoTarget"] = "No entity found under your crosshair.",
                ["Killed"] = "Removed {0} (id {1}).",
                ["Usage"] = "Usage: /killall <shortprefabname|last> | /killall confirm | /killall cancel",
                ["NoMatches"] = "No entities matched '{0}'.",
                ["Excluded"] = "'{0}' is in the excluded prefabs list.",
                ["AlreadyPending"] = "A batch for '{0}' is already waiting for confirmation. Type /killall confirm.",
                ["BatchReady"] = "{0} entities match '{1}'. Type /killall confirm within {2} seconds to remove them.",
                ["BatchTrimmed"] = "Listed {0} entities, trimmed to the configured limit of {1}.",
                ["ConfirmExpired"] = "The confirmation window has expired. Run /killall again.",
                ["NothingPending"] = "You have no pending batch to confirm.",
                ["Cancelled"] = "Pending batch cleared.",
                ["Timeout"] = "The confirmation window for '{0}' closed. Nothing was removed.",
                ["RemovedCount"] = "Removed {0} of {1} entities matching '{2}'."
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args) =>
            string.Format(lang.GetMessage(key, this, userId), args);

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
        }

        private void OnServerInitialized()
        {
            Puts($"AdminEntityRemover ready. Ray distance {config.MaxRayDistance}m, confirm window {config.ConfirmSeconds}s.");
        }

        private void Unload()
        {
            foreach (var batch in pending.Values)
            {
                batch.Timeout?.Destroy();
            }
            pending.Clear();
        }

        [ChatCommand("kill")]
        private void CmdKill(BasePlayer player, string command, string[] args)
        {
            if (!HasPermission(player)) return;
            if (player.IsDead()) return;

            RaycastHit hit;
            var ray = new Ray(player.eyes.position, player.eyes.HeadForward());
            if (!Physics.Raycast(ray, out hit, config.MaxRayDistance, ~PlayerLayer, QueryTriggerInteraction.Ignore))
            {
                player.ChatMessage(Msg("NoTarget", player.UserIDString));
                return;
            }

            var entity = hit.collider.GetComponentInParent<BaseEntity>();
            if (entity == null || entity == player)
            {
                player.ChatMessage(Msg("NoTarget", player.UserIDString));
                return;
            }

            var label = entity.ShortPrefabName ?? entity.PrefabName;
            var id = entity.net?.ID.Value ?? 0;
            entity.Kill();
            player.ChatMessage(Msg("Killed", player.UserIDString, label, id));
        }

        [ChatCommand("killall")]
        private void CmdKillAll(BasePlayer player, string command, string[] args)
        {
            if (!HasPermission(player)) return;

            if (args == null || args.Length == 0)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            var arg = args[0].ToLowerInvariant();
            if (arg == "confirm")
            {
                Confirm(player);
                return;
            }
            if (arg == "cancel")
            {
                ClearPending(player.userID);
                player.ChatMessage(Msg("Cancelled", player.UserIDString));
                return;
            }

            if (pending.ContainsKey(player.userID))
            {
                player.ChatMessage(Msg("AlreadyPending", player.UserIDString, pending[player.userID].Prefab));
                return;
            }

            var matches = new List<BaseNetworkable>();
            string prefabLabel;

            if (arg == "last")
            {
                RaycastHit hit;
                var ray = new Ray(player.eyes.position, player.eyes.HeadForward());
                if (!Physics.Raycast(ray, out hit, config.MaxRayDistance, ~PlayerLayer, QueryTriggerInteraction.Ignore))
                {
                    player.ChatMessage(Msg("NoTarget", player.UserIDString));
                    return;
                }
                var entity = hit.collider.GetComponentInParent<BaseEntity>();
                if (entity == null || entity == player)
                {
                    player.ChatMessage(Msg("NoTarget", player.UserIDString));
                    return;
                }
                prefabLabel = entity.ShortPrefabName;
                matches.Add(entity);
            }
            else
            {
                prefabLabel = args[0];
                if (IsExcluded(prefabLabel))
                {
                    player.ChatMessage(Msg("Excluded", player.UserIDString, prefabLabel));
                    return;
                }

                foreach (var networkable in BaseNetworkable.serverEntities)
                {
                    var entity = networkable as BaseNetworkable;
                    if (entity == null || entity.IsDestroyed) continue;
                    if (string.IsNullOrEmpty(entity.ShortPrefabName)) continue;
                    if (!entity.ShortPrefabName.Equals(prefabLabel, StringComparison.OrdinalIgnoreCase)) continue;
                    if (IsExcluded(entity.ShortPrefabName)) continue;
                    matches.Add(entity);
                }
            }

            if (matches.Count == 0)
            {
                player.ChatMessage(Msg("NoMatches", player.UserIDString, prefabLabel));
                return;
            }

            var trimmed = false;
            if (matches.Count > config.MaxBatchSize)
            {
                matches.RemoveRange(config.MaxBatchSize, matches.Count - config.MaxBatchSize);
                trimmed = true;
            }

            var batch = new PendingBatch
            {
                Entities = matches,
                Prefab = prefabLabel,
                ExpiresAt = Time.realtimeSinceStartup + config.ConfirmSeconds
            };
            batch.Timeout = timer.Once(config.ConfirmSeconds, () => OnConfirmTimeout(player.userID));
            pending[player.userID] = batch;

            if (trimmed)
            {
                player.ChatMessage(Msg("BatchTrimmed", player.UserIDString, matches.Count, config.MaxBatchSize));
            }
            player.ChatMessage(Msg("BatchReady", player.UserIDString, matches.Count, prefabLabel, config.ConfirmSeconds));
        }

        private void Confirm(BasePlayer player)
        {
            PendingBatch batch;
            if (!pending.TryGetValue(player.userID, out batch))
            {
                player.ChatMessage(Msg("NothingPending", player.UserIDString));
                return;
            }

            if (Time.realtimeSinceStartup > batch.ExpiresAt)
            {
                ClearPending(player.userID);
                player.ChatMessage(Msg("ConfirmExpired", player.UserIDString));
                return;
            }

            var queued = batch.Entities.Count;
            var removed = 0;
            foreach (var entity in batch.Entities)
            {
                if (entity == null || entity.IsDestroyed) continue;
                entity.Kill();
                removed++;
            }

            var label = batch.Prefab;
            ClearPending(player.userID);
            player.ChatMessage(Msg("RemovedCount", player.UserIDString, removed, queued, label));
        }

        private void OnConfirmTimeout(ulong userId)
        {
            PendingBatch batch;
            if (!pending.TryGetValue(userId, out batch)) return;

            var prefab = batch.Prefab;
            pending.Remove(userId);

            var player = BasePlayer.FindByID(userId);
            if (player != null && player.IsConnected)
            {
                player.ChatMessage(Msg("Timeout", player.UserIDString, prefab));
            }
        }

        private void ClearPending(ulong userId)
        {
            PendingBatch batch;
            if (!pending.TryGetValue(userId, out batch)) return;
            batch.Timeout?.Destroy();
            pending.Remove(userId);
        }

        private bool IsExcluded(string shortPrefabName)
        {
            if (config.ExcludedPrefabs == null || string.IsNullOrEmpty(shortPrefabName)) return false;
            foreach (var excluded in config.ExcludedPrefabs)
            {
                if (!string.IsNullOrEmpty(excluded) && excluded.Equals(shortPrefabName, StringComparison.OrdinalIgnoreCase))
                    return true;
            }
            return false;
        }

        private bool HasPermission(BasePlayer player)
        {
            if (player == null) return false;
            if (player.IsAdmin) return true;
            if (permission.UserHasPermission(player.UserIDString, PermUse)) return true;
            player.ChatMessage(Msg("NoPermission", player.UserIDString));
            return false;
        }
    }
}