How to make a Rust bounty plugin (scrap bounty pool)

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

namespace Oxide.Plugins
{
    [Info("BountySystem", "RustPluginGenerator", "1.0.0")]
    [Description("Scrap bounties on players that pay out to the killer on death.")]
    public class BountySystem : RustPlugin
    {
        private const string PermUse = "bountysystem.use";
        private const string DataFile = "BountySystem";

        private PluginConfig config;
        private Dictionary<string, BountyEntry> bounties = new Dictionary<string, BountyEntry>();

        private class BountyEntry
        {
            [JsonProperty("Target name")]
            public string Name;

            [JsonProperty("Backers")]
            public List<Backer> Backers = new List<Backer>();

            public int Total()
            {
                int total = 0;
                foreach (var b in Backers) total += b.Amount;
                return total;
            }
        }

        private class Backer
        {
            [JsonProperty("Steam ID")]
            public string UserId;

            [JsonProperty("Amount")]
            public int Amount;

            [JsonProperty("Name")]
            public string Name;
        }

        private class PluginConfig
        {
            [JsonProperty("Minimum bounty amount")]
            public int MinimumBounty = 10;

            [JsonProperty("Block killers from the target's team")]
            public bool BlockSameTeam = true;

            [JsonProperty("Broadcast new bounties")]
            public bool BroadcastNewBounties = true;
        }

        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>
            {
                ["Placed"] = "<color=#ffb347>[Bounty]</color> You placed {0} scrap on {1}. Current pool: {2}.",
                ["Broadcast"] = "<color=#ffb347>[Bounty]</color> {0} now has a bounty of {1} scrap.",
                ["Claimed"] = "<color=#ffb347>[Bounty]</color> You claimed {0} scrap from killing {1}.",
                ["Victim"] = "<color=#ffb347>[Bounty]</color> {0} collected the {1} scrap bounty on you.",
                ["ListHeader"] = "<color=#ffb347>[Bounty]</color> Active bounties ({0}):",
                ["ListItem"] = "{0} - pool {1} scrap",
                ["ListEmpty"] = "<color=#ffb347>[Bounty]</color> There are no active bounties.",
                ["NoPermission"] = "You do not have permission to use bounties.",
                ["InvalidArgs"] = "Usage: /bounty <player> <amount>",
                ["NotFound"] = "No player found with that name or ID.",
                ["Self"] = "You cannot place a bounty on yourself.",
                ["SameTeam"] = "You cannot place a bounty on a teammate.",
                ["TooLow"] = "The minimum bounty is {0} scrap.",
                ["NoScrap"] = "You do not have {0} scrap.",
                ["Cancelled"] = "Removed all bounties on {0}.",
                ["CancelUsage"] = "Usage: bountysystem.cancel <steamid>"
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args)
        {
            return string.Format(lang.GetMessage(key, this, userId), args);
        }

        private int ScrapId => ItemManager.FindItemDefinition("scrap")?.itemid ?? -932201673;

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
        }

        private void OnServerInitialized()
        {
            bounties = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<string, BountyEntry>>(DataFile) ?? new Dictionary<string, BountyEntry>();
        }

        private void Unload()
        {
            SaveBounties();
        }

