OnRfBroadcasterAdd

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

namespace Oxide.Plugins
{
    [Info("RfBroadcasterLimit", "RustPluginGenerator", "1.0.0")]
    [Description("Caps active RF broadcasters per player and frequency and reports blocks in chat")]
    public class RfBroadcasterLimit : RustPlugin
    {
        private const string PermBypass = "rfbroadcasterlimit.bypass";

        private PluginConfig config;
        private readonly Dictionary<string, int> counts = new Dictionary<string, int>();

        private class PluginConfig
        {
            [JsonProperty("Max broadcasters per player per frequency")]
            public int MaxPerFrequency { get; set; } = 2;

            [JsonProperty("Message owner when a broadcaster is blocked")]
            public bool NotifyOwner { 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>
            {
                ["LimitReached"] = "You already have {0} RF broadcaster(s) on frequency {1}.",
                ["Blocked"] = "This RF broadcaster was not activated: frequency {0} is at its limit for you."
            }, 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 OnRfBroadcasterAdd(IRFObject obj, int frequency)
        {
            var entity = obj as BaseEntity;
            if (entity == null || entity.OwnerID == 0) return null;

            string userId = entity.OwnerID.ToString();
            if (permission.UserHasPermission(userId, PermBypass)) return null;

            string key = userId + ":" + frequency;
            int current;
            counts.TryGetValue(key, out current);

            if (current >= config.MaxPerFrequency)
            {
                if (config.NotifyOwner)
                {
                    var player = BasePlayer.FindByID(entity.OwnerID);
                    if (player != null && player.IsConnected)
                    {
                        player.ChatMessage(Msg("Blocked", userId, frequency));
                    }
                }
                return false;
            }

            counts[key] = current + 1;
            return null;
        }

        private void OnRfBroadcasterRemove(IRFObject obj, int frequency)
        {
            var entity = obj as BaseEntity;
            if (entity == null || entity.OwnerID == 0) return;

            string key = entity.OwnerID + ":" + frequency;
            int current;
            if (!counts.TryGetValue(key, out current)) return;

            if (current <= 1) counts.Remove(key);
            else counts[key] = current - 1;
        }

        private void Unload()
        {
            counts.Clear();
        }
    }
}