How to make a Rust PvE traps plugin (traps ignore players)

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

namespace Oxide.Plugins
{
    [Info("PveTraps", "RustPluginGenerator", "1.0.0")]
    [Description("Stops auto turrets, flame turrets, shotgun traps and landmines from damaging players.")]
    public class PveTraps : RustPlugin
    {
        private const string PermAdmin = "pvetraps.admin";

        private PluginConfig config;
        private readonly HashSet<string> trapPrefabs = new HashSet<string>(StringComparer.OrdinalIgnoreCase);

        private class PluginConfig
        {
            [JsonProperty("Player Proof Trap Prefabs")]
            public string[] TrapPrefabs =
            {
                "flameturret",
                "guntrap",
                "shotgun_trap",
                "trap.fireball"
            };

            [JsonProperty("Landmine Prefab")]
            public string LandminePrefab = "trap.landmine";

            [JsonProperty("Protect From Landmines")]
            public bool ProtectFromLandmines = true;

            [JsonProperty("Protect From Turret Targeting")]
            public bool ProtectFromTurretTargeting = true;

            [JsonProperty("Protect From Flame Turrets")]
            public bool ProtectFromFlameTurrets = 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();
            RebuildTrapSet();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["Status"] = "PvE traps: landmines {0}, turret targeting {1}, flame turrets {2}, {3} trap prefabs configured.",
                ["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(PermAdmin, this);
            LoadDefaultMessages();
            RebuildTrapSet();
        }

        private void RebuildTrapSet()
        {
            trapPrefabs.Clear();
            if (config?.TrapPrefabs == null) return;
            foreach (var prefab in config.TrapPrefabs)
            {
                if (string.IsNullOrEmpty(prefab)) continue;
                trapPrefabs.Add(NormalizePrefab(prefab));
            }
        }

        private static string NormalizePrefab(string prefab)
        {
            if (string.IsNullOrEmpty(prefab)) return string.Empty;
            int slash = prefab.LastIndexOf('/');
            if (slash >= 0 && slash < prefab.Length - 1) prefab = prefab.Substring(slash + 1);
            return prefab.Trim();
        }

        private bool IsLandmine(string prefab)
        {
            if (string.IsNullOrEmpty(prefab)) return false;
            string configured = NormalizePrefab(config?.LandminePrefab ?? "trap.landmine");
            return prefab.Equals(configured, StringComparison.OrdinalIgnoreCase);
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo hitInfo)
        {
            if (entity == null || hitInfo == null) return null;
            if (!(entity is BasePlayer)) return null;
            if (hitInfo.Initiator == null) return null;

            var attacker = hitInfo.Initiator.ShortPrefabName;
            if (string.IsNullOrEmpty(attacker)) return null;

            if (config.ProtectFromLandmines && IsLandmine(attacker))
            {
                CancelDamage(hitInfo);
                return true;
            }

            if (!trapPrefabs.Contains(attacker)) return null;

            if (!config.ProtectFromFlameTurrets &&
                attacker.Equals("flameturret", StringComparison.OrdinalIgnoreCase))
                return null;

            CancelDamage(hitInfo);
            return true;
        }

        private static void CancelDamage(HitInfo hitInfo)
        {
            if (hitInfo.damageTypes != null) hitInfo.damageTypes.ScaleAll(0f);
            hitInfo.damageTypes = new Rust.DamageTypeList();
        }

        private object OnTurretTarget(AutoTurret autoTurret, BaseCombatEntity targ)
        {
            if (autoTurret == null || targ == null) return null;
            if (!config.ProtectFromTurretTargeting) return null;
            if (!(targ is BasePlayer)) return null;
            return false;
        }

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

            arg.ReplyWith(Msg("Status", player?.UserIDString,
                config.ProtectFromLandmines ? "on" : "off",
                config.ProtectFromTurretTargeting ? "on" : "off",
                config.ProtectFromFlameTurrets ? "on" : "off",
                trapPrefabs.Count));
        }
    }
}