-- !!! PUT ON AUTOEXEC OF YOUR EXECUTOR !!!

local Players = game:GetService("Players")
local Workspace = game:GetService("Workspace")
local UserInputService = game:GetService("UserInputService")
local VirtualInputManager = game:GetService("VirtualInputManager")
local TweenService = game:GetService("TweenService")
local RunService = game:GetService("RunService")
local TeleportService = game:GetService("TeleportService")
local HttpService = game:GetService("HttpService")
local CoreGui = game:GetService("CoreGui")

local LOCAL = Players.LocalPlayer

----------------------------------------------------------------
-- GOD MODE
----------------------------------------------------------------

loadstring(game:HttpGet("https://loser-scripts.pages.dev/god-mode"))()

----------------------------------------------------------------
-- config
----------------------------------------------------------------
local HIGHLIGHT_COLOR = Color3.fromRGB(0, 255, 140)
local STEALS_PER_CYCLE = 2
local POST_SAFE_WAIT = 2.0
local START_DELAY = 3.0
local BETWEEN_STEAL_WAIT = 1.0

local STEAL_COOLDOWN = 5.0
local AFTER_SUCCESS_EXTRA = 1.0
local AFTER_FAIL_EXTRA = 3.0
local HOLD_TIME = 3.40
local POST_HOLD_WAIT = 0.45

local WALK_SPEED = 150
local WALK_TIMEOUT = 45
local APPROACH_DIST = 28
local REACH_CHEST = 5
local REACH_RAFT = 7
local WATER_FLOOR_Y = 4.64
local WATER_FLOOR_SIZE = Vector3.new(24, 2, 24)
local LIFT_ASSIST = 28
local WALK_HEIGHT_OFFSET = 50
local POST_STEAL_TWEEN_UP = 50
local POST_STEAL_TWEEN_TIME = 0.35
local TP_RAFT_TWEEN_SPEED = 120
local TWEEN_MIN_TIME = 0.08
local TWEEN_MAX_TIME = 2.5

local CHEST_TWEEN_DIST = 20
local CHEST_TWEEN_SPEED = 120

local SAFE_UP = 150
local SAFE_SOLID_SIZE = Vector3.new(1000, 4, 1000)
local SAFE_HOLD_SURFACE = 3
local SAFE_DRIVE_SPEED = 80
local SAFE_DRIVE_SPRINT = 140
local SAFE_FOLLOW_PAD = true

local E_KEY = Enum.KeyCode.E
local E_VK = 0x45
local RESOURCES = { "Metal", "Prefab", "Wood", "Scrap" }

local HOP_CURSOR = ""
local HOP_RETRIES = 8

----------------------------------------------------------------
-- state
----------------------------------------------------------------
local farming = false
local farmToken = 0
local statusLabel
local farmBtn

local stealLock = false
local stealCount = 0
local failStreak = 0

local noclipConn = nil
local waterFloor = nil
local waterFloorConn = nil
local safeSolidFloor = nil
local raftDriveConn = nil
local raftPosTrackerConn = nil
local safeFloorY = nil
local safeSurfaceY = nil
local safeYaw = 0
local savedWalkSpeed = 16
local safeOriginY = nil
local activeTween = nil
local safeActive = false

local savedRaftPos = nil
local savedRaftPosAt = 0

local stealCamConn = nil
local STEAL_CAM_HEIGHT = 10
local STEAL_CAM_BACK = 0

local current = {
	username = nil,
	highlight = nil,
	selection = nil,
	billboard = nil,
	chest = nil,
}

----------------------------------------------------------------
local function getUiParent()
	local ok, hui = pcall(function()
		return gethui and gethui()
	end)
	if ok and hui then return hui end
	if pcall(function() return CoreGui end) then return CoreGui end
	return LOCAL:WaitForChild("PlayerGui")
end
local UI_PARENT = getUiParent()

local function setStatus(t)
	if statusLabel then statusLabel.Text = t end
end

local function stillFarming(token)
	return farming and token == farmToken
end

----------------------------------------------------------------
local function styleAsWater(part)
	part.Name = "Water"
	part.Material = Enum.Material.Water
	part.Color = Color3.fromRGB(0, 120, 200)
	part.Transparency = 0.85
	part.Reflectance = 0.1
	part.Anchored = true
	part.CanCollide = true
	part.CanQuery = true
	part.CanTouch = true
	part.CastShadow = false
	part.Massless = true
	pcall(function()
		part:SetAttribute("Water", true)
		part:SetAttribute("IsWater", true)
	end)
end

----------------------------------------------------------------
-- character helpers
----------------------------------------------------------------
local function getChar()
	return LOCAL.Character
end

local function getHRP()
	local c = getChar()
	return c and c:FindFirstChild("HumanoidRootPart") or nil
end

local function getHumanoid()
	local c = getChar()
	return c and c:FindFirstChildOfClass("Humanoid") or nil
end

local function getHead()
	local c = getChar()
	if not c then return nil end
	return c:FindFirstChild("Head") or c:FindFirstChild("HumanoidRootPart")
end

----------------------------------------------------------------
-- steal camera
----------------------------------------------------------------
local function stopStealCamera()
	if stealCamConn then
		pcall(function() stealCamConn:Disconnect() end)
		stealCamConn = nil
	end
	pcall(function()
		local cam = Workspace.CurrentCamera
		if not cam then return end
		cam.CameraType = Enum.CameraType.Custom
		local hum = getHumanoid()
		if hum then
			cam.CameraSubject = hum
		end
	end)
end

local function startStealCamera()
	stopStealCamera()
	stealCamConn = RunService.RenderStepped:Connect(function()
		local cam = Workspace.CurrentCamera
		if not cam then return end
		local head = getHead()
		local hrp = getHRP()
		local target = head or hrp
		if not target then return end
		local lookAt = target.Position
		local back = Vector3.new(0, 0, 1)
		if hrp then
			local flat = Vector3.new(hrp.CFrame.LookVector.X, 0, hrp.CFrame.LookVector.Z)
			if flat.Magnitude > 0.05 then
				back = -flat.Unit
			end
		end
		local camPos = lookAt + Vector3.new(0, STEAL_CAM_HEIGHT, 0) + back * STEAL_CAM_BACK
		cam.CameraType = Enum.CameraType.Scriptable
		cam.CFrame = CFrame.lookAt(camPos, lookAt)
	end)
end

----------------------------------------------------------------
-- helpers
----------------------------------------------------------------
local function getAmount(raft, resource)
	local ok, result = pcall(function()
		return raft.Chest.Primary.BillboardGui.Holder[resource].Holder.Amount.Text
	end)
	if not ok or result == nil then return 0, "?" end
	local n = tonumber(result)
	if n then return n, tostring(n) end
	local digits = string.match(tostring(result), "[-%d%.]+")
	n = digits and tonumber(digits) or 0
	return n, tostring(result)
end

