OnRfListenerRemove

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

namespace Oxide.Plugins
{
    [Info("Rf Channel Guard", "RustPluginGenerator", "1.0.0")]
    [Description("Blocks RF listeners from being removed from protected frequencies unless the player has bypass permission.")]
    public class RfChannelGuard : RustPlugin
    {
        private const string PermBypass = "rfchannelguard.bypass";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Protected frequencies")]
            public List<int> ProtectedFrequencies = new List<int> { 101, 202 };

            [JsonProperty("Notify blocked players in chat")]
            public bool NotifyPlayers = 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>
            {
                ["Blocked"] = "Frequency {0} is protected. A receiver can not be detached from it."
            }, 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);
        }

        private object OnRfListenerRemove(IRFObject rfObject, int frequency)
        {
            if (rfObject == null || config.ProtectedFrequencies == null) return null;
            if (!config.ProtectedFrequencies.Contains(frequency)) return null;

            var entity = rfObject as BaseEntity;
            if (entity == null) return null;

            var ownerId = entity.OwnerID;
            // Server-owned listeners (OwnerID 0) are always protected.
            if (ownerId != 0)
            {
                var ownerIdString = ownerId.ToString();
                if (permission.UserHasPermission(ownerIdString, PermBypass)) return null;

                if (config.NotifyPlayers)
                {
                    var player = BasePlayer.FindByID(ownerId);
                    if (player != null && player.IsConnected)
                    {
                        player.ChatMessage(Msg("Blocked", ownerIdString, frequency));
                    }
                }
            }

            return false;
        }
    }
}