How to make a Rust monument build-block plugin (radius zones)

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

namespace Oxide.Plugins
{
    [Info("Monument Build Block", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks building placement inside a configurable horizontal radius of monuments, with per-monument overrides.")]
    public class MonumentBuildBlock : RustPlugin
    {
        private const string PermUse = "monumentbuildblock.use";
        private const string PermBypass = "monumentbuildblock.bypass";

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

            [JsonProperty("Per-monument radius overrides")]
            public Dictionary<string, float> MonumentRadii { get; set; } = new Dictionary<string, float>(StringComparer.OrdinalIgnoreCase)
            {
                ["Launch Site"] = 250f,
                ["Airfield"] = 150f,
                ["Outpost"] = 0f,
                ["Bandit Camp"] = 0f
            };
        }

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

        private PluginConfig config;
        private readonly List<Zone> zones = new List<Zone>();
        private readonly Dictionary<ulong, float> lastWarn = new Dictionary<ulong, float>();

        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>
            {
                ["Blocked"] = "You cannot build here: {0} is a protected monument zone ({1}m radius).",
                ["Nearest"] = "Nearest monument: {0} ({1}m radius).",
                ["None"] = "No monument zones are configured on this map.",
                ["Status"] = "{0} monument zones cached. Default radius: {1}m.",
                ["Reloaded"] = "Reloaded: {0} monument zones, default radius {1}m.",
                ["NoPermission"] = "You do not have permission to use this command."
            }, 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);
            permission.RegisterPermission(PermBypass, this);
        }

        private void OnServerInitialized()
        {
            BuildZones();
        }

        private void BuildZones()
        {
            zones.Clear();

            var monuments = TerrainMeta.Path?.Monuments;
            if (monuments == null)
            {
                PrintWarning("No monument list available from the terrain");
                return;
            }

            foreach (var monument in monuments)
            {
                if (monument == null || monument.transform == null) continue;

                string display = monument.displayPhrase != null && !string.IsNullOrEmpty(monument.displayPhrase.english)
                    ? monument.displayPhrase.english.Trim()
                    : monument.name;

                if (string.IsNullOrEmpty(display)) continue;
                if (IsInternalName(display)) continue;

                float radius = config.DefaultRadius;
                if (config.MonumentRadii != null && config.MonumentRadii.TryGetValue(display, out var overrideRadius))
                {
                    radius = overrideRadius;
                }

                if (radius <= 0f) continue;

                zones.Add(new Zone
                {
                    Name = display,
                    Center = monument.transform.position,
                    Radius = radius
                });
            }
        }

        private static bool IsInternalName(string name)
        {
            return name == "Loading" || name == "Tutorial" || name.StartsWith("monument", StringComparison.OrdinalIgnoreCase);
        }

        private static float FlatDistance(Vector3 a, Vector3 b)
        {
            float dx = a.x - b.x;
            float dz = a.z - b.z;
            return Mathf.Sqrt(dx * dx + dz * dz);
        }

        private object CanBuild(Planner planner, Construction construction, Construction.Target target)
        {
            if (planner == null || target.entity == null) return null;
            if (zones.Count == 0) return null;

            var player = planner.GetOwnerPlayer();
            if (player == null || player.IsNpc) return null;
            if (permission.UserHasPermission(player.UserIDString, PermBypass)) return null;

            Vector3 position = target.position;
            if (position == Vector3.zero) position = target.entity.transform.position;

            for (int i = 0; i < zones.Count; i++)
            {
                var zone = zones[i];
                float distance = FlatDistance(position, zone.Center);
                if (distance > zone.Radius) continue;

                Notify(player, zone);
                return false;
            }

            return null;
        }

        private void Notify(BasePlayer player, Zone zone)
        {
            ulong userId = player.userID.Get();
            float now = Time.realtimeSinceStartup;
            if (lastWarn.TryGetValue(userId, out var last) && now - last < 3f) return;
            lastWarn[userId] = now;

            SendReply(player, Msg("Blocked", player.UserIDString, zone.Name, Mathf.RoundToInt(zone.Radius)));
        }

        [ChatCommand("mbb")]
        private void CmdMbb(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            if (zones.Count == 0)
            {
                SendReply(player, Msg("None", player.UserIDString));
                return;
            }

            Zone nearest = null;
            float best = float.MaxValue;

            for (int i = 0; i < zones.Count; i++)
            {
                float distance = FlatDistance(player.transform.position, zones[i].Center);
                if (distance < best)
                {
                    best = distance;
                    nearest = zones[i];
                }
            }

            if (nearest == null)
            {
                SendReply(player, Msg("None", player.UserIDString));
                return;
            }

            SendReply(player, Msg("Nearest", player.UserIDString, nearest.Name, Mathf.RoundToInt(nearest.Radius)));
        }

        [ConsoleCommand("monumentbuildblock.status")]
        private void CcmdStatus(ConsoleSystem.Arg arg)
        {
            string text = Msg("Status", null, zones.Count, Mathf.RoundToInt(config.DefaultRadius));
            if (arg != null && arg.Player() != null) arg.ReplyWith(text);
            else Puts(text);
        }

        [ConsoleCommand("monumentbuildblock.reload")]
        private void CcmdReload(ConsoleSystem.Arg arg)
        {
            if (arg != null && arg.Player() != null && !arg.IsAdmin)
            {
                arg.ReplyWith("Admin only");
                return;
            }

            LoadConfig();
            BuildZones();
            string text = Msg("Reloaded", null, zones.Count, Mathf.RoundToInt(config.DefaultRadius));
            if (arg != null && arg.Player() != null) arg.ReplyWith(text);
            else Puts(text);
        }

        private void Unload()
        {
            zones.Clear();
            lastWarn.Clear();
        }
    }
}