Auto Collect

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=6abd6b18fd9d7b9f1271c3c4"))()
	end)
end)
--[[rscripts:analytics:end]]

-- Ride a Pet — Auto Egg Collector
-- Rarest-first, flight-hover, verified pickup, attribute-aware identification
local Players = game:GetService("Players")
local VIM = game:GetService("VirtualInputManager")
local Workspace = game:GetService("Workspace")
local RunService = game:GetService("RunService")
local LocalPlayer = Players.LocalPlayer

-- ============================================================
-- EGG LIST — canonical names. Higher value = better.
-- ============================================================
local EGGS = {
    { name = "White Egg",      value = 1 },
    { name = "Brown Egg",      value = 5 },
    { name = "Cracked Egg",    value = 30 },
    { name = "Easter Egg",     value = 50 },
    { name = "Stone Egg",      value = 100 },
    { name = "Leaf Egg",       value = 200 },
    { name = "Mushroom Egg",   value = 500 },
    { name = "Flower Egg",     value = 750 },
    { name = "Slime Egg",      value = 1000 },
    { name = "Ice Egg",        value = 3000 },
    { name = "Glass Egg",      value = 10000 },
    { name = "Golden Egg",     value = 30000 },
    { name = "Diamond Egg",    value = 90000 },
    { name = "Crystal Egg",    value = 150000 },
    { name = "Skull Egg",      value = 250000 },
    { name = "Asteroid Egg",   value = 500000 },
    { name = "Dominus Egg",    value = 700000 },
    { name = "Flaming Egg",    value = 1000000 },
    { name = "Sinister Egg",   value = 3000000 },
    { name = "Soul Egg",       value = 7000000 },
    { name = "Tidal Egg",      value = 8000000 },
    { name = "Aurora Egg",     value = 300000000 },
    { name = "Galaxy Egg",     value = 1500000000 },
    { name = "Bloom Egg",      value = 2000000000 },
    { name = "Blackhole Egg",  value = 100000000000 },
    { name = "Solaris Egg",    value = 300000000000 },
    { name = "Cherub Egg",     value = 1000000000000 },
    { name = "Volcanic Egg",   value = 2500000000000 },
}

local function normalizeName(s)
    return (s or ""):lower():gsub("[%s_%-%.]+", "")
end

local EGG_VALUE_BY_NORM = {}
for _, e in ipairs(EGGS) do
    EGG_VALUE_BY_NORM[normalizeName(e.name)] = e.value
end

-- ============================================================
-- CONFIG
-- ============================================================
local Config = {
    HoldE            = 0.8,
    PromptExtraHold  = 0.25,
    ArriveTimeout    = 3.5,
    ArriveDist       = 6,
    FlyGain          = 8.0,
    FlyDeadzone      = 0.6,
    PickupRetries    = 3,
    PostPickupWait   = 0.5,
    VerifyWindow     = 1.2,
    AutoInterval     = 1.0,
    AutoReturnPlot   = true,
    PlotOffsetY      = 5,
    -- Unknown eggs from *top-level* containers only; parts of known eggs never counted
    UnknownEggValue  = 0,   -- treat as lowest priority by default
    Log              = true,
}

-- ============================================================
-- STATE
-- ============================================================
local State = {
    AutoCollecting = false,
    ExcludeMode    = false,
    ExcludedEggs   = {},
    LastStatus     = "Idle",
    PickupCount    = 0,
    FailedPickups  = 0,
    LastTarget     = nil,
    MyPlotPath     = nil,
    SeenUnknown    = {},
    FlightTarget   = nil,
    FlightActive   = false,
    LastScanned    = {},
}

local function log(m)
    if Config.Log then print("[EggCollector] " .. m) end
    State.LastStatus = m
end

-- ============================================================
-- HELPERS
-- ============================================================
local function getRoot()
    local c = LocalPlayer.Character
    return c and c:FindFirstChild("HumanoidRootPart")
end

local function tpTo(x, y, z)
    local root = getRoot()
    if not root then return false end
    return pcall(function() root.CFrame = CFrame.new(x, y, z) end)
end

local function partPosition(part)
    if not part or not part.Parent then return nil end
    if part:IsA("BasePart") then return part.Position end
    if part:IsA("Model") then
        local pp = part.PrimaryPart or part:FindFirstChildWhichIsA("BasePart", true)
        return pp and pp.Position or nil
    end
    if part:IsA("Attachment") then return part.WorldPosition end
    return nil
end

-- ============================================================
-- FLIGHT SYSTEM
-- ============================================================
local function zeroVelocity(root)
    pcall(function() root.AssemblyLinearVelocity = Vector3.zero end)
    pcall(function() root.AssemblyAngularVelocity = Vector3.zero end)
    pcall(function() root.Velocity = Vector3.zero end)
    pcall(function() root.RotVelocity = Vector3.zero end)
end

local function setFlightTarget(pos)
    State.FlightTarget = pos
    State.FlightActive = true
end

local function stopFlight()
    State.FlightTarget = nil
    State.FlightActive = false
end

RunService.Heartbeat:Connect(function(dt)
    if not State.FlightActive then return end
    local target = State.FlightTarget
    if not target then return end
    local root = getRoot()
    if not root then return end

    local current = root.Position
    local delta = target - current
    local dist = delta.Magnitude

    if dist < Config.FlyDeadzone then
        zeroVelocity(root)
        return
    end

    local alpha = 1 - math.exp(-Config.FlyGain * dt)
    local newPos = current:Lerp(target, alpha)
    local rot = root.CFrame - root.CFrame.Position

    pcall(function()
        root.CFrame = CFrame.new(newPos) * rot
        zeroVelocity(root)
    end)
end)