local function raftTotal(raft)
	local total = 0
	for _, res in ipairs(RESOURCES) do
		total += select(1, getAmount(raft, res))
	end
	return total
end

local function isShielded(raft)
	if not raft then return false end
	local v
	pcall(function() v = raft:GetAttribute("ShieldActive") end)
	return v == true
end

local function doJump()
	local hum = getHumanoid()
	if not hum then return end
	pcall(function()
		hum.Sit = false
		hum.PlatformStand = false
		hum.Jump = true
	end)
	task.wait(0.2)
end

local function chestPos(chest)
	if not chest then return nil end
	if chest:IsA("Model") and chest.PrimaryPart then return chest.PrimaryPart.Position end
	local p = chest:FindFirstChild("Primary")
	if p and p:IsA("BasePart") then return p.Position end
	local b = chest:FindFirstChildWhichIsA("BasePart", true)
	return b and b.Position or nil
end

local function pickAnchor(chest)
	local primary = chest:FindFirstChild("Primary")
	if primary and primary:IsA("BasePart") then return primary end
	if chest:IsA("Model") and chest.PrimaryPart then return chest.PrimaryPart end
	return chest:FindFirstChildWhichIsA("BasePart", true)
end

local function getLocalRaft()
	local rafts = Workspace:FindFirstChild("Rafts")
	if not rafts then return nil end
	return rafts:FindFirstChild("Raft_" .. LOCAL.Name)
end

local function getLocalRaftWalkTargetLive()
	local raft = getLocalRaft()
	if not raft then return nil end
	local chest = raft:FindFirstChild("Chest")
	local function underChest(p)
		return chest and p:IsDescendantOf(chest)
	end
	for _, name in ipairs({ "Base", "Floor", "Platform", "Hull", "Deck", "Root", "Main" }) do
		local p = raft:FindFirstChild(name, true)
		if p and p:IsA("BasePart") and not underChest(p) then
			return p.Position
		end
	end
	if raft:IsA("Model") then
		if raft.PrimaryPart and not underChest(raft.PrimaryPart) then
			return raft.PrimaryPart.Position
		end
		local ok, cf = pcall(function() return raft:GetPivot() end)
		if ok and cf then return cf.Position end
	end
	for _, p in ipairs(raft:GetDescendants()) do
		if p:IsA("BasePart") and not underChest(p) then
			return p.Position
		end
	end
	if raft:IsA("Model") then
		local ok, cf = pcall(function() return raft:GetPivot() end)
		if ok and cf then return cf.Position end
	end
	return nil
end

local function rememberRaftPos(pos)
	if not pos then return end
	savedRaftPos = Vector3.new(pos.X, pos.Y, pos.Z)
	savedRaftPosAt = tick()
end

local function getLocalRaftWalkTarget()
	local live = getLocalRaftWalkTargetLive()
	if live then
		rememberRaftPos(live)
		return live
	end
	return savedRaftPos
end

local function getLocalRaftRoot()
	local raft = getLocalRaft()
	if not raft then return nil end
	if raft:IsA("Model") and raft.PrimaryPart then return raft.PrimaryPart end
	for _, name in ipairs({ "Base", "Floor", "Platform", "Hull", "Deck", "Root", "Main", "Primary" }) do
		local p = raft:FindFirstChild(name, true)
		if p and p:IsA("BasePart") then return p end
	end
	return raft:FindFirstChildWhichIsA("BasePart", true)
end

local function isRaftClientDriven()
	local raft = getLocalRaft()
	if not raft then return false end
	local v
	pcall(function() v = raft:GetAttribute("ClientDriven") end)
	return v == true
end

local function findCaptainChair()
	local raft = getLocalRaft()
	if not raft then return nil end
	local placed = raft:FindFirstChild("PlacedObjects")
	if not placed then return nil end
	for _, ch in ipairs(placed:GetChildren()) do
		if string.sub(ch.Name, 1, 13) == "CaptainChair_" then
			return ch
		end
	end
	for _, d in ipairs(placed:GetDescendants()) do
		if string.sub(d.Name, 1, 13) == "CaptainChair_" then
			return d
		end
	end
	return nil
end

local function instanceWorldPos(inst)
	if not inst then return nil end
	if inst:IsA("Model") then
		if inst.PrimaryPart then return inst.PrimaryPart.Position end
		local ok, cf = pcall(function() return inst:GetPivot() end)
		if ok and cf then return cf.Position end
		local p = inst:FindFirstChildWhichIsA("BasePart", true)
		return p and p.Position or nil
	end
	if inst:IsA("BasePart") then return inst.Position end
	local p = inst:FindFirstChildWhichIsA("BasePart", true)
	return p and p.Position or nil
end

local function readHoldTime(chest)
	local t = HOLD_TIME
	if not chest then return t end
	local prompt
	local primary = chest:FindFirstChild("Primary")
	if primary then prompt = primary:FindFirstChild("StealPrompt") end
	if not (prompt and prompt:IsA("ProximityPrompt")) then
		for _, d in ipairs(chest:GetDescendants()) do
			if d:IsA("ProximityPrompt") then
				local n = d.Name:lower()
				if d.Name == "StealPrompt" or n:find("steal") then
					prompt = d
					break
				end
			end
		end
	end
	if prompt then
		pcall(function()
			if prompt.HoldDuration and prompt.HoldDuration > 0 then
				t = prompt.HoldDuration + 0.35
			end
		end)
	end
	return t
end

local function flatDist(a, b)
	local dx, dz = a.X - b.X, a.Z - b.Z
	return math.sqrt(dx * dx + dz * dz)
end

local function startRaftPosTracker()
	if raftPosTrackerConn then return end
	raftPosTrackerConn = RunService.Heartbeat:Connect(function()
		local live = getLocalRaftWalkTargetLive()
		if live then rememberRaftPos(live) end
	end)
end

local function waitForChar(timeout)
	timeout = timeout or 20
	local t0 = tick()
	while tick() - t0 < timeout do
		local hrp = getHRP()
		local hum = getHumanoid()
		if hrp and hum and hum.Health > 0 then
			return true
		end
		task.wait(0.2)
	end
	return getHRP() ~= nil
end

local function waitForLocalRaft(timeout)
	timeout = timeout or 25
	local t0 = tick()
	while tick() - t0 < timeout do
		if getLocalRaft() and findCaptainChair() then
			return true
		end
		task.wait(0.25)
	end
	return getLocalRaft() ~= nil
end

----------------------------------------------------------------
-- tweens
----------------------------------------------------------------
local function cancelTween()
	if activeTween then
		pcall(function() activeTween:Cancel() end)
		activeTween = nil
	end
	local hrp = getHRP()
	if hrp then
		pcall(function()
			hrp.AssemblyLinearVelocity = Vector3.zero
			hrp.AssemblyAngularVelocity = Vector3.zero
		end)
	end
end

local function tweenTimeForDistance(dist, speed)
	speed = speed or WALK_SPEED
	return math.clamp(dist / math.max(speed, 1), TWEEN_MIN_TIME, TWEEN_MAX_TIME)
