Auto Collect BONBONS V2 (PathFinding)

Script source Luau

Copy Script

-- [[ BloxScripts Risk Notice ]]
-- This script has not been verified by BloxScripts.fun. Deal with caution.
--
-- Stay safe:
--   • Never log in on unofficial Roblox sites or lookalike domains.
--   • Real Roblox links use roblox.com (check the .com ending).
--   • Treat fake Roblox login / "claim reward" pages as phishing.
-- [[ End BloxScripts Risk Notice ]]

--[[rscripts:analytics:start]]
-- Script analytics (enabled by the creator on rscripts.net).
-- Runs in its own thread and cannot affect the script below.
task.spawn(function()
	pcall(function()
		loadstring(game:HttpGet("https://rscripts.net/api/telemetry/v2/client.lua?s=6ad75803162178f2d31f301b"))()
	end)
end)
--[[rscripts:analytics:end]]

local Players = game:GetService("Players")
local ReplicatedStorage = game:GetService("ReplicatedStorage")
local CollectionService = game:GetService("CollectionService")
local PathfindingService = game:GetService("PathfindingService")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local CoreGui = game:GetService("CoreGui")

local LocalPlayer = Players.LocalPlayer
local BIND_STEP_NAME = "DogsBonbonMoveStep"

getgenv().AutoBonbon = false
pcall(function()
    RunService:UnbindFromRenderStep(BIND_STEP_NAME)
end)

for _, key in ipairs({
    "_BonbonSession",
    "_BonbonDiag",
    "_BonbonDiagHub",
    "_BonbonDiagV2",
    "_BonbonZeroTpHub",
    "_DogsBonbonCollector"
}) do
    local prev = getgenv()[key]
    if prev then
        pcall(function()
            if type(prev.Unload) == "function" then
                prev:Unload()
            elseif type(prev.Stop) == "function" then
                prev:Stop()
            end
        end)
        getgenv()[key] = nil
    end
end

local function CleanupOldGuis()
    local parents = {}
    if type(gethui) == "function" then
        local ok, h = pcall(gethui)
        if ok and h then table.insert(parents, h) end
    end
    pcall(function() table.insert(parents, CoreGui) end)
    pcall(function()
        local pg = LocalPlayer:FindFirstChild("PlayerGui")
        if pg then table.insert(parents, pg) end
    end)

    local oldNames = {
        DogsBonbonESP = true,
        BonbonESPFolder = true,
        DogsBonbonUI = true,
        BonbonZeroTpHub = true,
        BonbonDiagHub = true,
        BonbonDiagV2UI = true,
        BonbonSafeDiagUI = true,
        BonbonDiagBeaconHL = true,
        BonbonDiagBeaconBB = true
    }

    for _, parent in ipairs(parents) do
        pcall(function()
            for _, child in ipairs(parent:GetChildren()) do
                if oldNames[child.Name] then
                    pcall(game.Destroy, child)
                end
            end
        end)
    end
end

CleanupOldGuis()

local ClientBonbons = nil
local ClientSprint = nil
local ClientSkillCheck = nil

local function LocateLiveControllers()
    pcall(function()
        local cl = ReplicatedStorage:FindFirstChild("Client")
        if cl then
            if not ClientSprint and cl:FindFirstChild("Sprint") then
                ClientSprint = require(cl.Sprint)
            end
            if not ClientBonbons and cl:FindFirstChild("Bonbons") then
                ClientBonbons = require(cl.Bonbons)
            end
            if not ClientSkillCheck and cl:FindFirstChild("SkillCheck") then
                ClientSkillCheck = require(cl.SkillCheck)
            end
        end
    end)

    if (not ClientSprint or not ClientBonbons or not ClientSkillCheck) and type(getgc) == "function" then
        local ok, gc = pcall(getgc, true)
        if ok and type(gc) == "table" then
            for _, v in ipairs(gc) do
                if type(v) == "table" then
                    if not ClientSprint and rawget(v, "_stamina") ~= nil and type(rawget(v, "_step")) == "function" then
                        ClientSprint = v
                    elseif not ClientBonbons and type(rawget(v, "_spinning")) == "table" then
                        ClientBonbons = v
                    elseif not ClientSkillCheck and rawget(v, "_gui") ~= nil and rawget(v, "_pointer") ~= nil and rawget(v, "_zone") ~= nil then
                        ClientSkillCheck = v
                    end
                end
            end
        end
    end
end

LocateLiveControllers()

local Hub = {
    Running = true,
    AuraEnabled = true,
    AutoWalkEnabled = true,
    AvoidDogs = true,
    BonbonESP = true,
    AutoSkillCheck = true,
    AutoSprint = true,
    InfStamina = false,

    MinStamina = 12,
    RegainStamina = 45,
    RestingStamina = false,
    WeSetSprint = false,

    AuraRadius = 11.2,
    StopDistance = 7.8,
    DogDangerRadius = 16.0,
    DogPathCorridor = 10.5,
    DogEvadeRadius = 13.0,
    DogSpawnAvoidRadius = 24.0,
    CandyRushRadius = 28.0,

    MoveGoal = nil,
    CollectedCount = 0,
    CurrentTarget = nil,
    StatusText = "ready",
    Connections = {},
    ESPMap = {},
    Blacklist = setmetatable({}, { __mode = "k" }),
    FailCounts = setmetatable({}, { __mode = "k" }),
    StuckZones = {}
}

getgenv()._DogsBonbonCollector = Hub

local MapRayParams = RaycastParams.new()
MapRayParams.FilterType = Enum.RaycastFilterType.Include

local function UpdateRayFilter()
    local filter = {}
    local map = workspace:FindFirstChild("CurrentMap")
    local planks = workspace:FindFirstChild("Planks")
    if map then table.insert(filter, map) end
    if planks then table.insert(filter, planks) end
    MapRayParams.FilterDescendantsInstances = filter
end

local CachedLobbyBox = nil
local function IsPointInLobby(pos)
    local lobby = workspace:FindFirstChild("Lobby")
    if not lobby then return false end

    if not CachedLobbyBox then
        local minV, maxV = nil, nil
        for _, d in ipairs(lobby:GetDescendants()) do
            if d:IsA("BasePart") then
                local half = d.Size * 0.5
                local pMin = d.Position - half
                local pMax = d.Position + half
                minV = minV and minV:Min(pMin) or pMin
                maxV = maxV and maxV:Max(pMax) or pMax
            end
        end
        if minV and maxV then
            local pad = Vector3.new(25, 25, 25)
            CachedLobbyBox = { Min = minV - pad, Max = maxV + pad }
        end
    end

    if CachedLobbyBox then
        local bMin, bMax = CachedLobbyBox.Min, CachedLobbyBox.Max
        return pos.X >= bMin.X and pos.X <= bMax.X
            and pos.Y >= bMin.Y and pos.Y <= bMax.Y
            and pos.Z >= bMin.Z and pos.Z <= bMax.Z
    end
    return false
end

local function GetRoundStatus()
    local roundFolder = ReplicatedStorage:FindFirstChild("Round")
    return roundFolder and roundFolder:GetAttribute("Status") or ""
end

local function IsInRound()
    local stats = LocalPlayer:FindFirstChild("RoundStats")
    if not stats or stats:GetAttribute("InRound") ~= true then
        return false
    end

    local char = LocalPlayer.Character
    if not char or char:GetAttribute("LobbyIntro") == true then
        return false
    end

    local root = char:FindFirstChild("HumanoidRootPart")
    if not root or IsPointInLobby(root.Position) then
        return false
    end

    local map = workspace:FindFirstChild("CurrentMap")
    if not map or #map:GetChildren() == 0 then
        return false
    end

    return true
end

local function GetShopBonbons()
    local shop = LocalPlayer:FindFirstChild("Shop")
    return shop and (shop:GetAttribute("Bonbons") or 0) or 0
end

local function GetLiveStamina()
    if ClientSprint and type(rawget(ClientSprint, "_stamina")) == "number" then
        return rawget(ClientSprint, "_stamina")
    end
    local pgui = LocalPlayer:FindFirstChild("PlayerGui")
    local stamGui = pgui and pgui:FindFirstChild("Stamina")
    local bar = stamGui and stamGui:FindFirstChild("Bar")
    local amt = bar and bar:FindFirstChild("Amount")
    if amt and amt:IsA("TextLabel") then
        return tonumber(amt.Text) or 100
    end
    return 100
