Create a new version of paste:

--BGSI New


if not game:IsLoaded() then
    game.Loaded:wait()
end

task.wait(10)

--[[setfpscap(55)
print("FPS CAP 15")]]--

-- Run a single check for 100M Egg availability
spawn(function()
    local success, result = pcall(function()
        -- Wait a bit to ensure the game is fully loaded
        task.wait(60)
        
        -- Check if the Generic folder exists
        if workspace:FindFirstChild("Rendered") and workspace.Rendered:FindFirstChild("Generic") then
            -- Check if 100M Egg exists directly
            if workspace.Rendered.Generic:FindFirstChild("100M Egg") then
                return true -- Egg found
            else
                -- Iterate through all children of Generic to find 100M Egg
                for i, v in pairs(workspace.Rendered.Generic:GetChildren()) do
                    if v.Name == "100M Egg" then
                        return true -- Egg found
                    end
                end
            end
        end
        
        -- If we reach here, egg was not found
        game:GetService("Players").LocalPlayer:Kick("100M Egg not available in this server. Please rejoin a different server.")
        return false
    end)
    
    if not success then
        print("Error checking for 100M Egg: " .. tostring(result))
    end
end)

spawn(function() -- anti afk
    task.wait(30)

    local vu = game:GetService("VirtualUser")
    game:GetService("Players").LocalPlayer.Idled:connect(function()
        vu:Button2Down(Vector2.new(0,0),workspace.CurrentCamera.CFrame)
        wait(1)
        vu:Button2Up(Vector2.new(0,0),workspace.CurrentCamera.CFrame)
    end)
end)

spawn(function() -- remove hatach animation
    task.wait(30)
    
    local HatchEggModule = nil

    for _, func in next, getgc(true) do
        if typeof(func) == "function" and getfenv(func).script then
            local scriptName = getfenv(func).script.Name
            local scriptParent = getfenv(func).script.Parent

            -- Look for the right module
            if scriptName == "HatchEgg" and tostring(scriptParent) == "Effects" then
                local env = getfenv(func)
                local module = require(env.script)

                if typeof(module) == "table" then
                    HatchEggModule = module
                    break
                end
            end
        end
    end

    -- Disable all functions in the HatchEgg module
    if HatchEggModule then
        for key, value in pairs(HatchEggModule) do
            if typeof(value) == "function" then
                HatchEggModule[key] = function(...) return end
            end
        end
        print("✅ Hatch animation functions disabled.")
    else
        warn("❌ Failed to find HatchEgg module.")
    end
end)

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Local Stuff ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local GuiService            = game:GetService("GuiService")
local VIM                   = game:GetService("VirtualInputManager")
local TweenService          = game:GetService("TweenService")
local Players               = game:GetService("Players")
local HttpService           = game:GetService("HttpService")
local Remote                = game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote
local LocalDataService      = require(game:GetService("ReplicatedStorage").Client.Framework.Services.LocalData)
local data                  = LocalDataService:Get()

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Trade Secret Pets ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local AutoTradeSecretPets_Toggle = false
local tradeThread = nil
local targetTradeName = "PixyPalx" -- Target player name (can be easily changed)

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Bubble & Sell Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local Auto_Bubble_And_Sell_Active = false
local Auto_Bubble_And_Sell_Thread = nil

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Use Potion Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local isAutoUsingPotions = false
local autoUsingPotionsThread = nil
local isHatchingX25Egg = false  -- New flag to track if we're hatching a x25 egg

-- List of regular potions we want to maintain active all the time
local priorityPotions = {
    "Lucky",
    "Speed",
    "Mythic"
}

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Collect Pickup Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local isAutoCollectingPickups = false
local autoCollectingPickupsThread = nil

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Hatch Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local isAutoHatching = false
local autoHatchingThread = nil
local tempDisableHatching = false
local pickupCollectionStartedByHatcher = false -- Track if we started pickup collection

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━ Coin & Gems Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local Max_Coins =   400000000000 --400B
local Low_Coins =   100000000 --100M

local Max_Gems  =   100000000 --100M
local Low_Gems  =   10000000 --10M

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Enchant Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀
-- 🔧 CONFIG: Desired Enchants and Level
local enchants = {
    ["team-up"] = 5
}
-- 🧪 You can add more like:
-- ["strong"]   = 2,
-- ["bubbler"]  = 5,
-- ["looter"]   = 5,
-- ["gleaming"] = 5

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Area To Unlock ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀
-- 🔧 CONFIG: Areas to Unlock
local AreaToUnlock = {
    "Floating Island",
    "Outer Space",
    "Twilight",
    "The Void",
    "Zen"
}

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Mastery ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local isAutoMastery = false -- Flag to track if we're automatically upgrading mastery
local autoMasteryThread = nil -- Variable to store the auto mastery thread

local PetsMasteryCompleted = false  -- Flag to track if Pets mastery reached target
local BuffsMasteryCompleted = false  -- Flag to track if Buffs mastery reached target
local ShopsMasteryCompleted = false  -- Flag to track if Shops mastery reached target
local AllMasteryCompleted = false  -- Flag to track if all mastery reached targets

local Target_Pets_Mastery = 15
local Target_Buffs_Mastery = 17
local Target_Shops_Mastery = 10

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Egg Counter ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- Add these at the top with your other global variables
local EggCounterGui = nil
local isEggCounterEnabled = false
local CurrentlyHatchingEgg = nil

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Secret Pet Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- Define list of secret pets
local SecretPets = {
    "Avernus",
    "King Doggy",
    "The Overlord",
    "MAN FACE GOD",
    "Royal Trophy",
    "Giant Chocolate Chicken",
    "Easter Basket",
    "Dementor",
    "Godly Gem"
    -- Add more pet names here
}

local SecretPetCheck_Toggle = false
local SecretPetOverlay = nil

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Egg List & Priority ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local Default_Egg = CFrame.new(19, 2, -2)

-- Define egg mapping - workspace model name to actual egg name for remote call
local eggMapping = {
    ["common-egg"] = "Common Egg",
    ["void-egg"] = "Void Egg",
    --["nightmare-egg"] = "Nightmare Egg",
    --["aura-egg"] = "Aura Egg",
    --["event-3"] = "Throwback Egg",  -- Correct event egg name
    ["silly-egg"] = "Silly Egg",
    ["100M Egg"] = "100M Egg"

}

-- Prioritize eggs (higher index = higher priority)
local eggPriority = {
   -- "event-3", -- Highest priority
    "silly-egg",
   -- "aura-egg",
    --"nightmare-egg",
    "void-egg",
    "common-egg", -- Lowest priority
    "100M Egg"
}

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Craft Potion Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- Configuration
local potionTypes = {
    "Lucky",
    "Speed",
    "Mythic",
    "Coins"
}

-- Define crafting requirements for each tier
local craftingRequirements = {
    [2] = 4,  -- Level 2 requires 4x Level 1
    [3] = 4,  -- Level 3 requires 4x Level 2
    [4] = 6,  -- Level 4 requires 6x Level 3
    [5] = 8   -- Level 5 requires 8x Level 4
}


-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Pet List To Delete ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- The threshold amount to keep for all pets in the list
local petKeepThreshold = 1 --Normal pet type
local shinyKeepThreshold = 5  --shiny pet type

-- List of pet names to delete when they exceed 10
local petsToDelete = {
    --Common Egg
    "Doggy",
    "Kitty",
    "Bunny",
    "Bear",
    --Common Egg
    "Mouse",
    "Wolf",
    "Fox",
    "Polar Bear",
    "Panda",
    --Spotted Egg
    "Ice Kitty",
    "Deer",
    "Ice Wolf",
    "Piggy",
    "Ice Deer",
    "Ice Dragon",
    --Spikey Egg
    "Golem",
    "Dinosaur",
    "Ruby Golem",
    "Dragon",
    "Dark Dragon",
    "Emerald Golem",
    --Magma Egg
    "Magma Doggy",
    "Magma Deer",
    "Magma Fox",
    "Magma Bear",
    "Demon",
    "Inferno Dragon",
    --Crystal Egg
    "Cave Bat",
    "Dark Bat",
    "Angel",
    "Emerald Bat",
    "Unicorn",
    "Flying Pig",
    --Lunar Egg
    "Space Mouse",
    "Space Bull",
    "Lunar Fox",
    "Lunarcorn",
    "Lunar Serpent",
    "Electra",
    --Void Egg
    "Void Kitty",
    "Void Bat",
    "Void Demon",
    "Dark Phoenix",
    "Neon Elemental",
    --Hell Egg
    "Hell Piggy",
    "Hell Dragon",
    "Hell Crawler",
    "Inferno Demon",
    "Inferno Cube",
    "Virus",
    --Nightmare Egg
    "Demon Doggy",
    "Skeletal Deer",
    "Night Crawler",
    "Hell Bat",
    "Green Hydra",
    "Demonic Hydra",
    --Rainbow Egg
    "Red Golem",
    "Orange Deer",
    "Yellow Fox",
    "Green Angel",
    --Aura Egg
    "Manny",
    "Manicorn",
    "Sigma Serpent",
    "Manarium",
    --Pastel Egg
    "Paper Doggy",
    "Paper Bunny",
    "Chubby Bunny",
    "Hatchling",
    --Bunny Egg
    "Bunny Doggy",
    "Egg Bunny",
    "Angel Bunny",
    "Seraphic Bunny",
    --Throwback Egg
    "Bow Bunny",
    "Easter Egg",
    "Flying Bunny",
    "Easter Serpent",
    --100M Egg
    "Bronze Bunny",
    "Silver Fox",
    "Golden Dragon",
    "Diamond Serpent",
    "Diamond Hexarium",
    "King Pufferfish"
}

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Flavors & Gum Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- Auto buy variables
local AutoBuy_Toggle = false
local Buy_Thread = nil
local max_Flavor_Reached = false
local max_Gum_Reached = false
local max_Upgrades_Reached = false

-- 🔧 CONFIG: Flavors to Buy (sorted by price)
local flavorsConfig = {
    ["Blueberry"] = {
        price = 25,
        currency = "Coins"
    },
    ["Cherry"] = {
        price = 500,
        currency = "Coins"
    },
    ["Pizza"] = {
        price = 1500,
        currency = "Coins"
    },
    ["Watermelon"] = {
        price = 3500,
        currency = "Coins"
    },
    ["Chocolate"] = {
        price = 10000,
        currency = "Coins"
    },
    ["Contrast"] = {
        price = 35000,
        currency = "Coins"
    },
    ["Gold"] = {
        price = 100000,
        currency = "Coins"
    },
    ["Lemon"] = {
        price = 450000,
        currency = "Coins"
    },
    ["Donut"] = {
        price = 1500000,
        currency = "Coins"
    },
    ["Swirl"] = {
        price = 30000000,
        currency = "Coins"
    },
    ["Molten"] = {
        price = 350000000,
        currency = "Coins"
    }
}

-- 🔧 CONFIG: Gum to Buy (sorted by price)
local gumConfig = {
    ["Stretchy Gum"] = {
        price = 25,
        currency = "Coins"
    },
    ["Chewy Gum"] = {
        price = 250,
        currency = "Coins"
    },
    ["Epic Gum"] = {
        price = 1500,
        currency = "Coins"
    },
    ["Ultra Gum"] = {
        price = 5000,
        currency = "Coins"
    },
    ["Omega Gum"] = {
        price = 12000,
        currency = "Coins"
    },
    ["Unreal Gum"] = {
        price = 45000,
        currency = "Coins"
    },
    ["Cosmic Gum"] = {
        price = 125000,
        currency = "Coins"
    },
    ["XL Gum"] = {
        price = 650000,
        currency = "Coins"
    },
    ["Mega Gum"] = {
        price = 1500000,
        currency = "Coins"
    },
    ["Quantum Gum"] = {
        price = 5000000000,
        currency = "Coins"
    },
    ["Alien Gum"] = {
        price = 35000000,
        currency = "Coins"
    },
    ["Radioactive Gum"] = {
        price = 150000000,
        currency = "Coins"
    },
    ["Experiment #52"] = {
        price = 1000000000,
        currency = "Coins"
    }
}

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Helper ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local function GetCurrentCoins()
    return LocalDataService:Get().Coins
end

local function GetCurrentGems()
    return LocalDataService:Get().Gems
end

local function getPetById(data, id)
    for _, pet in ipairs(data.Pets) do
        if pet.Id == id then
            return pet
        end
    end
end

-- Function to format numbers with suffixes (K, M, B, T, etc.)
local function FormatNumberCompact(num)
    if num >= 1e18 then return string.format("%.1fQnt", num / 1e18)
    elseif num >= 1e15 then return string.format("%.1fQ", num / 1e15)
    elseif num >= 1e12 then return string.format("%.1fT", num / 1e12)
    elseif num >= 1e9 then return string.format("%.1fB", num / 1e9)
    elseif num >= 1e6 then return string.format("%.1fM", num / 1e6)
    elseif num >= 1e3 then return string.format("%.1fK", num / 1e3)
    else return tostring(num)
    end
end

local function extractNumbers(text)
    -- Remove all HTML-like tags
    local cleanText = text:gsub("<[^>]+>", "")
    
    -- Extract the text before and after the slash
    local currentStr, maxStr = cleanText:match("([%d%,%.]+)%s*/%s*([%d%,%.]+)")
    
    if not currentStr or not maxStr then
        return nil, nil
    end
    
    -- Remove commas from the numbers
    currentStr = currentStr:gsub(",", "")
    maxStr = maxStr:gsub(",", "")
    
    -- Convert to numbers
    return tonumber(currentStr), tonumber(maxStr)
end

-- Function to convert price text to a number value
local function convertPriceToNumber(priceText)
    -- Remove commas and spaces
    local cleanPrice = priceText:gsub(",", ""):gsub("%s+", "")
    
    -- Check for suffixes like K, M, B
    local value = tonumber(cleanPrice:match("^%d+%.?%d*"))
    if not value then return 999999999999 end -- Return a high value if can't parse
    
    -- Handle suffixes
    if cleanPrice:match("[Kk]$") then
        value = value * 1000
    elseif cleanPrice:match("[Mm]$") then
        value = value * 1000000
    elseif cleanPrice:match("[Bb]$") then
        value = value * 1000000000
    end
    
    return value
