How to make a Rust longest shot plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("Longest Shot Tracker", "RustPluginGenerator", "1.0.0")]
    [Description("Tracks each player's longest projectile kill distance and the server-wide record.")]
    public class LongestShotTracker : RustPlugin
    {
        private const string PermUse = "longestshottracker.use";
        private const string PermReset = "longestshottracker.reset";
        private const string DataFileName = "LongestShotTracker";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Announce Server Record")]
            public bool AnnounceServerRecord { get; set; } = true;

            [JsonProperty("Minimum Distance To Record")]
            public float MinimumDistance { get; set; } = 50f;
        }

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

            [JsonProperty("Distance")]
            public float Distance { get; set; }

            [JsonProperty("Victim Name")]
            public string VictimName { get; set; } = "";

            [JsonProperty("Timestamp")]
            public long Timestamp { get; set; }
        }

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

            [JsonProperty("Distance")]
            public float Distance { get; set; }

            [JsonProperty("Victim Name")]
            public string VictimName { get; set; } = "";

            [JsonProperty("Timestamp")]
            public long Timestamp { get; set; }
        }

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

            [JsonProperty("Server")]
            public ServerRecord Server { get; set; } = new ServerRecord();
        }

        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>
            {
                ["NoRecord"] = "You have no projectile kill record yet. Land a kill from at least {0} m.",
                ["YourRecord"] = "Your longest shot: {0} m (victim: {1}).",
                ["ServerRecord"] = "Server record: {0} m by {1} (victim: {2}).",
                ["NoServerRecord"] = "No server record has been set yet.",
                ["RecordBroken"] = "{0} just set a new server record: {1} m kill on {2}!",
                ["Reset"] = "All longest shot records have been wiped.",
                ["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(PermUse, this);
            permission.RegisterPermission(PermReset, this);
        }

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

        private void Unload()
        {
            SaveData();
        }

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

        private object OnPlayerDeath(BasePlayer player, HitInfo info)
        {
            if (player == null || info == null) return null;
            var attacker = info.InitiatorPlayer;
            if (attacker == null || attacker == player) return null;
            if (!info.IsProjectile()) return null;

            float distance = Vector3.Distance(attacker.eyes.position, player.transform.position);
            if (distance < config.MinimumDistance) return null;
            distance = Mathf.Round(distance * 10f) / 10f;

            if (data == null) data = new StoredData();

            PlayerRecord existing;
            if (!data.Players.TryGetValue(attacker.userID, out existing) || distance > existing.Distance)
            {
                data.Players[attacker.userID] = new PlayerRecord
                {
                    Name = attacker.displayName,
                    Distance = distance,
                    VictimName = player.displayName,
                    Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
                };
            }

            if (distance > data.Server.Distance)
            {
                data.Server = new ServerRecord
                {
                    Name = attacker.displayName,
                    Distance = distance,
                    VictimName = player.displayName,
                    Timestamp = DateTimeOffset.UtcNow.ToUnixTimeSeconds()
                };

                if (config.AnnounceServerRecord)
                    Server.Broadcast(Msg("RecordBroken", null, attacker.displayName, distance.ToString("0.0"), player.displayName));
            }

            SaveData();
            return null;
        }

        [ChatCommand("longest")]
        private void CmdLongest(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            PlayerRecord own;
            if (data != null && data.Players.TryGetValue(player.userID, out own))
                SendReply(player, Msg("YourRecord", player.UserIDString, own.Distance.ToString("0.0"), own.VictimName));
            else
                SendReply(player, Msg("NoRecord", player.UserIDString, config.MinimumDistance.ToString("0")));

            if (data != null && data.Server.Distance > 0f)
                SendReply(player, Msg("ServerRecord", player.UserIDString, data.Server.Distance.ToString("0.0"), data.Server.Name, data.Server.VictimName));
            else
                SendReply(player, Msg("NoServerRecord", player.UserIDString));
        }

        [ConsoleCommand("longestshot.reset")]
        private void CcmdReset(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermReset))
            {
                arg.ReplyWith(lang.GetMessage("NoPermission", this, player.UserIDString));
                return;
            }

            data = new StoredData();
            SaveData();
            arg.ReplyWith(lang.GetMessage("Reset", this, player?.UserIDString));
        }
    }
}