How to make a Rust new player protection plugin (raid protection)

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

namespace Oxide.Plugins
{
    [Info("New Player Protection", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks damage to buildings owned by players under a playtime threshold this wipe.")]
    public class NewPlayerProtection : RustPlugin
    {
        private const string PermAdmin = "newplayerprotection.admin";

        private PluginConfig config;
        private ProtectionData data;
        private Timer tickTimer;
        private Timer saveTimer;
        private bool dirty;

        private class PluginConfig
        {
            [JsonProperty("Protection Hours")]
            public double ProtectionHours { get; set; } = 12.0;

            [JsonProperty("Protect Deployables")]
            public bool ProtectDeployables { get; set; } = true;

            [JsonProperty("Tick Seconds")]
            public float TickSeconds { get; set; } = 60f;

            [JsonProperty("Save Interval")]
            public float SaveInterval { get; set; } = 120f;

            [JsonProperty("Wipe Seed")]
            public string WipeSeed { get; set; } = string.Empty;

            [JsonProperty("Playtime Minutes")]
            public Dictionary<string, double> Playtime { get; set; } = new Dictionary<string, double>();

            [JsonProperty("Protection Broken")]
            public HashSet<string> Broken { get; set; } = new HashSet<string>();
        }

        private class ProtectionData
        {
            public string WipeSeed { get; set; } = string.Empty;
            public Dictionary<string, double> Playtime { get; set; } = new Dictionary<string, double>();
            public HashSet<string> Broken { get; set; } = new HashSet<string>();

            public ProtectionData() { }

            public ProtectionData(string wipeSeed, Dictionary<string, double> playtime, HashSet<string> broken)
            {
                WipeSeed = wipeSeed ?? string.Empty;
                Playtime = playtime ?? new Dictionary<string, double>();
                Broken = broken ?? new HashSet<string>();
            }
        }

        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>
            {
                ["Check"] = "{0} has {1} minutes tracked and is {2}.",
                ["Protected"] = "protected",
                ["Unprotected"] = "not protected",
                ["End"] = "Protection removed for {0}.",
                ["NotFound"] = "No player found with that name or ID.",
                ["Status"] = "{0} of {1} known players are currently protected. Threshold: {2} hours.",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["Usage"] = "Usage: /npp check <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()
        {
            LoadData();
            tickTimer = timer.Every(config.TickSeconds, TickPlaytime);
            saveTimer = timer.Every(config.SaveInterval, Flush);
        }

        private void Unload()
        {
            tickTimer?.Destroy();
            saveTimer?.Destroy();
            Flush();
        }

        private void LoadData()
        {
            try
            {
                data = Interface.Oxide.DataFileSystem.ReadObject<ProtectionData>(Name);
            }
            catch
            {
                data = null;
            }

            if (data == null)
            {
                data = new ProtectionData(config.WipeSeed, config.Playtime, config.Broken);
            }

            if (data.Playtime == null) data.Playtime = new Dictionary<string, double>();
            if (data.Broken == null) data.Broken = new HashSet<string>();
            config.WipeSeed = data.WipeSeed;
            config.Playtime = data.Playtime;
            config.Broken = data.Broken;
        }

        private void Flush()
        {
            if (!dirty || data == null) return;
            config.WipeSeed = data.WipeSeed;
            config.Playtime = data.Playtime;
            config.Broken = data.Broken;
            Interface.Oxide.DataFileSystem.WriteObject(Name, data);
            SaveConfig();
            dirty = false;
        }

        private void TickPlaytime()
        {
            double minutes = config.TickSeconds / 60.0;
            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null || player.IsNpc || !player.IsConnected || player.IsSleeping()) continue;
                string id = player.UserIDString;
                data.Playtime.TryGetValue(id, out double current);
                data.Playtime[id] = current + minutes;
            }
            dirty = true;
        }

        private void OnNewSave(string strFilename)
        {
            data = new ProtectionData { WipeSeed = strFilename ?? string.Empty };
            dirty = true;
            Flush();
        }

        private bool IsTracked(string userId) => data.Playtime.TryGetValue(userId, out double minutes) && minutes < config.ProtectionHours * 60.0;

        private bool IsProtected(BasePlayer player)
        {
            if (player == null || player.IsNpc) return false;
            string id = player.UserIDString;
            if (data.Broken.Contains(id)) return false;
            return IsTracked(id);
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
        {
            if (entity == null || hitInfo == null) return null;
            var attacker = hitInfo.InitiatorPlayer;
            if (attacker == null || attacker.IsNpc) return null;

            ulong ownerId = entity.OwnerID;
            if (ownerId == 0) return null;

            // Same player or teammate: no interference with self-damage or team repairs.
            if (ownerId == attacker.userID.Get()) return null;
            if (attacker.currentTeam != 0 && data.Playtime.ContainsKey(ownerId.ToString()))
            {
                var team = RelationshipManager.ServerInstance.FindTeam(attacker.currentTeam);
                if (team != null && team.members.Contains(ownerId)) return null;
            }

            var owner = BasePlayer.FindByID(ownerId);
            string ownerKey = ownerId.ToString();

            // If the victim is a protected builder, cancel the hit.
            if (IsShieldedEntity(entity) && !data.Broken.Contains(ownerKey) && IsTracked(ownerKey))
            {
                if (IsProtected(owner) || owner == null)
                {
                    hitInfo.damageTypes.ScaleAll(0f);
                    return true;
                }
            }

            // If the attacker is protected and hits someone else's structure, drop their shield.
            if (IsShieldedEntity(entity) && !data.Broken.Contains(attacker.UserIDString) && IsTracked(attacker.UserIDString))
            {
                if (owner != null && owner.UserIDString != attacker.UserIDString)
                {
                    data.Broken.Add(attacker.UserIDString);
                    dirty = true;
                }
            }

            return null;
        }

        private bool IsShieldedEntity(BaseCombatEntity entity)
        {
            if (entity is BuildingBlock) return true;
            if (!config.ProtectDeployables) return false;
            if (entity is Door) return true;
            if (entity is StorageContainer) return true;
            if (entity is CodeLock) return true;
            if (entity is BuildingPrivlidge) return true;
            return false;
        }

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

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

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

            string id = found.UserIDString;
            if (sub == "check")
            {
                data.Playtime.TryGetValue(id, out double minutes);
                bool protectedNow = !data.Broken.Contains(id) && minutes < config.ProtectionHours * 60.0;
                SendReply(player, Msg("Check", player.UserIDString, found.displayName, Math.Round(minutes, 1), Msg(protectedNow ? "Protected" : "Unprotected", player.UserIDString)));
            }
            else if (sub == "end")
            {
                data.Broken.Add(id);
                dirty = true;
                Flush();
                SendReply(player, Msg("End", player.UserIDString, found.displayName));
            }
            else
            {
                SendReply(player, Msg("Usage", player.UserIDString));
            }
        }

        [ConsoleCommand("npp.status")]
        private void CcmdStatus(ConsoleSystem.Arg arg)
        {
            if (arg == null) return;
            var caller = arg.Player();
            if (caller != null && !permission.UserHasPermission(caller.UserIDString, PermAdmin))
            {
                arg.ReplyWith(Msg("NoPermission", caller.UserIDString));
                return;
            }

            int protectedCount = 0;
            foreach (var kvp in data.Playtime)
            {
                if (!data.Broken.Contains(kvp.Key) && kvp.Value < config.ProtectionHours * 60.0) protectedCount++;
            }

            arg.ReplyWith(Msg("Status", caller?.UserIDString, protectedCount, data.Playtime.Count, config.ProtectionHours));
        }
    }
}