end

local function tweenHRPTo(pos, time, easing)
	local hrp = getHRP()
	if not hrp or not pos then return false end
	cancelTween()
	time = time or tweenTimeForDistance((hrp.Position - pos).Magnitude)
	easing = easing or Enum.EasingStyle.Quad
	pcall(function()
		hrp.AssemblyLinearVelocity = Vector3.zero
		hrp.AssemblyAngularVelocity = Vector3.zero
		local from = hrp.Position
		local flat = Vector3.new(pos.X - from.X, 0, pos.Z - from.Z)
		local look = hrp.CFrame
		if flat.Magnitude > 0.05 then
			look = CFrame.new(from, from + flat)
		end
		local goalCF = CFrame.new(pos) * (look - look.Position)
		local tw = TweenService:Create(
			hrp,
			TweenInfo.new(time, easing, Enum.EasingDirection.Out),
			{ CFrame = goalCF }
		)
		activeTween = tw
		tw:Play()
		tw.Completed:Wait()
		if activeTween == tw then activeTween = nil end
		hrp.AssemblyLinearVelocity = Vector3.zero
		hrp.AssemblyAngularVelocity = Vector3.zero
	end)
	return true
end

local function tweenUp(studs, time)
	local hrp = getHRP()
	if not hrp then return end
	tweenHRPTo(hrp.Position + Vector3.new(0, studs or POST_STEAL_TWEEN_UP, 0), time or POST_STEAL_TWEEN_TIME, Enum.EasingStyle.Quad)
end

local function walkPlaneY()
	return WATER_FLOOR_Y + WALK_HEIGHT_OFFSET + 3
end

----------------------------------------------------------------
-- body / noclip
----------------------------------------------------------------
local function resetBody()
	local hrp = getHRP()
	local hum = getHumanoid()
	if hrp then
		pcall(function()
			hrp.Anchored = false
			hrp.AssemblyAngularVelocity = Vector3.zero
		end)
	end
	if hum then
		pcall(function()
			hum.PlatformStand = false
			hum.Sit = false
			hum.Jump = false
			hum.AutoRotate = true
		end)
	end
end

local function setNoclip(on)
	local char = getChar()
	if not char then return end
	for _, p in ipairs(char:GetDescendants()) do
		if p:IsA("BasePart") then
			pcall(function()
				if on then
					p.CanCollide = false
				else
					if p.Name == "HumanoidRootPart" or p.Name == "Torso"
						or p.Name == "UpperTorso" or p.Name == "LowerTorso" or p.Name == "Head" then
						p.CanCollide = true
					end
				end
			end)
		end
	end
end

local function stopNoclip()
	if noclipConn then
		noclipConn:Disconnect()
		noclipConn = nil
	end
	setNoclip(false)
end

local function startNoclip()
	stopNoclip()
	setNoclip(true)
	noclipConn = RunService.Stepped:Connect(function()
		setNoclip(true)
	end)
end

----------------------------------------------------------------
-- water floor
----------------------------------------------------------------
local function destroyWaterFloor()
	if waterFloorConn then
		waterFloorConn:Disconnect()
		waterFloorConn = nil
	end
	if waterFloor then
		pcall(function() waterFloor:Destroy() end)
		waterFloor = nil
	end
end

local function startWaterFloor()
	if waterFloor and waterFloor.Parent then return end
	destroyWaterFloor()
	local part = Instance.new("Part")
	part.Size = WATER_FLOOR_SIZE
	styleAsWater(part)
	part.Name = "Water"
	part.Parent = Workspace
	waterFloor = part
	local half = WATER_FLOOR_SIZE.Y / 2
	local floorY = WATER_FLOOR_Y + WALK_HEIGHT_OFFSET
	waterFloorConn = RunService.Heartbeat:Connect(function()
		local hrp = getHRP()
		if not hrp or not waterFloor then return end
		local p = hrp.Position
		local raftPos = getLocalRaftWalkTarget()
		local x, z = p.X, p.Z
		if raftPos and flatDist(p, raftPos) < 40 then
			x = (p.X + raftPos.X) * 0.5
			z = (p.Z + raftPos.Z) * 0.5
		end
		waterFloor.CFrame = CFrame.new(x, floorY - half, z)
	end)
end

local function stopWaterFloor()
	destroyWaterFloor()
end

local function keepOnWaterPlane(enabled)
	if not enabled then return end
	local hrp = getHRP()
	if not hrp then return end
	local p = hrp.Position
	local plane = walkPlaneY()
	if p.Y < plane - 2 or p.Y > plane + 6 then
		pcall(function()
			hrp.CFrame = CFrame.new(p.X, plane, p.Z)
			local v = hrp.AssemblyLinearVelocity
			hrp.AssemblyLinearVelocity = Vector3.new(v.X, 0, v.Z)
		end)
	end
end

local function beginTravel()
	cancelTween()
	local hum = getHumanoid()
	if hum then
		pcall(function()
			savedWalkSpeed = hum.WalkSpeed
			if savedWalkSpeed < 1 then savedWalkSpeed = 16 end
			hum.WalkSpeed = WALK_SPEED
			hum.PlatformStand = false
			hum.Sit = false
			hum.AutoRotate = true
			hum.UseJumpPower = true
			hum.JumpPower = math.max(hum.JumpPower, 50)
		end)
	end
	startNoclip()
end

local function endTravel()
	cancelTween()
	stopNoclip()
	stopWaterFloor()
	local hum = getHumanoid()
	local hrp = getHRP()
	if hum then
		pcall(function()
			if hrp then hum:MoveTo(hrp.Position) end
			hum.WalkSpeed = savedWalkSpeed or 16
			hum.Jump = false
		end)
	end
	if hrp then
		pcall(function()
			hrp.AssemblyLinearVelocity = Vector3.zero
			hrp.AssemblyAngularVelocity = Vector3.zero
		end)
	end
	resetBody()
end

local function tpTo(pos)
	local hrp = getHRP()
	if not hrp or not pos then return false end
	cancelTween()
	pcall(function()
		hrp.AssemblyLinearVelocity = Vector3.zero
		hrp.AssemblyAngularVelocity = Vector3.zero
	end)
	hrp.CFrame = CFrame.new(pos + Vector3.new(0, 3, 0))
	pcall(function()
		hrp.AssemblyLinearVelocity = Vector3.zero
		hrp.AssemblyAngularVelocity = Vector3.zero
	end)
	return true
end

----------------------------------------------------------------
-- safe pad
----------------------------------------------------------------
local function isKeyDown(key)
	return UserInputService:IsKeyDown(key)
end

local function stopRaftDrive()
	if raftDriveConn then
		raftDriveConn:Disconnect()
		raftDriveConn = nil
	end
end