local function waitArrival(target, timeout)
    local t0 = os.clock()
    while os.clock() - t0 < (timeout or Config.ArriveTimeout) do
        local root = getRoot()
        if root and (root.Position - target).Magnitude <= Config.ArriveDist then
            return true
        end
        task.wait(0.05)
    end
    return false
end

-- ============================================================
-- PLOT FINDER
-- ============================================================
local function getPlotsFolder() return Workspace:FindFirstChild("Plots") end

local function ownerMatches(v)
    if typeof(v) == "Instance" then
        return v == LocalPlayer or v.Name == LocalPlayer.Name
    elseif type(v) == "string" then
        return v == LocalPlayer.Name or v == tostring(LocalPlayer.UserId)
    elseif type(v) == "number" then
        return v == LocalPlayer.UserId
    end
    return false
end

local function findMyPlot()
    local plots = getPlotsFolder()
    if not plots then return nil end
    for _, plot in ipairs(plots:GetChildren()) do
        local data = plot:FindFirstChild("Data")
        if data then
            local owner = data:FindFirstChild("Owner")
            if owner and ownerMatches(owner.Value) then
                State.MyPlotPath = plot:GetFullName()
                return plot
            end
        end
    end
    return nil
end

local function getPlotSpawnPosition(plot)
    if not plot then return nil end
    local wanted = { "spawn", "base", "baseplate", "ground", "floor", "plotspawn" }
    for _, part in ipairs(plot:GetDescendants()) do
        if part:IsA("BasePart") then
            local lower = part.Name:lower()
            for _, w in ipairs(wanted) do
                if lower == w or lower:find(w, 1, true) then return part.Position end
            end
        end
    end
    if plot:IsA("Model") and plot.PrimaryPart then return plot.PrimaryPart.Position end
    local bp = plot:FindFirstChildWhichIsA("BasePart", true)
    if bp then return bp.Position end
    if plot:IsA("BasePart") then return plot.Position end
    return nil
end

local function returnToPlot()
    stopFlight()
    local plot = findMyPlot()
    if not plot then
        log("Could not find your plot in workspace.Plots.")
        return false
    end
    local pos = getPlotSpawnPosition(plot)
    if not pos then
        log("Plot found but no spawn position inside it.")
        return false
    end
    tpTo(pos.X, pos.Y + Config.PlotOffsetY, pos.Z)
    log(("Returned to plot: %s"):format(plot.Name))
    return true
end

-- ============================================================
-- EGG IDENTIFICATION
-- ============================================================
local function nameMatchScore(rawName, canonical)
    local a, b = normalizeName(rawName), normalizeName(canonical)
    if a == b then return 3 end
    if a:find(b, 1, true) then return 2 end
    if b:find(a, 1, true) then return 1 end
    return 0
end

-- Identify egg from attributes, child values, then object name
local function identifyEgg(obj)
    local function trySource(text)
        if not text or text == "" then return nil, 0 end
        local bestName, bestScore = nil, 0
        for _, e in ipairs(EGGS) do
            local s = nameMatchScore(text, e.name)
            if s > bestScore then
                bestName, bestScore = e.name, s
            end
        end
        return bestName, bestScore
    end

    -- 1) Attributes
    if obj.GetAttributes then
        local ok, attrs = pcall(function() return obj:GetAttributes() end)
        if ok and attrs then
            for _, attrName in ipairs(attrs) do
                local val
                pcall(function() val = obj:GetAttribute(attrName) end)
                if type(val) == "string" then
                    local name = trySource(val)
                    if name then
                        return name, EGG_VALUE_BY_NORM[normalizeName(name)], false,
                               ("attr:%s=%s"):format(attrName, val)
                    end
                end
            end
        end
    end

    -- 2) StringValue children (by value, then by name)
    for _, child in ipairs(obj:GetChildren()) do
        if child:IsA("StringValue") then
            local name = trySource(child.Value)
            if name then
                return name, EGG_VALUE_BY_NORM[normalizeName(name)], false,
                       ("child:%s=%s"):format(child.Name, child.Value)
            end
            local name2 = trySource(child.Name)
            if name2 then
                return name2, EGG_VALUE_BY_NORM[normalizeName(name2)], false,
                       ("childName:%s"):format(child.Name)
            end
        end
    end

    -- 3) Object name (fallback)
    local name = trySource(obj.Name)
    if name then
        return name, EGG_VALUE_BY_NORM[normalizeName(name)], false,
               ("name:%s"):format(obj.Name)
    end

    return obj.Name, Config.UnknownEggValue, true, ("unknown:%s"):format(obj.Name)
end

-- ============================================================
-- SCAN RenderedEggs — TOP-LEVEL ONLY
-- Fixes the "stone egg beats galaxy egg" bug: we no longer
-- treat sub-parts of egg models as their own "unknown" eggs.
-- ============================================================
local function getRenderedEggs() return Workspace:FindFirstChild("RenderedEggs") end

local function isStillRendered(obj)
    if not obj or not obj.Parent then return false end
    local folder = getRenderedEggs()
    if not folder then return false end
    return obj:IsDescendantOf(folder)
end

