How to make a Rust kill streak plugin (Oxide/Carbon)

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

namespace Oxide.Plugins
{
    [Info("KillStreaks", "RustPluginGenerator", "1.0.0")]
    [Description("Tracks consecutive PvP kills and rewards configurable milestones.")]
    public class KillStreaks : RustPlugin
    {
        private const string PermUse = "killstreaks.use";
        private const string PermAdmin = "killstreaks.admin";
        private const string DataFile = "KillStreaks";

        private class Milestone
        {
            [JsonProperty("Kills required")]
            public int Kills { get; set; }

            [JsonProperty("Reward shortname")]
            public string RewardShortname { get; set; }

            [JsonProperty("Reward amount")]
            public int RewardAmount { get; set; }
        }

        private class PluginConfig
        {
            [JsonProperty("Announce every kill")]
            public bool AnnounceEveryKill { get; set; }

            [JsonProperty("Minimum streak to announce a lost streak")]
            public int MinimumStreakToAnnounceLoss { get; set; }

            [JsonProperty("Milestones")]
            public List<Milestone> Milestones { get; set; }
        }

        private PluginConfig config;
        private Dictionary<string, int> streaks = new Dictionary<string, int>();

        protected override void LoadDefaultConfig()
        {
            config = new PluginConfig
            {
                AnnounceEveryKill = false,
                MinimumStreakToAnnounceLoss = 5,
                Milestones = new List<Milestone>
                {
                    new Milestone { Kills = 5, RewardShortname = "scrap", RewardAmount = 50 },
                    new Milestone { Kills = 10, RewardShortname = "supply.signal", RewardAmount = 1 },
                    new Milestone { Kills = 15, RewardShortname = "rifle.ak", RewardAmount = 1 }
                }
            };
        }

        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>
            {
                ["Milestone"] = "{0} reached a {1} kill streak!",
                ["EveryKill"] = "{0} is on a {1} kill streak.",
                ["StreakLost"] = "{0} lost a {1} kill streak.",
                ["YourStreak"] = "Your current kill streak: {0}",
                ["NoStreak"] = "You have no active kill streak.",
                ["TopHeader"] = "Top kill streaks:",
                ["TopEntry"] = "{0}. {1} - {2}",
                ["TopEmpty"] = "Nobody is on a kill streak right now.",
                ["ResetDone"] = "Cleared the streak for {0}.",
                ["ResetNotFound"] = "No streak found for {0}.",
                ["ResetUsage"] = "Usage: /streak reset <name or steamid>",
                ["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(PermAdmin, this);
        }

        private void OnServerInitialized()
        {
            var loaded = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<string, int>>(DataFile);
            if (loaded != null) streaks = loaded;
        }

        private void Unload()
        {
            SaveData();
        }

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, streaks);
        }

        private void OnEntityDeath(BasePlayer victim, HitInfo info)
        {
            if (victim == null || victim.IsNpc) return;

            string victimId = victim.UserIDString;
            int lostStreak = GetStreak(victimId);
            if (lostStreak > 0)
            {
                streaks.Remove(victimId);
                SaveData();
                if (lostStreak >= config.MinimumStreakToAnnounceLoss)
                    Server.Broadcast(Msg("StreakLost", null, victim.displayName, lostStreak));
            }

            if (info == null) return;
            BasePlayer attacker = info.InitiatorPlayer;
            if (attacker == null || attacker.IsNpc || attacker == victim || !attacker.IsConnected) return;
            if (attacker.userID == victim.userID) return;

            string attackerId = attacker.UserIDString;
            int newStreak = GetStreak(attackerId) + 1;
            streaks[attackerId] = newStreak;
            SaveData();

            Milestone milestone = FindMilestone(newStreak);
            if (milestone != null)
            {
                Server.Broadcast(Msg("Milestone", null, attacker.displayName, newStreak));
                GiveReward(attacker, milestone);
            }
            else if (config.AnnounceEveryKill)
            {
                Server.Broadcast(Msg("EveryKill", null, attacker.displayName, newStreak));
            }
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null) return;
            string userId = player.UserIDString;
            if (streaks.Remove(userId)) SaveData();
        }

        private int GetStreak(string userId)
        {
            int value;
            return streaks.TryGetValue(userId, out value) ? value : 0;
        }

        private Milestone FindMilestone(int kills)
        {
            if (config.Milestones == null) return null;
            foreach (var milestone in config.Milestones)
            {
                if (milestone != null && milestone.Kills == kills) return milestone;
            }
            return null;
        }

        private void GiveReward(BasePlayer player, Milestone milestone)
        {
            if (string.IsNullOrEmpty(milestone.RewardShortname) || milestone.RewardAmount <= 0) return;
            Item item = ItemManager.CreateByName(milestone.RewardShortname, milestone.RewardAmount);
            if (item == null) return;
            player.GiveItem(item);
        }

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

            if (args != null && args.Length > 0 && args[0].ToLower() == "top")
            {
                ShowTop(player);
                return;
            }

            if (args != null && args.Length > 0 && args[0].ToLower() == "reset")
            {
                HandleReset(player, args);
                return;
            }

            int streak = GetStreak(player.UserIDString);
            SendReply(player, streak > 0 ? Msg("YourStreak", player.UserIDString, streak) : Msg("NoStreak", player.UserIDString));
        }

        private void ShowTop(BasePlayer player)
        {
            var list = new List<KeyValuePair<string, int>>(streaks);
            list.Sort((a, b) => b.Value.CompareTo(a.Value));
            if (list.Count == 0)
            {
                SendReply(player, Msg("TopEmpty", player.UserIDString));
                return;
            }

            SendReply(player, Msg("TopHeader", player.UserIDString));
            int shown = 0;
            foreach (var entry in list)
            {
                if (shown >= 5) break;
                string name = GetDisplayName(entry.Key);
                SendReply(player, Msg("TopEntry", player.UserIDString, shown + 1, name, entry.Value));
                shown++;
            }
        }

        private string GetDisplayName(string userId)
        {
            BasePlayer found = BasePlayer.FindAwakeOrSleeping(userId);
            return found != null ? found.displayName : userId;
        }

        private void HandleReset(BasePlayer player, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args.Length < 2)
            {
                SendReply(player, Msg("ResetUsage", player.UserIDString));
                return;
            }

            string target = args[1];
            string targetId = target;
            BasePlayer found = BasePlayer.FindAwakeOrSleeping(target);
            if (found != null) targetId = found.UserIDString;

            if (streaks.Remove(targetId))
            {
                SaveData();
                SendReply(player, Msg("ResetDone", player.UserIDString, target));
            }
            else
            {
                SendReply(player, Msg("ResetNotFound", player.UserIDString, target));
            }
        }
    }
}