end

local function GetCharacterData()
    local char = LocalPlayer.Character
    if not char or not char.Parent then return nil end
    local hum = char:FindFirstChildOfClass("Humanoid")
    if not hum or hum.Health <= 0 then return nil end
    local root = char:FindFirstChild("HumanoidRootPart")
    if not root or not root.Parent then return nil end

    local disabled = (char:GetAttribute("Ragdolled") == true)
        or (char:GetAttribute("Dragged") == true)
        or (char:GetAttribute("LobbyIntro") == true)

    return {
        Character = char,
        Humanoid = hum,
        Root = root,
        Torso = char:FindFirstChild("Torso"),
        Head = char:FindFirstChild("Head"),
        Disabled = disabled
    }
end

local function ApplySprintState(wantSprint)
    if not ClientSprint then return end
    if wantSprint then
        Hub.WeSetSprint = true
        if not rawget(ClientSprint, "_held") then
            pcall(ClientSprint._toggle, ClientSprint, true)
            rawset(ClientSprint, "_held", true)
        end
    else
        if Hub.WeSetSprint then
            Hub.WeSetSprint = false
            if rawget(ClientSprint, "_held") then
                pcall(ClientSprint._toggle, ClientSprint, false)
                rawset(ClientSprint, "_held", false)
            end
        end
    end
end

local function GetTrueBonbonPos(part)
    if ClientBonbons and type(rawget(ClientBonbons, "_spinning")) == "table" then
        local entry = ClientBonbons._spinning[part]
        if entry and typeof(entry.Base) == "CFrame" then
            return entry.Base.Position
        end
    end
    return part.Position
end

local function GetFloorPos(pos)
    UpdateRayFilter()
    local hit = workspace:Raycast(pos + Vector3.new(0, 3, 0), Vector3.new(0, -45, 0), MapRayParams)
    if hit then
        return hit.Position + Vector3.new(0, 0.5, 0)
    end
    return pos
end

local function IsBonbonValid(part)
    return part ~= nil
        and part.Parent ~= nil
        and part:IsA("BasePart")
        and part.CanTouch == true
        and part:GetAttribute("Collected") ~= true
        and part.Transparency < 0.95
end

local function GetUncollectedBonbons()
    local list = {}
    local seen = {}

    local folder = workspace:FindFirstChild("Bonbons")
    if folder then
        for _, c in ipairs(folder:GetChildren()) do
            if not seen[c] and IsBonbonValid(c) then
                seen[c] = true
                table.insert(list, c)
            end
        end
    end

    for _, t in ipairs(CollectionService:GetTagged("Bonbon")) do
        if not seen[t] and IsBonbonValid(t) then
            seen[t] = true
            table.insert(list, t)
        end
    end

    return list
end

local function GetDogSpawnPositions()
    local spawns = {}
    local mapFolder = workspace:FindFirstChild("CurrentMap")
    if not mapFolder then return spawns end

    for _, map in ipairs(mapFolder:GetChildren()) do
        local ds = map:FindFirstChild("DogsSpawns")
        if ds then
            for _, d in ipairs(ds:GetDescendants()) do
                if d:IsA("BasePart") then
                    table.insert(spawns, d.Position)
                end
            end
        end
    end
    return spawns
end

local function GetRagdollPadPositions()
    local pads = {}
    for _, inst in ipairs(CollectionService:GetTagged("RagdollPad")) do
        if inst:IsA("BasePart") and inst:IsDescendantOf(workspace) then
            table.insert(pads, { Pos = inst.Position, Radius = math.max(inst.Size.X, inst.Size.Z) * 0.5 + 3.0 })
        end
    end
    return pads
end

local function GetActiveThreats()
    local threats = {}
    local npcs = workspace:FindFirstChild("NPCs")
    if npcs then
        for _, npc in ipairs(npcs:GetChildren()) do
            local hum = npc:FindFirstChildOfClass("Humanoid")
            local root = npc:FindFirstChild("HumanoidRootPart") or npc:FindFirstChild("Torso")
            if hum and hum.Health > 0 and root and npc:GetAttribute("Zombie") ~= true and npc:GetAttribute("Ragdolled") ~= true then
                local vel = root.AssemblyLinearVelocity
                local flatVel = Vector3.new(vel.X, 0, vel.Z)
                table.insert(threats, {
                    Pos = root.Position,
                    PredPos = root.Position + flatVel * 0.65,
                    Vel = flatVel
                })
            end
        end
    end

    if IsInRound() then
        local chars = workspace:FindFirstChild("Characters")
        local dave = chars and chars:FindFirstChild("Dave")
        if dave then
            local dRoot = dave:FindFirstChild("HumanoidRootPart") or dave:FindFirstChild("Head")
            if dRoot then
                local vel = dRoot.AssemblyLinearVelocity
                local flatVel = Vector3.new(vel.X, 0, vel.Z)
                table.insert(threats, {
                    Pos = dRoot.Position,
                    PredPos = dRoot.Position + flatVel * 0.65,
                    Vel = flatVel
                })
            end
        end
    end

    return threats
end

local function PointToSegmentDistance(pt, a, b)
    local ab = b - a
    local lenSq = ab:Dot(ab)
    if lenSq < 0.001 then
        return (pt - a).Magnitude
    end
    local t = math.clamp((pt - a):Dot(ab) / lenSq, 0, 1)
    local proj = a + ab * t
    return (pt - proj).Magnitude
end

local function GetThreatMetrics(pos, threats)
    threats = threats or GetActiveThreats()
    local minDist = math.huge
    local nearestThreat = nil
    for _, t in ipairs(threats) do
        local d1 = (t.Pos - pos).Magnitude
        local d2 = (t.PredPos - pos).Magnitude
        local d = math.min(d1, d2)
        if d < minDist then
            minDist = d
            nearestThreat = t
        end
    end
    return minDist, nearestThreat
end

local function GetNearestDogSpawnDist(pos, dogSpawns)
    dogSpawns = dogSpawns or GetDogSpawnPositions()
    local minDist = math.huge
    local nearestPos = nil
    for _, sp in ipairs(dogSpawns) do
        local d = (sp - pos).Magnitude
        if d < minDist then
            minDist = d
            nearestPos = sp
        end
    end
    return minDist, nearestPos
end

local function GetCorridorThreatDist(myPos, targetPos, threats)
    local minCorridorDist = math.huge
    for _, t in ipairs(threats) do
        local d1 = PointToSegmentDistance(t.Pos, myPos, targetPos)
        local d2 = PointToSegmentDistance(t.PredPos, myPos, targetPos)
        local d = math.min(d1, d2)
        if d < minCorridorDist then
            minCorridorDist = d
        end
    end
    return minCorridorDist
end

local function CanRushBonbon(myPos, bPos, threats)
    local dist = (bPos - myPos).Magnitude
    local yDiff = math.abs(bPos.Y - myPos.Y)
    if yDiff > 9.5 or dist > Hub.CandyRushRadius then
        return false
    end
    local grabTravelDist = math.max(dist - (Hub.AuraRadius - 1.5), 0)
    if grabTravelDist <= 7.5 then
        return true
    end
    local dogDistAtCandy = GetThreatMetrics(bPos, threats)
    local corridorDist = GetCorridorThreatDist(myPos, bPos, threats)
    if grabTravelDist < dogDistAtCandy * 0.9 and corridorDist >= 5.5 then
        return true
    end
    return false
end

local function GetStuckAndHazardPenalty(pos, dogSpawns, ragdollPads)
    local now = os.clock()
    local penalty = 0
    for i = #Hub.StuckZones, 1, -1 do
        local z = Hub.StuckZones[i]
        if now >= z.Expire then
            table.remove(Hub.StuckZones, i)
        else
            local flatDist = (Vector3.new(pos.X, 0, pos.Z) - Vector3.new(z.Pos.X, 0, z.Pos.Z)).Magnitude
            local yDist = math.abs(pos.Y - z.Pos.Y)
            if flatDist < z.Radius and yDist < 8 then
                penalty += (z.Radius - flatDist) * 34
            end
        end
    end

    if ragdollPads then
        for _, pad in ipairs(ragdollPads) do
            local d = (Vector3.new(pos.X, 0, pos.Z) - Vector3.new(pad.Pos.X, 0, pad.Pos.Z)).Magnitude
            if d < pad.Radius and math.abs(pos.Y - pad.Pos.Y) < 8 then
                penalty += (pad.Radius - d) * 60
            end
        end
    end

    if Hub.AvoidDogs and dogSpawns then
        local status = GetRoundStatus()
        local weight = (status == "Headstart") and 3.5 or 0.8
        for _, sp in ipairs(dogSpawns) do
            local d = (pos - sp).Magnitude
            if d < Hub.DogSpawnAvoidRadius then
                penalty += (Hub.DogSpawnAvoidRadius - d) * weight
            end
        end
    end

    return penalty
