How to make a Rust team teleport plugin (/tpteam)

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

namespace Oxide.Plugins
{
    [Info("Team Teleport", "RustPluginGenerator", "1.0.0")]
    [Description("Teleports players to a teammate after a warmup, with cooldown and opt-out.")]
    public class TeamTeleport : RustPlugin
    {
        private const string PermUse = "teamteleport.use";
        private const string PermBypass = "teamteleport.bypass";

        private class PlayerSettings
        {
            [JsonProperty("Allow teammates to teleport to me")]
            public bool AllowTeleportTo = true;
        }

        private class PluginConfig
        {
            [JsonProperty("Warmup seconds")]
            public float WarmupSeconds = 10f;

            [JsonProperty("Cooldown seconds")]
            public float CooldownSeconds = 300f;

            [JsonProperty("Allow teammates to teleport to me")]
            public bool DefaultAllowTeleportTo = true;
        }

        private class PendingTeleport
        {
            public BasePlayer Player;
            public Timer Timer;
        }

        private PluginConfig config;
        private Dictionary<ulong, PlayerSettings> settings = new Dictionary<ulong, PlayerSettings>();
        private Dictionary<ulong, PendingTeleport> pending = new Dictionary<ulong, PendingTeleport>();
        private Dictionary<ulong, float> cooldowns = new Dictionary<ulong, float>();

        private const string DataFile = "TeamTeleport";

        private void Init()
        {
            permission.RegisterPermission(PermUse, this);
            permission.RegisterPermission(PermBypass, this);
        }

        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.",
                ["Usage"] = "Usage: /tpteam <name> or /tpteam off",
                ["PlayerNotFound"] = "No player found with that name.",
                ["Self"] = "You cannot teleport to yourself.",
                ["NotSameTeam"] = "That player is not on your team.",
                ["TargetOffline"] = "That teammate is not online.",
                ["TargetOptedOut"] = "That teammate has teleports disabled.",
                ["WarmupStarted"] = "Teleporting to {0} in {1} seconds. Do not move.",
                ["WarmupCancelled"] = "Teleport cancelled.",
                ["Cooldown"] = "You must wait {0} seconds before teleporting again.",
                ["OptOutOn"] = "Teammates can no longer teleport to you.",
                ["OptOutOff"] = "Teammates can teleport to you again."
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args) =>
            string.Format(lang.GetMessage(key, this, userId), args);

        private PlayerSettings GetSettings(ulong userId)
        {
            PlayerSettings s;
            if (!settings.TryGetValue(userId, out s))
            {
                s = new PlayerSettings { AllowTeleportTo = config.DefaultAllowTeleportTo };
                settings[userId] = s;
            }
            return s;
        }

        [ChatCommand("tpteam")]
        private void CmdTpTeam(BasePlayer player, string command, string[] args)
        {
            if (player == null || !player.IsConnected) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                player.ChatMessage(Msg("NoPermission", player.UserIDString));
                return;
            }
            if (args == null || args.Length == 0)
            {
                player.ChatMessage(Msg("Usage", player.UserIDString));
                return;
            }

            if (args[0].Equals("off", StringComparison.OrdinalIgnoreCase))
            {
                var s = GetSettings(player.userID.Get());
                s.AllowTeleportTo = !s.AllowTeleportTo;
                player.ChatMessage(Msg(s.AllowTeleportTo ? "OptOutOff" : "OptOutOn", player.UserIDString));
                return;
            }

            if (pending.ContainsKey(player.userID.Get()))
            {
                player.ChatMessage(Msg("WarmupCancelled", player.UserIDString));
                return;
            }

            var target = BasePlayer.FindAwakeOrSleeping(args[0]);
            if (target == null)
            {
                player.ChatMessage(Msg("PlayerNotFound", player.UserIDString));
                return;
            }
            if (target == player)
            {
                player.ChatMessage(Msg("Self", player.UserIDString));
                return;
            }
            if (!target.IsConnected)
            {
                player.ChatMessage(Msg("TargetOffline", player.UserIDString));
                return;
            }
            if (player.currentTeam == 0 || player.currentTeam != target.currentTeam)
            {
                player.ChatMessage(Msg("NotSameTeam", player.UserIDString));
                return;
            }
            if (!GetSettings(target.userID.Get()).AllowTeleportTo)
            {
                player.ChatMessage(Msg("TargetOptedOut", player.UserIDString));
                return;
            }

            if (!permission.UserHasPermission(player.UserIDString, PermBypass))
            {
                float last;
                if (cooldowns.TryGetValue(player.userID.Get(), out last))
                {
                    float remaining = config.CooldownSeconds - (Time.realtimeSinceStartup - last);
                    if (remaining > 0f)
                    {
                        player.ChatMessage(Msg("Cooldown", player.UserIDString, Mathf.CeilToInt(remaining)));
                        return;
                    }
                }
            }

            var entry = new PendingTeleport { Player = player };
            pending[player.userID.Get()] = entry;
            player.ChatMessage(Msg("WarmupStarted", player.UserIDString, target.displayName, Mathf.CeilToInt(config.WarmupSeconds)));

            entry.Timer = timer.Once(config.WarmupSeconds, () =>
            {
                if (entry.Player == null || !entry.Player.IsConnected || entry.Player.IsDead())
                {
                    pending.Remove(player.userID.Get());
                    return;
                }
                pending.Remove(player.userID.Get());
                entry.Player.Teleport(target.transform.position);
                cooldowns[player.userID.Get()] = Time.realtimeSinceStartup;
            });
        }

        private void OnPlayerInput(BasePlayer player, InputState input)
        {
            if (player == null || input == null) return;
            PendingTeleport entry;
            if (!pending.TryGetValue(player.userID.Get(), out entry)) return;
            if (input.WasJustPressed(BUTTON.FORWARD) || input.WasJustPressed(BUTTON.BACKWARD) ||
                input.WasJustPressed(BUTTON.LEFT) || input.WasJustPressed(BUTTON.RIGHT) ||
                input.WasJustPressed(BUTTON.JUMP))
            {
                CancelPending(player);
            }
        }

        private object OnEntityTakeDamage(BaseCombatEntity entity, HitInfo info)
        {
            if (entity == null || info == null) return null;
            var player = entity as BasePlayer;
            if (player == null) return null;
            if (pending.ContainsKey(player.userID.Get()))
            {
                CancelPending(player);
            }
            return null;
        }

        private void CancelPending(BasePlayer player)
        {
            PendingTeleport entry;
            if (pending.TryGetValue(player.userID.Get(), out entry))
            {
                if (entry.Timer != null) entry.Timer.Destroy();
                pending.Remove(player.userID.Get());
                player.ChatMessage(Msg("WarmupCancelled", player.UserIDString));
            }
        }

        private void OnServerSave()
        {
            SaveData();
        }

        private void SaveData()
        {
            Interface.Oxide.DataFileSystem.WriteObject(DataFile, settings);
        }

        private void OnServerInitialized()
        {
            try
            {
                var loaded = Interface.Oxide.DataFileSystem.ReadObject<Dictionary<ulong, PlayerSettings>>(DataFile);
                if (loaded != null) settings = loaded;
            }
            catch
            {
                PrintWarning("Could not read data file, starting fresh");
                settings = new Dictionary<ulong, PlayerSettings>();
            }
        }

        private void Unload()
        {
            foreach (var entry in pending.Values)
            {
                if (entry.Timer != null) entry.Timer.Destroy();
            }
            pending.Clear();
            SaveData();
        }
    }
}