local function startRaftDrive()
	stopRaftDrive()
	if not isRaftClientDriven() then return end

	local raft = getLocalRaft()
	if raft then
		pcall(function()
			local pivot = raft:IsA("Model") and raft:GetPivot() or getLocalRaftRoot().CFrame
			local look = pivot.LookVector
			safeYaw = math.atan2(-look.X, -look.Z)
		end)
	end

	raftDriveConn = RunService.Heartbeat:Connect(function(dt)
		if not safeActive or not safeSurfaceY then return end
		if not isRaftClientDriven() then return end
		if stealLock then return end
		dt = math.clamp(dt or 0.016, 0, 0.05)

		local raft = getLocalRaft()
		if not raft then return end
		local live = getLocalRaftWalkTargetLive()
		if live then rememberRaftPos(live) end

		local cam = Workspace.CurrentCamera
		local cf = cam and cam.CFrame or CFrame.Angles(0, safeYaw, 0)
		local forward = Vector3.new(cf.LookVector.X, 0, cf.LookVector.Z)
		if forward.Magnitude < 0.05 then
			forward = Vector3.new(-math.sin(safeYaw), 0, -math.cos(safeYaw))
		else
			forward = forward.Unit
		end
		local right = Vector3.new(cf.RightVector.X, 0, cf.RightVector.Z)
		if right.Magnitude < 0.05 then
			right = Vector3.new(forward.Z, 0, -forward.X)
		else
			right = right.Unit
		end

		local move = Vector3.zero
		if isKeyDown(Enum.KeyCode.W) then move = move + forward end
		if isKeyDown(Enum.KeyCode.S) then move = move - forward end
		if isKeyDown(Enum.KeyCode.A) then move = move - right end
		if isKeyDown(Enum.KeyCode.D) then move = move + right end

		local speed = SAFE_DRIVE_SPEED
		if isKeyDown(Enum.KeyCode.LeftShift) or isKeyDown(Enum.KeyCode.RightShift) then
			speed = SAFE_DRIVE_SPRINT
		end

		local dx, dz = 0, 0
		if move.Magnitude > 0 then
			move = move.Unit
			dx = move.X * speed * dt
			dz = move.Z * speed * dt
			safeYaw = math.atan2(-move.X, -move.Z)
		end

		pcall(function()
			local pivot
			if raft:IsA("Model") then
				pivot = raft:GetPivot()
			else
				local root = getLocalRaftRoot()
				if not root then return end
				pivot = root.CFrame
			end
			local pos = pivot.Position
			local newCf = CFrame.new(pos.X + dx, safeSurfaceY, pos.Z + dz) * CFrame.Angles(0, safeYaw, 0)
			if raft:IsA("Model") then
				raft:PivotTo(newCf)
			else
				local root = getLocalRaftRoot()
				if root then root.CFrame = newCf end
			end
			local root = getLocalRaftRoot()
			if root then
				root.AssemblyLinearVelocity = Vector3.zero
				root.AssemblyAngularVelocity = Vector3.zero
			end
			rememberRaftPos(Vector3.new(pos.X + dx, safeSurfaceY, pos.Z + dz))
		end)

		local hrp = getHRP()
		if hrp then
			pcall(function()
				local p = hrp.Position
				if p.Y < safeSurfaceY - 2 or p.Y > safeSurfaceY + 12 then
					hrp.CFrame = CFrame.new(p.X, safeSurfaceY + 4, p.Z)
				end
				hrp.AssemblyLinearVelocity = Vector3.zero
			end)
		end

		if SAFE_FOLLOW_PAD and safeSolidFloor then
			local raftPos = getLocalRaftWalkTarget()
			local hrp2 = getHRP()
			local x = raftPos and raftPos.X or (hrp2 and hrp2.Position.X)
			local z = raftPos and raftPos.Z or (hrp2 and hrp2.Position.Z)
			if x then
				safeSolidFloor.CFrame = CFrame.new(x, safeFloorY - SAFE_SOLID_SIZE.Y / 2, z)
			end
		end
	end)
end

local function destroySafeFloor()
	stopRaftDrive()
	if safeSolidFloor then
		pcall(function() safeSolidFloor:Destroy() end)
		safeSolidFloor = nil
	end
	safeFloorY = nil
	safeSurfaceY = nil
end

local function startSafeFloor(floorY)
	destroySafeFloor()
	safeFloorY = floorY
	safeSurfaceY = floorY + SAFE_HOLD_SURFACE

	local function getXZ()
		local raftPos = getLocalRaftWalkTarget()
		if raftPos then return raftPos.X, raftPos.Z end
		local hrp = getHRP()
		if hrp then return hrp.Position.X, hrp.Position.Z end
		return nil, nil
	end

	local x, z = getXZ()
	if not x then return end

	local solid = Instance.new("Part")
	solid.Name = "SafeSolidFloor"
	solid.Size = SAFE_SOLID_SIZE
	solid.Anchored = true
	solid.CanCollide = true
	solid.CanQuery = false
	solid.CanTouch = false
	solid.Transparency = 1
	solid.CastShadow = false
	solid.Material = Enum.Material.SmoothPlastic
	solid.CFrame = CFrame.new(x, floorY - SAFE_SOLID_SIZE.Y / 2, z)
	solid.Parent = Workspace
	safeSolidFloor = solid
	startRaftDrive()
end

----------------------------------------------------------------
-- E key
----------------------------------------------------------------
local BACKEND = (typeof(keypress) == "function") and "keypress" or "vim"

local function keyDown()
	if BACKEND == "keypress" then
		pcall(keypress, E_VK)
	else
		pcall(function()
			VirtualInputManager:SendKeyEvent(true, E_KEY, false, game)
		end)
	end
end

local function keyUp()
	if BACKEND == "keypress" then
		pcall(keyrelease, E_VK)
	else
		pcall(function()
			VirtualInputManager:SendKeyEvent(false, E_KEY, false, game)
		end)
	end
end

local function releaseE()
	for _ = 1, 5 do
		keyUp()
		task.wait()
	end
end

local function tapE()
	releaseE()
	task.wait(0.05)
	keyDown()
	task.wait(0.12)
	releaseE()
end

local function holdE(duration, label)
	duration = math.max(duration or HOLD_TIME, 0.5)
	setStatus(label or string.format("E %.1fs", duration))
	cancelTween()
	releaseE()
	task.wait(0.10)

	local hum = getHumanoid()
	local hrp = getHRP()
	if hum and hrp then
		pcall(function()
			hum:MoveTo(hrp.Position)
			hum.WalkSpeed = 0
			hum.Jump = false
		end)
	end
	if hrp then
		pcall(function()
			hrp.AssemblyLinearVelocity = Vector3.zero
			hrp.AssemblyAngularVelocity = Vector3.zero
		end)
	end

	keyDown()
	local t0 = tick()
	local nextAssert = t0 + 1.5
	while tick() - t0 < duration do
		hum = getHumanoid()
		if hum and hum.Health <= 0 then break end
		hrp = getHRP()
		if hrp then
			pcall(function()
				hrp.AssemblyLinearVelocity = Vector3.zero
				hrp.AssemblyAngularVelocity = Vector3.zero
			end)
		end
		if tick() >= nextAssert then
			keyDown()
			nextAssert = tick() + 1.5
		end
		task.wait(0.05)
	end
	releaseE()

	hum = getHumanoid()
	if hum then
		pcall(function() hum.WalkSpeed = WALK_SPEED end)
	end