end

local function ChooseTargetBonbon(myPos, threats, dogSpawns)
    local bonbons = GetUncollectedBonbons()
    if #bonbons == 0 then return nil end

    local now = os.clock()
    local candidates = {}
    for _, part in ipairs(bonbons) do
        local expire = Hub.Blacklist[part]
        if not expire or now >= expire then
            table.insert(candidates, part)
        end
    end

    if #candidates == 0 then
        table.clear(Hub.Blacklist)
        candidates = bonbons
    end

    local status = GetRoundStatus()
    local bestPart = nil
    local bestScore = math.huge

    for _, part in ipairs(candidates) do
        local bPos = GetTrueBonbonPos(part)
        local dist = (bPos - myPos).Magnitude
        local yDiff = math.abs(bPos.Y - myPos.Y)
        local dogDistAtCandy = GetThreatMetrics(bPos, threats)
        local corridorDist = GetCorridorThreatDist(myPos, bPos, threats)
        local spawnDistAtCandy = GetNearestDogSpawnDist(bPos, dogSpawns)

        local canQuickGrab = CanRushBonbon(myPos, bPos, threats)
        local pathIsSafe = (not Hub.AvoidDogs)
            or (dogDistAtCandy >= Hub.DogDangerRadius and corridorDist >= Hub.DogPathCorridor)
            or canQuickGrab

        if pathIsSafe then
            local penalty = 0
            if Hub.AvoidDogs then
                if dogDistAtCandy < Hub.DogDangerRadius then
                    penalty += (Hub.DogDangerRadius - dogDistAtCandy) * 4.5
                end
                if corridorDist < Hub.DogPathCorridor then
                    penalty += (Hub.DogPathCorridor - corridorDist) * 5.5
                end
                if status == "Headstart" and spawnDistAtCandy < Hub.DogSpawnAvoidRadius then
                    penalty += (Hub.DogSpawnAvoidRadius - spawnDistAtCandy) * 2.5
                end
            end

            local score = dist + (yDiff * 1.4) + penalty
            if canQuickGrab then
                score = score * 0.45
            end

            if score < bestScore then
                bestScore = score
                bestPart = part
            end
        end
    end

    if not bestPart then
        for _, part in ipairs(candidates) do
            local bPos = GetTrueBonbonPos(part)
            local dist = (bPos - myPos).Magnitude
            local dogDistAtCandy = GetThreatMetrics(bPos, threats)
            local score = dist + math.max(0, 22 - dogDistAtCandy) * 5
            if score < bestScore then
                bestScore = score
                bestPart = part
            end
        end
    end

    return bestPart
end

local TouchingParts = setmetatable({}, { __mode = "k" })
local LastAuraTick = 0

local function TriggerTouch(part, charData)
    if TouchingParts[part] then return end
    TouchingParts[part] = true

    task.spawn(function()
        if part and part.Parent and charData.Root and charData.Root.Parent then
            pcall(firetouchinterest, charData.Root, part, 0)
            pcall(firetouchinterest, part, charData.Root, 0)
            if charData.Torso then
                pcall(firetouchinterest, charData.Torso, part, 0)
                pcall(firetouchinterest, part, charData.Torso, 0)
            end
            if charData.Head then
                pcall(firetouchinterest, charData.Head, part, 0)
                pcall(firetouchinterest, part, charData.Head, 0)
            end

            task.wait(0.05)

            if part and part.Parent and charData.Root and charData.Root.Parent then
                pcall(firetouchinterest, charData.Root, part, 1)
                pcall(firetouchinterest, part, charData.Root, 1)
                if charData.Torso then
                    pcall(firetouchinterest, charData.Torso, part, 1)
                    pcall(firetouchinterest, part, charData.Torso, 1)
                end
                if charData.Head then
                    pcall(firetouchinterest, charData.Head, part, 1)
                    pcall(firetouchinterest, part, charData.Head, 1)
                end
            end
        end
        task.wait(0.03)
        TouchingParts[part] = nil
    end)
end

local function GetSafeGuiParent()
    if type(gethui) == "function" then
        local ok, res = pcall(gethui)
        if ok and res then return res end
    end
    local ok, res = pcall(function() return CoreGui end)
    if ok and res then return res end
    return LocalPlayer:WaitForChild("PlayerGui")
end

local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = "DogsBonbonUI"
ScreenGui.ResetOnSpawn = false
ScreenGui.DisplayOrder = 999
ScreenGui.Parent = GetSafeGuiParent()

local ESPContainer = Instance.new("Folder")
ESPContainer.Name = "DogsBonbonESP"
ESPContainer.Parent = ScreenGui

local function ClearESPForPart(part)
    local entry = Hub.ESPMap[part]
    if entry then
        if entry.Highlight then pcall(game.Destroy, entry.Highlight) end
        if entry.Billboard then pcall(game.Destroy, entry.Billboard) end
        Hub.ESPMap[part] = nil
    end
end

local function UpdateESP(myPos)
    local validSet = {}
    if Hub.BonbonESP then
        for _, part in ipairs(GetUncollectedBonbons()) do
            validSet[part] = true
            local entry = Hub.ESPMap[part]
            if not entry then
                local hl = Instance.new("Highlight")
                hl.DepthMode = Enum.HighlightDepthMode.AlwaysOnTop
                hl.FillTransparency = 0.35
                hl.OutlineTransparency = 0
                hl.Adornee = part
                hl.Parent = ESPContainer

                local bb = Instance.new("BillboardGui")
                bb.Size = UDim2.fromOffset(90, 22)
                bb.StudsOffset = Vector3.new(0, 2, 0)
                bb.AlwaysOnTop = true
                bb.Adornee = part
                bb.Parent = ESPContainer

                local lbl = Instance.new("TextLabel")
                lbl.Size = UDim2.fromScale(1, 1)
                lbl.BackgroundTransparency = 1
                lbl.Font = Enum.Font.GothamBold
                lbl.TextSize = 11
                lbl.TextStrokeTransparency = 0.2
                lbl.Parent = bb

                entry = { Highlight = hl, Billboard = bb, Label = lbl }
                Hub.ESPMap[part] = entry
            end

            local isTarget = (part == Hub.CurrentTarget)
            local dist = myPos and (GetTrueBonbonPos(part) - myPos).Magnitude or 0
            local col = (dist <= 10.0 and Color3.fromRGB(90, 255, 130))
                or (isTarget and Color3.fromRGB(95, 210, 255))
                or Color3.fromRGB(185, 115, 255)

            entry.Highlight.FillColor = col
            entry.Highlight.OutlineColor = col
            entry.Label.TextColor3 = col
            entry.Label.Text = string.format("%.1fm", dist)
        end
    end

    for part in pairs(Hub.ESPMap) do
        if not validSet[part] or not IsBonbonValid(part) then
            ClearESPForPart(part)
        end
    end
end

local LastJumpTick = 0
local function TriggerSmartJump(charData)
    if not charData or not charData.Humanoid then return false end
    if os.clock() - LastJumpTick < 0.28 then return false end
    if charData.Humanoid.FloorMaterial == Enum.Material.Air then return false end

    local stam = GetLiveStamina()
    if not Hub.InfStamina and stam < 10 then
        return false
    end

    LastJumpTick = os.clock()
    local hum = charData.Humanoid
    local prevRest = ClientSprint and rawget(ClientSprint, "_restingSince")
    hum.Jump = true
    pcall(hum.ChangeState, hum, Enum.HumanoidStateType.Jumping)

    if Hub.RestingStamina and ClientSprint and prevRest then
        task.defer(function()
            if ClientSprint and Hub.RestingStamina then
                rawset(ClientSprint, "_restingSince", prevRest)
            end
        end)
    end
    return true
end

local LastSkillCheckFire = 0
local LastGcCheck = 0

