How to make a Rust NPC damage multiplier plugin (per-type overrides)

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

namespace Oxide.Plugins
{
    [Info("NpcDamageMultiplier", "RustPluginGenerator", "1.0.0")]
    [Description("Scales damage NPCs deal to players and damage players deal to NPCs, with per-NPC-type overrides.")]
    public class NpcDamageMultiplier : RustPlugin
    {
        private const string PermUse = "npcdamagemultiplier.use";
        private const string PermAdmin = "npcdamagemultiplier.admin";

        private PluginConfig config;

        private class NpcTypeOverride
        {
            [JsonProperty("Npc deals damage multiplier")]
            public float Outgoing = 1f;

            [JsonProperty("Npc takes damage multiplier")]
            public float Incoming = 1f;
        }

        private class PluginConfig
        {
            [JsonProperty("Npc damage to players")]
            public float NpcDamageToPlayers = 1f;

            [JsonProperty("Player damage to NPCs")]
            public float PlayerDamageToNpcs = 1f;

            [JsonProperty("Npc type overrides")]
            public Dictionary<string, NpcTypeOverride> NpcTypeOverrides = new Dictionary<string, NpcTypeOverride>
            {
                ["scientistnpc_peacekeeper"] = new NpcTypeOverride { Outgoing = 1.25f, Incoming = 1f },
                ["scientistnpc_heavy"] = new NpcTypeOverride { Outgoing = 1.5f, Incoming = 1f },
                ["scientistnpc_junkpile_a"] = new NpcTypeOverride { Outgoing = 1f, Incoming = 2f },
                ["bear"] = new NpcTypeOverride { Outgoing = 1.2f, Incoming = 1f }
            };
        }

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

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

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Status"] = "NPC multiplier: NPC->player {0}x, player->NPC {1}x, {2} override(s).",
                ["Reloaded"] = "Configuration reloaded.",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Usage"] = "Usage: /npddmg <status|reload>"
            }, this);
        }

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

        private void ClampConfig()
        {
            config.NpcDamageToPlayers = Clamp(config.NpcDamageToPlayers);
            config.PlayerDamageToNpcs = Clamp(config.PlayerDamageToNpcs);

            if (config.NpcTypeOverrides == null)
                config.NpcTypeOverrides = new Dictionary<string, NpcTypeOverride>();

            foreach (var kvp in config.NpcTypeOverrides)
            {
                if (kvp.Value == null) continue;
                kvp.Value.Outgoing = Clamp(kvp.Value.Outgoing);
                kvp.Value.Incoming = Clamp(kvp.Value.Incoming);
            }
        }

        private static float Clamp(float value)
        {
            if (value < 0.05f) return 0.05f;
            if (value > 10f) return 10f;
            return value;
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
        {
            if (entity == null || hitInfo == null || hitInfo.damageTypes == null) return null;

            var victimNpc = GetNpc(entity);
            var attackerNpc = GetNpc(hitInfo.Initiator);
            var attackerPlayer = hitInfo.InitiatorPlayer;

            // NPC hits NPC -> leave vanilla.
            if (victimNpc != null && attackerNpc != null) return null;

            if (attackerNpc != null && attackerPlayer == null && entity is BasePlayer)
            {
                if (ShouldSkip(hitInfo)) return null;
                var mult = GetOutgoingMultiplier(attackerNpc);
                if (mult != 1f) hitInfo.damageTypes.ScaleAll(mult);
                return null;
            }

            if (victimNpc != null && attackerPlayer != null)
            {
                if (ShouldSkip(hitInfo)) return null;
                var mult = GetIncomingMultiplier(victimNpc);
                if (mult != 1f) hitInfo.damageTypes.ScaleAll(mult);
                return null;
            }

            return null;
        }

        private static BaseNpc GetNpc(BaseEntity entity)
        {
            if (entity == null || entity.IsDestroyed) return null;
            return entity as BaseNpc;
        }

        private float GetOutgoingMultiplier(BaseNpc npc)
        {
            NpcTypeOverride over;
            if (TryGetOverride(npc, out over)) return over.Outgoing;
            return config.NpcDamageToPlayers;
        }

        private float GetIncomingMultiplier(BaseNpc npc)
        {
            NpcTypeOverride over;
            if (TryGetOverride(npc, out over)) return over.Incoming;
            return config.PlayerDamageToNpcs;
        }

        private bool TryGetOverride(BaseNpc npc, out NpcTypeOverride over)
        {
            over = null;
            if (npc == null || config.NpcTypeOverrides == null) return false;
            var key = npc.ShortPrefabName;
            if (string.IsNullOrEmpty(key)) return false;
            return config.NpcTypeOverrides.TryGetValue(key, out over) && over != null;
        }

        private static bool ShouldSkip(HitInfo hitInfo)
        {
            var type = hitInfo.damageTypes.GetMajorityDamageType();
            return type == Rust.DamageType.Decay || type == Rust.DamageType.Fall || type == Rust.DamageType.Suicide;
        }

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

            if (args == null || args.Length == 0)
            {
                SendReply(player, Msg("Usage", player.UserIDString));
                return;
            }

            switch (args[0].ToLowerInvariant())
            {
                case "status":
                    if (!permission.UserHasPermission(player.UserIDString, PermUse) &&
                        !permission.UserHasPermission(player.UserIDString, PermAdmin))
                    {
                        SendReply(player, Msg("NoPermission", player.UserIDString));
                        return;
                    }
                    SendReply(player, Msg("Status", player.UserIDString,
                        config.NpcDamageToPlayers, config.PlayerDamageToNpcs, config.NpcTypeOverrides.Count));
                    break;
                case "reload":
                    if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
                    {
                        SendReply(player, Msg("NoPermission", player.UserIDString));
                        return;
                    }
                    LoadConfig();
                    SendReply(player, Msg("Reloaded", player.UserIDString));
                    break;
                default:
                    SendReply(player, Msg("Usage", player.UserIDString));
                    break;
            }
        }

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