local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local player = Players.LocalPlayer

------------------------------------------------
-- CHARACTER
------------------------------------------------

local function getChar()
	local char = player.Character or player.CharacterAdded:Wait()
	local root = char:WaitForChild("HumanoidRootPart")
	local humanoid = char:WaitForChild("Humanoid")
	return char, root, humanoid
end

local character, root, humanoid = getChar()

player.CharacterAdded:Connect(function()
	character, root, humanoid = getChar()
end)

------------------------------------------------
-- GUI
------------------------------------------------

local gui = Instance.new("ScreenGui")
gui.Name = "SealPanel"
gui.ResetOnSpawn = false
gui.Parent = player:WaitForChild("PlayerGui")

------------------------------------------------
-- BADGE POPUP 🏅
------------------------------------------------

local badge = Instance.new("Frame")
badge.Size = UDim2.new(0, 0, 0, 60)
badge.Position = UDim2.new(0.5, 0, 0.1, 0)
badge.AnchorPoint = Vector2.new(0.5, 0)
badge.BackgroundColor3 = Color3.fromRGB(20, 60, 40)
badge.Parent = gui

Instance.new("UICorner", badge).CornerRadius = UDim.new(0,12)

local stroke = Instance.new("UIStroke")
stroke.Color = Color3.fromRGB(0,255,150)
stroke.Thickness = 2
stroke.Parent = badge

-- текст
local text = Instance.new("TextLabel")
text.Size = UDim2.new(1, -60, 1, 0)
text.Position = UDim2.new(0, 60, 0, 0)
text.BackgroundTransparency = 1
text.Text = "Made by TheRealDuck228"
text.TextColor3 = Color3.new(1,1,1)
text.TextScaled = true
text.Font = Enum.Font.GothamBold
text.Parent = badge

-- иконка (как у бейджа)
local icon = Instance.new("ImageLabel")
icon.Size = UDim2.new(0, 40, 0, 40)
icon.Position = UDim2.new(0, 10, 0.5, -20)
icon.BackgroundTransparency = 1
icon.Image = "rbxassetid://6031094670" -- иконка
icon.Parent = badge

------------------------------------------------
-- АНИМАЦИЯ
------------------------------------------------

local TweenService = game:GetService("TweenService")

-- появление
TweenService:Create(
	badge,
	TweenInfo.new(0.5, Enum.EasingStyle.Back, Enum.EasingDirection.Out),
	{Size = UDim2.new(0, 300, 0, 60)}
):Play()

-- исчезновение через время
task.delay(3, function()
	TweenService:Create(
		badge,
		TweenInfo.new(0.4, Enum.EasingStyle.Quad, Enum.EasingDirection.In),
		{
			Size = UDim2.new(0, 0, 0, 60),
			Position = UDim2.new(0.5, 0, 0.05, 0)
		}
	):Play()

	task.wait(0.5)
	badge:Destroy()
end)
------------------------------------------------
-- SOUND 🏅
------------------------------------------------

local sound = Instance.new("Sound")
sound.SoundId = "rbxassetid://123417519775640" -- звук получения
sound.Volume = 1
sound.Parent = badge

sound:Play()
------------------------------------------------
-- TOGGLE BUTTON
------------------------------------------------

local panelVisible = false

local toggleBtn = Instance.new("TextButton")
toggleBtn.Size = UDim2.new(0, 130, 0, 40)
toggleBtn.Position = UDim2.new(0, 20, 0.1, 0)
toggleBtn.Text = "OPEN PANEL"
toggleBtn.TextScaled = true
toggleBtn.BackgroundColor3 = Color3.fromRGB(50,50,50)
toggleBtn.TextColor3 = Color3.new(1,1,1)
toggleBtn.Parent = gui
Instance.new("UICorner", toggleBtn).CornerRadius = UDim.new(0,8)

------------------------------------------------
-- PANEL (SCROLLING)
------------------------------------------------

local panel = Instance.new("ScrollingFrame")
panel.Size = UDim2.new(0, 220, 0, 580)
panel.Position = UDim2.new(0, 20, 0.2, 0)
panel.BackgroundColor3 = Color3.fromRGB(0,128,0)
panel.Visible = false
panel.Parent = gui

panel.ScrollBarThickness = 6
panel.ScrollingDirection = Enum.ScrollingDirection.Y
panel.AutomaticCanvasSize = Enum.AutomaticSize.Y
panel.CanvasSize = UDim2.new(0,0,0,0)

Instance.new("UICorner", panel).CornerRadius = UDim.new(0,12)

local layout = Instance.new("UIListLayout")
layout.Padding = UDim.new(0, 10)
layout.SortOrder = Enum.SortOrder.LayoutOrder
layout.Parent = panel

------------------------------------------------
-- HEADER
------------------------------------------------

local header = Instance.new("Frame")
header.Size = UDim2.new(1,0,0,40)
header.BackgroundTransparency = 1
header.Parent = panel

local icon = Instance.new("ImageLabel")
icon.Size = UDim2.new(0,28,0,28)
icon.Position = UDim2.new(0,10,0.5,-14)
icon.BackgroundTransparency = 1
icon.Image = "rbxassetid://98045001959186"
icon.Parent = header

local title2 = Instance.new("TextLabel")
title2.Size = UDim2.new(1,-50,1,0)
title2.Position = UDim2.new(0,45,0,0)
title2.BackgroundTransparency = 1
title2.Text = "SEAL PANEL"
title2.TextColor3 = Color3.new(1,1,1)
title2.TextScaled = true
title2.Font = Enum.Font.GothamBold
title2.Parent = header

------------------------------------------------
-- TOGGLE PANEL
------------------------------------------------

toggleBtn.MouseButton1Click:Connect(function()
	panelVisible = not panelVisible
	panel.Visible = panelVisible
	toggleBtn.Text = panelVisible and "CLOSE PANEL" or "OPEN PANEL"
end)


------------------------------------------------
-- BUTTON FACTORY
------------------------------------------------

local function makeBtn(text)
	local b = Instance.new("TextButton")
	b.Size = UDim2.new(0.9,0,0,40)
	b.BackgroundColor3 = Color3.fromRGB(50,50,50)
	b.Text = text
	b.TextScaled = true
	b.TextColor3 = Color3.new(1,1,1)
	b.Parent = panel
	Instance.new("UICorner", b).CornerRadius = UDim.new(0,8)
	return b
end

------------------------------------------------
-- FLY
------------------------------------------------

local flying = false
local flyForce
local flyConn

local function toggleFly()
	flying = not flying

	if flying then
		flyForce = Instance.new("BodyVelocity")
		flyForce.MaxForce = Vector3.new(1e9,1e9,1e9)
		flyForce.Parent = root

		flyConn = RunService.RenderStepped:Connect(function()
			if root then
				flyForce.Velocity = workspace.CurrentCamera.CFrame.LookVector * 70
			end
		end)
	else
		if flyConn then flyConn:Disconnect() end
		if flyForce then flyForce:Destroy() end
	end
end

------------------------------------------------
-- SPIN
------------------------------------------------

local spinConn
local superSpinConn

local function toggleSpin()
	if superSpinConn then superSpinConn:Disconnect() end

	if spinConn then
		spinConn:Disconnect()
		spinConn = nil
		return
	end

	spinConn = RunService.RenderStepped:Connect(function()
		if root then
			root.CFrame = root.CFrame * CFrame.Angles(0, math.rad(15), 0)
		end
	end)
end

local function toggleSuperSpin()
	if spinConn then spinConn:Disconnect() end

	if superSpinConn then
		superSpinConn:Disconnect()
		superSpinConn = nil
		return
	end

	superSpinConn = RunService.RenderStepped:Connect(function()
		if root then
			root.CFrame = root.CFrame * CFrame.Angles(0, math.rad(60), 0)
		end
	end)
end

------------------------------------------------
-- SPEED
------------------------------------------------

local normalSpeed = 16
local speedOn = false