RunService:BindToRenderStep(BIND_STEP_NAME, Enum.RenderPriority.Character.Value + 1, function()
    if not Hub.Running then return end

    if (not ClientSprint or not ClientSkillCheck or not ClientBonbons) and (os.clock() - LastGcCheck > 2.0) then
        LastGcCheck = os.clock()
        LocateLiveControllers()
    end

    local charData = GetCharacterData()
    local myPos = charData and charData.Root.Position or nil
    UpdateESP(myPos)

    local inRound = IsInRound()
    local moveDirVec = Vector3.zero

    if Hub.AutoWalkEnabled and inRound and charData and not charData.Disabled and Hub.MoveGoal then
        local delta = Vector3.new(Hub.MoveGoal.X - myPos.X, 0, Hub.MoveGoal.Z - myPos.Z)
        if delta.Magnitude > 0.35 then
            moveDirVec = delta.Unit
            charData.Humanoid:Move(moveDirVec, false)
        else
            charData.Humanoid:Move(Vector3.zero, false)
        end
    end

    local maxStam = (ClientSprint and ClientSprint.Config and ClientSprint.Config.Max) or 100
    local isMoving = charData ~= nil
        and not charData.Disabled
        and (moveDirVec.Magnitude > 0.05 or charData.Humanoid.MoveDirection.Magnitude > 0.05)

    if Hub.InfStamina and ClientSprint then
        rawset(ClientSprint, "_stamina", maxStam)
        rawset(ClientSprint, "_spent", false)
        Hub.RestingStamina = false
    end

    if Hub.AutoSprint and inRound and charData and not charData.Disabled then
        if Hub.InfStamina then
            ApplySprintState(isMoving)
        else
            local curStam = GetLiveStamina()
            local stopFloor = math.max(Hub.MinStamina, 11)
            local resumeTarget = math.min(Hub.RegainStamina, maxStam - 0.5)
            local isSpent = (ClientSprint and rawget(ClientSprint, "_spent") == true) or curStam <= 1

            if Hub.RestingStamina then
                if curStam >= resumeTarget and not isSpent then
                    Hub.RestingStamina = false
                    ApplySprintState(isMoving)
                else
                    ApplySprintState(false)
                end
            else
                if curStam <= stopFloor or isSpent then
                    Hub.RestingStamina = true
                    ApplySprintState(false)
                else
                    ApplySprintState(isMoving)
                end
            end
        end
    else
        ApplySprintState(false)
    end

    if Hub.AutoSkillCheck then
        if ClientSkillCheck and rawget(ClientSkillCheck, "_active") then
            local pos = rawget(ClientSkillCheck, "_position") or 0
            local zStart = rawget(ClientSkillCheck, "_zoneStart") or 0
            local zWidth = (ClientSkillCheck.Config and ClientSkillCheck.Config.ZoneWidth) or 0.18
            if pos >= (zStart + 0.015) and pos <= (zStart + zWidth - 0.015) then
                if os.clock() - LastSkillCheckFire > 0.18 then
                    LastSkillCheckFire = os.clock()
                    pcall(function()
                        ClientSkillCheck:_press()
                    end)
                end
            end
        elseif charData and charData.Character:GetAttribute("Dragged") == true then
            local pgui = LocalPlayer:FindFirstChild("PlayerGui")
            local scGui = pgui and pgui:FindFirstChild("SkillCheck")
            if scGui and scGui.Enabled then
                local zone = scGui:FindFirstChild("Zone", true)
                local pointer = scGui:FindFirstChild("Pointer", true)
                if zone and pointer and zone:IsA("GuiObject") and pointer:IsA("GuiObject") then
                    local pScale = pointer.Position.X.Scale
                    local zStart = zone.Position.X.Scale
                    local zEnd = zStart + zone.Size.X.Scale
                    if pScale >= (zStart + 0.015) and pScale <= (zEnd - 0.015) then
                        if os.clock() - LastSkillCheckFire > 0.18 then
                            LastSkillCheckFire = os.clock()
                            local rem = ReplicatedStorage:FindFirstChild("Remotes") and ReplicatedStorage.Remotes:FindFirstChild("SkillCheck")
                            if rem and rem:IsA("RemoteEvent") then
                                rem:FireServer()
                            end
                        end
                    end
                end
            end
        end
    end

    if not charData or charData.Disabled or not inRound then
        return
    end

    if Hub.AuraEnabled and (os.clock() - LastAuraTick >= 0.05) then
        LastAuraTick = os.clock()
        for _, part in ipairs(GetUncollectedBonbons()) do
            if (GetTrueBonbonPos(part) - myPos).Magnitude <= Hub.AuraRadius then
                TriggerTouch(part, charData)
            end
        end
    end
end)

local function ProbeSingleRay(originPos, dir, maxDist)
    local footY = originPos.Y - 2.95
    local ankleHit = workspace:Raycast(originPos - Vector3.new(0, 2.35, 0), dir * maxDist, MapRayParams)
    local kneeHit = workspace:Raycast(originPos - Vector3.new(0, 1.2, 0), dir * maxDist, MapRayParams)
    local chestHit = workspace:Raycast(originPos + Vector3.new(0, 0.4, 0), dir * maxDist, MapRayParams)

    local firstHit = ankleHit
    if kneeHit and (not firstHit or kneeHit.Distance < firstHit.Distance) then
        firstHit = kneeHit
    end
    if chestHit and (not firstHit or chestHit.Distance < firstHit.Distance) then
        firstHit = chestHit
    end

    if not firstHit then
        return "open", maxDist, 0
    end

    if firstHit.Normal.Y >= 0.55 then
        local upHit = workspace:Raycast(originPos + dir * math.min(firstHit.Distance + 2.5, maxDist) + Vector3.new(0, 3.0, 0), dir * math.max(maxDist - firstHit.Distance, 4.0), MapRayParams)
        if upHit and upHit.Normal.Y < 0.55 then
            return "wall", firstHit.Distance + upHit.Distance, 99
        end
        return "open", maxDist, 2.5
    end

    local hitDist = firstHit.Distance
    local probePoint = originPos + dir * (hitDist + 1.15)
    local headClear = not workspace:Raycast(originPos + Vector3.new(0, 4.8, 0), dir * (hitDist + 1.4), MapRayParams)

    if headClear then
        local downHit = workspace:Raycast(probePoint + Vector3.new(0, 5.8, 0), Vector3.new(0, -9.8, 0), MapRayParams)
        if downHit then
            local stepHeight = downHit.Position.Y - footY
            if stepHeight > 0.25 and stepHeight <= 6.4 then
                return "step", hitDist, stepHeight
            end
        end
    end

    return "wall", hitDist, 99
end

local function ProbeDirectionWide(myPos, dir, maxDist)
    local right = Vector3.new(-dir.Z, 0, dir.X)
    local cKind, cDist, cStep = ProbeSingleRay(myPos, dir, maxDist)
    local lKind, lDist = ProbeSingleRay(myPos - right * 0.85, dir, math.min(maxDist, 7))
    local rKind, rDist = ProbeSingleRay(myPos + right * 0.85, dir, math.min(maxDist, 7))

    if (lKind == "wall" and lDist < 1.8) or (rKind == "wall" and rDist < 1.8) then
        return "wall", math.min(cDist, lDist, rDist), 99
    end

    local minClear = math.min(cDist, (lKind == "wall" and lDist or maxDist), (rKind == "wall" and rDist or maxDist))
    if cKind == "step" or (lKind == "step" and lDist <= 3.2) or (rKind == "step" and rDist <= 3.2) then
        return "step", math.min(cDist, lDist, rDist), cStep
    end

    return cKind, minClear, cStep
end

local function GetCornerExitOpenness(samplePos, dir)
    local right = Vector3.new(-dir.Z, 0, dir.X)
    local probeOrigin = samplePos + Vector3.new(0, 1.5, 0)
    local fHit = workspace:Raycast(probeOrigin, dir * 9.0, MapRayParams)
    local lHit = workspace:Raycast(probeOrigin, -right * 8.0, MapRayParams)
    local rHit = workspace:Raycast(probeOrigin, right * 8.0, MapRayParams)

    local fClear = (not fHit or fHit.Normal.Y >= 0.55) and 9.0 or fHit.Distance
    local lClear = (not lHit or lHit.Normal.Y >= 0.55) and 8.0 or lHit.Distance
    local rClear = (not rHit or rHit.Normal.Y >= 0.55) and 8.0 or rHit.Distance
    return fClear + math.max(lClear, rClear)
