How to make a Rust NPC health multiplier plugin (per-prefab scaling)

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

namespace Oxide.Plugins
{
    [Info("Npc Health Multiplier", "RustPluginGenerator", "1.0.0")]
    [Description("Scales scientist and animal health on spawn using per-prefab multipliers.")]
    public class NpcHealthMultiplier : RustPlugin
    {
        private const string PermAdmin = "npchealthmultiplier.admin";
        private const int SeenCap = 5000;

        private PluginConfig config;
        private readonly HashSet<ulong> seen = new HashSet<ulong>();

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

            [JsonProperty("Prefab multipliers")]
            public Dictionary<string, float> PrefabMultipliers { get; set; } = new Dictionary<string, float>
            {
                ["scientistnpc_heavy"] = 1.5f,
                ["scientistnpc_roam"] = 1.25f,
                ["bear"] = 0.75f,
                ["boar"] = 1.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();
            }
            SaveConfig();
        }

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

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["NoPerm"] = "You do not have permission to use this command.",
                ["Set"] = "Set multiplier for {0} to {1}.",
                ["Default"] = "Default multiplier set to {0}.",
                ["List Header"] = "NPC health multipliers (default {0}):",
                ["List Row"] = "{0} = {1}",
                ["Usage Set"] = "Usage: /npchealth.set <prefab> <multiplier>",
                ["Usage Default"] = "Usage: /npchealth.default <multiplier>",
                ["Bad Number"] = "{0} is not a valid number.",
                ["Out Of Range"] = "Multiplier must be between 0.1 and 50."
            }, this);
        }

        private void Init()
        {
            permission.RegisterPermission(PermAdmin, this);
        }

        private void Unload()
        {
            seen.Clear();
        }

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

        private void OnEntitySpawned(BaseNetworkable networkable)
        {
            if (networkable == null || networkable.IsDestroyed) return;

            var combat = networkable as BaseCombatEntity;
            if (combat == null) return;

            if (!(networkable is ScientistNPC) && !(networkable is BaseAnimalNPC) && !(networkable is ScarecrowNPC))
                return;

            var id = networkable.net?.ID.Value ?? 0;
            if (id == 0 || seen.Contains(id)) return;
            if (seen.Count >= SeenCap) seen.Clear();
            seen.Add(id);

            var prefab = networkable.ShortPrefabName;
            float multiplier = config.DefaultMultiplier;
            if (!string.IsNullOrEmpty(prefab) && config.PrefabMultipliers.TryGetValue(prefab, out var specific))
                multiplier = specific;

            if (Mathf.Approximately(multiplier, 1f)) return;
            if (multiplier <= 0f) multiplier = 0.1f;

            var target = Mathf.Max(1f, combat.MaxHealth() * multiplier);
            if (combat.health >= target) return;

            combat.Heal(target - combat.health);
        }

        [ChatCommand("npchealth.set")]
        private void CmdSet(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPerm", player.UserIDString));
                return;
            }
            if (args == null || args.Length < 2)
            {
                SendReply(player, Msg("Usage Set", player.UserIDString));
                return;
            }

            if (!float.TryParse(args[1], out var multiplier))
            {
                SendReply(player, Msg("Bad Number", player.UserIDString, args[1]));
                return;
            }
            if (multiplier < 0.1f || multiplier > 50f)
            {
                SendReply(player, Msg("Out Of Range", player.UserIDString));
                return;
            }

            var prefab = args[0].ToLowerInvariant();
            config.PrefabMultipliers[prefab] = multiplier;
            SaveConfig();
            SendReply(player, Msg("Set", player.UserIDString, prefab, multiplier));
        }

        [ChatCommand("npchealth.default")]
        private void CmdDefault(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPerm", player.UserIDString));
                return;
            }
            if (args == null || args.Length < 1)
            {
                SendReply(player, Msg("Usage Default", player.UserIDString));
                return;
            }
            if (!float.TryParse(args[0], out var multiplier))
            {
                SendReply(player, Msg("Bad Number", player.UserIDString, args[0]));
                return;
            }
            if (multiplier < 0.1f || multiplier > 50f)
            {
                SendReply(player, Msg("Out Of Range", player.UserIDString));
                return;
            }

            config.DefaultMultiplier = multiplier;
            SaveConfig();
            SendReply(player, Msg("Default", player.UserIDString, multiplier));
        }

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

            SendReply(player, Msg("List Header", player.UserIDString, config.DefaultMultiplier));
            foreach (var pair in config.PrefabMultipliers.OrderBy(p => p.Key))
                SendReply(player, Msg("List Row", player.UserIDString, pair.Key, pair.Value));
        }
    }
}