How to make a Rust friendly fire plugin (team damage blocker)

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

namespace Oxide.Plugins
{
    [Info("No Friendly Fire", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks damage between members of the same team, with a per-team toggle.")]
    public class NoFriendlyFire : RustPlugin
    {
        private const string PermUse = "nofriendlyfire.use";
        private const string PermBypass = "nofriendlyfire.bypass";
        private const string DataFile = "NoFriendlyFire";

        private class PluginConfig
        {
            [JsonProperty("Allow damage with nofriendlyfire.use permission")]
            public bool AllowDamageWithPermission = true;

            [JsonProperty("Allow team leader toggle")]
            public bool AllowTeamLeaderToggle = true;

            [JsonProperty("Default state for teams that never toggled (true = friendly fire on)")]
            public bool DefaultState = false;

            [JsonProperty("Show chat message to victim when hit is blocked")]
            public bool ShowBlockMessage = true;

            [JsonProperty("Block message cooldown per victim (seconds)")]
            public float BlockMessageCooldown = 8f;
        }

        private PluginConfig config;
        private Dictionary<ulong, bool> teamStates = new Dictionary<ulong, bool>();
        private readonly Dictionary<ulong, float> messageCooldowns = new Dictionary<ulong, float>();

        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>
            {
                ["Blocked"] = "Friendly fire is disabled: {0} cannot damage you.",
                ["NoTeam"] = "You are not in a team.",
                ["NotLeader"] = "Only the team leader can change friendly fire.",
                ["NoPermission"] = "You do not have permission to use this command.",
                ["ToggleOn"] = "Friendly fire is now ENABLED for your team.",
                ["ToggleOff"] = "Friendly fire is now DISABLED for your team.",
                ["Current"] = "Friendly fire is currently {0} for your team.",
                ["On"] = "enabled",
                ["Off"] = "disabled",
                ["Usage"] = "Usage: /ff on|off"
            }, 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 Loaded()
        {
            teamStates = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<ulong, bool>>(DataFile)
                         ?? new Dictionary<ulong, bool>();
        }

        private void Unload()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, teamStates);
            messageCooldowns.Clear();
        }

        private void SaveStates() => Interface.Oxide.DataFileSystem.WriteObject(DataFile, teamStates);

        private bool IsProtected(ulong teamId)
        {
            bool enabled;
            return teamStates.TryGetValue(teamId, out enabled) ? !enabled : !config.DefaultState;
        }

        private object OnEntityTakeDamage(BasePlayer player, HitInfo hitInfo)
        {
            if (player == null || hitInfo == null || player.IsNpc) return null;

            BasePlayer attacker = hitInfo.InitiatorPlayer != null ? hitInfo.InitiatorPlayer : hitInfo.Initiator as BasePlayer;
            if (attacker == null || attacker.IsNpc) return null;
            if (player.userID == attacker.userID) return null;

            ulong victimTeam = player.currentTeam;
            if (victimTeam == 0 || attacker.currentTeam != victimTeam) return null;

            string attackerId = attacker.UserIDString;
            string victimId = player.UserIDString;

            if (permission.UserHasPermission(attackerId, PermBypass) || permission.UserHasPermission(victimId, PermBypass)) return null;
            if (config.AllowDamageWithPermission &&
                (permission.UserHasPermission(attackerId, PermUse) || permission.UserHasPermission(victimId, PermUse))) return null;

            if (!IsProtected(victimTeam)) return null;

            if (config.ShowBlockMessage && attacker != player)
            {
                float now = Time.realtimeSinceStartup;
                float last;
                if (!messageCooldowns.TryGetValue(player.userID, out last) || now - last >= config.BlockMessageCooldown)
                {
                    messageCooldowns[player.userID] = now;
                    player.ChatMessage(Msg("Blocked", victimId, attacker.displayName));
                }
            }

            return true;
        }

        private void OnPlayerDisconnected(BasePlayer player, string reason)
        {
            if (player != null) messageCooldowns.Remove(player.userID);
        }

        [ChatCommand("ff")]
        private void CmdFriendlyFire(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            string userId = player.UserIDString;

            if (!permission.UserHasPermission(userId, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", userId));
                return;
            }
            if (!config.AllowTeamLeaderToggle)
            {
                player.ChatMessage(Msg("NoPermission", userId));
                return;
            }

            ulong teamId = player.currentTeam;
            if (teamId == 0)
            {
                player.ChatMessage(Msg("NoTeam", userId));
                return;
            }

            var team = RelationshipManager.ServerInstance.FindTeam(teamId);
            if (team == null || team.teamLeader != player.userID)
            {
                player.ChatMessage(Msg("NotLeader", userId));
                return;
            }

            bool friendlyFireOn = !IsProtected(teamId);

            if (args == null || args.Length == 0)
            {
                player.ChatMessage(Msg("Current", userId, Msg(friendlyFireOn ? "On" : "Off", userId)));
                return;
            }

            string state = args[0].ToLowerInvariant();
            if (state != "on" && state != "off")
            {
                player.ChatMessage(Msg("Usage", userId));
                return;
            }

            bool enable = state == "on";
            teamStates[teamId] = enable;
            SaveStates();

            foreach (ulong memberId in team.members)
            {
                BasePlayer member = BasePlayer.FindByID(memberId);
                if (member == null || !member.IsConnected) continue;
                member.ChatMessage(Msg(enable ? "ToggleOn" : "ToggleOff", member.UserIDString));
            }
        }
    }
}