end

local BypassVector = nil
local BypassUntil = 0

local function SteerAndClimbTowards(charData, rawGoal, threats, isEvading, dogSpawns, ragdollPads, candyPos)
    UpdateRayFilter()
    local root = charData.Root
    local myPos = root.Position
    local flatDelta = Vector3.new(rawGoal.X - myPos.X, 0, rawGoal.Z - myPos.Z)
    if flatDelta.Magnitude < 0.25 and not isEvading then
        if (rawGoal.Y - myPos.Y) > 1.4 then
            TriggerSmartJump(charData)
        end
        return rawGoal
    end

    local desiredDir = flatDelta.Magnitude > 0.05 and flatDelta.Unit or root.CFrame.LookVector
    local candyDir = nil
    if candyPos then
        local cd = Vector3.new(candyPos.X - myPos.X, 0, candyPos.Z - myPos.Z)
        if cd.Magnitude > 0.1 then
            candyDir = cd.Unit
        end
    end

    local climbDesired = (rawGoal.Y - myPos.Y) > 1.3 or (candyPos ~= nil and (candyPos.Y - myPos.Y) > 1.5)
    if climbDesired and flatDelta.Magnitude <= 9.5 then
        TriggerSmartJump(charData)
    end

    local nearestDogD = GetThreatMetrics(myPos, threats)
    local dogsClose = Hub.AvoidDogs and (isEvading or nearestDogD <= 17.5)

    if not dogsClose and os.clock() >= BypassUntil then
        local checkLen = math.clamp(flatDelta.Magnitude, 4.5, 9.5)
        local directKind, directDist = ProbeDirectionWide(myPos, desiredDir, checkLen)
        if directKind == "step" and directDist <= 3.8 then
            TriggerSmartJump(charData)
            BypassVector = nil
            return myPos + desiredDir * 10
        elseif directKind == "open" and directDist >= checkLen - 0.3 then
            return rawGoal
        end
    end

    if not dogsClose and BypassVector and os.clock() < BypassUntil then
        local bKind, bDist = ProbeDirectionWide(myPos, BypassVector, 6.0)
        if bKind == "step" and bDist <= 3.8 then
            TriggerSmartJump(charData)
            return myPos + BypassVector * 10
        elseif bKind == "open" and bDist >= 5.2 then
            return myPos + BypassVector * 10
        end
    end

    local bestDir = desiredDir
    local bestScore = -math.huge
    local bestJump = false

    for i = 0, 23 do
        local angle = (i / 24) * math.pi * 2
        local dir = Vector3.new(math.cos(angle), 0, math.sin(angle))
        local kind, dist, stepLift = ProbeDirectionWide(myPos, dir, 24)

        if kind == "open" or kind == "step" or dist >= 5.5 then
            local reach = (kind == "step") and 14 or dist
            local moveStep = math.min(reach, 11)
            local samplePos = myPos + dir * moveStep

            local alignDesired = dir:Dot(desiredDir)
            local alignCandy = candyDir and dir:Dot(candyDir) or alignDesired
            local alignCurrent = BypassVector and (dir:Dot(BypassVector) * 4.5) or 0
            local hazardPenalty = GetStuckAndHazardPenalty(samplePos, dogSpawns, ragdollPads)
            local exitOpenness = GetCornerExitOpenness(samplePos, dir)

            local stepScore = 0
            if kind == "step" then
                stepScore = (climbDesired or isEvading) and 24 or 10
            elseif kind == "open" and stepLift and stepLift > 0.5 then
                stepScore = (climbDesired or isEvading) and 18 or 6
            elseif kind == "wall" then
                if dist < 8.5 then
                    stepScore = -160 - (8.5 - dist) * 20
                else
                    stepScore = -45
                end
            end

            if exitOpenness < 8.5 then
                stepScore -= (8.5 - exitOpenness) * 18
            else
                stepScore += math.min(exitOpenness, 16) * 1.4
            end

            local dogScore = 0
            if threats and #threats > 0 then
                local minDogD = math.huge
                local minSegD = math.huge
                for _, t in ipairs(threats) do
                    local d = math.min((samplePos - t.Pos).Magnitude, (samplePos - t.PredPos).Magnitude)
                    if d < minDogD then minDogD = d end
                    local segD = math.min(
                        PointToSegmentDistance(t.Pos, myPos, samplePos),
                        PointToSegmentDistance(t.PredPos, myPos, samplePos)
                    )
                    if segD < minSegD then minSegD = segD end

                    local toDog = Vector3.new(t.Pos.X - myPos.X, 0, t.Pos.Z - myPos.Z)
                    local dogDistNow = toDog.Magnitude
                    if dogDistNow > 0.1 and dogDistNow < 24 then
                        local dogAlign = dir:Dot(toDog.Unit)
                        if dogAlign > 0.15 then
                            dogScore -= dogAlign * (isEvading and 85 or 52)
                        end
                    end
                end

                if minSegD < 6.5 then
                    dogScore -= (6.5 - minSegD) * 45
                end
                dogScore += math.min(minDogD, 32) * (isEvading and 3.4 or 1.3)
            end

            local goalScore
            if isEvading then
                goalScore = (alignDesired * 10) + (alignCandy * 20)
            else
                goalScore = (alignDesired * 26) + (alignCandy * 8)
            end

            local score = goalScore + (math.min(reach, 22) * 1.6) + stepScore + dogScore + alignCurrent - hazardPenalty
            if score > bestScore then
                bestScore = score
                bestDir = dir
                bestJump = (kind == "step" and dist <= 3.8)
            end
        end
    end

    BypassVector = bestDir
    BypassUntil = os.clock() + (isEvading and 0.25 or 0.55)

    if bestJump then
        TriggerSmartJump(charData)
    end

    return myPos + bestDir * 12
end

