How to make a Rust admin teleport plugin (tp, tphere, tppos)

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

namespace Oxide.Plugins
{
    [Info("Admin Teleport", "RustPluginGenerator", "1.0.0")]
    [Description("Permission based /tp, /tphere and /tppos chat commands for admins.")]
    public class AdminTeleport : RustPlugin
    {
        private const string PermTp = "adminteleport.tp";
        private const string PermTpHere = "adminteleport.tphere";
        private const string PermTpPos = "adminteleport.tppos";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Teleport Delay Seconds")]
            public float TeleportDelay = 0f;

            [JsonProperty("Maximum Name Matches Shown")]
            public int MaxNameMatches = 5;
        }

        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>
            {
                ["NoPermission"] = "You do not have permission to use this command.",
                ["UsageTp"] = "Usage: /tp <player name>",
                ["UsageTpHere"] = "Usage: /tphere <player name>",
                ["UsageTpPos"] = "Usage: /tppos <x> <y> <z>",
                ["NoPlayer"] = "No player found matching '{0}'.",
                ["Ambiguous"] = "Multiple players match '{0}': {1}. Type more of the name.",
                ["TeleportedTo"] = "You teleported to {0}.",
                ["TeleportedHere"] = "{0} was teleported to you.",
                ["MovedByAdmin"] = "You were teleported by {0}.",
                ["TeleportedPos"] = "You teleported to {0} {1} {2}.",
                ["DelayWait"] = "Teleporting in {0} second(s)...",
                ["InvalidCoords"] = "Coordinates must be numbers."
            }, 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(PermTp, this);
            permission.RegisterPermission(PermTpHere, this);
            permission.RegisterPermission(PermTpPos, this);
        }

        private bool HasPerm(BasePlayer player, string perm)
        {
            if (player == null) return false;
            return player.IsAdmin || permission.UserHasPermission(player.UserIDString, perm);
        }

        private List<BasePlayer> FindPlayers(string query, BasePlayer caller)
        {
            var matches = new List<BasePlayer>();
            if (string.IsNullOrEmpty(query)) return matches;

            foreach (var p in BasePlayer.activePlayerList)
            {
                if (p == null || p.IsNpc || p == caller) continue;
                if (p.displayName != null && p.displayName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0)
                    matches.Add(p);
            }

            foreach (var p in BasePlayer.sleepingPlayerList)
            {
                if (p == null || p.IsNpc || p == caller) continue;
                if (matches.Contains(p)) continue;
                if (p.displayName != null && p.displayName.IndexOf(query, StringComparison.OrdinalIgnoreCase) >= 0)
                    matches.Add(p);
            }

            return matches;
        }

        private BasePlayer ResolveTarget(BasePlayer caller, string query)
        {
            var matches = FindPlayers(query, caller);
            if (matches.Count == 0)
            {
                caller.ChatMessage(Msg("NoPlayer", caller.UserIDString, query));
                return null;
            }
            if (matches.Count > 1)
            {
                int show = Mathf.Max(1, config.MaxNameMatches);
                var names = new List<string>();
                for (int i = 0; i < matches.Count && i < show; i++)
                    names.Add(matches[i].displayName);
                caller.ChatMessage(Msg("Ambiguous", caller.UserIDString, query, string.Join(", ", names.ToArray())));
                return null;
            }
            return matches[0];
        }

        private void DoTeleport(BasePlayer player, Vector3 pos, Action onDone)
        {
            if (config.TeleportDelay <= 0f)
            {
                player.Teleport(pos);
                onDone?.Invoke();
                return;
            }

            player.ChatMessage(Msg("DelayWait", player.UserIDString, config.TeleportDelay));
            timer.Once(config.TeleportDelay, () =>
            {
                if (player == null || !player.IsConnected) return;
                player.Teleport(pos);
                onDone?.Invoke();
            });
        }

        [ChatCommand("tp")]
        private void CmdTp(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!HasPerm(player, PermTp))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length < 1)
            {
                player.ChatMessage(Msg("UsageTp", player.UserIDString));
                return;
            }

            var target = ResolveTarget(player, string.Join(" ", args));
            if (target == null) return;

            var dest = target.transform.position;
            DoTeleport(player, dest, () => player.ChatMessage(Msg("TeleportedTo", player.UserIDString, target.displayName)));
        }

        [ChatCommand("tphere")]
        private void CmdTpHere(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!HasPerm(player, PermTpHere))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length < 1)
            {
                player.ChatMessage(Msg("UsageTpHere", player.UserIDString));
                return;
            }

            var target = ResolveTarget(player, string.Join(" ", args));
            if (target == null) return;

            var dest = player.transform.position;
            DoTeleport(target, dest, () =>
            {
                player.ChatMessage(Msg("TeleportedHere", player.UserIDString, target.displayName));
                target.ChatMessage(Msg("MovedByAdmin", target.UserIDString, player.displayName));
            });
        }

        [ChatCommand("tppos")]
        private void CmdTpPos(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!HasPerm(player, PermTpPos))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length < 3)
            {
                player.ChatMessage(Msg("UsageTpPos", player.UserIDString));
                return;
            }

            float x, y, z;
            if (!float.TryParse(args[0], NumberStyles.Float, CultureInfo.InvariantCulture, out x)
                || !float.TryParse(args[1], NumberStyles.Float, CultureInfo.InvariantCulture, out y)
                || !float.TryParse(args[2], NumberStyles.Float, CultureInfo.InvariantCulture, out z))
            {
                player.ChatMessage(Msg("InvalidCoords", player.UserIDString));
                return;
            }

            var terrainY = TerrainMeta.HeightMap != null ? TerrainMeta.HeightMap.GetHeight(new Vector3(x, 0f, z)) : y;
            if (y < terrainY) y = terrainY + 0.5f;

            var dest = new Vector3(x, y, z);
            DoTeleport(player, dest, () => player.ChatMessage(Msg("TeleportedPos", player.UserIDString, x.ToString("0"), y.ToString("0"), z.ToString("0"))));
        }
    }
}