end
-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Function Tween ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- Function to tween character to a target
function TweenCharacterToTarget(targetPart)
    -- Parameter validation
    if not targetPart then
        warn("Target part not provided!")
        return
    end
    
    -- Fixed speeds
    local horizontalSpeed = 16
    local verticalSpeed = math.huge
    
    -- Get Player and Character
    local player = Players.LocalPlayer
    local character = player.Character or player.CharacterAdded:Wait()
    local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
    
    -- Calculate Target CFrames and Durations
    local startCFrame = humanoidRootPart.CFrame
    local targetPosition = targetPart.Position + Vector3.new(1, 5, 1)
    
    -- Create initial downward position (5 units below current position)
    local downwardPosition = startCFrame.Position + Vector3.new(0, -20, 0)
    local downwardCFrame = CFrame.new(downwardPosition) * (startCFrame - startCFrame.Position)
    
    -- Intermediate CFrame: Target X/Z, current Y, maintain character orientation
    local intermediatePosition = Vector3.new(targetPosition.X, downwardPosition.Y, targetPosition.Z)
    local intermediateCFrame = CFrame.new(intermediatePosition) * (startCFrame - startCFrame.Position)
    
    -- Final CFrame: Target X/Y/Z, maintain character orientation
    local finalCFrame = CFrame.new(targetPosition) * (startCFrame - startCFrame.Position)
    
    -- Calculate Distances
    local downwardDistance = math.abs(startCFrame.Position.Y - downwardPosition.Y)
    local horizontalDistance = (Vector3.new(downwardPosition.X, 0, downwardPosition.Z) - Vector3.new(intermediatePosition.X, 0, intermediatePosition.Z)).Magnitude
    local verticalDistance = math.abs(intermediatePosition.Y - targetPosition.Y)
    
    -- Calculate Durations based on speed
    local downwardTime = downwardDistance / verticalSpeed
    local horizontalTime = horizontalDistance / horizontalSpeed
    local verticalTime = verticalDistance / verticalSpeed
    
    -- TweenInfo Configuration
    local tweenInfoDownward = TweenInfo.new(downwardTime, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
    local tweenInfoHorizontal = TweenInfo.new(horizontalTime, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
    local tweenInfoVertical = TweenInfo.new(verticalTime, Enum.EasingStyle.Linear, Enum.EasingDirection.Out)
    
    -- Create Tweens
    local downwardTween = TweenService:Create(humanoidRootPart, tweenInfoDownward, { CFrame = downwardCFrame })
    local horizontalTween = TweenService:Create(humanoidRootPart, tweenInfoHorizontal, { CFrame = intermediateCFrame })
    local verticalTween = TweenService:Create(humanoidRootPart, tweenInfoVertical, { CFrame = finalCFrame })
    
    -- Play Tweens Sequentially
    downwardTween.Completed:Connect(function(playbackState)
        if playbackState == Enum.PlaybackState.Completed then
            horizontalTween:Play()
        end
    end)
    
    horizontalTween.Completed:Connect(function(playbackState)
        if playbackState == Enum.PlaybackState.Completed then
            verticalTween:Play()
        end
    end)
    
    -- Start the first tween
    downwardTween:Play()
    
    -- Return tweens so they can be monitored or cancelled
    return horizontalTween, verticalTween, downwardTween
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Trade Secret Pets ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local AutoTradeSecretPets_Toggle = false
local tradeThread = nil
local targetTradeName = "PixyPalx" -- Target player name (can be easily changed)

local function autoTradeSecretPets()
    AutoTradeSecretPets_Toggle = not AutoTradeSecretPets_Toggle
    
    if AutoTradeSecretPets_Toggle then
        tradeThread = spawn(function()
            while AutoTradeSecretPets_Toggle do
                local targetPlayer = game:GetService("Players"):FindFirstChild(targetTradeName)
                
                if not targetPlayer then
                    -- Wait for player to join
                    for i = 1, 300 do
                        if not AutoTradeSecretPets_Toggle then break end
                        if game:GetService("Players"):FindFirstChild(targetTradeName) then break end
                        task.wait(1)
                    end
                    task.wait(1)
                    continue
                end
                
                -- Quick check if we have any secret pets
                local freshPetData = LocalDataService:Get()
                local hasSecretPets = false
                
                if freshPetData and freshPetData.Pets then
                    for _, pet in pairs(freshPetData.Pets) do
                        for _, secretPetName in pairs(SecretPets) do
                            if pet.Name == secretPetName then
                                hasSecretPets = true
                                break
                            end
                        end
                        if hasSecretPets then break end
                    end
                end
                
                if not hasSecretPets then
                    task.wait(30)
                    continue
                end
                
                -- Trading logic
                local tradingUI = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.Trading
                
                -- If not in trade, send requests
                if not (tradingUI and tradingUI.Visible) then
                    while targetPlayer and targetPlayer.Parent ~= nil and AutoTradeSecretPets_Toggle do
                        tradingUI = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.Trading
                        if tradingUI and tradingUI.Visible then break end
                        
                        game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("TradeRequest", targetPlayer)
                        task.wait(3)
                    end
                end
                
                -- Handle active trade
                tradingUI = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.Trading
                if tradingUI and tradingUI.Visible then
                    -- Verify trading with correct player
                    local tradePartnerName = tradingUI.Frame.Top.Them.Username.Text
                    if string.sub(tradePartnerName, 1, 1) == "@" then
                        tradePartnerName = string.sub(tradePartnerName, 2)
                    end
                    
                    if tradePartnerName == targetTradeName then
                        -- Add pets to trade one by one, checking data each time
                        local allPetsAdded = false
                        local petCount = 0
                        
                        while not allPetsAdded and petCount < 10 do
                            -- Get fresh pet data
                            local currentPetData = LocalDataService:Get()
                            
                            -- Get currently traded pets and count them
                            local tradeContent = tradingUI.Frame.Inner.Offers.You.Content
                            local petIDsInTrade = {}
                            petCount = 0
                            
                            for _, item in pairs(tradeContent:GetChildren()) do
                                if item:IsA("Frame") and not string.match(item.Name, "^Blank%d+$") and not string.match(item.Name, "^Entry%d+$") then
                                    petIDsInTrade[item.Name] = true
                                    petCount = petCount + 1
                                end
                            end
                            
                            -- Stop if we've already added 10 pets
                            if petCount >= 10 then
                                allPetsAdded = true
                                break
                            end
                            
                            -- Try to find a pet to add
                            local foundPetToAdd = false
                            local petIdToAdd = nil
                            
                            if currentPetData and currentPetData.Pets then
                                for _, pet in pairs(currentPetData.Pets) do
                                    -- Check if this pet is a secret pet
                                    local isSecretPet = false
                                    for _, secretPetName in pairs(SecretPets) do
                                        if pet.Name == secretPetName then
                                            isSecretPet = true
                                            break
                                        end
                                    end
                                    
                                    if isSecretPet then
                                        if pet.Amount then
                                            -- For pets with Amount, add each index starting from 1
                                            for i = 1, pet.Amount do
                                                local fullPetId = pet.Id .. ":" .. i
                                                if not petIDsInTrade[fullPetId] then
                                                    petIdToAdd = fullPetId
                                                    foundPetToAdd = true
                                                    break
                                                end
                                            end
                                        else
                                            -- For pets without Amount, just add :0
                                            local fullPetId = pet.Id .. ":0"
                                            if not petIDsInTrade[fullPetId] then
                                                petIdToAdd = fullPetId
                                                foundPetToAdd = true
                                            end
                                        end
                                        
                                        -- Check if we found a pet to add
                                        if foundPetToAdd then
                                            break
                                        end
                                    end
                                end
                            end
                            
                            -- Add the pet if we found one
                            if foundPetToAdd and petIdToAdd then
                                -- Before pet count
                                local beforeCount = petCount
                                
                                -- Add the pet
                                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("TradeAddPet", petIdToAdd)
                                task.wait(1) -- Wait a bit longer to ensure UI updates
                                
                                -- Verify the pet was actually added by checking the count again
                                local tradeContent = tradingUI.Frame.Inner.Offers.You.Content
                                local afterCount = 0
                                
                                for _, item in pairs(tradeContent:GetChildren()) do
                                    if item:IsA("Frame") and not string.match(item.Name, "^Blank%d+$") and not string.match(item.Name, "^Entry%d+$") then
                                        afterCount = afterCount + 1
                                    end
                                end
                                
                                -- Update pet count with current number in trade
                                petCount = afterCount
                                
                                -- If count didn't increase, try one more time
                                if afterCount <= beforeCount then
                                    task.wait(0.5)
                                    game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("TradeAddPet", petIdToAdd)
                                    task.wait(1)
                                end
                            else
                                -- No more pets to add
                                allPetsAdded = true
                            end
                        end
                        
                        -- Double check how many pets we have in trade
                        local finalTradeContent = tradingUI.Frame.Inner.Offers.You.Content
                        local finalPetCount = 0
                        
                        for _, item in pairs(finalTradeContent:GetChildren()) do
                            if item:IsA("Frame") and not string.match(item.Name, "^Blank%d+$") and not string.match(item.Name, "^Entry%d+$") then
                                finalPetCount = finalPetCount + 1
                            end
                        end
                        
                        -- Only proceed if we actually added some pets
                        if finalPetCount > 0 then
                            -- Accept trade after all pets added
                            task.wait(1)
                            game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("TradeAccept")
                            
                            task.wait(1)
                            -- Check button text
                            local acceptButtonText = tradingUI.Frame.Inner.Offers.Buttons.Accept.Button.Label.Text
                            
                            if acceptButtonText == "Confirm" then
                                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("TradeConfirm")
                            end
                            
                            task.wait(5)
                        end
                    end
                end
                
                task.wait(1)
            end
        end)
    else
        if tradeThread then
            task.cancel(tradeThread)
            tradeThread = nil
        end
    end
    
    return AutoTradeSecretPets_Toggle
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Secret Check ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- Function to check if user has any secret pets
local function checkForSecretPets()
    -- Get fresh player data each time
    local freshPetData = LocalDataService:Get()
    local foundSecretPet = false
    local secretPetCounts = {}
    local playerName = game:GetService("Players").LocalPlayer.Name
    
    -- If data exists and has pets
    if freshPetData and freshPetData.Pets then
        -- Loop through all pets
        for _, pet in pairs(freshPetData.Pets) do
            -- Check if current pet name is in the secret pets list
            for _, secretPetName in pairs(SecretPets) do
                if pet.Name == secretPetName then
                    -- Count the pet
                    secretPetCounts[secretPetName] = (secretPetCounts[secretPetName] or 0) + 1
                    foundSecretPet = true
                end
            end
        end
    end
    
    -- If any secret pets found, create or update the overlay
    if foundSecretPet then
        -- Create green overlay if it doesn't exist
        if not SecretPetOverlay then
            SecretPetOverlay = Instance.new("ScreenGui")
            SecretPetOverlay.Name = "SecretPetOverlay"
            SecretPetOverlay.ResetOnSpawn = false
            SecretPetOverlay.IgnoreGuiInset = true
            SecretPetOverlay.DisplayOrder = 99  -- Make it appear above egg counter
            
            -- Create fully green background
            local frame = Instance.new("Frame")
            frame.Size = UDim2.new(1, 0, 1, 0)
            frame.BackgroundColor3 = Color3.fromRGB(0, 255, 0) -- Green
            frame.BackgroundTransparency = 0
            frame.BorderSizePixel = 0
            frame.Name = "SecretFrame"
            frame.Parent = SecretPetOverlay
            
            -- Add player name at the top
            local playerNameLabel = Instance.new("TextLabel")
            playerNameLabel.Size = UDim2.new(1, 0, 0, 60)
            playerNameLabel.Position = UDim2.new(0, 0, 0.1, 0)
            playerNameLabel.BackgroundTransparency = 1
            playerNameLabel.Font = Enum.Font.SourceSansBold
            playerNameLabel.TextSize = 140
            playerNameLabel.TextWrapped = true
            playerNameLabel.TextColor3 = Color3.fromRGB(255, 255, 255) -- White text
            playerNameLabel.Text = "PLAYER: " .. string.upper(playerName)
            playerNameLabel.TextStrokeTransparency = 0
            playerNameLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
            playerNameLabel.Name = "PlayerName"
            playerNameLabel.Parent = frame
            
            -- Add a ScrollingFrame to contain all pet text labels
            local scrollFrame = Instance.new("ScrollingFrame")
            scrollFrame.Size = UDim2.new(0.8, 0, 0.5, 0)
            scrollFrame.Position = UDim2.new(0.1, 0, 0.25, 0)
            scrollFrame.BackgroundTransparency = 1
            scrollFrame.ScrollBarThickness = 6
            scrollFrame.CanvasSize = UDim2.new(0, 0, 0, 0) -- Will be updated based on content
            scrollFrame.Name = "PetList"
            scrollFrame.Parent = frame
            
            SecretPetOverlay.Parent = game:GetService("CoreGui")
        else
            -- Update player name if it changed
            SecretPetOverlay.SecretFrame.PlayerName.Text = "PLAYER: " .. string.upper(playerName)
        end
        
        -- Get the scrolling frame reference
        local scrollFrame = SecretPetOverlay.SecretFrame.PetList
        
        -- Clear existing pet labels
        for _, child in pairs(scrollFrame:GetChildren()) do
            if child:IsA("TextLabel") then
                child:Destroy()
            end
        end
        
        -- Add text labels for each secret pet with count
        local yPosition = 0
        for petName, count in pairs(secretPetCounts) do
            local textLabel = Instance.new("TextLabel")
            textLabel.Size = UDim2.new(1, 0, 0, 70)
            textLabel.Position = UDim2.new(0, 0, 0, yPosition)
            textLabel.BackgroundTransparency = 1
            textLabel.Font = Enum.Font.SourceSansBold
            textLabel.TextSize = 140
            textLabel.TextWrapped = true
            textLabel.TextColor3 = Color3.fromRGB(255, 255, 255) -- White text
            textLabel.Text = string.upper(petName) .. " x" .. count
            textLabel.TextStrokeTransparency = 0
            textLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
            textLabel.Parent = scrollFrame
            
            yPosition = yPosition + 80
        end
        
        -- Update canvas size to fit all labels
        scrollFrame.CanvasSize = UDim2.new(0, 0, 0, yPosition)
        
        -- Enable auto trade if not already enabled
        if not AutoTradeSecretPets_Toggle then
            autoTradeSecretPets() -- Call the function to enable auto trading
        end
        
        task.wait(5) -- Wait 5 seconds before the next check
        return true
    else
        -- Remove overlay if no secret pets found
        if SecretPetOverlay then
            SecretPetOverlay:Destroy()
            SecretPetOverlay = nil
        end
        
        -- Disable auto trade if it's enabled
        if AutoTradeSecretPets_Toggle then
            autoTradeSecretPets() -- Call the function to disable auto trading
        end
        
        task.wait(10) -- Wait 10 seconds before the next check
        return false
    end
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Handle Intro ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local IntroHandling_Toggle = false
local hasHandledIntro = false -- Flag to track if intro was successfully handled

local function SimulateIntroPlayButtonClick()
    local IntroPlayButton = game:GetService("Players").LocalPlayer.PlayerGui.Intro.Play.Button
    IntroPlayButton:SetAttribute("Pressed", true)
    task.wait(0.1)
    IntroPlayButton:SetAttribute("Pressed", false)
end

local function SimulateOptimizedButtonClick()
    local Optimized = game:GetService("Players").LocalPlayer.PlayerGui.Intro.Graphics.Content.Low.Action.Button
    Optimized:SetAttribute("Pressed", true)
    task.wait(0.1)
    Optimized:SetAttribute("Pressed", false)
end

local function handleIntro()
    if IntroHandling_Toggle then
        return hasHandledIntro
    end
    
    IntroHandling_Toggle = true
    
    -- Keep trying until intro is completely gone - no timeout
    while true do
        -- Safely check if intro exists and is enabled
        local success, introStillActive = pcall(function()
            local Intro = game:GetService("Players").LocalPlayer.PlayerGui:FindFirstChild("Intro")
            
            if Intro and Intro.Enabled then
                -- Check if Play is visible and click it
                if Intro.Play.Visible == true then
                    task.wait(5)
                    SimulateIntroPlayButtonClick()
                    task.wait(1) -- Wait for graphics options to appear
                end
                
                -- Check if Graphics is visible and click low option
                if Intro.Graphics.Visible == true then
                    SimulateOptimizedButtonClick()
                    task.wait(1)
                end
                
                -- Try clicking both again for good measure
                SimulateIntroPlayButtonClick()
                task.wait(0.5)
                SimulateOptimizedButtonClick()
                
                -- Intro still exists and is enabled
                return true
            end
            
            -- Intro is gone or not enabled
            return false
        end)
        
        -- Check if intro is gone
        if success and not introStillActive then
            hasHandledIntro = true
            break
        end
        
        -- Wait a bit before checking again
        task.wait(2)
    end
    
    -- Turn off toggle when done
    IntroHandling_Toggle = false
    
    return hasHandledIntro
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━ Daily Rewards Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local CheckRewards_Toggle = false
local hasClaimedDailyReward = false -- Tracks if rewards were successfully claimed
local startCheckTime = nil

local function SimulateShopCloseButtonClick() -- for buying storage
    local ShopClose = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.DailyRewards.Shop.Top.Close.Button
    ShopClose:SetAttribute("Pressed", true)
    task.wait(0.1)
    ShopClose:SetAttribute("Pressed", false)
end

local function checkDailyRewards()
    CheckRewards_Toggle = not CheckRewards_Toggle
    
    if CheckRewards_Toggle then
        -- Initialize timer on first check
        startCheckTime = os.time()
        
        -- Start thread or continue with logic
        spawn(function()
            while CheckRewards_Toggle do
                -- Check if we've exceeded the timeout period (300 seconds / 5 minutes)
                if os.time() - startCheckTime > 300 then
                    CheckRewards_Toggle = false -- Stop the function
                    return false
                end
                
                -- Use pcall for safety
                local success, result = pcall(function()
                    -- Check if the daily rewards UI is visible
                    local dailyRewardsUI = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.DailyRewards
                    
                    if dailyRewardsUI and dailyRewardsUI.Login and dailyRewardsUI.Login.Visible == true then
                        -- Claim the rewards
                        game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("DailyRewardClaimStars")
                        task.wait(1)
                        
                        -- Close the shop if it appeared
                        if dailyRewardsUI.Shop and dailyRewardsUI.Shop.Visible == true then
                            SimulateShopCloseButtonClick()
                            task.wait(0.5)
                        end
                        
                        -- Mark as successful and stop checking
                        CheckRewards_Toggle = false
                        hasClaimedDailyReward = true
                        return true
                    end
                    
                    -- Wait a bit before checking again
                    task.wait(1)
                    return false
                end)
                
                -- Handle errors
                if not success then
                    CheckRewards_Toggle = false
                    return false
                end
            end
        end)
    end
    
    return hasClaimedDailyReward
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Claim Playtime ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local AutoClaimPlaytime_Toggle = false -- Flag to track if we're automatically claiming playtime rewards
local autoClaimingPlaytimeThread = nil -- Variable to store the auto claiming thread
local PlaytimeRewardsClaimed = false -- Flag to track if all playtime rewards are claimed

local function toggleAutoClaimPlaytime()
    -- If all rewards are claimed, don't start again
    if PlaytimeRewardsClaimed then
        return PlaytimeRewardsClaimed
    end
    
    AutoClaimPlaytime_Toggle = not AutoClaimPlaytime_Toggle
    
    if AutoClaimPlaytime_Toggle then
        -- Start a new thread for continuous playtime reward claiming
        autoClaimingPlaytimeThread = spawn(function()
            while AutoClaimPlaytime_Toggle do
                -- Get the Playtime UI
                local Playtime = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.Playtime
                
                -- Check if Playtime exists
                if Playtime and Playtime:FindFirstChild("Frame") and Playtime.Frame:FindFirstChild("Main") then
                    local Main = Playtime.Frame.Main
                    local allClaimed = true -- Assume all claimed until we find one that's not
                    local foundAnyRewards = false -- Track if we found any reward UI elements
                    local anyPending = false -- Track if there are any pending rewards
                    
                    -- Loop through all children of Main
                    for _, child in pairs(Main:GetChildren()) do
                        -- Check if this is a numbered reward (1, 2, 3, 4, etc.)
                        if tonumber(child.Name) then
                            foundAnyRewards = true
                            local rewardNumber = tonumber(child.Name)
                            local button = child:FindFirstChild("Button")
                            local completed = child:FindFirstChild("Completed")
                            
                            -- Only proceed if both button and completed exist
                            if button and completed then
                                local label = button:FindFirstChild("Label")
                                
                                -- State 1: Ready to claim
                                if label and label.Text == "Open" and not completed.Visible then
                                    allClaimed = false -- Found one that's not claimed
                                    
                                    -- Invoke server to claim the reward
                                    local success, result = pcall(function()
                                        return game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Function:InvokeServer("ClaimPlaytime", rewardNumber)
                                    end)
                                    game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimSeason")
                                    -- Wait a bit after claiming
                                    task.wait(1)
                                end
                                
                                -- State 2: Already claimed
                                if completed.Visible and (not label or not label.Visible) then
                                    -- This one is already claimed, don't change allClaimed
                                end
                                
                                -- State 3: Pending (time countdown)
                                if not completed.Visible and label and label.Text ~= "Open" then
                                    allClaimed = false -- Not all claimed yet
                                    anyPending = true -- We have pending rewards
                                end
                            end
                        end
                    end
                    
                    -- If we found reward UI elements and all are claimed (none pending), we're done
                    if foundAnyRewards and allClaimed and not anyPending then
                        PlaytimeRewardsClaimed = true
                        AutoClaimPlaytime_Toggle = false
                        break
                    end
                end
                
                -- Wait before checking again
                task.wait(30) -- Check for playtime rewards every 30 seconds
            end
        end)
    end
    
    return AutoClaimPlaytime_Toggle
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Claim Prizes Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local AutoClaimPrizes_Toggle = false -- Flag to track if we're automatically claiming prizes
local autoClaimingPrizeThread = nil -- Variable to store the auto claiming thread

-- Function to check and claim available prizes once
local function CheckAndClaimPrizes()
    -- Get the Quests UI
    local Prizes = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.Quests.Frame.Main.Prizes
    
    -- Loop through all prize items (b-1, b-2, etc.)
    for _, prizeItem in pairs(Prizes:GetChildren()) do
        
        -- Check for Content
        local Content = prizeItem:FindFirstChild("Content")
        if Content then
            -- Find Bar and Claim inside Content
            local Bar = Content:FindFirstChild("Bar")
            local Claim = Content:FindFirstChild("Claim")
            
            if Bar and Claim and Bar:FindFirstChild("Label") and Claim:FindFirstChild("Button") then
                local progressText = Bar.Label.Text
                local ClaimButton = Claim.Button
                
                -- Check if progress is 100% and Claim is visible
                if progressText == "100%" and Claim.Visible then

                    -- Simulate button press
                    ClaimButton:SetAttribute("Pressed", true)
                    task.wait(0.1)
                    ClaimButton:SetAttribute("Pressed", false)
                    
                    -- Return after claiming the first prize found
                    return true
                end
            end
        end
    end

    return false
end

-- Function to check for prizes until no notifications remain
local function checkAllTabsForPrizes()
    local PlayerGui = game:GetService("Players").LocalPlayer.PlayerGui
    local QuestsFrame = PlayerGui.ScreenGui.Quests.Frame
    local Sidebar = QuestsFrame.Sidebar
    
    local hasClaimedAny = false
    local keepChecking = true
    
    -- Keep checking until no more notifications are found
    while keepChecking do
        keepChecking = false -- Will be set to true if we find and claim something
        
        -- Check buttons with notifications
        local BubblesButton = Sidebar.Buttons.Bubbles.Button
        local EggsButton = Sidebar.Buttons.Eggs.Button
        local QuestsButton = Sidebar.Buttons.Quests.Button
        
        -- Check for Bubbles notification
        local BubblesNotification = BubblesButton:FindFirstChild("Notification")
        if BubblesNotification and BubblesNotification.Visible then
            BubblesButton:SetAttribute("Pressed", true)
            task.wait(0.1)
            BubblesButton:SetAttribute("Pressed", false)
            task.wait(1) -- Wait for UI to update
            
            -- Try to claim prizes
            local claimed = CheckAndClaimPrizes()
            if claimed then 
                hasClaimedAny = true
                keepChecking = true -- Continue checking
                task.wait(0.5) -- Short wait before checking again
                continue 
            end
        end
        
        -- Check for Eggs notification
        local EggsNotification = EggsButton:FindFirstChild("Notification")
        if EggsNotification and EggsNotification.Visible then
            EggsButton:SetAttribute("Pressed", true)
            task.wait(0.1)
            EggsButton:SetAttribute("Pressed", false)
            task.wait(1) -- Wait for UI to update
            
            -- Try to claim prizes
            local claimed = CheckAndClaimPrizes()
            if claimed then 
                hasClaimedAny = true
                keepChecking = true -- Continue checking
                task.wait(0.5) -- Short wait before checking again
                continue
            end
        end
        
        -- Check Quests tab
        local QuestsNotification = QuestsButton:FindFirstChild("Notification")
        if QuestsNotification and QuestsNotification.Visible then
            QuestsButton:SetAttribute("Pressed", true)
            task.wait(0.1)
            QuestsButton:SetAttribute("Pressed", false)
            task.wait(1) -- Wait for UI to update
            
            -- Try to claim prizes
            local claimed = CheckAndClaimPrizes()
            if claimed then 
                hasClaimedAny = true
                keepChecking = true -- Continue checking
                task.wait(0.5) -- Short wait before checking again
                continue
            end
        end
    end
    
    -- Always end on the Quests tab
    local QuestsButton = Sidebar.Buttons.Quests.Button
    QuestsButton:SetAttribute("Pressed", true)
    task.wait(0.1)
    QuestsButton:SetAttribute("Pressed", false)
    
    return hasClaimedAny
end

-- Function to toggle automatic prize claiming
local function toggleAutoClaimPrizes()
    AutoClaimPrizes_Toggle = not AutoClaimPrizes_Toggle
    
    if AutoClaimPrizes_Toggle then
        -- Start a new thread for continuous prize claiming
        autoClaimingPrizeThread = spawn(function()
            while AutoClaimPrizes_Toggle do
                checkAllTabsForPrizes()
                task.wait(60) -- Check for prizes every 60 seconds
            end
        end)
    end
    
    return AutoClaimPrizes_Toggle
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Wheel Spin Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local AutoWheelSpin_Toggle = false -- Flag to track if we're automatically spinning the wheel
local autoSpinningWheelThread = nil -- Variable to store the auto wheel spinning thread

local function WheelSpinButtonClick()
    local WheelSpin = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.WheelSpin.Frame.Main.Spin.Button
    WheelSpin:SetAttribute("Pressed", true)
    task.wait(0.1)
    WheelSpin:SetAttribute("Pressed", false)
end

local function toggleAutoWheelSpin()
    AutoWheelSpin_Toggle = not AutoWheelSpin_Toggle
    
    if AutoWheelSpin_Toggle then
        -- Start a new thread for continuous wheel spin checking
        autoSpinningWheelThread = spawn(function()
            while AutoWheelSpin_Toggle do
                local shouldContinueSpinning = false
                
                -- Use pcall for error handling
                pcall(function()
                    -- Get fresh data directly from the LocalDataService
                    local freshData = LocalDataService:Get()
                    
                    -- Check if the player has Spin Tickets in their Powerups
                    local spinTickets = freshData.Powerups and freshData.Powerups["Spin Ticket"] or 0
                    
                    -- Check if wheel spin UI exists for free spin
                    local wheelSpinUI = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.WheelSpin
                    
                    if wheelSpinUI and wheelSpinUI.Frame and wheelSpinUI.Frame.Main then
                        local Main = wheelSpinUI.Frame.Main
                        
                        -- Check for free spin
                        if Main.Buttons and Main.Buttons.Free and 
                           Main.Buttons.Free.Button and 
                           Main.Buttons.Free.Button.Title and 
                           Main.Buttons.Free.Button.Title.Text == "Claim" then
                            
                            -- Claim the free spin
                            game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimFreeWheelSpin")
                            task.wait(1) -- Wait a bit after claiming
                            
                            -- Refresh data after claiming
                            freshData = LocalDataService:Get()
                            spinTickets = freshData.Powerups and freshData.Powerups["Spin Ticket"] or 0
                        end
                    end
                    
                    -- If spin tickets are available in inventory, use them
                    if spinTickets > 0 then

                        WheelSpinButtonClick()
                        --game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Function:InvokeServer("WheelSpin")
                        task.wait(15) -- Wait longer after spinning to let animations complete
                        
                        -- Refresh data after using a spin ticket
                        freshData = LocalDataService:Get()
                        spinTickets = freshData.Powerups and freshData.Powerups["Spin Ticket"] or 0
                        
                        -- If we still have tickets, set flag to continue spinning without waiting
                        if spinTickets > 0 then
                            shouldContinueSpinning = true
                        end
                    end
                end)
                
                -- Skip the wait and continue spinning if we have more tickets
                if shouldContinueSpinning then
                    task.wait(0.1) -- Small wait to prevent overwhelming the server
                else
                    -- Wait before checking again
                    task.wait(60) -- Check every 3 minutes
                end
            end
        end)
    end
    
    return AutoWheelSpin_Toggle
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Set Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local SetSettings_Toggle = false
local SettingsThread = nil
local settingsApplied = false

local function SetOptimalSettings()
    -- Don't run if settings are already applied
    if settingsApplied then
        return settingsApplied
    end

    SetSettings_Toggle = not SetSettings_Toggle
    
    if SetSettings_Toggle then
        SettingsThread = spawn(function()
            -- Settings to optimize gameplay
            local optimalSettings = {
                ["Hide Bubbles"] = true,
                ["Hide Others Pets"] = true,
                ["Hide All Pets"] = true,
                ["Compact Pet Inventory"] = true,
                ["Skip Easy Legendary"] = true,
                ["Music"] = 0,
                ["Sound Effects"] = 0
            }
            
            -- Maximum retries to prevent getting stuck
            local maxRetries = 3
            local retryCount = 0
            
            while retryCount < maxRetries and SetSettings_Toggle do
                -- Get fresh data
                local data = LocalDataService:Get()
                local Settings = data.Settings or {}
                
                -- Check if any settings need to be applied
                local settingsToApply = {}
                local allSettingsMatch = true
                
                for setting, value in pairs(optimalSettings) do
                    -- Skip settings that don't exist
                    if Settings[setting] == nil then
                        continue
                    end
                    
                    local settingMatches = false
                    
                    if setting == "Music" or setting == "Sound Effects" then
                        settingMatches = Settings[setting] <= 1
                    else
                        settingMatches = Settings[setting] == value
                    end
                    
                    if not settingMatches then
                        allSettingsMatch = false
                        table.insert(settingsToApply, {setting = setting, value = value})
                    end
                end
                
                -- If all settings match optimal values, we're done
                if allSettingsMatch then
                    break
                end
                
                -- Apply each setting that needs changing
                for _, settingData in ipairs(settingsToApply) do
                    Remote.Event:FireServer("SetSetting", settingData.setting, settingData.value)
                    task.wait(0.3)  -- Slightly longer delay to ensure each setting is processed
                end
                
                -- Wait for settings to apply
                task.wait(1.5)
                
                -- Increment retry counter
                retryCount = retryCount + 1
            end
            
            -- Mark as complete regardless of verification outcome
            SetSettings_Toggle = false
            settingsApplied = true
        end)
    end
    
    return settingsApplied
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Hide Overlay ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local AutoHideOverlay_Toggle = false -- Flag to track if we're automatically hiding overlays
local autoHidingOverlayThread = nil -- Variable to store the auto hiding thread

local function toggleAutoHideOverlay()
    AutoHideOverlay_Toggle = not AutoHideOverlay_Toggle
    
    if AutoHideOverlay_Toggle then
        -- Start a new thread for continuous overlay checking
        autoHidingOverlayThread = spawn(function()
            while AutoHideOverlay_Toggle do
                -- Use pcall for error handling
                pcall(function()
                    -- Check if the overlay exists and is visible
                    local overlay = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("_overlay")
                    local dailyRWD = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("DailyRewards")
                    local PlyTime = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("Playtime")
                    local Mstry = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("Mastery")
                    local Qust = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("Quests")
                    local Sesson = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("Season")
                    local NotifGame = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("HUD") and 
                                    game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.HUD:FindFirstChild("NotifyGame")
                    local Prompts = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("Prompt")
                    local WorldMp = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("WorldMap")
                    local UpdateNews = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui:FindFirstChild("_changelog")

                    if WorldMp and WorldMp.Visible then
                        -- Set the overlay to not visible
                        WorldMp.Visible = false
                    end

                    if overlay and overlay.Visible then
                        -- Set the overlay to not visible
                        overlay.Visible = false
                    end

                    if dailyRWD and dailyRWD.Visible then
                        -- Set the overlay to not visible
                        dailyRWD.Visible = false
                    end

                    if PlyTime and PlyTime.Visible then
                        -- Set the overlay to not visible
                        PlyTime.Visible = false
                    end

                    if Mstry and Mstry.Visible then
                        -- Set the overlay to not visible
                        Mstry.Visible = false
                    end

                    if Qust and Qust.Visible then
                        -- Set the overlay to not visible
                        Qust.Visible = false
                    end

                    if Sesson and Sesson.Visible then
                        -- Set the overlay to not visible
                        Sesson.Visible = false
                    end

                    if NotifGame and NotifGame.Visible then
                        -- Set the overlay to not visible
                        NotifGame.Visible = false
                    end

                    if Prompts and Prompts.Visible then
                        -- Set the overlay to not visible
                        Prompts.Visible = false
                    end

                    if UpdateNews and UpdateNews.Visible then
                        -- Set the overlay to not visible
                        UpdateNews.Visible = false
                    end

                end)
                
                -- Wait before checking again
                task.wait(20) -- Check every 20 seconds
            end
        end)
    end
    
    return AutoHideOverlay_Toggle
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Fly ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local isFlyModeActive = false
local flyModeThread = nil

local function toggleFlyMode()
    isFlyModeActive = not isFlyModeActive
    
    if isFlyModeActive then
        flyModeThread = spawn(function()
            while isFlyModeActive do
                pcall(function()
                    local player = game:GetService("Players").LocalPlayer
                    local character = player.Character
                    if not character then return end
                    
                    local humanoid = character:FindFirstChild("Humanoid")
                    local rootPart = character:FindFirstChild("HumanoidRootPart")
                    if not humanoid or not rootPart then return end
                    
                    local camera = workspace.CurrentCamera
                    local UIS = game:GetService("UserInputService")
                    local flySpeed = humanoid.WalkSpeed * 0.9
                    
                    -- Check if Gyro exists in rootPart, create if not
                    local Gyro = rootPart:FindFirstChild("Gyro")
                    if not Gyro then
                        Gyro = Instance.new("BodyGyro")
                        Gyro.Name = "Gyro"
                        Gyro.P = 9e4
                        Gyro.MaxTorque = Vector3.new(9e9, 9e9, 9e9)
                        Gyro.Parent = rootPart
                    end
                    
                    -- Check if BodyVelocity exists in rootPart, create if not
                    local Velocity = rootPart:FindFirstChild("BodyVelocity")
                    if not Velocity then
                        Velocity = Instance.new("BodyVelocity")
                        Velocity.Name = "BodyVelocity"
                        Velocity.MaxForce = Vector3.new(9e9, 9e9, 9e9)
                        Velocity.Velocity = Vector3.zero
                        Velocity.Parent = rootPart
                    end
                    
                    -- Set platform stand
                    humanoid.PlatformStand = true
                    
                    -- Update Gyro CFrame
                    Gyro.CFrame = CFrame.new(rootPart.Position, rootPart.Position + camera.CFrame.LookVector)
                    
                    -- Calculate movement direction based on key presses
                    local moveDir = Vector3.new(0,0,0)
                    if UIS:IsKeyDown(Enum.KeyCode.W) then moveDir = moveDir + camera.CFrame.LookVector end
                    if UIS:IsKeyDown(Enum.KeyCode.S) then moveDir = moveDir - camera.CFrame.LookVector end
                    if UIS:IsKeyDown(Enum.KeyCode.A) then moveDir = moveDir - camera.CFrame.RightVector end
                    if UIS:IsKeyDown(Enum.KeyCode.D) then moveDir = moveDir + camera.CFrame.RightVector end
                    if UIS:IsKeyDown(Enum.KeyCode.E) then moveDir = moveDir + Vector3.new(0,1,0) end
                    if UIS:IsKeyDown(Enum.KeyCode.Q) then moveDir = moveDir - Vector3.new(0,1,0) end
                    
                    -- Apply speed
                    if moveDir.Magnitude > 0 then moveDir = moveDir.Unit * flySpeed end
                    Velocity.Velocity = moveDir
                end)
                
                task.wait(0.1)
            end
        end)
    else
        -- Clean up when toggled off
        pcall(function()
            local player = game:GetService("Players").LocalPlayer
            local character = player.Character
            if character then
                local humanoid = character:FindFirstChild("Humanoid")
                local rootPart = character:FindFirstChild("HumanoidRootPart")
                
                if humanoid then humanoid.PlatformStand = false end
                
                if rootPart then
                    local Gyro = rootPart:FindFirstChild("Gyro")
                    local Velocity = rootPart:FindFirstChild("BodyVelocity")
                    
                    if Gyro then Gyro:Destroy() end
                    if Velocity then Velocity:Destroy() end
                end
            end
        end)
    end
    
    return isFlyModeActive
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Press B ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local isPressingB = false -- Flag to track if we're pressing B periodically
local pressingBThread = nil -- Variable to store the pressing B thread

-- Function to toggle periodic B key pressing
local function togglePeriodicB()
    isPressingB = not isPressingB
    
    if isPressingB then
        -- Start a new thread for periodic B key pressing
        pressingBThread = spawn(function()
            while isPressingB do
                -- Press B key
                VIM:SendKeyEvent(true, "B", false, game) -- Press B
                task.wait(0.01)
                VIM:SendKeyEvent(false, "B", false, game) -- Release B
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("BeginSeasonInfinite")
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ChallengePassClaimAll")
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 1, 1)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 2, 1)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 3, 1)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 4, 2)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 5, 1)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 6, 1)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 7, 2)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 8, 2)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 9, 1)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 10, 1)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimCompetitivePrize", 11, 1)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimChest", "Giant Chest", true)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimChest", "Void Chest", true)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("UnlockHatchingZone")
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimSeason")
                task.wait(1)   
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("DoggyJumpWin", 1)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("DoggyJumpWin", 2)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("DoggyJumpWin", 3)
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimChest", "Void Chest")
                task.wait(1)
                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimChest", "Giant Chest")
                task.wait(5)
                
                -- Wait for 1 minute before pressing again
                task.wait(180)
            end
        end)
    end
    
    return isPressingB
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Mastery Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local function SimulateMasteryBuffButtonClick()
    local BuffButton = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.Mastery.Container.Left.ScrollingFrame.Buffs.Button
    BuffButton:SetAttribute("Pressed", true)
    task.wait(0.1)
    BuffButton:SetAttribute("Pressed", false)