end

----------------------------------------------------------------
-- tp safe
----------------------------------------------------------------
local function doTpSafe()
	local hrp = getHRP()
	if not hrp then setStatus("TP Safe: no HRP") return false end

	local chair = findCaptainChair()
	if not chair then setStatus("TP Safe: no CaptainChair") return false end

	local chairPos = instanceWorldPos(chair)
	if not chairPos then setStatus("TP Safe: chair has no pos") return false end

	setStatus("TP Safe: chair")
	tpTo(chairPos)
	task.wait(0.25)

	setStatus("TP Safe: E")
	tapE()
	task.wait(0.20)

	hrp = getHRP()
	if not hrp then return false end

	safeOriginY = hrp.Position.Y
	local upPos = Vector3.new(hrp.Position.X, hrp.Position.Y + SAFE_UP, hrp.Position.Z)
	local floorY = upPos.Y - 3

	setStatus("TP Safe: building pad")
	startSafeFloor(floorY)
	task.wait(0.10)

	setStatus("TP Safe: +150")
	local raft = getLocalRaft()
	if raft and raft:IsA("Model") then
		pcall(function()
			local pivot = raft:GetPivot()
			local y = safeSurfaceY or (floorY + SAFE_HOLD_SURFACE)
			local look = pivot.LookVector
			safeYaw = math.atan2(-look.X, -look.Z)
			local newPos = Vector3.new(pivot.Position.X, y, pivot.Position.Z)
			if isRaftClientDriven() then
				raft:PivotTo(CFrame.new(newPos) * CFrame.Angles(0, safeYaw, 0))
			else
				raft:PivotTo(CFrame.new(newPos) * (pivot - pivot.Position))
			end
			rememberRaftPos(newPos)
			local root = getLocalRaftRoot()
			if root then
				root.AssemblyLinearVelocity = Vector3.zero
				root.AssemblyAngularVelocity = Vector3.zero
			end
		end)
	end

	tpTo(Vector3.new(upPos.X, (safeSurfaceY or upPos.Y) + 3, upPos.Z))
	task.wait(0.05)

	hrp = getHRP()
	if hrp then
		pcall(function()
			local p = hrp.Position
			hrp.CFrame = CFrame.new(p.X, (safeSurfaceY or floorY) + 4, p.Z)
			hrp.AssemblyLinearVelocity = Vector3.zero
		end)
	end

	safeActive = true
	setStatus("Safe ON")
	return true
end

----------------------------------------------------------------
-- walk
----------------------------------------------------------------
local function walkToDynamic(getPos, reach, label, opts)
	opts = opts or {}
	local ignoreY = opts.ignoreY == true
	local elevated = opts.elevated ~= false
	local forceElevated = opts.forceElevated == true or ignoreY

	local hum = getHumanoid()
	local hrp = getHRP()
	if not hum or not hrp then return false end
	if not getPos() then return false end

	beginTravel()
	setStatus(label or "Walking...")

	local t0 = tick()
	local reached = false
	local oceanMode = elevated
	if elevated then
		startWaterFloor()
	end

	while tick() - t0 < WALK_TIMEOUT do
		hum = getHumanoid()
		hrp = getHRP()
		if not hum or not hrp or hum.Health <= 0 then break end

		local pos = getPos()
		if not pos then break end

		local fd = flatDist(hrp.Position, pos)
		local fullDist = ignoreY and fd or (hrp.Position - pos).Magnitude

		if fullDist <= reach then
			reached = true
			break
		end

		if forceElevated or (elevated and fd > APPROACH_DIST) then
			if elevated and not oceanMode then
				oceanMode = true
				startWaterFloor()
			end
			if elevated then
				keepOnWaterPlane(true)
			end

			local plane = walkPlaneY()
			local goal = Vector3.new(pos.X, plane, pos.Z)
			pcall(function()
				hum.WalkSpeed = WALK_SPEED
				hum:MoveTo(goal)
			end)

			local flat = Vector3.new(goal.X - hrp.Position.X, 0, goal.Z - hrp.Position.Z)
			if flat.Magnitude > 1 then
				local dir = flat.Unit
				pcall(function()
					hrp.AssemblyLinearVelocity = Vector3.new(dir.X * WALK_SPEED, 0, dir.Z * WALK_SPEED)
				end)
			end
			pcall(function()
				local p = hrp.Position
				if math.abs(p.Y - plane) > 1.5 then
					hrp.CFrame = CFrame.new(p.X, plane, p.Z)
				end
			end)
			setStatus(string.format("%s %.0fst (air)", label or "Walk", fd))
		else
			if oceanMode then
				oceanMode = false
				stopWaterFloor()
			end

			local goal = pos
			local needUp = goal.Y - hrp.Position.Y
			pcall(function()
				hum.WalkSpeed = WALK_SPEED
				hum:MoveTo(goal)
			end)

			local flat = Vector3.new(goal.X - hrp.Position.X, 0, goal.Z - hrp.Position.Z)
			if flat.Magnitude > 1 then
				local dir = flat.Unit
				pcall(function()
					local vy = hrp.AssemblyLinearVelocity.Y
					hrp.AssemblyLinearVelocity = Vector3.new(dir.X * WALK_SPEED, vy, dir.Z * WALK_SPEED)
				end)
			end

			if needUp > 2.5 then
				pcall(function()
					hum.Jump = true
					if needUp > 4 and flat.Magnitude < 14 then
						local v = hrp.AssemblyLinearVelocity
						hrp.AssemblyLinearVelocity = Vector3.new(v.X, math.max(v.Y, LIFT_ASSIST), v.Z)
					end
				end)
			elseif needUp < -3 and not ignoreY then
				pcall(function()
					local v = hrp.AssemblyLinearVelocity
					hrp.AssemblyLinearVelocity = Vector3.new(v.X, math.min(v.Y, -20), v.Z)
				end)
			end
			setStatus(string.format("%s %.0fst h%.0f", label or "Walk", fd, needUp))
		end
		task.wait(0.10)
	end

	hrp = getHRP()
	hum = getHumanoid()
	if hrp then
		pcall(function()
			hrp.AssemblyLinearVelocity = Vector3.zero
			hrp.AssemblyAngularVelocity = Vector3.zero
		end)
	end
	if hum and hrp then
		pcall(function() hum:MoveTo(hrp.Position) end)
	end
	return reached
end

