-- [[ Rscripts Risk Notice ]]
-- This script is not verified by rscripts.net. 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 Rscripts 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.")