local settings = {
    farmSpeed = 0.02,
    targetXP = 750,
    autoFindWorms = true,
    showConsoleLogs = false,
    excludeList = {
        "Dummy", "Template", "Example", "Baseplate"
    }
}

local player = game:GetService("Players").LocalPlayer
local replicatedStorage = game:GetService("ReplicatedStorage")
local runService = game:GetService("RunService")
local collectionService = game:GetService("CollectionService")

local farming = false
local farmConnection = nil
local stats = {
    totalEaten = 0,
    totalXP = 0,
    startTime = 0,
    itemsDiscovered = 0
}

local scanLocations = {
    {container = workspace, path = "Consumables"},
    {container = workspace, path = "Consumables/Items"},
    {container = workspace, path = "Consumables/Food"},
    {container = workspace, path = "Consumables/Pool"},
    {container = workspace, path = "Consumables/Storage"},
    {container = workspace, path = "Food"},
    {container = workspace, path = "Foods"},
    {container = workspace, path = "FoodItems"},
    {container = workspace, path = "Items"},
    {container = workspace, path = "Items/Consumables"},
    {container = workspace, path = "Items/Food"},
    {container = workspace, path = "Resources/Consumables"},
    {container = workspace, path = "Resources/Food"},
    {container = workspace, path = "Assets/Consumables"},
    {container = workspace, path = "Assets/Food"},
    {container = workspace, path = "Drops"},
    {container = workspace, path = "Pickups"},
    {container = workspace, path = "Pickups/Consumables"},
    {container = workspace, path = "Pickups/Food"},
    {container = workspace, path = "Collectibles"},
    {container = workspace, path = "Collectibles/Consumables"},
    {container = workspace, path = "Collectibles/Food"},
    {container = workspace, path = "Loot"},
    {container = workspace, path = "Loot/Consumables"},
    {container = workspace, path = "Loot/Food"},
    {container = workspace, path = "Chests/Items"},
    {container = workspace, path = "Chests/Consumables"},
    {container = workspace, path = "Map/Consumables"},
    {container = workspace, path = "Map/Food"},
    {container = workspace, path = "World/Consumables"},
    {container = workspace, path = "World/Food"},
    {container = workspace, path = "Game/Consumables"},
    {container = workspace, path = "Game/Food"},
    {container = replicatedStorage, path = "Consumables"},
    {container = replicatedStorage, path = "Consumables/Items"},
    {container = replicatedStorage, path = "Consumables/Food"},
    {container = replicatedStorage, path = "ConsumablePool"},
    {container = replicatedStorage, path = "ConsumablePool/Items"},
    {container = replicatedStorage, path = "ConsumablePool/Food"},
    {container = replicatedStorage, path = "Assets/Consumables"},
    {container = replicatedStorage, path = "Assets/Food"},
    {container = replicatedStorage, path = "Assets/Items/Consumables"},
    {container = replicatedStorage, path = "Assets/Items/Food"},
    {container = replicatedStorage, path = "Items/Consumables"},
    {container = replicatedStorage, path = "Items/Food"},
    {container = replicatedStorage, path = "ReplicatedItems/Consumables"},
    {container = replicatedStorage, path = "ReplicatedItems/Food"},
    {container = replicatedStorage, path = "Storage/Consumables"},
    {container = replicatedStorage, path = "Storage/Food"},
    {container = replicatedStorage, path = "Data/Consumables"},
    {container = replicatedStorage, path = "Data/Food"},
    {container = replicatedStorage, path = "Modules/Consumables"},
    {container = replicatedStorage, path = "Modules/Food"},
    {container = replicatedStorage, path = "Shared/Consumables"},
    {container = replicatedStorage, path = "Shared/Food"},
    {container = replicatedStorage, path = "Food"},
    {container = replicatedStorage, path = "Foods"},
    {container = replicatedStorage, path = "FoodItems"},
    {container = replicatedStorage, path = "FoodPool"},
    {container = replicatedStorage, path = "Items"},
    {container = replicatedStorage, path = "Items/Pool"},
    {container = replicatedStorage, path = "ItemPool"},
    {container = replicatedStorage, path = "Resources/Consumables"},
    {container = replicatedStorage, path = "Resources/Food"},
    {container = replicatedStorage, path = "GameAssets/Consumables"},
    {container = replicatedStorage, path = "GameAssets/Food"},
    {container = replicatedStorage, path = "Remotes/Items"},
    {container = replicatedStorage, path = "Remotes/Consumables"},
}

