How to make a Rust tool durability plugin (per-item condition multipliers)

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

namespace Oxide.Plugins
{
    [Info("ToolDurability", "RustPluginGenerator", "1.0.0")]
    [Description("Scales condition loss on tools and weapons with per-item multipliers and an unbreakable permission.")]
    public class ToolDurability : RustPlugin
    {
        private const string PermUnbreakable = "tooldurability.unbreakable";
        private const string PermCheck = "tooldurability.check";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Default multiplier")]
            public float DefaultMultiplier { get; set; } = 0.5f;

            [JsonProperty("Affect only tools and weapons")]
            public bool AffectOnlyToolsAndWeapons { get; set; } = true;

            [JsonProperty("Per item multipliers")]
            public Dictionary<string, float> PerItemMultipliers { get; set; } = new Dictionary<string, float>
            {
                ["rock"] = 0.5f,
                ["torch"] = 0.5f,
                ["hatchet"] = 0.5f,
                ["pickaxe"] = 0.5f,
                ["stone.pickaxe"] = 0.5f,
                ["stone.hatchet"] = 0.5f,
                ["salvaged.axe"] = 0.25f,
                ["salvaged.pickaxe"] = 0.25f,
                ["salvaged.sword"] = 0.25f,
                ["hammer"] = 0.0f
            };
        }

        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();
            }

            if (config.PerItemMultipliers == null)
            {
                config.PerItemMultipliers = new Dictionary<string, float>();
            }

            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["NoItem"] = "Hold a tool or weapon and try again.",
                ["Result"] = "Condition loss for {0}: x{1}",
                ["Clamped"] = "Condition loss for {0}: x{1} (no wear)"
            }, 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(PermUnbreakable, this);
            permission.RegisterPermission(PermCheck, this);
        }

        private void OnLoseCondition(Item item, ref float amount)
        {
            if (item == null || item.info == null || amount <= 0f)
            {
                return;
            }

            if (!IsAffected(item))
            {
                return;
            }

            var player = item.GetOwnerPlayer();
            if (player != null && permission.UserHasPermission(player.UserIDString, PermUnbreakable))
            {
                amount = 0f;
                return;
            }

            var multiplier = ResolveMultiplier(item);
            if (multiplier == 1f)
            {
                return;
            }

            amount *= multiplier;

            if (amount < 0f)
            {
                amount = 0f;
            }
        }

        private bool IsAffected(Item item)
        {
            if (!config.AffectOnlyToolsAndWeapons)
            {
                return true;
            }

            var category = item.info.category;
            return category == ItemCategory.Tool || category == ItemCategory.Weapon;
        }

        private float ResolveMultiplier(Item item)
        {
            if (config.PerItemMultipliers != null && item.info.shortname != null)
            {
                float value;
                if (config.PerItemMultipliers.TryGetValue(item.info.shortname, out value))
                {
                    return value;
                }
            }

            return config.DefaultMultiplier;
        }

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

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

            var held = player.GetActiveItem();
            if (held == null || held.info == null)
            {
                player.ChatMessage(Msg("NoItem", player.UserIDString));
                return;
            }

            var multiplier = ResolveMultiplier(held);
            var label = held.info.displayName != null ? held.info.displayName.english : held.info.shortname;

            if (permission.UserHasPermission(player.UserIDString, PermUnbreakable))
            {
                player.ChatMessage(Msg("Clamped", player.UserIDString, label, "0"));
                return;
            }

            player.ChatMessage(Msg("Result", player.UserIDString, label, multiplier));
        }
    }
}