EKKO YIELD

--[[
	EKKO YIELD — Owner-Only Self Tools
	Place in: StarterPlayer > StarterPlayerScripts (as a LocalScript)

	This script ONLY affects the local player running it, and ONLY
	runs its effects if their UserId matches OWNER_ID below.
	It does not give you any power over other players.
--]]

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

local player = Players.LocalPlayer

----------------------------------------------------------------
-- OWNER CHECK
----------------------------------------------------------------
local OWNER_ID = 10687208976 -- your UserId, double check this is correct

if player.UserId ~= OWNER_ID then
	return -- script does nothing for anyone else
end

----------------------------------------------------------------
-- STATE
----------------------------------------------------------------
local state = {
	noclip = false,
	fly = false,
	flySpeed = 50,
	walkSpeed = 16,
	godMode = false,
	infiniteJump = false,
	glow = false,
	invisible = false,
	rainbow = false,
	ragdoll = false,
	size = 1,
}

local waypoints = {}

local character = player.Character
local humanoid, rootPart

local flyConnection
local noclipConnection
local godModeConnection
local rainbowConnection
local jumpConnection

local applyGlow, applyInvisible, applyRainbow, applySize, applyGodMode, setInfiniteJump, applyRagdoll

----------------------------------------------------------------
-- CHARACTER HANDLING
----------------------------------------------------------------
local function disconnectAll()
	if noclipConnection then noclipConnection:Disconnect() noclipConnection = nil end
	if godModeConnection then godModeConnection:Disconnect() godModeConnection = nil end
	if rainbowConnection then rainbowConnection:Disconnect() rainbowConnection = nil end
	if jumpConnection then jumpConnection:Disconnect() jumpConnection = nil end
end

local function applyNoclip(char, enabled)
	for _, part in ipairs(char:GetDescendants()) do
		if part:IsA("BasePart") then
			part.CanCollide = not enabled
		end
	end
end

local function setupCharacter(char)
	character = char
	humanoid = char:WaitForChild("Humanoid")
	rootPart = char:WaitForChild("HumanoidRootPart")

	disconnectAll()

	if state.noclip then
		applyNoclip(char, true)
		noclipConnection = char.DescendantAdded:Connect(function(descendant)
			if descendant:IsA("BasePart") then
				descendant.CanCollide = false
			end
		end)
	end

	if state.godMode then
		applyGodMode(true)
	end
	if state.infiniteJump then
		setInfiniteJump(true)
	end

	humanoid.WalkSpeed = state.walkSpeed

	if state.glow then applyGlow(true) end
	if state.invisible then applyInvisible(true) end
	if state.rainbow then applyRainbow(true) end
	applySize(state.size)
end

----------------------------------------------------------------
-- NOCLIP
----------------------------------------------------------------
local function setNoclip(enabled)
	state.noclip = enabled
	if not character then return end
	applyNoclip(character, enabled)

	if noclipConnection then noclipConnection:Disconnect() noclipConnection = nil end
	if enabled then
		noclipConnection = character.DescendantAdded:Connect(function(descendant)
			if descendant:IsA("BasePart") then
				descendant.CanCollide = false
			end
		end)
	end
end

----------------------------------------------------------------
-- FLY (smooth version — uses PlatformStand + AssemblyLinearVelocity
-- instead of BodyVelocity, which was fighting the Humanoid's own
-- physics state every frame and causing the jitter/lag)
----------------------------------------------------------------
local flyConn
local flyingNow = false

local function setFly(enabled)
	state.fly = enabled
	if flyConn then flyConn:Disconnect() flyConn = nil end

	if not enabled then
		flyingNow = false
		if humanoid then
			humanoid.PlatformStand = false
			humanoid:ChangeState(Enum.HumanoidStateType.GettingUp)
		end
		if rootPart then
			rootPart.AssemblyLinearVelocity = Vector3.new()
		end
		return
	end

	if not rootPart or not humanoid then return end

	flyingNow = true
	humanoid.PlatformStand = true -- stops Humanoid fighting our velocity every frame
	rootPart.AssemblyLinearVelocity = Vector3.new()

	flyConn = RunService.RenderStepped:Connect(function()
		if not flyingNow or not rootPart or not rootPart.Parent then return end

		local camera = Workspace.CurrentCamera
		local moveDir = Vector3.new()
		local cf = camera.CFrame

		if UserInputService:IsKeyDown(Enum.KeyCode.W) then moveDir += cf.LookVector end
		if UserInputService:IsKeyDown(Enum.KeyCode.S) then moveDir -= cf.LookVector end
		if UserInputService:IsKeyDown(Enum.KeyCode.A) then moveDir -= cf.RightVector end
		if UserInputService:IsKeyDown(Enum.KeyCode.D) then moveDir += cf.RightVector end
		if UserInputService:IsKeyDown(Enum.KeyCode.Space) then moveDir += Vector3.new(0, 1, 0) end
		if UserInputService:IsKeyDown(Enum.KeyCode.LeftControl) then moveDir -= Vector3.new(0, 1, 0) end

		if moveDir.Magnitude > 0 then
			moveDir = moveDir.Unit
		end

		-- Directly set velocity instead of going through a BodyMover —
		-- avoids the per-frame fight with Humanoid ground physics.
		rootPart.AssemblyLinearVelocity = moveDir * state.flySpeed
	end)