----------------------------------------------------------------
-- toChest
----------------------------------------------------------------
local function goToChest(getPos, reach, label)
	label = label or "To chest"
	reach = reach or REACH_CHEST

	local hum = getHumanoid()
	local hrp = getHRP()
	if not hum or not hrp then return false end

	local pos = getPos()
	if not pos then return false end

	local function distTo(p)
		local h = getHRP()
		if not h or not p then return math.huge end
		return (h.Position - p).Magnitude
	end

	local function tweenIntoChest(target)
		local h = getHRP()
		if not h or not target then return false end
		beginTravel()
		local dest = Vector3.new(target.X, target.Y + 3, target.Z)
		local d = (h.Position - dest).Magnitude
		local dur = math.clamp(
			tweenTimeForDistance(d, CHEST_TWEEN_SPEED),
			0.12,
			1.25
		)
		setStatus(string.format("%s tween %.0fst", label, d))
		tweenHRPTo(dest, dur, Enum.EasingStyle.Quad)

		local refined = getPos()
		h = getHRP()
		if h and refined and (h.Position - refined).Magnitude > reach then
			local fine = Vector3.new(refined.X, refined.Y + 3, refined.Z)
			tweenHRPTo(fine, 0.15, Enum.EasingStyle.Quad)
		end

		h = getHRP()
		if h then
			pcall(function()
				h.AssemblyLinearVelocity = Vector3.zero
				h.AssemblyAngularVelocity = Vector3.zero
			end)
		end
		local final = getPos()
		return h and final and (h.Position - final).Magnitude <= math.max(reach, 6)
	end

	if distTo(pos) <= CHEST_TWEEN_DIST then
		stopWaterFloor()
		return tweenIntoChest(pos)
	end

	local walked = walkToDynamic(
		getPos,
		CHEST_TWEEN_DIST,
		label,
		{ elevated = true }
	)

	pos = getPos()
	hrp = getHRP()
	if not hrp or not pos then
		endTravel()
		return false
	end

	if distTo(pos) <= CHEST_TWEEN_DIST + 5 then
		stopWaterFloor()
		return tweenIntoChest(pos)
	end

	return walked and distTo(pos) <= reach
end

----------------------------------------------------------------
-- visuals
----------------------------------------------------------------
local function clearWorldVisuals()
	if current.highlight then pcall(function() current.highlight:Destroy() end) end
	if current.selection then pcall(function() current.selection:Destroy() end) end
	if current.billboard then pcall(function() current.billboard:Destroy() end) end
	current.highlight, current.selection, current.billboard = nil, nil, nil
	current.chest, current.username = nil, nil
end

local function buildWorldVisuals(username, chest, amounts, total)
	clearWorldVisuals()
	local anchor = pickAnchor(chest)

	local hl = Instance.new("Highlight")
	hl.Name = "RaftESP_Best"
	hl.Adornee = chest
	hl.FillColor = HIGHLIGHT_COLOR
	hl.OutlineColor = Color3.new(1, 1, 1)
	hl.FillTransparency = 0.4
	hl.OutlineTransparency = 0
	hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
	hl.Enabled = true
	hl.Parent = UI_PARENT

	local sel
	if anchor then
		sel = Instance.new("SelectionBox")
		sel.Name = "RaftESP_Sel"
		sel.Adornee = anchor
		sel.Color3 = HIGHLIGHT_COLOR
		sel.LineThickness = 0.08
		sel.SurfaceColor3 = HIGHLIGHT_COLOR
		sel.SurfaceTransparency = 0.7
		sel.Parent = UI_PARENT
	end

	local bb = Instance.new("BillboardGui")
	bb.Name = "RaftESP_Info"
	bb.Adornee = anchor or chest
	bb.Size = UDim2.new(0, 140, 0, 105)
	bb.StudsOffset = Vector3.new(0, 4, 0)
	bb.AlwaysOnTop = true
	bb.MaxDistance = 5000
	bb.Parent = UI_PARENT

	local frame = Instance.new("Frame")
	frame.Size = UDim2.new(1, 0, 1, 0)
	frame.BackgroundColor3 = Color3.fromRGB(10, 10, 14)
	frame.BackgroundTransparency = 0.25
	frame.BorderSizePixel = 0
	frame.Parent = bb
	Instance.new("UICorner", frame).CornerRadius = UDim.new(0, 5)
	local stroke = Instance.new("UIStroke", frame)
	stroke.Color = HIGHLIGHT_COLOR
	stroke.Thickness = 1.5
	local pad = Instance.new("UIPadding", frame)
	pad.PaddingTop = UDim.new(0, 5)
	pad.PaddingBottom = UDim.new(0, 5)
	pad.PaddingLeft = UDim.new(0, 7)
	pad.PaddingRight = UDim.new(0, 7)
	local layout = Instance.new("UIListLayout", frame)
	layout.SortOrder = Enum.SortOrder.LayoutOrder
	layout.Padding = UDim.new(0, 1)

	local function label(name, text, color, order, bold)
		local lbl = Instance.new("TextLabel")
		lbl.Name = name
		lbl.Size = UDim2.new(1, 0, 0, 14)
		lbl.BackgroundTransparency = 1
		lbl.Font = bold and Enum.Font.GothamBold or Enum.Font.Gotham
		lbl.TextSize = bold and 12 or 11
		lbl.TextColor3 = color
		lbl.TextXAlignment = Enum.TextXAlignment.Left
		lbl.Text = text
		lbl.LayoutOrder = order
		lbl.Parent = frame
	end

	label("Title", username, HIGHLIGHT_COLOR, 0, true)
	label("Total", "Total: " .. tostring(total), Color3.fromRGB(255, 220, 80), 1, true)
	for i, res in ipairs(RESOURCES) do
		label(res, res .. ": " .. amounts[res], Color3.fromRGB(225, 225, 225), i + 1, false)
	end

	current.username = username
	current.highlight = hl
	current.selection = sel
	current.billboard = bb
	current.chest = chest
end

----------------------------------------------------------------
-- steal once
----------------------------------------------------------------
local function cleanupAll()
	releaseE()
	endTravel()
end

local function pickBestLoaded()
	local raftsFolder = Workspace:FindFirstChild("Rafts")
	if not raftsFolder then return nil, nil end
	local bestName, best = nil, nil
	for _, player in ipairs(Players:GetPlayers()) do
		if player == LOCAL then continue end
		local username = player.Name
		local raft = raftsFolder:FindFirstChild("Raft_" .. username)
		if not raft or isShielded(raft) then continue end
		local chest = raft:FindFirstChild("Chest")
		if not chest then continue end
		local amounts, total = {}, 0
		for _, res in ipairs(RESOURCES) do
			local n, display = getAmount(raft, res)
			amounts[res] = display
			total += n
		end
		if total <= 0 then continue end
		if not best or total > best.total then
			bestName = username
			best = { username = username, raft = raft, chest = chest, amounts = amounts, total = total }
		end
	end
	return bestName, best
end

