How to make a Rust PvE server plugin (block PvP and foreign structure damage)

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

namespace Oxide.Plugins
{
    [Info("PveServer", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks player-vs-player damage and damage to entities owned by other players.")]
    public class PveServer : RustPlugin
    {
        private const string PermBypass = "pveserver.bypass";
        private const string PermUse = "pveserver.use";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Block PvP Damage")]
            public bool BlockPvpDamage { get; set; } = true;

            [JsonProperty("Protect Owned Entities")]
            public bool ProtectOwnedEntities { get; set; } = true;

            [JsonProperty("Allow Team Damage")]
            public bool AllowTeamDamage { get; set; } = false;

            [JsonProperty("Allow Building Auth")]
            public bool AllowBuildingAuth { get; set; } = 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>
            {
                ["Status"] = "PvE rules: PvP block {0}, owned entity protection {1}. You {2} bypass the rules.",
                ["Yes"] = "can",
                ["No"] = "cannot",
                ["Enabled"] = "enabled",
                ["Disabled"] = "disabled",
                ["NoPermission"] = "You do not have permission to use this command."
            }, 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(PermBypass, this);
            permission.RegisterPermission(PermUse, this);
        }

        private bool CanBypass(BasePlayer player) =>
            player != null && permission.UserHasPermission(player.UserIDString, PermBypass);

        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;
            if (attacker == entity) return null;
            if (CanBypass(attacker)) return null;

            if (entity is BasePlayer victim)
                return HandlePlayerDamage(attacker, victim, hitInfo);

            if (!config.ProtectOwnedEntities) return null;

            var owned = entity as BaseEntity;
            if (owned == null) return null;
            if (!IsProtectedEntity(owned)) return null;

            ulong ownerId = owned.OwnerID;
            if (ownerId == 0L) return null;
            if (ownerId == attacker.userID.Get()) return null;

            if (config.AllowBuildingAuth && IsAuthorisedOn(attacker, owned)) return null;

            if (attacker.currentTeam != 0 && IsTeammate(attacker, ownerId)) return null;

            NullifyDamage(hitInfo);
            return 0f;
        }

        private object HandlePlayerDamage(BasePlayer attacker, BasePlayer victim, HitInfo hitInfo)
        {
            if (!config.BlockPvpDamage) return null;
            if (victim.IsNpc) return null;

            if (!config.AllowTeamDamage && attacker.currentTeam != 0 && attacker.currentTeam == victim.currentTeam)
            {
                NullifyDamage(hitInfo);
                return 0f;
            }

            NullifyDamage(hitInfo);
            return 0f;
        }

        private bool IsTeammate(BasePlayer attacker, ulong ownerId)
        {
            var team = RelationshipManager.ServerInstance.FindTeam(attacker.currentTeam);
            return team != null && team.members.Contains(ownerId);
        }

        private bool IsAuthorisedOn(BasePlayer attacker, BaseEntity entity)
        {
            var priv = entity.GetBuildingPrivilege();
            return priv != null && priv.IsAuthed(attacker);
        }

        private bool IsProtectedEntity(BaseEntity entity)
        {
            if (entity is BasePlayer) return true;
            if (entity is LootableCorpse) return false;
            if (entity is DroppedItemContainer) return false;
            if (entity is SupplyDrop) return false;
            return true;
        }

        private void NullifyDamage(HitInfo hitInfo)
        {
            hitInfo.damageTypes?.ScaleAll(0f);
            hitInfo.damageTypes?.Scale(Rust.DamageType.Bullet, 0f);
            PropertyBlock();
        }

        private void PropertyBlock()
        {
        }

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

            string pvp = config.BlockPvpDamage ? Msg("Enabled", player.UserIDString) : Msg("Disabled", player.UserIDString);
            string owned = config.ProtectOwnedEntities ? Msg("Enabled", player.UserIDString) : Msg("Disabled", player.UserIDString);
            string bypass = CanBypass(player) ? Msg("Yes", player.UserIDString) : Msg("No", player.UserIDString);

            SendReply(player, Msg("Status", player.UserIDString, pvp, owned, bypass));
        }
    }
}