How to make a Rust vehicle spawn command plugin (owner-locked)

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

namespace Oxide.Plugins
{
    [Info("Vehicle Spawn Commands", "RustPluginGenerator", "1.0.0")]
    [Description("Spawns owner-locked minicopters, scrap helis and rowboats from chat commands with permissions and cooldowns")]
    public class VehicleSpawnCommands : RustPlugin
    {
        private const string PermPrefix = "vehiclespawncommands.";
        private const string DataFileName = "VehicleSpawnCommands";

        private PluginConfig config;
        private Dictionary<ulong, ActiveRecord> active = new Dictionary<ulong, ActiveRecord>();
        private Dictionary<string, double> cooldowns = new Dictionary<string, double>();

        private class VehicleDefinition
        {
            [JsonProperty("Key")] public string Key = "";
            [JsonProperty("Display Name")] public string DisplayName = "";
            [JsonProperty("Prefab")] public string Prefab = "";
            [JsonProperty("Cooldown Seconds")] public double CooldownSeconds = 300;
            [JsonProperty("Spawn Offset")] public float SpawnOffset = 4f;
        }

        private class PluginConfig
        {
            [JsonProperty("Maximum active vehicles per type per player")]
            public int MaxActivePerType = 1;

            [JsonProperty("Vehicles")]
            public List<VehicleDefinition> Vehicles = new List<VehicleDefinition>
            {
                new VehicleDefinition
                {
                    Key = "mini",
                    DisplayName = "Minicopter",
                    Prefab = "assets/content/vehicles/minicopter/minicopter.entity.prefab"
                },
                new VehicleDefinition
                {
                    Key = "scrapheli",
                    DisplayName = "Scrap Transport Helicopter",
                    Prefab = "assets/content/vehicles/scrap heli carrier/scraptransporthelicopter.prefab"
                },
                new VehicleDefinition
                {
                    Key = "rowboat",
                    DisplayName = "Rowboat",
                    Prefab = "assets/content/vehicles/boats/rowboat/rowboat.prefab"
                }
            };
        }

