How to make a Rust duels plugin (1v1 challenge system)

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

namespace Oxide.Plugins
{
    [Info("DuelSystem", "RustPluginGenerator", "1.0.0")]
    [Description("Adds player versus player duels with outside damage blocked and winner announcements")]
    public class DuelSystem : RustPlugin
    {
        private const string PermUse = "duelsystem.use";

        private PluginConfig config;
        private readonly Dictionary<ulong, ulong> requests = new Dictionary<ulong, ulong>();
        private readonly Dictionary<ulong, float> requestExpiry = new Dictionary<ulong, float>();
        private readonly Dictionary<ulong, Duel> duels = new Dictionary<ulong, Duel>();

        private class PluginConfig
        {
            [JsonProperty("Request Timeout Seconds")]
            public float RequestTimeoutSeconds { get; set; } = 30f;

            [JsonProperty("Maximum Request Distance")]
            public float MaximumRequestDistance { get; set; } = 300f;

            [JsonProperty("Block Damage From Non Duelists")]
            public bool BlockDamageFromNonDuelists { get; set; } = true;

            [JsonProperty("Announce Winner Server Wide")]
            public bool AnnounceWinnerServerWide { get; set; } = true;

            [JsonProperty("Wins")]
            public string WinsLabel { get; set; } = "Wins";

            [JsonProperty("Losses")]
            public string LossesLabel { get; set; } = "Losses";
        }

