How to make a Rust PvP zones plugin (spherical zones, Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("PvpZones", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks player-versus-player damage outside configured spherical zones.")]
    public class PvpZones : RustPlugin
    {
        private const string PermAdmin = "pvpzones.admin";

        private PluginConfig config;
        private readonly Dictionary<ulong, float> lastNotice = new Dictionary<ulong, float>();

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

            [JsonProperty("X")]
            public float X { get; set; }

            [JsonProperty("Y")]
            public float Y { get; set; }

            [JsonProperty("Z")]
            public float Z { get; set; }

            [JsonProperty("Radius")]
            public float Radius { get; set; }

            [JsonIgnore]
            public Vector3 Center => new Vector3(X, Y, Z);
        }

        private class PluginConfig
        {
            [JsonProperty("Default radius")]
            public float DefaultRadius { get; set; } = 50f;

            [JsonProperty("Seconds between blocked-hit notices")]
            public float NoticeCooldown { get; set; } = 10f;

            [JsonProperty("Zones")]
            public List<ZoneEntry> Zones { get; set; } = 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();
                if (config.Zones == null) config.Zones = new List<ZoneEntry>();
            }
            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>
            {
                ["NoPvpZone"] = "PvP is disabled here. Fight inside a marked arena.",
                ["ZoneAdded"] = "Zone '{0}' created at {1} with radius {2}.",
                ["ZoneRemoved"] = "Zone '{0}' removed.",
                ["ZoneMissing"] = "No zone named '{0}'.",
                ["NoZones"] = "No PvP zones are configured.",
                ["ZoneList"] = "{0} - {1} r{2}",
                ["NeedName"] = "Usage: pvpzone add <name> | pvpzone remove <name> | pvpzone list",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["PlayerOnly"] = "This command must be run in game from a player."
            }, 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(PermAdmin, this);
        }

        private object OnEntityTakeDamage(BasePlayer player, HitInfo hitInfo)
        {
            if (player == null || hitInfo == null) return null;
            var attacker = hitInfo.InitiatorPlayer;
            if (attacker == null || attacker == player) return null;
            if (attacker.IsNpc || player.IsNpc) return null;
            if (IsInsideAnyZone(player.transform.position)) return null;

            hitInfo.damageTypes.ScaleAll(0f);

            if (config.NoticeCooldown > 0f)
            {
                float now = UnityEngine.Time.realtimeSinceStartup;
                float last;
                if (!lastNotice.TryGetValue(player.userID, out last) || now - last >= config.NoticeCooldown)
                {
                    lastNotice[player.userID] = now;
                    player.ChatMessage(Msg("NoPvpZone", player.UserIDString));
                }
            }
            return true;
        }

        private bool IsInsideAnyZone(Vector3 position)
        {
            for (int i = 0; i < config.Zones.Count; i++)
            {
                var zone = config.Zones[i];
                if (zone == null || zone.Radius <= 0f) continue;
                if (Vector3.Distance(position, zone.Center) <= zone.Radius) return true;
            }
            return false;
        }

        [ConsoleCommand("pvpzone")]
        private void CmdPvpZone(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            string sub = arg.GetString(0, string.Empty).ToLowerInvariant();
            if (sub == "add")
            {
                if (player == null)
                {
                    arg.ReplyWith(Msg("PlayerOnly"));
                    return;
                }
                string name = arg.GetString(1, string.Empty);
                if (string.IsNullOrEmpty(name))
                {
                    arg.ReplyWith(Msg("NeedName"));
                    return;
                }
                if (FindZone(name) != null)
                {
                    arg.ReplyWith(Msg("ZoneMissing", null, name));
                    return;
                }
                var pos = player.transform.position;
                var zone = new ZoneEntry { Name = name, X = pos.x, Y = pos.y, Z = pos.z, Radius = config.DefaultRadius };
                config.Zones.Add(zone);
                SaveConfig();
                arg.ReplyWith(Msg("ZoneAdded", null, zone.Name, pos.ToString("F0"), zone.Radius));
            }
            else if (sub == "remove")
            {
                string name = arg.GetString(1, string.Empty);
                var zone = FindZone(name);
                if (zone == null)
                {
                    arg.ReplyWith(Msg("ZoneMissing", null, name));
                    return;
                }
                config.Zones.Remove(zone);
                SaveConfig();
                arg.ReplyWith(Msg("ZoneRemoved", null, zone.Name));
            }
            else if (sub == "list")
            {
                if (config.Zones.Count == 0)
                {
                    arg.ReplyWith(Msg("NoZones"));
                    return;
                }
                for (int i = 0; i < config.Zones.Count; i++)
                {
                    var zone = config.Zones[i];
                    arg.ReplyWith(Msg("ZoneList", null, zone.Name, zone.Center.ToString("F0"), zone.Radius));
                }
            }
            else
            {
                arg.ReplyWith(Msg("NeedName"));
            }
        }

        private ZoneEntry FindZone(string name)
        {
            if (string.IsNullOrEmpty(name)) return null;
            for (int i = 0; i < config.Zones.Count; i++)
            {
                if (string.Equals(config.Zones[i].Name, name, StringComparison.OrdinalIgnoreCase)) return config.Zones[i];
            }
            return null;
        }

        private void Unload()
        {
            SaveConfig();
            lastNotice.Clear();
        }
    }
}