How to make a Rust raid logger plugin (explosive hit tracking)

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

namespace Oxide.Plugins
{
    [Info("Raid Logger", "RustPluginGenerator", "1.0.0")]
    [Description("Logs explosive damage on player buildings to a data file and lists recent raids in game.")]
    public class RaidLogger : RustPlugin
    {
        private const string PermUse = "raidlogger.use";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Merge Radius (metres)")]
            public float MergeRadius = 25f;

            [JsonProperty("Merge Window Seconds")]
            public int MergeWindowSeconds = 300;

            [JsonProperty("Max Stored Events")]
            public int MaxStoredEvents = 500;

            [JsonProperty("Minimum Hits Per Event")]
            public int MinimumHits = 1;

            [JsonProperty("Log To Console")]
            public bool LogToConsole = true;
        }

        private class RaidEvent
        {
            [JsonProperty("Attacker Id")]
            public string AttackerId;

            [JsonProperty("Attacker Name")]
            public string AttackerName;

            [JsonProperty("Defender Id")]
            public string DefenderId;

            [JsonProperty("Defender Name")]
            public string DefenderName;

            [JsonProperty("Grid")]
            public string Grid;

            [JsonProperty("Position")]
            public Vector3 Position;

            [JsonProperty("Weapon")]
            public string Weapon;

            [JsonProperty("First Seen")]
            public long FirstSeen;

            [JsonProperty("Last Seen")]
            public long LastSeen;

            [JsonProperty("Hits")]
            public int Hits;
        }

        private class StoredData
        {
            [JsonProperty("Raids")]
            public List<RaidEvent> Raids = new List<RaidEvent>();
        }

        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>
            {
                ["NoPermission"] = "You do not have permission to use this command.",
                ["NoRaids"] = "No raids have been logged yet.",
                ["Header"] = "Recent raids ({0} shown of {1}):",
                ["Entry"] = "{0}. {1} ago | {2} grid | {3} ({4}) hit {5} ({6}) with {7}, {8} hits",
                ["InvalidCount"] = "Invalid count. Usage: /raids [count]"
            }, 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(PermUse, this);
        }

        private void OnServerInitialized()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name) ?? new StoredData();
        }

        private void Unload()
        {
            if (data != null)
                Interface.Oxide.DataFileSystem.WriteObject(Name, data);
        }

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

            var block = entity as BuildingBlock;
            if (block == null) return null;

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

            BasePlayer attacker = hitInfo.InitiatorPlayer;
            if (attacker == null && hitInfo.Initiator is BasePlayer initiatorPlayer)
                attacker = initiatorPlayer;

            if (attacker == null || attacker.IsNpc) return null;

            string defenderId = ResolveOwnerId(block);
            if (string.IsNullOrEmpty(defenderId)) return null;

            string weapon = hitInfo.WeaponPrefab != null
                ? hitInfo.WeaponPrefab.ShortPrefabName
                : hitInfo.Weapon != null ? hitInfo.Weapon.ShortPrefabName : "explosive";

            RecordRaid(block, attacker, defenderId, weapon);
            return null;
        }

        private string ResolveOwnerId(BuildingBlock block)
        {
            if (block.buildingID != 0)
            {
                foreach (var ent in BaseNetworkable.serverEntities)
                {
                    var priv = ent as BuildingPrivlidge;
                    if (priv != null && priv.buildingID == block.buildingID)
                        return priv.OwnerID.ToString();
                }
            }

            return block.OwnerID != 0 ? block.OwnerID.ToString() : null;
        }

        private void RecordRaid(BuildingBlock block, BasePlayer attacker, string defenderId, string weapon)
        {
            if (data == null) data = new StoredData();

            Vector3 pos = block.transform.position;
            long now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();

            RaidEvent match = null;
            foreach (var ev in data.Raids)
            {
                if (ev.DefenderId != defenderId) continue;
                if (ev.AttackerId != attacker.UserIDString) continue;
                if (now - ev.LastSeen > config.MergeWindowSeconds) continue;
                if (Vector3.Distance(ev.Position, pos) > config.MergeRadius) continue;
                match = ev;
                break;
            }

            if (match != null)
            {
                match.Hits++;
                match.LastSeen = now;
                match.Position = pos;
                return;
            }

            var raid = new RaidEvent
            {
                AttackerId = attacker.UserIDString,
                AttackerName = attacker.displayName,
                DefenderId = defenderId,
                DefenderName = "Unknown",
                Grid = GridReference(pos),
                Position = pos,
                Weapon = weapon,
                FirstSeen = now,
                LastSeen = now,
                Hits = 1
            };

            var defender = BasePlayer.FindAwakeOrSleeping(defenderId);
            if (defender != null)
                raid.DefenderName = defender.displayName;

            data.Raids.Add(raid);

            while (data.Raids.Count > Math.Max(1, config.MaxStoredEvents))
                data.Raids.RemoveAt(0);

            Interface.Oxide.DataFileSystem.WriteObject(Name, data);

            if (config.LogToConsole)
                Puts(string.Format("[Raid] {0} ({1}) hit {2} ({3}) at {4} grid with {5}",
                    attacker.displayName, attacker.UserIDString, raid.DefenderName, defenderId, raid.Grid, weapon));
        }

        private static string GridReference(Vector3 position)
        {
            const float cellSize = 146.5f;
            const float worldSize = 4500f;

            int x = Mathf.FloorToInt((position.x + worldSize / 2f) / cellSize);
            int z = Mathf.FloorToInt((position.z + worldSize / 2f) / cellSize);

            x = Mathf.Clamp(x, 0, 30);
            z = Mathf.Clamp(z, 0, 30);

            char column = (char)('A' + x);
            return column + z.ToString();
        }

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

            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            if (data == null || data.Raids.Count == 0)
            {
                player.ChatMessage(Msg("NoRaids", player.UserIDString));
                return;
            }

            int count = 10;
            if (args != null && args.Length > 0 && (!int.TryParse(args[0], out count) || count <= 0))
            {
                player.ChatMessage(Msg("InvalidCount", player.UserIDString));
                return;
            }

            count = Mathf.Clamp(count, 1, data.Raids.Count);
            var recent = data.Raids.Skip(data.Raids.Count - count).Reverse().ToList();

            player.ChatMessage(Msg("Header", player.UserIDString, count, data.Raids.Count));

            long now = DateTimeOffset.UtcNow.ToUnixTimeSeconds();
            for (int i = 0; i < recent.Count; i++)
            {
                var ev = recent[i];
                long ago = Math.Max(0, now - ev.FirstSeen);
                string time = ago < 60 ? ago + "s" : (ago / 60) + "m";
                player.ChatMessage(Msg("Entry", player.UserIDString,
                    i + 1, time, ev.Grid, ev.AttackerName, ev.AttackerId,
                    ev.DefenderName, ev.DefenderId, ev.Weapon, ev.Hits));
            }
        }
    }
}