local function scanAllConsumables()
    local foundItems = {}
    local itemNames = {}
    
    for _, location in ipairs(scanLocations) do
        local container = location.container
        local path = location.path
        
        local current = container
        if path then
            for part in string.gmatch(path, "[^/]+") do
                current = current:FindFirstChild(part)
                if not current then break end
            end
        end
        
        if current then
            for _, item in ipairs(current:GetChildren()) do
                if item:IsA("Part") or item:IsA("MeshPart") or item:IsA("Model") or item:IsA("Tool") then
                    local itemName = item.Name
                    
                    local excluded = false
                    for _, excludeName in ipairs(settings.excludeList) do
                        if itemName:find(excludeName) then
                            excluded = true
                            break
                        end
                    end
                    
                    if not excluded and not itemNames[itemName] then
                        itemNames[itemName] = true
                        table.insert(foundItems, {
                            name = itemName,
                            object = item,
                            source = tostring(current)
                        })
                    end
                end
            end
        end
    end
    
    local taggedItems = collectionService:GetTagged("Consumable")
    for _, item in ipairs(taggedItems) do
        local itemName = item.Name
        if not itemNames[itemName] then
            itemNames[itemName] = true
            table.insert(foundItems, {
                name = itemName,
                object = item,
                source = "Tagged"
            })
        end
    end
    
    stats.itemsDiscovered = #foundItems
    return foundItems
end

local function findWorm()
    if settings.autoFindWorms then
        local wormLocations = {
            workspace:FindFirstChild("Worms"),
            workspace:FindFirstChild("WormSpawn"),
            workspace:FindFirstChild("Entities/Worms"),
            workspace:FindFirstChild("WormFolder"),
            workspace:FindFirstChild("WormsFolder"),
            workspace:FindFirstChild("WormPool"),
            workspace:FindFirstChild("WormStorage"),
            workspace:FindFirstChild("WormSpawner"),
            workspace:FindFirstChild("SpawnedWorms"),
            workspace:FindFirstChild("ActiveWorms"),
            workspace:FindFirstChild("LiveWorms"),
            workspace:FindFirstChild("WormEntities"),
            replicatedStorage:FindFirstChild("Worms"),
            replicatedStorage:FindFirstChild("WormPool"),
            replicatedStorage:FindFirstChild("WormFolder"),
            replicatedStorage:FindFirstChild("WormStorage"),
            replicatedStorage:FindFirstChild("WormAssets"),
        }
        
        for _, location in ipairs(wormLocations) do
            if location then
                for _, worm in ipairs(location:GetChildren()) do
                    if worm.Name:find("Worm") or 
                       worm.Name:find("Warm") or 
                       worm.Name:lower():find("worm") or
                       worm.Name:lower():find("sxro") or
                       worm.Name:lower():find("worm%-sxro") then
                        return worm
                    end
                end
            end
        end
        
        for _, obj in ipairs(workspace:GetDescendants()) do
            if (obj.Name:find("Worm") or obj.Name:find("sxro") or obj.Name:lower():find("worm")) 
               and (obj:IsA("Part") or obj:IsA("Model") or obj:IsA("MeshPart")) then
                return obj
            end
        end
        
        for _, plr in ipairs(game:GetService("Players"):GetPlayers()) do
            if plr.Character then
                for _, obj in ipairs(plr.Character:GetDescendants()) do
                    if (obj.Name:find("Worm") or obj.Name:find("sxro")) 
                       and (obj:IsA("Part") or obj:IsA("Model") or obj:IsA("Tool")) then
                        return obj
                    end
                end
            end
        end
    else
        local allWorms = {}
        local wormsFolder = workspace:FindFirstChild("Worms")
        if wormsFolder then
            for _, worm in ipairs(wormsFolder:GetChildren()) do
                if worm.Name:find("Worm") or worm.Name:find("sxro") then
                    table.insert(allWorms, worm)
                end
            end
            if #allWorms > 0 then
                return allWorms
            end
        end
    end
    return nil
