How to make a Rust starter kit plugin (on respawn)

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

namespace Oxide.Plugins
{
    [Info("Starter Kit", "RustPluginGenerator", "1.0.0")]
    [Description("Gives a configurable starter kit to every respawning player instead of the default rock and torch.")]
    public class StarterKit : RustPlugin
    {
        private const string PermUse = "starterkit.use";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Give kit automatically on respawn")]
            public bool GiveOnRespawn { get; set; } = true;

            [JsonProperty("Require permission for automatic kit")]
            public bool RequirePermission { get; set; } = false;

            [JsonProperty("Drop overflow items on ground")]
            public bool DropOverflow { get; set; } = true;

            [JsonProperty("Starter items")]
            public List<KitItem> Items { get; set; } = new List<KitItem>
            {
                new KitItem { Shortname = "hoodie", Amount = 1, Container = "wear" },
                new KitItem { Shortname = "pants", Amount = 1, Container = "wear" },
                new KitItem { Shortname = "shoes.boots", Amount = 1, Container = "wear" },
                new KitItem { Shortname = "rock", Amount = 1, Container = "belt" },
                new KitItem { Shortname = "torch", Amount = 1, Container = "belt" },
                new KitItem { Shortname = "bandage", Amount = 3, Container = "main" },
                new KitItem { Shortname = "apple", Amount = 3, Container = "main" }
            };
        }

        private class KitItem
        {
            [JsonProperty("Item shortname")]
            public string Shortname { get; set; }

            [JsonProperty("Amount")]
            public int Amount { get; set; } = 1;

            [JsonProperty("Skin ID")]
            public ulong Skin { get; set; } = 0;

            [JsonProperty("Condition (0 = default)")]
            public float Condition { get; set; } = 0f;

            [JsonProperty("Container (wear, belt, main)")]
            public string Container { get; set; } = "main";
        }

        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>
            {
                ["KitGiven"] = "Your starter kit has been given.",
                ["KitGivenTarget"] = "You gave {0} the starter kit.",
                ["PlayerNotFound"] = "No matching player found.",
                ["NoPermission"] = "You don't have permission to use this command.",
                ["Usage"] = "Usage: /starterkit give <name or steamid> | /starterkit self",
                ["TargetNoPermission"] = "{0} does not have the starterkit.use permission."
            }, 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);
            foreach (var entry in config.Items)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Shortname)) continue;
                if (ItemManager.FindItemDefinition(entry.Shortname) == null)
                    PrintWarning($"Unknown item shortname '{entry.Shortname}' in config, skipping");
            }
        }

        private void OnPlayerRespawned(BasePlayer player)
        {
            if (player == null || !config.GiveOnRespawn) return;
            if (player.IsNpc || player.IsDead()) return;
            if (config.RequirePermission && !permission.UserHasPermission(player.UserIDString, PermUse)) return;
            GiveKit(player);
        }

        [ChatCommand("starterkit")]
        private void CmdStarterKit(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length == 0)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }
            var sub = args[0].ToLowerInvariant();
            if (sub == "self")
            {
                GiveKit(player);
                player.ChatMessage(Msg("KitGiven", player.UserIDString));
                return;
            }
            if (sub == "give" && args.Length >= 2)
            {
                var target = BasePlayer.FindAwakeOrSleeping(args[1]);
                if (target == null)
                {
                    player.ChatMessage(Msg("PlayerNotFound", player.UserIDString));
                    return;
                }
                if (config.RequirePermission && !permission.UserHasPermission(target.UserIDString, PermUse))
                {
                    player.ChatMessage(Msg("TargetNoPermission", player.UserIDString, target.displayName));
                    return;
                }
                GiveKit(target);
                player.ChatMessage(Msg("KitGivenTarget", player.UserIDString, target.displayName));
                return;
            }
            player.ChatMessage(Msg("Usage", player.UserIDString));
        }

        private void GiveKit(BasePlayer player)
        {
            if (player?.inventory == null) return;
            player.inventory.Strip();

            foreach (var entry in config.Items)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Shortname)) continue;
                var item = ItemManager.CreateByName(entry.Shortname, Mathf.Max(1, entry.Amount), entry.Skin);
                if (item == null) continue;
                if (entry.Condition > 0f && item.maxCondition > 0f)
                {
                    item.condition = Mathf.Min(entry.Condition, item.maxCondition);
                }
                item.MarkDirty();

                var container = ResolveContainer(player, entry.Container);
                if (container == null || item.MoveToContainer(container))
                {
                    if (config.DropOverflow) item.Drop(player.transform.position + Vector3.up, Vector3.zero);
                    else item.Remove();
                }
            }
            player.SendNetworkUpdate();
        }

        private ItemContainer ResolveContainer(BasePlayer player, string name)
        {
            var inv = player.inventory;
            if (inv == null) return null;
            switch ((name ?? "main").ToLowerInvariant())
            {
                case "wear": return inv.containerWear;
                case "belt": return inv.containerBelt;
                default: return inv.containerMain;
            }
        }
    }
}