local function toggleSpeed()
	speedOn = not speedOn
	humanoid.WalkSpeed = speedOn and 40 or normalSpeed
end

------------------------------------------------
-- NOCLIP
------------------------------------------------

local noclip = false
local noclipConn

local function toggleNoclip()
	noclip = not noclip

	if noclip then
		noclipConn = RunService.Stepped:Connect(function()
			for _,v in pairs(character:GetDescendants()) do
				if v:IsA("BasePart") then
					v.CanCollide = false
				end
			end
		end)
	else
		if noclipConn then noclipConn:Disconnect() end
		for _,v in pairs(character:GetDescendants()) do
			if v:IsA("BasePart") then
				v.CanCollide = true
			end
		end
	end
end

------------------------------------------------
-- PUSH
------------------------------------------------

local function pushNearest()
	local nearest = nil
	local dist = 12

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
			local hrp = p.Character.HumanoidRootPart
			local d = (hrp.Position - root.Position).Magnitude

			if d < dist then
				dist = d
				nearest = hrp
			end
		end
	end

	if nearest then
		local dir = (nearest.Position - root.Position).Unit
		nearest.AssemblyLinearVelocity = dir * 120 + Vector3.new(0,60,0)
	end
end

------------------------------------------------
-- TP LOOK
------------------------------------------------

local function tpLook()
	local cam = workspace.CurrentCamera
	local origin = cam.CFrame.Position
	local direction = cam.CFrame.LookVector * 500

	local params = RaycastParams.new()
	params.FilterDescendantsInstances = {character}
	params.FilterType = Enum.RaycastFilterType.Blacklist

	local result = workspace:Raycast(origin, direction, params)

	if result then
		root.CFrame = CFrame.new(result.Position + Vector3.new(0,3,0))
	else
		root.CFrame = root.CFrame + cam.CFrame.LookVector * 100
	end
end

------------------------------------------------
-- DANCE
------------------------------------------------

local dancing = false
local danceTrack

local function toggleDance()
	dancing = not dancing

	if dancing then
		local anim = Instance.new("Animation")
		anim.AnimationId = "rbxassetid://105248382902194"

		danceTrack = humanoid:LoadAnimation(anim)
		danceTrack.Looped = true
		danceTrack:Play()
	else
		if danceTrack then
			danceTrack:Stop()
		end
	end
end
---
local function tpToNearest()
	if not root then return end

	local nearest = nil
	local dist = math.huge

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
			local hrp = p.Character.HumanoidRootPart
			local d = (hrp.Position - root.Position).Magnitude

			if d < dist then
				dist = d
				nearest = hrp
			end
		end
	end

	if nearest then
		-- телепорт рядом, а не внутрь игрока (чтобы не застревать)
		root.CFrame = nearest.CFrame * CFrame.new(0, 0, 3)
	end
end
------
local function launchSelf()
	if not root then return end

	-- направление (куда смотришь)
	local look = workspace.CurrentCamera.CFrame.LookVector

	-- сила толчка
	local force = (look * 120) + Vector3.new(0, 150, 0)

	-- применяем скорость
	root.AssemblyLinearVelocity = force
end
-------
local jumpOn = false
local normalJump = 50

local function toggleJump()
	if not humanoid then return end

	jumpOn = not jumpOn

	if jumpOn then
		humanoid.JumpPower = 120 -- усиленный прыжок
	else
		humanoid.JumpPower = normalJump -- обычный
	end
end
------------
------------------------------------------------
-- PLAYER LIST GUI
------------------------------------------------

local plrGui = Instance.new("ScreenGui")
plrGui.Name = "PlayerListGUI"
plrGui.ResetOnSpawn = false
plrGui.Parent = player:WaitForChild("PlayerGui")

local plrFrame = Instance.new("Frame")
plrFrame.Size = UDim2.new(0, 250, 0, 350)
plrFrame.Position = UDim2.new(0.5, -125, 0.5, -175)
plrFrame.BackgroundColor3 = Color3.fromRGB(30,30,30)
plrFrame.Visible = false
plrFrame.Parent = plrGui
Instance.new("UICorner", plrFrame).CornerRadius = UDim.new(0,12)

------------------------------------------------
-- DRAGGABLE
------------------------------------------------

local UIS = game:GetService("UserInputService")

local dragging = false
local dragInput
local dragStart
local startPos

local function update(input)
	local delta = input.Position - dragStart
	plrFrame.Position = UDim2.new(
		startPos.X.Scale,
		startPos.X.Offset + delta.X,
		startPos.Y.Scale,
		startPos.Y.Offset + delta.Y
	)
end

plrFrame.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1
	or input.UserInputType == Enum.UserInputType.Touch then

		dragging = true
		dragStart = input.Position
		startPos = plrFrame.Position

		input.Changed:Connect(function()
			if input.UserInputState == Enum.UserInputState.End then
				dragging = false
			end
		end)
	end
end)

plrFrame.InputChanged:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseMovement
	or input.UserInputType == Enum.UserInputType.Touch then
		dragInput = input
	end
end)

UIS.InputChanged:Connect(function(input)
	if dragging and input == dragInput then
		update(input)
	end
end)

------------------------------------------------
-- SCROLL LIST
------------------------------------------------

local scroll = Instance.new("ScrollingFrame")
scroll.Size = UDim2.new(1, 0, 1, 0)
scroll.CanvasSize = UDim2.new(0,0,0,0)
scroll.AutomaticCanvasSize = Enum.AutomaticSize.Y
scroll.ScrollBarThickness = 6
scroll.BackgroundTransparency = 1
scroll.Parent = plrFrame

local layout = Instance.new("UIListLayout")
layout.Padding = UDim.new(0, 6)
layout.Parent = scroll

------------------------------------------------
-- TP FUNCTION
------------------------------------------------

local function tpToPlayer(target)
	if not root then return end
	if not target.Character then return end

	local hrp = target.Character:FindFirstChild("HumanoidRootPart")
	if not hrp then return end

	root.CFrame = hrp.CFrame * CFrame.new(0,0,3)
end

------------------------------------------------
-- REFRESH LIST
------------------------------------------------

local function refreshList()
	for _, v in pairs(scroll:GetChildren()) do
		if v:IsA("TextButton") then
			v:Destroy()
		end
	end

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player then
			local btn = Instance.new("TextButton")
			btn.Size = UDim2.new(0.9, 0, 0, 40)
			btn.BackgroundColor3 = Color3.fromRGB(50,50,50)
			btn.TextColor3 = Color3.new(1,1,1)
			btn.TextScaled = true
			btn.Text = "TP: " .. p.Name
			btn.Parent = scroll

			Instance.new("UICorner", btn).CornerRadius = UDim.new(0,8)

			btn.MouseButton1Click:Connect(function()
				tpToPlayer(p)
			end)
		end
	end
end

------------------------------------------------
-- AUTO UPDATE
------------------------------------------------

Players.PlayerAdded:Connect(function()
	task.wait(1)
	refreshList()
end)

Players.PlayerRemoving:Connect(function()
	task.wait(1)
	refreshList()
end)

------------------------------------------------
-- OPEN BUTTON
------------------------------------------------

local plrOpen = false

makeBtn("PLAYER LIST").MouseButton1Click:Connect(function()
	plrOpen = not plrOpen
	plrFrame.Visible = plrOpen

	if plrOpen then
		refreshList()
	end
end)
---------
local tpLoop = false

local function tpToAllPlayers()
	if tpLoop then
		tpLoop = false
		return
	end

	tpLoop = true

	task.spawn(function()
		while tpLoop do
			for _, p in pairs(Players:GetPlayers()) do
				if not tpLoop then break end

				if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
					local hrp = p.Character.HumanoidRootPart

					if root then
						root.CFrame = hrp.CFrame * CFrame.new(0, 0, 3)
					end

					task.wait(1) -- задержка между телепортами
				end
			end
		end
	end)
end
--------
local trailOn = false
local trailFolder
local trailConn

