How to make a Rust kill feed plugin (CUI, last 5 kills)

using System.Linq;
using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Game.Rust.Cui;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Kill Feed UI", "RustPluginGenerator", "1.0.0")]
    [Description("Shows a CUI kill feed with the last player kills on the right side of every player's screen.")]
    public class KillFeedUI : RustPlugin
    {
        private const string PermUse = "killfeedui.use";
        private const string PanelName = "killfeedui.panel";

        private class PluginConfig
        {
            [JsonProperty("Enabled")]
            public bool Enabled = true;
            [JsonProperty("Feed size")]
            public int FeedSize = 5;
            [JsonProperty("Entry seconds")]
            public int EntrySeconds = 10;
            [JsonProperty("Panel anchor min")]
            public string AnchorMin = "0.84 0.55";
            [JsonProperty("Panel anchor max")]
            public string AnchorMax = "0.99 0.90";
            [JsonProperty("Panel color")]
            public string PanelColor = "0.05 0.05 0.05 0.55";
            [JsonProperty("Text color")]
            public string TextColor = "1 1 1 1";
            [JsonProperty("Font size")]
            public int FontSize = 12;
            [JsonProperty("Fallback weapon name")]
            public string FallbackWeapon = "Unknown";
            [JsonProperty("Muted players")]
            public HashSet<string> MutedPlayers = new HashSet<string>();
        }

        private class KillEntry
        {
            public string Killer;
            public string Weapon;
            public string Victim;
            public float When;
        }

        private PluginConfig config;
        private readonly List<KillEntry> feed = new List<KillEntry>();
        private Timer expireTimer;

        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();
            }
            if (config.MutedPlayers == null) config.MutedPlayers = new HashSet<string>();
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["KillLine"] = "{0} [{1}] {2}",
                ["ToggledOff"] = "Kill feed hidden. Use /killfeed to show it again.",
                ["ToggledOn"] = "Kill feed shown.",
                ["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);
        }

        private void OnServerInitialized()
        {
            if (!config.Enabled) return;
            expireTimer = timer.Every(1f, ExpireTick);
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null || !player.IsConnected) continue;
                BuildFeed(player);
            }
        }

        private void Unload()
        {
            expireTimer?.Destroy();
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null) continue;
                CuiHelper.DestroyUi(player, PanelName);
            }
            SaveConfig();
        }

        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            if (!config.Enabled || entity == null || info == null) return;
            var victim = entity as BasePlayer;
            if (victim == null || victim.IsNpc) return;
            var killer = info.InitiatorPlayer;
            if (killer == null || killer.IsNpc || killer == victim) return;

            var weapon = info.Weapon?.GetItem()?.info?.displayName?.english ?? config.FallbackWeapon;
            feed.Add(new KillEntry
            {
                Killer = killer.displayName ?? "?",
                Weapon = weapon,
                Victim = victim.displayName ?? "?",
                When = UnityEngine.Time.realtimeSinceStartup
            });
            while (feed.Count > Mathf.Max(1, config.FeedSize)) feed.RemoveAt(0);
            RedrawAll();
        }

        private void ExpireTick()
        {
            if (!config.Enabled) return;
            float now = UnityEngine.Time.realtimeSinceStartup;
            if (feed.RemoveAll(e => now - e.When > config.EntrySeconds) > 0)
                RedrawAll();
        }

        private void RedrawAll()
        {
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null || !player.IsConnected) continue;
                BuildFeed(player);
            }
        }

        private void BuildFeed(BasePlayer player)
        {
            CuiHelper.DestroyUi(player, PanelName);
            if (!config.Enabled || config.MutedPlayers.Contains(player.UserIDString)) return;

            var container = new CuiElementContainer();
            var panel = container.Add(new CuiPanel
            {
                Image = { Color = config.PanelColor },
                RectTransform = { AnchorMin = config.AnchorMin, AnchorMax = config.AnchorMax },
                CursorEnabled = false
            }, "Overlay", PanelName);

            int count = feed.Count;
            int slots = Mathf.Max(1, config.FeedSize);
            for (int i = 0; i < count; i++)
            {
                var entry = feed[count - 1 - i];
                float top = 1f - i * (1f / slots);
                float bottom = top - (1f / slots);
                container.Add(new CuiLabel
                {
                    Text =
                    {
                        Text = Msg("KillLine", player.UserIDString, entry.Killer, entry.Weapon, entry.Victim),
                        FontSize = config.FontSize,
                        Color = config.TextColor,
                        Align = TextAnchor.MiddleLeft
                    },
                    RectTransform = { AnchorMin = $"0.03 {bottom:0.###}", AnchorMax = $"0.97 {top:0.###}" }
                }, panel);
            }
            CuiHelper.AddUi(player, container);
        }

        private void OnPlayerSleepEnded(BasePlayer player)
        {
            if (player == null || !config.Enabled) return;
            BuildFeed(player);
        }

        [ChatCommand("killfeed")]
        private void CmdKillFeed(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (!config.MutedPlayers.Remove(player.UserIDString))
            {
                config.MutedPlayers.Add(player.UserIDString);
                CuiHelper.DestroyUi(player, PanelName);
                player.ChatMessage(Msg("ToggledOff", player.UserIDString));
            }
            else
            {
                BuildFeed(player);
                player.ChatMessage(Msg("ToggledOn", player.UserIDString));
            }
            SaveConfig();
        }
    }
}