end

local function eatCycle()
    if not farming then return end
    
    local worm = findWorm()
    if not worm then
        wait(0.5)
        return
    end
    
    local consumablesList = scanAllConsumables()
    
    for _, itemData in ipairs(consumablesList) do
        if not farming then break end
        
        local consumable = itemData.object
        
        if consumable and consumable.Parent then
            local args = {worm, consumable}
            
            local success = pcall(function()
                local remote = replicatedStorage:FindFirstChild("EatConsumable") or
                               replicatedStorage:FindFirstChild("Consume") or
                               replicatedStorage:FindFirstChild("Eat") or
                               replicatedStorage:FindFirstChild("UseItem") or
                               replicatedStorage:FindFirstChild("EatFood") or
                               replicatedStorage:FindFirstChild("Feed") or
                               replicatedStorage:FindFirstChild("ConsumeItem") or
                               replicatedStorage:FindFirstChild("UseConsumable") or
                               replicatedStorage:FindFirstChild("FoodEat") or
                               replicatedStorage:FindFirstChild("EatItem")
                
                if remote then
                    remote:FireServer(unpack(args))
                    
                    stats.totalEaten = stats.totalEaten + 1
                    stats.totalXP = stats.totalXP + settings.targetXP
                    
                    updateUI()
                end
            end)
        end
        
        wait(0.01)
    end
end

local function createLoadingScreen()
    local loadingGui = Instance.new("ScreenGui")
    loadingGui.Name = "DOSROX_Loading"
    loadingGui.ResetOnSpawn = false
    loadingGui.Parent = player:WaitForChild("PlayerGui")
    
    local mainFrame = Instance.new("Frame")
    mainFrame.Size = UDim2.new(1, 0, 1, 0)
    mainFrame.BackgroundTransparency = 1
    mainFrame.Parent = loadingGui
    
    local titleLabel = Instance.new("TextLabel")
    titleLabel.Size = UDim2.new(1, 0, 0.3, 0)
    titleLabel.Position = UDim2.new(0, 0, 0.35, -30)
    titleLabel.BackgroundTransparency = 1
    titleLabel.Text = "DOSROX STUDIO"
    titleLabel.TextColor3 = Color3.fromRGB(255, 0, 0)
    titleLabel.TextScaled = true
    titleLabel.Font = Enum.Font.SourceSans
    titleLabel.TextStrokeTransparency = 0.3
    titleLabel.TextStrokeColor3 = Color3.fromRGB(255, 100, 100)
    titleLabel.Parent = mainFrame
    
    local circleFrame = Instance.new("Frame")
    circleFrame.Name = "LoadingCircle"
    circleFrame.Size = UDim2.new(0, 60, 0, 60)
    circleFrame.Position = UDim2.new(0.5, -30, 0.5, -30)
    circleFrame.BackgroundColor3 = Color3.fromRGB(255, 255, 255)
    circleFrame.BackgroundTransparency = 1
    circleFrame.Parent = mainFrame
    
    local colors = {Color3.fromRGB(255, 0, 0), Color3.fromRGB(200, 0, 0), 
                    Color3.fromRGB(150, 0, 0), Color3.fromRGB(255, 50, 50)}
    
    for i = 1, 4 do
        local dot = Instance.new("Frame")
        dot.Name = "Dot" .. i
        dot.Size = UDim2.new(0, 12, 0, 12)
        dot.Position = UDim2.new(0.5, -6, 0.5, -6)
        dot.BackgroundColor3 = colors[i]
        dot.BackgroundTransparency = 0.2
        dot.Parent = circleFrame
        
        local dotCorner = Instance.new("UICorner")
        dotCorner.CornerRadius = UDim.new(1, 0)
        dotCorner.Parent = dot
    end
    
    local angle = 0
    
    local function updateSpinner()
        if not loadingGui or not loadingGui.Parent then return end
        
        angle = (angle + 0.02) % (2 * math.pi)
        
        for i, dot in ipairs(circleFrame:GetChildren()) do
            if dot.Name:find("Dot") then
                local dotAngle = angle + (i - 1) * (math.pi / 2)
                local radius = 20
                local x = math.cos(dotAngle) * radius
                local y = math.sin(dotAngle) * radius
                
                dot.Position = UDim2.new(0.5, x - 6, 0.5, y - 6)
            end
        end
    end
    
    local heartbeatConn = runService.Heartbeat:Connect(updateSpinner)
    
    return {
        gui = loadingGui,
        heartbeatConn = heartbeatConn,
        destroy = function()
            heartbeatConn:Disconnect()
            loadingGui:Destroy()
        end
    }