end

local function setFlySpeed(value)
	state.flySpeed = value
end

----------------------------------------------------------------
-- WALK SPEED
----------------------------------------------------------------
local function setWalkSpeed(value)
	state.walkSpeed = value
	if humanoid then humanoid.WalkSpeed = value end
end

----------------------------------------------------------------
-- GOD MODE
----------------------------------------------------------------
applyGodMode = function(enabled)
	state.godMode = enabled
	if godModeConnection then godModeConnection:Disconnect() godModeConnection = nil end
	if not humanoid then return end

	if enabled then
		humanoid.MaxHealth = math.huge
		humanoid.Health = math.huge
		godModeConnection = humanoid.HealthChanged:Connect(function()
			if state.godMode and humanoid.Health < humanoid.MaxHealth then
				humanoid.Health = humanoid.MaxHealth
			end
		end)
	else
		humanoid.MaxHealth = 100
		humanoid.Health = 100
	end
end

----------------------------------------------------------------
-- INFINITE JUMP
----------------------------------------------------------------
setInfiniteJump = function(enabled)
	state.infiniteJump = enabled
	if jumpConnection then jumpConnection:Disconnect() jumpConnection = nil end
	if enabled then
		jumpConnection = UserInputService.JumpRequest:Connect(function()
			if state.infiniteJump and humanoid then
				humanoid:ChangeState(Enum.HumanoidStateType.Jumping)
			end
		end)
	end
end

----------------------------------------------------------------
-- GLOW
----------------------------------------------------------------
applyGlow = function(enabled)
	state.glow = enabled
	if not rootPart then return end
	local existing = rootPart:FindFirstChild("EkkoYieldGlow")
	if enabled then
		if existing then return end
		local light = Instance.new("PointLight")
		light.Name = "EkkoYieldGlow"
		light.Brightness = 8
		light.Range = 16
		light.Color = Color3.fromRGB(150, 220, 255)
		light.Parent = rootPart
	else
		if existing then existing:Destroy() end
	end
end