        private void SaveBounties()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, bounties);
        }

        [ChatCommand("bounty")]
        private void CmdBounty(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 < 2)
            {
                SendReply(player, Msg("InvalidArgs", player.UserIDString));
                return;
            }

            BasePlayer target = BasePlayer.FindAwakeOrSleeping(args[0]);
            if (target == null)
            {
                SendReply(player, Msg("NotFound", player.UserIDString));
                return;
            }

            if (target.userID == player.userID)
            {
                SendReply(player, Msg("Self", player.UserIDString));
                return;
            }

            if (config.BlockSameTeam && player.currentTeam != 0 && player.currentTeam == target.currentTeam)
            {
                SendReply(player, Msg("SameTeam", player.UserIDString));
                return;
            }

            int amount;
            if (!int.TryParse(args[1], out amount) || amount < config.MinimumBounty)
            {
                SendReply(player, Msg("TooLow", player.UserIDString, config.MinimumBounty));
                return;
            }

            if (player.inventory.GetAmount(ScrapId) < amount)
            {
                SendReply(player, Msg("NoScrap", player.UserIDString, amount));
                return;
            }

            var taken = player.inventory.Take(null, ScrapId, amount);
            if (taken <= 0)
            {
                SendReply(player, Msg("NoScrap", player.UserIDString, amount));
                return;
            }
            taken = Math.Min(taken, amount);

            BountyEntry entry;
            if (!bounties.TryGetValue(target.UserIDString, out entry))
            {
                entry = new BountyEntry { Name = target.displayName };
                bounties[target.UserIDString] = entry;
            }
            entry.Name = target.displayName;

            Backer existing = null;
            foreach (var b in entry.Backers)
            {
                if (b.UserId == player.UserIDString) { existing = b; break; }
            }
            if (existing == null)
            {
                entry.Backers.Add(new Backer { UserId = player.UserIDString, Amount = taken, Name = player.displayName });
            }
            else
            {
                existing.Amount += taken;
            }

            SaveBounties();

            SendReply(player, Msg("Placed", player.UserIDString, taken, target.displayName, entry.Total()));
            if (config.BroadcastNewBounties)
            {
                Server.Broadcast(Msg("Broadcast", null, target.displayName, entry.Total()));
            }
        }

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

            if (bounties.Count == 0)
            {
                SendReply(player, Msg("ListEmpty", player.UserIDString));
                return;
            }

            SendReply(player, Msg("ListHeader", player.UserIDString, bounties.Count));
            foreach (var kvp in bounties)
            {
                SendReply(player, Msg("ListItem", player.UserIDString, kvp.Value.Name, kvp.Value.Total()));
            }
        }

        [ConsoleCommand("bountysystem.cancel")]
        private void CcmdCancel(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player != null && !player.IsAdmin)
            {
                arg.ReplyWith("Only admins can cancel bounties.");
                return;
            }

            string id = arg.GetString(0, "");
            if (string.IsNullOrEmpty(id))
            {
                arg.ReplyWith(Msg("CancelUsage"));
                return;
            }

            BountyEntry entry;
            if (!bounties.TryGetValue(id, out entry))
            {
                arg.ReplyWith("No bounty on that ID.");
                return;
            }

            foreach (var b in entry.Backers)
            {
                var backer = BasePlayer.FindByID(Convert.ToUInt64(b.UserId));
                if (backer == null || !backer.IsConnected)
                {
                    PrintWarning("Could not refund {0} ({1} scrap) - offline.", b.Name, b.Amount);
                    continue;
                }
                var item = ItemManager.CreateByItemID(ScrapId, b.Amount);
                if (item != null) backer.GiveItem(item);
            }

            bounties.Remove(id);
            SaveBounties();
            arg.ReplyWith(Msg("Cancelled", null, entry.Name));
        }

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

            BountyEntry entry;
            if (!bounties.TryGetValue(victim.UserIDString, out entry)) return;

            if (config.BlockSameTeam && killer.currentTeam != 0 && killer.currentTeam == victim.currentTeam)
            {
                return;
            }

            int total = entry.Total();
            if (total <= 0)
            {
                bounties.Remove(victim.UserIDString);
                SaveBounties();
                return;
            }

            var item = ItemManager.CreateByItemID(ScrapId, total);
            if (item != null)
            {
                killer.GiveItem(item);
            }

            bounties.Remove(victim.UserIDString);
            SaveBounties();

            SendReply(killer, Msg("Claimed", killer.UserIDString, total, victim.displayName));
            if (victim.IsConnected)
            {
                SendReply(victim, Msg("Victim", victim.UserIDString, killer.displayName, total));
            }
        }
    }
}