local function toggleTrail()
	trailOn = not trailOn

	if trailOn then
		trailFolder = Instance.new("Folder")
		trailFolder.Name = "TrailFolder"
		trailFolder.Parent = workspace

		trailConn = RunService.RenderStepped:Connect(function()
			if root then
				local part = Instance.new("Part")
				part.Size = Vector3.new(0.4,0.4,0.4)
				part.Anchored = true
				part.CanCollide = false
				part.Material = Enum.Material.Neon
				part.Color = Color3.fromRGB(0, 170, 255)
				part.Position = root.Position
				part.Parent = trailFolder

				game:GetService("Debris"):AddItem(part, 1)
			end
		end)
	else
		if trailConn then trailConn:Disconnect() end
		if trailFolder then trailFolder:Destroy() end
	end
end
-------
local gravityLow = false
local originalJump = humanoid.JumpPower
local originalSpeed = humanoid.WalkSpeed

local function toggleGravityShift()
	gravityLow = not gravityLow

	if gravityLow then
		humanoid.JumpPower = 120
		workspace.Gravity = 50
	else
		humanoid.JumpPower = originalJump
		workspace.Gravity = 196.2
	end
end
-------
local rainbowOn = false
local rainbowConn

local function toggleRainbow()
	rainbowOn = not rainbowOn

	if rainbowOn then
		rainbowConn = RunService.RenderStepped:Connect(function()
			if not character then return end

			local hue = tick() % 5 / 5
			local color = Color3.fromHSV(hue, 1, 1)

			for _, v in pairs(character:GetDescendants()) do
				if v:IsA("BasePart") and v.Name ~= "HumanoidRootPart" then
					v.Color = color
				end
			end
		end)
	else
		if rainbowConn then
			rainbowConn:Disconnect()
			rainbowConn = nil
		end
	end
end
------
local launchTouchOn = false
local touchConn

local function toggleAutoLaunch()
	launchTouchOn = not launchTouchOn

	if launchTouchOn then
		touchConn = RunService.Stepped:Connect(function()
			if not root then return end

			for _, p in pairs(Players:GetPlayers()) do
				if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
					local hrp = p.Character.HumanoidRootPart

					local dist = (hrp.Position - root.Position).Magnitude

					-- если почти касаешься игрока
					if dist < 4 then
						local dir = (hrp.Position - root.Position).Unit

						hrp.AssemblyLinearVelocity =
							dir * 120 + Vector3.new(0, 90, 0)
					end
				end
			end
		end)
	else
		if touchConn then
			touchConn:Disconnect()
			touchConn = nil
		end
	end
end
-------
local noCollideOn = false
local loopConn

local function toggleNoPlayerCollision()
	noCollideOn = not noCollideOn

	if noCollideOn then
		loopConn = RunService.Stepped:Connect(function()
			for _, p in pairs(Players:GetPlayers()) do
				if p ~= player and p.Character then
					for _, v in pairs(p.Character:GetDescendants()) do
						if v:IsA("BasePart") then
							v.CanCollide = false
						end
					end
				end
			end
		end)
	else
		if loopConn then
			loopConn:Disconnect()
			loopConn = nil
		end

		-- вернуть коллизию игрокам
		for _, p in pairs(Players:GetPlayers()) do
			if p.Character then
				for _, v in pairs(p.Character:GetDescendants()) do
					if v:IsA("BasePart") then
						v.CanCollide = true
					end
				end
			end
		end
	end
end
-------
local impactOn = false
local impactConn

local function toggleImpactZone()
	impactOn = not impactOn

	if impactOn then
		impactConn = RunService.Stepped:Connect(function()
			if not root then return end

			for _, p in pairs(Players:GetPlayers()) do
				if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
					local hrp = p.Character.HumanoidRootPart

					local offset = hrp.Position - root.Position
					local dist = offset.Magnitude

					if dist < 12 and dist > 0 then
						local dir = offset.Unit

						-- мягкий отталкивающий эффект
						hrp.AssemblyLinearVelocity =
							dir * 35 + Vector3.new(0, 10, 0)
					end
				end
			end
		end)
	else
		if impactConn then
			impactConn:Disconnect()
			impactConn = nil
		end
	end
end
-------
local bounceOn = false
local bounceConn
local direction = 1

local function toggleBounceMove()
	bounceOn = not bounceOn

	if bounceOn then
		local startPos = root.Position

		bounceConn = RunService.Heartbeat:Connect(function()
			if not root then return end

			-- быстро меняем направление
			if math.random(1, 10) == 1 then
				direction = -direction
			end

			local offset = root.CFrame.LookVector * direction * 0.3

			-- держим почти на месте
			root.CFrame = CFrame.new(startPos) * CFrame.new(offset)
		end)
	else
		if bounceConn then
			bounceConn:Disconnect()
			bounceConn = nil
		end
	end
end
-----
local function pushPlayers()
	if not root then return end

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character then
			local hrp = p.Character:FindFirstChild("HumanoidRootPart")

			if hrp then
				local offset = hrp.Position - root.Position
				local dist = offset.Magnitude

				if dist < 12 and dist > 0 then
					local dir = offset.Unit

					-- пытаемся “захватить” физику
					pcall(function()
						hrp:SetNetworkOwner(nil)
					end)

					-- более сильный и стабильный толчок
					hrp.Velocity = dir * 150 + Vector3.new(0, 70, 0)
				end
			end
		end
	end
end
---------
local chaseOn = false
local chaseConn
local direction = 1

local function getNearestPlayer()
	local nearest = nil
	local dist = math.huge

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
			local d = (p.Character.HumanoidRootPart.Position - root.Position).Magnitude
			if d < dist then
				dist = d
				nearest = p
			end
		end
	end

	return nearest
end

local function toggleChaseBounce()
	chaseOn = not chaseOn

	if chaseOn then
		chaseConn = RunService.Heartbeat:Connect(function()
			if not root then return end

			local target = getNearestPlayer()
			if not target or not target.Character then return end

			local thrp = target.Character:FindFirstChild("HumanoidRootPart")
			if not thrp then return end

			-- телепорт рядом с игроком
			local basePos = thrp.Position + Vector3.new(3, 0, 0)

			-- быстрый вперёд-назад эффект
			if math.random(1, 8) == 1 then
				direction = -direction
			end

			local offset = thrp.CFrame.LookVector * direction * 2

			root.CFrame = CFrame.new(basePos + offset)
		end)
	else
		if chaseConn then
			chaseConn:Disconnect()
			chaseConn = nil
		end
	end
end
---------
local chaseOn = false
local chaseConn

local function getNearestPlayer()
	local nearest = nil
	local dist = math.huge

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
			local d = (p.Character.HumanoidRootPart.Position - root.Position).Magnitude
			if d < dist then
				dist = d
				nearest = p
			end
		end
	end

	return nearest
end

local function toggleChaseBehind()
	chaseOn = not chaseOn

	if chaseOn then
		chaseConn = RunService.Heartbeat:Connect(function()
			if not root then return end

			local target = getNearestPlayer()
			if not target or not target.Character then return end

			local hrp = target.Character:FindFirstChild("HumanoidRootPart")
			if not hrp then return end

			-- позиция СЗАДИ игрока
			local behindPos = hrp.Position - (hrp.CFrame.LookVector * 3)

			-- телепорт за игроком постоянно
			root.CFrame = CFrame.new(behindPos, hrp.Position)
		end)
	else
		if chaseConn then
			chaseConn:Disconnect()
			chaseConn = nil
		end
	end
end
---------
local chaseBounceOn = false
local chaseConn
local direction = 1

local function getNearestPlayer()
	local nearest = nil
	local dist = math.huge

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
			local d = (p.Character.HumanoidRootPart.Position - root.Position).Magnitude
			if d < dist then
				dist = d
				nearest = p
			end
		end
	end

	return nearest
end