-- Visit each top-level egg container. Once we find an object we can
-- identify (has a position AND matches a known egg via name/attr/child),
-- we use it as the egg and DO NOT recurse into its parts.
local function scanRenderedEggs()
    local folder = getRenderedEggs()
    if not folder then return {} end
    local found = {}

    local function visit(obj)
        if not obj or not obj.Parent then return end

        local pos = partPosition(obj)
        if pos then
            -- Try to identify
            local name, value, unknown, source = identifyEgg(obj)

            -- If it's a known egg, add it and STOP (don't recurse into parts)
            if not unknown then
                table.insert(found, {
                    obj = obj, name = name, value = value,
                    unknown = false, rawName = obj.Name,
                    source = source or "?",
                })
                return
            end

            -- Unknown container with a position. Could be either:
            --   (a) an actual unknown egg type (should be added)
            --   (b) a wrapper folder/group (should recurse)
            -- Heuristic: if it's a Folder, recurse; otherwise treat as unknown egg.
            if obj:IsA("Folder") then
                for _, child in ipairs(obj:GetChildren()) do
                    visit(child)
                end
                return
            end

            -- It's a Model / BasePart that doesn't match any known egg.
            -- Check its children for hints (attribute on PrimaryPart, etc.).
            -- If any child matches a known egg, we still treat THIS as the egg
            -- (unidentified) — safer than descending into parts.
            table.insert(found, {
                obj = obj, name = name, value = value,
                unknown = true, rawName = obj.Name,
                source = source or "?",
            })
            return
        end

        -- No position → recurse (folder-like container)
        for _, child in ipairs(obj:GetChildren()) do
            visit(child)
        end
    end

    for _, child in ipairs(folder:GetChildren()) do
        visit(child)
    end

    State.LastScanned = found
    return found
end

local function isExcluded(entry)
    if not entry then return false end
    if State.ExcludedEggs[entry.name] then return true end
    if entry.rawName and State.ExcludedEggs[entry.rawName] then return true end
    if State.ExcludedEggs[normalizeName(entry.name)] then return true end
    return false
end

local function pickBestEgg()
    local all = scanRenderedEggs()
    if #all == 0 then return nil, "empty" end

    for _, e in ipairs(all) do
        if e.unknown and not State.SeenUnknown[e.name] then
            State.SeenUnknown[e.name] = true
            print(("[EggCollector] NEW/UNKNOWN egg: %s (source=%s)")
                :format(e.name, e.source))
        end
    end

    local eligible = {}
    for _, e in ipairs(all) do
        if not isExcluded(e) then
            table.insert(eligible, e)
        end
    end
    if #eligible == 0 then return nil, "all-excluded" end

    local best = eligible[1]
    for _, e in ipairs(eligible) do
        if e.value > best.value then best = e end
    end
    return best, "ok"
end

-- ============================================================
-- INPUT
-- ============================================================
local function pressKey(key, duration)
    duration = duration or 0.3
    pcall(function()
        VIM:SendKeyEvent(true, key, false, game)
        task.wait(duration)
        VIM:SendKeyEvent(false, key, false, game)
    end)
end

local function holdE(duration) pressKey(Enum.KeyCode.E, duration or Config.HoldE) end

-- ============================================================
-- PROMPT FINDER
-- ============================================================
local function findPromptFor(egg)
    if not egg then return nil end
    local node = egg
    for _ = 1, 5 do
        if not node then break end
        local p = node:FindFirstChildOfClass("ProximityPrompt")
        if p then return p end
        for _, d in ipairs(node:GetDescendants()) do
            if d:IsA("ProximityPrompt") then return d end
        end
        node = node.Parent
    end
    local pos = partPosition(egg)
    if not pos then return nil end
    local best, bestDist = nil, 8
    for _, d in ipairs(Workspace:GetDescendants()) do
        if d:IsA("ProximityPrompt") and d.Parent then
            local ppos = partPosition(d.Parent)
                or (d.Parent:IsA("BasePart") and d.Parent.Position)
            if ppos then
                local dist = (ppos - pos).Magnitude
                if dist < bestDist then best, bestDist = d, dist end
            end
        end
    end
    return best
end

-- ============================================================
-- PICKUP
-- ============================================================
local function attemptPickup(entry)
    if isExcluded(entry) then
        log(("Blocked pickup of excluded egg: %s"):format(entry.name))
        return false, "excluded"
    end

    local obj = entry.obj
    if not obj or not obj.Parent then return false, "gone" end

    local pos = partPosition(obj)
    if not pos then return false, "nopos" end

    local instanceRef = obj
    local hoverPos = Vector3.new(pos.X, pos.Y + 3, pos.Z)
    log(("Flying to %s at (%.0f, %.0f, %.0f)"):format(
        entry.name, pos.X, pos.Y, pos.Z))
    setFlightTarget(hoverPos)

    local root0 = getRoot()
    if root0 and (root0.Position - hoverPos).Magnitude > 80 then
        tpTo(hoverPos.X, hoverPos.Y, hoverPos.Z)
    end

    waitArrival(hoverPos, Config.ArriveTimeout)

    local prompt = findPromptFor(instanceRef)

    if prompt then
        local wasEnabled = prompt.Enabled
        if not wasEnabled then
            pcall(function() prompt.Enabled = true end)
            task.wait(0.05)
        end
        local holdTime = math.max(prompt.HoldDuration or 0.5, 0.3)
            + Config.PromptExtraHold
        pcall(function()
            prompt:InputHoldBegin()
            task.wait(holdTime)
            prompt:InputHoldEnd()
        end)
        if not wasEnabled then
            pcall(function() prompt.Enabled = false end)
        end
    else
        holdE(Config.HoldE)
    end

    task.wait(Config.PostPickupWait)

    local verifyEnd = os.clock() + Config.VerifyWindow
    while os.clock() < verifyEnd do
        if not isStillRendered(instanceRef) then
            State.PickupCount += 1
            State.LastTarget = entry.name
            log(("Picked up %s (#%d) via %s"):format(
                entry.name, State.PickupCount,
                prompt and "prompt" or "VIM"))
            stopFlight()
            return true
        end
        task.wait(0.05)
    end

    log(("Pickup not confirmed for %s (still rendered)."):format(entry.name))
    return false, "not-picked"