end

local function SimulateMasteryPetButtonClick()
    local PetButton = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.Mastery.Container.Left.ScrollingFrame.Pets.Button
    PetButton:SetAttribute("Pressed", true)
    task.wait(0.1)
    PetButton:SetAttribute("Pressed", false)
end

local function SimulateMasteryShopButtonClick()
    local ShopButton = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.Mastery.Container.Left.ScrollingFrame.Shops.Button
    ShopButton:SetAttribute("Pressed", true)
    task.wait(0.1)
    ShopButton:SetAttribute("Pressed", false)
end

local function FindAvailableAndMastery()
    isAutoMastery = not isAutoMastery
    
    if isAutoMastery then
        autoMasteryThread = spawn(function()
            while isAutoMastery do
                -- Get current mastery levels from data
                local freshData = LocalDataService:Get()
                
                -- Handle different data structures for MasteryLevels
                local masteryLevels = {Pets = 0, Buffs = 0, Shops = 0}
                
                -- Check if MasteryLevels exists and is a table
                if freshData.MasteryLevels and type(freshData.MasteryLevels) == "table" then
                    -- Check if it's an object with properties
                    if freshData.MasteryLevels.Pets ~= nil then
                        -- It's an object, get values or default to 0
                        masteryLevels = {
                            Pets = freshData.MasteryLevels.Pets or 0,
                            Buffs = freshData.MasteryLevels.Buffs or 0,
                            Shops = freshData.MasteryLevels.Shops or 0
                        }
                    end
                end
                
                -- Update the mastery completion flags
                PetsMasteryCompleted = (masteryLevels.Pets or 0) >= Target_Pets_Mastery
                BuffsMasteryCompleted = (masteryLevels.Buffs or 0) >= Target_Buffs_Mastery
                ShopsMasteryCompleted = (masteryLevels.Shops or 0) >= Target_Shops_Mastery
                AllMasteryCompleted = PetsMasteryCompleted and BuffsMasteryCompleted and ShopsMasteryCompleted
                
                -- Determine which category to focus on based on priority using global target variables
                local upgradePets = not PetsMasteryCompleted
                local upgradeBuffs = PetsMasteryCompleted and not BuffsMasteryCompleted
                local upgradeShops = PetsMasteryCompleted and BuffsMasteryCompleted and not ShopsMasteryCompleted
                
                -- Function to attempt upgrades within a category
                local function attemptUpgradesInCategory()
                    -- Get the Mastery UI
                    local MasteryFrame = game:GetService("Players").LocalPlayer.PlayerGui.ScreenGui.Mastery
                    
                    if not (MasteryFrame and MasteryFrame.Container and 
                            MasteryFrame.Container.Right and 
                            MasteryFrame.Container.Right.ScrollingFrame) then
                        return false
                    end
                    
                    local ScrollingFrame = MasteryFrame.Container.Right.ScrollingFrame
                    local madeUpgrade = false
                    
                    -- Loop through all templates to find upgrades
                    for _, template in pairs(ScrollingFrame:GetChildren()) do
                        if template.Name == "Template" then
                            local Content = template:FindFirstChild("Content")
                            if Content then
                                local Purchase = Content:FindFirstChild("Purchase")
                                if Purchase then
                                    local Button = Purchase:FindFirstChild("Button")
                                    if Button then
                                        local Label = Button:FindFirstChild("Label")
                                        if Label and Label.Text then
                                            -- Check if it's free
                                            if Label.Text == "FREE" or Label.Text == "0" then
                                                -- Click the button
                                                Button:SetAttribute("Pressed", true)
                                                task.wait(0.1)
                                                Button:SetAttribute("Pressed", false)
                                                madeUpgrade = true
                                                task.wait(0.2)
                                                return true
                                            end
                                            
                                            -- Determine currency type
                                            local isCoinPrice = true  -- Default to Coin
                                            local isGemPrice = false
                                            
                                            -- Look for currency icon
                                            for _, child in pairs(Button:GetChildren()) do
                                                if child:IsA("ImageLabel") or child:IsA("ImageButton") then
                                                    if child.Image and child.Image:match("122003296498191") then
                                                        isCoinPrice = false
                                                        isGemPrice = true
                                                        break
                                                    elseif child.Image and child.Image:match("121401017387099") then
                                                        isCoinPrice = true
                                                        isGemPrice = false
                                                        break
                                                    end
                                                end
                                            end
                                            
                                            -- Get the price value
                                            local price = convertPriceToNumber(Label.Text)
                                            
                                            -- Check resources - using the existing functions
                                            local currentCoins = GetCurrentCoins()
                                            local currentGems = GetCurrentGems()
                                            
                                            local canAfford = false
                                            if isCoinPrice and currentCoins >= price then
                                                canAfford = true
                                            elseif isGemPrice and currentGems >= price then
                                                canAfford = true
                                            end
                                            
                                            -- If we can afford it, make the purchase
                                            if canAfford then
                                                Button:SetAttribute("Pressed", true)
                                                task.wait(0.1)
                                                Button:SetAttribute("Pressed", false)
                                                madeUpgrade = true
                                                task.wait(0.2)
                                                return true
                                            end
                                        end
                                    end
                                end
                            end
                        end
                    end
                    
                    return madeUpgrade
                end
                
                -- Process upgrades by priority:
                -- First focus on Pets until they reach target, then Buffs, then Shops
                if upgradePets then
                    SimulateMasteryPetButtonClick()
                    task.wait(0.5)
                    attemptUpgradesInCategory()
                elseif upgradeBuffs then
                    SimulateMasteryBuffButtonClick()
                    task.wait(0.5)
                    attemptUpgradesInCategory()
                elseif upgradeShops then
                    SimulateMasteryShopButtonClick()
                    task.wait(0.5)
                    attemptUpgradesInCategory()
                else
                    -- All target levels reached, check all categories for any additional upgrades
                    
                    -- Check Pets first
                    SimulateMasteryPetButtonClick()
                    task.wait(0.5)
                    local upgradedPets = attemptUpgradesInCategory()
                    
                    if not upgradedPets then
                        -- Then check Buffs
                        SimulateMasteryBuffButtonClick()
                        task.wait(0.5)
                        local upgradedBuffs = attemptUpgradesInCategory()
                        
                        if not upgradedBuffs then
                            -- Finally check Shops
                            SimulateMasteryShopButtonClick()
                            task.wait(0.5)
                            attemptUpgradesInCategory()
                        end
                    end
                end
                
                -- Wait before next check
                task.wait(10)
            end
        end)
    end
    
    return isAutoMastery
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Reroll Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local RerollEnchants_Toggle = false
local RerollThread = nil