local function toggleChaseBounce()
	chaseBounceOn = not chaseBounceOn

	if chaseBounceOn then
		chaseConn = RunService.Heartbeat:Connect(function()
			if not root then return end

			local target = getNearestPlayer()
			if not target or not target.Character then return end

			local hrp = target.Character:FindFirstChild("HumanoidRootPart")
			if not hrp then return end

			-- переключение направления (быстрое “дрожание”)
			if math.random(1, 6) == 1 then
				direction = -direction
			end

			-- позиция ЗА игроком
			local behindPos = hrp.Position - (hrp.CFrame.LookVector * 3)

			-- добавляем bounce вперёд/назад
			local bounceOffset = hrp.CFrame.LookVector * direction * 1.5

			root.CFrame = CFrame.new(behindPos + bounceOffset, hrp.Position)
		end)
	else
		if chaseConn then
			chaseConn:Disconnect()
			chaseConn = nil
		end
	end
end
---------
local listOpen = false
local listGui
local bounceConn
local direction = 1

local function stopBounce()
	if bounceConn then
		bounceConn:Disconnect()
		bounceConn = nil
	end
end

local function startBounceOnPlayer(target)
	stopBounce()

	bounceConn = RunService.Heartbeat:Connect(function()
		if not target or not target.Character then return end
		if not root then return end

		local hrp = target.Character:FindFirstChild("HumanoidRootPart")
		if not hrp then return end

		if math.random(1,6) == 1 then
			direction = -direction
		end

		local base = hrp.Position - (hrp.CFrame.LookVector * 3)
		local offset = hrp.CFrame.LookVector * direction * 1.5

		root.CFrame = CFrame.new(base + offset, hrp.Position)
	end)
end

local function createPlayerList()
	if listGui then listGui:Destroy() end

	listGui = Instance.new("Frame")
	listGui.Size = UDim2.new(0, 200, 0, 300)
	listGui.Position = UDim2.new(0.7, -100, 0.5, -150)
	listGui.BackgroundColor3 = Color3.fromRGB(30,30,30)
	listGui.Parent = gui
	Instance.new("UICorner", listGui)

	local scroll = Instance.new("ScrollingFrame")
	scroll.Size = UDim2.new(1,0,1,0)
	scroll.CanvasSize = UDim2.new(0,0,0,0)
	scroll.AutomaticCanvasSize = Enum.AutomaticSize.Y
	scroll.ScrollBarThickness = 5
	scroll.Parent = listGui

	local layout = Instance.new("UIListLayout")
	layout.Padding = UDim.new(0,5)
	layout.Parent = scroll

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player then
			local btn = Instance.new("TextButton")
			btn.Size = UDim2.new(1, -10, 0, 40)
			btn.Text = p.Name .. " (TP)"
			btn.BackgroundColor3 = Color3.fromRGB(50,50,50)
			btn.TextColor3 = Color3.new(1,1,1)
			btn.Parent = scroll
			Instance.new("UICorner", btn)

			btn.MouseButton1Click:Connect(function()
				if p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
					local hrp = p.Character.HumanoidRootPart

					-- телепорт
					root.CFrame = hrp.CFrame * CFrame.new(0,0,3)

					-- включаем bounce
					startBounceOnPlayer(p)
				end
			end)
		end
	end
end

local function togglePlayerList()
	listOpen = not listOpen

	if listOpen then
		createPlayerList()
	else
		if listGui then
			listGui:Destroy()
			listGui = nil
		end
		stopBounce()
	end
end
------------------------------------------------
-- BALL MODE (ВИДНО ДРУГИМ + ФИЗИКА)
------------------------------------------------

local ballOn = false
local ballPart
local weld
local gyro
local vel

local function toggleBall()
	if not character or not root then return end

	ballOn = not ballOn

	if ballOn then
		-- скрываем тело
		for _, v in pairs(character:GetDescendants()) do
			if v:IsA("BasePart") and v.Name ~= "HumanoidRootPart" then
				v.Transparency = 1
				v.CanCollide = false
			end
		end

		-- создаём шар
		ballPart = Instance.new("Part")
		ballPart.Shape = Enum.PartType.Ball
		ballPart.Size = Vector3.new(5,5,5)
		ballPart.Material = Enum.Material.SmoothPlastic
		ballPart.Color = Color3.fromRGB(255, 100, 0)
		ballPart.Position = root.Position
		ballPart.CanCollide = true
		ballPart.Parent = character

		-- физика
		ballPart.CustomPhysicalProperties = PhysicalProperties.new(
			0.7, -- плотность
			0.3, -- трение
			0.9  -- упругость (отскок)
		)

		-- привязка
		weld = Instance.new("WeldConstraint")
		weld.Part0 = ballPart
		weld.Part1 = root
		weld.Parent = ballPart

		-- управление через физику
		vel = Instance.new("BodyVelocity")
		vel.MaxForce = Vector3.new(1e5, 0, 1e5)
		vel.Velocity = Vector3.new(0,0,0)
		vel.Parent = ballPart

		gyro = Instance.new("BodyGyro")
		gyro.MaxTorque = Vector3.new(1e5,1e5,1e5)
		gyro.P = 3000
		gyro.Parent = ballPart

		-- скрываем root
		root.Transparency = 1

		-- даём тебе контроль (чтобы другие видели движение)
		pcall(function()
			root:SetNetworkOwner(player)
		end)

		-- движение как у мяча
		RunService.RenderStepped:Connect(function()
			if ballOn and ballPart and vel then
				local cam = workspace.CurrentCamera
				local move = humanoid.MoveDirection

				vel.Velocity = (cam.CFrame.RightVector * move.X + cam.CFrame.LookVector * move.Z) * 60
			end
		end)

	else
		-- возврат
		for _, v in pairs(character:GetDescendants()) do
			if v:IsA("BasePart") then
				v.Transparency = 0
				v.CanCollide = true
			end
		end

		if ballPart then ballPart:Destroy() end
		if vel then vel:Destroy() end
		if gyro then gyro:Destroy() end

		ballPart = nil
	end
end 
------------------------------------------------
-- REAL BALL PHYSICS (РЕАЛЬНОЕ КАТАНИЕ)
------------------------------------------------

local realBallOn = false
local torque
local gyro
local conn

local function toggleRealBall()
	if not root or not humanoid then return end

	realBallOn = not realBallOn

	if realBallOn then
		-- отключаем управление
		humanoid.PlatformStand = true

		-- делаем тело скользким
		root.CustomPhysicalProperties = PhysicalProperties.new(
			1,   -- плотность
			0.1, -- трение (очень мало = катится)
			0.8  -- упругость
		)

		-- вращение (ВОТ ГЛАВНОЕ)
		torque = Instance.new("BodyAngularVelocity")
		torque.MaxTorque = Vector3.new(1e6, 1e6, 1e6)
		torque.AngularVelocity = Vector3.new(0,0,0)
		torque.Parent = root

		-- чтобы не заваливался
		gyro = Instance.new("BodyGyro")
		gyro.MaxTorque = Vector3.new(0,1e6,0)
		gyro.P = 3000
		gyro.Parent = root

		conn = RunService.RenderStepped:Connect(function()
			local cam = workspace.CurrentCamera
			local move = humanoid.MoveDirection

			-- направление движения
			local dir =
				(cam.CFrame.RightVector * move.X +
				cam.CFrame.LookVector * move.Z)

			-- ПЕРЕВОД ДВИЖЕНИЯ В ВРАЩЕНИЕ
			local spin = Vector3.new(-dir.Z, 0, dir.X) * 25

			torque.AngularVelocity = spin

			-- поворот корпуса по камере
			if dir.Magnitude > 0 then
				gyro.CFrame = CFrame.new(root.Position, root.Position + dir)
			end
		end)

	else
		-- вернуть всё назад
		humanoid.PlatformStand = false

		if conn then conn:Disconnect() end
		if torque then torque:Destroy() end
		if gyro then gyro:Destroy() end

		root.CustomPhysicalProperties = nil
	end
end
------------------------------------------------
-- ULTRA BALL MODE 😈🟠
------------------------------------------------

local ultraBallOn = false
local torque, gyro, conn, hitConn
local speed = 0

