How to make a Rust no-NPC zones plugin (remove scientists)

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

namespace Oxide.Plugins
{
    [Info("No NPC Zones", "RustPluginGenerator", "1.0.0")]
    [Description("Removes scientists and animals that spawn inside configured world zones.")]
    public class NoNpcZones : RustPlugin
    {
        private const string PermUse = "nonpczones.use";
        private const float MaxRadius = 1000f;

        private PluginConfig config;

        private class ZoneEntry
        {
            [JsonProperty("Name")]
            public string Name;

            [JsonProperty("X")]
            public float X;

            [JsonProperty("Z")]
            public float Z;

            [JsonProperty("Radius")]
            public float Radius;

            [JsonProperty("IgnoreHeight")]
            public bool IgnoreHeight;
        }

        private class PluginConfig
        {
            [JsonProperty("SkipPlayerOwned")]
            public bool SkipPlayerOwned = true;

            [JsonProperty("Zones")]
            public List<ZoneEntry> Zones = new List<ZoneEntry>();
        }

        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>
            {
                ["ZoneAdded"] = "Zone '{0}' added at X {1:0} Z {2:0} with radius {3:0}.",
                ["ZoneRemoved"] = "Zone '{0}' removed.",
                ["ZoneMissing"] = "No zone named '{0}'.",
                ["ZoneDuplicate"] = "A zone named '{0}' already exists.",
                ["RadiusInvalid"] = "Radius must be between 1 and {0}.",
                ["UsageAdd"] = "Usage: /npc nzadd <name> <radius>",
                ["UsageRemove"] = "Usage: /npc nzremove <name>",
                ["NoZones"] = "No zones configured.",
                ["ZoneLine"] = "{0}: X {1:0} Z {2:0} radius {3:0}, ignore height: {4}",
                ["PlayerOnly"] = "This command can only be used in game."
            }, 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);
            cmd.AddChatCommand("npc", this, nameof(CmdNpc));
        }

        private void CmdNpc(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("PlayerOnly", player.UserIDString));
                return;
            }

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

            switch (args[0].ToLowerInvariant())
            {
                case "nzadd":
                    AddZone(player, args);
                    break;
                case "nzlist":
                    ListZones(player);
                    break;
                case "nzremove":
                    RemoveZone(player, args);
                    break;
                default:
                    SendReply(player, Msg("UsageAdd", player.UserIDString));
                    break;
            }
        }

        private void AddZone(BasePlayer player, string[] args)
        {
            if (args.Length < 3)
            {
                SendReply(player, Msg("UsageAdd", player.UserIDString));
                return;
            }

            string name = args[1].Trim();
            if (string.IsNullOrEmpty(name) || FindZone(name) != null)
            {
                SendReply(player, Msg("ZoneDuplicate", player.UserIDString, name));
                return;
            }

            float radius;
            if (!float.TryParse(args[2], out radius) || radius < 1f || radius > MaxRadius)
            {
                SendReply(player, Msg("RadiusInvalid", player.UserIDString, MaxRadius));
                return;
            }

            Vector3 pos = player.transform.position;
            var zone = new ZoneEntry
            {
                Name = name,
                X = pos.x,
                Z = pos.z,
                Radius = radius,
                IgnoreHeight = true
            };

            config.Zones.Add(zone);
            SaveConfig();

            SendReply(player, Msg("ZoneAdded", player.UserIDString, zone.Name, zone.X, zone.Z, zone.Radius));
        }

        private void ListZones(BasePlayer player)
        {
            if (config.Zones == null || config.Zones.Count == 0)
            {
                SendReply(player, Msg("NoZones", player.UserIDString));
                return;
            }

            foreach (var zone in config.Zones)
            {
                SendReply(player, Msg("ZoneLine", player.UserIDString, zone.Name, zone.X, zone.Z, zone.Radius, zone.IgnoreHeight));
            }
        }

        private void RemoveZone(BasePlayer player, string[] args)
        {
            if (args.Length < 2)
            {
                SendReply(player, Msg("UsageRemove", player.UserIDString));
                return;
            }

            string name = args[1].Trim();
            var zone = FindZone(name);
            if (zone == null)
            {
                SendReply(player, Msg("ZoneMissing", player.UserIDString, name));
                return;
            }

            config.Zones.Remove(zone);
            SaveConfig();
            SendReply(player, Msg("ZoneRemoved", player.UserIDString, zone.Name));
        }

        private ZoneEntry FindZone(string name)
        {
            if (config.Zones == null) return null;

            foreach (var zone in config.Zones)
            {
                if (zone != null && string.Equals(zone.Name, name, StringComparison.OrdinalIgnoreCase))
                    return zone;
            }

            return null;
        }

        private void OnEntitySpawned(BaseNetworkable entity)
        {
            if (entity == null || config.Zones == null || config.Zones.Count == 0) return;

            BaseCombatEntity combat = entity as BaseCombatEntity;
            if (combat == null) return;

            bool isNpc = entity is ScientistNPC || entity is BaseAnimalNPC;
            if (!isNpc) return;

            if (config.SkipPlayerOwned && combat.OwnerID != 0) return;

            Vector3 pos = combat.transform.position;

            for (int i = 0; i < config.Zones.Count; i++)
            {
                var zone = config.Zones[i];
                if (zone == null) continue;
                if (IsInside(zone, pos))
                {
                    combat.Kill();
                    return;
                }
            }
        }

        private static bool IsInside(ZoneEntry zone, Vector3 pos)
        {
            float dx = pos.x - zone.X;
            float dz = pos.z - zone.Z;
            float flatSq = dx * dx + dz * dz;

            if (flatSq > zone.Radius * zone.Radius) return false;
            if (zone.IgnoreHeight) return true;

            float dy = pos.y;
            return flatSq + dy * dy <= zone.Radius * zone.Radius;
        }
    }
}