How to make a Rust gather rate plugin (per-resource multipliers)

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

namespace Oxide.Plugins
{
    [Info("Gather Rate Multiplier", "RustPluginGenerator", "1.0.0")]
    [Description("Scales resources from dispensers, depleted bonuses and world pickups with per-resource multipliers.")]
    public class GatherRateMultiplier : RustPlugin
    {
        private const string PermUse = "gatherratemultiplier.use";
        private const string PermVip = "gatherratemultiplier.vip";
        private const string PermAdmin = "gatherratemultiplier.admin";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Default multiplier")]
            public float DefaultMultiplier = 2f;

            [JsonProperty("VIP multiplier")]
            public float VipMultiplier = 1.5f;

            [JsonProperty("Minimum amount")]
            public int MinAmount = 1;

            [JsonProperty("Maximum multiplier")]
            public float MaxMultiplier = 50f;

            [JsonProperty("Per-resource multipliers")]
            public Dictionary<string, float> Multipliers = new Dictionary<string, float>
            {
                ["wood"] = 2f,
                ["stones"] = 2f,
                ["metal.ore"] = 2f,
                ["hq.metal.ore"] = 1.5f,
                ["sulfur.ore"] = 1f,
                ["cloth"] = 2f,
                ["bone.fragments"] = 2f,
                ["fat.animal"] = 1.5f
            };
        }

        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>
            {
                ["YourRate"] = "Your gather multiplier: {0}x{1}",
                ["VipActive"] = " (VIP bonus included)",
                ["NoPermission"] = "You do not have permission to use this command",
                ["SetOk"] = "{0} multiplier set to {1}x",
                ["SetDefaultOk"] = "Default multiplier set to {0}x",
                ["Reloaded"] = "Config reloaded. Default multiplier: {0}x",
                ["UnknownItem"] = "'{0}' is not a valid item shortname",
                ["UsageSet"] = "Usage: /gatherrate set <shortname|default> <multiplier>",
                ["BadNumber"] = "'{0}' is not a valid number"
            }, 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);
            permission.RegisterPermission(PermVip, this);
            permission.RegisterPermission(PermAdmin, this);
        }

        private object OnDispenserGather(ResourceDispenser resourceDispenser, BasePlayer entity, Item item)
        {
            if (entity == null || item == null || item.info == null) return null;
            ScaleItem(entity, item);
            return null;
        }

        private object OnDispenserBonus(ResourceDispenser resourceDispenser, BasePlayer player, Item item)
        {
            if (player == null || item == null || item.info == null) return null;
            ScaleItem(player, item);
            return null;
        }

        private object OnCollectiblePickup(CollectibleEntity collectibleEntity, BasePlayer reciever, bool eat)
        {
            if (reciever == null || collectibleEntity == null) return null;
            if (collectibleEntity.itemList == null) return null;

            // Hook does not expose the produced item, so scale the source entries
            foreach (var entry in collectibleEntity.itemList)
            {
                if (entry == null || entry.itemDef == null) continue;
                var mult = MultiplierFor(entry.itemDef.shortname, reciever);
                if (Mathf.Approximately(mult, 1f)) continue;

                int scaled = Mathf.RoundToInt(entry.amount * mult);
                if (scaled < config.MinAmount) scaled = config.MinAmount;
                entry.amount = scaled;
            }

            return null;
        }

        private void ScaleItem(BasePlayer player, Item item)
        {
            var mult = MultiplierFor(item.info.shortname, player);
            if (Mathf.Approximately(mult, 1f)) return;

            int scaled = Mathf.RoundToInt(item.amount * mult);
            if (scaled < config.MinAmount) scaled = config.MinAmount;
            item.amount = scaled;
        }

        private float MultiplierFor(string shortname, BasePlayer player)
        {
            float mult = config.DefaultMultiplier;
            if (!string.IsNullOrEmpty(shortname) && config.Multipliers != null && config.Multipliers.TryGetValue(shortname, out float configured))
            {
                mult = configured;
            }

            if (player != null && permission.UserHasPermission(player.UserIDString, PermVip))
            {
                mult *= config.VipMultiplier;
            }

            if (mult < 0f) mult = 0f;
            if (mult > config.MaxMultiplier) mult = config.MaxMultiplier;
            return mult;
        }

        [ChatCommand("gatherrate")]
        private void CmdGatherRate(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;

            if (args == null || args.Length == 0)
            {
                if (!permission.UserHasPermission(player.UserIDString, PermUse))
                {
                    player.ChatMessage(Msg("NoPermission", player.UserIDString));
                    return;
                }

                float baseMult = config.DefaultMultiplier;
                bool vip = permission.UserHasPermission(player.UserIDString, PermVip);
                string vipText = vip ? Msg("VipActive", player.UserIDString) : string.Empty;
                player.ChatMessage(Msg("YourRate", player.UserIDString, baseMult.ToString("0.##"), vipText));
                return;
            }

            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            if (args[0].Equals("reload", StringComparison.OrdinalIgnoreCase))
            {
                LoadConfig();
                player.ChatMessage(Msg("Reloaded", player.UserIDString, config.DefaultMultiplier.ToString("0.##")));
                return;
            }

            if (!args[0].Equals("set", StringComparison.OrdinalIgnoreCase) || args.Length < 3)
            {
                player.ChatMessage(Msg("UsageSet", player.UserIDString));
                return;
            }

            string target = args[1].ToLowerInvariant();
            if (!float.TryParse(args[2], out float value))
            {
                player.ChatMessage(Msg("BadNumber", player.UserIDString, args[2]));
                return;
            }

            if (value < 0f) value = 0f;
            if (value > config.MaxMultiplier) value = config.MaxMultiplier;

            if (target == "default")
            {
                config.DefaultMultiplier = value;
                SaveConfig();
                player.ChatMessage(Msg("SetDefaultOk", player.UserIDString, value.ToString("0.##")));
                return;
            }

            var def = ItemManager.FindItemDefinition(target);
            if (def == null)
            {
                player.ChatMessage(Msg("UnknownItem", player.UserIDString, target));
                return;
            }

            if (config.Multipliers == null) config.Multipliers = new Dictionary<string, float>();
            config.Multipliers[def.shortname] = value;
            SaveConfig();
            player.ChatMessage(Msg("SetOk", player.UserIDString, def.shortname, value.ToString("0.##")));
        }
    }
}