local function toggleUltraBall()
	if not root or not humanoid then return end

	ultraBallOn = not ultraBallOn

	if ultraBallOn then
		humanoid.PlatformStand = true

		-- СУПЕР ФИЗИКА
		root.CustomPhysicalProperties = PhysicalProperties.new(
			1,    -- плотность
			0.05, -- почти нет трения = дикий дрифт
			1     -- максимальный отскок
		)

		-- вращение
		torque = Instance.new("BodyAngularVelocity")
		torque.MaxTorque = Vector3.new(1e7,1e7,1e7)
		torque.Parent = root

		-- стабилизация
		gyro = Instance.new("BodyGyro")
		gyro.MaxTorque = Vector3.new(0,1e7,0)
		gyro.P = 5000
		gyro.Parent = root

		-- ТАРАН 💥
		hitConn = root.Touched:Connect(function(hit)
			local model = hit:FindFirstAncestorOfClass("Model")
			if model and model ~= character then
				local hrp = model:FindFirstChild("HumanoidRootPart")
				if hrp then
					local dir = (hrp.Position - root.Position).Unit
					hrp.AssemblyLinearVelocity = dir * (80 + speed*2) + Vector3.new(0,50,0)
				end
			end
		end)

		-- ДВИЖЕНИЕ
		conn = RunService.RenderStepped:Connect(function()
			local cam = workspace.CurrentCamera
			local move = humanoid.MoveDirection

			local dir =
				(cam.CFrame.RightVector * move.X +
				cam.CFrame.LookVector * move.Z)

			-- РАЗГОН 🚀
			if dir.Magnitude > 0 then
				speed = math.clamp(speed + 1.5, 0, 120)
			else
				speed = speed * 0.98
			end

			-- вращение = движение
			local spin = Vector3.new(-dir.Z, 0, dir.X) * speed
			torque.AngularVelocity = spin

			-- поворот
			if dir.Magnitude > 0 then
				gyro.CFrame = CFrame.new(root.Position, root.Position + dir)
			end
		end)

	else
		-- ВЫКЛ
		humanoid.PlatformStand = false
		speed = 0

		if conn then conn:Disconnect() end
		if torque then torque:Destroy() end
		if gyro then gyro:Destroy() end
		if hitConn then hitConn:Disconnect() end

		root.CustomPhysicalProperties = nil
	end
end
------------------------------------------------
-- REAL FLING 💥
------------------------------------------------

local function flingNearest()
	if not root then return end

	local target = nil
	local dist = 15

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
			local hrp = p.Character.HumanoidRootPart
			local d = (hrp.Position - root.Position).Magnitude

			if d < dist then
				dist = d
				target = hrp
			end
		end
	end

	if not target then return end

	-- сохраняем позицию
	local oldCFrame = root.CFrame

	-- создаём вращение (основа fling)
	local bav = Instance.new("BodyAngularVelocity")
	bav.AngularVelocity = Vector3.new(99999,99999,99999)
	bav.MaxTorque = Vector3.new(1e9,1e9,1e9)
	bav.P = 1e6
	bav.Parent = root

	-- телепорт внутрь игрока и крутимся
	for i = 1, 25 do
		root.CFrame = target.CFrame * CFrame.new(0, 0, 0)
		RunService.Heartbeat:Wait()
	end

	-- убираем вращение
	bav:Destroy()

	-- возвращаем назад
	root.CFrame = oldCFrame
end
------------------------------------------------
-- ANTIFLING 🛡️
------------------------------------------------

local antiflingOn = false
local antiflingConn

local function enableAntiFling()
	if not character or not root then return end

	antiflingOn = true

	-- делаем персонаж устойчивым
	root.CustomPhysicalProperties = PhysicalProperties.new(
		100,  -- плотность (очень тяжёлый)
		0,    -- трение
		0     -- отскок
	)

	-- стабилизация
	local antiGyro = Instance.new("BodyGyro")
	antiGyro.Name = "AntiFlingGyro"
	antiGyro.MaxTorque = Vector3.new(1e9,1e9,1e9)
	antiGyro.P = 10000
	antiGyro.CFrame = root.CFrame
	antiGyro.Parent = root

	-- гасим резкие скорости
	antiflingConn = RunService.Heartbeat:Connect(function()
		if not root then return end

		-- если тебя пытаются флинговать — гасим движение
		if root.AssemblyLinearVelocity.Magnitude > 120 then
			root.AssemblyLinearVelocity = root.AssemblyLinearVelocity * 0.2
		end

		if root.AssemblyAngularVelocity.Magnitude > 80 then
			root.AssemblyAngularVelocity = Vector3.new(0,0,0)
		end
	end)
end

local function disableAntiFling()
	antiflingOn = false

	if antiflingConn then
		antiflingConn:Disconnect()
		antiflingConn = nil
	end

	local gyro = root and root:FindFirstChild("AntiFlingGyro")
	if gyro then gyro:Destroy() end

	if root then
		root.CustomPhysicalProperties = nil
	end
end

local function toggleAntiFling()
	if antiflingOn then
		disableAntiFling()
	else
		enableAntiFling()
	end
end
------------------------------------------------
-- FLING SAFE MODE 🛡️💥
------------------------------------------------

local flingSafeOn = false
local safeConn

local function enableFlingSafe()
	if not root then return end

	flingSafeOn = true

	-- фиксируем игрока
	local gyro = Instance.new("BodyGyro")
	gyro.Name = "FlingSafeGyro"
	gyro.MaxTorque = Vector3.new(1e9,1e9,1e9)
	gyro.P = 10000
	gyro.CFrame = root.CFrame
	gyro.Parent = root

	local velLock = Instance.new("BodyVelocity")
	velLock.Name = "FlingSafeVel"
	velLock.MaxForce = Vector3.new(1e9,1e9,1e9)
	velLock.Velocity = Vector3.new(0,0,0)
	velLock.Parent = root

	-- гасим любой отлёт
	safeConn = RunService.Heartbeat:Connect(function()
		if not root then return end

		-- полностью убираем отдачу
		if root.AssemblyLinearVelocity.Magnitude > 0 then
			root.AssemblyLinearVelocity = Vector3.zero
		end

		if root.AssemblyAngularVelocity.Magnitude > 0 then
			root.AssemblyAngularVelocity = Vector3.zero
		end
	end)
end

local function disableFlingSafe()
	flingSafeOn = false

	if safeConn then
		safeConn:Disconnect()
		safeConn = nil
	end

	local g = root and root:FindFirstChild("FlingSafeGyro")
	if g then g:Destroy() end

	local v = root and root:FindFirstChild("FlingSafeVel")
	if v then v:Destroy() end
end

local function toggleFlingSafe()
	if flingSafeOn then
		disableFlingSafe()
	else
		enableFlingSafe()
	end
end
------------------------------------------------
-- GRAVITY PUSH 🚀
------------------------------------------------

local gravityPushOn = false
local gravityConn

local function toggleGravityPush()
	if not root then return end

	gravityPushOn = not gravityPushOn

	if gravityPushOn then
		gravityConn = RunService.Heartbeat:Connect(function()
			if not root then return end

			for _, p in pairs(Players:GetPlayers()) do
				if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
					local hrp = p.Character.HumanoidRootPart

					local offset = hrp.Position - root.Position
					local dist = offset.Magnitude

					if dist < 25 and dist > 0 then
						local dir = offset.Unit

						-- чем ближе — тем сильнее отталкивание
						local power = math.clamp(120 - dist * 3, 20, 120)

						hrp.AssemblyLinearVelocity =
							dir * power + Vector3.new(0, 40, 0)
					end
				end
			end
		end)
	else
		if gravityConn then
			gravityConn:Disconnect()
			gravityConn = nil
		end
	end
end
------------------------------------------------
-- SELF ORBIT MODE 🪐 (ты крутишься вокруг игрока)
------------------------------------------------

local selfOrbitOn = false
local orbitConn

