How to make a Rust death messages plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("Death Notes", "RustPluginGenerator", "1.0.0")]
    [Description("Broadcasts a configurable chat message for every player death")]
    public class DeathNotes : RustPlugin
    {
        private const string PermAdmin = "deathnotes.admin";

        private PluginConfig config;
        private ulong lastVictim;
        private float lastDeathTime;

        private class PluginConfig
        {
            [JsonProperty("Broadcast Prefix")]
            public string BroadcastPrefix = "<color=#ce422b>[Death]</color>";

            [JsonProperty("Duplicate Window Seconds")]
            public float DuplicateWindowSeconds = 0.5f;

            [JsonProperty("Unknown Weapon")]
            public string UnknownWeapon = "Unknown";

            [JsonProperty("PvP Templates")]
            public Dictionary<string, string> PvpTemplates = new Dictionary<string, string>
            {
                ["Weapon"] = "{0} killed {1} with {2} at {3}m",
                ["NoWeapon"] = "{0} killed {1}"
            };

            [JsonProperty("Animal Templates")]
            public Dictionary<string, string> AnimalTemplates = new Dictionary<string, string>
            {
                ["Killed"] = "{1} was eaten by a {0}",
                ["Named"] = "{1} was killed by a {0}"
            };

            [JsonProperty("Npc Templates")]
            public Dictionary<string, string> NpcTemplates = new Dictionary<string, string>
            {
                ["Killed"] = "{1} was eliminated by {0}"
            };

            [JsonProperty("Environment Templates")]
            public Dictionary<string, string> EnvironmentTemplates = new Dictionary<string, string>
            {
                ["Fall"] = "{0} fell to their death",
                ["Cold"] = "{0} froze to death",
                ["Bleeding"] = "{0} bled out",
                ["Decay"] = "{0} decayed",
                ["Hunger"] = "{0} starved",
                ["Thirst"] = "{0} died of thirst",
                ["Radiation"] = "{0} died of radiation",
                ["Heat"] = "{0} burned to death",
                ["Suicide"] = "{0} ended it all",
                ["Default"] = "{0} died"
            };

            [JsonProperty("Animal Names")]
            public Dictionary<string, string> AnimalNames = new Dictionary<string, string>
            {
                ["bear"] = "Bear",
                ["polarbear"] = "Polar Bear",
                ["boar"] = "Boar",
                ["wolf"] = "Wolf",
                ["stag"] = "Stag",
                ["horse"] = "Horse",
                ["chicken"] = "Chicken",
                ["snake"] = "Snake",
                ["shark"] = "Shark",
                ["crocodile"] = "Crocodile",
                ["tiger"] = "Tiger",
                ["panther"] = "Panther"
            };

            [JsonProperty("Npc Names")]
            public Dictionary<string, string> NpcNames = new Dictionary<string, string>
            {
                ["scientistnpc"] = "Scientist",
                ["scientistnpc_arctic"] = "Arctic Scientist",
                ["scientistnpc_heavy"] = "Heavy Scientist",
                ["scientistnpc_junkpile"] = "Junkpile Scientist",
                ["tunneldweller"] = "Tunnel Dweller",
                ["underwaterdweller"] = "Underwater Dweller"
            };
        }

        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>
            {
                ["Death Message"] = "{0}",
                ["Test Header"] = "Test message for template group '{0}':",
                ["Reloaded"] = "DeathNotes config reloaded with {0} templates."
            }, this);
        }

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

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

        private object OnPlayerDeath(BasePlayer player, HitInfo info)
        {
            if (player == null || info == null) return null;

            if (config.DuplicateWindowSeconds > 0f && player.userID.Get() == lastVictim &&
                Time.realtimeSinceStartup - lastDeathTime < config.DuplicateWindowSeconds)
                return null;

            lastVictim = player.userID.Get();
            lastDeathTime = Time.realtimeSinceStartup;

            var line = BuildLine(player, info);
            if (string.IsNullOrEmpty(line)) return null;

            Server.Broadcast(string.Format("{0} {1}", config.BroadcastPrefix, Msg("Death Message", null, line)));
            return null;
        }

        private string BuildLine(BasePlayer victim, HitInfo info)
        {
            var victimName = victim.displayName;

            var attackerPlayer = info.InitiatorPlayer;
            if (attackerPlayer != null && attackerPlayer != victim)
            {
                var weapon = GetWeaponName(info);
                var template = string.IsNullOrEmpty(weapon)
                    ? Get(config.PvpTemplates, "NoWeapon", "{0} killed {1}")
                    : Get(config.PvpTemplates, "Weapon", "{0} killed {1} with {2} at {3}m");
                var distance = Mathf.RoundToInt(Vector3.Distance(attackerPlayer.transform.position, victim.transform.position));
                return string.Format(template, attackerPlayer.displayName, victimName, weapon, distance);
            }

            var initiator = info.Initiator;
            var animal = initiator as BaseAnimalNPC;
            if (animal != null)
            {
                var name = ReadableName(animal.ShortPrefabName, config.AnimalNames);
                var template = Get(config.AnimalTemplates, "Killed", "{1} was killed by a {0}");
                return string.Format(template, name, victimName);
            }

            var npc = initiator as BaseNpc;
            if (npc != null)
            {
                var name = ReadableName(npc.ShortPrefabName, config.NpcNames);
                var template = Get(config.NpcTemplates, "Killed", "{1} was eliminated by {0}");
                return string.Format(template, name, victimName);
            }

            var damageType = info.damageTypes.GetMajorityDamageType();
            var envKey = EnvironmentKey(damageType);
            var envTemplate = Get(config.EnvironmentTemplates, envKey, Get(config.EnvironmentTemplates, "Default", "{0} died"));
            return string.Format(envTemplate, victimName);
        }

        private static string GetWeaponName(HitInfo info)
        {
            var attack = info.Weapon;
            if (attack == null) return null;
            var item = attack.GetItem();
            if (item?.info == null) return null;
            return item.info.displayName.english;
        }

        private static string ReadableName(string prefab, Dictionary<string, string> table)
        {
            if (string.IsNullOrEmpty(prefab)) return "Unknown";
            var key = prefab.ToLowerInvariant().Replace(".prefab", "");
            if (key.StartsWith("npc_")) key = key.Substring(4);
            if (table != null && table.TryGetValue(key, out var known)) return known;
            return char.ToUpperInvariant(key[0]) + key.Substring(1).Replace('_', ' ');
        }

        private static string EnvironmentKey(Rust.DamageType type)
        {
            switch (type)
            {
                case Rust.DamageType.Fall: return "Fall";
                case Rust.DamageType.Cold: return "Cold";
                case Rust.DamageType.Bleeding: return "Bleeding";
                case Rust.DamageType.Decay: return "Decay";
                case Rust.DamageType.Hunger: return "Hunger";
                case Rust.DamageType.Thirst: return "Thirst";
                case Rust.DamageType.Radiation: return "Radiation";
                case Rust.DamageType.Heat: return "Heat";
                case Rust.DamageType.Suicide: return "Suicide";
                default: return "Default";
            }
        }

        private static string Get(Dictionary<string, string> table, string key, string fallback)
        {
            if (table != null && table.TryGetValue(key, out var value) && !string.IsNullOrEmpty(value))
                return value;
            return fallback;
        }

        [ChatCommand("deathnotes")]
        private void CmdDeathNotes(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, "You do not have permission to use this command.");
                return;
            }
            if (args == null || args.Length < 2 || args[0].ToLowerInvariant() != "test")
            {
                SendReply(player, "Usage: /deathnotes test <pvp|animal|npc|env>");
                return;
            }

            var group = args[1].ToLowerInvariant();
            Dictionary<string, string> table;
            switch (group)
            {
                case "animal": table = config.AnimalTemplates; break;
                case "npc": table = config.NpcTemplates; break;
                case "env": table = config.EnvironmentTemplates; break;
                default: group = "pvp"; table = config.PvpTemplates; break;
            }

            SendReply(player, Msg("Test Header", player.UserIDString, group));
            if (table == null) return;
            foreach (var pair in table)
                SendReply(player, string.Format("{0}: {1}", pair.Key, pair.Value));
        }

        [ConsoleCommand("deathnotes.reload")]
        private void CcmdReload(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                arg.ReplyWith("You do not have permission to use this command.");
                return;
            }

            LoadConfig();
            var count = 0;
            if (config.PvpTemplates != null) count += config.PvpTemplates.Count;
            if (config.AnimalTemplates != null) count += config.AnimalTemplates.Count;
            if (config.NpcTemplates != null) count += config.NpcTemplates.Count;
            if (config.EnvironmentTemplates != null) count += config.EnvironmentTemplates.Count;
            arg.ReplyWith(Msg("Reloaded", null, count));
        }
    }
}