How to make a Rust random teleport plugin (/rtp)

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

namespace Oxide.Plugins
{
    [Info("Random Teleport", "RustPluginGenerator", "1.0.0")]
    [Description("Teleports players to a random safe land position with a configurable cooldown.")]
    public class RandomTeleport : RustPlugin
    {
        private const string PermUse = "randomteleport.use";
        private const string PermVip = "randomteleport.vip";

        private readonly Dictionary<ulong, float> cooldowns = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Cooldown Seconds")]
            public float CooldownSeconds = 300f;

            [JsonProperty("VIP Cooldown Seconds")]
            public float VipCooldownSeconds = 60f;

            [JsonProperty("Max Attempts")]
            public int MaxAttempts = 40;

            [JsonProperty("World Border Margin")]
            public float WorldBorderMargin = 200f;

            [JsonProperty("Minimum Terrain Height")]
            public float MinimumTerrainHeight = 1.2f;

            [JsonProperty("Structure Check Radius")]
            public float StructureCheckRadius = 6f;
        }

        private PluginConfig config;

        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>
            {
                ["Teleported"] = "You have been teleported to a random location.",
                ["NoSafeSpot"] = "Could not find a safe spot. Try again later.",
                ["Cooldown"] = "You must wait {0} seconds before using /rtp again.",
                ["NoPermission"] = "You do not have permission to use /rtp."
            }, 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);
            permission.RegisterPermission(PermVip, this);
        }

        private void OnPlayerDisconnected(BasePlayer player)
        {
            if (player != null) cooldowns.Remove(player.userID);
        }

        [ChatCommand("rtp")]
        private void CmdRtp(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 (player.IsDead() || player.IsSleeping()) return;

            float remaining = GetRemaining(player);
            if (remaining > 0f)
            {
                player.ChatMessage(Msg("Cooldown", player.UserIDString, Mathf.CeilToInt(remaining)));
                return;
            }

            Vector3 position;
            if (!TryFindPosition(player, out position))
            {
                player.ChatMessage(Msg("NoSafeSpot", player.UserIDString));
                return;
            }

            player.Teleport(position);
            player.ChatMessage(Msg("Teleported", player.UserIDString));
            cooldowns[player.userID] = Time.realtimeSinceStartup;
        }

        private float GetRemaining(BasePlayer player)
        {
            float cooldown = permission.UserHasPermission(player.UserIDString, PermVip)
                ? config.VipCooldownSeconds
                : config.CooldownSeconds;
            if (cooldown <= 0f) return 0f;

            float stamp;
            if (!cooldowns.TryGetValue(player.userID, out stamp)) return 0f;

            float elapsed = Time.realtimeSinceStartup - stamp;
            return Mathf.Max(0f, cooldown - elapsed);
        }

        private bool TryFindPosition(BasePlayer player, out Vector3 result)
        {
            result = Vector3.zero;
            if (TerrainMeta.HeightMap == null || TerrainMeta.Size == null) return false;

            float sizeX = TerrainMeta.Size.x;
            float sizeZ = TerrainMeta.Size.z;
            float margin = Mathf.Clamp(config.WorldBorderMargin, 0f, Mathf.Min(sizeX, sizeZ) * 0.45f);
            float halfX = sizeX * 0.5f - margin;
            float halfZ = sizeZ * 0.5f - margin;

            for (int i = 0; i < Mathf.Max(1, config.MaxAttempts); i++)
            {
                float x = UnityEngine.Random.Range(-halfX, halfX);
                float z = UnityEngine.Random.Range(-halfZ, halfZ);
                Vector3 candidate = new Vector3(x, 0f, z);

                float height = TerrainMeta.HeightMap.GetHeight(candidate);
                if (height < config.MinimumTerrainHeight) continue;
                if (IsWater(candidate)) continue;

                candidate.y = height + 0.2f;
                if (IsNearStructure(candidate)) continue;
                if (IsInsideBuildingBlocked(player, candidate)) continue;

                result = candidate;
                return true;
            }

            return false;
        }

        private static bool IsWater(Vector3 position)
        {
            if (TerrainMeta.TopologyMap == null) return false;
            int topology = TerrainMeta.TopologyMap.GetTopology(position);
            return (topology & (int)TerrainTopology.Enum.Ocean) != 0 ||
                   (topology & (int)TerrainTopology.Enum.Lake) != 0;
        }

        private bool IsNearStructure(Vector3 position)
        {
            int mask = LayerMask.GetMask("Construction", "Deployed", "Default");
            Collider[] hits = Physics.OverlapSphere(position, config.StructureCheckRadius, mask, QueryTriggerInteraction.Ignore);
            if (hits == null || hits.Length == 0) return false;

            for (int i = 0; i < hits.Length; i++)
            {
                BaseEntity entity = hits[i].GetComponentInParent<BaseEntity>();
                if (entity == null) continue;
                if (entity is BuildingBlock || entity is Door || entity is Deployable) return true;
            }
            return false;
        }

        private static bool IsInsideBuildingBlocked(BasePlayer player, Vector3 position)
        {
            Vector3 original = player.transform.position;
            player.transform.position = position;
            bool blocked = player.IsBuildingBlocked();
            player.transform.position = original;
            return blocked;
        }
    }
}