local function doStealOnce(username, best)
	if stealLock then return false end
	if not best or best.total <= 0 or not getHRP() then return false end

	stealLock = true
	local success = false

	local homeBackup = getLocalRaftWalkTarget()
	if homeBackup then rememberRaftPos(homeBackup) end

	startStealCamera()
		setStatus("Jump")
		doJump()
	local ok, err = pcall(function()
		cleanupAll()

		local rafts = Workspace:FindFirstChild("Rafts")
		local targetRaft = rafts and rafts:FindFirstChild("Raft_" .. username)
		local chest = targetRaft and targetRaft:FindFirstChild("Chest")
		if not (targetRaft and chest) then
			setStatus("Chest missing")
			return
		end
		if isShielded(targetRaft) then
			setStatus("Shielded")
			return
		end

		local totalBefore = raftTotal(targetRaft)

		local function chestTarget()
			local r = Workspace:FindFirstChild("Rafts")
			local tr = r and r:FindFirstChild("Raft_" .. username)
			local ch = tr and tr:FindFirstChild("Chest")
			if not ch then return nil end
			if tr and isShielded(tr) then return nil end
			return chestPos(ch)
		end

		local arrived = goToChest(chestTarget, REACH_CHEST, "To chest")

		if not arrived then
			setStatus("Never reached chest")
			endTravel()
			return
		end

		rafts = Workspace:FindFirstChild("Rafts")
		targetRaft = rafts and rafts:FindFirstChild("Raft_" .. username)
		chest = targetRaft and targetRaft:FindFirstChild("Chest")
		if not (targetRaft and chest) or isShielded(targetRaft) then
			setStatus("Lost target")
			endTravel()
			return
		end

		stopWaterFloor()
		holdE(readHoldTime(chest), "Steal E " .. username)
		task.wait(POST_HOLD_WAIT)
		releaseE()

		setStatus("Tween +50")
		tweenUp(POST_STEAL_TWEEN_UP, POST_STEAL_TWEEN_TIME)

		local totalAfter = raftTotal(targetRaft)
		success = totalAfter < totalBefore
		stealCount += 1
		setStatus(success and ("Got #" .. stealCount) or ("Miss #" .. stealCount))

		walkToDynamic(
			function()
				return getLocalRaftWalkTarget() or homeBackup or savedRaftPos
			end,
			REACH_RAFT,
			"To raft",
			{ ignoreY = true, elevated = true, forceElevated = true }
		)
		endTravel()

		if success then
			failStreak = 0
		else
			failStreak += 1
		end
	end)

	if not ok then
		warn("[AutoFarm]", err)
		setStatus("Steal error")
	end

	cleanupAll()
	stopStealCamera()
	stealLock = false
	return success
end

local function stealWithRetry(token)
	for attempt = 1, 5 do
		if not stillFarming(token) then return false end
		local name, best = pickBestLoaded()
		if not best then
			setStatus(string.format("No targets (try %d/5)", attempt))
			task.wait(2)
		else
			buildWorldVisuals(name, best.chest, best.amounts, best.total)
			setStatus(string.format("Steal %d/%d → %s (%s)", stealCount + 1, STEALS_PER_CYCLE, name, tostring(best.total)))
			local ok = doStealOnce(name, best)
			if ok then return true end
			if stealCount > 0 or attempt >= 2 then
				return false
			end
			task.wait(1.5)
		end
	end
	return false
end

----------------------------------------------------------------
-- server hop
----------------------------------------------------------------
local function httpGet(url)
	local ok, body = pcall(function()
		if syn and syn.request then
			local r = syn.request({ Url = url, Method = "GET" })
			return r.Body
		end
		if http_request then
			local r = http_request({ Url = url, Method = "GET" })
			return r.Body
		end
		if request then
			local r = request({ Url = url, Method = "GET" })
			return r.Body
		end
		return game:HttpGet(url)
	end)
	if ok then return body end
	return nil
end