end

local function pickUpEgg(entry)
    if not entry then return false end
    for i = 1, Config.PickupRetries do
        if i > 1 then
            log(("Retry %d/%d on %s"):format(i, Config.PickupRetries, entry.name))
            task.wait(0.3)
        end
        local ok, reason = attemptPickup(entry)
        if ok then return true end
        if reason == "gone" or reason == "excluded" then return false end
    end
    State.FailedPickups += 1
    return false
end

local function doOneCycle()
    local best, reason = pickBestEgg()
    if not best then
        if reason == "all-excluded" then
            log("All rendered eggs are excluded — waiting.")
        end
        return false
    end
    log(("Best eligible: %s (%s) via %s"):format(
        best.name, tostring(best.value), best.source))
    local ok = pickUpEgg(best)
    if ok and Config.AutoReturnPlot then
        task.wait(0.2)
        returnToPlot()
    end
    return ok
end

-- ============================================================
-- AUTO LOOP
-- ============================================================
task.spawn(function()
    while true do
        if State.AutoCollecting then
            local ok, err = pcall(doOneCycle)
            if not ok then warn("[EggCollector] " .. tostring(err)) end
            task.wait(ok and Config.AutoInterval or 0.6)
        else
            stopFlight()
            task.wait(0.15)
        end
    end
end)

-- ============================================================
-- GUI
-- ============================================================
local gui = Instance.new("ScreenGui")
gui.Name = "EggCollector"
gui.ResetOnSpawn = false
gui.ZIndexBehavior = Enum.ZIndexBehavior.Global
gui.Parent = game:GetService("CoreGui")

local frame = Instance.new("Frame")
frame.Size = UDim2.new(0, 400, 0, 580)
frame.Position = UDim2.new(0.5, -200, 0.5, -290)
frame.BackgroundColor3 = Color3.fromRGB(24, 20, 30)
frame.BorderSizePixel = 0
frame.Active = true
frame.Draggable = true
frame.ZIndex = 10
frame.Parent = gui
Instance.new("UICorner", frame).CornerRadius = UDim.new(0, 10)

local title = Instance.new("TextLabel")
title.Size = UDim2.new(1, 0, 0, 30)
title.BackgroundColor3 = Color3.fromRGB(48, 36, 60)
title.Text = "Auto Egg Collector"
title.TextColor3 = Color3.fromRGB(235, 215, 255)
title.Font = Enum.Font.GothamBold
title.TextSize = 14
title.ZIndex = 11
title.Parent = frame
Instance.new("UICorner", title).CornerRadius = UDim.new(0, 10)

local close = Instance.new("TextButton")
close.Size = UDim2.new(0, 22, 0, 22)
close.Position = UDim2.new(1, -26, 0, 4)
close.BackgroundColor3 = Color3.fromRGB(140, 40, 40)
close.Text = "X"
close.TextColor3 = Color3.fromRGB(255, 255, 255)
close.Font = Enum.Font.GothamBold
close.TextSize = 12
close.ZIndex = 12
close.Parent = frame
Instance.new("UICorner", close).CornerRadius = UDim.new(0, 6)
close.MouseButton1Click:Connect(function()
    State.AutoCollecting = false
    stopFlight()
    gui:Destroy()
end)

local tabBar = Instance.new("Frame")
tabBar.Size = UDim2.new(1, -20, 0, 30)
tabBar.Position = UDim2.new(0, 10, 0, 36)
tabBar.BackgroundColor3 = Color3.fromRGB(32, 30, 42)
tabBar.BorderSizePixel = 0
tabBar.ZIndex = 11
tabBar.Parent = frame
Instance.new("UICorner", tabBar).CornerRadius = UDim.new(0, 6)

local function mkTabBtn(text, xScale)
    local b = Instance.new("TextButton")
    b.Size = UDim2.new(0.5, -2, 1, -4)
    b.Position = UDim2.new(xScale, 2, 0, 2)
    b.BackgroundColor3 = Color3.fromRGB(45, 45, 60)
    b.TextColor3 = Color3.fromRGB(180, 180, 210)
    b.Font = Enum.Font.GothamBold
    b.TextSize = 12
    b.Text = text
    b.ZIndex = 12
    b.Parent = tabBar
    Instance.new("UICorner", b).CornerRadius = UDim.new(0, 5)
    return b
end

local mainTabBtn = mkTabBtn("Main", 0)
local manualTabBtn = mkTabBtn("Manual", 0.5)

-- ============================================================
-- MAIN TAB
-- ============================================================
local mainTab = Instance.new("Frame")
mainTab.Size = UDim2.new(1, 0, 1, -76)
mainTab.Position = UDim2.new(0, 0, 0, 76)
mainTab.BackgroundTransparency = 1
mainTab.ZIndex = 11
mainTab.Parent = frame