local function getNearestPlayer()
	local nearest = nil
	local dist = math.huge

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
			local hrp = p.Character.HumanoidRootPart
			local d = (hrp.Position - root.Position).Magnitude

			if d < dist then
				dist = d
				nearest = p
			end
		end
	end

	return nearest
end

local function toggleSelfOrbit()
	if not root then return end

	selfOrbitOn = not selfOrbitOn

	if selfOrbitOn then
		orbitConn = RunService.Heartbeat:Connect(function()
			if not root then return end

			local targetPlayer = getNearestPlayer()
			if not targetPlayer or not targetPlayer.Character then return end

			local hrp = targetPlayer.Character:FindFirstChild("HumanoidRootPart")
			if not hrp then return end

			local t = tick()

			-- угол вращения
			local angle = t * 3

			local radius = 6

			-- позиция вокруг игрока
			local orbitPos = hrp.Position + Vector3.new(
				math.cos(angle) * radius,
				2,
				math.sin(angle) * radius
			)

			-- движение к позиции орбиты
			root.AssemblyLinearVelocity =
				(orbitPos - root.Position) * 10
		end)
	else
		if orbitConn then
			orbitConn:Disconnect()
			orbitConn = nil
		end
	end
end
------------------------------------------------
-- HEAL 🩺 (мгновенно)
------------------------------------------------

local function healPlayer()
	if not humanoid then return end
	humanoid.Health = humanoid.MaxHealth
end
------------------------------------------------
-- LOOK AT NEAREST 👀
------------------------------------------------

local lookConn
local lookOn = false

local function getNearestPlayer()
	local nearest = nil
	local dist = math.huge

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
			local d = (p.Character.HumanoidRootPart.Position - root.Position).Magnitude
			if d < dist then
				dist = d
				nearest = p
			end
		end
	end

	return nearest
end

local function toggleLookNearest()
	lookOn = not lookOn

	if lookOn then
		lookConn = RunService.RenderStepped:Connect(function()
			if not root then return end

			local target = getNearestPlayer()
			if not target or not target.Character then return end

			local hrp = target.Character:FindFirstChild("HumanoidRootPart")
			if not hrp then return end

			-- поворачиваемся к игроку
			local pos = root.Position
			local targetPos = hrp.Position

			root.CFrame = CFrame.new(pos, Vector3.new(targetPos.X, pos.Y, targetPos.Z))
		end)
	else
		if lookConn then
			lookConn:Disconnect()
			lookConn = nil
		end
	end
end
------------------------------------------------
-- RED HIGHLIGHT PLAYERS 🔴
------------------------------------------------

local highlightOn = false
local highlights = {}

local function toggleHighlightPlayers()
	highlightOn = not highlightOn

	if highlightOn then
		for _, p in pairs(Players:GetPlayers()) do
			if p ~= player and p.Character then
				if not highlights[p] then
					local hl = Instance.new("Highlight")
					hl.FillColor = Color3.fromRGB(255, 0, 0)
					hl.OutlineColor = Color3.fromRGB(255, 255, 255)
					hl.FillTransparency = 0.5
					hl.Parent = p.Character

					highlights[p] = hl
				end
			end
		end

		-- новые игроки тоже подсвечиваются
		Players.PlayerAdded:Connect(function(p)
			p.CharacterAdded:Connect(function(char)
				if highlightOn then
					local hl = Instance.new("Highlight")
					hl.FillColor = Color3.fromRGB(255, 0, 0)
					hl.OutlineColor = Color3.fromRGB(255, 255, 255)
					hl.FillTransparency = 0.5
					hl.Parent = char

					highlights[p] = hl
				end
			end)
		end)

	else
		-- выключаем
		for _, hl in pairs(highlights) do
			if hl then
				hl:Destroy()
			end
		end
		highlights = {}
	end
end
------------------------------------------------
-- PREDICT MOVE 🔮
------------------------------------------------

local predictOn = false
local predictConn
local arrowPart

local function togglePredictMove()
	predictOn = not predictOn

	if predictOn then
		-- создаём стрелку
		arrowPart = Instance.new("Part")
		arrowPart.Size = Vector3.new(0.5, 0.5, 3)
		arrowPart.Anchored = true
		arrowPart.CanCollide = false
		arrowPart.Material = Enum.Material.Neon
		arrowPart.Color = Color3.fromRGB(255, 0, 0)
		arrowPart.Name = "PredictArrow"
		arrowPart.Parent = workspace

		predictConn = RunService.RenderStepped:Connect(function()
			if not root then return end

			local nearest = nil
			local dist = math.huge

			for _, p in pairs(Players:GetPlayers()) do
				if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
					local hrp = p.Character.HumanoidRootPart
					local d = (hrp.Position - root.Position).Magnitude

					if d < dist then
						dist = d
						nearest = hrp
					end
				end
			end

			if nearest then
				local velocity = nearest.AssemblyLinearVelocity
				local predictedPos = nearest.Position + velocity * 0.5

				arrowPart.CFrame = CFrame.new(nearest.Position, predictedPos)
				arrowPart.Position = nearest.Position + velocity.Unit * 2
			end
		end)

	else
		if predictConn then
			predictConn:Disconnect()
			predictConn = nil
		end

		if arrowPart then
			arrowPart:Destroy()
			arrowPart = nil
		end
	end
end
------------------------------------------------
-- UP / DOWN CONTROL 🔼🔽
------------------------------------------------

local udGui
local upConn
local downConn
local moveForce

local function toggleUpDown()
	if udGui then
		-- выключение
		if upConn then upConn:Disconnect() end
		if downConn then downConn:Disconnect() end
		if moveForce then moveForce:Destroy() end

		udGui:Destroy()
		udGui = nil
		return
	end

	-- создаём силу
	moveForce = Instance.new("BodyVelocity")
	moveForce.MaxForce = Vector3.new(0, 1e9, 0)
	moveForce.Velocity = Vector3.new(0,0,0)
	moveForce.Parent = root

	-- GUI
	udGui = Instance.new("ScreenGui")
	udGui.Name = "UpDownControl"
	udGui.Parent = player.PlayerGui

	-- кнопка ВВЕРХ
	local upBtn = Instance.new("TextButton")
	upBtn.Size = UDim2.new(0, 60, 0, 60)
	upBtn.Position = UDim2.new(1, -80, 0.6, -70)
	upBtn.Text = "▲"
	upBtn.TextScaled = true
	upBtn.BackgroundColor3 = Color3.fromRGB(50,50,50)
	upBtn.TextColor3 = Color3.new(1,1,1)
	upBtn.Parent = udGui
	Instance.new("UICorner", upBtn)

	-- кнопка ВНИЗ
	local downBtn = Instance.new("TextButton")
	downBtn.Size = UDim2.new(0, 60, 0, 60)
	downBtn.Position = UDim2.new(1, -80, 0.6, 10)
	downBtn.Text = "▼"
	downBtn.TextScaled = true
	downBtn.BackgroundColor3 = Color3.fromRGB(50,50,50)
	downBtn.TextColor3 = Color3.new(1,1,1)
	downBtn.Parent = udGui
	Instance.new("UICorner", downBtn)

	-- удержание вверх
	upBtn.MouseButton1Down:Connect(function()
		upConn = RunService.RenderStepped:Connect(function()
			if moveForce then
				moveForce.Velocity = Vector3.new(0, 80, 0)
			end
		end)
	end)

	upBtn.MouseButton1Up:Connect(function()
		if upConn then upConn:Disconnect() end
		moveForce.Velocity = Vector3.new(0,0,0)
	end)

	-- удержание вниз
	downBtn.MouseButton1Down:Connect(function()
		downConn = RunService.RenderStepped:Connect(function()
			if moveForce then
				moveForce.Velocity = Vector3.new(0, -80, 0)
			end
		end)
	end)

	downBtn.MouseButton1Up:Connect(function()
		if downConn then downConn:Disconnect() end
		moveForce.Velocity = Vector3.new(0,0,0)
	end)
end
------------------------------------------------
-- SHAKE ARM FIXED 🤪
------------------------------------------------

