How to make a Rust sleeper protection plugin (timed spawn protection)

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

namespace Oxide.Plugins
{
    [Info("Sleeper Protection", "RustPluginGenerator", "1.0.0")]
    [Description("Gives sleeping players a timed protection window against damage and looting after they disconnect.")]
    public class SleeperProtection : RustPlugin
    {
        private const string PermAdmin = "sleeperprotection.admin";
        private const string DataFile = "SleeperProtection";

        private PluginConfig config;
        private Dictionary<string, int> protection = new Dictionary<string, int>();

        private class PluginConfig
        {
            [JsonProperty("Protection seconds")]
            public int ProtectionSeconds = 300;

            [JsonProperty("Block looting of protected sleepers")]
            public bool BlockLooting = true;

            [JsonProperty("Block explosion damage")]
            public bool BlockExplosions = true;

            [JsonProperty("Admins bypass loot block")]
            public bool AdminBypassLoot = 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>
            {
                ["Protected"] = "This sleeper is protected and cannot be looted right now.",
                ["Status"] = "{0} is protected for another {1} seconds.",
                ["StatusExpired"] = "{0} has no active protection.",
                ["Cleared"] = "Protection cleared for {0}.",
                ["NotFound"] = "No player found matching '{0}'.",
                ["Usage"] = "Usage: /sleepers <status|clear> <name or steamid>"
            }, 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(PermAdmin, this);
        }

        private void OnServerInitialized()
        {
            var loaded = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<string, int>>(DataFile);
            if (loaded != null) protection = loaded;

            int now = Facepunch.Math.Epoch.Current;
            var expired = new List<string>();
            foreach (var kvp in protection)
            {
                if (kvp.Value <= now) expired.Add(kvp.Key);
            }
            foreach (var id in expired) protection.Remove(id);
            SaveData();
        }

        private void Unload()
        {
            SaveData();
        }

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, protection);
        }

        private bool IsProtected(BasePlayer sleeper)
        {
            if (sleeper == null) return false;
            int expires;
            if (!protection.TryGetValue(sleeper.UserIDString, out expires)) return false;
            if (Facepunch.Math.Epoch.Current >= expires)
            {
                protection.Remove(sleeper.UserIDString);
                return false;
            }
            return true;
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player == null || player.IsNpc || !player.IsConnected) return;
            if (config.ProtectionSeconds <= 0) return;

            protection[player.UserIDString] = Facepunch.Math.Epoch.Current + config.ProtectionSeconds;
            SaveData();
        }

        private void OnPlayerSleepEnded(BasePlayer player)
        {
            if (player == null) return;
            if (protection.Remove(player.UserIDString)) SaveData();
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
        {
            if (entity == null || hitInfo == null) return null;

            var sleeper = entity as BasePlayer;
            if (sleeper == null) return null;
            if (!IsProtected(sleeper)) return null;

            if (hitInfo.Initiator == null) return null;
            if (hitInfo.Initiator == entity) return null;

            if (hitInfo.damageTypes != null && hitInfo.damageTypes.GetMajorityDamageType() == Rust.DamageType.Explosion && !config.BlockExplosions)
                return null;

            var attacker = hitInfo.InitiatorPlayer;
            if (attacker == null)
            {
                if (!(hitInfo.Initiator is BasePlayer)) return null;
                attacker = hitInfo.Initiator as BasePlayer;
            }

            if (attacker == null || attacker == sleeper) return null;

            return true;
        }

        private object CanLootPlayer(BasePlayer player, BasePlayer target)
        {
            if (player == null || target == null) return null;
            if (!config.BlockLooting) return null;
            if (!IsProtected(target)) return null;

            if (config.AdminBypassLoot && permission.UserHasPermission(player.UserIDString, PermAdmin))
                return null;

            player.ChatMessage(Msg("Protected", player.UserIDString));
            return false;
        }

        [ChatCommand("sleepers")]
        private void CmdSleepers(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermAdmin))
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            if (args == null || args.Length < 2)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            string sub = args[0].ToLowerInvariant();
            string query = string.Join(" ", args, 1, args.Length - 1);
            BasePlayer target = BasePlayer.FindAwakeOrSleeping(query);

            if (target == null)
            {
                player.ChatMessage(Msg("NotFound", player.UserIDString, query));
                return;
            }

            if (sub == "status")
            {
                int expires;
                if (!IsProtected(target))
                {
                    player.ChatMessage(Msg("StatusExpired", player.UserIDString, target.displayName));
                    return;
                }
                expires = protection[target.UserIDString];
                int remaining = expires - Facepunch.Math.Epoch.Current;
                player.ChatMessage(Msg("Status", player.UserIDString, target.displayName, remaining));
            }
            else if (sub == "clear")
            {
                protection.Remove(target.UserIDString);
                SaveData();
                player.ChatMessage(Msg("Cleared", player.UserIDString, target.displayName));
            }
            else
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
            }
        }
    }
}