local function serverHop()
	setStatus("Server hopping...")
	local placeId = game.PlaceId
	local currentJob = game.JobId

	for try = 1, HOP_RETRIES do
		if not farming then return false end
		local url = string.format(
			"https://games.roblox.com/v1/games/%d/servers/Public?sortOrder=Desc&limit=100&cursor=%s",
			placeId,
			HOP_CURSOR or ""
		)
		local body = httpGet(url)
		if not body then
			setStatus(string.format("Hop list fail %d/%d", try, HOP_RETRIES))
			task.wait(1)
		else
			local ok, data = pcall(function()
				return HttpService:JSONDecode(body)
			end)
			if ok and data and data.data then
				HOP_CURSOR = data.nextPageCursor or ""
				local candidates = {}
				for _, s in ipairs(data.data) do
					if s.id and s.id ~= currentJob and (s.playing or 0) < (s.maxPlayers or 1) then
						table.insert(candidates, s)
					end
				end
				if #candidates > 0 then
					local pick = candidates[math.random(1, #candidates)]
					setStatus(string.format("Hop → %d/%d players", pick.playing or 0, pick.maxPlayers or 0))
					task.wait(0.35)
					local tpOk, tpErr = pcall(function()
						TeleportService:TeleportToPlaceInstance(placeId, pick.id, LOCAL)
					end)
					if not tpOk then
						warn("[AutoFarm] teleport", tpErr)
						pcall(function()
							TeleportService:Teleport(placeId, LOCAL)
						end)
					end
					task.wait(8)
					return true
				end
			end
			setStatus(string.format("No servers %d/%d", try, HOP_RETRIES))
			task.wait(1)
		end
	end

	setStatus("Hop fallback...")
	pcall(function()
		TeleportService:Teleport(placeId, LOCAL)
	end)
	task.wait(8)
	return true
end

----------------------------------------------------------------
-- farm cycle
----------------------------------------------------------------
local function setFarmButton(on)
	if not farmBtn then return end
	if on then
		farmBtn.Text = "AUTO FARM: ON"
		farmBtn.BackgroundColor3 = Color3.fromRGB(20, 70, 20)
	else
		farmBtn.Text = "AUTO FARM: OFF"
		farmBtn.BackgroundColor3 = Color3.fromRGB(30, 30, 30)
	end
end

local function stopFarm()
	farming = false
	farmToken += 1
	stealLock = false
	cleanupAll()
	stopStealCamera()
	clearWorldVisuals()
	setFarmButton(false)
	setStatus("Idle")
end

local function runCycle(token)
	stealCount = 0
	failStreak = 0

	setStatus("Waiting for character...")
	if not waitForChar(25) then
		setStatus("No character — hop")
		if stillFarming(token) then serverHop() end
		return
	end

	setStatus("Waiting for raft...")
	if not waitForLocalRaft(30) then
		setStatus("No raft/chair — hop")
		if stillFarming(token) then serverHop() end
		return
	end

	if not stillFarming(token) then return end

	setStatus("TP Safe...")
	local safeOk = false
	local sOk, sErr = pcall(function()
		safeOk = doTpSafe()
	end)
	if not sOk then
		warn("[AutoFarm] TP Safe", sErr)
		setStatus("TP Safe error")
	end
	if not stillFarming(token) then return end

	if not safeOk then
		setStatus("TP Safe failed — retrying once")
		task.wait(2)
		if not stillFarming(token) then return end
		pcall(function() safeOk = doTpSafe() end)
	end
	if not stillFarming(token) then return end

	setStatus(string.format("Safe done — wait %.0fs", POST_SAFE_WAIT))
	task.wait(POST_SAFE_WAIT)
	if not stillFarming(token) then return end

	for i = 1, STEALS_PER_CYCLE do
		if not stillFarming(token) then return end
		setStatus(string.format("Steal round %d/%d", i, STEALS_PER_CYCLE))
		stealWithRetry(token)
		if not stillFarming(token) then return end
		if i < STEALS_PER_CYCLE then
			task.wait(BETWEEN_STEAL_WAIT)
		end
	end

	if not stillFarming(token) then return end

	clearWorldVisuals()
	stopStealCamera()
	cleanupAll()
	setStatus("Cycle done — hopping")
	serverHop()
end

local function startFarm()
	if farming then return end
	farming = true
	farmToken += 1
	local token = farmToken
	setFarmButton(true)
	setStatus("Auto Farm starting...")

	task.spawn(function()
		local ok, err = pcall(runCycle, token)
		if not ok then
			warn("[AutoFarm] cycle", err)
			setStatus("Cycle error — hop")
			if stillFarming(token) then
				pcall(serverHop)
			end
		end
		if stillFarming(token) then
			setStatus("Waiting / hop stalled")
		end
	end)
end

----------------------------------------------------------------
-- UI
----------------------------------------------------------------
local screenGui = Instance.new("ScreenGui")
screenGui.Name = "gui_autofarm"
screenGui.ResetOnSpawn = false
screenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling
screenGui.Parent = LOCAL:WaitForChild("PlayerGui")

local frame = Instance.new("Frame")
frame.Size = UDim2.new(0, 200, 0, 120)
frame.Position = UDim2.new(0.05, 0, 0.05, 0)
frame.BackgroundColor3 = Color3.fromRGB(15, 15, 15)
frame.BackgroundTransparency = 0.3
frame.BorderSizePixel = 0
frame.Active = true
frame.Parent = screenGui
Instance.new("UICorner", frame).CornerRadius = UDim.new(0, 8)

local uiStroke = Instance.new("UIStroke", frame)
uiStroke.Thickness = 2
task.spawn(function()
	while uiStroke.Parent do
		uiStroke.Color = Color3.fromHSV((tick() % 5) / 5, 1, 1)
		task.wait(0.05)
	end
end)

local titleLabel = Instance.new("TextLabel")
titleLabel.Size = UDim2.new(0, 140, 0, 25)
titleLabel.Position = UDim2.new(0, 10, 0, 6)
titleLabel.BackgroundTransparency = 1
titleLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
titleLabel.Text = "Auto Farm"
titleLabel.Font = Enum.Font.GothamBold
titleLabel.TextSize = 14
titleLabel.TextXAlignment = Enum.TextXAlignment.Left
titleLabel.Parent = frame

statusLabel = Instance.new("TextLabel")
statusLabel.Size = UDim2.new(0, 180, 0, 18)
statusLabel.Position = UDim2.new(0, 10, 0, 28)
statusLabel.BackgroundTransparency = 1
statusLabel.TextColor3 = Color3.fromRGB(180, 180, 180)
statusLabel.Text = "Booting..."
statusLabel.Font = Enum.Font.Gotham
statusLabel.TextSize = 11
statusLabel.TextXAlignment = Enum.TextXAlignment.Left
statusLabel.Parent = frame

local closeBtn = Instance.new("TextButton")
closeBtn.Size = UDim2.new(0, 22, 0, 22)
closeBtn.Position = UDim2.new(1, -28, 0, 8)
closeBtn.BackgroundColor3 = Color3.fromRGB(180, 40, 40)
closeBtn.BackgroundTransparency = 0.2
closeBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
closeBtn.Text = "X"
closeBtn.Font = Enum.Font.GothamBold
closeBtn.TextSize = 12
closeBtn.Parent = frame
Instance.new("UICorner", closeBtn).CornerRadius = UDim.new(0, 4)

farmBtn = Instance.new("TextButton")
farmBtn.Size = UDim2.new(0, 180, 0, 32)
farmBtn.Position = UDim2.new(0, 10, 0, 54)
farmBtn.BackgroundColor3 = Color3.fromRGB(30, 30, 30)
farmBtn.BackgroundTransparency = 0.2
farmBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
farmBtn.Text = "AUTO FARM: OFF"
farmBtn.Font = Enum.Font.GothamBold
farmBtn.TextSize = 13
farmBtn.Parent = frame
Instance.new("UICorner", farmBtn).CornerRadius = UDim.new(0, 6)

local hintLabel = Instance.new("TextLabel")
hintLabel.Size = UDim2.new(0, 180, 0, 16)
hintLabel.Position = UDim2.new(0, 10, 0, 94)
hintLabel.BackgroundTransparency = 1
hintLabel.TextColor3 = Color3.fromRGB(120, 120, 120)
hintLabel.Text = "safe → x2 steal → hop"
hintLabel.Font = Enum.Font.Gotham
hintLabel.TextSize = 10
hintLabel.TextXAlignment = Enum.TextXAlignment.Left
hintLabel.Parent = frame

local dragging, dragInput, dragStart, startPos
frame.InputBegan:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then
		dragging = true
		dragStart = input.Position
		startPos = frame.Position
		input.Changed:Connect(function()
			if input.UserInputState == Enum.UserInputState.End then dragging = false end
		end)
	end
end)
frame.InputChanged:Connect(function(input)
	if input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch then
		dragInput = input
	end
end)
UserInputService.InputChanged:Connect(function(input)
	if input == dragInput and dragging then
		local d = input.Position - dragStart
		frame.Position = UDim2.new(startPos.X.Scale, startPos.X.Offset + d.X, startPos.Y.Scale, startPos.Y.Offset + d.Y)
	end
end)

farmBtn.MouseButton1Click:Connect(function()
	if farming then
		stopFarm()
	else
		startFarm()
	end
end)

closeBtn.MouseButton1Click:Connect(function()
	stopFarm()
	destroySafeFloor()
	cancelTween()
	stopStealCamera()
	if raftPosTrackerConn then
		raftPosTrackerConn:Disconnect()
		raftPosTrackerConn = nil
	end
	screenGui:Destroy()
end)

----------------------------------------------------------------
-- boot
----------------------------------------------------------------
startRaftPosTracker()
do
	local live = getLocalRaftWalkTargetLive()
	if live then rememberRaftPos(live) end
end

setStatus(string.format("Auto-start in %.0fs", START_DELAY))
task.spawn(function()
	task.wait(START_DELAY)
	if screenGui.Parent and not farming then
		startFarm()
	end
end)