How to make a Rust safe PvE zones plugin (spherical, no damage)

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

namespace Oxide.Plugins
{
    [Info("Safe PvE Zones", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks player and building damage inside configurable spherical zones and announces entry and exit.")]
    public class SafePveZones : RustPlugin
    {
        private const string PermAdmin = "safepvezones.admin";

        private PluginConfig config;
        private readonly List<Zone> zones = new List<Zone>();
        private readonly Dictionary<ulong, string> playerZones = new Dictionary<ulong, string>();
        private Timer checkTimer;

        private class Zone
        {
            public string Name;
            public Vector3 Center;
            public float RadiusSqr;
        }

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

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

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

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

            [JsonProperty("Radius")]
            public float Radius = 50f;
        }

        private class PluginConfig
        {
            [JsonProperty("Check Interval Seconds")]
            public float CheckIntervalSeconds = 2f;

            [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>
            {
                ["Entered"] = "You entered the safe zone '{0}'. PvP and building damage are disabled here.",
                ["Left"] = "You left the safe zone '{0}'. You are vulnerable again.",
                ["Added"] = "Zone '{0}' created with radius {1}.",
                ["Removed"] = "Zone '{0}' removed.",
                ["NotFound"] = "No zone named '{0}' exists.",
                ["ListHeader"] = "{0} safe zone(s) configured:",
                ["ListEntry"] = "- {0}: {1} (radius {2})",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Usage"] = "Usage: /pvezone add <name> <radius> | /pvezone remove <name> | /pvezone list",
                ["InvalidRadius"] = "Radius must be a number greater than 0.",
                ["Empty"] = "No zones are configured."
            }, this);
        }

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

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

        private void OnServerInitialized()
        {
            RebuildZones();
            StartTimer();
        }

        private void Unload()
        {
            if (checkTimer != null)
            {
                checkTimer.Destroy();
                checkTimer = null;
            }
            playerZones.Clear();
        }

        private void RebuildZones()
        {
            zones.Clear();
            if (config?.Zones == null) return;
            foreach (var entry in config.Zones)
            {
                if (entry == null || entry.Radius <= 0f) continue;
                zones.Add(new Zone
                {
                    Name = entry.Name,
                    Center = new Vector3(entry.X, entry.Y, entry.Z),
                    RadiusSqr = entry.Radius * entry.Radius
                });
            }
        }

        private void StartTimer()
        {
            if (checkTimer != null) checkTimer.Destroy();
            checkTimer = timer.Every(Mathf.Max(0.5f, config.CheckIntervalSeconds), CheckPlayers);
        }

        private Zone TryGetZone(Vector3 position)
        {
            for (int i = 0; i < zones.Count; i++)
            {
                var zone = zones[i];
                if ((position - zone.Center).sqrMagnitude <= zone.RadiusSqr) return zone;
            }
            return null;
        }

        private void CheckPlayers()
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null || player.IsNpc || !player.IsConnected) continue;
                if (player.IsSleeping() || player.IsDead()) continue;

                var zone = TryGetZone(player.transform.position);
                string previous;
                playerZones.TryGetValue(player.userID.Get(), out previous);

                if (zone == null)
                {
                    if (previous != null)
                    {
                        playerZones.Remove(player.userID.Get());
                        player.ChatMessage(Msg("Left", player.UserIDString, previous));
                    }
                    continue;
                }

                if (previous == zone.Name) continue;
                playerZones[player.userID.Get()] = zone.Name;
                if (previous != null)
                {
                    player.ChatMessage(Msg("Left", player.UserIDString, previous));
                }
                player.ChatMessage(Msg("Entered", player.UserIDString, zone.Name));
            }
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player != null) playerZones.Remove(player.userID.Get());
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
        {
            if (entity == null || hitInfo == null) return null;
            if (!(entity is BasePlayer) && !(entity is BuildingBlock)) return null;

            if (TryGetZone(entity.transform.position) == null) return null;

            hitInfo.damageTypes.ScaleAll(0f);
            return false;
        }

        [ChatCommand("pvezone")]
        private void CmdZone(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

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

            switch (args[0].ToLower())
            {
                case "add":
                    HandleAdd(player, args);
                    break;
                case "remove":
                    HandleRemove(player, args);
                    break;
                case "list":
                    HandleList(player);
                    break;
                default:
                    player.ChatMessage(Msg("Usage", player.UserIDString));
                    break;
            }
        }

        private void HandleAdd(BasePlayer player, string[] args)
        {
            if (args.Length < 3)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            float radius;
            if (!float.TryParse(args[2], out radius) || radius <= 0f)
            {
                player.ChatMessage(Msg("InvalidRadius", player.UserIDString));
                return;
            }

            var entry = new ZoneEntry
            {
                Name = args[1],
                X = player.transform.position.x,
                Y = player.transform.position.y,
                Z = player.transform.position.z,
                Radius = radius
            };
            config.Zones.Add(entry);
            SaveConfig();
            RebuildZones();
            player.ChatMessage(Msg("Added", player.UserIDString, entry.Name, radius));
        }

        private void HandleRemove(BasePlayer player, string[] args)
        {
            if (args.Length < 2)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            var index = config.Zones.FindIndex(z => z != null && string.Equals(z.Name, args[1], StringComparison.OrdinalIgnoreCase));
            if (index < 0)
            {
                player.ChatMessage(Msg("NotFound", player.UserIDString, args[1]));
                return;
            }

            var name = config.Zones[index].Name;
            config.Zones.RemoveAt(index);
            SaveConfig();
            RebuildZones();
            player.ChatMessage(Msg("Removed", player.UserIDString, name));
        }

        private void HandleList(BasePlayer player)
        {
            if (config.Zones == null || config.Zones.Count == 0)
            {
                player.ChatMessage(Msg("Empty", player.UserIDString));
                return;
            }

            player.ChatMessage(Msg("ListHeader", player.UserIDString, config.Zones.Count));
            foreach (var entry in config.Zones)
            {
                if (entry == null) continue;
                player.ChatMessage(Msg("ListEntry", player.UserIDString, entry.Name,
                    string.Format("({0:0}, {1:0}, {2:0})", entry.X, entry.Y, entry.Z), entry.Radius));
            }
        }
    }
}