end

local function createMainUI()
    local oldGui = player.PlayerGui:FindFirstChild("ICECORE_UltimateFarm")
    if oldGui then oldGui:Destroy() end
    
    local screenGui = Instance.new("ScreenGui")
    screenGui.Name = "ICECORE_UltimateFarm"
    screenGui.ResetOnSpawn = false
    screenGui.Parent = player:WaitForChild("PlayerGui")
    
    local mainFrame = Instance.new("Frame")
    mainFrame.Size = UDim2.new(0, 320, 0, 240)
    mainFrame.Position = UDim2.new(0.5, -160, 0.5, -120)
    mainFrame.BackgroundColor3 = Color3.fromRGB(10, 15, 25)
    mainFrame.BackgroundTransparency = 0.1
    mainFrame.BorderSizePixel = 0
    mainFrame.Active = true
    mainFrame.Draggable = true
    mainFrame.Parent = screenGui
    
    local corner = Instance.new("UICorner")
    corner.CornerRadius = UDim.new(0, 20)
    corner.Parent = mainFrame
    
    local stroke = Instance.new("UIStroke")
    stroke.Thickness = 2
    stroke.Color = Color3.fromRGB(0, 255, 255)
    stroke.Transparency = 0.4
    stroke.Parent = mainFrame
    
    local titleLabel = Instance.new("TextLabel")
    titleLabel.Size = UDim2.new(1, 0, 0, 40)
    titleLabel.Position = UDim2.new(0, 0, 0, 5)
    titleLabel.BackgroundTransparency = 1
    titleLabel.Text = "🧊 ICE FARM | DOSROX"
    titleLabel.TextColor3 = Color3.fromRGB(0, 255, 255)
    titleLabel.TextScaled = true
    titleLabel.Font = Enum.Font.GothamBold
    titleLabel.Parent = mainFrame
    
    local statsFrame = Instance.new("Frame")
    statsFrame.Size = UDim2.new(1, -20, 0, 80)
    statsFrame.Position = UDim2.new(0, 10, 0, 45)
    statsFrame.BackgroundColor3 = Color3.fromRGB(0, 0, 0)
    statsFrame.BackgroundTransparency = 0.5
    statsFrame.Parent = mainFrame
    
    local statsCorner = Instance.new("UICorner")
    statsCorner.CornerRadius = UDim.new(0, 12)
    statsCorner.Parent = statsFrame
    
    local statsLabel = Instance.new("TextLabel")
    statsLabel.Name = "StatsLabel"
    statsLabel.Size = UDim2.new(1, -10, 0.5, 0)
    statsLabel.Position = UDim2.new(0, 5, 0, 2)
    statsLabel.BackgroundTransparency = 1
    statsLabel.Text = "📊 Eaten: 0 | XP: 0"
    statsLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
    statsLabel.TextScaled = true
    statsLabel.Font = Enum.Font.Gotham
    statsLabel.TextXAlignment = Enum.TextXAlignment.Left
    statsLabel.Parent = statsFrame
    
    local discoveredLabel = Instance.new("TextLabel")
    discoveredLabel.Name = "DiscoveredLabel"
    discoveredLabel.Size = UDim2.new(1, -10, 0.5, -5)
    discoveredLabel.Position = UDim2.new(0, 5, 0.5, 0)
    discoveredLabel.BackgroundTransparency = 1
    discoveredLabel.Text = "🔍 Items: 0"
    discoveredLabel.TextColor3 = Color3.fromRGB(100, 255, 100)
    discoveredLabel.TextScaled = true
    discoveredLabel.Font = Enum.Font.Gotham
    discoveredLabel.TextXAlignment = Enum.TextXAlignment.Left
    discoveredLabel.Parent = statsFrame
    
    local statusFrame = Instance.new("Frame")
    statusFrame.Size = UDim2.new(1, -20, 0, 40)
    statusFrame.Position = UDim2.new(0, 10, 0, 130)
    statusFrame.BackgroundColor3 = Color3.fromRGB(20, 20, 35)
    statusFrame.BackgroundTransparency = 0.3
    statusFrame.Parent = mainFrame
    
    local statusCorner = Instance.new("UICorner")
    statusCorner.CornerRadius = UDim.new(0, 12)
    statusCorner.Parent = statusFrame
    
    local statusLabel = Instance.new("TextLabel")
    statusLabel.Name = "StatusLabel"
    statusLabel.Size = UDim2.new(0.7, 0, 1, 0)
    statusLabel.Position = UDim2.new(0, 10, 0, 0)
    statusLabel.BackgroundTransparency = 1
    statusLabel.Text = "⏸️ Stopped"
    statusLabel.TextColor3 = Color3.fromRGB(255, 80, 80)
    statusLabel.TextScaled = true
    statusLabel.Font = Enum.Font.GothamBold
    statusLabel.TextXAlignment = Enum.TextXAlignment.Left
    statusLabel.Parent = statusFrame
    
    local countLabel = Instance.new("TextLabel")
    countLabel.Name = "CountLabel"
    countLabel.Size = UDim2.new(0.3, -10, 1, 0)
    countLabel.Position = UDim2.new(0.7, 0, 0, 0)
    countLabel.BackgroundTransparency = 1
    countLabel.Text = "0"
    countLabel.TextColor3 = Color3.fromRGB(255, 255, 0)
    countLabel.TextScaled = true
    countLabel.Font = Enum.Font.GothamBold
    countLabel.Parent = statusFrame
    
    local buttonFrame = Instance.new("Frame")
    buttonFrame.Size = UDim2.new(1, -20, 0, 50)
    buttonFrame.Position = UDim2.new(0, 10, 0, 175)
    buttonFrame.BackgroundTransparency = 1
    buttonFrame.Parent = mainFrame
    
    local toggleButton = Instance.new("TextButton")
    toggleButton.Name = "ToggleButton"
    toggleButton.Size = UDim2.new(0.6, -5, 1, 0)
    toggleButton.Position = UDim2.new(0, 0, 0, 0)
    toggleButton.BackgroundColor3 = Color3.fromRGB(0, 200, 255)
    toggleButton.Text = "▶️ START"
    toggleButton.TextColor3 = Color3.fromRGB(255, 255, 255)
    toggleButton.TextScaled = true
    toggleButton.Font = Enum.Font.GothamBold
    
    local toggleCorner = Instance.new("UICorner")
    toggleCorner.CornerRadius = UDim.new(0, 12)
    toggleCorner.Parent = toggleButton
    
    toggleButton.Parent = buttonFrame
    
    local rescanButton = Instance.new("TextButton")
    rescanButton.Name = "RescanButton"
    rescanButton.Size = UDim2.new(0.4, -5, 1, 0)
    rescanButton.Position = UDim2.new(0.6, 5, 0, 0)
    rescanButton.BackgroundColor3 = Color3.fromRGB(100, 100, 150)
    rescanButton.Text = "🔄 SCAN"
    rescanButton.TextColor3 = Color3.fromRGB(255, 255, 255)
    rescanButton.TextScaled = true
    rescanButton.Font = Enum.Font.GothamBold
    
    local rescanCorner = Instance.new("UICorner")
    rescanCorner.CornerRadius = UDim.new(0, 12)
    rescanCorner.Parent = rescanButton
    
    rescanButton.Parent = buttonFrame
    
    _G.ICEUI = {
        statsLabel = statsLabel,
        discoveredLabel = discoveredLabel,
        statusLabel = statusLabel,
        countLabel = countLabel,
        toggleButton = toggleButton,
        rescanButton = rescanButton,
        mainFrame = mainFrame,
        gui = screenGui
    }
    
    return screenGui
