LoadDefaultConfig

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

namespace Oxide.Plugins
{
    [Info("StarterKitDefaults", "RustPluginGenerator", "1.0.0")]
    [Description("Gives each new player a one-time starter kit controlled by a config file.")]
    public class StarterKitDefaults : RustPlugin
    {
        private const string DataFileName = "StarterKitDefaults/players";

        private PluginConfig config;
        private HashSet<ulong> grantedPlayers;

        private class PluginConfig
        {
            [JsonProperty("Enable starter kit")]
            public bool Enabled { get; set; } = true;

            [JsonProperty("Item shortname")]
            public string ItemShortname { get; set; } = "supply.signal";

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

            [JsonProperty("Give only once per player")]
            public bool OncePerPlayer { get; set; } = true;

            [JsonProperty("Broadcast message to the player")]
            public bool NotifyPlayer { get; set; } = true;
        }

        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"] = "You received your starter kit: {0} x {1}",
                ["KitDisabled"] = "Starter kits are currently disabled."
            }, this);
        }

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

        private void Init()
        {
            LoadData();
        }

        private void LoadData()
        {
            grantedPlayers = Interface.Oxide.DataFileSystem.ReadObject<HashSet<ulong>>(DataFileName) ?? new HashSet<ulong>();
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            if (!config.Enabled || player == null || player.IsNpc) return;

            if (config.OncePerPlayer && grantedPlayers.Contains(player.userID))
            {
                return;
            }

            ItemDefinition definition = ItemManager.FindItemDefinition(config.ItemShortname);
            if (definition == null)
            {
                return;
            }

            int amount = Mathf.Max(1, config.Amount);
            Item item = ItemManager.CreateByName(config.ItemShortname, amount);
            if (item == null) return;

            player.GiveItem(item);

            if (config.OncePerPlayer)
            {
                grantedPlayers.Add(player.userID);
            }

            if (config.NotifyPlayer)
            {
                player.ChatMessage(Msg("KitGiven", player.UserIDString, amount, definition.displayName.english));
            }
        }

        private void Unload()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFileName, grantedPlayers);
        }
    }
}