How to make a Rust explosive damage multiplier plugin (per-weapon raiding)

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

namespace Oxide.Plugins
{
    [Info("Explosive Damage Multiplier", "RustPluginGenerator", "1.0.0")]
    [Description("Scales explosion damage against structures and deployables with per-weapon multipliers.")]
    public class ExplosiveDamageMultiplier : RustPlugin
    {
        private const string PermAdmin = "explosivedamagemultiplier.admin";

        private PluginConfig config;

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

            [JsonProperty("Max Multiplier")]
            public float MaxMultiplier = 4f;

            [JsonProperty("Weapon Multipliers")]
            public Dictionary<string, float> WeaponMultipliers = new Dictionary<string, float>
            {
                ["explosive.satchel"] = 1.25f,
                ["explosive.timed"] = 1.0f,
                ["rocket_basic"] = 1.5f,
                ["rocket_hv"] = 1.25f,
                ["ammo.rocket.basic"] = 1.25f
            };
        }

        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>
            {
                ["Reloaded"] = "Explosive damage multipliers reloaded: {0} weapon entries, enabled: {1}",
                ["NoPermission"] = "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);
        }

        private void Unload()
        {
            config = null;
        }

        [ChatCommand("edm.reload")]
        private void CmdReload(BasePlayer player, string command, string[] args)
        {
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            LoadConfig();
            string msg = Msg("Reloaded", player?.UserIDString, config.WeaponMultipliers.Count, config.Enabled);
            if (player != null) SendReply(player, msg);
            else PrintWarning(msg);
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
        {
            if (config == null || !config.Enabled || entity == null || hitInfo == null) return null;
            if (hitInfo.damageTypes == null) return null;
            if (entity is BasePlayer) return null;

            if (hitInfo.damageTypes.GetMajorityDamageType() != Rust.DamageType.Explosion) return null;
            if (!IsRaidable(entity)) return null;

            string prefab = GetWeaponShortName(hitInfo);
            if (string.IsNullOrEmpty(prefab)) return null;

            float multiplier;
            if (!config.WeaponMultipliers.TryGetValue(prefab.ToLower(), out multiplier)) return null;
            if (multiplier <= 0f) return null;

            float original = hitInfo.damageTypes.Total();
            if (original <= 0f) return null;

            float capped = Mathf.Min(multiplier, config.MaxMultiplier);
            hitInfo.damageTypes.ScaleAll(capped);
            return null;
        }

        private static bool IsRaidable(BaseCombatEntity entity)
        {
            if (entity is BuildingBlock) return true;
            if (entity is Door) return true;
            if (entity is StorageContainer) return true;
            if (entity is BaseOven) return true;
            if (entity is CodeLock) return true;
            if (entity is BuildingPrivlidge) return true;
            if (entity is AutoTurret) return true;
            if (entity is SamSite) return true;
            return false;
        }

        private static string GetWeaponShortName(HitInfo hitInfo)
        {
            try
            {
                if (hitInfo.WeaponPrefab != null && !string.IsNullOrEmpty(hitInfo.WeaponPrefab.ShortPrefabName))
                    return hitInfo.WeaponPrefab.ShortPrefabName;

                if (hitInfo.Weapon != null)
                {
                    BaseEntity weaponEntity = hitInfo.Weapon as BaseEntity;
                    if (weaponEntity != null && !string.IsNullOrEmpty(weaponEntity.ShortPrefabName))
                        return weaponEntity.ShortPrefabName;
                }
            }
            catch
            {
                // ignore resolve failures
            }
            return null;
        }
    }
}