How to make a Rust no vehicle decay plugin (per-type scaling)

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

namespace Oxide.Plugins
{
    [Info("No Vehicle Decay", "RustPluginGenerator", "1.0.0")]
    [Description("Scales or disables decay damage on vehicles per type, optionally only within a tool cupboard range")]
    public class NoVehicleDecay : RustPlugin
    {
        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Require tool cupboard to protect")]
            public bool RequireBuildingPrivilege { get; set; } = false;

            [JsonProperty("Vehicle rules")]
            public Dictionary<string, VehicleRule> Vehicles { get; set; } = new Dictionary<string, VehicleRule>
            {
                ["minicopter.entity"] = new VehicleRule { Multiplier = 0.0f },
                ["boat.entity"] = new VehicleRule { Multiplier = 0.0f },
                ["ridablehorse.entity"] = new VehicleRule { Multiplier = 0.0f },
                ["modularcar.entity"] = new VehicleRule { Multiplier = 0.0f }
            };

            [JsonProperty("Ignored prefabs")]
            public List<string> IgnoredPrefabs { get; set; } = new List<string>();
        }

        private class VehicleRule
        {
            [JsonProperty("Decay multiplier (0 = never)")]
            public float Multiplier { get; set; } = 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();
            }
            SaveConfig();
        }

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

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

            if (hitInfo.damageTypes.GetMajorityDamageType() != Rust.DamageType.Decay) return null;
            if (hitInfo.InitiatorPlayer != null) return null;

            string prefab = entity.ShortPrefabName;
            if (string.IsNullOrEmpty(prefab)) return null;
            if (config.IgnoredPrefabs != null && config.IgnoredPrefabs.Contains(prefab)) return null;

            VehicleRule rule = ResolveRule(entity, prefab);
            if (rule == null) return null;

            if (config.RequireBuildingPrivilege && entity.GetBuildingPrivilege() == null) return null;

            float multiplier = Mathf.Clamp(rule.Multiplier, 0f, 10f);
            if (multiplier <= 0f)
            {
                hitInfo.damageTypes.ScaleAll(0f);
                return true;
            }

            hitInfo.damageTypes.ScaleAll(multiplier);
            return null;
        }

        private VehicleRule ResolveRule(BaseCombatEntity entity, string prefab)
        {
            if (config.Vehicles != null)
            {
                VehicleRule direct;
                if (config.Vehicles.TryGetValue(prefab, out direct)) return direct;

                foreach (var pair in config.Vehicles)
                {
                    if (string.Equals(pair.Key, prefab, StringComparison.OrdinalIgnoreCase)) return pair.Value;
                }
            }

            string fallback = ClassKey(entity);
            if (fallback == null) return null;

            if (config.Vehicles != null && config.Vehicles.TryGetValue(fallback, out var found)) return found;

            return new VehicleRule { Multiplier = 0.0f };
        }

        private string ClassKey(BaseEntity entity)
        {
            if (entity == null) return null;
            string prefab = entity.ShortPrefabName;
            if (string.IsNullOrEmpty(prefab)) return null;
            if (prefab.Contains("minicopter")) return "minicopter.entity";
            if (prefab.Contains("boat")) return "boat.entity";
            if (prefab.Contains("ridablehorse")) return "ridablehorse.entity";
            if (prefab.Contains("modularcar")) return "modularcar.entity";
            return null;
        }
    }
}