local function hasAnyDesiredEnchant(pet)
    if not pet or not pet.Enchants then return false end
    for _, enchant in ipairs(pet.Enchants) do
        local requiredLevel = enchants[enchant.Id]
        if requiredLevel and enchant.Level >= requiredLevel then
            return true
        end
    end
    return false
end

local function RerollEnchants()
    RerollEnchants_Toggle = not RerollEnchants_Toggle
    
    if RerollEnchants_Toggle then
        -- Start a new thread for continuous enchant rerolling
        RerollThread = spawn(function()
            while RerollEnchants_Toggle do
                -- Get the current team, which will refresh every cycle
                local data = LocalDataService:Get()
                local currentTeam = data.Teams[1].Pets
                
                for _, uuid in ipairs(currentTeam) do
                    local pet = getPetById(data, uuid)

                    if pet and not hasAnyDesiredEnchant(pet) then
                        while RerollEnchants_Toggle do
                            Remote.Function:InvokeServer("RerollEnchants", uuid)
                            task.wait(0.2)

                            -- Refresh data after each reroll
                            local updatedData = LocalDataService:Get()
                            pet = getPetById(updatedData, uuid)

                            if hasAnyDesiredEnchant(pet) then
                                break
                            end
                        end
                    end
                end
                
                -- After checking all pets, wait before rechecking to catch any team changes
                task.wait(60)
            end
        end)
    end
    
    return RerollEnchants_Toggle
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Buy Gum and Flavors ━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- Function to get the highest priced item from a config table
local function get_Highest_Priced_Item(config_table)
    local highest_price = 0
    local highest_item_name = nil
    
    for item_name, item_data in pairs(config_table) do
        if item_data.price > highest_price then
            highest_price = item_data.price
            highest_item_name = item_name
        end
    end
    
    return highest_item_name