end

function updateUI()
    if _G.ICEUI and _G.ICEUI.statsLabel then
        _G.ICEUI.statsLabel.Text = string.format("📊 Eaten: %d | XP: %.1fk", 
            stats.totalEaten, 
            stats.totalXP / 1000
        )
    end
    if _G.ICEUI and _G.ICEUI.discoveredLabel then
        _G.ICEUI.discoveredLabel.Text = "🔍 Items Found: " .. stats.itemsDiscovered
    end
end

function toggleFarm()
    farming = not farming
    
    if farming then
        local items = scanAllConsumables()
        stats.startTime = tick()
        
        farmConnection = runService.Heartbeat:Connect(function()
            eatCycle()
            wait(settings.farmSpeed)
            
            if _G.ICEUI and _G.ICEUI.countLabel then
                local currentItems = scanAllConsumables()
                _G.ICEUI.countLabel.Text = tostring(#currentItems)
            end
        end)
        
        if _G.ICEUI then
            _G.ICEUI.statusLabel.Text = "✅ RUNNING"
            _G.ICEUI.statusLabel.TextColor3 = Color3.fromRGB(0, 255, 100)
            _G.ICEUI.toggleButton.Text = "⏹️ STOP"
            _G.ICEUI.toggleButton.BackgroundColor3 = Color3.fromRGB(255, 80, 80)
        end
        
        print("🧸 DOSROX FARM STARTED - Items found: " .. #items)
    else
        if farmConnection then
            farmConnection:Disconnect()
            farmConnection = nil
        end
        
        if _G.ICEUI then
            _G.ICEUI.statusLabel.Text = "⏸️ STOPPED"
            _G.ICEUI.statusLabel.TextColor3 = Color3.fromRGB(255, 80, 80)
            _G.ICEUI.toggleButton.Text = "▶️ START"
            _G.ICEUI.toggleButton.BackgroundColor3 = Color3.fromRGB(0, 200, 255)
        end
        
        local totalTime = math.floor(tick() - stats.startTime)
        print(string.format("🧸 STOPPED - Eaten: %d | XP: %d | Time: %ds", 
            stats.totalEaten, stats.totalXP, totalTime))
    end
end

print("🧸 DOSROX STUDIO - Loading...")
local loadingScreen = createLoadingScreen()

wait(2)

loadingScreen:destroy()

createMainUI()

local initialItems = scanAllConsumables()
if _G.ICEUI and _G.ICEUI.countLabel then
    _G.ICEUI.countLabel.Text = tostring(#initialItems)
end
updateUI()

if _G.ICEUI then
    _G.ICEUI.toggleButton.MouseButton1Click:Connect(toggleFarm)
    _G.ICEUI.rescanButton.MouseButton1Click:Connect(function()
        local items = scanAllConsumables()
        if _G.ICEUI and _G.ICEUI.countLabel then
            _G.ICEUI.countLabel.Text = tostring(#items)
        end
        print("🧸 Rescan complete - " .. #items .. " items found")
    end)
end

print([[
🧊 DOSROX STUDIO ICE FARM v4.0
🧊 Auto-discovery system: ACTIVE
🧊 Found ]] .. #initialItems .. [[ consumable items
🧊 Click START to begin farming
]])