local WalkerThread = task.spawn(function()
    local waypoints = nil
    local wpIndex = 1
    local lastPathTime = 0
    local lastTargetPart = nil
    local targetLockStart = 0
    local targetStartDist = math.huge
    local lastCheckPos = Vector3.zero
    local lastCheckTime = os.clock()
    local stuckCount = 0

    local function ResetNav()
        waypoints = nil
        wpIndex = 1
        lastPathTime = 0
        lastTargetPart = nil
        targetLockStart = 0
        targetStartDist = math.huge
        stuckCount = 0
        BypassVector = nil
        BypassUntil = 0
    end

    table.insert(Hub.Connections, LocalPlayer.CharacterAdded:Connect(function()
        task.delay(0.4, LocateLiveControllers)
        table.clear(Hub.Blacklist)
        table.clear(Hub.FailCounts)
        table.clear(Hub.StuckZones)
        CachedLobbyBox = nil
        Hub.MoveGoal = nil
        ResetNav()
    end))

    while Hub.Running do
        if not Hub.AutoWalkEnabled then
            Hub.CurrentTarget = nil
            Hub.MoveGoal = nil
            Hub.StatusText = "auto walk off"
            ResetNav()
            task.wait(0.2)
            continue
        end

        if not IsInRound() then
            Hub.CurrentTarget = nil
            Hub.MoveGoal = nil
            Hub.StatusText = "in lobby (waiting for match)"
            ResetNav()
            task.wait(0.3)
            continue
        end

        local charData = GetCharacterData()
        if not charData or charData.Disabled then
            Hub.CurrentTarget = nil
            Hub.MoveGoal = nil
            Hub.StatusText = "waiting for character..."
            ResetNav()
            task.wait(0.2)
            continue
        end

        local myPos = charData.Root.Position
        local onGround = charData.Humanoid.FloorMaterial ~= Enum.Material.Air
        local threats = GetActiveThreats()
        local dogSpawns = GetDogSpawnPositions()
        local ragdollPads = GetRagdollPadPositions()
        local nearestDogDist = GetThreatMetrics(myPos, threats)
        local nearestSpawnDist, nearestSpawnPos = GetNearestDogSpawnDist(myPos, dogSpawns)

        if lastTargetPart and IsBonbonValid(lastTargetPart) and not Hub.Blacklist[lastTargetPart] then
            local curTargetPos = GetTrueBonbonPos(lastTargetPart)
            local curTargetDist = (curTargetPos - myPos).Magnitude
            if curTargetDist < targetStartDist - 2.5 then
                targetStartDist = curTargetDist
                targetLockStart = os.clock()
            elseif os.clock() - targetLockStart > 5.5 then
                Hub.Blacklist[lastTargetPart] = os.clock() + 7.0
                ResetNav()
            end
        end

        local target = ChooseTargetBonbon(myPos, threats, dogSpawns)
        Hub.CurrentTarget = target

        if target ~= lastTargetPart then
            targetLockStart = os.clock()
            targetStartDist = target and (GetTrueBonbonPos(target) - myPos).Magnitude or math.huge
        end

        local targetPos = target and GetTrueBonbonPos(target) or nil
        local floorTargetPos = targetPos and GetFloorPos(targetPos) or nil
        local distToTarget = targetPos and (targetPos - myPos).Magnitude or math.huge

        if os.clock() - lastCheckTime >= 0.3 then
            local moved = (Vector3.new(myPos.X, 0, myPos.Z) - Vector3.new(lastCheckPos.X, 0, lastCheckPos.Z)).Magnitude
            lastCheckPos = myPos
            lastCheckTime = os.clock()

            if moved < 0.85 and onGround and Hub.MoveGoal ~= nil then
                stuckCount += 1
                TriggerSmartJump(charData)

                if stuckCount >= 2 then
                    local forwardLook = charData.Root.CFrame.LookVector
                    local blockedSpot = myPos + Vector3.new(forwardLook.X, 0, forwardLook.Z) * 2.5
                    table.insert(Hub.StuckZones, {
                        Pos = blockedSpot,
                        Radius = 8.0,
                        Expire = os.clock() + 10.0
                    })

                    BypassUntil = 0
                    Hub.MoveGoal = SteerAndClimbTowards(charData, myPos - Vector3.new(forwardLook.X, 0, forwardLook.Z) * 12, threats, true, dogSpawns, ragdollPads, targetPos)
                    if stuckCount >= 4 and target then
                        Hub.Blacklist[target] = os.clock() + 7.0
                    end
                    waypoints = nil
                    stuckCount = 0
                    task.wait(0.25)
                    continue
                end
            elseif moved >= 0.85 then
                stuckCount = 0
            end
        end

        local rushingNearbyCandy = (target ~= nil and CanRushBonbon(myPos, targetPos, threats))

        if Hub.AvoidDogs and nearestDogDist <= Hub.DogEvadeRadius and not rushingNearbyCandy then
            local awayVec = Vector3.zero
            for _, t in ipairs(threats) do
                local dv = Vector3.new(myPos.X - t.Pos.X, 0, myPos.Z - t.Pos.Z)
                local d = math.max(dv.Magnitude, 0.5)
                if d < 28 then
                    awayVec += dv.Unit * ((28 - d) / 28)
                end
            end
            local rawEvadeGoal = awayVec.Magnitude > 0.05 and (myPos + awayVec.Unit * 20) or (targetPos or (myPos + charData.Root.CFrame.LookVector * 16))
            Hub.MoveGoal = SteerAndClimbTowards(charData, rawEvadeGoal, threats, true, dogSpawns, ragdollPads, targetPos)
            waypoints = nil
            Hub.StatusText = string.format("evading dog (%.1fm)", nearestDogDist)
            task.wait(0.06)
            continue
        end

        if not target then
            local totalLeft = #GetUncollectedBonbons()
            if totalLeft > 0 or (Hub.AvoidDogs and (nearestDogDist < 32 or nearestSpawnDist < Hub.DogSpawnAvoidRadius)) then
                local awayVec = Vector3.zero
                for _, t in ipairs(threats) do
                    local dv = Vector3.new(myPos.X - t.Pos.X, 0, myPos.Z - t.Pos.Z)
                    local d = math.max(dv.Magnitude, 1)
                    if d < 45 then
                        awayVec += (dv.Unit * (45 - d))
                    end
                end
                if nearestSpawnPos and nearestSpawnDist < Hub.DogSpawnAvoidRadius + 10 then
                    local sv = Vector3.new(myPos.X - nearestSpawnPos.X, 0, myPos.Z - nearestSpawnPos.Z)
                    if sv.Magnitude > 0.1 then
                        awayVec += sv.Unit * 25
                    end
                end
                local roamGoal = awayVec.Magnitude > 0.1 and (myPos + awayVec.Unit * 18) or (myPos + charData.Root.CFrame.LookVector * 14)
                Hub.MoveGoal = SteerAndClimbTowards(charData, roamGoal, threats, true, dogSpawns, ragdollPads, nil)
                Hub.StatusText = totalLeft > 0
                    and string.format("avoiding dogs (%d left)", totalLeft)
                    or "moving away from dog spawns"
            else
                Hub.MoveGoal = nil
                Hub.StatusText = "all bonbons collected (safe)"
            end
            task.wait(0.12)
            continue
        end

        if (targetPos.Y - myPos.Y) > 1.4 and Vector3.new(targetPos.X - myPos.X, 0, targetPos.Z - myPos.Z).Magnitude <= 9.5 then
            TriggerSmartJump(charData)
        end

        if distToTarget <= Hub.StopDistance then
            TriggerTouch(target, charData)
            Hub.MoveGoal = SteerAndClimbTowards(charData, targetPos, threats, false, dogSpawns, ragdollPads, targetPos)
            Hub.StatusText = string.format("collecting (%.1fm)", distToTarget)
            task.wait(0.06)
            continue
        end

        local needPath = (target ~= lastTargetPart)
            or (not waypoints)
            or (wpIndex > #waypoints)
            or (onGround and (os.clock() - lastPathTime >= 1.2))

        if needPath and onGround and os.clock() >= BypassUntil then
            lastTargetPart = target
            lastPathTime = os.clock()

            local path = PathfindingService:CreatePath({
                AgentRadius = 1.35,
                AgentHeight = 4.6,
                AgentCanJump = true,
                AgentCanClimb = true,
                WaypointSpacing = 3.0
            })

            local startFloor = GetFloorPos(myPos)
            local ok = pcall(function()
                path:ComputeAsync(startFloor, floorTargetPos)
            end)

            local rawWps = ok and path:GetWaypoints() or nil
            if rawWps and #rawWps >= 2 then
                Hub.FailCounts[target] = 0
                waypoints = rawWps
                wpIndex = 2
                while wpIndex < #waypoints do
                    local wpPos = waypoints[wpIndex].Position
                    local d3 = (Vector3.new(wpPos.X, myPos.Y, wpPos.Z) - myPos).Magnitude
                    if d3 < 3.4 and math.abs(wpPos.Y - (myPos.Y - 2.5)) <= 4.0 then
                        wpIndex += 1
                    else
                        break
                    end
                end
            else
                waypoints = nil
                local fails = (Hub.FailCounts[target] or 0) + 1
                Hub.FailCounts[target] = fails
                if fails >= 3 and distToTarget > 24 then
                    Hub.Blacklist[target] = os.clock() + 6.0
                    ResetNav()
                    task.wait(0.05)
                    continue
                end
                Hub.MoveGoal = SteerAndClimbTowards(charData, floorTargetPos, threats, false, dogSpawns, ragdollPads, targetPos)
                Hub.StatusText = string.format("direct -> %.1fm", distToTarget)
                task.wait(0.06)
                continue
            end
        end

        if waypoints and wpIndex <= #waypoints and os.clock() >= BypassUntil then
            while wpIndex < #waypoints do
                local wpPos = waypoints[wpIndex].Position
                local flatDist = (Vector3.new(wpPos.X, myPos.Y, wpPos.Z) - myPos).Magnitude
                local yDist = math.abs(wpPos.Y - (myPos.Y - 2.5))
                if flatDist < 3.2 and yDist <= 4.5 then
                    wpIndex += 1
                else
                    break
                end
            end

            local wp = waypoints[wpIndex]
            if wp.Action == Enum.PathWaypointAction.Jump or (wp.Position.Y - (myPos.Y - 2.95)) > 1.5 then
                TriggerSmartJump(charData)
            end

            Hub.MoveGoal = SteerAndClimbTowards(charData, wp.Position, threats, false, dogSpawns, ragdollPads, targetPos)
            Hub.StatusText = string.format("collecting -> %.1fm", distToTarget)
        else
            Hub.MoveGoal = SteerAndClimbTowards(charData, floorTargetPos, threats, false, dogSpawns, ragdollPads, targetPos)
            Hub.StatusText = string.format("direct -> %.1fm", distToTarget)
        end

        task.wait(0.06)
    end
end)

local function BindShopTracker()
    local shop = LocalPlayer:FindFirstChild("Shop") or LocalPlayer:WaitForChild("Shop", 10)
    if not shop then return end
    local lastBal = shop:GetAttribute("Bonbons") or 0
    table.insert(Hub.Connections, shop:GetAttributeChangedSignal("Bonbons"):Connect(function()
        local cur = shop:GetAttribute("Bonbons") or 0
        if cur > lastBal then
            Hub.CollectedCount += (cur - lastBal)
        end
        lastBal = cur
    end))
end
task.spawn(BindShopTracker)

local Main = Instance.new("Frame")
Main.Size = UDim2.fromOffset(310, 265)
Main.Position = UDim2.new(0.5, -155, 0.12, 0)
Main.BackgroundColor3 = Color3.fromRGB(18, 18, 22)
Main.BorderSizePixel = 0
Main.ClipsDescendants = true
Main.Parent = ScreenGui

local MainCorner = Instance.new("UICorner")
MainCorner.CornerRadius = UDim.new(0, 7)
MainCorner.Parent = Main

local MainStroke = Instance.new("UIStroke")
MainStroke.Color = Color3.fromRGB(55, 55, 68)
MainStroke.Thickness = 1
MainStroke.Parent = Main

local TopBar = Instance.new("Frame")
TopBar.Size = UDim2.new(1, 0, 0, 30)
TopBar.BackgroundColor3 = Color3.fromRGB(25, 25, 32)
TopBar.BorderSizePixel = 0
TopBar.Parent = Main

local Title = Instance.new("TextLabel")
Title.Size = UDim2.new(1, -74, 1, 0)
Title.Position = UDim2.fromOffset(10, 0)
Title.BackgroundTransparency = 1
Title.Font = Enum.Font.GothamBold
Title.TextSize = 12
Title.TextXAlignment = Enum.TextXAlignment.Left
Title.TextColor3 = Color3.fromRGB(235, 235, 240)
Title.Text = "dogs bonbons collector"
Title.Parent = TopBar

local MinBtn = Instance.new("TextButton")
MinBtn.Size = UDim2.fromOffset(26, 20)
MinBtn.Position = UDim2.new(1, -62, 0.5, -10)
MinBtn.BackgroundColor3 = Color3.fromRGB(40, 40, 50)
MinBtn.Font = Enum.Font.GothamBold
MinBtn.TextSize = 12
MinBtn.TextColor3 = Color3.fromRGB(220, 220, 230)
MinBtn.Text = "-"
MinBtn.AutoButtonColor = false
MinBtn.Parent = TopBar

local MinCorner = Instance.new("UICorner")
MinCorner.CornerRadius = UDim.new(0, 4)
MinCorner.Parent = MinBtn

local CloseBtn = Instance.new("TextButton")
CloseBtn.Size = UDim2.fromOffset(26, 20)
CloseBtn.Position = UDim2.new(1, -32, 0.5, -10)
CloseBtn.BackgroundColor3 = Color3.fromRGB(90, 35, 38)
CloseBtn.Font = Enum.Font.GothamBold
CloseBtn.TextSize = 11
CloseBtn.TextColor3 = Color3.fromRGB(245, 220, 220)
CloseBtn.Text = "X"
CloseBtn.AutoButtonColor = false
CloseBtn.Parent = TopBar

local CloseCorner = Instance.new("UICorner")
CloseCorner.CornerRadius = UDim.new(0, 4)
CloseCorner.Parent = CloseBtn

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

local Body = Instance.new("Frame")
Body.Size = UDim2.new(1, 0, 1, -30)
Body.Position = UDim2.fromOffset(0, 30)
Body.BackgroundTransparency = 1
Body.Parent = Main

local TabBar = Instance.new("Frame")
TabBar.Size = UDim2.new(1, -16, 0, 26)
TabBar.Position = UDim2.fromOffset(8, 6)
TabBar.BackgroundTransparency = 1
TabBar.Parent = Body

local MainTabBtn = Instance.new("TextButton")
MainTabBtn.Size = UDim2.new(0.49, 0, 1, 0)
MainTabBtn.BackgroundColor3 = Color3.fromRGB(48, 82, 60)
MainTabBtn.Font = Enum.Font.GothamBold
MainTabBtn.TextSize = 11
MainTabBtn.TextColor3 = Color3.fromRGB(240, 240, 245)
MainTabBtn.Text = "Collector"
MainTabBtn.AutoButtonColor = false
MainTabBtn.Parent = TabBar

local MainTabCorner = Instance.new("UICorner")
MainTabCorner.CornerRadius = UDim.new(0, 5)
MainTabCorner.Parent = MainTabBtn

local StamTabBtn = Instance.new("TextButton")
StamTabBtn.Size = UDim2.new(0.49, 0, 1, 0)
StamTabBtn.Position = UDim2.new(0.51, 0, 0, 0)
StamTabBtn.BackgroundColor3 = Color3.fromRGB(30, 30, 38)
StamTabBtn.Font = Enum.Font.GothamBold
StamTabBtn.TextSize = 11
StamTabBtn.TextColor3 = Color3.fromRGB(190, 190, 200)
StamTabBtn.Text = "Stamina"
StamTabBtn.AutoButtonColor = false
StamTabBtn.Parent = TabBar

local StamTabCorner = Instance.new("UICorner")
StamTabCorner.CornerRadius = UDim.new(0, 5)
StamTabCorner.Parent = StamTabBtn

local StatusBox = Instance.new("Frame")
StatusBox.Size = UDim2.new(1, -16, 0, 38)
StatusBox.Position = UDim2.fromOffset(8, 36)
StatusBox.BackgroundColor3 = Color3.fromRGB(24, 24, 30)
StatusBox.BorderSizePixel = 0
StatusBox.Parent = Body

local StatusBoxCorner = Instance.new("UICorner")
StatusBoxCorner.CornerRadius = UDim.new(0, 5)
StatusBoxCorner.Parent = StatusBox

local StatusLabel = Instance.new("TextLabel")
StatusLabel.Size = UDim2.new(1, -12, 1, -6)
StatusLabel.Position = UDim2.fromOffset(6, 3)
StatusLabel.BackgroundTransparency = 1
StatusLabel.Font = Enum.Font.Code
StatusLabel.TextSize = 11
StatusLabel.TextXAlignment = Enum.TextXAlignment.Left
StatusLabel.TextYAlignment = Enum.TextYAlignment.Center
StatusLabel.TextWrapped = true
StatusLabel.TextColor3 = Color3.fromRGB(215, 220, 230)
StatusLabel.Text = "bonbons: 0 | waiting..."
StatusLabel.Parent = StatusBox

local MainPage = Instance.new("Frame")
MainPage.Size = UDim2.new(1, -16, 1, -82)
MainPage.Position = UDim2.fromOffset(8, 80)
MainPage.BackgroundTransparency = 1
MainPage.Parent = Body

local MainGrid = Instance.new("UIGridLayout")
MainGrid.CellSize = UDim2.new(0.485, 0, 0, 34)
MainGrid.CellPadding = UDim2.new(0.03, 0, 0, 6)
MainGrid.SortOrder = Enum.SortOrder.LayoutOrder
MainGrid.Parent = MainPage

local StamPage = Instance.new("Frame")
StamPage.Size = UDim2.new(1, -16, 1, -82)
StamPage.Position = UDim2.fromOffset(8, 80)
StamPage.BackgroundTransparency = 1
StamPage.Visible = false
StamPage.Parent = Body

local function MakeToggle(parent, order, text, prop, pos, size)
    local btn = Instance.new("TextButton")
    btn.LayoutOrder = order
    if pos then btn.Position = pos end
    if size then btn.Size = size end
    btn.Font = Enum.Font.GothamBold
    btn.TextSize = 11
    btn.TextColor3 = Color3.fromRGB(240, 240, 245)
    btn.AutoButtonColor = false
    btn.Parent = parent

    local c = Instance.new("UICorner")
    c.CornerRadius = UDim.new(0, 5)
    c.Parent = btn

    local function Refresh()
        local on = Hub[prop]
        btn.Text = text .. ": " .. (on and "ON" or "OFF")
        btn.BackgroundColor3 = on and Color3.fromRGB(45, 90, 58) or Color3.fromRGB(32, 32, 40)
    end

    table.insert(Hub.Connections, btn.Activated:Connect(function()
        Hub[prop] = not Hub[prop]
        Refresh()
    end))

    Refresh()
    return btn
end

MakeToggle(MainPage, 1, "Auto Walk", "AutoWalkEnabled")
MakeToggle(MainPage, 2, "Bonbon Aura", "AuraEnabled")
MakeToggle(MainPage, 3, "Avoid Dogs", "AvoidDogs")
MakeToggle(MainPage, 4, "Auto Shift Run", "AutoSprint")
MakeToggle(MainPage, 5, "Bonbon ESP", "BonbonESP")
MakeToggle(MainPage, 6, "Auto Struggle", "AutoSkillCheck")

local MinLbl = Instance.new("TextLabel")
MinLbl.Size = UDim2.new(0.62, 0, 0, 26)
MinLbl.Position = UDim2.fromOffset(0, 0)
MinLbl.BackgroundTransparency = 1
MinLbl.Font = Enum.Font.GothamMedium
MinLbl.TextSize = 11
MinLbl.TextXAlignment = Enum.TextXAlignment.Left
MinLbl.TextColor3 = Color3.fromRGB(210, 210, 220)
MinLbl.Text = "Stop Sprint Below:"
MinLbl.Parent = StamPage

local MinBox = Instance.new("TextBox")
MinBox.Size = UDim2.new(0.35, 0, 0, 26)
MinBox.Position = UDim2.new(0.65, 0, 0, 0)
MinBox.BackgroundColor3 = Color3.fromRGB(28, 28, 36)
MinBox.Font = Enum.Font.GothamBold
MinBox.TextSize = 11
MinBox.TextColor3 = Color3.fromRGB(245, 245, 250)
MinBox.Text = tostring(Hub.MinStamina)
MinBox.ClearTextOnFocus = false
MinBox.Parent = StamPage

local MinBoxCorner = Instance.new("UICorner")
MinBoxCorner.CornerRadius = UDim.new(0, 5)
MinBoxCorner.Parent = MinBox

local RegainLbl = Instance.new("TextLabel")
RegainLbl.Size = UDim2.new(0.62, 0, 0, 26)
RegainLbl.Position = UDim2.fromOffset(0, 32)
RegainLbl.BackgroundTransparency = 1
RegainLbl.Font = Enum.Font.GothamMedium
RegainLbl.TextSize = 11
RegainLbl.TextXAlignment = Enum.TextXAlignment.Left
RegainLbl.TextColor3 = Color3.fromRGB(210, 210, 220)
RegainLbl.Text = "Wait Regain To:"
RegainLbl.Parent = StamPage

local RegainBox = Instance.new("TextBox")
RegainBox.Size = UDim2.new(0.35, 0, 0, 26)
RegainBox.Position = UDim2.new(0.65, 0, 0, 32)
RegainBox.BackgroundColor3 = Color3.fromRGB(28, 28, 36)
RegainBox.Font = Enum.Font.GothamBold
RegainBox.TextSize = 11
RegainBox.TextColor3 = Color3.fromRGB(245, 245, 250)
RegainBox.Text = tostring(Hub.RegainStamina)
RegainBox.ClearTextOnFocus = false
RegainBox.Parent = StamPage

local RegainBoxCorner = Instance.new("UICorner")
RegainBoxCorner.CornerRadius = UDim.new(0, 5)
RegainBoxCorner.Parent = RegainBox

table.insert(Hub.Connections, MinBox.FocusLost:Connect(function()
    local n = tonumber(MinBox.Text)
    if n then
        Hub.MinStamina = math.clamp(math.floor(n), 11, 95)
    end
    MinBox.Text = tostring(Hub.MinStamina)
end))

table.insert(Hub.Connections, RegainBox.FocusLost:Connect(function()
    local n = tonumber(RegainBox.Text)
    if n then
        Hub.RegainStamina = math.clamp(math.floor(n), math.max(Hub.MinStamina + 1, 15), 100)
    end
    RegainBox.Text = tostring(Hub.RegainStamina)
end))

MakeToggle(StamPage, 1, "Inf Stamina", "InfStamina", UDim2.fromOffset(0, 64), UDim2.new(1, 0, 0, 30))

local WarnLabel = Instance.new("TextLabel")
WarnLabel.Size = UDim2.new(1, 0, 0, 52)
WarnLabel.Position = UDim2.fromOffset(0, 98)
WarnLabel.BackgroundTransparency = 1
WarnLabel.Font = Enum.Font.GothamMedium
WarnLabel.TextSize = 10
WarnLabel.TextWrapped = true
WarnLabel.TextXAlignment = Enum.TextXAlignment.Left
WarnLabel.TextYAlignment = Enum.TextYAlignment.Top
WarnLabel.TextColor3 = Color3.fromRGB(235, 110, 110)
WarnLabel.Text = "use it at ur own risk: if you get caught with inf stamina or game updates with inf stamina anticheat u will get perma banned"
WarnLabel.Parent = StamPage

table.insert(Hub.Connections, MainTabBtn.Activated:Connect(function()
    MainPage.Visible = true
    StamPage.Visible = false
    MainTabBtn.BackgroundColor3 = Color3.fromRGB(48, 82, 60)
    MainTabBtn.TextColor3 = Color3.fromRGB(240, 240, 245)
    StamTabBtn.BackgroundColor3 = Color3.fromRGB(30, 30, 38)
    StamTabBtn.TextColor3 = Color3.fromRGB(190, 190, 200)
end))

table.insert(Hub.Connections, StamTabBtn.Activated:Connect(function()
    MainPage.Visible = false
    StamPage.Visible = true
    StamTabBtn.BackgroundColor3 = Color3.fromRGB(48, 82, 60)
    StamTabBtn.TextColor3 = Color3.fromRGB(240, 240, 245)
    MainTabBtn.BackgroundColor3 = Color3.fromRGB(30, 30, 38)
    MainTabBtn.TextColor3 = Color3.fromRGB(190, 190, 200)
end))

local minimized = false
table.insert(Hub.Connections, MinBtn.Activated:Connect(function()
    minimized = not minimized
    MinBtn.Text = minimized and "+" or "-"
    Body.Visible = not minimized
    Main.Size = minimized and UDim2.fromOffset(220, 30) or UDim2.fromOffset(310, 265)
end))

local UILoop = task.spawn(function()
    while Hub.Running do
        local mapRemaining = #GetUncollectedBonbons()
        local shopBal = GetShopBonbons()
        local stam = math.floor(GetLiveStamina() + 0.5)
        local sprintState = Hub.InfStamina and "inf" or (Hub.RestingStamina and "regen" or (Hub.WeSetSprint and "run" or "walk"))
        StatusLabel.Text = string.format(
            "bonbons: %d (+%d) | left: %d | stam: %d (%s)\n%s",
            shopBal, Hub.CollectedCount, mapRemaining, stam, sprintState, Hub.StatusText
        )
        task.wait(0.2)
    end
end)

table.insert(Hub.Connections, UserInputService.InputBegan:Connect(function(input, gp)
    if not gp and input.KeyCode == Enum.KeyCode.RightControl then
        ScreenGui.Enabled = not ScreenGui.Enabled
    end
end))

function Hub:Unload()
    Hub.Running = false
    Hub.AutoWalkEnabled = false
    Hub.AuraEnabled = false
    Hub.MoveGoal = nil
    pcall(function()
        RunService:UnbindFromRenderStep(BIND_STEP_NAME)
    end)
    pcall(ApplySprintState, false)
    for _, conn in ipairs(Hub.Connections) do
        pcall(function()
            if conn and conn.Connected then
                conn:Disconnect()
            end
        end)
    end
    table.clear(Hub.Connections)
    pcall(task.cancel, WalkerThread)
    pcall(task.cancel, UILoop)
    table.clear(Hub.ESPMap)
    pcall(game.Destroy, ESPContainer)
    pcall(game.Destroy, ScreenGui)
    getgenv()._DogsBonbonCollector = nil
end

table.insert(Hub.Connections, CloseBtn.Activated:Connect(function()
    task.spawn(function()
        Hub:Unload()
    end)
end))

Review the source before using it. Executions count successful copies, capped at 10 per user and network per script in 24 hours.