local autoBtn = Instance.new("TextButton")
autoBtn.Size = UDim2.new(0.9, 0, 0, 46)
autoBtn.Position = UDim2.new(0.05, 0, 0, 6)
autoBtn.BackgroundColor3 = Color3.fromRGB(70, 75, 85)
autoBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
autoBtn.Font = Enum.Font.GothamBold
autoBtn.TextSize = 15
autoBtn.Text = "Auto Collect: OFF"
autoBtn.ZIndex = 11
autoBtn.Parent = mainTab
Instance.new("UICorner", autoBtn).CornerRadius = UDim.new(0, 6)

local descLbl = Instance.new("TextLabel")
descLbl.Size = UDim2.new(0.9, 0, 0, 26)
descLbl.Position = UDim2.new(0.05, 0, 0, 56)
descLbl.BackgroundTransparency = 1
descLbl.Text = "Always targets the rarest egg. Flies to it and verifies pickup."
descLbl.TextColor3 = Color3.fromRGB(160, 180, 200)
descLbl.Font = Enum.Font.Gotham
descLbl.TextSize = 10
descLbl.TextXAlignment = Enum.TextXAlignment.Left
descLbl.TextYAlignment = Enum.TextYAlignment.Top
descLbl.TextWrapped = true
descLbl.ZIndex = 11
descLbl.Parent = mainTab

-- Exclude checkbox
local excludeBtn = Instance.new("TextButton")
excludeBtn.Size = UDim2.new(0.9, 0, 0, 28)
excludeBtn.Position = UDim2.new(0.05, 0, 0, 90)
excludeBtn.BackgroundColor3 = Color3.fromRGB(45, 55, 70)
excludeBtn.TextColor3 = Color3.fromRGB(200, 215, 230)
excludeBtn.Font = Enum.Font.GothamBold
excludeBtn.TextSize = 11
excludeBtn.Text = ""
excludeBtn.Visible = false
excludeBtn.ZIndex = 11
excludeBtn.Parent = mainTab
Instance.new("UICorner", excludeBtn).CornerRadius = UDim.new(0, 5)

local excludeBox = Instance.new("Frame")
excludeBox.Size = UDim2.new(0, 14, 0, 14)
excludeBox.Position = UDim2.new(0, 8, 0.5, -7)
excludeBox.BackgroundColor3 = Color3.fromRGB(38, 44, 54)
excludeBox.BorderSizePixel = 0
excludeBox.ZIndex = 12
excludeBox.Parent = excludeBtn
Instance.new("UICorner", excludeBox).CornerRadius = UDim.new(0, 3)
local excludeBoxStroke = Instance.new("UIStroke")
excludeBoxStroke.Color = Color3.fromRGB(120, 130, 145)
excludeBoxStroke.Thickness = 1
excludeBoxStroke.Parent = excludeBox

local excludeLbl = Instance.new("TextLabel")
excludeLbl.Size = UDim2.new(1, -30, 1, 0)
excludeLbl.Position = UDim2.new(0, 28, 0, 0)
excludeLbl.BackgroundTransparency = 1
excludeLbl.Text = "Exclude Eggs  (0 selected)"
excludeLbl.TextColor3 = Color3.fromRGB(200, 215, 230)
excludeLbl.Font = Enum.Font.GothamBold
excludeLbl.TextSize = 11
excludeLbl.TextXAlignment = Enum.TextXAlignment.Left
excludeLbl.ZIndex = 12
excludeLbl.Parent = excludeBtn

-- Exclude dropdown
local excludeFrame = Instance.new("Frame")
excludeFrame.Size = UDim2.new(0.9, 0, 0, 280)
excludeFrame.Position = UDim2.new(0.05, 0, 0, 122)
excludeFrame.BackgroundColor3 = Color3.fromRGB(30, 26, 38)
excludeFrame.BorderSizePixel = 0
excludeFrame.Visible = false
excludeFrame.ZIndex = 20
excludeFrame.Parent = mainTab
Instance.new("UICorner", excludeFrame).CornerRadius = UDim.new(0, 6)

local excludeScroll = Instance.new("ScrollingFrame")
excludeScroll.Size = UDim2.new(1, -6, 1, -6)
excludeScroll.Position = UDim2.new(0, 3, 0, 3)
excludeScroll.BackgroundTransparency = 1
excludeScroll.BorderSizePixel = 0
excludeScroll.ScrollBarThickness = 5
excludeScroll.CanvasSize = UDim2.new(0, 0, 0, 0)
excludeScroll.ZIndex = 21
excludeScroll.Parent = excludeFrame
local excludeLayout = Instance.new("UIListLayout")
excludeLayout.Padding = UDim.new(0, 2)
excludeLayout.Parent = excludeScroll

local function formatVal(n)
    if n >= 1e12 then return ("%.2fT"):format(n / 1e12):gsub("%.00T", "T") end
    if n >= 1e9  then return ("%.2fB"):format(n / 1e9):gsub("%.00B", "B") end
    if n >= 1e6  then return ("%.2fM"):format(n / 1e6):gsub("%.00M", "M") end
    if n >= 1e3  then return ("%.1fK"):format(n / 1e3) end
    return tostring(n)
end