end

-- Get the dynamic max items
local max_flavor_item = get_Highest_Priced_Item(flavorsConfig)
local max_gum_item = get_Highest_Priced_Item(gumConfig)

local function AutoBuyItems()
    -- Refresh the max items in case the configs changed
    max_flavor_item = get_Highest_Priced_Item(flavorsConfig)
    max_gum_item = get_Highest_Priced_Item(gumConfig)
    
    AutoBuy_Toggle = not AutoBuy_Toggle
    
    if AutoBuy_Toggle then
        Buy_Thread = spawn(function()
            -- First check if we already have max upgrades
            local freshData = LocalDataService:Get()
            
            -- Check for max flavor using dynamic highest item
            if freshData.Flavors and freshData.Flavors[max_flavor_item] then
                max_Flavor_Reached = true
            end
            
            -- Check for max gum using dynamic highest item
            if freshData.Gum and freshData.Gum[max_gum_item] then
                max_Gum_Reached = true
            end
            
            -- Set combined flag
            max_Upgrades_Reached = max_Flavor_Reached and max_Gum_Reached
            
            -- If both are already maxed, no need to continue
            if max_Upgrades_Reached then
                AutoBuy_Toggle = false
                return
            end
            
            while AutoBuy_Toggle do
                local freshData = LocalDataService:Get()
                
                -- Update max status flags with fresh data
                if freshData.Flavors and freshData.Flavors[max_flavor_item] then
                    max_Flavor_Reached = true
                end
                
                if freshData.Gum and freshData.Gum[max_gum_item] then
                    max_Gum_Reached = true
                end
                
                max_Upgrades_Reached = max_Flavor_Reached and max_Gum_Reached
                
                -- Check if all items are already purchased
                if max_Upgrades_Reached then
                    AutoBuy_Toggle = false
                    break
                end
                
                -- Sort flavors by price (lowest first) if we haven't reached max flavor
                if not max_Flavor_Reached then
                    local flavors_To_Buy = {}
                    
                    for flavorName, config in pairs(flavorsConfig) do
                        if not freshData.Flavors[flavorName] then
                            table.insert(flavors_To_Buy, {name = flavorName, config = config})
                        end
                    end
                    
                    table.sort(flavors_To_Buy, function(a, b)
                        if a.config.currency == b.config.currency then
                            return a.config.price < b.config.price
                        else
                            return a.config.currency == "Coins" -- Prioritize coins purchases
                        end
                    end)
                    
                    -- Try to buy flavors in order of price
                    for _, flavorInfo in ipairs(flavors_To_Buy) do
                        local flavorName = flavorInfo.name
                        local config = flavorInfo.config
                        
                        local can_Afford = false
                        if config.currency == "Coins" and GetCurrentCoins() >= config.price then
                            can_Afford = true
                        elseif config.currency == "Gems" and GetCurrentGems() >= config.price then
                            can_Afford = true
                        end
                        
                        if can_Afford then
                            -- Attempt to buy the flavor using correct remote
                            Remote.Event:FireServer("GumShopPurchase", flavorName)
                            
                            -- Wait a moment for purchase to process
                            task.wait(0.3)
                            
                            -- Refresh data to check if purchase was successful
                            freshData = LocalDataService:Get()
                            
                            -- Check if we've reached max flavor
                            if freshData.Flavors and freshData.Flavors[max_flavor_item] then
                                max_Flavor_Reached = true
                            end
                            
                            -- Small delay between purchases
                            task.wait(0.5)
                        end
                    end
                end
                
                -- Sort gums by price (lowest first) if we haven't reached max gum
                if not max_Gum_Reached then
                    local gums_To_Buy = {}
                    freshData = LocalDataService:Get() -- Refresh data again
                    
                    for gumName, config in pairs(gumConfig) do
                        if not freshData.Gum[gumName] then
                            table.insert(gums_To_Buy, {name = gumName, config = config})
                        end
                    end
                    
                    table.sort(gums_To_Buy, function(a, b)
                        if a.config.currency == b.config.currency then
                            return a.config.price < b.config.price
                        else
                            return a.config.currency == "Coins" -- Prioritize coins purchases
                        end
                    end)
                    
                    -- Try to buy gums in order of price
                    for _, gumInfo in ipairs(gums_To_Buy) do
                        local gumName = gumInfo.name
                        local config = gumInfo.config
                        
                        local can_Afford = false
                        if config.currency == "Coins" and GetCurrentCoins() >= config.price then
                            can_Afford = true
                        elseif config.currency == "Gems" and GetCurrentGems() >= config.price then
                            can_Afford = true
                        end
                        
                        if can_Afford then
                            -- Attempt to buy the gum using correct remote
                            Remote.Event:FireServer("GumShopPurchase", gumName)
                            
                            -- Wait a moment for purchase to process
                            task.wait(0.3)
                            
                            -- Refresh data to check if purchase was successful
                            freshData = LocalDataService:Get()
                            
                            -- Check if we've reached max gum
                            if freshData.Gum and freshData.Gum[max_gum_item] then
                                max_Gum_Reached = true
                            end
                            
                            -- Small delay between purchases
                            task.wait(0.5)
                        end
                    end
                end
                
                -- Update combined flag
                max_Upgrades_Reached = max_Flavor_Reached and max_Gum_Reached
                
                -- Wait before checking again
                task.wait(5)
            end
        end)
    end
    
    return AutoBuy_Toggle, max_Flavor_Reached, max_Gum_Reached, max_Upgrades_Reached
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Area Unlock Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local AreaUnlock_Toggle = false
local AreaThread = nil
local areasUnlocked = false

local function UnlockAreas()
    AreaUnlock_Toggle = not AreaUnlock_Toggle
    
    if AreaUnlock_Toggle then
        AreaThread = spawn(function()
            -- Get player and character
            local player = game:GetService("Players").LocalPlayer
            
            while AreaUnlock_Toggle do
                -- Check current unlocked status
                local freshData = LocalDataService:Get()
                local allAreasUnlocked = true
                local areasToTry = {}
                
                -- Check which areas still need to be unlocked
                for _, areaName in ipairs(AreaToUnlock) do
                    if type(freshData.AreasUnlocked) ~= "table" or not freshData.AreasUnlocked[areaName] then
                        allAreasUnlocked = false
                        table.insert(areasToTry, areaName)
                    end
                end
                
                -- If all areas are unlocked, turn off function and exit
                if allAreasUnlocked then
                    AreaUnlock_Toggle = false
                    areasUnlocked = true
                    break
                end
                
                -- Try to unlock each remaining area
                for _, areaName in ipairs(areasToTry) do
                    if not AreaUnlock_Toggle then break end
                    
                    -- Make sure character exists
                    local character = player.Character or player.CharacterAdded:Wait()
                    local humanoidRootPart = character:WaitForChild("HumanoidRootPart")
                    
                    -- Find the area in Worlds
                    local areaWithoutSpaces = areaName:gsub(" ", "")
                    local areaFolder = workspace.Worlds["The Overworld"].Islands:FindFirstChild(areaName) or 
                                     workspace.Worlds["The Overworld"].Islands:FindFirstChild(areaWithoutSpaces)
                    
                    if areaFolder then
                        -- Search for UnlockHitbox using GetDescendants
                        local unlockHitbox = nil
                        for _, descendant in ipairs(areaFolder:GetDescendants()) do
                            if descendant.Name == "UnlockHitbox" then
                                unlockHitbox = descendant
                                break
                            end
                        end
                        
                        if unlockHitbox then
                            -- Teleport to the UnlockHitbox
                            humanoidRootPart.CFrame = unlockHitbox.CFrame * CFrame.new(0, 15, 0)
                            
                            -- Wait a bit for the unlock to register
                            task.wait(0.1)
                            
                            -- Update data to check if area was unlocked
                            freshData = LocalDataService:Get()
                            
                            -- If area is now unlocked, we can move to the next one
                            if type(freshData.AreasUnlocked) == "table" and freshData.AreasUnlocked[areaName] then
                                -- Area successfully unlocked
                            end
                        end
                    end
                    
                    -- Wait between areas
                    task.wait(0.1)
                end
                
                -- Wait before checking again
                task.wait(0.5)
            end
        end)
    end
    
    return AreaUnlock_Toggle
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━ Auto Mystery Boxes Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local AutoMysteryBoxes_Toggle = false -- Flag to track if we're automatically using mystery boxes
local autoMysteryBoxesThread = nil -- Variable to store the auto mystery boxes thread

-- Function to check and use Mystery Boxes with toggle functionality
local function toggleAutoMysteryBoxes()
    AutoMysteryBoxes_Toggle = not AutoMysteryBoxes_Toggle
    
    if AutoMysteryBoxes_Toggle then
        -- Start a new thread for continuous Mystery Box usage
        autoMysteryBoxesThread = spawn(function()
            while AutoMysteryBoxes_Toggle do
                -- Use pcall to safely check data
                pcall(function()
                    -- Get fresh data directly from the LocalDataService
                    local freshData = LocalDataService:Get()
                    
                    -- Check if the player has Mystery Boxes in their Powerups
                    local mysteryBoxCount = freshData.Powerups and freshData.Powerups["Mystery Box"] or 0
                    
                    if mysteryBoxCount > 0 then
                        -- Use Mystery Box (10 at a time or all if less than 10)
                        local amountToUse = math.min(mysteryBoxCount, 10)
                        game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("UseGift", "Mystery Box", amountToUse)
                        task.wait(1)
                        
                        -- Check for gifts and claim them using the remote event
                        while true do
                            -- Check if Gifts folder exists and has children
                            local giftsFolder = workspace.Rendered:FindFirstChild("Gifts")
                            if not giftsFolder or #giftsFolder:GetChildren() == 0 then
                                break
                            end
                            
                            -- Process each gift in the folder
                            for _, gift in pairs(giftsFolder:GetChildren()) do
                                -- Get the gift's name/UUID
                                local giftId = gift.Name
                                
                                -- Claim the gift using the remote event
                                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("ClaimGift", giftId)

                                task.wait(1)
                                
                                -- Destroy the gift after claiming
                                gift:Destroy()
                                
                                -- Short wait to prevent overwhelming the server
                                task.wait(0.01)
                            end
                        end
                    end
                end)
                
                -- Wait before checking again (every 30 seconds)
                task.wait(30)
            end
        end)
    end
    
    return AutoMysteryBoxes_Toggle
end


-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Buy Shop Settings ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local isAutoBuyingShopItems = false
local autoBuyingShopItemsThread = nil

local function toggleAutoBuyShopItems()
    isAutoBuyingShopItems = not isAutoBuyingShopItems
    
    if isAutoBuyingShopItems then
        
        -- Start the auto buying thread
        autoBuyingShopItemsThread = spawn(function()
            while isAutoBuyingShopItems do
                -- Define shops and their items for efficient iteration
                local shops = {
                    ["alien-shop"] = {1, 2, 3},
                    ["shard-shop"] = {1, 2, 3}
                }
                
                -- Check if we have minimum gems before attempting purchases
                local currentGems = GetCurrentGems()
                if currentGems < Low_Gems then
                    task.wait(60) -- Wait a minute before checking again
                    continue
                end
                
                -- Process each shop
                for shopName, items in pairs(shops) do
                    -- Process each item ID in this shop
                    for _, itemId in ipairs(items) do
                        -- Verify we still have enough gems
                        if GetCurrentGems() >= Low_Gems then
                            game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
                                "BuyShopItem", 
                                shopName, 
                                itemId
                            )
                            task.wait(0.5) -- Wait between purchases
                        else
                            task.wait(30) -- If below threshold, wait and continue loop
                            break
                        end
                    end
                    
                    -- Check if toggle was turned off during purchases
                    if not isAutoBuyingShopItems then 
                        break 
                    end
                    
                    task.wait(0.5)
                end
                
                -- Wait between shop purchase cycles
                task.wait(60) -- Wait 1 minute between full cycles
            end
        end)
    else
        -- Kill the thread if it exists
        if autoBuyingShopItemsThread then
            task.cancel(autoBuyingShopItemsThread)
            autoBuyingShopItemsThread = nil
        end
    end
    
    return isAutoBuyingShopItems
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Delete Pets ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local isAutoDeletingPets = false
local autoDeletingPetsThread = nil

