How to make a Rust NPC loot lock plugin (owner + team only)

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

namespace Oxide.Plugins
{
    [Info("NpcLootLock", "RustPluginGenerator", "1.0.0")]
    [Description("Locks NPC corpses to the killer and their team for a configurable duration.")]
    public class NpcLootLock : RustPlugin
    {
        private const string PermUse = "npclootlock.use";
        private const string PermBypass = "npclootlock.bypass";

        private PluginConfig config;
        private Timer cleanupTimer;
        private readonly Dictionary<ulong, LockEntry> locks = new Dictionary<ulong, LockEntry>();

        private class LockEntry
        {
            public ulong KillerId;
            public ulong TeamId;
            public DateTime KillTime;
        }

        private class PluginConfig
        {
            [JsonProperty("Lock Seconds")]
            public int LockSeconds = 60;

            [JsonProperty("Locked NPC Types")]
            public List<string> LockedNpcTypes = new List<string>
            {
                "scientistnpc",
                "scientistnpc_heavy",
                "scientistnpc_arcade",
                "scientistnpc_vehicle",
                "bear",
                "polarbear",
                "wolf",
                "boar",
                "stag",
                "chicken",
                "bradleyapc",
                "patrolhelicopter"
            };

            [JsonProperty("Cleanup Interval Seconds")]
            public int CleanupIntervalSeconds = 30;
        }

        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>
            {
                ["loot_blocked"] = "This corpse is locked. Unlocks in {0}s.",
                ["info_locked"] = "Locked for {0} more seconds.",
                ["info_unlocked"] = "This corpse is not locked.",
                ["no_corpse"] = "Look at a locked corpse to see its lock timer."
            }, 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(PermBypass, this);
        }

        private void OnServerInitialized()
        {
            if (config.LockSeconds <= 0) return;
            cleanupTimer = timer.Every(Mathf.Max(5, config.CleanupIntervalSeconds), CleanupExpired);
        }

        private void Unload()
        {
            cleanupTimer?.Destroy();
            cleanupTimer = null;
            locks.Clear();
        }

        private void OnEntityDeath(BaseCombatEntity entity, HitInfo info)
        {
            if (entity == null || info == null) return;
            if (config.LockSeconds <= 0) return;

            if (!IsLockableNpc(entity)) return;

            var killer = info.InitiatorPlayer;
            if (killer == null || killer.IsNpc || killer.IsDead()) return;

            // The lootable corpse is created shortly after death; map it via the death position.
            var container = entity as LootableCorpse;
            BaseEntity lootTarget = container;

            if (lootTarget == null)
            {
                var netId = entity.net?.ID.Value ?? 0;
                if (netId == 0) return;

                NextTick(() =>
                {
                    // Try to find the spawned corpse owned by this entity near its death position.
                    var center = entity.transform.position;
                    LootableCorpse found = null;
                    foreach (var b in BaseNetworkable.serverEntities)
                    {
                        var c = b as LootableCorpse;
                        if (c == null) continue;
                        if (Vector3.Distance(c.transform.position, center) > 2f) continue;
                        found = c;
                        break;
                    }
                    if (found == null) return;

                    var corpseId = found.net.ID.Value;
                    locks[corpseId] = new LockEntry
                    {
                        KillerId = killer.userID.Get(),
                        TeamId = killer.currentTeam,
                        KillTime = DateTime.UtcNow
                    };
                });
                return;
            }

            var targetId = lootTarget.net.ID.Value;
            locks[targetId] = new LockEntry
            {
                KillerId = killer.userID.Get(),
                TeamId = killer.currentTeam,
                KillTime = DateTime.UtcNow
            };
        }

        private object CanLootEntity(BasePlayer player, StorageContainer storageContainer)
        {
            if (player == null || storageContainer == null) return null;
            if (config.LockSeconds <= 0) return null;

            var netId = storageContainer.net?.ID.Value ?? 0;
            if (netId == 0) return null;

            LockEntry entry;
            if (!locks.TryGetValue(netId, out entry)) return null;

            var remaining = config.LockSeconds - (DateTime.UtcNow - entry.KillTime).TotalSeconds;
            if (remaining <= 0)
            {
                locks.Remove(netId);
                return null;
            }

            if (permission.UserHasPermission(player.UserIDString, PermBypass)) return null;

            var playerId = player.userID.Get();
            if (playerId == entry.KillerId) return null;
            if (entry.TeamId != 0 && player.currentTeam == entry.TeamId) return null;

            player.ChatMessage(Msg("loot_blocked", player.UserIDString, Mathf.CeilToInt((float)remaining)));
            return true;
        }

        private void OnEntityKill(BaseNetworkable networkable)
        {
            if (networkable == null) return;
            var netId = networkable.net?.ID.Value ?? 0;
            if (netId == 0) return;
            locks.Remove(netId);
        }

        [ChatCommand("npclock")]
        private void CmdNpcLock(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage("You do not have permission to use this command.");
                return;
            }

            var ray = new Ray(player.eyes.position, player.eyes.HeadForward());
            RaycastHit hit;
            if (!Physics.Raycast(ray, out hit, 5f))
            {
                player.ChatMessage(Msg("no_corpse", player.UserIDString));
                return;
            }

            var lootable = hit.GetEntity() as LootableCorpse;
            if (lootable == null)
            {
                player.ChatMessage(Msg("no_corpse", player.UserIDString));
                return;
            }

            LockEntry entry;
            if (!locks.TryGetValue(lootable.net.ID.Value, out entry))
            {
                player.ChatMessage(Msg("info_unlocked", player.UserIDString));
                return;
            }

            var remaining = config.LockSeconds - (DateTime.UtcNow - entry.KillTime).TotalSeconds;
            if (remaining <= 0)
            {
                player.ChatMessage(Msg("info_unlocked", player.UserIDString));
                locks.Remove(lootable.net.ID.Value);
                return;
            }

            player.ChatMessage(Msg("info_locked", player.UserIDString, Mathf.CeilToInt((float)remaining)));
        }

        private void CleanupExpired()
        {
            if (locks.Count == 0) return;
            var cutoff = DateTime.UtcNow.AddSeconds(-config.LockSeconds * 2);
            var stale = new List<ulong>();
            foreach (var kvp in locks)
            {
                if (kvp.Value.KillTime < cutoff) stale.Add(kvp.Key);
            }
            foreach (var id in stale) locks.Remove(id);
        }

        private bool IsLockableNpc(BaseCombatEntity entity)
        {
            if (entity == null) return false;
            if (entity is LootableCorpse) return false;
            if (!(entity is ScientistNPC) && !(entity is BaseAnimalNPC) &&
                !(entity is BradleyAPC) && !(entity is BaseHelicopter)) return false;

            var shortName = entity.ShortPrefabName ?? "";
            if (shortName.EndsWith(".prefab")) shortName = shortName.Substring(0, shortName.Length - 7);
            if (config.LockedNpcTypes.Count == 0) return true;
            return config.LockedNpcTypes.Exists(t => shortName.StartsWith(t, StringComparison.OrdinalIgnoreCase));
        }
    }
}