local function refreshExcludeRows()
    for _, c in ipairs(excludeScroll:GetChildren()) do
        if c:IsA("TextButton") then c:Destroy() end
    end
    local rows = {}
    local seen = {}
    for _, e in ipairs(EGGS) do
        rows[#rows+1] = { name = e.name, value = e.value, canonical = true }
        seen[e.name] = true
    end
    for _, e in ipairs(State.LastScanned) do
        if e.unknown and not seen[e.name] then
            seen[e.name] = true
            rows[#rows+1] = { name = e.name, value = e.value, canonical = false }
        end
    end
    table.sort(rows, function(a, b) return a.value > b.value end)

    for _, entry in ipairs(rows) do
        local name = entry.name
        local row = Instance.new("TextButton")
        row.Size = UDim2.new(1, -4, 0, 22)
        row.BackgroundColor3 = Color3.fromRGB(42, 40, 52)
        row.Text = ""
        row.AutoButtonColor = false
        row.ZIndex = 22
        row.Parent = excludeScroll
        Instance.new("UICorner", row).CornerRadius = UDim.new(0, 4)

        local box = Instance.new("Frame")
        box.Size = UDim2.new(0, 12, 0, 12)
        box.Position = UDim2.new(0, 6, 0.5, -6)
        box.BackgroundColor3 = Color3.fromRGB(38, 44, 54)
        box.BorderSizePixel = 0
        box.ZIndex = 23
        box.Parent = row
        Instance.new("UICorner", box).CornerRadius = UDim.new(0, 2)
        local bs = Instance.new("UIStroke")
        bs.Color = Color3.fromRGB(120, 130, 145)
        bs.Thickness = 1
        bs.Parent = box

        local lbl = Instance.new("TextLabel")
        lbl.Size = UDim2.new(1, -30, 1, 0)
        lbl.Position = UDim2.new(0, 24, 0, 0)
        lbl.BackgroundTransparency = 1
        local suffix = entry.canonical
            and ("  (%s)"):format(formatVal(entry.value)) or "  [new]"
        lbl.Text = name .. suffix
        lbl.TextColor3 = entry.canonical
            and Color3.fromRGB(220, 225, 240)
            or Color3.fromRGB(255, 220, 120)
        lbl.Font = Enum.Font.Gotham
        lbl.TextSize = 10
        lbl.TextXAlignment = Enum.TextXAlignment.Left
        lbl.ZIndex = 23
        lbl.Parent = row

        local function refresh()
            if State.ExcludedEggs[name] then
                box.BackgroundColor3 = Color3.fromRGB(70, 130, 200)
                bs.Color = Color3.fromRGB(70, 130, 200)
                row.BackgroundColor3 = Color3.fromRGB(52, 48, 65)
            else
                box.BackgroundColor3 = Color3.fromRGB(38, 44, 54)
                bs.Color = Color3.fromRGB(120, 130, 145)
                row.BackgroundColor3 = Color3.fromRGB(42, 40, 52)
            end
        end
        refresh()

        row.MouseButton1Click:Connect(function()
            if State.ExcludedEggs[name] then
                State.ExcludedEggs[name] = nil
            else
                State.ExcludedEggs[name] = true
            end
            refresh()
            local count = 0
            for _ in pairs(State.ExcludedEggs) do count += 1 end
            excludeLbl.Text = ("Exclude Eggs  (%d selected)"):format(count)
        end)
    end
    excludeScroll.CanvasSize = UDim2.new(0, 0, 0, excludeLayout.AbsoluteContentSize.Y + 6)
end

excludeBtn.MouseButton1Click:Connect(function()
    State.ExcludeMode = not State.ExcludeMode
    if State.ExcludeMode then
        excludeBox.BackgroundColor3 = Color3.fromRGB(70, 130, 200)
        excludeBoxStroke.Color = Color3.fromRGB(70, 130, 200)
        excludeFrame.Visible = true
        refreshExcludeRows()
    else
        excludeBox.BackgroundColor3 = Color3.fromRGB(38, 44, 54)
        excludeBoxStroke.Color = Color3.fromRGB(120, 130, 145)
        excludeFrame.Visible = false
    end
end)

autoBtn.MouseButton1Click:Connect(function()
    State.AutoCollecting = not State.AutoCollecting
    autoBtn.BackgroundColor3 = State.AutoCollecting
        and Color3.fromRGB(60, 140, 60) or Color3.fromRGB(70, 75, 85)
    autoBtn.Text = "Auto Collect: " .. (State.AutoCollecting and "ON" or "OFF")
    excludeBtn.Visible = State.AutoCollecting
    if not State.AutoCollecting then
        excludeFrame.Visible = false
        State.ExcludeMode = false
        excludeBox.BackgroundColor3 = Color3.fromRGB(38, 44, 54)
        excludeBoxStroke.Color = Color3.fromRGB(120, 130, 145)
        stopFlight()
    end
    log(("Auto Collect %s"):format(State.AutoCollecting and "started" or "stopped"))
end)

-- Return to Plot — at the BOTTOM of Main tab
local returnBtn = Instance.new("TextButton")
returnBtn.Size = UDim2.new(0.9, 0, 0, 34)
returnBtn.Position = UDim2.new(0.05, 0, 1, -44)   -- bottom of main tab
returnBtn.BackgroundColor3 = Color3.fromRGB(60, 100, 160)
returnBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
returnBtn.Font = Enum.Font.GothamBold
returnBtn.TextSize = 13
returnBtn.Text = "Return to My Plot"
returnBtn.ZIndex = 11
returnBtn.Parent = mainTab
Instance.new("UICorner", returnBtn).CornerRadius = UDim.new(0, 6)
returnBtn.MouseButton1Click:Connect(function()
    task.spawn(returnToPlot)
end)

-- ============================================================
-- MANUAL TAB
-- ============================================================
local manualTab = Instance.new("Frame")
manualTab.Size = UDim2.new(1, 0, 1, -76)
manualTab.Position = UDim2.new(0, 0, 0, 76)
manualTab.BackgroundTransparency = 1
manualTab.Visible = false
manualTab.ZIndex = 11
manualTab.Parent = frame

local function mkMBtn(text, y, color, onClick)
    local b = Instance.new("TextButton")
    b.Size = UDim2.new(0.9, 0, 0, 30)
    b.Position = UDim2.new(0.05, 0, 0, y)
    b.BackgroundColor3 = color
    b.TextColor3 = Color3.fromRGB(255, 255, 255)
    b.Font = Enum.Font.GothamBold
    b.TextSize = 12
    b.Text = text
    b.ZIndex = 11
    b.Parent = manualTab
    Instance.new("UICorner", b).CornerRadius = UDim.new(0, 6)
    b.MouseButton1Click:Connect(onClick)
    return b
end

local autoRetBtn = mkMBtn("Auto Return to Plot: ON", 6,
    Color3.fromRGB(60, 140, 60), function() end)
autoRetBtn.MouseButton1Click:Connect(function()
    Config.AutoReturnPlot = not Config.AutoReturnPlot
    autoRetBtn.BackgroundColor3 = Config.AutoReturnPlot
        and Color3.fromRGB(60, 140, 60) or Color3.fromRGB(70, 75, 85)
    autoRetBtn.Text = "Auto Return to Plot: " .. (Config.AutoReturnPlot and "ON" or "OFF")
end)

mkMBtn("Scan RenderedEggs (log)", 42, Color3.fromRGB(60, 100, 160), function()
    local all = scanRenderedEggs()
    print(("[EggCollector] RenderedEggs scan: %d objects"):format(#all))
    local list = {}
    for _, e in ipairs(all) do
        list[#list+1] = e
    end
    table.sort(list, function(a, b) return a.value > b.value end)
    for _, e in ipairs(list) do
        local tag = e.unknown and "  [UNKNOWN]" or ""
        print(("   %-20s val=%-14s src=%s%s"):format(
            e.name, tostring(e.value), e.source, tag))
    end
    log(("Scanned %d top-level eggs"):format(#all))
end)

mkMBtn("Dump RenderedEggs structure", 78, Color3.fromRGB(120, 90, 40), function()
    local folder = getRenderedEggs()
    if not folder then log("No workspace.RenderedEggs folder.") return end
    print("================ RenderedEggs DUMP ================")
    local function dump(obj, indent)
        indent = indent or ""
        local pos = partPosition(obj)
        local posStr = pos and ("  pos=(%.1f,%.1f,%.1f)"):format(pos.X, pos.Y, pos.Z) or ""
        print(("%s%s [%s]%s"):format(indent, obj.Name, obj.ClassName, posStr))
        local ok, attrs = pcall(function() return obj:GetAttributes() end)
        if ok and attrs and #attrs > 0 then
            for _, a in ipairs(attrs) do
                local v = obj:GetAttribute(a)
                print(("%s   attr %s = %s (%s)"):format(indent, a, tostring(v), typeof(v)))
            end
        end
        for _, c in ipairs(obj:GetChildren()) do
            if c:IsA("StringValue") or c:IsA("NumberValue")
               or c:IsA("IntValue") or c:IsA("BoolValue") then
                print(("%s   child %s = %s (%s)"):format(
                    indent, c.Name, tostring(c.Value), c.ClassName))
            end
        end
        if obj:IsA("Model") or obj:IsA("Folder") then
            for _, c in ipairs(obj:GetChildren()) do
                if not (c:IsA("StringValue") or c:IsA("NumberValue")
                        or c:IsA("IntValue") or c:IsA("BoolValue")) then
                    dump(c, indent .. "   ")
                end
            end
        end
    end
    for _, obj in ipairs(folder:GetChildren()) do dump(obj, "  ") end
    print("================ END DUMP ================")
    log("Dumped RenderedEggs to console.")
end)

mkMBtn("Force One Cycle Now", 114, Color3.fromRGB(120, 60, 160), function()
    task.spawn(doOneCycle)
end)

mkMBtn("Clear Exclusions", 150, Color3.fromRGB(140, 50, 50), function()
    State.ExcludedEggs = {}
    excludeLbl.Text = "Exclude Eggs  (0 selected)"
    if excludeFrame.Visible then refreshExcludeRows() end
    log("Exclusions cleared.")
end)

mkMBtn("Reset Counters", 186, Color3.fromRGB(140, 80, 40), function()
    State.PickupCount = 0
    State.FailedPickups = 0
    log("Counters reset.")
end)

-- Settings
local setHdr = Instance.new("TextLabel")
setHdr.Size = UDim2.new(0.9, 0, 0, 16)
setHdr.Position = UDim2.new(0.05, 0, 0, 222)
setHdr.BackgroundTransparency = 1
setHdr.Text = "Settings"
setHdr.TextColor3 = Color3.fromRGB(180, 200, 220)
setHdr.Font = Enum.Font.GothamBold
setHdr.TextSize = 11
setHdr.TextXAlignment = Enum.TextXAlignment.Left
setHdr.ZIndex = 11
setHdr.Parent = manualTab

local holdHdr = Instance.new("TextLabel")
holdHdr.Size = UDim2.new(0.9, 0, 0, 14)
holdHdr.Position = UDim2.new(0.05, 0, 0, 242)
holdHdr.BackgroundTransparency = 1
holdHdr.Text = ("Hold E: %.2fs"):format(Config.HoldE)
holdHdr.TextColor3 = Color3.fromRGB(190, 210, 230)
holdHdr.Font = Enum.Font.Gotham
holdHdr.TextSize = 11
holdHdr.TextXAlignment = Enum.TextXAlignment.Left
holdHdr.ZIndex = 11
holdHdr.Parent = manualTab

local holdMinus = Instance.new("TextButton")
holdMinus.Size = UDim2.new(0, 40, 0, 22)
holdMinus.Position = UDim2.new(0.05, 0, 0, 260)
holdMinus.BackgroundColor3 = Color3.fromRGB(60, 100, 160)
holdMinus.TextColor3 = Color3.fromRGB(255, 255, 255)
holdMinus.Font = Enum.Font.GothamBold
holdMinus.TextSize = 11
holdMinus.Text = "-.1"
holdMinus.ZIndex = 11
holdMinus.Parent = manualTab
Instance.new("UICorner", holdMinus).CornerRadius = UDim.new(0, 5)
holdMinus.MouseButton1Click:Connect(function()
    Config.HoldE = math.max(0.1, Config.HoldE - 0.1)
    holdHdr.Text = ("Hold E: %.2fs"):format(Config.HoldE)
end)

local holdPlus = Instance.new("TextButton")
holdPlus.Size = UDim2.new(0, 40, 0, 22)
holdPlus.Position = UDim2.new(0.85, 0, 0, 260)
holdPlus.BackgroundColor3 = Color3.fromRGB(60, 100, 160)
holdPlus.TextColor3 = Color3.fromRGB(255, 255, 255)
holdPlus.Font = Enum.Font.GothamBold
holdPlus.TextSize = 11
holdPlus.Text = "+.1"
holdPlus.ZIndex = 11
holdPlus.Parent = manualTab
Instance.new("UICorner", holdPlus).CornerRadius = UDim.new(0, 5)
holdPlus.MouseButton1Click:Connect(function()
    Config.HoldE = math.min(5.0, Config.HoldE + 0.1)
    holdHdr.Text = ("Hold E: %.2fs"):format(Config.HoldE)
end)

local statusBox = Instance.new("TextLabel")
statusBox.Size = UDim2.new(0.9, 0, 0, 180)
statusBox.Position = UDim2.new(0.05, 0, 0, 292)
statusBox.BackgroundColor3 = Color3.fromRGB(18, 22, 28)
statusBox.TextColor3 = Color3.fromRGB(180, 210, 220)
statusBox.Font = Enum.Font.Code
statusBox.TextSize = 10
statusBox.TextXAlignment = Enum.TextXAlignment.Left
statusBox.TextYAlignment = Enum.TextYAlignment.Top
statusBox.TextWrapped = true
statusBox.ZIndex = 11
statusBox.Parent = manualTab
Instance.new("UICorner", statusBox).CornerRadius = UDim.new(0, 6)

-- ============================================================
-- TAB SWITCH
-- ============================================================
local function switchTab(name)
    if name == "main" then
        mainTab.Visible = true
        manualTab.Visible = false
        mainTabBtn.BackgroundColor3 = Color3.fromRGB(70, 130, 200)
        manualTabBtn.BackgroundColor3 = Color3.fromRGB(45, 45, 60)
        mainTabBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
        manualTabBtn.TextColor3 = Color3.fromRGB(180, 180, 210)
    else
        mainTab.Visible = false
        manualTab.Visible = true
        mainTabBtn.BackgroundColor3 = Color3.fromRGB(45, 45, 60)
        manualTabBtn.BackgroundColor3 = Color3.fromRGB(70, 130, 200)
        mainTabBtn.TextColor3 = Color3.fromRGB(180, 180, 210)
        manualTabBtn.TextColor3 = Color3.fromRGB(255, 255, 255)
    end
end
mainTabBtn.MouseButton1Click:Connect(function() switchTab("main") end)
manualTabBtn.MouseButton1Click:Connect(function() switchTab("manual") end)
switchTab("main")

-- ============================================================
-- LIVE STATUS
-- ============================================================
task.spawn(function()
    while gui.Parent do
        local plot = findMyPlot()
        local plotStr = plot and plot.Name or "(not found)"
        local excludedCount = 0
        for _ in pairs(State.ExcludedEggs) do excludedCount += 1 end

        local total, eligible = 0, 0
        local bestEligible, bestAll = nil, nil
        for _, e in ipairs(State.LastScanned) do
            total += 1
            if not bestAll or e.value > bestAll.value then bestAll = e end
            if not isExcluded(e) then
                eligible += 1
                if not bestEligible or e.value > bestEligible.value then
                    bestEligible = e
                end
            end
        end

        statusBox.Text = table.concat({
            ("  Auto: %s   Exclude: %s"):format(
                tostring(State.AutoCollecting), tostring(State.ExcludeMode)),
            ("  Rendered: %d   Eligible: %d"):format(total, eligible),
            ("  Excluded: %d   Picked: %d   Failed: %d"):format(
                excludedCount, State.PickupCount, State.FailedPickups),
            ("  Highest (any): %s"):format(
                bestAll and (bestAll.name .. " (" .. formatVal(bestAll.value) .. ")")
                or "(none)"),
            ("  Best eligible: %s"):format(
                bestEligible and (bestEligible.name .. " (" .. formatVal(bestEligible.value) .. ")")
                or "(none)"),
            ("  Last picked: %s"):format(State.LastTarget or "(none)"),
            ("  Plot: %s"):format(plotStr),
            ("  %s"):format(State.LastStatus),
        }, "\n")
        task.wait(0.5)
    end
end)

print("[EggCollector] Loaded.")
print("  Scan now only considers TOP-LEVEL RenderedEggs entries.")
print("  Sub-parts of egg models are no longer treated as separate eggs.")
print("  If rarest still misses, click 'Dump RenderedEggs structure' and paste output.")

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