local function toggleAutoPetDeletion()
    isAutoDeletingPets = not isAutoDeletingPets
    
    if isAutoDeletingPets then
        -- Start a new thread for continuous pet deletion
        autoDeletingPetsThread = spawn(function()
            while isAutoDeletingPets do
                -- Use pcall for error handling
                pcall(function()
                    -- Get fresh data
                    local freshData = LocalDataService:Get()
                    
                    -- Create a lookup table for all pet IDs in teams
                    local petsInTeams = {}
                    for _, team in ipairs(freshData.Teams) do
                        for _, petId in ipairs(team.Pets) do
                            petsInTeams[petId] = true
                        end
                    end
                    
                    -- Track pets with shiny versions for auto-delete toggling later
                    local petsWithShinyVersions = {}
                    
                    -- Check which pets have shiny versions
                    for _, petName in ipairs(petsToDelete) do
                        local hasShiny = false
                        for _, pet in ipairs(freshData.Pets) do
                            if pet.Name == petName and pet.Shiny then
                                hasShiny = true
                                break
                            end
                        end
                        
                        if hasShiny then
                            petsWithShinyVersions[petName] = true
                        end
                    end
                    
                    -- Check and track all pets by name, separating normal and shiny
                    local petsByName = {}
                    
                    -- First pass: organize pets by name to determine counts and find shiny versions
                    for _, pet in ipairs(freshData.Pets) do
                        -- Skip pets that are in teams or locked
                        if petsInTeams[pet.Id] or pet.Locked then
                            continue
                        end
                        
                        -- Check if this pet is in our deletion list
                        local shouldTrack = false
                        for _, petName in ipairs(petsToDelete) do
                            if pet.Name == petName then
                                shouldTrack = true
                                break
                            end
                        end
                        
                        if shouldTrack then
                            -- Initialize the pet tracking if not exists
                            if not petsByName[pet.Name] then
                                petsByName[pet.Name] = {
                                    normal = {
                                        pets = {},
                                        count = 0
                                    },
                                    shiny = {
                                        exists = false,
                                        pets = {},
                                        count = 0
                                    }
                                }
                            end
                            
                            -- Add to appropriate category
                            if pet.Shiny then
                                petsByName[pet.Name].shiny.exists = true
                                table.insert(petsByName[pet.Name].shiny.pets, pet)
                                petsByName[pet.Name].shiny.count = petsByName[pet.Name].shiny.count + (pet.Amount or 1)
                            else
                                table.insert(petsByName[pet.Name].normal.pets, pet)
                                petsByName[pet.Name].normal.count = petsByName[pet.Name].normal.count + (pet.Amount or 1)
                            end
                        end
                    end
                    
                    -- Process each pet name to check for shiny crafting opportunity
                    for petName, data in pairs(petsByName) do
                        -- Check if we need to make a shiny (no shiny exists and we have 16+ normal pets)
                        if not data.shiny.exists and data.normal.count >= 16 then
                            -- Find best candidate for shiny crafting (preferably a stacked pet)
                            local bestCandidate = nil
                            
                            -- First try to find a stacked pet with at least 16
                            for _, pet in ipairs(data.normal.pets) do
                                if pet.Amount and pet.Amount >= 16 then
                                    bestCandidate = pet
                                    break
                                end
                            end
                            
                            -- If no stacked pet has 16+, we'll need to use the first pet we find
                            if not bestCandidate and #data.normal.pets > 0 then
                                bestCandidate = data.normal.pets[1]
                            end
                            
                            -- Execute the shiny crafting if we have a candidate
                            if bestCandidate then
                                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
                                    "MakePetShiny", 
                                    bestCandidate.Id
                                )
                                
                                -- Wait for the operation to complete
                                task.wait(1)
                                
                                -- Refresh data after crafting a shiny
                                freshData = LocalDataService:Get()
                                
                                -- Update our tracking of pets with shiny versions
                                petsWithShinyVersions[petName] = true
                                
                                -- Recreate teams lookup after refresh
                                petsInTeams = {}
                                for _, team in ipairs(freshData.Teams) do
                                    for _, petId in ipairs(team.Pets) do
                                        petsInTeams[petId] = true
                                    end
                                end
                            end
                        end
                    end
                    
                    -- Now reorganize for deletion processing with updated data
                    local petsByNameAndType = {}
                    
                    for _, pet in ipairs(freshData.Pets) do
                        -- Skip pets that are in any team
                        if petsInTeams[pet.Id] then
                            continue
                        end
                        
                        -- Skip locked pets
                        if pet.Locked then
                            continue
                        end
                        
                        -- Check if this pet is in our deletion list
                        local shouldTrack = false
                        for _, petName in ipairs(petsToDelete) do
                            if pet.Name == petName then
                                shouldTrack = true
                                break
                            end
                        end
                        
                        -- Check if we should skip deletion for normal pets where no shiny exists yet
                        if shouldTrack and not pet.Shiny then
                            -- Check if we have a shiny version in the data
                            local shinyExists = petsWithShinyVersions[pet.Name] or false
                            if not shinyExists then
                                -- Re-check in fresh data
                                for _, checkPet in ipairs(freshData.Pets) do
                                    if checkPet.Name == pet.Name and checkPet.Shiny then
                                        shinyExists = true
                                        petsWithShinyVersions[pet.Name] = true
                                        break
                                    end
                                end
                            end
                            
                            -- If no shiny exists yet, we need 16+ pets to make a shiny, so don't delete
                            if not shinyExists then
                                -- Count how many we have of this pet
                                local totalCount = 0
                                for _, countPet in ipairs(freshData.Pets) do
                                    if countPet.Name == pet.Name and not countPet.Shiny and not petsInTeams[countPet.Id] and not countPet.Locked then
                                        totalCount = totalCount + (countPet.Amount or 1)
                                    end
                                end
                                
                                -- Only delete if we have more than 16 of this pet
                                if totalCount <= 16 then
                                    shouldTrack = false
                                end
                            end
                        end
                        
                        -- Only track pets in our deletion list
                        if shouldTrack then
                            -- Create a key that combines name and shiny status
                            local petKey = pet.Name .. (pet.Shiny and "_shiny" or "_normal")
                            
                            if not petsByNameAndType[petKey] then
                                petsByNameAndType[petKey] = {
                                    xpPets = {},
                                    stackedPets = {},
                                    totalCount = 0,
                                    isShiny = pet.Shiny,
                                    name = pet.Name
                                }
                            end
                            
                            -- Check if it's a stacked pet (has Amount) or individual XP pet
                            if pet.Amount then
                                table.insert(petsByNameAndType[petKey].stackedPets, pet)
                                petsByNameAndType[petKey].totalCount = petsByNameAndType[petKey].totalCount + pet.Amount
                            else
                                table.insert(petsByNameAndType[petKey].xpPets, pet)
                                petsByNameAndType[petKey].totalCount = petsByNameAndType[petKey].totalCount + 1
                            end
                        end
                    end
                    
                    -- Process each pet type for deletion
                    for petKey, petData in pairs(petsByNameAndType) do
                        -- Use appropriate threshold based on shiny status
                        local threshold = petData.isShiny and shinyKeepThreshold or petKeepThreshold
                        local totalToDelete = petData.totalCount - threshold
                        
                        -- Only proceed if we need to delete pets
                        if totalToDelete > 0 then
                            -- First delete individual XP pets (prioritize these)
                            local refreshNeeded = false
                            
                            for i, xpPet in ipairs(petData.xpPets) do
                                if totalToDelete > 0 then
                                    -- Double check that this pet is not in a team
                                    if not petsInTeams[xpPet.Id] then
                                        -- Delete this individual pet
                                        game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
                                            "DeletePet", 
                                            xpPet.Id,
                                            1, 
                                            false
                                        )
                                        
                                        totalToDelete = totalToDelete - 1
                                        task.wait(0.3) -- Wait for deletion to process
                                        refreshNeeded = true
                                        
                                        -- Refresh data after each 3 deletions to avoid too many refreshes
                                        if i % 3 == 0 or totalToDelete <= 0 then
                                            -- Refresh data and team info
                                            freshData = LocalDataService:Get()
                                            petsInTeams = {}
                                            for _, team in ipairs(freshData.Teams) do
                                                for _, petId in ipairs(team.Pets) do
                                                    petsInTeams[petId] = true
                                                end
                                            end
                                            refreshNeeded = false
                                        end
                                    end
                                else
                                    break
                                end
                            end
                            
                            -- Refresh data if needed before handling stacked pets
                            if refreshNeeded then
                                freshData = LocalDataService:Get()
                                petsInTeams = {}
                                for _, team in ipairs(freshData.Teams) do
                                    for _, petId in ipairs(team.Pets) do
                                        petsInTeams[petId] = true
                                    end
                                end
                            end
                            
                            -- Recalculate remaining pets to delete after refreshing data
                            if totalToDelete > 0 then
                                -- Find all stacked pets again with fresh data
                                local stackedPets = {}
                                for _, pet in ipairs(freshData.Pets) do
                                    -- Match both name and shiny status, make sure not in team
                                    local isRightType = pet.Name == petData.name and (pet.Shiny == petData.isShiny)
                                    if isRightType and pet.Amount and not petsInTeams[pet.Id] and not pet.Locked then
                                        table.insert(stackedPets, pet)
                                    end
                                end
                                
                                -- Then handle stacked pets if we still need to delete more
                                for i, stackedPet in ipairs(stackedPets) do
                                    if totalToDelete > 0 then
                                        -- Calculate how many to delete from this stack
                                        local amountToDelete = math.min(stackedPet.Amount, totalToDelete)
                                        
                                        -- Delete from this stacked pet
                                        game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
                                            "DeletePet", 
                                            stackedPet.Id,
                                            amountToDelete, 
                                            false
                                        )
                                        
                                        totalToDelete = totalToDelete - amountToDelete
                                        task.wait(0.3) -- Wait for deletion to process
                                        
                                        -- Refresh data after each deletion of stacked pets
                                        if i % 2 == 0 or totalToDelete <= 0 then
                                            freshData = LocalDataService:Get()
                                            petsInTeams = {}
                                            for _, team in ipairs(freshData.Teams) do
                                                for _, petId in ipairs(team.Pets) do
                                                    petsInTeams[petId] = true
                                                end
                                            end
                                        end
                                    else
                                        break
                                    end
                                end
                            end
                        end
                    end
                    
                    -- After deletion, check which pets should be toggled for auto-delete
                    freshData = LocalDataService:Get() -- Get fresh data again
                    
                    -- Enable auto-delete for pets where we have a shiny version
                    for petName in pairs(petsWithShinyVersions) do
                        -- Check if this pet is already set for auto-deletion
                        local isAlreadyAutoDelete = freshData.AutoDelete and freshData.AutoDelete[petName]
                        
                        -- If not set for auto-delete yet, toggle it
                        if not isAlreadyAutoDelete then
                            game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
                                "ToggleAutoDelete", 
                                petName
                            )
                            task.wait(0.2) -- Small wait between toggles
                        end
                    end
                end)
                
                -- Wait before checking again
                task.wait(30) -- Check every 30 seconds
            end
        end)
    end
    
    return isAutoDeletingPets
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Craft Potion Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local isAutoCraftingPotions = false
local autoCraftingPotionsThread = nil

local function toggleAutoCraftPotions()
    isAutoCraftingPotions = not isAutoCraftingPotions
    
    if isAutoCraftingPotions then
        autoCraftingPotionsThread = spawn(function()
            while isAutoCraftingPotions do
                -- Check gem threshold first
                local currentGems = GetCurrentGems()
                
                -- Only proceed if we have enough gems
                if currentGems >= Low_Gems then
                    local madeCraft = false
                    local data = LocalDataService:Get()
                    
                    -- Check from lowest to highest tier
                    for tier = 2, 5 do
                        for _, potionType in ipairs(potionTypes) do
                            -- Find source potion in inventory
                            local sourceTier = tier - 1
                            local required = craftingRequirements[tier]
                            local available = 0
                            
                            for _, potion in ipairs(data.Potions or {}) do
                                if potion.Name == potionType and potion.Level == sourceTier then
                                    available = potion.Amount or 0
                                    break
                                end
                            end
                            
                            -- Craft if possible and check gems again before each craft
                            if available >= required and GetCurrentGems() >= Low_Gems then
                                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
                                    "CraftPotion", potionType, tier, true)
                                madeCraft = true
                                task.wait(0.3)
                                data = LocalDataService:Get() -- Refresh data
                            end
                        end
                    end
                    
                    -- Wait based on crafting activity
                    task.wait(madeCraft and 0.5 or 10)
                else
                    -- If not enough gems, wait longer before checking again
                    task.wait(15)
                end
            end
        end)
    end
    
    return isAutoCraftingPotions
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Use Potion Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local function isPotionActive(potionType)
    -- Get fresh data every time we check
    local freshData = LocalDataService:Get()
    
    -- Check if ActivePotions exists and has the specific potion
    if freshData.ActivePotions and 
       type(freshData.ActivePotions) == "table" and
       freshData.ActivePotions[potionType] and 
       freshData.ActivePotions[potionType].Active then
        return true
    end
    
    return false
end

-- Function to get the highest level potion of a specific type from inventory
local function getHighestLevelPotion(potionType)
    -- Get fresh data every time we check inventory
    local freshData = LocalDataService:Get()
    local highestLevel = 0
    local highestLevelPotion = nil
    
    -- Check if we have potions in inventory
    if freshData.Potions and #freshData.Potions > 0 then
        for _, potion in ipairs(freshData.Potions) do
            -- Check if this potion matches the exact type we're looking for
            if potion.Name == potionType and potion.Amount > 0 then
                -- If this potion has a higher level than our current highest, update
                if potion.Level > highestLevel then
                    highestLevel = potion.Level
                    highestLevelPotion = potion
                end
            end
        end
    end
    
    return highestLevelPotion
end

-- Function to use a potion
local function usePotion(potionName, potionLevel)
    -- Use the potion
    game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
        "UsePotion", 
        potionName, 
        potionLevel
    )
    
    -- Wait briefly for data to update
    task.wait(0.3)
    
    -- Return true to indicate success
    return true
end

