-- Script Local de Téléportation Multi-Modes avec Interface
-- Place ce script dans StarterPlayer > StarterPlayerScripts

local Players = game:GetService("Players")
local TweenService = game:GetService("TweenService")
local RunService = game:GetService("RunService")
local player = Players.LocalPlayer
local character = player.Character or player.CharacterAdded:Wait()
local humanoidRootPart = character:WaitForChild("HumanoidRootPart")

-- Configuration
local TELEPORT_DISTANCE_MIN = 5
local TELEPORT_DISTANCE_MAX = 15
local TELEPORT_COOLDOWN = 1.5
local canTeleport = true
local currentMode = "instant"

-- Modes de téléportation disponibles
local teleportModes = {
    {name = "instant", icon = "⚡", display = "Instant", color = Color3.fromRGB(100, 150, 255)},
    {name = "walk", icon = "🚶", display = "Marche", color = Color3.fromRGB(100, 200, 100)},
    {name = "tween", icon = "✈️", display = "Vol Smooth", color = Color3.fromRGB(150, 100, 255)},
    {name = "jump", icon = "🦘", display = "Super Saut", color = Color3.fromRGB(255, 150, 100)},
    {name = "spin", icon = "🌀", display = "Tourbillon", color = Color3.fromRGB(100, 255, 200)},
    {name = "fade", icon = "👻", display = "Fantôme", color = Color3.fromRGB(200, 100, 255)},
    {name = "rocket", icon = "🚀", display = "Fusée", color = Color3.fromRGB(255, 100, 150)},
    {name = "behind", icon = "🎯", display = "Derrière", color = Color3.fromRGB(255, 200, 100)},
    {name = "above", icon = "☁️", display = "Au-dessus", color = Color3.fromRGB(150, 200, 255)},
    {name = "circle", icon = "⭕", display = "Orbite", color = Color3.fromRGB(255, 150, 255)},
    {name = "zigzag", icon = "⚡", display = "Zig-Zag", color = Color3.fromRGB(255, 255, 100)},
    {name = "spiral", icon = "🌪️", display = "Spirale", color = Color3.fromRGB(100, 255, 255)},
}

-- Fonction pour obtenir une position aléatoire autour d'un point
local function getRandomPositionAround(centerCFrame, distance)
    distance = distance or math.random(TELEPORT_DISTANCE_MIN, TELEPORT_DISTANCE_MAX)
    local angle = math.random() * math.pi * 2
    local offsetX = math.cos(angle) * distance
    local offsetZ = math.sin(angle) * distance
    return centerCFrame * CFrame.new(offsetX, 0, offsetZ)
end

-- MODES DE TÉLÉPORTATION
local function teleportInstant(targetCFrame)
    if humanoidRootPart then
        humanoidRootPart.CFrame = targetCFrame
    end
end

local function teleportWalk(targetCFrame)
    local humanoid = character:FindFirstChild("Humanoid")
    if humanoid then
        humanoid:MoveTo(targetCFrame.Position)
    end
end

