How to make a Rust first loot bonus plugin (chance-based crate bonus)

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

namespace Oxide.Plugins
{
    [Info("First Loot Bonus", "RustPluginGenerator", "1.0.0")]
    [Description("Rolls a configured chance to add one bonus item the first time each loot container is opened.")]
    public class FirstLootBonus : RustPlugin
    {
        private const string PermAdmin = "firstlootbonus.admin";

        private PluginConfig config;
        private readonly HashSet<ulong> claimed = new HashSet<ulong>();
        private readonly Dictionary<ulong, float> cooldowns = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Enabled")]
            public bool Enabled = true;

            [JsonProperty("Bonus chance (percent)")]
            public float BonusChance = 15f;

            [JsonProperty("Only plain crates")]
            public bool OnlyCrates = false;

            [JsonProperty("Per-player cooldown (seconds)")]
            public float CooldownSeconds = 60f;

            [JsonProperty("Notify player in chat")]
            public bool NotifyPlayer = true;

            [JsonProperty("Bonus items")]
            public List<BonusItem> BonusItems = new List<BonusItem>
            {
                new BonusItem { Shortname = "scrap", Amount = 25, Weight = 50f },
                new BonusItem { Shortname = "metal.fragments", Amount = 200, Weight = 30f },
                new BonusItem { Shortname = "rifle.ak", Amount = 1, Weight = 15f },
                new BonusItem { Shortname = "weapon.mod.lasersight", Amount = 1, Weight = 5f }
            };
        }

        private class BonusItem
        {
            [JsonProperty("Shortname")]
            public string Shortname;

            [JsonProperty("Amount")]
            public int Amount;

            [JsonProperty("Weight")]
            public float Weight;
        }

        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>
            {
                ["BonusReceived"] = "You found a bonus: {0} x{1}",
                ["Status"] = "First loot bonus enabled: {0}. Chance: {1}%. Tracked containers: {2}",
                ["Reloaded"] = "First loot bonus config reloaded.",
                ["NoPerm"] = "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(PermAdmin, this);
        }

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

            if (args != null && args.Length > 0 && args[0].ToLowerInvariant() == "reload")
            {
                LoadConfig();
                cooldowns.Clear();
                SendReply(player, Msg("Reloaded", player.UserIDString));
                return;
            }

            SendReply(player, Msg("Status", player.UserIDString, config.Enabled, config.BonusChance, claimed.Count));
        }

        [ConsoleCommand("flb.status")]
        private void CcmdStatus(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                arg.ReplyWith("No permission.");
                return;
            }
            arg.ReplyWith($"Enabled: {config.Enabled}, chance: {config.BonusChance}%, tracked: {claimed.Count}");
        }

        private void OnLootEntity(BasePlayer player, BaseEntity targetEntity)
        {
            if (!config.Enabled || player == null || targetEntity == null) return;
            if (player.IsNpc || !player.IsConnected) return;

            if (config.OnlyCrates && !(targetEntity is StorageContainer)) return;

            var containerEntity = targetEntity as IItemContainerEntity;
            if (containerEntity == null) return;

            ItemContainer container = containerEntity.inventory;
            if (container == null || container.IsFull()) return;

            ulong id = targetEntity.net.ID.Value;
            if (claimed.Contains(id)) return;

            float now = UnityEngine.Time.realtimeSinceStartup;
            if (config.CooldownSeconds > 0f)
            {
                float last;
                if (cooldowns.TryGetValue(player.userID, out last) && now - last < config.CooldownSeconds) return;
            }

            claimed.Add(id);

            if (UnityEngine.Random.Range(0f, 100f) >= config.BonusChance) return;

            BonusItem pick = PickBonus();
            if (pick == null) return;

            Item item = ItemManager.CreateByName(pick.Shortname, Mathf.Max(1, pick.Amount));
            if (item == null) return;

            if (!item.MoveToContainer(container))
            {
                item.Drop(targetEntity.transform.position + Vector3.up * 0.5f, Vector3.zero);
            }
            else
            {
                container.MarkDirty();
            }

            if (config.CooldownSeconds > 0f)
            {
                cooldowns[player.userID] = now;
            }

            if (config.NotifyPlayer)
            {
                SendReply(player, Msg("BonusReceived", player.UserIDString, item.info.displayName.english, item.amount));
            }
        }

        private BonusItem PickBonus()
        {
            if (config.BonusItems == null || config.BonusItems.Count == 0) return null;

            float total = 0f;
            foreach (var entry in config.BonusItems)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Shortname) || entry.Weight <= 0f) continue;
                total += entry.Weight;
            }
            if (total <= 0f) return null;

            float roll = UnityEngine.Random.Range(0f, total);
            foreach (var entry in config.BonusItems)
            {
                if (entry == null || string.IsNullOrEmpty(entry.Shortname) || entry.Weight <= 0f) continue;
                roll -= entry.Weight;
                if (roll <= 0f) return entry;
            }
            return null;
        }

        private void Unload()
        {
            claimed.Clear();
            cooldowns.Clear();
        }
    }
}