-- Function to toggle auto potion usage
local function toggleAutoUsePotion()
    isAutoUsingPotions = not isAutoUsingPotions
    
    if isAutoUsingPotions then
        -- Start a new thread for continuous potion checking
        autoUsingPotionsThread = spawn(function()
            while isAutoUsingPotions do
                -- Only process potions if auto hatching is enabled AND not temporarily disabled
                if isAutoHatching and not tempDisableHatching then
                    -- First handle regular priority potions
                    for _, potionType in ipairs(priorityPotions) do
                        -- Check with fresh data if potion is active
                        if not isPotionActive(potionType) then
                            -- Get highest level potion with fresh data
                            local bestPotion = getHighestLevelPotion(potionType)
                            
                            -- If we found a potion, use it
                            if bestPotion then
                                usePotion(bestPotion.Name, bestPotion.Level)
                                -- Wait a bit between using different potions
                                task.wait(1)
                            end
                        end
                    end
                    
                    -- Check for Infinity Elixir only when hatching x25 egg
                    if isHatchingX25Egg and not isPotionActive("Infinity Elixir") then
                        local infinityPotion = getHighestLevelPotion("Infinity Elixir")
                        if infinityPotion then
                            usePotion(infinityPotion.Name, infinityPotion.Level)
                            task.wait(1)
                        end
                    end
                end
                
                -- Wait before checking again
                task.wait(3) -- Check potions every 3 seconds
            end
        end)
    end
    
    return isAutoUsingPotions
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━ Auto Collection Buffs Function ━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- Function to check and use buffs during coin collection
local function useCollectionBuffs()
    -- Get fresh data
    local freshData = LocalDataService:Get()
    
    -- Check if Coins potion is active
    local hasCoinsPotion = false
    if freshData.ActivePotions and type(freshData.ActivePotions) == "table" then
        if freshData.ActivePotions["Coins"] and freshData.ActivePotions["Coins"].Active then
            hasCoinsPotion = true
        end
    end
    
    -- Check if GoldRush buff is active
    local hasGoldRush = false
    if freshData.ActiveBuffs and type(freshData.ActiveBuffs) == "table" then
        for _, buff in ipairs(freshData.ActiveBuffs) do
            if buff.Name == "GoldRush" then
                hasGoldRush = true
                break
            end
        end
    end
    
    -- Use Coins potion if not active and we have one
    if not hasCoinsPotion then
        local coinsPotion = getHighestLevelPotion("Coins")
        if coinsPotion then
            usePotion(coinsPotion.Name, coinsPotion.Level)
            task.wait(0.5)
        end
    end
    
    -- Use Golden Orb if GoldRush not active and we have some
    if not hasGoldRush and freshData.Powerups and freshData.Powerups["Golden Orb"] and freshData.Powerups["Golden Orb"] > 0 then
        game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("UseGoldenOrb")
        task.wait(0.5)
    end
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Collect Pickup ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local function toggleAutoCollectPickups()
    isAutoCollectingPickups = not isAutoCollectingPickups
    
    if isAutoCollectingPickups then
        -- Start a new thread for continuous pickup collection
        autoCollectingPickupsThread = spawn(function()
            while isAutoCollectingPickups do
                -- Use pcall for error handling
                pcall(function()
                    -- First, check and use collection buffs
                    useCollectionBuffs()
                    
                    local player = game:GetService("Players").LocalPlayer
                    local character = player.Character
                    if character then
                        local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")
                        if humanoidRootPart then
                            local isInZen = math.abs(humanoidRootPart.Position.Y - 15975) < 30
                            
                            -- Only collect if in Zen Island
                            if isInZen then
                                -- Loop through all Chunker folders in Rendered
                                for _, chunkerFolder in pairs(workspace.Rendered:GetChildren()) do
                                    if chunkerFolder.Name == "Chunker" and chunkerFolder:IsA("Folder") then
                                        -- Loop through each UUID object 
                                        for _, uuidObject in pairs(chunkerFolder:GetChildren()) do
                                            -- Check if it's a UUID-like name (contains hyphens)
                                            if typeof(uuidObject) == "Instance" and uuidObject.Name:match("%-") then
                                                -- This UUID object is the pickup itself
                                                local pickupId = uuidObject.Name
                                                game:GetService("ReplicatedStorage").Remotes.Pickups.CollectPickup:FireServer(pickupId)
                                                task.wait(0.05)
                                                uuidObject:Destroy()
                                                task.wait(0.05)
                                            end
                                        end
                                    end
                                end
                            else
                                -- Not in Zen, teleport there
                                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("Teleport", "Workspace.Worlds.The Overworld.Islands.Zen.Island.Portal.Spawn")
                                task.wait(5) -- Wait for teleport to complete
                            end
                        end
                    end
                end)
                
                -- Wait before checking again
                task.wait(1)
            end
        end)
    end
    
    return isAutoCollectingPickups
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Egg Counter Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local function toggleEggCounter()
    isEggCounterEnabled = not isEggCounterEnabled
    
    if isEggCounterEnabled then
        -- Create GUI if not exists
        if not EggCounterGui then

            EggCounterGui = Instance.new("ScreenGui")
            EggCounterGui.Name = "EggCounterGui"
            EggCounterGui.ResetOnSpawn = false
            EggCounterGui.IgnoreGuiInset = true
            EggCounterGui.DisplayOrder = 98 
            
            -- Create fully black background covering the entire screen
            local frame = Instance.new("Frame")
            frame.Size = UDim2.new(1, 0, 1, 0)  -- Full screen size
            frame.Position = UDim2.new(0, 0, 0, 0)  -- Starting from top-left corner
            frame.BackgroundColor3 = Color3.fromRGB(0, 0, 0) -- Black
            frame.BackgroundTransparency = 0 -- Black Transparancy
            frame.BorderSizePixel = 0
            frame.Name = "Frame"
            frame.Parent = EggCounterGui
            
            -- Title label
            local titleLabel = Instance.new("TextLabel")
            titleLabel.Size = UDim2.new(1, 0, 0, 50)
            titleLabel.Position = UDim2.new(0, 0, 0.23, 0)  -- Moved up to 30% down
            titleLabel.BackgroundTransparency = 1
            titleLabel.Font = Enum.Font.SourceSansBold
            titleLabel.TextSize = 135  -- Larger text size
            titleLabel.TextColor3 = Color3.fromRGB(255, 0, 0) -- Red text initially
            titleLabel.Text = "Hatching Off"
            titleLabel.TextStrokeTransparency = 0
            titleLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
            titleLabel.Name = "TitleLabel"
            titleLabel.Parent = frame
            
            -- Egg counter label
            local counterLabel = Instance.new("TextLabel")
            counterLabel.Size = UDim2.new(1, 0, 0, 50)
            counterLabel.Position = UDim2.new(0, 0, 0.37, 0)  -- Moved up to 40% down
            counterLabel.BackgroundTransparency = 1
            counterLabel.Font = Enum.Font.SourceSansBold
            counterLabel.TextSize = 125
            counterLabel.TextColor3 = Color3.fromRGB(255, 255, 255)
            counterLabel.Text = ""
            counterLabel.TextWrapped = true
            counterLabel.TextXAlignment = Enum.TextXAlignment.Center
            counterLabel.TextStrokeTransparency = 0
            counterLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
            counterLabel.Name = "CounterLabel"
            counterLabel.Parent = frame
            
            -- Coins counter label
            local coinsLabel = Instance.new("TextLabel")
            coinsLabel.Size = UDim2.new(1, 0, 0, 50)
            coinsLabel.Position = UDim2.new(0, 0, 0.52, 0)  -- At 50% down
            coinsLabel.BackgroundTransparency = 1
            coinsLabel.Font = Enum.Font.SourceSansBold
            coinsLabel.TextSize = 125
            coinsLabel.TextColor3 = Color3.fromRGB(255, 215, 0)  -- Gold color for coins
            coinsLabel.Text = "Coins: 0"
            coinsLabel.TextWrapped = true
            coinsLabel.TextXAlignment = Enum.TextXAlignment.Center
            coinsLabel.TextStrokeTransparency = 0
            coinsLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
            coinsLabel.Name = "CoinsLabel"
            coinsLabel.Parent = frame
            
            -- Gems counter label
            local gemsLabel = Instance.new("TextLabel")
            gemsLabel.Size = UDim2.new(1, 0, 0, 50)
            gemsLabel.Position = UDim2.new(0, 0, 0.65, 0)  -- At 60% down
            gemsLabel.BackgroundTransparency = 1
            gemsLabel.Font = Enum.Font.SourceSansBold
            gemsLabel.TextSize = 125
            gemsLabel.TextColor3 = Color3.fromRGB(170, 0, 255)  -- Purple color for gems
            gemsLabel.Text = "Gems: 0"
            gemsLabel.TextWrapped = true
            gemsLabel.TextXAlignment = Enum.TextXAlignment.Center
            gemsLabel.TextStrokeTransparency = 0
            gemsLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)
            gemsLabel.Name = "GemsLabel"
            gemsLabel.Parent = frame
            
            EggCounterGui.Parent = game:GetService("CoreGui")
        else
            EggCounterGui.Enabled = true
        end
        
        -- Start updating the counter in a loop
        spawn(function()
            while isEggCounterEnabled and EggCounterGui do
                local playerData = LocalDataService:Get()
                local titleLabel = EggCounterGui.Frame.TitleLabel
                local counterLabel = EggCounterGui.Frame.CounterLabel
                local coinsLabel = EggCounterGui.Frame.CoinsLabel
                local gemsLabel = EggCounterGui.Frame.GemsLabel
                
                -- Update coins and gems regardless of hatching state
                if playerData then
                    -- Update coins (using your existing GetCurrentCoins function)
                    local currentCoins = GetCurrentCoins()
                    coinsLabel.Text = "Coins: " .. FormatNumberCompact(currentCoins)
                    
                    -- Update gems
                    local currentGems = playerData.Gems or 0
                    gemsLabel.Text = "Gems: " .. FormatNumberCompact(currentGems)
                end
                
                if CurrentlyHatchingEgg and playerData and playerData.EggsOpened then
                    local eggCount = playerData.EggsOpened[CurrentlyHatchingEgg] or 0
                    titleLabel.Text = "Currently Hatching"
                    titleLabel.TextColor3 = Color3.fromRGB(0, 255, 0) -- Green
                    counterLabel.Text = CurrentlyHatchingEgg .. " : " .. tostring(eggCount)
                else
                    titleLabel.Text = "Hatching Off"
                    titleLabel.TextColor3 = Color3.fromRGB(255, 0, 0) -- Red
                    counterLabel.Text = ""
                end
                
                task.wait(1)
                
                -- Break the loop if toggle is turned off
                if not isEggCounterEnabled then break end
            end
        end)
    else
        -- Hide the GUI when toggled off
        if EggCounterGui then
            EggCounterGui.Enabled = false
        end
    end
    
    return isEggCounterEnabled
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Hatch Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

-- Function to extract luck multiplier from text (e.g. "x5", "x10")
local function getLuckMultiplier(luckText)
    if not luckText then return 0 end
    
    -- Extract number after 'x'
    local multiplier = luckText:match("x(%d+)")
    if multiplier then
        return tonumber(multiplier) or 0
    end
    return 0
end

-- Inside findBestEgg function
local function findBestEgg()
    local rifts = workspace.Rendered:FindFirstChild("Rifts")
    if not rifts then return nil end
    
    -- Store all available eggs with their priority and luck multiplier
    local availableEggs = {}
    
    -- Check all eggs and get their priority and luck info
    for _, eggId in ipairs(eggPriority) do
        local egg = rifts:FindFirstChild(eggId)
        if egg then
            local display = egg:FindFirstChild("Display")
            if display then
                -- Find the luck text if it exists
                local luckMultiplier = 0
                for _, descendant in ipairs(egg:GetDescendants()) do
                    if descendant.Name == "Luck" and descendant:IsA("TextLabel") and descendant.Text then
                        luckMultiplier = getLuckMultiplier(descendant.Text)
                        break
                    end
                end
                
                -- Store egg with priority index and luck multiplier
                table.insert(availableEggs, {
                    eggId = eggId,
                    eggName = eggMapping[eggId],
                    display = display,
                    priority = table.find(eggPriority, eggId) or #eggPriority + 1,
                    luckMultiplier = luckMultiplier
                })
            end
        end
    end
    
    -- Sort eggs by x25 first, then by priority, then by luck multiplier
    table.sort(availableEggs, function(a, b)
        -- Always prioritize x25 eggs over anything else
        if a.luckMultiplier == 25 and b.luckMultiplier ~= 25 then
            return true
        elseif a.luckMultiplier ~= 25 and b.luckMultiplier == 25 then
            return false
        -- If both are x25 or neither is x25, fall back to normal priority
        elseif a.priority == b.priority then
            -- Higher luck multiplier comes first
            return a.luckMultiplier > b.luckMultiplier
        end
        -- Lower priority index comes first (higher priority)
        return a.priority < b.priority
    end)
    
    -- Get the best egg
    local bestEgg = #availableEggs > 0 and availableEggs[1] or nil
    
    -- Set the flag for x25 egg if found
    isHatchingX25Egg = bestEgg and bestEgg.luckMultiplier == 25 or false
    
    -- Return the best egg or nil if none found
    return bestEgg
end

-- Function to check if we're near the egg
local function isNearEgg(eggDisplay)
    if not eggDisplay then return false end
    
    local player = game:GetService("Players").LocalPlayer
    local character = player.Character
    if not character then return false end
    
    local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")
    if not humanoidRootPart then return false end
    
    -- Check if we're within 10 studs of the egg
    local distance = (humanoidRootPart.Position - eggDisplay.Position).Magnitude
    return distance < 15
end

