OnRfListenerAdded

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

namespace Oxide.Plugins
{
    [Info("Rf Channel Monitor", "RustPluginGenerator", "1.0.0")]
    [Description("Warns players when an RF listener registers on a restricted channel near their tracked position")]
    public class RfChannelMonitor : RustPlugin
    {
        private const string PermBypass = "rfchannelmonitor.bypass";

        private PluginConfig config;
        private StoredData data;

        private class PluginConfig
        {
            [JsonProperty("Restricted frequencies")]
            public List<int> RestrictedFrequencies = new List<int> { 4242, 7777 };

            [JsonProperty("Alert radius (meters)")]
            public float AlertRadius = 50f;

            [JsonProperty("Tracked position lifetime (seconds)")]
            public int TrackLifetime = 120;
        }

        private class StoredData
        {
            [JsonProperty("Tracked players")]
            public Dictionary<ulong, TrackedPlayer> Tracked = new Dictionary<ulong, TrackedPlayer>();
        }

        private class TrackedPlayer
        {
            [JsonProperty("Position")]
            public Vector3 Position;

            [JsonProperty("Timestamp")]
            public int Timestamp;
        }

        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>
            {
                ["Alert"] = "RF listener detected on restricted channel {0} at {1}. A device near you is listening.",
                ["Owner"] = "Your device now listens on restricted channel {0}."
            }, 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);
            data = Interface.Oxide.DataFileSystem.ReadObject<StoredData>(Name) ?? new StoredData();
        }

        private void Unload()
        {
            Interface.Oxide.DataFileSystem.WriteObject(Name, data);
        }

        private void OnPlayerSleepEnded(BasePlayer player)
        {
            if (player == null || player.IsNpc) return;
            data.Tracked[player.userID] = new TrackedPlayer
            {
                Position = player.transform.position,
                Timestamp = Facepunch.Math.Epoch.Current
            };
        }

        private void OnRfListenerAdded(IRFObject obj, int frequency)
        {
            if (config == null || !config.RestrictedFrequencies.Contains(frequency)) return;

            var entity = obj as BaseEntity;
            if (entity == null || entity.IsDestroyed) return;

            var owner = BasePlayer.FindByID(entity.OwnerID);
            if (owner != null && owner.IsConnected && !permission.UserHasPermission(owner.UserIDString, PermBypass))
            {
                owner.ChatMessage(Msg("Owner", owner.UserIDString, frequency));
                return;
            }

            Vector3 position = entity.transform.position;
            int now = Facepunch.Math.Epoch.Current;
            var stale = new List<ulong>();

            foreach (var pair in data.Tracked)
            {
                if (now - pair.Value.Timestamp > config.TrackLifetime)
                {
                    stale.Add(pair.Key);
                    continue;
                }

                if (Vector3.Distance(pair.Value.Position, position) > config.AlertRadius) continue;

                var player = BasePlayer.FindByID(pair.Key);
                if (player == null || !player.IsConnected) continue;
                if (permission.UserHasPermission(player.UserIDString, PermBypass)) continue;

                player.ChatMessage(Msg("Alert", player.UserIDString, frequency,
                    position.ToString("F0")));
            }

            foreach (var id in stale) data.Tracked.Remove(id);
        }
    }
}