How to make a Rust NPC kill counter plugin (scientists and animals)

using System;
using System.Collections.Generic;
using Facepunch.Math;
using Newtonsoft.Json;
using Oxide.Core;
using Oxide.Core.Plugins;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("NpcKillCounter", "RustPluginGenerator", "1.0.0")]
    [Description("Counts scientist and animal kills per player and announces every 100th kill.")]
    public class NpcKillCounter : RustPlugin
    {
        private const string PermView = "npckillcounter.view";
        private const string PermAnnounce = "npckillcounter.announce";

        private PluginConfig config;
        private StoredData data;
        private Timer saveTimer;

        private class PluginConfig
        {
            [JsonProperty("Save Interval Seconds")]
            public float SaveIntervalSeconds { get; set; } = 300f;

            [JsonProperty("Track Scientists")]
            public bool TrackScientists { get; set; } = true;

            [JsonProperty("Track Animals")]
            public bool TrackAnimals { get; set; } = true;

            [JsonProperty("Use Permission For Announce")]
            public bool UsePermissionForAnnounce { get; set; } = false;

            [JsonProperty("Announce Milestone")]
            public int AnnounceMilestone { get; set; } = 100;
        }

        private class PlayerStats
        {
            [JsonProperty("Name")]
            public string Name { get; set; }

            [JsonProperty("Scientists")]
            public int Scientists { get; set; }

            [JsonProperty("Animals")]
            public int Animals { get; set; }

            [JsonProperty("Last Kill")]
            public int LastKill { get; set; }

            [JsonIgnore]
            public int Total => Scientists + Animals;
        }

        private class StoredData
        {
            [JsonProperty("Players")]
            public Dictionary<string, PlayerStats> Players { get; set; } = new Dictionary<string, PlayerStats>();
        }

        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>
            {
                ["Your Stats"] = "NPC kills: {0} scientists, {1} animals (total {2}).",
                ["Other Stats"] = "{0}: {1} scientists, {2} animals (total {3}).",
                ["No Data"] = "No NPC kill data found for that player.",
                ["No Access"] = "You do not have permission to view other players.",
                ["Announce"] = "{0} reached {1} NPC kills ({2} scientists, {3} animals)!"
            }, 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(PermView, this);
            permission.RegisterPermission(PermAnnounce, this);
        }

        private void OnServerInitialized()
        {
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name) ?? new StoredData();
            if (data.Players == null) data.Players = new Dictionary<string, PlayerStats>();

            if (config.SaveIntervalSeconds > 0f)
                saveTimer = timer.Every(config.SaveIntervalSeconds, SaveData);
        }

        private void Unload()
        {
            if (saveTimer != null && !saveTimer.Destroyed) saveTimer.Destroy();
            SaveData();
        }

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

        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            if (entity == null || info == null) return;

            var attacker = info.InitiatorPlayer;
            if (attacker == null || attacker.IsNpc || attacker.IsDead()) return;

            bool isScientist = entity is ScientistNPC;
            bool isAnimal = entity is BaseAnimalNPC;

            if (isScientist && !config.TrackScientists) return;
            if (isAnimal && !config.TrackAnimals) return;
            if (!isScientist && !isAnimal) return;

            PlayerStats stats;
            if (!data.Players.TryGetValue(attacker.UserIDString, out stats))
            {
                stats = new PlayerStats();
                data.Players[attacker.UserIDString] = stats;
            }

            stats.Name = attacker.displayName;
            stats.LastKill = Epoch.Current;

            if (isScientist) stats.Scientists++;
            else stats.Animals++;

            int total = stats.Total;
            int milestone = config.AnnounceMilestone;
            if (milestone <= 0 || total % milestone != 0) return;

            if (config.UsePermissionForAnnounce && !permission.UserHasPermission(attacker.UserIDString, PermAnnounce)) return;

            Server.Broadcast(Msg("Announce", null, stats.Name, total, stats.Scientists, stats.Animals));
        }

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

            if (args == null || args.Length == 0)
            {
                SendStats(player, player.UserIDString, true);
                return;
            }

            if (!permission.UserHasPermission(player.UserIDString, PermView))
            {
                player.ChatMessage(Msg("No Access", player.UserIDString));
                return;
            }

            string query = string.Join(" ", args).Trim();
            string targetId = ResolvePlayerId(query);

            if (string.IsNullOrEmpty(targetId) || !data.Players.ContainsKey(targetId))
            {
                player.ChatMessage(Msg("No Data", player.UserIDString));
                return;
            }

            SendStats(player, targetId, false);
        }

        private string ResolvePlayerId(string query)
        {
            if (string.IsNullOrEmpty(query)) return null;

            ulong rawId;
            if (ulong.TryParse(query, out rawId))
                return rawId.ToString();

            var target = BasePlayer.FindAwakeOrSleeping(query);
            if (target != null) return target.UserIDString;

            foreach (var pair in data.Players)
            {
                if (string.Equals(pair.Value.Name, query, StringComparison.OrdinalIgnoreCase))
                    return pair.Key;
            }

            return null;
        }

        private void SendStats(BasePlayer viewer, string targetId, bool self)
        {
            PlayerStats stats;
            if (!data.Players.TryGetValue(targetId, out stats))
            {
                viewer.ChatMessage(Msg("No Data", viewer.UserIDString));
                return;
            }

            if (self)
                viewer.ChatMessage(Msg("Your Stats", viewer.UserIDString, stats.Scientists, stats.Animals, stats.Total));
            else
                viewer.ChatMessage(Msg("Other Stats", viewer.UserIDString, stats.Name ?? targetId, stats.Scientists, stats.Animals, stats.Total));
        }
    }
}