        private class ActiveRecord
        {
            public ulong EntityId;
            public string Key;
            public ulong OwnerId;
            public int SpawnedAt;
        }

        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>
            {
                ["NoPermission"] = "You do not have permission to spawn a {0}.",
                ["UnknownVehicle"] = "Usage: /mini, /scrapheli, /rowboat, or /vehicle.spawn.release <key>.",
                ["Cooldown"] = "You can spawn a {0} again in {1} seconds.",
                ["LimitReached"] = "You already have {0} {1} active. Release it with /vehicle.spawn.release {2}.",
                ["SpawnFailed"] = "The {0} could not be spawned. Try a different spot.",
                ["Spawned"] = "You spawned a {0}.",
                ["Released"] = "Your {0} record was released.",
                ["NothingToRelease"] = "You have no active {0} record.",
                ["DataCorrupt"] = "Saved vehicle data could not be read and was reset."
            }, this);
        }

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

        private void Init()
        {
            LoadData();
            foreach (var vehicle in config.Vehicles)
            {
                if (!string.IsNullOrEmpty(vehicle.Key))
                    permission.RegisterPermission(PermPrefix + vehicle.Key, this);
            }
        }

        private void OnServerInitialized() => PruneMissing();

        private void Unload() => SaveData();

        [ChatCommand("mini")]
        private void CmdMini(BasePlayer player, string command, string[] args) => TrySpawn(player, "mini");

        [ChatCommand("scrapheli")]
        private void CmdScrapHeli(BasePlayer player, string command, string[] args) => TrySpawn(player, "scrapheli");

        [ChatCommand("rowboat")]
        private void CmdRowboat(BasePlayer player, string command, string[] args) => TrySpawn(player, "rowboat");

        [ChatCommand("vehicle.spawn.release")]
        private void CmdRelease(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (args == null || args.Length < 1)
            {
                SendReply(player, Msg("UnknownVehicle", player.UserIDString));
                return;
            }

            var key = args[0].ToLowerInvariant();
            var definition = FindDefinition(key);
            if (definition == null)
            {
                SendReply(player, Msg("UnknownVehicle", player.UserIDString));
                return;
            }

            PruneMissing();

            var records = active.Values.Where(r => r.OwnerId == player.userID.Get() && r.Key == key).ToList();
            if (records.Count == 0)
            {
                SendReply(player, Msg("NothingToRelease", player.UserIDString, definition.DisplayName));
                return;
            }

            foreach (var record in records)
                active.Remove(record.EntityId);

            SaveData();
            SendReply(player, Msg("Released", player.UserIDString, definition.DisplayName));
        }

        private void TrySpawn(BasePlayer player, string key)
        {
            if (player == null || !player.IsConnected) return;

            var definition = FindDefinition(key);
            if (definition == null)
            {
                SendReply(player, Msg("UnknownVehicle", player.UserIDString));
                return;
            }

            var perm = PermPrefix + definition.Key;
            if (!permission.UserHasPermission(player.UserIDString, perm))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString, definition.DisplayName));
                return;
            }

            var cooldownKey = player.UserIDString + ":" + definition.Key;
            double last;
            if (cooldowns.TryGetValue(cooldownKey, out last))
            {
                var remaining = definition.CooldownSeconds - (UnityEngine.Time.realtimeSinceStartup - last);
                if (remaining > 0)
                {
                    SendReply(player, Msg("Cooldown", player.UserIDString, definition.DisplayName, Math.Ceiling(remaining)));
                    return;
                }
            }

            PruneMissing();

            var owned = active.Values.Count(r => r.OwnerId == player.userID.Get() && r.Key == definition.Key);
            if (owned >= Math.Max(1, config.MaxActivePerType))
            {
                SendReply(player, Msg("LimitReached", player.UserIDString, owned, definition.DisplayName, definition.Key));
                return;
            }

            var position = GetSpawnPosition(player, definition);
            var entity = GameManager.server.CreateEntity(definition.Prefab, position, Quaternion.identity);
            if (entity == null)
            {
                SendReply(player, Msg("SpawnFailed", player.UserIDString, definition.DisplayName));
                return;
            }

            entity.OwnerID = player.userID.Get();
            entity.Spawn();
            entity.SendNetworkUpdate();

            active[entity.net.ID.Value] = new ActiveRecord
            {
                EntityId = entity.net.ID.Value,
                Key = definition.Key,
                OwnerId = player.userID.Get(),
                SpawnedAt = Facepunch.Math.Epoch.Current
            };

            cooldowns[cooldownKey] = UnityEngine.Time.realtimeSinceStartup;
            SaveData();

            SendReply(player, Msg("Spawned", player.UserIDString, definition.DisplayName));
        }

        private object OnEntityKill(BaseNetworkable entity)
        {
            if (entity == null || entity.net == null) return null;

            var id = entity.net.ID.Value;
            if (!active.ContainsKey(id)) return null;

            active.Remove(id);
            SaveData();
            return null;
        }

        private Vector3 GetSpawnPosition(BasePlayer player, VehicleDefinition definition)
        {
            var position = player.eyes.position + player.eyes.HeadForward() * definition.SpawnOffset;
            position.y = TerrainMeta.HeightMap.GetHeight(position);
            return position;
        }

        private VehicleDefinition FindDefinition(string key)
        {
            return config.Vehicles.FirstOrDefault(v => string.Equals(v.Key, key, StringComparison.OrdinalIgnoreCase));
        }

        private void PruneMissing()
        {
            if (active.Count == 0) return;

            var stale = new List<ulong>();
            foreach (var pair in active)
            {
                var entity = FindEntity(pair.Key);
                if (entity == null || entity.IsDestroyed)
                    stale.Add(pair.Key);
            }

            if (stale.Count == 0) return;

            foreach (var id in stale)
                active.Remove(id);

            SaveData();
        }

        private BaseEntity FindEntity(ulong id)
        {
            foreach (var networkable in BaseNetworkable.serverEntities)
            {
                var entity = networkable as BaseEntity;
                if (entity != null && entity.net != null && entity.net.ID.Value == id)
                    return entity;
            }
            return null;
        }

        private void LoadData()
        {
            try
            {
                var loaded = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<ulong, ActiveRecord>>(DataFileName);
                active = loaded ?? new Dictionary<ulong, ActiveRecord>();
            }
            catch
            {
                PrintWarning(Msg("DataCorrupt"));
                active = new Dictionary<ulong, ActiveRecord>();
            }
        }

        private void SaveData() => Interface.Oxide.DataFileSystem.WriteObject(DataFileName, active);
    }
}