How to make a Rust admin radar plugin (proximity player list)

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

namespace Oxide.Plugins
{
    [Info("Admin Radar", "RustPluginGenerator", "1.0.0")]
    [Description("Lists nearby players for admins and draws their names in world for a few seconds.")]
    public class AdminRadar : RustPlugin
    {
        private const string PermUse = "adminradar.use";
        private const string OverlayKey = "adminradar.overlay";

        private PluginConfig config;
        private Timer overlayTimer;

        private class PluginConfig
        {
            [JsonProperty("Default Radius")]
            public float DefaultRadius = 100f;

            [JsonProperty("Maximum Radius")]
            public float MaximumRadius = 500f;

            [JsonProperty("Overlay Seconds")]
            public float OverlaySeconds = 8f;

            [JsonProperty("Label Font Size")]
            public int LabelFontSize = 14;

            [JsonProperty("Label Colour (RGBA)")]
            public string LabelColour = "1 0.85 0.2 1";
        }

        private class RadarEntry
        {
            public BasePlayer Player;
            public float Distance;
            public string Bearing;
            public bool Sleeping;
        }

        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>
            {
                ["No Permission"] = "You do not have permission to use the radar.",
                ["Usage"] = "Usage: /radar [radius]",
                ["Header"] = "Radar: {0} player(s) within {1}m",
                ["Line"] = "{0} - {1}m {2}{3}",
                ["Sleeping"] = " (sleeping)",
                ["None"] = "Radar: no players within {0}m"
            }, 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);
        }

        private void Unload()
        {
            if (overlayTimer != null)
            {
                overlayTimer.Destroy();
                overlayTimer = null;
            }

            foreach (var player in BasePlayer.activePlayerList)
            {
                if (player == null) continue;
                DDraw.Clear(player);
            }
        }

        [ChatCommand("radar")]
        private void CmdRadar(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("No Permission", player.UserIDString));
                return;
            }

            float radius = config.DefaultRadius;
            if (args != null && args.Length > 0 && !float.TryParse(args[0], out radius))
            {
                SendReply(player, Msg("Usage", player.UserIDString));
                return;
            }

            radius = Mathf.Clamp(radius, 1f, Mathf.Max(1f, config.MaximumRadius));

            var entries = Collect(player, radius);
            if (entries.Count == 0)
            {
                SendReply(player, Msg("None", player.UserIDString, Mathf.RoundToInt(radius)));
                return;
            }

            SendReply(player, Msg("Header", player.UserIDString, entries.Count, Mathf.RoundToInt(radius)));
            foreach (var entry in entries)
            {
                SendReply(player, Msg("Line", player.UserIDString,
                    entry.Player.displayName,
                    Mathf.RoundToInt(entry.Distance),
                    entry.Bearing,
                    entry.Sleeping ? Msg("Sleeping", player.UserIDString) : string.Empty));
            }

            ShowOverlay(player, entries);
        }

        private List<RadarEntry> Collect(BasePlayer admin, float radius)
        {
            var vector = admin.transform.position;
            var forward = admin.eyes.HeadForward();
            forward.y = 0f;
            if (forward.sqrMagnitude < 0.001f) forward = admin.transform.forward;
            forward.Normalize();
            var right = Vector3.Cross(Vector3.up, forward).normalized;

            var results = new List<RadarEntry>();

            foreach (var target in BasePlayer.activePlayerList) AddCandidate(results, admin, target, vector, forward, right, radius);
            foreach (var target in BasePlayer.sleepingPlayerList) AddCandidate(results, admin, target, vector, forward, right, radius);

            results.Sort((a, b) => a.Distance.CompareTo(b.Distance));
            return results;
        }

        private void AddCandidate(List<RadarEntry> results, BasePlayer admin, BasePlayer target, Vector3 origin, Vector3 forward, Vector3 right, float radius)
        {
            if (target == null || target == admin || target.IsNpc || target.userID == admin.userID) return;

            var distance = Vector3.Distance(target.transform.position, origin);
            if (distance > radius) return;

            var offset = target.transform.position - origin;
            offset.y = 0f;
            var degrees = Mathf.Atan2(Vector3.Dot(offset, right), Vector3.Dot(offset, forward)) * Mathf.Rad2Deg;

            results.Add(new RadarEntry
            {
                Player = target,
                Distance = distance,
                Bearing = Bearing(degrees),
                Sleeping = target.IsSleeping()
            });
        }

        private static string Bearing(float degrees)
        {
            if (degrees < 0f) degrees += 360f;

            if (degrees < 22.5f || degrees >= 337.5f) return "N";
            if (degrees < 67.5f) return "NE";
            if (degrees < 112.5f) return "E";
            if (degrees < 157.5f) return "SE";
            if (degrees < 202.5f) return "S";
            if (degrees < 247.5f) return "SW";
            if (degrees < 292.5f) return "W";
            return "NW";
        }

        // DDraw.Text on this Rust build takes (BasePlayer, Vector3, string text, Color color, int fontSize, bool ...)
        // so pass a UnityEngine.Color and omit the extra float parameter.
        private static Color ParseColour(string value)
        {
            if (string.IsNullOrEmpty(value)) return Color.yellow;
            var parts = value.Split(' ');
            if (parts.Length < 3) return Color.yellow;
            float r, g, b, a = 1f;
            if (!float.TryParse(parts[0], out r)) r = 1f;
            if (!float.TryParse(parts[1], out g)) g = 1f;
            if (!float.TryParse(parts[2], out b)) b = 0f;
            if (parts.Length > 3) float.TryParse(parts[3], out a);
            return new Color(r, g, b, a);
        }

        private void ShowOverlay(BasePlayer admin, List<RadarEntry> entries)
        {
            if (overlayTimer != null)
            {
                overlayTimer.Destroy();
                overlayTimer = null;
            }

            DDraw.Clear(admin);

            var colour = ParseColour(config.LabelColour);

            foreach (var entry in entries)
            {
                if (entry.Player == null || entry.Player.IsDestroyed) continue;
                var head = entry.Player.transform.position + new Vector3(0f, 2.1f, 0f);
                DDraw.Text(admin, head, entry.Player.displayName, colour, config.LabelFontSize, true);
            }

            overlayTimer = timer.Once(Mathf.Max(1f, config.OverlaySeconds), () =>
            {
                if (admin != null && admin.IsConnected) DDraw.Clear(admin);
                overlayTimer = null;
            });
        }
    }
}