local function toggleAutoHatch()
    -- Only allow toggling on if mastery requirements are met
    if not isAutoHatching and not (PetsMasteryCompleted and BuffsMasteryCompleted) then
        -- Skip activation if mastery is not completed yet
        return false
    end
    
    isAutoHatching = not isAutoHatching
    
    if isAutoHatching then
        -- If auto potions not active yet, start it
        if not isAutoUsingPotions then
            toggleAutoUsePotion()
        end
        
        -- Start a new thread for continuous hatching
        autoHatchingThread = spawn(function()
            while isAutoHatching do
                -- Use pcall for error handling
                pcall(function()
                    -- Check coin levels
                    local currentCoins = GetCurrentCoins()
                    
                    -- If coins are below the low threshold, switch to pickup collection
                    if currentCoins < Low_Coins then
                        -- Enable pickup collection if not already collecting
                        if not isAutoCollectingPickups then
                            toggleAutoCollectPickups()
                            pickupCollectionStartedByHatcher = true
                            tempDisableHatching = true
                        end
                        task.wait(3) -- Wait before checking again
                        return
                    else
                        -- Only disable collection and resume hatching if we've reached the target (60% of max)
                        if currentCoins >= Max_Coins * 0.6 then
                            -- Re-enable hatching
                            tempDisableHatching = false
                            
                            -- Disable pickup collection if it was enabled by us
                            if isAutoCollectingPickups and pickupCollectionStartedByHatcher then
                                toggleAutoCollectPickups()
                                pickupCollectionStartedByHatcher = false
                            end
                        else
                            -- We're between Low_Coins and 60% target, keep collecting if already started
                            if isAutoCollectingPickups and pickupCollectionStartedByHatcher then
                                -- Continue collecting
                                task.wait(3)
                                return
                            else
                                -- No collection active, but we're between thresholds
                                -- Clear temp disable so we can hatch until low again
                                tempDisableHatching = false
                            end
                        end
                    end
                    
                    -- Only proceed with hatching if not temporarily disabled
                    if not tempDisableHatching then
                        -- Check if we're near Max_Coins - prioritize hatching
                        local shouldPrioritizeHatching = currentCoins >= Max_Coins * 0.95
                        
                        -- Find the best egg to hatch
                        local bestEgg = findBestEgg()
                        
                        -- If no eggs found, use Default_Egg
                        if not bestEgg then
                            -- Check if we're already near Default_Egg position by Y coordinate
                            local player = game:GetService("Players").LocalPlayer
                            local character = player.Character
                            if character then
                                local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")
                                if humanoidRootPart then
                                    local playerPos = humanoidRootPart.Position
                                    local defaultEggY = Default_Egg.Position.Y - 7  -- Account for the -7 offset
                                    
                                    -- Only tween if we're not already near Default_Egg
                                    if math.abs(playerPos.Y - defaultEggY) > 10 then
                                        -- Create adjusted CFrame below Default_Egg
                                        local adjustedCFrame = Default_Egg * CFrame.new(0, -7, 0)
                                        
                                        -- Use adjusted CFrame for tweening
                                        local horizTween, vertTween = TweenCharacterToTarget(adjustedCFrame)
                                        
                                        -- Wait for the tween to complete
                                        if horizTween and vertTween then
                                            horizTween.Completed:Wait()
                                            vertTween.Completed:Wait()
                                        else
                                            task.wait(0.5) -- Reduced wait time
                                        end
                                    end
                                end
                            end
                            
                            -- Try hatching at the default location
                            local hatchAmount = 8
                            CurrentlyHatchingEgg = "100M Egg"
                            game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
                                "HatchEgg", 
                                "100M Egg", -- Assuming a default egg name, adjust as needed
                                hatchAmount
                            )
                            
                            -- Press R key to skip egg opening
                            task.wait(0.05) -- Reduced wait time
                            VIM:SendKeyEvent(true, Enum.KeyCode.R, false, game)
                            task.wait(0.05) -- Reduced wait time
                            VIM:SendKeyEvent(false, Enum.KeyCode.R, false, game)
                            
                            task.wait(0.5) -- Reduced wait time
                        elseif currentCoins >= Low_Coins then
                            -- Use our tween function to move to the egg
                            local horizTween, vertTween = TweenCharacterToTarget(bestEgg.display)
                            
                            -- Wait for the tween to complete
                            if horizTween and vertTween then
                                horizTween.Completed:Wait()
                                vertTween.Completed:Wait()
                            else
                                task.wait(0.5) -- Reduced wait time
                            end
                            
                            -- Start hatching eggs (8 at a time)
                            local hatchAmount = 8
                            
                            -- Only try to hatch if we're near the egg
                            while GetCurrentCoins() >= Low_Coins do
                                -- Recheck for the best egg every time
                                local newBestEgg = findBestEgg()
                                
                                -- If no eggs available anymore, break out completely
                                if not newBestEgg then
                                    -- No eggs available at all, break and wait for next cycle
                                    break
                                elseif newBestEgg.eggId ~= bestEgg.eggId then
                                    -- A different (possibly better) egg is available - update and move to it
                                    bestEgg = newBestEgg
                                    
                                    -- Move to the new best egg
                                    local newHorizTween, newVertTween = TweenCharacterToTarget(bestEgg.display)
                                    if newHorizTween and newVertTween then
                                        newHorizTween.Completed:Wait()
                                        newVertTween.Completed:Wait()
                                    else
                                        task.wait(0.5) -- Reduced wait time
                                    end
                                end
                                
                                -- Make sure we're near the egg before hatching
                                if isNearEgg(bestEgg.display) then
                                    -- Hatch the egg
                                    CurrentlyHatchingEgg = bestEgg.eggName
                                    game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
                                        "HatchEgg", 
                                        bestEgg.eggName, 
                                        hatchAmount
                                    )
                                    
                                    -- Press R key to skip egg opening
                                    task.wait(0.05) -- Reduced wait time
                                    VIM:SendKeyEvent(true, Enum.KeyCode.R, false, game)
                                    task.wait(0.05) -- Reduced wait time
                                    VIM:SendKeyEvent(false, Enum.KeyCode.R, false, game)
                                    
                                    -- Wait a bit between hatches
                                    task.wait(0.5) -- Reduced wait time
                                    
                                    -- If coins go too low, break early
                                    if GetCurrentCoins() < Low_Coins * 1.1 then
                                        break
                                    end
                                else
                                    -- We've lost proximity to the egg, need to recheck
                                    break
                                end
                            end
                        end
                    end
                end)
                
                -- Wait before checking again
                task.wait(0.5) -- Reduced wait time for responsiveness
            end
        end)
    else
        -- If we're turning off auto hatching, also turn off auto potions
        if isAutoUsingPotions then
            toggleAutoUsePotion()
        end
        
        -- If we're turning off auto hatching, also turn off pickup collection if we started it
        if isAutoCollectingPickups and pickupCollectionStartedByHatcher then
            toggleAutoCollectPickups()
            pickupCollectionStartedByHatcher = false
        end
    end
    
    return isAutoHatching
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Auto Bubble & Sell Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local function Auto_Bubble_And_Sell()
    -- Only activate if we haven't met all the completion conditions
    if Auto_Bubble_And_Sell_Active or 
       (AllMasteryCompleted and max_Upgrades_Reached) or 
       isAutoHatching then
        -- If already running, everything complete, or hatching is active, turn off
        Auto_Bubble_And_Sell_Active = false
        return false
    end
    
    Auto_Bubble_And_Sell_Active = true
    
    -- Start a new thread for continuous bubble blowing and selling/collecting
    Auto_Bubble_And_Sell_Thread = spawn(function()
        while Auto_Bubble_And_Sell_Active do
            -- Always blow bubbles regardless of location
            game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("BlowBubble")
            
            -- Stop if auto hatching started or all tasks completed
            if isAutoHatching or (AllMasteryCompleted and max_Upgrades_Reached) then
                Auto_Bubble_And_Sell_Active = false
                break
            end
            
            -- First, always check and use buffs regardless of location
            pcall(function()
                -- Get fresh data
                local freshData = LocalDataService:Get()
                
                -- Check if Coins potion is active
                local hasCoinsPotion = false
                if freshData.ActivePotions and type(freshData.ActivePotions) == "table" then
                    if freshData.ActivePotions["Coins"] and freshData.ActivePotions["Coins"].Active then
                        hasCoinsPotion = true
                    end
                end
                
                -- Check if GoldRush buff is active
                local hasGoldRush = false
                if freshData.ActiveBuffs and type(freshData.ActiveBuffs) == "table" then
                    for _, buff in ipairs(freshData.ActiveBuffs) do
                        if buff.Name == "GoldRush" then
                            hasGoldRush = true
                            break
                        end
                    end
                end
                
                -- Use Coins potion if not active and we have one
                if not hasCoinsPotion then
                    local coinsPotion = getHighestLevelPotion("Coins")
                    if coinsPotion then
                        usePotion(coinsPotion.Name, coinsPotion.Level)
                        task.wait(0.5)
                    end
                end
                
                -- Use Golden Orb if GoldRush not active and we have some
                if not hasGoldRush and freshData.Powerups and freshData.Powerups["Golden Orb"] and freshData.Powerups["Golden Orb"] > 0 then
                    game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("UseGoldenOrb")
                    task.wait(0.5)
                end
            end)
            
            -- Decide mode: Zen pickup collection OR Twilight bubble selling
            if max_Flavor_Reached and 
               (not PetsMasteryCompleted or not BuffsMasteryCompleted or not ShopsMasteryCompleted) then
                -- PICKUP COLLECTION MODE: Switch to Zen pickup collection for gems
                if not isAutoCollectingPickups then
                    toggleAutoCollectPickups() -- This will handle teleporting to Zen
                    task.wait(3) -- Give time for teleport
                end
                
                -- Don't attempt to sell bubbles in this mode (we're in Zen)
            else
                -- BUBBLE SELLING MODE: Turn off pickup collection if active
                if isAutoCollectingPickups then
                    toggleAutoCollectPickups()
                    task.wait(1)
                end
                
                -- Only attempt selling bubbles when we're in selling mode
                pcall(function()
                    -- Get player and character
                    local player = game:GetService("Players").LocalPlayer
                    local character = player.Character
                    
                    if character then
                        local humanoidRootPart = character:FindFirstChild("HumanoidRootPart")
                        if humanoidRootPart then
                            local playerPos = humanoidRootPart.Position
                            
                            -- Check if player is NOT in Twilight area (Y position ~6862)
                            if math.abs(playerPos.Y - 6862) > 30 then
                                -- Player is not at the right location, teleport there
                                game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer(
                                    "Teleport", 
                                    "Workspace.Worlds.The Overworld.Islands.Twilight.Island.Portal.Spawn"
                                )
                                task.wait(2) -- Longer wait after teleport
                            else
                                -- Player is at the right Y level, tween to the sell area
                                local sellRoot = workspace.Worlds["The Overworld"].Islands.Twilight.Island.Sell.Root
                                if sellRoot then
                                    -- Check if already near the sell root
                                    local distance = (humanoidRootPart.Position - sellRoot.Position).Magnitude
                                    if distance > 10 then
                                        -- Tween to the sell area
                                        local horizontalTween, verticalTween = TweenCharacterToTarget(sellRoot)
                                        
                                        -- Wait for tweens to complete
                                        if horizontalTween then
                                            horizontalTween.Completed:Wait()
                                        end
                                        
                                        if verticalTween then
                                            verticalTween.Completed:Wait()
                                        end
                                        
                                        task.wait(0.5) -- Wait after tweening
                                    end
                                    
                                    -- Check bubble count after reaching sell area
                                    local GuiGum = player.PlayerGui.ScreenGui.HUD.Left.Currency.Bubble.Frame.Label.Text
                                    local current, max = extractNumbers(GuiGum)
                                    
                                    -- Sell bubbles if we have any
                                    if current and current > 1 then
                                        game:GetService("ReplicatedStorage").Shared.Framework.Network.Remote.Event:FireServer("SellBubble")
                                        task.wait(0.5) -- Wait after selling
                                    end
                                end
                            end
                        end
                    end
                end)
            end
            
            -- Check if all tasks completed
            if (AllMasteryCompleted and max_Upgrades_Reached) or isAutoHatching then
                Auto_Bubble_And_Sell_Active = false
                
                -- Turn off pickup collection if it's on
                if isAutoCollectingPickups then
                    toggleAutoCollectPickups()
                end
                
                break
            end
            
            -- Wait a small amount between cycles
            task.wait(0.3)
        end
    end)
    
    return Auto_Bubble_And_Sell_Active
end


-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━ Initialize Data Function ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

local function InitializePlayerData()
    -- Get fresh player data
    local freshData = LocalDataService:Get()
    
    -- Initialize all status flags based on current data
    if freshData then
        -- 1. Check flavor and gum upgrade status
        if freshData.Flavors then
            -- Get the highest price flavor to check if we've reached max flavor
            local max_flavor_item = get_Highest_Priced_Item(flavorsConfig)
            if freshData.Flavors[max_flavor_item] then
                max_Flavor_Reached = true
            else
                max_Flavor_Reached = false
            end
        else
            max_Flavor_Reached = false
        end
        
        if freshData.Gum then
            -- Get the highest price gum to check if we've reached max gum
            local max_gum_item = get_Highest_Priced_Item(gumConfig)
            if freshData.Gum[max_gum_item] then
                max_Gum_Reached = true
            else
                max_Gum_Reached = false
            end
        else
            max_Gum_Reached = false
        end
        
        max_Upgrades_Reached = max_Flavor_Reached and max_Gum_Reached
        
        -- 2. Check mastery completion status
        -- Function to check if mastery is completed based on available targets
        local function checkMasteryCompleted(masteryTargets)
            if not masteryTargets or #masteryTargets == 0 then
                return true -- No targets means mastery is completed
            end
            return false
        end
        
        -- Use FindAvailableAndMastery to update mastery targets
        FindAvailableAndMastery()
        
        -- Set completion flags based on target counts
        PetsMasteryCompleted = checkMasteryCompleted(Mastery_Pets_Targets)
        BuffsMasteryCompleted = checkMasteryCompleted(Mastery_Buffs_Targets)
        ShopsMasteryCompleted = checkMasteryCompleted(Mastery_Shops_Targets)
        
        -- Update combined mastery flag
        AllMasteryCompleted = PetsMasteryCompleted and BuffsMasteryCompleted and ShopsMasteryCompleted
        
        return true
    end
    
    return false
end

-- 🌀━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Main Loop ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━🌀

while true do
    -- Use pcall for the entire loop body to prevent script crashes
    local success, errorMsg = pcall(function()

        -- Handle intro once at the beginning
        if not hasHandledIntro then
            hasHandledIntro = handleIntro()
            if hasHandledIntro then
                -- Wait longer after handling the intro to ensure everything loads properly
                task.wait(5)
                InitializePlayerData()
                task.wait(10)
            end
        end

        -- First unlock areas and enable fly mode (basic setup)
        if not AreaUnlock_Toggle and not areasUnlocked then
            areasUnlocked = UnlockAreas()
        end

        if not isFlyModeActive then
            toggleFlyMode()
        end

        -- Check and update mastery progress
        if not isAutoMastery then
            FindAvailableAndMastery()
        end

        -- Bubble and sell OR hatch eggs based on mastery progress
        if PetsMasteryCompleted and BuffsMasteryCompleted then
            -- Mastery complete - focus on hatching
            if not isAutoHatching then
                toggleAutoHatch()
            elseif isAutoHatching and not isAutoUsingPotions then
                -- Make sure potions are enabled when hatching is active
                toggleAutoUsePotion()
            end
        else
            -- Mastery not complete - focus on bubble selling
            if not Auto_Bubble_And_Sell_Active and not isAutoHatching then
                Auto_Bubble_And_Sell()
            end
        end

        -- Always handle pet deletion
        if not isAutoDeletingPets then
            toggleAutoPetDeletion()
        end

        -- Check for daily rewards
        if not CheckRewards_Toggle and not hasClaimedDailyReward then
            hasClaimedDailyReward = checkDailyRewards()
        end

        -- Claim playtime rewards
        if not AutoClaimPlaytime_Toggle and not PlaytimeRewardsClaimed then
            toggleAutoClaimPlaytime()
        end

        -- Apply optimal settings
        if not SetSettings_Toggle and not settingsApplied then
            SetOptimalSettings()
        end

        -- Claim prizes
        if not AutoClaimPrizes_Toggle then
            toggleAutoClaimPrizes()
        end
        
        -- Buy items if not already running and not completed
        if not AutoBuy_Toggle and not max_Upgrades_Reached then
            AutoBuy_Toggle, max_Flavor_Reached, max_Gum_Reached, max_Upgrades_Reached = AutoBuyItems()
        end
        
        -- Hide overlays
        if not AutoHideOverlay_Toggle then
            toggleAutoHideOverlay()
        end
        
        -- Use mystery boxes
        if not AutoMysteryBoxes_Toggle then
            toggleAutoMysteryBoxes()
        end

        -- Spin wheel
        if not AutoWheelSpin_Toggle then
            toggleAutoWheelSpin()
        end

        -- Craft potions
        if not isAutoCraftingPotions then
            toggleAutoCraftPotions()
        end

        -- Only run reroll enchants if mastery requirements are met
        if not RerollEnchants_Toggle and (PetsMasteryCompleted and BuffsMasteryCompleted) then
            RerollEnchants()
        end

        if not isPressingB then
            togglePeriodicB()
        end    

        if not isAutoBuyingShopItems then
            toggleAutoBuyShopItems()
        end

        if not SecretPetCheck_Toggle then
            checkForSecretPets()
        end

        if not isEggCounterEnabled then
            toggleEggCounter()
        end

        -- Wait a bit to prevent the game from lagging
        task.wait(0.2)
    end)
    
    -- Handle any errors that occurred during execution
    if not success then
        print("ERROR IN MAIN LOOP: " .. tostring(errorMsg))
        -- Wait a bit before continuing to prevent error spam
        task.wait(2)
    end
    
    -- Always have a small wait to prevent infinite loops if the task.wait inside pcall fails
    task.wait(0.1)
end