How to make a Rust corpse loot protection plugin (solo and team lock)

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

namespace Oxide.Plugins
{
    [Info("Corpse Loot Protection", "RustPluginGenerator", "1.0.0")]
    [Description("Locks player corpses and dropped backpacks to the owner and their team for a configurable time.")]
    public class CorpseLootProtection : RustPlugin
    {
        private const string PermAdmin = "corpselootprotection.admin";
        private const string PermUse = "corpselootprotection.use";

        private class LockEntry
        {
            public ulong OwnerId;
            public ulong TeamId;
            public int ExpiresAt;
        }

        private class PluginConfig
        {
            [JsonProperty("Lock duration in seconds")]
            public int LockSeconds = 300;

            [JsonProperty("Share lock with owner's team")]
            public bool TeamShared = true;

            [JsonProperty("Lock player corpses")]
            public bool LockPlayerCorpses = true;

            [JsonProperty("Lock dropped backpacks")]
            public bool LockDroppedBackpacks = true;

            [JsonProperty("Show remaining time in refusal message")]
            public bool ShowRemainingTime = true;

            [JsonProperty("Refusal message cooldown in seconds")]
            public float MessageCooldown = 5f;
        }

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

        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>
            {
                ["Locked"] = "This container is locked to another player for {0} more seconds.",
                ["LockedShort"] = "This container is locked to another player.",
                ["NotYours"] = "This is not your container.",
                ["Status"] = "This container is locked to its owner for {0} more seconds.",
                ["NoLock"] = "This container is not locked.",
                ["UnlockedAll"] = "All corpse locks were cleared ({0} entries removed).",
                ["NoPermission"] = "You do not have permission to use this command."
            }, this);
        }

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

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

        private void OnServerInitialized()
        {
            LoadLocks();
            cleanupTimer = timer.Every(30f, Cleanup);
        }

        private void Unload()
        {
            cleanupTimer?.Destroy();
            SaveLocks();
        }

        private void LoadLocks()
        {
            try
            {
                var stored = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<ulong, LockEntry>>(Name);
                if (stored == null) return;
                var now = Facepunch.Math.Epoch.Current;
                foreach (var pair in stored)
                {
                    if (pair.Value == null || pair.Value.ExpiresAt <= now) continue;
                    if (!(BaseNetworkable.serverEntities.Find(new NetworkableId(pair.Key)) is BaseEntity)) continue;
                    locks[pair.Key] = pair.Value;
                }
            }
            catch (Exception ex)
            {
                PrintWarning("Could not load stored locks: " + ex.Message);
            }
        }

        private void SaveLocks()
        {
            Interface.Oxide.DataFileSystem.WriteObject(Name, locks);
        }

        private void OnEntitySpawned(BaseNetworkable entity)
        {
            if (entity == null || entity.IsDestroyed) return;

            var corpse = entity as LootableCorpse;
            if (corpse != null)
            {
                if (!config.LockPlayerCorpses) return;
                if (corpse.playerSteamID == 0) return;
                CreateLock(entity, corpse.playerSteamID);
                return;
            }

            var dropped = entity as DroppedItemContainer;
            if (dropped != null)
            {
                if (!config.LockDroppedBackpacks) return;
                if (dropped.playerSteamID == 0) return;
                CreateLock(entity, dropped.playerSteamID);
            }
        }

        private void CreateLock(BaseNetworkable entity, ulong ownerId)
        {
            if (config.LockSeconds <= 0) return;
            var id = entity.net.ID.Value;
            if (locks.ContainsKey(id)) return;

            ulong teamId = 0;
            var owner = BasePlayer.FindByID(ownerId);
            if (owner != null && owner.currentTeam != 0) teamId = owner.currentTeam;

            locks[id] = new LockEntry
            {
                OwnerId = ownerId,
                TeamId = teamId,
                ExpiresAt = Facepunch.Math.Epoch.Current + config.LockSeconds
            };
        }

        private void Cleanup()
        {
            if (locks.Count == 0) return;
            var now = Facepunch.Math.Epoch.Current;
            var remove = new List<ulong>();
            foreach (var pair in locks)
            {
                if (pair.Value == null || pair.Value.ExpiresAt <= now) remove.Add(pair.Key);
            }
            foreach (var id in remove) locks.Remove(id);
        }

        private object CanLootEntity(BasePlayer player, LootableCorpse corpse)
        {
            if (player == null || corpse == null) return null;
            return CheckAccess(player, corpse.net.ID.Value);
        }

        private object CanLootEntity(BasePlayer player, DroppedItemContainer container)
        {
            if (player == null || container == null) return null;
            return CheckAccess(player, container.net.ID.Value);
        }

        private object CanLootEntity(BasePlayer player, StorageContainer container)
        {
            if (player == null || container == null) return null;
            return CheckAccess(player, container.net.ID.Value);
        }

        private object CheckAccess(BasePlayer player, ulong entityId)
        {
            LockEntry entry;
            if (!locks.TryGetValue(entityId, out entry) || entry == null) return null;
            if (entry.ExpiresAt <= Facepunch.Math.Epoch.Current)
            {
                locks.Remove(entityId);
                return null;
            }

            if (permission.UserHasPermission(player.UserIDString, PermAdmin)) return null;
            if (player.userID.Get() == entry.OwnerId) return null;
            if (config.TeamShared && entry.TeamId != 0 && player.currentTeam == entry.TeamId) return null;

            NotifyLocked(player, entry);
            return false;
        }

        private void NotifyLocked(BasePlayer player, LockEntry entry)
        {
            float now = UnityEngine.Time.realtimeSinceStartup;
            float last;
            if (lastMessage.TryGetValue(player.userID.Get(), out last) && now - last < config.MessageCooldown) return;
            lastMessage[player.userID.Get()] = now;

            int remaining = Mathf.Max(0, entry.ExpiresAt - Facepunch.Math.Epoch.Current);
            if (config.ShowRemainingTime)
                player.ChatMessage(Msg("Locked", player.UserIDString, remaining));
            else
                player.ChatMessage(Msg("LockedShort", player.UserIDString));
        }

        [ChatCommand("corpselock")]
        private void CmdCorpseLock(BasePlayer player, string command, string[] args)
        {
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }

            BaseEntity found = FindLookingAt(player);
            if (found == null)
            {
                player.ChatMessage(Msg("NotYours", player.UserIDString));
                return;
            }

            LockEntry entry;
            if (!locks.TryGetValue(found.net.ID.Value, out entry) || entry == null || entry.ExpiresAt <= Facepunch.Math.Epoch.Current)
            {
                player.ChatMessage(Msg("NoLock", player.UserIDString));
                return;
            }

            if (player.userID.Get() != entry.OwnerId &&
                !(config.TeamShared && entry.TeamId != 0 && player.currentTeam == entry.TeamId) &&
                !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                player.ChatMessage(Msg("NotYours", player.UserIDString));
                return;
            }

            int remaining = Mathf.Max(0, entry.ExpiresAt - Facepunch.Math.Epoch.Current);
            player.ChatMessage(Msg("Status", player.UserIDString, remaining));
        }

        private BaseEntity FindLookingAt(BasePlayer player)
        {
            RaycastHit hit;
            if (!Physics.Raycast(player.eyes.HeadRay(), out hit, 5f, Physics.DefaultRaycastLayers, QueryTriggerInteraction.Ignore))
                return null;
            var entity = hit.GetEntity();
            if (entity is LootableCorpse || entity is DroppedItemContainer || entity is StorageContainer)
                return entity;
            return null;
        }

        [ConsoleCommand("corpselootprotection.unlock")]
        private void CcmdUnlockAll(ConsoleSystem.Arg arg)
        {
            var player = arg.Player();
            if (player != null && !permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                arg.ReplyWith(Msg("NoPermission", player.UserIDString));
                return;
            }

            int count = locks.Count;
            locks.Clear();
            SaveLocks();
            arg.ReplyWith(Msg("UnlockedAll", null, count));
        }
    }
}