        private class Duel
        {
            public ulong PlayerA;
            public ulong PlayerB;
            public ulong OpponentOf(ulong id) => id == PlayerA ? PlayerB : PlayerA;
        }

        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 duels.",
                ["Usage"] = "Usage: /duel <player>, /duel accept or /duel cancel.",
                ["SelfDuel"] = "You cannot duel yourself.",
                ["NoPlayer"] = "No player found by that name.",
                ["TargetNpc"] = "You cannot duel NPCs.",
                ["NotAlive"] = "Both players must be alive and awake.",
                ["AlreadyDueling"] = "You are already in a duel.",
                ["TargetAlreadyDueling"] = "That player is already in a duel.",
                ["AlreadyRequested"] = "You already have a pending duel request.",
                ["TooFar"] = "That player is too far away to duel.",
                ["RequestSent"] = "Duel request sent to {0}. You have {1} seconds.",
                ["RequestReceived"] = "{0} challenged you to a duel. Type /duel accept to fight.",
                ["NoPending"] = "You have no pending duel request.",
                ["Cancelled"] = "Duel request cancelled.",
                ["Declined"] = "Duel request declined.",
                ["Started"] = "Duel started against {0}. Fight!",
                ["StartedBoth"] = "The duel between {0} and {1} has begun.",
                ["WinAnnounce"] = "{0} won a duel against {1}.",
                ["WinSelf"] = "You won the duel against {0}.",
                ["Loss"] = "You lost the duel against {0}.",
                ["DisconnectWin"] = "{0} disconnected. You win the duel."
            }, 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);
        }

        [ChatCommand("duel")]
        private void CmdDuel(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)
            {
                SendReply(player, Msg("Usage", player.UserIDString));
                return;
            }

            string sub = args[0].ToLowerInvariant();
            if (sub == "accept") { Accept(player); return; }
            if (sub == "cancel") { Cancel(player); return; }

            SendRequest(player, args[0]);
        }

        private void SendRequest(BasePlayer player, string name)
        {
            if (duels.ContainsKey(player.userID))
            {
                SendReply(player, Msg("AlreadyDueling", player.UserIDString));
                return;
            }
            if (requests.ContainsKey(player.userID))
            {
                SendReply(player, Msg("AlreadyRequested", player.UserIDString));
                return;
            }

            BasePlayer target = BasePlayer.FindAwakeOrSleeping(name);
            if (target == null)
            {
                SendReply(player, Msg("NoPlayer", player.UserIDString));
                return;
            }
            if (target.IsNpc)
            {
                SendReply(player, Msg("TargetNpc", player.UserIDString));
                return;
            }
            if (target.userID == player.userID)
            {
                SendReply(player, Msg("SelfDuel", player.UserIDString));
                return;
            }
            if (!target.IsAlive() || player.IsDead())
            {
                SendReply(player, Msg("NotAlive", player.UserIDString));
                return;
            }
            if (duels.ContainsKey(target.userID))
            {
                SendReply(player, Msg("TargetAlreadyDueling", player.UserIDString));
                return;
            }
            if (Vector3.Distance(player.transform.position, target.transform.position) > config.MaximumRequestDistance)
            {
                SendReply(player, Msg("TooFar", player.UserIDString));
                return;
            }

            requests[player.userID] = target.userID;
            requestExpiry[player.userID] = Time.realtimeSinceStartup + config.RequestTimeoutSeconds;

            SendReply(player, Msg("RequestSent", player.UserIDString, target.displayName, (int)config.RequestTimeoutSeconds));
            SendReply(target, Msg("RequestReceived", target.UserIDString, player.displayName));
        }

        private void Accept(BasePlayer player)
        {
            if (duels.ContainsKey(player.userID))
            {
                SendReply(player, Msg("AlreadyDueling", player.UserIDString));
                return;
            }

            ulong challengerId = 0;
            foreach (var pair in requests)
            {
                if (pair.Value == player.userID)
                {
                    float expiry;
                    if (requestExpiry.TryGetValue(pair.Key, out expiry) && expiry >= Time.realtimeSinceStartup)
                    {
                        challengerId = pair.Key;
                        break;
                    }
                }
            }

            if (challengerId == 0)
            {
                SendReply(player, Msg("NoPending", player.UserIDString));
                return;
            }

            requests.Remove(challengerId);
            requestExpiry.Remove(challengerId);

            BasePlayer challenger = BasePlayer.FindByID(challengerId);
            if (challenger == null || !player.IsAlive() || !challenger.IsAlive() || duels.ContainsKey(challenger.userID))
            {
                SendReply(player, Msg("NotAlive", player.UserIDString));
                return;
            }

            var duel = new Duel { PlayerA = challenger.userID, PlayerB = player.userID };
            duels[challenger.userID] = duel;
            duels[player.userID] = duel;

            SendReply(player, Msg("Started", player.UserIDString, challenger.displayName));
            SendReply(challenger, Msg("Started", challenger.UserIDString, player.displayName));
            Server.Broadcast(Msg("StartedBoth", null, challenger.displayName, player.displayName));
        }

        private void Cancel(BasePlayer player)
        {
            if (requests.Remove(player.userID))
            {
                requestExpiry.Remove(player.userID);
                SendReply(player, Msg("Cancelled", player.UserIDString));
                return;
            }

            ulong sourceId = 0;
            foreach (var pair in requests)
            {
                if (pair.Value == player.userID) { sourceId = pair.Key; break; }
            }
            if (sourceId != 0)
            {
                BasePlayer source = BasePlayer.FindByID(sourceId);
                requests.Remove(sourceId);
                requestExpiry.Remove(sourceId);
                SendReply(player, Msg("Declined", player.UserIDString));
                if (source != null) SendReply(source, Msg("Declined", source.UserIDString));
                return;
            }

            SendReply(player, Msg("NoPending", player.UserIDString));
        }

        private object OnEntityTakeDamage(BasePlayer player, HitInfo hitInfo)
        {
            if (player == null || hitInfo == null) return null;

            Duel duel;
            bool victimInDuel = duels.TryGetValue(player.userID, out duel);

            BasePlayer attacker = hitInfo.InitiatorPlayer;
            if (attacker == null || attacker == player) return null;

            if (victimInDuel && duel.OpponentOf(player.userID) == attacker.userID) return null;

            if (victimInDuel && config.BlockDamageFromNonDuelists) return true;

            if (duels.ContainsKey(attacker.userID)) return true;

            return null;
        }

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

            Duel duel;
            if (!duels.TryGetValue(victim.userID, out duel)) return;

            ulong winnerId = duel.OpponentOf(victim.userID);
            EndDuel(duel, winnerId, victim.userID, false);
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null) return;

            requests.Remove(player.userID);
            requestExpiry.Remove(player.userID);

            Duel duel;
            if (duels.TryGetValue(player.userID, out duel))
            {
                EndDuel(duel, duel.OpponentOf(player.userID), player.userID, true);
            }
        }

        private void EndDuel(Duel duel, ulong winnerId, ulong loserId, bool disconnected)
        {
            duels.Remove(duel.PlayerA);
            duels.Remove(duel.PlayerB);

            BasePlayer winner = BasePlayer.FindByID(winnerId);
            BasePlayer loser = BasePlayer.FindByID(loserId);

            string winnerName = winner != null ? winner.displayName : winnerId.ToString();
            string loserName = loser != null ? loser.displayName : loserId.ToString();

            if (config.AnnounceWinnerServerWide && !disconnected)
            {
                Server.Broadcast(Msg("WinAnnounce", null, winnerName, loserName));
            }

            if (winner != null)
            {
                SendReply(winner, disconnected
                    ? Msg("DisconnectWin", winner.UserIDString, loserName)
                    : Msg("WinSelf", winner.UserIDString, loserName));
            }
            if (loser != null)
            {
                SendReply(loser, Msg("Loss", loser.UserIDString, winnerName));
            }
        }
    }
}