----------------------------------------------------------------
-- INVISIBILITY (local-only, doesn't hide you from other players)
----------------------------------------------------------------
applyInvisible = function(enabled)
	state.invisible = enabled
	if not character then return end
	for _, part in ipairs(character:GetDescendants()) do
		if part:IsA("BasePart") or part:IsA("Decal") then
			part.LocalTransparencyModifier = enabled and 1 or 0
		end
	end
end

----------------------------------------------------------------
-- RAINBOW
----------------------------------------------------------------
applyRainbow = function(enabled)
	state.rainbow = enabled
	if rainbowConnection then rainbowConnection:Disconnect() rainbowConnection = nil end

	if not enabled then
		if character then
			for _, part in ipairs(character:GetDescendants()) do
				if part:IsA("BasePart") then
					part.Color = Color3.fromRGB(163, 162, 165)
				end
			end
		end
		return
	end

	if not character then return end
	local hue = 0
	rainbowConnection = RunService.Heartbeat:Connect(function(dt)
		if not character or not character.Parent then
			if rainbowConnection then
				rainbowConnection:Disconnect()
				rainbowConnection = nil
			end
			return
		end
		hue = (hue + dt * 0.5) % 1
		local color = Color3.fromHSV(hue, 1, 1)
		for _, part in ipairs(character:GetDescendants()) do
			if part:IsA("BasePart") then
				part.Color = color
			end
		end
	end)
end

----------------------------------------------------------------
-- RAGDOLL (self only)
----------------------------------------------------------------
applyRagdoll = function(enabled)
	state.ragdoll = enabled
	if not humanoid then return end
	if enabled then
		humanoid:ChangeState(Enum.HumanoidStateType.Ragdoll)
		humanoid:SetStateEnabled(Enum.HumanoidStateType.Ragdoll, true)
		humanoid.PlatformStand = true
	else
		humanoid.PlatformStand = false
		humanoid:ChangeState(Enum.HumanoidStateType.GettingUp)
	end
end

----------------------------------------------------------------
-- HEAL / RESPAWN
----------------------------------------------------------------
local function healSelf()
	if humanoid then
		humanoid.Health = humanoid.MaxHealth
	end
end

local function respawnSelf()
	if humanoid then
		humanoid.Health = 0
	end
end

----------------------------------------------------------------
-- WAYPOINTS
----------------------------------------------------------------
local function setWaypoint(name)
	if not rootPart then return end
	waypoints[name] = rootPart.CFrame
end

local function gotoWaypoint(name)
	local cf = waypoints[name]
	if cf and rootPart then
		rootPart.CFrame = cf
		return true
	end
	return false
end

----------------------------------------------------------------
-- SIZE
----------------------------------------------------------------
applySize = function(multiplier)
	state.size = multiplier
	if not humanoid then return end
	multiplier = math.clamp(multiplier, 0.2, 5)
	pcall(function()
		humanoid.BodyDepthScale.Value = multiplier
		humanoid.BodyWidthScale.Value = multiplier
		humanoid.BodyHeightScale.Value = multiplier
		humanoid.HeadScale.Value = multiplier
	end)
end

----------------------------------------------------------------
-- CHARACTER LIFECYCLE
----------------------------------------------------------------
player.CharacterAdded:Connect(setupCharacter)
if player.Character then
	setupCharacter(player.Character)
end

----------------------------------------------------------------
-- UI — styled to match reference: dark rows, red ON/OFF labels,
-- scrollable list, command bar at the bottom
----------------------------------------------------------------
local toggleRefs = {}

local function setToggleVisual(button, name, on)
	button.Text = name .. ": " .. (on and "ON" or "OFF")
	button.TextColor3 = Color3.fromRGB(255, 90, 90)
end

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

	local frame = Instance.new("Frame")
	frame.Size = UDim2.new(0, 230, 0, 420)
	frame.Position = UDim2.new(0, 16, 0.5, -210)
	frame.BackgroundColor3 = Color3.fromRGB(13, 14, 22)
	frame.BorderSizePixel = 0
	frame.Active = true
	frame.Draggable = true
	frame.Parent = gui

	local outline = Instance.new("UIStroke")
	outline.Color = Color3.fromRGB(40, 60, 110)
	outline.Thickness = 1
	outline.Parent = frame

	local corner = Instance.new("UICorner")
	corner.CornerRadius = UDim.new(0, 6)
	corner.Parent = frame

	local titleBar = Instance.new("Frame")
	titleBar.Size = UDim2.new(1, 0, 0, 32)
	titleBar.BackgroundColor3 = Color3.fromRGB(10, 11, 18)
	titleBar.BorderSizePixel = 0
	titleBar.Parent = frame

	local titleCorner = Instance.new("UICorner")
	titleCorner.CornerRadius = UDim.new(0, 6)
	titleCorner.Parent = titleBar

	local title = Instance.new("TextLabel")
	title.Size = UDim2.new(1, -10, 1, 0)
	title.Position = UDim2.new(0, 10, 0, 0)
	title.BackgroundTransparency = 1
	title.Text = "EKKO YIELD"
	title.TextColor3 = Color3.fromRGB(120, 170, 255)
	title.Font = Enum.Font.GothamBold
	title.TextSize = 16
	title.TextXAlignment = Enum.TextXAlignment.Left
	title.Parent = titleBar

	local scroll = Instance.new("ScrollingFrame")
	scroll.Size = UDim2.new(1, 0, 1, -68)
	scroll.Position = UDim2.new(0, 0, 0, 32)
	scroll.BackgroundTransparency = 1
	scroll.BorderSizePixel = 0
	scroll.ScrollBarThickness = 4
	scroll.CanvasSize = UDim2.new(0, 0, 0, 0)
	scroll.AutomaticCanvasSize = Enum.AutomaticSize.Y
	scroll.Parent = frame

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

	local padding = Instance.new("UIPadding")
	padding.PaddingTop = UDim.new(0, 6)
	padding.PaddingLeft = UDim.new(0, 6)
	padding.PaddingRight = UDim.new(0, 6)
	padding.PaddingBottom = UDim.new(0, 6)
	padding.Parent = scroll

	local function makeRow()
		local btn = Instance.new("TextButton")
		btn.Size = UDim2.new(1, 0, 0, 34)
		btn.BackgroundColor3 = Color3.fromRGB(22, 23, 33)
		btn.AutoButtonColor = false
		btn.Font = Enum.Font.GothamBold
		btn.TextSize = 13
		btn.Parent = scroll
		local rc = Instance.new("UICorner")
		rc.CornerRadius = UDim.new(0, 5)
		rc.Parent = btn
		return btn
	end

	local function makeToggleRow(name, onChange)
		local btn = makeRow()
		local on = false
		setToggleVisual(btn, name, on)
		btn.MouseButton1Click:Connect(function()
			on = not on
			setToggleVisual(btn, name, on)
			onChange(on)
		end)
		toggleRefs[name] = {
			set = function(value)
				on = value
				setToggleVisual(btn, name, on)
				onChange(on)
			end
		}
		return btn
	end

	local function makeActionRow(name, onClick)
		local btn = makeRow()
		btn.Text = name
		btn.TextColor3 = Color3.fromRGB(220, 220, 230)
		btn.MouseButton1Click:Connect(onClick)
		return btn
	end

	makeToggleRow("Fly", setFly)
	makeToggleRow("Noclip", setNoclip)
	makeToggleRow("God Mode", applyGodMode)
	makeToggleRow("Invisible", applyInvisible)
	makeToggleRow("Infinite Jump", setInfiniteJump)
	makeToggleRow("Ragdoll", applyRagdoll)
	makeToggleRow("Glow", applyGlow)
	makeToggleRow("Rainbow", applyRainbow)
	makeActionRow("Respawn", respawnSelf)
	makeActionRow("Heal Me", healSelf)
	makeActionRow("Set Waypoint", function()
		setWaypoint("default")
	end)
	makeActionRow("Go To Waypoint", function()
		gotoWaypoint("default")
	end)

	local commandBox = Instance.new("TextBox")
	commandBox.Size = UDim2.new(1, -12, 0, 28)
	commandBox.Position = UDim2.new(0, 6, 1, -34)
	commandBox.BackgroundColor3 = Color3.fromRGB(10, 11, 18)
	commandBox.TextColor3 = Color3.fromRGB(200, 200, 210)
	commandBox.PlaceholderText = "Type :command here..."
	commandBox.PlaceholderColor3 = Color3.fromRGB(110, 110, 120)
	commandBox.Font = Enum.Font.Gotham
	commandBox.TextSize = 13
	commandBox.ClearTextOnFocus = false
	commandBox.TextXAlignment = Enum.TextXAlignment.Left
	commandBox.Parent = frame
	local cbCorner = Instance.new("UICorner")
	cbCorner.CornerRadius = UDim.new(0, 5)
	cbCorner.Parent = commandBox
	local cbPad = Instance.new("UIPadding")
	cbPad.PaddingLeft = UDim.new(0, 8)
	cbPad.Parent = commandBox

	local function runCommand(raw)
		raw = raw:gsub("^:", ""):gsub("^%s+", ""):gsub("%s+$", "")
		if raw == "" then return end

		local parts = {}
		for word in raw:gmatch("%S+") do table.insert(parts, word) end
		local cmd = parts[1] and parts[1]:lower()
		local arg = parts[2]

		if cmd == "speed" or cmd == "walkspeed" then
			local v = tonumber(arg)
			if v then setWalkSpeed(v) end
		elseif cmd == "flyspeed" then
			local v = tonumber(arg)
			if v then setFlySpeed(v) end
		elseif cmd == "size" then
			local v = tonumber(arg)
			if v then applySize(v) end
		elseif cmd == "fly" then
			toggleRefs["Fly"].set(arg ~= "off")
		elseif cmd == "noclip" then
			toggleRefs["Noclip"].set(arg ~= "off")
		elseif cmd == "god" or cmd == "godmode" then
			toggleRefs["God Mode"].set(arg ~= "off")
		elseif cmd == "invisible" or cmd == "invis" then
			toggleRefs["Invisible"].set(arg ~= "off")
		elseif cmd == "infinitejump" or cmd == "infjump" then
			toggleRefs["Infinite Jump"].set(arg ~= "off")
		elseif cmd == "ragdoll" then
			toggleRefs["Ragdoll"].set(arg ~= "off")
		elseif cmd == "glow" then
			toggleRefs["Glow"].set(arg ~= "off")
		elseif cmd == "rainbow" then
			toggleRefs["Rainbow"].set(arg ~= "off")
		elseif cmd == "respawn" then
			respawnSelf()
		elseif cmd == "heal" then
			healSelf()
		elseif cmd == "setwp" then
			setWaypoint(arg or "default")
		elseif cmd == "gotowp" or cmd == "goto" then
			gotoWaypoint(arg or "default")
		end
	end

	commandBox.FocusLost:Connect(function(enterPressed)
		if enterPressed then
			runCommand(commandBox.Text)
			commandBox.Text = ""
		end
	end)
end

buildUI()

print("[EKKO YIELD] Loaded for owner: " .. player.Name)