local function teleportTween(targetCFrame)
    if not humanoidRootPart then return end
    
    local tweenInfo = TweenInfo.new(1.5, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
    local tween = TweenService:Create(humanoidRootPart, tweenInfo, {CFrame = targetCFrame})
    tween:Play()
end

local function teleportJump(targetCFrame)
    if not humanoidRootPart then return end
    
    local startPos = humanoidRootPart.CFrame
    local midPos = (startPos.Position + targetCFrame.Position) / 2 + Vector3.new(0, 30, 0)
    
    local tweenInfo1 = TweenInfo.new(0.75, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
    local tweenInfo2 = TweenInfo.new(0.75, Enum.EasingStyle.Quad, Enum.EasingDirection.In)
    
    local tween1 = TweenService:Create(humanoidRootPart, tweenInfo1, {CFrame = CFrame.new(midPos)})
    tween1:Play()
    tween1.Completed:Connect(function()
        local tween2 = TweenService:Create(humanoidRootPart, tweenInfo2, {CFrame = targetCFrame})
        tween2:Play()
    end)
end

local function teleportSpin(targetCFrame)
    if not humanoidRootPart then return end
    
    local duration = 1
    local startTime = tick()
    local startCFrame = humanoidRootPart.CFrame
    
    local connection
    connection = RunService.Heartbeat:Connect(function()
        local elapsed = tick() - startTime
        local alpha = elapsed / duration
        
        if alpha >= 1 then
            humanoidRootPart.CFrame = targetCFrame
            connection:Disconnect()
            return
        end
        
        local rotation = CFrame.Angles(0, math.pi * 4 * alpha, 0)
        humanoidRootPart.CFrame = startCFrame:Lerp(targetCFrame, alpha) * rotation
    end)
end

local function teleportFade(targetCFrame)
    if not humanoidRootPart then return end
    
    -- Fade out
    for _, part in pairs(character:GetDescendants()) do
        if part:IsA("BasePart") then
            local tween = TweenService:Create(part, TweenInfo.new(0.5), {Transparency = 1})
            tween:Play()
        end
    end
    
    task.wait(0.5)
    humanoidRootPart.CFrame = targetCFrame
    task.wait(0.2)
    
    -- Fade in
    for _, part in pairs(character:GetDescendants()) do
        if part:IsA("BasePart") then
            local originalTransparency = 0
            if part.Name == "HumanoidRootPart" then originalTransparency = 1 end
            local tween = TweenService:Create(part, TweenInfo.new(0.5), {Transparency = originalTransparency})
            tween:Play()
        end
    end
end

local function teleportRocket(targetCFrame)
    if not humanoidRootPart then return end
    
    local startCFrame = humanoidRootPart.CFrame
    local upCFrame = startCFrame + Vector3.new(0, 50, 0)
    
    -- Monter
    local tweenInfo1 = TweenInfo.new(0.8, Enum.EasingStyle.Quad, Enum.EasingDirection.Out)
    local tween1 = TweenService:Create(humanoidRootPart, tweenInfo1, {CFrame = upCFrame})
    tween1:Play()
    
    tween1.Completed:Connect(function()
        task.wait(0.2)
        
        -- Descendre vers la cible
        local tweenInfo2 = TweenInfo.new(0.8, Enum.EasingStyle.Quad, Enum.EasingDirection.In)
        local tween2 = TweenService:Create(humanoidRootPart, tweenInfo2, {CFrame = targetCFrame})
        tween2:Play()
    end)
end

local function teleportBehind(targetCFrame)
    if not humanoidRootPart then return end
    
    -- Position derrière le joueur
    local behindCFrame = targetCFrame * CFrame.new(0, 0, 5)
    local tweenInfo = TweenInfo.new(0.8, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
    local tween = TweenService:Create(humanoidRootPart, tweenInfo, {CFrame = behindCFrame})
    tween:Play()
end

local function teleportAbove(targetCFrame)
    if not humanoidRootPart then return end
    
    -- Position au-dessus
    local aboveCFrame = targetCFrame + Vector3.new(0, 15, 0)
    local tweenInfo = TweenInfo.new(0.8, Enum.EasingStyle.Sine, Enum.EasingDirection.InOut)
    local tween = TweenService:Create(humanoidRootPart, tweenInfo, {CFrame = aboveCFrame})
    tween:Play()
end

local function teleportCircle(targetCFrame)
    if not humanoidRootPart then return end
    
    local duration = 2
    local startTime = tick()
    local radius = 10
    
    local connection
    connection = RunService.Heartbeat:Connect(function()
        local elapsed = tick() - startTime
        local alpha = elapsed / duration
        
        if alpha >= 1 then
            humanoidRootPart.CFrame = targetCFrame
            connection:Disconnect()
            return
        end
        
        local angle = math.pi * 2 * alpha
        local offset = Vector3.new(math.cos(angle) * radius, 0, math.sin(angle) * radius)
        humanoidRootPart.CFrame = CFrame.new(targetCFrame.Position + offset)
    end)
end

local function teleportZigZag(targetCFrame)
    if not humanoidRootPart then return end
    
    local startPos = humanoidRootPart.Position
    local endPos = targetCFrame.Position
    local points = 5
    
    for i = 1, points do
        local alpha = i / points
        local midPos = startPos:Lerp(endPos, alpha)
        local offset = Vector3.new(math.sin(alpha * math.pi * 3) * 5, 0, 0)
        local nextCFrame = CFrame.new(midPos + offset)
        
        local tweenInfo = TweenInfo.new(0.2, Enum.EasingStyle.Linear)
        local tween = TweenService:Create(humanoidRootPart, tweenInfo, {CFrame = nextCFrame})
        tween:Play()
        task.wait(0.2)
    end
    
    humanoidRootPart.CFrame = targetCFrame
end

local function teleportSpiral(targetCFrame)
    if not humanoidRootPart then return end
    
    local duration = 2
    local startTime = tick()
    local startCFrame = humanoidRootPart.CFrame
    
    local connection
    connection = RunService.Heartbeat:Connect(function()
        local elapsed = tick() - startTime
        local alpha = elapsed / duration
        
        if alpha >= 1 then
            humanoidRootPart.CFrame = targetCFrame
            connection:Disconnect()
            return
        end
        
        local angle = math.pi * 4 * alpha
        local radius = 10 * (1 - alpha)
        local offset = Vector3.new(math.cos(angle) * radius, 20 * alpha, math.sin(angle) * radius)
        
        local currentPos = startCFrame.Position:Lerp(targetCFrame.Position, alpha)
        humanoidRootPart.CFrame = CFrame.new(currentPos + offset)
    end)
end

-- Fonction principale de téléportation
local function executeTeleport(targetCFrame)
    if not canTeleport then return end
    
    canTeleport = false
    
    if currentMode == "instant" then
        teleportInstant(targetCFrame)
    elseif currentMode == "walk" then
        teleportWalk(targetCFrame)
    elseif currentMode == "tween" then
        teleportTween(targetCFrame)
    elseif currentMode == "jump" then
        teleportJump(targetCFrame)
    elseif currentMode == "spin" then
        teleportSpin(targetCFrame)
    elseif currentMode == "fade" then
        teleportFade(targetCFrame)
    elseif currentMode == "rocket" then
        teleportRocket(targetCFrame)
    elseif currentMode == "behind" then
        teleportBehind(targetCFrame)
    elseif currentMode == "above" then
        teleportAbove(targetCFrame)
    elseif currentMode == "circle" then
        teleportCircle(targetCFrame)
    elseif currentMode == "zigzag" then
        teleportZigZag(targetCFrame)
    elseif currentMode == "spiral" then
        teleportSpiral(targetCFrame)
    end
    
    task.wait(TELEPORT_COOLDOWN)
    canTeleport = true
end

-- Créer l'interface
local screenGui = Instance.new("ScreenGui")
screenGui.Name = "TeleportGui"
screenGui.ResetOnSpawn = false
screenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
screenGui.Parent = player:WaitForChild("PlayerGui")

-- Frame principale
local mainFrame = Instance.new("Frame")
mainFrame.Size = UDim2.new(0, 350, 0, 500)
mainFrame.Position = UDim2.new(0.5, -175, 0.5, -250)
mainFrame.BackgroundColor3 = Color3.fromRGB(25, 25, 35)
mainFrame.BorderSizePixel = 0
mainFrame.Visible = false
mainFrame.Active = true
mainFrame.Draggable = true
mainFrame.Parent = screenGui

local mainCorner = Instance.new("UICorner")
mainCorner.CornerRadius = UDim.new(0, 12)
mainCorner.Parent = mainFrame

-- Titre
local title = Instance.new("TextLabel")
title.Size = UDim2.new(1, 0, 0, 50)
title.BackgroundColor3 = Color3.fromRGB(15, 15, 25)
title.BorderSizePixel = 0
title.Text = "🌟 Téléportation Multi-Modes"
title.TextColor3 = Color3.fromRGB(255, 255, 255)
title.TextSize = 20
title.Font = Enum.Font.GothamBold
title.Parent = mainFrame

local titleCorner = Instance.new("UICorner")
titleCorner.CornerRadius = UDim.new(0, 12)
titleCorner.Parent = title

-- Bouton fermer
local closeBtn = Instance.new("TextButton")
closeBtn.Size = UDim2.new(0, 30, 0, 30)
closeBtn.Position = UDim2.new(1, -40, 0, 10)
closeBtn.BackgroundColor3 = Color3.fromRGB(200, 50, 50)
closeBtn.Text = "✕"
closeBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
closeBtn.TextSize = 18
closeBtn.Font = Enum.Font.GothamBold
closeBtn.Parent = mainFrame

local closeCorner = Instance.new("UICorner")
closeCorner.CornerRadius = UDim.new(1, 0)
closeCorner.Parent = closeBtn

closeBtn.MouseButton1Click:Connect(function()
    mainFrame.Visible = not mainFrame.Visible
end)

-- Section modes
local modeLabel = Instance.new("TextLabel")
modeLabel.Size = UDim2.new(1, -20, 0, 25)
modeLabel.Position = UDim2.new(0, 10, 0, 60)
modeLabel.BackgroundTransparency = 1
modeLabel.Text = "Choisis ton mode de téléportation:"
modeLabel.TextColor3 = Color3.fromRGB(200, 200, 200)
modeLabel.TextSize = 14
modeLabel.Font = Enum.Font.Gotham
modeLabel.TextXAlignment = Enum.TextXAlignment.Left
modeLabel.Parent = mainFrame

-- Grille de modes
local modeScroll = Instance.new("ScrollingFrame")
modeScroll.Size = UDim2.new(1, -20, 0, 180)
modeScroll.Position = UDim2.new(0, 10, 0, 90)
modeScroll.BackgroundColor3 = Color3.fromRGB(35, 35, 50)
modeScroll.BorderSizePixel = 0
modeScroll.ScrollBarThickness = 6
modeScroll.Parent = mainFrame

local modeScrollCorner = Instance.new("UICorner")
modeScrollCorner.CornerRadius = UDim.new(0, 8)
modeScrollCorner.Parent = modeScroll

local modeGrid = Instance.new("UIGridLayout")
modeGrid.CellSize = UDim2.new(0, 100, 0, 50)
modeGrid.CellPadding = UDim2.new(0, 5, 0, 5)
modeGrid.SortOrder = Enum.SortOrder.LayoutOrder
modeGrid.Parent = modeScroll

local modePadding = Instance.new("UIPadding")
modePadding.PaddingTop = UDim.new(0, 5)
modePadding.PaddingLeft = UDim.new(0, 5)
modePadding.Parent = modeScroll

-- Créer les boutons de modes
for i, mode in ipairs(teleportModes) do
    local btn = Instance.new("TextButton")
    btn.Name = mode.name
    btn.BackgroundColor3 = mode.color
    btn.BorderSizePixel = 0
    btn.Text = mode.icon .. "\n" .. mode.display
    btn.TextColor3 = Color3.fromRGB(255, 255, 255)
    btn.TextSize = 12
    btn.Font = Enum.Font.GothamBold
    btn.Parent = modeScroll
    
    local btnCorner = Instance.new("UICorner")
    btnCorner.CornerRadius = UDim.new(0, 8)
    btnCorner.Parent = btn
    
    btn.MouseButton1Click:Connect(function()
        currentMode = mode.name
        
        -- Mettre à jour les couleurs
        for _, child in pairs(modeScroll:GetChildren()) do
            if child:IsA("TextButton") then
                child.BackgroundTransparency = 0.5
            end
        end
        btn.BackgroundTransparency = 0
    end)
    
    if mode.name == currentMode then
        btn.BackgroundTransparency = 0
    else
        btn.BackgroundTransparency = 0.5
    end
end

modeScroll.CanvasSize = UDim2.new(0, 0, 0, modeGrid.AbsoluteContentSize.Y + 10)

-- Liste joueurs
local playerLabel = Instance.new("TextLabel")
playerLabel.Size = UDim2.new(1, -20, 0, 25)
playerLabel.Position = UDim2.new(0, 10, 0, 280)
playerLabel.BackgroundTransparency = 1
playerLabel.Text = "Joueurs connectés:"
playerLabel.TextColor3 = Color3.fromRGB(200, 200, 200)
playerLabel.TextSize = 14
playerLabel.Font = Enum.Font.Gotham
playerLabel.TextXAlignment = Enum.TextXAlignment.Left
playerLabel.Parent = mainFrame

local playerScroll = Instance.new("ScrollingFrame")
playerScroll.Size = UDim2.new(1, -20, 0, 120)
playerScroll.Position = UDim2.new(0, 10, 0, 310)
playerScroll.BackgroundColor3 = Color3.fromRGB(35, 35, 50)
playerScroll.BorderSizePixel = 0
playerScroll.ScrollBarThickness = 6
playerScroll.Parent = mainFrame

local playerScrollCorner = Instance.new("UICorner")
playerScrollCorner.CornerRadius = UDim.new(0, 8)
playerScrollCorner.Parent = playerScroll

local playerList = Instance.new("UIListLayout")
playerList.Padding = UDim.new(0, 5)
playerList.SortOrder = Enum.SortOrder.Name
playerList.Parent = playerScroll

-- Bouton téléportation aléatoire
local randomBtn = Instance.new("TextButton")
randomBtn.Size = UDim2.new(1, -20, 0, 50)
randomBtn.Position = UDim2.new(0, 10, 1, -60)
randomBtn.BackgroundColor3 = Color3.fromRGB(150, 50, 200)
randomBtn.Text = "🎲 Téléporter Aléatoirement"
randomBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
randomBtn.TextSize = 18
randomBtn.Font = Enum.Font.GothamBold
randomBtn.Parent = mainFrame

local randomCorner = Instance.new("UICorner")
randomCorner.CornerRadius = UDim.new(0, 10)
randomCorner.Parent = randomBtn

-- Créer boutons joueurs
local function createPlayerButton(targetPlayer)
    if targetPlayer == player then return end
    
    local btn = Instance.new("TextButton")
    btn.Name = targetPlayer.Name
    btn.Size = UDim2.new(1, -10, 0, 35)
    btn.BackgroundColor3 = Color3.fromRGB(45, 45, 65)
    btn.Text = "👤 " .. targetPlayer.DisplayName
    btn.TextColor3 = Color3.fromRGB(255, 255, 255)
    btn.TextSize = 14
    btn.Font = Enum.Font.Gotham
    btn.TextXAlignment = Enum.TextXAlignment.Left
    btn.Parent = playerScroll
    
    local pad = Instance.new("UIPadding")
    pad.PaddingLeft = UDim.new(0, 10)
    pad.Parent = btn
    
    local corner = Instance.new("UICorner")
    corner.CornerRadius = UDim.new(0, 6)
    corner.Parent = btn
    
    btn.MouseButton1Click:Connect(function()
        if targetPlayer.Character then
            local hrp = targetPlayer.Character:FindFirstChild("HumanoidRootPart")
            if hrp then
                local targetCFrame = getRandomPositionAround(hrp.CFrame)
                executeTeleport(targetCFrame)
                
                btn.BackgroundColor3 = Color3.fromRGB(0, 200, 100)
                task.wait(0.3)
                btn.BackgroundColor3 = Color3.fromRGB(45, 45, 65)
            end
        end
    end)
end

local function updatePlayerList()
    for _, child in pairs(playerScroll:GetChildren()) do
        if child:IsA("TextButton") then
            child:Destroy()
        end
    end
    
    for _, p in pairs(Players:GetPlayers()) do
        createPlayerButton(p)
    end
    
    playerScroll.CanvasSize = UDim2.new(0, 0, 0, playerList.AbsoluteContentSize.Y)
end

-- Téléportation aléatoire
randomBtn.MouseButton1Click:Connect(function()
    local others = {}
    for _, p in pairs(Players:GetPlayers()) do
        if p ~= player and p.Character then
            local hrp = p.Character:FindFirstChild("HumanoidRootPart")
            if hrp then table.insert(others, hrp) end
        end
    end
    
    if #others == 0 then
        randomBtn.Text = "❌ Aucun joueur!"
        task.wait(1)
        randomBtn.Text = "🎲 Téléporter Aléatoirement"
        return
    end
    
    local target = others[math.random(1, #others)]
    local targetCFrame = getRandomPositionAround(target.CFrame)
    executeTeleport(targetCFrame)
    
    randomBtn.BackgroundColor3 = Color3.fromRGB(0, 200, 100)
    task.wait(0.3)
    randomBtn.BackgroundColor3 = Color3.fromRGB(150, 50, 200)
end)

updatePlayerList()
Players.PlayerAdded:Connect(updatePlayerList)
Players.PlayerRemoving:Connect(updatePlayerList)

player.CharacterAdded:Connect(function(newChar)
    character = newChar
    humanoidRootPart = character:WaitForChild("HumanoidRootPart")
    canTeleport = true
end)

-- Indicateur de touches permanent en bas à droite
local keyIndicator = Instance.new("Frame")
keyIndicator.Name = "KeyIndicator"
keyIndicator.Size = UDim2.new(0, 180, 0, 80)
keyIndicator.Position = UDim2.new(1, -190, 1, -90)
keyIndicator.BackgroundColor3 = Color3.fromRGB(20, 20, 30)
keyIndicator.BorderSizePixel = 0
keyIndicator.Parent = screenGui

local keyCorner = Instance.new("UICorner")
keyCorner.CornerRadius = UDim.new(0, 10)
keyCorner.Parent = keyIndicator

-- Titre de l'indicateur
local keyTitle = Instance.new("TextLabel")
keyTitle.Size = UDim2.new(1, 0, 0, 25)
keyTitle.BackgroundTransparency = 1
keyTitle.Text = "⌨️ Contrôles"
keyTitle.TextColor3 = Color3.fromRGB(200, 200, 200)
keyTitle.TextSize = 14
keyTitle.Font = Enum.Font.GothamBold
keyTitle.Parent = keyIndicator

-- Liste des touches
local keysText = Instance.new("TextLabel")
keysText.Size = UDim2.new(1, -10, 1, -30)
keysText.Position = UDim2.new(0, 5, 0, 25)
keysText.BackgroundTransparency = 1
keysText.Text = "T - Ouvrir/Fermer\nR - Téléport Aléatoire"
keysText.TextColor3 = Color3.fromRGB(255, 255, 255)
keysText.TextSize = 13
keysText.Font = Enum.Font.Gotham
keysText.TextXAlignment = Enum.TextXAlignment.Left
keysText.TextYAlignment = Enum.TextYAlignment.Top
keysText.Parent = keyIndicator

-- Gestion des touches clavier/console
local UserInputService = game:GetService("UserInputService")

UserInputService.InputBegan:Connect(function(input, gameProcessed)
    if gameProcessed then return end
    
    -- Touche T pour ouvrir/fermer l'interface
    if input.KeyCode == Enum.KeyCode.T or input.KeyCode == Enum.KeyCode.ButtonY then
        mainFrame.Visible = not mainFrame.Visible
        
        -- Animation de feedback
        keyIndicator.BackgroundColor3 = Color3.fromRGB(50, 100, 150)
        task.wait(0.2)
        keyIndicator.BackgroundColor3 = Color3.fromRGB(20, 20, 30)
    end
    
    -- Touche R pour téléportation aléatoire
    if input.KeyCode == Enum.KeyCode.R or input.KeyCode == Enum.KeyCode.ButtonX then
        local others = {}
        for _, p in pairs(Players:GetPlayers()) do
            if p ~= player and p.Character then
                local hrp = p.Character:FindFirstChild("HumanoidRootPart")
                if hrp then table.insert(others, hrp) end
            end
        end
        
        if #others > 0 then
            local target = others[math.random(1, #others)]
            local targetCFrame = getRandomPositionAround(target.CFrame)
            executeTeleport(targetCFrame)
            
            -- Animation de feedback
            keyIndicator.BackgroundColor3 = Color3.fromRGB(100, 50, 150)
            task.wait(0.2)
            keyIndicator.BackgroundColor3 = Color3.fromRGB(20, 20, 30)
        end
    end
end)

print("🌟 Interface de téléportation multi-modes chargée!")