How to make a Rust death penalty plugin (scrap transfer on PvP death)

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

namespace Oxide.Plugins
{
    [Info("Death Penalty", "RustPluginGenerator", "1.0.0")]
    [Description("Moves a percentage of the victim's carried scrap to the killer on PvP death.")]
    public class DeathPenalty : RustPlugin
    {
        private const string PermUse = "deathpenalty.use";

        private class PluginConfig
        {
            [JsonProperty("Percent of victim's scrap transferred")]
            public float PercentOfScrap { get; set; } = 0.15f;

            [JsonProperty("Minimum scrap moved per kill")]
            public int MinimumScrap { get; set; } = 10;

            [JsonProperty("Maximum scrap moved per kill")]
            public int MaximumScrap { get; set; } = 200;

            [JsonProperty("Ignore team kills")]
            public bool IgnoreTeamKills { get; set; } = true;

            [JsonProperty("Ignore NPC kills")]
            public bool IgnoreNpcKills { get; set; } = true;

            [JsonProperty("Notify victim and killer in chat")]
            public bool NotifyPlayers { get; set; } = true;
        }

        private PluginConfig config;
        private int scrapItemId;

        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>
            {
                ["PenaltyCharged"] = "You lost {0} scrap to {1}.",
                ["PenaltyReceived"] = "You received {0} scrap from {1}.",
                ["PenaltyDestroyed"] = "You lost {0} scrap.",
                ["CommandReply"] = "You carry {0} scrap. Death transfers {1}% between {2} and {3} scrap."
            }, 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()
        {
            var definition = ItemManager.FindItemDefinition("scrap");
            if (definition != null) scrapItemId = definition.itemid;
        }

        [ChatCommand("deathpenalty")]
        private void CmdDeathPenalty(BasePlayer player, string command, string[] args)
        {
            if (player == null || !permission.UserHasPermission(player.UserIDString, PermUse)) return;
            var amount = scrapItemId == 0 ? 0 : player.inventory.GetAmount(scrapItemId);
            player.ChatMessage(Msg("CommandReply", player.UserIDString, amount,
                Mathf.RoundToInt(config.PercentOfScrap * 100f), config.MinimumScrap, config.MaximumScrap));
        }

        private object OnPlayerDeath(BasePlayer player, HitInfo info)
        {
            if (player == null || info == null || scrapItemId == 0) return null;
            if (player.IsNpc) return null;

            var killer = info.InitiatorPlayer;
            var isSelfKill = killer != null && killer.userID == player.userID;
            var isNpcKill = killer == null || killer.IsNpc;
            var isTeamKill = killer != null && !isSelfKill && player.currentTeam != 0 && player.currentTeam == killer.currentTeam;

            if (isNpcKill)
            {
                if (config.IgnoreNpcKills) return null;
                ChargeWithoutPayout(player);
                return null;
            }

            if (isSelfKill) return null;

            if (isTeamKill)
            {
                if (config.IgnoreTeamKills) return null;
                ChargeWithoutPayout(player);
                return null;
            }

            var held = player.inventory.GetAmount(scrapItemId);
            if (held <= 0) return null;

            var amount = Mathf.RoundToInt(held * config.PercentOfScrap);
            amount = Mathf.Clamp(amount, config.MinimumScrap, config.MaximumScrap);
            if (amount <= 0) return null;
            if (amount > held) amount = held;

            var taken = player.inventory.Take(new List<Item>(), scrapItemId, amount);
            if (taken <= 0) return null;

            var item = ItemManager.CreateByItemID(scrapItemId, taken);
            if (item == null)
            {
                player.inventory.GiveItem(ItemManager.CreateByItemID(scrapItemId, taken));
                return null;
            }

            killer.GiveItem(item);

            if (config.NotifyPlayers)
            {
                player.ChatMessage(Msg("PenaltyCharged", player.UserIDString, taken, killer.displayName));
                killer.ChatMessage(Msg("PenaltyReceived", killer.UserIDString, taken, player.displayName));
            }

            return null;
        }

        private void ChargeWithoutPayout(BasePlayer player)
        {
            var held = player.inventory.GetAmount(scrapItemId);
            if (held <= 0) return;

            var amount = Mathf.RoundToInt(held * config.PercentOfScrap);
            amount = Mathf.Clamp(amount, config.MinimumScrap, config.MaximumScrap);
            if (amount <= 0) return;
            if (amount > held) amount = held;

            var taken = player.inventory.Take(new List<Item>(), scrapItemId, amount);
            if (taken > 0 && config.NotifyPlayers)
                player.ChatMessage(Msg("PenaltyDestroyed", player.UserIDString, taken));
        }
    }
}