local armShakeOn = false
local armConn
local armJoint
local originalC0

local function getRightArmJoint()
	if not character then return nil end

	-- ищем Motor6D, который отвечает за правую руку
	for _, v in pairs(character:GetDescendants()) do
		if v:IsA("Motor6D") then
			if string.find(v.Name:lower(), "right") then
				return v
			end
		end
	end

	return nil
end

local function toggleArmShake()
	armShakeOn = not armShakeOn

	if armShakeOn then
		armJoint = getRightArmJoint()
		if not armJoint then return end

		originalC0 = armJoint.C0

		armConn = RunService.RenderStepped:Connect(function()
			if not armJoint then return end

			-- более резкая тряска
			local x = math.rad(math.random(-60,60))
			local y = math.rad(math.random(-60,60))
			local z = math.rad(math.random(-60,60))

			armJoint.C0 = originalC0 * CFrame.Angles(x, y, z)
		end)

	else
		if armConn then
			armConn:Disconnect()
			armConn = nil
		end

		if armJoint and originalC0 then
			armJoint.C0 = originalC0
		end
	end
end
------------------------------------------------
-- FORCE SIT 🪑
------------------------------------------------

local function forceSitNearest()
	if not root then return end

	local nearestHum = nil
	local dist = 12

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character then
			local hum = p.Character:FindFirstChild("Humanoid")
			local hrp = p.Character:FindFirstChild("HumanoidRootPart")

			if hum and hrp then
				local d = (hrp.Position - root.Position).Magnitude

				if d < dist then
					dist = d
					nearestHum = hum
				end
			end
		end
	end

	if nearestHum then
		-- пробуем посадить
		nearestHum.Sit = true
	end
end
------------------------------------------------
-- SAFE FLING 💥 (ты не улетаешь)
------------------------------------------------

local function safeFling()
	if not root then return end

	local target = nil
	local dist = 15

	-- ищем ближайшего
	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
			local hrp = p.Character.HumanoidRootPart
			local d = (hrp.Position - root.Position).Magnitude

			if d < dist then
				dist = d
				target = hrp
			end
		end
	end

	if not target then return end

	-- сохраняем позицию
	local oldCF = root.CFrame

	-- защита от отлёта
	root.AssemblyLinearVelocity = Vector3.zero
	root.AssemblyAngularVelocity = Vector3.zero

	-- создаём мощное вращение
	local bav = Instance.new("BodyAngularVelocity")
	bav.AngularVelocity = Vector3.new(99999,99999,99999)
	bav.MaxTorque = Vector3.new(1e9,1e9,1e9)
	bav.P = 1e6
	bav.Parent = root

	-- короткий fling
	for i = 1, 15 do
		root.CFrame = target.CFrame
		RunService.Heartbeat:Wait()
	end

	-- удаляем вращение
	bav:Destroy()

	-- возвращаем тебя назад
	root.CFrame = oldCF

	-- ещё раз гасим скорость (чтобы точно не улетел)
	root.AssemblyLinearVelocity = Vector3.zero
	root.AssemblyAngularVelocity = Vector3.zero
end
------------------------------------------------
-- AUTO HEAL 🩺
------------------------------------------------

local autoHealOn = false
local healConn

local function toggleAutoHeal()
	autoHealOn = not autoHealOn

	if autoHealOn then
		healConn = RunService.Heartbeat:Connect(function()
			if not humanoid then return end

			-- если здоровье меньше 50%
			if humanoid.Health < humanoid.MaxHealth * 0.5 then
				humanoid.Health = humanoid.MaxHealth
			end
		end)
	else
		if healConn then
			healConn:Disconnect()
			healConn = nil
		end
	end
end
-----------------
local infoGui

local function toggleInfoGui()
	if infoGui then
		infoGui:Destroy()
		infoGui = nil
		return
	end

	infoGui = Instance.new("ScreenGui")
	infoGui.Name = "InfoGui"
	infoGui.Parent = player:WaitForChild("PlayerGui")

	local frame = Instance.new("Frame")
	frame.Size = UDim2.new(0, 350, 0, 180)
	frame.Position = UDim2.new(0.5, -175, 0.5, -90)
	frame.BackgroundColor3 = Color3.fromRGB(0, 128, 0)
	frame.Parent = infoGui
	Instance.new("UICorner", frame).CornerRadius = UDim.new(0, 12)

	local layout = Instance.new("UIListLayout")
	layout.Padding = UDim.new(0, 10)
	layout.Parent = frame

	local function makeText(txt)
		local t = Instance.new("TextLabel")
		t.Size = UDim2.new(1, -20, 0, 50)
		t.BackgroundTransparency = 1
		t.TextColor3 = Color3.fromRGB(255,255,255)
		t.TextScaled = true
		t.Font = Enum.Font.GothamBold
		t.Text = txt
		t.Parent = frame
	end

	makeText("Telegram channel - @kanaltylenya")
	makeText("Tiktok channel - @tulenchik_dxs")
end
makeBtn("INFO").MouseButton1Click:Connect(toggleInfoGui)
local dances = {
	"rbxassetid://105248382902194", -- танец 1
	"rbxassetid://507771019",       -- танец 2
	"rbxassetid://507776043",       -- танец 3
	"rbxassetid://507777268"        -- танец 4
}

local currentDance = 1
local danceTrack
local dancing = false

makeBtn("DANCES 💃").MouseButton1Click:Connect(function()

	if not humanoid then return end

	-- если уже танцуешь → следующий танец
	if dancing then
		currentDance = currentDance + 1
		if currentDance > #dances then
			currentDance = 1
		end

		if danceTrack then
			danceTrack:Stop()
		end
	else
		dancing = true
	end

	-- запускаем танец
	local anim = Instance.new("Animation")
	anim.AnimationId = dances[currentDance]

	danceTrack = humanoid:LoadAnimation(anim)
	danceTrack.Looped = true
	danceTrack:Play()
end)
local speedLockOn = false
local function enableSpeedLock()
	speedLockOn = true

	local function applySpeed(char)
		local hum = char:WaitForChild("Humanoid")
		hum.WalkSpeed = 40

		-- если игра пытается сбросить скорость → возвращаем обратно
		hum:GetPropertyChangedSignal("WalkSpeed"):Connect(function()
			if speedLockOn and hum.WalkSpeed ~= 40 then
				hum.WalkSpeed = 40
			end
		end)
	end

	-- применяем к текущему персонажу
	if player.Character then
		applySpeed(player.Character)
	end

	-- применяем после смерти
	player.CharacterAdded:Connect(function(char)
		if speedLockOn then
			applySpeed(char)
		end
	end)
end

local function disableSpeedLock()
	speedLockOn = false

	if humanoid then
		humanoid.WalkSpeed = 16 -- стандарт
	end
end
local speedLockOn = false

local function enableSpeedLock()
	speedLockOn = true

	local function applySpeed(char)
		local hum = char:WaitForChild("Humanoid")
		hum.WalkSpeed = 40

		-- если игра пытается сбросить скорость → возвращаем обратно
		hum:GetPropertyChangedSignal("WalkSpeed"):Connect(function()
			if speedLockOn and hum.WalkSpeed ~= 40 then
				hum.WalkSpeed = 40
			end
		end)
	end

	-- применяем к текущему персонажу
	if player.Character then
		applySpeed(player.Character)
	end

	-- применяем после смерти
	player.CharacterAdded:Connect(function(char)
		if speedLockOn then
			applySpeed(char)
		end
	end)
end

local function disableSpeedLock()
	speedLockOn = false

	if humanoid then
		humanoid.WalkSpeed = 16 -- стандарт
	end
end

makeBtn("SPEED LOCK 40 ⚡").MouseButton1Click:Connect(function()
	if speedLockOn then
		disableSpeedLock()
	else
		enableSpeedLock()
	end
end)

--------------
local faceTpOn = false
local faceConn
local direction = 1

