How to make a Rust NPC spawn points plugin (respawn timers)

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

namespace Oxide.Plugins
{
    [Info("Npc Spawn Points", "RustPluginGenerator", "1.0.0")]
    [Description("Stores NPC spawn points in a data file and respawns a scientist at each one after death")]
    public class NpcSpawnPoints : RustPlugin
    {
        private const string PermAdmin = "npcspawnpoints.admin";

        private PluginConfig config;
        private NpcSpawnPointsData data;
        private readonly Dictionary<ulong, SpawnPoint> tracked = new Dictionary<ulong, SpawnPoint>();

        private class PluginConfig
        {
            [JsonProperty("NPC prefab path")]
            public string Prefab = "assets/rust.ai/agents/npcplayer/humannpc/scientist/scientistnpc_roam.prefab";

            [JsonProperty("Respawn delay (seconds)")]
            public float RespawnSeconds = 120f;

            [JsonProperty("Spawn effect prefab")]
            public string SpawnEffect = "assets/bundled/prefabs/fx/entities/gib/scientist_head.prefab";

            [JsonProperty("Skip points inside building privilege")]
            public bool SkipBuildingBlocked = true;

            [JsonProperty("Remove radius (metres)")]
            public float RemoveRadius = 5f;
        }

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

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

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

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

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

            [JsonIgnore]
            public ulong EntityId;

            [JsonIgnore]
            public Timer RespawnTimer;

            public Vector3 Position => new Vector3(X, Y, Z);
        }

        private class NpcSpawnPointsData
        {
            [JsonProperty("Spawn points")]
            public List<SpawnPoint> Points = new List<SpawnPoint>();
        }

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

        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>
            {
                ["Added"] = "Spawn point #{0} added at your position. NPC spawned.",
                ["Removed"] = "Spawn point #{0} removed.",
                ["NoneNear"] = "No spawn point within {0} metres.",
                ["List"] = "Spawn points ({0}):",
                ["ListEntry"] = "#{0} {1} at {2} - {3}",
                ["Alive"] = "alive",
                ["Empty"] = "empty",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Usage"] = "Usage: /npcspawn add [name] | /npcspawn remove | /npcspawn list"
            }, this);
        }

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

        private void OnServerInitialized()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<NpcSpawnPointsData>(Name);
            if (data == null)
            {
                data = new NpcSpawnPointsData();
            }
            if (data.Points == null)
            {
                data.Points = new List<SpawnPoint>();
            }

            for (int i = 0; i < data.Points.Count; i++)
            {
                var point = data.Points[i];
                point.EntityId = 0;
                if (config.SkipBuildingBlocked && IsBlocked(point.Position)) continue;
                SpawnAt(point);
            }
        }

        private void Unload()
        {
            foreach (var point in data?.Points ?? new List<SpawnPoint>())
            {
                point.RespawnTimer?.Destroy();
                point.RespawnTimer = null;

                if (point.EntityId == 0) continue;
                var entity = BaseNetworkable.serverEntities.Find(new NetworkableId(point.EntityId)) as BaseEntity;
                if (entity != null && !entity.IsDestroyed) entity.Kill();
                point.EntityId = 0;
            }

            SaveData();
        }

        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            if (entity == null) return;
            ulong id = entity.net.ID.Value;

            SpawnPoint match = null;
            foreach (var point in data?.Points ?? new List<SpawnPoint>())
            {
                if (point.EntityId == id)
                {
                    match = point;
                    break;
                }
            }

            if (match == null) return;
            match.EntityId = 0;
            tracked.Remove(id);

            if (config.RespawnSeconds <= 0f) return;

            match.RespawnTimer?.Destroy();
            match.RespawnTimer = timer.Once(config.RespawnSeconds, () =>
            {
                match.RespawnTimer = null;
                if (match.EntityId != 0) return;
                if (config.SkipBuildingBlocked && IsBlocked(match.Position)) return;
                SpawnAt(match);
            });
        }

        private void SpawnAt(SpawnPoint point)
        {
            Vector3 pos = point.Position;
            Quaternion rot = Quaternion.Euler(0f, point.Yaw, 0f);
            var entity = GameManager.server.CreateEntity(config.Prefab, pos, rot);
            if (entity == null) return;

            entity.Spawn();
            if (!(entity is BasePlayer npc))
            {
                entity.Kill();
                return;
            }

            point.EntityId = npc.net.ID.Value;
            tracked[npc.net.ID.Value] = point;

            if (!string.IsNullOrEmpty(config.SpawnEffect))
            {
                Effect.server.Run(config.SpawnEffect, pos);
            }
        }

        private bool IsBlocked(Vector3 pos)
        {
            var grid = TerrainMeta.TopologyMap;
            if (grid == null) return false;

            foreach (var entity in BaseNetworkable.serverEntities)
            {
                var block = entity as BuildingBlock;
                if (block == null) continue;
                if (Vector3.Distance(block.transform.position, pos) > 30f) continue;
                var priv = block.GetBuildingPrivilege();
                if (priv != null) return true;
            }
            return false;
        }

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

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

            string sub = args[0].ToLowerInvariant();
            if (sub == "add")
            {
                string name = args.Length > 1 ? string.Join(" ", args, 1, args.Length - 1) : "scientist";
                var forward = player.eyes.HeadForward();
                var point = new SpawnPoint
                {
                    Name = name,
                    X = player.transform.position.x,
                    Y = player.transform.position.y,
                    Z = player.transform.position.z,
                    Yaw = Mathf.Atan2(forward.x, forward.z) * Mathf.Rad2Deg
                };

                data.Points.Add(point);
                SpawnAt(point);
                SaveData();
                SendReply(player, Msg("Added", player.UserIDString, data.Points.Count - 1));
                return;
            }

            if (sub == "remove")
            {
                SpawnPoint nearest = null;
                float best = config.RemoveRadius;
                int index = -1;
                for (int i = 0; i < data.Points.Count; i++)
                {
                    float distance = Vector3.Distance(data.Points[i].Position, player.transform.position);
                    if (distance > best) continue;
                    best = distance;
                    nearest = data.Points[i];
                    index = i;
                }

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

                nearest.RespawnTimer?.Destroy();
                nearest.RespawnTimer = null;

                if (nearest.EntityId != 0)
                {
                    var entity = BaseNetworkable.serverEntities.Find(new NetworkableId(nearest.EntityId)) as BaseEntity;
                    if (entity != null && !entity.IsDestroyed) entity.Kill();
                    tracked.Remove(nearest.EntityId);
                    nearest.EntityId = 0;
                }

                data.Points.RemoveAt(index);
                SaveData();
                SendReply(player, Msg("Removed", player.UserIDString, index));
                return;
            }

            if (sub == "list")
            {
                SendReply(player, Msg("List", player.UserIDString, data.Points.Count));
                for (int i = 0; i < data.Points.Count; i++)
                {
                    var point = data.Points[i];
                    string state = point.EntityId != 0 ? Msg("Alive", player.UserIDString) : Msg("Empty", player.UserIDString);
                    SendReply(player, Msg("ListEntry", player.UserIDString, i, point.Name, $"{point.X:F0},{point.Y:F0},{point.Z:F0}", state));
                }
                return;
            }

            SendReply(player, Msg("Usage", player.UserIDString));
        }

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject(Name, data);
        }
    }
}