local function getNearestPlayer()
	local nearest = nil
	local dist = math.huge

	for _, p in pairs(Players:GetPlayers()) do
		if p ~= player and p.Character and p.Character:FindFirstChild("Head") then
			local head = p.Character.Head
			local d = (head.Position - root.Position).Magnitude

			if d < dist then
				dist = d
				nearest = p
			end
		end
	end

	return nearest
end

local function toggleFaceTP()
	faceTpOn = not faceTpOn

	if faceTpOn then
		faceConn = RunService.Heartbeat:Connect(function()
			if not root then return end

			local target = getNearestPlayer()
			if not target or not target.Character then return end

			local head = target.Character:FindFirstChild("Head")
			if not head then return end

			-- иногда меняем направление (эффект дергания)
			if math.random(1,5) == 1 then
				direction = -direction
			end

			-- позиция прямо перед лицом
			local facePos = head.Position + (head.CFrame.LookVector * 1.5)

			-- движение вперёд-назад
			local offset = head.CFrame.LookVector * direction * 1.2

			root.CFrame = CFrame.new(facePos + offset, head.Position)
		end)
	else
		if faceConn then
			faceConn:Disconnect()
			faceConn = nil
		end
	end
end

makeBtn("FACE TP ↔️ 😈").MouseButton1Click:Connect(toggleFaceTP)
------------------------------------------------
-- SUPER FLING 🌀💥 (КРУТИТСЯ И РАЗБРАСЫВАЕТ ВСЕХ)
------------------------------------------------

local superFlingOn = false
local superFlingConn
local spinForce

local function toggleSuperFling()
	if not root then return end

	superFlingOn = not superFlingOn

	if superFlingOn then
		-- мощное вращение
		spinForce = Instance.new("BodyAngularVelocity")
		spinForce.AngularVelocity = Vector3.new(0, 99999, 0)
		spinForce.MaxTorque = Vector3.new(1e9,1e9,1e9)
		spinForce.P = 1e6
		spinForce.Parent = root

		-- анти-падение
		local gyro = Instance.new("BodyGyro")
		gyro.Name = "SuperFlingGyro"
		gyro.MaxTorque = Vector3.new(1e9,1e9,1e9)
		gyro.P = 10000
		gyro.CFrame = root.CFrame
		gyro.Parent = root

		-- основная логика флинга
		superFlingConn = RunService.Heartbeat:Connect(function()
			if not root then return end

			for _, p in pairs(Players:GetPlayers()) do
				if p ~= player and p.Character and p.Character:FindFirstChild("HumanoidRootPart") then
					local hrp = p.Character.HumanoidRootPart

					local offset = hrp.Position - root.Position
					local dist = offset.Magnitude

					if dist < 10 and dist > 0 then
						local dir = offset.Unit

						-- телепорт внутрь игрока (ключ к флингу)
						root.CFrame = hrp.CFrame

						-- мощный отлет
						hrp.AssemblyLinearVelocity =
							dir * 200 + Vector3.new(0,100,0)
					end
				end
			end
		end)

	else
		-- выключение
		if superFlingConn then
			superFlingConn:Disconnect()
			superFlingConn = nil
		end

		if spinForce then
			spinForce:Destroy()
			spinForce = nil
		end

		local gyro = root:FindFirstChild("SuperFlingGyro")
		if gyro then gyro:Destroy() end
	end
end
----------
--------------------------------
-- BUTTONS
------------------------------------------------

makeBtn("FLY").MouseButton1Click:Connect(toggleFly)
makeBtn("SPIN").MouseButton1Click:Connect(toggleSpin)
makeBtn("SUPER SPIN").MouseButton1Click:Connect(toggleSuperSpin)
makeBtn("SPEED 40").MouseButton1Click:Connect(toggleSpeed)
makeBtn("NOCLIP").MouseButton1Click:Connect(toggleNoclip)
makeBtn("PUSH").MouseButton1Click:Connect(pushNearest)
makeBtn("TP LOOK").MouseButton1Click:Connect(tpLook)
makeBtn("DANCE").MouseButton1Click:Connect(toggleDance)
makeBtn("TP NEAREST").MouseButton1Click:Connect(tpToNearest)
makeBtn("LAUNCH ME").MouseButton1Click:Connect(launchSelf)
makeBtn("SUPER JUMP").MouseButton1Click:Connect(toggleJump)
makeBtn("TP ALL (LOOP)").MouseButton1Click:Connect(tpToAllPlayers)
makeBtn("TRAIL MODE").MouseButton1Click:Connect(toggleTrail)
makeBtn("GRAVITY SHIFT 🌙").MouseButton1Click:Connect(toggleGravityShift)
makeBtn("RAINBOW MODE 🌈").MouseButton1Click:Connect(toggleRainbow)
makeBtn("AUTO LAUNCH 🚀").MouseButton1Click:Connect(toggleAutoLaunch)
makeBtn("NO PLAYER COLLISION 🧍").MouseButton1Click:Connect(toggleNoPlayerCollision)
makeBtn("IMPACT ZONE 💥").MouseButton1Click:Connect(toggleImpactZone)
makeBtn("BOUNCE FAST ↔️").MouseButton1Click:Connect(toggleBounceMove)
makeBtn("PUSH 💥").MouseButton1Click:Connect(pushPlayers)
makeBtn("CHASE BOUNCE 🎯").MouseButton1Click:Connect(toggleChaseBounce)
makeBtn("CHASE BEHIND 🎯").MouseButton1Click:Connect(toggleChaseBehind)
makeBtn("CHASE BOUNCE 🎯↔️").MouseButton1Click:Connect(toggleChaseBounce)
makeBtn("BANG PEOPLE").MouseButton1Click:Connect(togglePlayerList)
makeBtn("BALL PHYSICS 🌍").MouseButton1Click:Connect(toggleBall)
makeBtn("REAL BALL 🟠").MouseButton1Click:Connect(toggleRealBall)
makeBtn("ULTRA BALL 😈🟠").MouseButton1Click:Connect(toggleUltraBall)
makeBtn("FLING 💥").MouseButton1Click:Connect(flingNearest)
makeBtn("ANTIFLING 🛡️").MouseButton1Click:Connect(toggleAntiFling)
makeBtn("FLING SAFE 🛡️💥").MouseButton1Click:Connect(toggleFlingSafe)
makeBtn("GRAVITY PUSH 🚀").MouseButton1Click:Connect(toggleGravityPush)
makeBtn("SELF ORBIT 🪐").MouseButton1Click:Connect(toggleSelfOrbit)
makeBtn("HEAL 🩺").MouseButton1Click:Connect(healPlayer)
makeBtn("LOOK NEAREST 👀").MouseButton1Click:Connect(toggleLookNearest)
makeBtn("RED PLAYERS 🔴").MouseButton1Click:Connect(toggleHighlightPlayers)
makeBtn("PREDICT MOVE 🔮").MouseButton1Click:Connect(togglePredictMove)
makeBtn("UP / DOWN 🔼🔽").MouseButton1Click:Connect(toggleUpDown)
makeBtn("SHAKE ARM 🤪").MouseButton1Click:Connect(toggleArmShake)
makeBtn("FORCE SIT 🪑").MouseButton1Click:Connect(forceSitNearest)
makeBtn("SAFE FLING 💥").MouseButton1Click:Connect(safeFling)
makeBtn("AUTO HEAL 🩺").MouseButton1Click:Connect(toggleAutoHeal)
makeBtn("SUPER FLING 🌀💥").MouseButton1Click:Connect(toggleSuperFling)
------------------------------------------------
-- AUTHOR TEXT (ПОД ЗАГОЛОВКОМ)
------------------------------------------------

local author = Instance.new("TextLabel")
author.Size = UDim2.new(1,0,0,30)
author.BackgroundTransparency = 1
author.Text = "Made by TheRealDuck228 🦆"
author.TextColor3 = Color3.fromRGB(200,200,200)
author.TextScaled = true
author.Font = Enum.Font.GothamBold

author.LayoutOrder = 1 -- сразу после header

author.Parent = panel