dwea - Pastebin.com

-- SERVICES & MODULES

local Players = game:GetService("Players")

local CollectionService = game:GetService("CollectionService")

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local Remotes = require(ReplicatedStorage.Modules.Remotes)

local GetFarm = require(ReplicatedStorage.Modules.GetFarm)

local InventoryService = require(ReplicatedStorage.Modules.InventoryService)

local sellRemote = ReplicatedStorage

:WaitForChild("GameEvents")

:WaitForChild("Sell_Inventory")

local sell_One_Remote = ReplicatedStorage

:WaitForChild("GameEvents")

:WaitForChild("Sell_Item")

local CalculatePetValue = require(ReplicatedStorage.Modules:WaitForChild("CalculatePetValue"))

local CalculatePlantValue = require(ReplicatedStorage.Modules:WaitForChild("CalculatePlantValue"))

local MutationHandler = require(ReplicatedStorage.Modules:WaitForChild("MutationHandler"))

local ActivePetsService = require(ReplicatedStorage.Modules.PetServices.ActivePetsService)

local PetConfig = require(ReplicatedStorage.Data.PetRegistry.PetConfig)

-- PLAYER & FARM ROOT

local player = Players.LocalPlayer

local farmRoot = GetFarm(player)

local HttpService = game:GetService("HttpService")

local webhookUrl = "https://discord.com/api/webhooks/1371732167499186206/cAHDH567wnjAb7oncu7Hn5OsekL9GquwrFxarRJD-zz7jkFoM8y9qFslznQZhAX7HTT5" -- replace with your Discord webhook URL

local hasSpecialPlant = false

-- Add this variable near the other local variable declarations

local noMorePlantsToDelete = false

local isAutoToggleUIEnabled = false

local autoToggleUIThread = nil

local isAutoSellEnabled = false

local autoSellThread = nil

local isAutoSellOneByOneEnabled = false

local autoSellOneByOneThread = nil

local isAutoFeedEnabled = false

local autoFeedThread = nil

local isAutoSubmitHoneyEnabled = false

local autoSubmitHoneyThread = nil

local isAutoCollectEnabled = false

local autoCollectThread = nil

local MIN_WEIGHT_BY_VARIANT = {

["Normal"] = 50,

["Gold"] = 40,

["Rainbow"] = 30

}

local DoNotCollect_Variants = {

["Gold"] = false,

["Rainbow"] = false

}

local DoNotCollect_Mutations = {

["Shocked"] = false,

["Frozen"] = false,

["Wet"] = false,

["Chilled"] = false,

["Twisted"] = false,

["Choc"] = false,

["Burnt"] = false,

["Moonlit"] = false,

["Bloodlit"] = false,

["Celestial"] = false,

["Zombified"] = false,

["Pollinated"] = false,

["HoneyGlazed"] = false

}

local isAutoPlaceEggEnabled = false

local autoPlaceEggThread = nil

local eggIndex = {

["Common Egg"] = true,

["Uncommon Egg"] = true,

["Rare Egg"] = true,

["Legendary Egg"] = true,

["Mythical Egg"] = true,

["Bug Egg"] = true,

["Night Egg"] = true,

["Bee Egg"] = true

}

local isAutoBuyEggEnabled = false

local autoBuyEggThread = nil

local Buy_PetEggs = {

["Common Egg"] = true,

["Uncommon Egg"] = true,

["Rare Egg"] = true,

["Legendary Egg"] = true,

["Mythical Egg"] = true,

["Bug Egg"] = true,

["Night Egg"] = true,

["Bee Egg"] = true

-- Add/modify as needed

}

local Keep_Value = 2000000000 -- 2 billion

-- Add these tables for the Auto_Sell_Multiple function

local DoNotSell_Variants = {

["Gold"] = false,

["Rainbow"] = false

}

local DoNotSell_Mutations = {

["Shocked"] = false,

["Frozen"] = false,

["Wet"] = false,

["Chilled"] = false,

["Twisted"] = false,

["Choc"] = false,

["Burnt"] = false,

["Moonlit"] = false,

["Bloodlit"] = false,

["Celestial"] = false,

["Zombified"] = false,

["Pollinated"] = true,

["HoneyGlazed"] = false

}

local isAutoFavoriteEnabled = false

local autoFavoriteThread = nil

local Favorite_Variants = {

["Gold"] = false,

["Rainbow"] = false

}

local Favorite_Mutations = {

["Shocked"] = false,

["Frozen"] = false,

["Wet"] = false,

["Chilled"] = false,

["Twisted"] = false,

["Choc"] = false,

["Burnt"] = false,

["Moonlit"] = false,

["Bloodlit"] = false,

["Celestial"] = false,

["Zombified"] = false,

["Pollinated"] = false,

["HoneyGlazed"] = false

}

local isSpecialPetDetectorEnabled = true -- Default to enabled

local specialPetDetectorThread = nil

local petScreenGui = nil

local specialPetDetectorInitialized = false

local specialPetListToggle = {

["Dragonfly"] = true,

["Raccoon"] = true,

["Queen Bee"] = true,

["Red Fox"] = true

}

-- AUTO-SELL PET VARIABLES

local isAutoSellPetEnabled = false

local autoSellPetThread = nil

-- Maximum weight to sell (in KG)

local MAX_PET_KG = 5 -- Adjust this value to your preference

-- Pet selling configuration based on actual pets in the game

local Sell_Pets = {

-- Common Pets

["Dog"] = true,

["Golden Lab"] = true,

["Bunny"] = true,

["Black Bunny"] = true,

["Cat"] = true,

["Orange Tabby"] = true,

["Deer"] = true,

["Spotted Deer"] = true,

["Chicken"] = true,

["Rooster"] = true,

["Pig"] = true,

-- Uncommon/Rare Pets

["Monkey"] = true,

["Silver Monkey"] = true,

["Turtle"] = true,

["Cow"] = true,

["Hedgehog"] = true,

["Kiwi"] = false,

["Mole"] = true,

["Frog"] = true,

["Echo Frog"] = false,

["Bee"] = true,

-- Legendary/Mythical/Divine Pets

["Snail"] = true,

["Giant Ant"] = true,

["Red Giant Ant"] = true,

["Sea Otter"] = true,

["Caterpillar"] = true,

["Praying Mantis"] = false,

["Grey Mouse"] = true,

["Brown Mouse"] = true,

["Squirrel"] = true,

["Blood Hedgehog"] = false,

["Honey Bee"] = true,

["Petal Bee"] = false,

["Golden Bee"] = true,

["Bear Bee"] = false,

--Good Pet

["Moon Cat"] = true,

["Queen Bee"] = false,

["Owl"] = false,

["Night Owl"] = false,

["Blood Owl"] = false,

["Blood Kiwi"] = false,

["Polar Bear"] = false,

["Red Fox"] = false,

["Raccoon"] = false,

["Dragonfly"] = false,

--Un-Obtainable

["Chicken Zombie"] = false,

["Panda"] = false,

["Firefly"] = false,

["Red Dragon"] = false

}

local isAutoBuySeedEnabled = false

local autoBuySeedThread = nil

-- Add this table after your other settings tables

local Buy_Seeds = {

["Carrot"] = false,

["Strawberry"] = true,

["Blueberry"] = true,

["Orange Tulip"] = true,

["Tomato"] = true,

["Corn"] = true,

["Daffodil"] = true,

["Watermelon"] = true,

["Pumpkin"] = true,

["Apple"] = true,

["Bamboo"] = false,

["Coconut"] = true,

["Cactus"] = true,

["Dragon Fruit"] = true,

["Mango"] = true,

["Grape"] = true,

["Mushroom"] = true,

["Pepper"] = true,

["Cacao"] = true

-- Add more seeds as needed

}

local isAutoBuyGearEnabled = false

local autoBuyGearThread = nil

-- Add this table after your other settings tables

local Buy_GearShop = {

["Favorite Tool"] = false,

["Watering Can"] = true,

["Recall Wrench"] = false,

["Trowel"] = true,

["Basic Sprinkler"] = true,

["Advanced Sprinkler"] = true,

["Godly Sprinkler"] = true,

["Lightning Rod"] = true,

["Master Sprinkler"] = true

-- Set to false for items you don't want to buy

}

local isAutoBuyHoneyShopEnabled = false

local autoBuyHoneyShopThread = nil

-- Add this configuration table with the actual items from HoneyEventShopData

local Buy_HoneyShop = {

-- Seeds and Seed Packs

["Bee Egg"] = {buy = true, priority = 1},

["Flower Seed Pack"] = {buy = true, priority = 2},

["Honey Sprinkler"] = {buy = true, priority = 3},

-- Gameplay Items

["Nectarine"] = {buy = false, priority = 4}, -- This is "Nectarine Seed" in shop display

["Hive Fruit"] = {buy = false, priority = 5}, -- This is "Hive Fruit Seed" in shop display

["Bee Crate"] = {buy = false, priority = 6},

-- Cosmetic Items

["Honey Comb"] = {buy = false, priority = 7},

["Bee Chair"] = {buy = false, priority = 8},

["Honey Torch"] = {buy = false, priority = 9},

["Honey Walkway"] = {buy = false, priority = 10}

}

local isAutoBuyEventEnabled = false

local autoBuyEventThread = nil

-- Include ALL items from EventShopData.lua, regardless of DisplayInShop value

local Buy_EventShop = {

-- Regular items (DisplayInShop=true)

["Mysterious Crate"] = false,

["Night Egg"] = true,

["Night Seed Pack"] = true,

["Blood Banana"] = true,

["Moon Melon"] = true,

["Star Caller"] = true,

["Blood Hedgehog"] = false,

["Blood Kiwi"] = true,

["Blood Owl"] = false,

-- Hidden items (DisplayInShop=false, but still purchasable)

["Chocolate Carrot"] = true,

["Red Lollipop"] = true,

["Candy Sunflower"] = true,

["Easter Egg"] = true,

["Chocolate Sprinkler"] = true,

["Candy Blossom"] = true

}

-- AUTO-BUY TWILIGHT SHOP VARIABLES

local isAutoBuyTwilightEnabled = false

local autoBuyTwilightThread = nil

-- Items from NightEventShopData.lua

local Buy_TwilightShop = {

["Night Egg"] = true,

["Night Seed Pack"] = true,

["Twilight Crate"] = true,

["Star Caller"] = true,

["Moon Cat"] = true,

["Celestiberry"] = true, -- Celestiberry Seed

["Moon Mango"] = true -- Moon Mango Seed

}

-- Add these variables for Auto_Plant

local isAutoPlantEnabled = false

local autoPlantThread = nil

local Plant_Seeds = {

["Carrot"] = false,

["Strawberry"] = false,

["Blueberry"] = false,

["Orange Tulip"] = false,

["Tomato"] = false,

["Corn"] = false,

["Daffodil"] = false,

["Watermelon"] = false,

["Pumpkin"] = false,

["Apple"] = false,

["Bamboo"] = false,

["Coconut"] = true,

["Cactus"] = false,

["Dragon Fruit"] = true,

["Mango"] = true,

["Grape"] = true,

["Mushroom"] = true,

["Pepper"] = true,

["Cacao"] = true,

-- The following seeds might not be available in shop but included for completeness

["Pineapple"] = false,

["Raspberry"] = false,

["Peach"] = false,

["Papaya"] = false,

["Banana"] = false,

["Passionfruit"] = false,

["Soul Fruit"] = false,

["Cursed Fruit"] = false,

["Succulent"] = false,

["Cranberry"] = false,

["Durian"] = false,

["Eggplant"] = false,

["Lotus"] = false,

["Venus Fly Trap"] = false,

["Pear"] = false,

["Lemon"] = false,

["Cherry Blossom"] = false,

["Avocado"] = false,

["Nightshade"] = false,

["Glowshroom"] = false,

["Mint"] = false,

["Moonflower"] = false,

["Starfruit"] = false,

["Moonglow"] = false,

["Moon Blossom"] = false,

["Chocolate Carrot"] = false,

["Red Lollipop"] = false,

["Candy Sunflower"] = false,

["Easter Egg"] = false,

["Candy Blossom"] = false

}

local isAutoDeletePlantEnabled = false

local autoDeletePlantThread = nil

local Delete_Plants = {

["Carrot"] = true,

["Strawberry"] = true,

["Blueberry"] = true,

["Orange Tulip"] = true,

["Tomato"] = true,

["Corn"] = true,

["Daffodil"] = true,

["Watermelon"] = true,

["Pumpkin"] = true,

["Apple"] = true,

["Bamboo"] = true,

["Coconut"] = false,

["Cactus"] = true,

["Dragon Fruit"] = false,

["Mango"] = false,

["Grape"] = false,

["Mushroom"] = false,

["Pepper"] = false,

["Cacao"] = false,

-- The following seeds might not be available in shop but included for completeness

["Pineapple"] = true,

["Raspberry"] = true,

["Peach"] = true,

["Papaya"] = true,

["Banana"] = false,

["Passionfruit"] = true,

["Soul Fruit"] = false,

["Cursed Fruit"] = false,

["Succulent"] = false,

["Cranberry"] = false,

["Durian"] = false,

["Eggplant"] = false,

["Lotus"] = false,

["Venus Fly Trap"] = false,

["Pear"] = false,

["Lemon"] = false,

["Cherry Blossom"] = false,

["Avocado"] = false,

["Nightshade"] = false,

["Glowshroom"] = false,

["Mint"] = false,

["Moonflower"] = false,

["Starfruit"] = false,

["Moonglow"] = false,

["Moon Blossom"] = false,

["Chocolate Carrot"] = false,

["Red Lollipop"] = false,

["Candy Sunflower"] = false,

["Easter Egg"] = false,

["Candy Blossom"] = false

}

local playerGui = player:WaitForChild("PlayerGui")

local priceGui = Instance.new("ScreenGui")

priceGui.Name = "PriceCalculatorGui"

priceGui.ResetOnSpawn = false

priceGui.Parent = playerGui

local priceFrame = Instance.new("Frame")

priceFrame.Name = "PriceFrame"

priceFrame.Size = UDim2.new(0, 350, 0, 200)

priceFrame.AnchorPoint = Vector2.new(0.5, 0)

priceFrame.Position = UDim2.new(0.1,85, 0, 0.0,1, 0)

priceFrame.BackgroundColor3 = Color3.new(0, 0, 0)

priceFrame.BackgroundTransparency = 0.9

priceFrame.Parent = priceGui

local priceLabel = Instance.new("TextLabel")

priceLabel.Name = "PriceLabel"

priceLabel.Size = UDim2.new(1, -10, 1, -10)

priceLabel.Position = UDim2.new(0, 5, 0, 5)

priceLabel.BackgroundTransparency = 1

priceLabel.TextColor3 = Color3.new(1, 1, 1)

priceLabel.TextScaled = true

priceLabel.TextWrapped = true

priceLabel.Font = Enum.Font.SourceSansBold

priceLabel.Text = ""

priceLabel.Parent = priceFrame

local ignoreGear = {

["Watering Can"] = true,

["Recall Wrench"] = true,

["Trowel"] = true,

["Basic Sprinkler"] = true,

["Advanced Sprinkler"]= true,

["Godly Sprinkler"] = true,

["Lightning Rod"] = true,

["Master Sprinkler"] = true,

}

local function formatNumber(n)

local sign = (n < 0) and "-" or ""

local absn = math.abs(n)

local suffix = ""

if absn >= 1e12 then

n = n/1e12; suffix = "T"

elseif absn >= 1e9 then

n = n/1e9; suffix = "B"

elseif absn >= 1e6 then

n = n/1e6; suffix = "M"

end

local i = math.floor(math.abs(n))

local f = math.abs(n) - i

local frac = (f > 0) and ("%.2f"):format(f):sub(2) or ""

local s = tostring(i)

while true do

local count

s, count = s:gsub("^(-?%d+)(%d%d%d)", "%1,%2")

if count == 0 then break end

end

return sign .. s .. frac .. suffix

end

local function updatePrice(tool)

if not tool or not tool:IsA("Tool") then

priceLabel.Text = ""

return

end

local t = tool:GetAttribute("ItemType")

if t == "Seed" then

priceLabel.Text = ""

return

end

if ignoreGear[tool.Name] then

priceLabel.Text = ""

return

end

if t == "Pet" then

priceLabel.Text = "Pet Price: " .. formatNumber(CalculatePetValue(tool))

else

priceLabel.Text = "Fruit Price: " .. formatNumber(CalculatePlantValue(tool))

end

local function hookTool(tool)

if not tool:IsA("Tool") then return end

tool.Equipped:Connect(function() updatePrice(tool) end)

tool.Unequipped:Connect(function() updatePrice(nil) end)

end

for _, tool in ipairs(player.Backpack:GetChildren()) do hookTool(tool) end

player.Backpack.ChildAdded:Connect(hookTool)

if player.Character then

for _, tool in ipairs(player.Character:GetChildren()) do hookTool(tool) end

end

player.CharacterAdded:Connect(function(char)

for _, tool in ipairs(char:GetChildren()) do hookTool(tool) end

end)

-- Function to initialize and start the pet detector

function Initialize_Special_Pet_Detector()

if specialPetDetectorInitialized then return end

specialPetDetectorInitialized = true

-- Create GUI if it doesn't exist

if not petScreenGui then

petScreenGui = Instance.new("ScreenGui")

petScreenGui.Name = "SpecialPetDetectorScreen"

petScreenGui.ResetOnSpawn = false

petScreenGui.IgnoreGuiInset = true

petScreenGui.ZIndexBehavior = Enum.ZIndexBehavior.Sibling

petScreenGui.DisplayOrder = 999

-- Create 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 = "GreenScreen"

frame.Parent = petScreenGui

-- Add title label

local titleLabel = Instance.new("TextLabel")

titleLabel.Size = UDim2.new(1, 0, 0, 60)

titleLabel.Position = UDim2.new(0, 0, 0.1, 0)

titleLabel.BackgroundTransparency = 1

titleLabel.Font = Enum.Font.SourceSansBold

titleLabel.TextSize = 40

titleLabel.TextWrapped = true

titleLabel.TextColor3 = Color3.fromRGB(255, 255, 255)

titleLabel.Text = "SPECIAL PET DETECTED"

titleLabel.TextStrokeTransparency = 0

titleLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)

titleLabel.Name = "TitleLabel"

titleLabel.Parent = frame

-- Add pet list

local petListLabel = Instance.new("TextLabel")

petListLabel.Size = UDim2.new(0.8, 0, 0.5, 0)

petListLabel.Position = UDim2.new(0.1, 0, 0.25, 0)

petListLabel.BackgroundTransparency = 1

petListLabel.Font = Enum.Font.SourceSansBold

petListLabel.TextSize = 30

petListLabel.TextWrapped = true

petListLabel.TextColor3 = Color3.fromRGB(255, 255, 255)

petListLabel.Text = "Checking for pets..."

petListLabel.TextStrokeTransparency = 0

petListLabel.TextStrokeColor3 = Color3.fromRGB(0, 0, 0)

petListLabel.Name = "PetList"

petListLabel.Parent = frame

petScreenGui.Parent = game:GetService("Players").LocalPlayer:WaitForChild("PlayerGui")

end

-- Start background detection thread (only one)

if not specialPetDetectorThread then

specialPetDetectorThread = spawn(function()

while true do -- Keep checking pets regardless of toggle (only visibility changes)

pcall(function()

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

local foundSpecialPet = false

local detectedPets = {}

if playerData and playerData.PetsData and playerData.PetsData.PetInventory and

playerData.PetsData.PetInventory.Data then

-- Loop through all pets in inventory

for _, petData in pairs(playerData.PetsData.PetInventory.Data) do

if petData and petData.PetType and specialPetListToggle[petData.PetType] then

foundSpecialPet = true

detectedPets[petData.PetType] = (detectedPets[petData.PetType] or 0) + 1

end

-- Update UI based on results

if foundSpecialPet and petScreenGui then

-- Only show if toggle is enabled

if isSpecialPetDetectorEnabled then

petScreenGui.Enabled = true

-- Update pet list text

local petListText = "Found Special Pets:\n\n"

for petType, count in pairs(detectedPets) do

petListText = petListText .. petType .. " x" .. count .. "\n"

end

if petScreenGui and petScreenGui.GreenScreen and petScreenGui.GreenScreen.PetList then

petScreenGui.GreenScreen.PetList.Text = petListText

end

else

if petScreenGui then

petScreenGui.Enabled = false

end

end)

task.wait(5) -- Check every 5 seconds

end

end)

end

-- This function ONLY toggles visibility, doesn't restart detection

function Toggle_Pet_Screen_Visibility()

isSpecialPetDetectorEnabled = not isSpecialPetDetectorEnabled

if petScreenGui then

petScreenGui.Enabled = isSpecialPetDetectorEnabled

end

return isSpecialPetDetectorEnabled

end

-- Add this T key toggle function with your other input listeners

game:GetService("UserInputService").InputBegan:Connect(function(input, gameProcessed)

if gameProcessed then return end

if input.KeyCode == Enum.KeyCode.T then

Toggle_Pet_Screen_Visibility()

end

end)

-- This function is called by the main loop to start the detector once

function Auto_Special_Pet_Detector()

if not specialPetDetectorInitialized then

Initialize_Special_Pet_Detector()

end

return isSpecialPetDetectorEnabled

end

function Auto_ToggleUI()

isAutoToggleUIEnabled = not isAutoToggleUIEnabled

if isAutoToggleUIEnabled then

autoToggleUIThread = spawn(function()

while isAutoToggleUIEnabled do

pcall(function()

-- Check and toggle Honey UI

local honeyUI = game:GetService("Players").LocalPlayer.PlayerGui:FindFirstChild("Honey_UI")

if honeyUI and honeyUI:FindFirstChild("Frame") and honeyUI.Frame.Visible == false then

honeyUI.Frame.Visible = true

task.wait(1)

game:service'VirtualInputManager':SendKeyEvent(true, "ButtonR2", false, game)

end

-- Check and toggle Teleport UI elements

local teleportUI = game:GetService("Players").LocalPlayer.PlayerGui:FindFirstChild("Teleport_UI")

if teleportUI and teleportUI:FindFirstChild("Frame") then

-- Toggle Gear visibility

if teleportUI.Frame:FindFirstChild("Gear") and teleportUI.Frame.Gear.Visible == false then

teleportUI.Frame.Gear.Visible = true

task.wait(1)

game:service'VirtualInputManager':SendKeyEvent(true, "ButtonR2", false, game)

end

-- Toggle Pets visibility

if teleportUI.Frame:FindFirstChild("Pets") and teleportUI.Frame.Pets.Visible == false then

teleportUI.Frame.Pets.Visible = true

task.wait(1)

game:service'VirtualInputManager':SendKeyEvent(true, "ButtonR2", false, game)

end

end)

-- Check UI elements every 3 seconds

task.wait(60)

end

autoToggleUIThread = nil

end)

else

if autoToggleUIThread then

task.cancel(autoToggleUIThread)

end

autoToggleUIThread = nil

end

return isAutoToggleUIEnabled

end

-- Create a function to check for special plants

function CheckForSpecialPlants()

local playerPlot = GetFarm(player)

if playerPlot and playerPlot:FindFirstChild("Important") and

playerPlot.Important:FindFirstChild("Plants_Physical") then

for _, plant in ipairs(playerPlot.Important.Plants_Physical:GetChildren()) do

if plant.Name == "Candy Blossom" then -- can add more plants ( example if plant.Name == "Candy Blossom" or plant.Name == "Other Special Plant" then) )

hasSpecialPlant = true

return true

end

return false

end

-- TOGGLE & RUN AUTO-COLLECT

function Auto_Collect()

isAutoCollectEnabled = not isAutoCollectEnabled

if isAutoCollectEnabled then

local cachedPrompts = {}

local scanTimer = 0

local isPaused = false

-- Set up notification listener for inventory full

local notificationConnection

notificationConnection = game.ReplicatedStorage:WaitForChild("GameEvents").Notification.OnClientEvent:Connect(function(message)

if isAutoCollectEnabled and typeof(message) == "string" and

(message:find("Inventory is full") or message:find("Max backpack")) then

-- Set paused flag and schedule resume after 10 seconds

isPaused = true

task.delay(10, function()

isPaused = false

end)

end

end)

autoCollectThread = spawn(function()

while isAutoCollectEnabled do

-- Skip collection if paused due to full inventory

if not isPaused then

pcall(function()

-- only refresh prompts every 15 loops (~7.5s)

scanTimer = scanTimer + 1

if #cachedPrompts == 0 or scanTimer >= 15 then

cachedPrompts = CollectionService:GetTagged("CollectPrompt")

scanTimer = 0

end

-- collect low-weight crops

local toCollect = {}

for _, prompt in ipairs(cachedPrompts) do

if prompt:IsDescendantOf(farmRoot) then

local model = prompt.Parent and prompt.Parent.Parent

if model and model:IsA("Model") then

-- Get variant and check it's not excluded

local variant = model:FindFirstChild("Variant")

local variantValue = variant and variant.Value or "Normal"

if not DoNotCollect_Variants[variantValue] then

-- Use MutationHandler to check mutations

local mutationString = ""

local success = pcall(function()

mutationString = MutationHandler:GetMutationsAsString(model)

end)

-- Check if any mutation is in the exclusion list

local shouldCollect = true

if success and mutationString ~= "" then

for mutation, excluded in pairs(DoNotCollect_Mutations) do

if excluded and mutationString:find(mutation) then

shouldCollect = false

break

end

-- Check weight and collect if appropriate

if shouldCollect then

local w = (model:FindFirstChild("Weight") and model.Weight.Value) or 0

local variantThreshold = MIN_WEIGHT_BY_VARIANT[variantValue]

if w <= variantThreshold then

table.insert(toCollect, model)

end

if #toCollect > 0 then

for _, model in ipairs(toCollect) do

Remotes.Crops.Collect.send({model})

task.wait(0.1)

end

end)

end

task.wait(1)

end

-- Clean up notification connection

if notificationConnection then

notificationConnection:Disconnect()

end

autoCollectThread = nil

end)

else

autoCollectThread = nil

end

return isAutoCollectEnabled

end

-- TOGGLE & RUN AUTO-SELL

--[[function Auto_Sell()

isAutoSellEnabled = not isAutoSellEnabled

if isAutoSellEnabled then

-- Set up notification listener

local notificationConnection

notificationConnection = game.ReplicatedStorage:WaitForChild("GameEvents").Notification.OnClientEvent:Connect(function(message)

if isAutoSellEnabled and typeof(message) == "string" and

(message:find("Inventory is full") or message:find("Max backpack")) then

pcall(function()

-- Ensure character and HRP exist

local char = player.Character or player.CharacterAdded:Wait()

local hrp = char:FindFirstChild("HumanoidRootPart")

local humanoid = char:FindFirstChild("Humanoid")

if not hrp or not humanoid then return end

-- Find a sell stand

local standsFolder = workspace:WaitForChild("NPCS"):WaitForChild("Sell Stands")

local closestStand = nil

local closestDist = math.huge

local closestPart = nil

-- Find the closest sell stand

for _, stand in ipairs(standsFolder:GetChildren()) do

local targetPart

if stand:IsA("Model") then

targetPart = stand.PrimaryPart or stand:FindFirstChildWhichIsA("BasePart")

elseif stand:IsA("BasePart") then

targetPart = stand

end

if targetPart then

local dist = (hrp.Position - targetPart.Position).Magnitude

if dist < closestDist then

closestStand = stand

closestDist = dist

closestPart = targetPart

end

if not closestPart then return end

-- Original position for teleporting back

local originalCFrame = hrp.CFrame

local originalState = humanoid:GetState()

-- Check if already near a sell stand (within 15 studs)

local isNearStand = closestDist <= 15

-- Only teleport if not already near

if not isNearStand then

-- Store the current state

local currentPlatformStand = humanoid.PlatformStand

-- Teleport to the front of the stand with proper orientation

local standCF = closestPart.CFrame

local lookAt = (standCF.Position - Vector3.new(standCF.Position.X, hrp.Position.Y, standCF.Position.Z)).Unit

local targetCF = CFrame.new(standCF.Position + Vector3.new(-3, 0, 5))

-- Teleport

hrp.CFrame = targetCF

-- Reset humanoid state to fix animation

humanoid:ChangeState(Enum.HumanoidStateType.GettingUp)

task.wait(0.1)

humanoid:ChangeState(Enum.HumanoidStateType.Running)

humanoid.PlatformStand = false

task.wait(0.5) -- Wait for teleport and animation reset

end

-- Try submitting all plants first if needed

task.spawn(function()

pcall(function()

game:GetService("ReplicatedStorage").GameEvents.NightQuestRemoteEvent:FireServer("SubmitAllPlants")

end)

task.wait(0.5)

-- Sell

sellRemote:FireServer()

task.wait(0.5)

-- Return to original position only if we teleported

if not isNearStand then

-- Teleport back

hrp.CFrame = originalCFrame

-- Reset state again

humanoid:ChangeState(Enum.HumanoidStateType.GettingUp)

task.wait(0.1)

humanoid:ChangeState(Enum.HumanoidStateType.Running)

humanoid.PlatformStand = false

end

end)

end

end)

autoSellThread = spawn(function()

while isAutoSellEnabled do

task.wait(1)

end

-- Clean up notification connection when disabled

if notificationConnection then

notificationConnection:Disconnect()

end

autoSellThread = nil

end)

else

autoSellThread = nil

end

return isAutoSellEnabled

end]]

function Auto_Sell_Multiple()

isAutoSellOneByOneEnabled = not isAutoSellOneByOneEnabled

if isAutoSellOneByOneEnabled then

autoSellOneByOneThread = spawn(function()

while isAutoSellOneByOneEnabled do

pcall(function()

-- Get player data to check for items

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if not playerData or not playerData.InventoryData then return end

-- Find items we can sell (not seeds, not favorites)

local itemsToSell = {}

for uuid, itemData in pairs(playerData.InventoryData) do

if itemData.ItemType == "Holdable" and itemData.ItemData then

-- Skip favorited items

if not itemData.ItemData.IsFavorite then

-- Check if item has a protected variant

local shouldSkip = false

-- Check for variants

if itemData.ItemData.Variant and DoNotSell_Variants[itemData.ItemData.Variant] == true then

shouldSkip = true

end

-- Check for mutations

if not shouldSkip and itemData.ItemData.MutationString then

for mutation, excluded in pairs(DoNotSell_Mutations) do

if excluded and itemData.ItemData.MutationString:find(mutation) then

shouldSkip = true

break

end

-- Only proceed if item is not to be skipped

if not shouldSkip then

local tool = nil

for _, t in pairs(player.Backpack:GetChildren()) do

if t:IsA("Tool") and t:GetAttribute("ITEM_UUID") == uuid then

tool = t

break

end

if not tool and player.Character then

for _, t in pairs(player.Character:GetChildren()) do

if t:IsA("Tool") and t:GetAttribute("ITEM_UUID") == uuid then

tool = t

break

end

-- If we found the tool, check its price

if tool then

-- Calculate the item's value

local itemValue = 0

if tool:GetAttribute("ItemType") == "Pet" then

itemValue = CalculatePetValue(tool)

else

itemValue = CalculatePlantValue(tool)

end

-- Only sell if value is below Keep_Value

if itemValue < Keep_Value then

table.insert(itemsToSell, tool)

end

-- Only teleport and sell if we found items to sell

if #itemsToSell > 10 then

-- Ensure character and HRP exist

local char = player.Character or player.CharacterAdded:Wait()

local hrp = char:FindFirstChild("HumanoidRootPart")

local humanoid = char:FindFirstChild("Humanoid")

if not hrp or not humanoid then return end

-- Find a sell stand

local standsFolder = workspace:WaitForChild("NPCS"):WaitForChild("Sell Stands")

local closestStand = nil

local closestDist = math.huge

local closestPart = nil

-- Find the closest sell stand

for _, stand in ipairs(standsFolder:GetChildren()) do

local targetPart

if stand:IsA("Model") then

targetPart = stand.PrimaryPart or stand:FindFirstChildWhichIsA("BasePart")

elseif stand:IsA("BasePart") then

targetPart = stand

end

if targetPart then

local dist = (hrp.Position - targetPart.Position).Magnitude

if dist < closestDist then

closestStand = stand

closestDist = dist

closestPart = targetPart

end

if not closestPart then return end

-- Original position for teleporting back

local originalCFrame = hrp.CFrame

local originalState = humanoid:GetState()

-- Check if already near a sell stand (within 5 studs)

local isNearStand = closestDist <= 5

-- Only teleport if not already near

if not isNearStand then

-- Store the current state

local currentPlatformStand = humanoid.PlatformStand

-- Teleport to the front of the stand with proper orientation

local standCF = closestPart.CFrame

local targetCF = CFrame.new(standCF.Position + Vector3.new(-3, 0, 5))

-- Teleport

hrp.CFrame = targetCF

-- Reset humanoid state to fix animation

humanoid:ChangeState(Enum.HumanoidStateType.GettingUp)

task.wait(0.1)

humanoid:ChangeState(Enum.HumanoidStateType.Running)

humanoid.PlatformStand = false

task.wait(0.5) -- Wait for teleport and animation reset

end

-- Sell all items found, one by one

for _, tool in ipairs(itemsToSell) do

if tool.Parent ~= player.Character then

tool.Parent = player.Character

task.wait(0.01)

end

sell_One_Remote:FireServer()

task.wait(0.1) -- Small delay between sells to avoid flooding

end

-- Return to original position only if we teleported

if not isNearStand then

-- Teleport back

hrp.CFrame = originalCFrame

-- Reset state again

humanoid:ChangeState(Enum.HumanoidStateType.GettingUp)

task.wait(0.1)

humanoid:ChangeState(Enum.HumanoidStateType.Running)

humanoid.PlatformStand = false

end

end)

task.wait(1) -- Wait before next check

end

autoSellOneByOneThread = nil

end)

else

if autoSellOneByOneThread then

task.cancel(autoSellOneByOneThread)

end

autoSellOneByOneThread = nil

end

return isAutoSellOneByOneEnabled

end

-- AUTO-FAVORITE FUNCTION

function Auto_Favorite()

isAutoFavoriteEnabled = not isAutoFavoriteEnabled

if isAutoFavoriteEnabled then

autoFavoriteThread = spawn(function()

while isAutoFavoriteEnabled do

pcall(function()

-- Get inventory data

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if playerData and playerData.InventoryData then

for uuid, record in pairs(playerData.InventoryData) do

-- Only check Holdable items

if record.ItemType == "Holdable" and record.ItemData then

-- Skip already favorited items

if record.ItemData.IsFavorite ~= true then

-- Find the tool object in player's inventory

local tool = nil

local backpack = player.Backpack

for _, t in pairs(backpack:GetChildren()) do

if t:IsA("Tool") and t:GetAttribute("ITEM_UUID") == uuid then

tool = t

break

end

if tool then

local shouldFavorite = false

local reason = ""

-- Priority 1: Check for mutations (highest priority)

local hasMutation = false

if record.ItemData.MutationString then

for mutation, shouldFavoriteMutation in pairs(Favorite_Mutations) do

if shouldFavoriteMutation and record.ItemData.MutationString:find(mutation) then

hasMutation = true

shouldFavorite = true

reason = "mutation"

break

end

-- Priority 2: Check item value if not already favorited by mutation

if not shouldFavorite then

local itemValue = 0

if tool:GetAttribute("ItemType") == "Pet" then

itemValue = CalculatePetValue(tool)

else

itemValue = CalculatePlantValue(tool)

end

if itemValue >= Keep_Value then

shouldFavorite = true

reason = "high value"

end

-- Priority 3: Check for special variant (lowest priority)

if not shouldFavorite then

local hasSpecialVariant = record.ItemData.Variant ~= nil and

Favorite_Variants[record.ItemData.Variant] == true

if hasSpecialVariant then

shouldFavorite = true

reason = "variant"

end

-- Favorite the item if any condition was met

if shouldFavorite then

-- Get the Favorite_Item remote

local favoriteRemote = ReplicatedStorage:WaitForChild("GameEvents")

:WaitForChild("Favorite_Item")

favoriteRemote:FireServer(tool)

task.wait(0.1) -- Wait to avoid flooding the server

end

end)

task.wait(0.1) -- Check frequently

end

autoFavoriteThread = nil

end)

else

autoFavoriteThread = nil

end

return isAutoFavoriteEnabled

end

-- AUTO-BUY EGG FUNCTION

function Auto_BuyEgg()

isAutoBuyEggEnabled = not isAutoBuyEggEnabled

if isAutoBuyEggEnabled then

autoBuyEggThread = spawn(function()

while isAutoBuyEggEnabled do

pcall(function()

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if playerData and playerData.PetEggStock and playerData.PetEggStock.Stocks then

for eggIndex, eggData in pairs(playerData.PetEggStock.Stocks) do

-- ALERT: Legendary or Bug Egg in stock

if (eggData.EggName == "Bee Egg" or eggData.EggName == "Bug Egg" or

eggData.EggName == "Night Egg") and eggData.Stock > 0 then

-- Send webhook notification

pcall(function()

request({

Url = webhookUrl,

Method = "POST",

Headers = { ["Content-Type"] = "application/json" },

Body = HttpService:JSONEncode({

embeds = {{

title = "Grow A Garden Alert",

color = 16753920,

fields = {

{ name = "Egg", value = eggData.EggName },

{ name = "Stock", value = tostring(eggData.Stock) }

}

}}

})

end)

end

-- Check if this egg is on our buy list and in stock

if Buy_PetEggs[eggData.EggName] and eggData.Stock > 0 then

-- Try to buy all available stock

local stockAmount = eggData.Stock

for i = 1, stockAmount do

-- Make purchase request

ReplicatedStorage.GameEvents.BuyPetEgg:FireServer(eggIndex)

-- Wait between purchases

task.wait(0.5)

-- Check if purchase was successful by checking updated stock

local updatedData = DataService:GetData()

if updatedData and updatedData.PetEggStock and

updatedData.PetEggStock.Stocks[eggIndex] then

local newStock = updatedData.PetEggStock.Stocks[eggIndex].Stock

if newStock < stockAmount then

stockAmount = newStock -- Update remaining stock

if stockAmount == 0 then break end

else

task.wait(1)

break

end

end)

-- Check for eggs every 5 seconds (more frequent than before)

task.wait(5)

end

autoBuyEggThread = nil

end)

else

if autoBuyEggThread then

task.cancel(autoBuyEggThread)

autoBuyEggThread = nil

end

return isAutoBuyEggEnabled

end

-- AUTO-BUY GEAR FUNCTION

function Auto_BuyGear()

isAutoBuyGearEnabled = not isAutoBuyGearEnabled

if isAutoBuyGearEnabled then

autoBuyGearThread = spawn(function()

while isAutoBuyGearEnabled do

pcall(function()

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if playerData and playerData.GearStock and playerData.GearStock.Stocks then

-- Track which items we've purchased in this cycle

local purchasedItems = {}

for itemName, stockData in pairs(playerData.GearStock.Stocks) do

-- ALERT: Master Sprinkler in stock

if itemName == "Master Sprinkler" and stockData.Stock > 0 then

-- Send webhook notification

pcall(function()

request({

Url = webhookUrl,

Method = "POST",

Headers = { ["Content-Type"] = "application/json" },

Body = HttpService:JSONEncode({

embeds = {{

title = "Grow A Garden Alert",

color = 65280,

fields = {

{ name = "Item", value = itemName },

{ name = "Stock", value = tostring(stockData.Stock) }

}

}}

})

end)

end

-- Check if this gear is on our buy list and in stock

if Buy_GearShop[itemName] == true and stockData.Stock > 0 then

-- Try to buy all available stock

local stockAmount = stockData.Stock

for i = 1, stockAmount do

-- Make purchase request

ReplicatedStorage.GameEvents.BuyGearStock:FireServer(itemName)

-- Wait between purchases

task.wait(0.5)

-- Check if purchase was successful by checking updated stock

local updatedData = DataService:GetData()

if updatedData and updatedData.GearStock and

updatedData.GearStock.Stocks[itemName] then

local newStock = updatedData.GearStock.Stocks[itemName].Stock

if newStock < stockAmount then

table.insert(purchasedItems, itemName)

stockAmount = newStock -- Update remaining stock

if stockAmount == 0 then break end

else

task.wait(1)

break

end

-- Submit plants quest only once after we've made purchases

if #purchasedItems > 0 then

task.wait(1)

pcall(function()

game:GetService("ReplicatedStorage").GameEvents.NightQuestRemoteEvent:FireServer("SubmitAllPlants")

end)

end

end)

-- Check for gear every 5 seconds

task.wait(5)

end

autoBuyGearThread = nil

end)

else

if autoBuyGearThread then

task.cancel(autoBuyGearThread)

autoBuyGearThread = nil

end

return isAutoBuyGearEnabled

end

-- AUTO-BUY EVENT SHOP FUNCTION

function Auto_BuyEvent()

isAutoBuyEventEnabled = not isAutoBuyEventEnabled

if isAutoBuyEventEnabled then

autoBuyEventThread = spawn(function()

while isAutoBuyEventEnabled do

pcall(function()

-- Check if it's blood moon

local isBloodMoon = workspace:GetAttribute("BloodMoonEvent") or false

-- Only run during blood moon

if isBloodMoon then

-- Get Event Shop data

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if playerData and playerData.EventShopStock and playerData.EventShopStock.Stocks then

-- Check current Blood Kiwi count in inventory

local bloodKiwiCount = 0

if playerData.InventoryData then

for _, itemData in pairs(playerData.InventoryData) do

if itemData.ItemType == "Holdable" and itemData.ItemData and

itemData.ItemData.ItemName == "Blood Kiwi" then

bloodKiwiCount = bloodKiwiCount + 1

end

for itemName, stockData in pairs(playerData.EventShopStock.Stocks) do

-- Skip Blood Kiwi if we already have 8 or more

if itemName == "Blood Kiwi" and bloodKiwiCount >= 8 then

continue

end

-- For ANY item in stock, if we don't have it in our Buy_EventShop table yet, add it

if Buy_EventShop[itemName] == nil then

Buy_EventShop[itemName] = true

end

-- Special alert for Divine rarity items or any item with Stock > 0

if stockData.Stock > 0 then

-- Send more detailed webhook for rarer items

local eventItem = require(ReplicatedStorage.Data:WaitForChild("EventShopData"))[itemName]

local rarity = eventItem and eventItem.SeedRarity or "Unknown"

if rarity == "Divine" or rarity == "Legendary" or rarity == "Mythical" then

pcall(function()

request({

Url = webhookUrl,

Method = "POST",

Headers = { ["Content-Type"] = "application/json" },

Body = HttpService:JSONEncode({

embeds = {{

title = "Grow A Garden Alert: " .. rarity .. " Item",

color = (rarity == "Divine") and 16711680 or 16776960,

fields = {

{ name = "Event Item", value = itemName },

{ name = "Rarity", value = rarity },

{ name = "Stock", value = tostring(stockData.Stock) }

}

}}

})

end)

end

-- Attempt to buy if in our list and in stock

if Buy_EventShop[itemName] == true and stockData.Stock > 0 then

-- Try to buy all available stock

local stockAmount = stockData.Stock

for i = 1, stockAmount do

-- Make purchase request

ReplicatedStorage.GameEvents.BuyEventShopStock:FireServer(itemName)

ReplicatedStorage.GameEvents.BuyEventShopStock:FireServer("Candy Blossom")

ReplicatedStorage.GameEvents.BuyEventShopStock:FireServer("Chocolate Sprinkler")

-- Wait between purchases

task.wait(0.5)

-- Check if purchase was successful

local updatedData = DataService:GetData()

if updatedData and updatedData.EventShopStock and

updatedData.EventShopStock.Stocks[itemName] then

local newStock = updatedData.EventShopStock.Stocks[itemName].Stock

if newStock < stockAmount then

stockAmount = newStock -- Update remaining stock

if stockAmount == 0 then break end

else

task.wait(1)

break

end

end)

-- Check for event shop items more frequently (once per second)

task.wait(1)

end

autoBuyEventThread = nil

end)

else

if autoBuyEventThread then

task.cancel(autoBuyEventThread)

autoBuyEventThread = nil

end

return isAutoBuyEventEnabled

end

-- AUTO-BUY TWILIGHT SHOP FUNCTION

function Auto_BuyTwilight()

isAutoBuyTwilightEnabled = not isAutoBuyTwilightEnabled

if isAutoBuyTwilightEnabled then

autoBuyTwilightThread = spawn(function()

while isAutoBuyTwilightEnabled do

pcall(function()

-- Check if it's regular night (not blood moon)

local isNight = workspace:GetAttribute("NightEvent") or false

local isBloodMoon = workspace:GetAttribute("BloodMoonEvent") or false

-- Only run during regular night (when isNight is true and isBloodMoon is false)

if isNight and not isBloodMoon then

-- Get NightEventShop data

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if playerData and playerData.NightEventShopStock and playerData.NightEventShopStock.Stocks then

for itemName, stockData in pairs(playerData.NightEventShopStock.Stocks) do

-- Special alert for rare items in stock

if stockData.Stock > 0 then

-- Get item data from ReplicatedStorage

local NightEventShopData = require(ReplicatedStorage.Data:WaitForChild("NightEventShopData"))

local itemInfo = NightEventShopData[itemName]

if itemInfo then

local rarity = itemInfo.SeedRarity or "Unknown"

-- Send webhook for rare items

if rarity == "Divine" or rarity == "Mythical" or rarity == "Legendary" then

pcall(function()

request({

Url = webhookUrl,

Method = "POST",

Headers = { ["Content-Type"] = "application/json" },

Body = HttpService:JSONEncode({

embeds = {{

title = "Grow A Garden Alert: Twilight Shop",

color = (rarity == "Divine") and 16711680 or 16776960,

fields = {

{ name = "Item", value = itemName },

{ name = "Rarity", value = rarity },

{ name = "Stock", value = tostring(stockData.Stock) }

}

}}

})

end)

end

-- Attempt to buy if in our list and in stock

if Buy_TwilightShop[itemName] == true and stockData.Stock > 0 then

-- Try to buy all available stock

local stockAmount = stockData.Stock

for i = 1, stockAmount do

-- Make purchase request

ReplicatedStorage.GameEvents.BuyNightEventShopStock:FireServer(itemName)

-- Wait between purchases

task.wait(0.5)

-- Check if purchase was successful

local updatedData = DataService:GetData()

if updatedData and updatedData.NightEventShopStock and

updatedData.NightEventShopStock.Stocks[itemName] then

local newStock = updatedData.NightEventShopStock.Stocks[itemName].Stock

if newStock < stockAmount then

stockAmount = newStock -- Update remaining stock

if stockAmount == 0 then break end

else

task.wait(1)

break

end

end)

-- Check for twilight shop items every second

task.wait(1)

end

autoBuyTwilightThread = nil

end)

else

if autoBuyTwilightThread then

task.cancel(autoBuyTwilightThread)

autoBuyTwilightThread = nil

end

return isAutoBuyTwilightEnabled

end

-- AUTO-BUY SEED FUNCTION

function Auto_BuySeed()

isAutoBuySeedEnabled = not isAutoBuySeedEnabled

if isAutoBuySeedEnabled then

autoBuySeedThread = spawn(function()

while isAutoBuySeedEnabled do

pcall(function()

-- Get seed data and stock info

local DataService = require(ReplicatedStorage.Modules.DataService)

local SeedData = require(ReplicatedStorage.Data.SeedData)

local playerData = DataService:GetData()

if playerData and playerData.SeedStock and playerData.SeedStock.Stocks then

-- Check each seed in our buy list

for seedName, shouldBuy in pairs(Buy_Seeds) do

if shouldBuy then

-- Verify the seed exists in SeedData and is displayed in shop

local seedInfo = SeedData[seedName]

if seedInfo and seedInfo.DisplayInShop then

-- Keep buying until stock depleted

while isAutoBuySeedEnabled do

-- Get fresh data to check current stock

playerData = DataService:GetData()

local stockInfo = playerData.SeedStock.Stocks[seedName]

if stockInfo and stockInfo.Stock > 0 then

-- Buy the seed

ReplicatedStorage.GameEvents.BuySeedStock:FireServer(seedName)

-- Short wait to allow server to process

task.wait(0.1)

else

-- No more stock for this seed, move to next

break

end

end)

-- Check every 5 seconds for restocked seeds

task.wait(5)

end

autoBuySeedThread = nil

end)

else

autoBuySeedThread = nil

end

return isAutoBuySeedEnabled

end

function Auto_Plant()

-- First check if we already know there's a special plant

if hasSpecialPlant then

return false

end

-- Check again for special plants

if CheckForSpecialPlants() then

return false

end

isAutoPlantEnabled = not isAutoPlantEnabled

if isAutoPlantEnabled then

-- Immediately check if we're already at max capacity before starting

local playerPlot = GetFarm(player)

local currentPlantCount = 0

if playerPlot and playerPlot:FindFirstChild("Important") and

playerPlot.Important:FindFirstChild("Plants_Physical") then

currentPlantCount = #playerPlot.Important.Plants_Physical:GetChildren()

end

-- Don't start if we're at capacity

if currentPlantCount >= 50 then

isAutoPlantEnabled = false

hasSpecialPlant = true

return false

end

autoPlantThread = spawn(function()

while isAutoPlantEnabled do

pcall(function()

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if playerData and playerData.InventoryData then

-- Find the player's plot

local playerPlot = GetFarm(player)

if not playerPlot then return end

-- Check for special plants

if CheckForSpecialPlants() then

isAutoPlantEnabled = false

if autoPlantThread then

task.cancel(autoPlantThread)

autoPlantThread = nil

end

return

end

-- Check how many plants we already have

if playerPlot:FindFirstChild("Important") and

playerPlot.Important:FindFirstChild("Plants_Physical") then

currentPlantCount = #playerPlot.Important.Plants_Physical:GetChildren()

end

-- Set a safety margin - stop at 50 to prevent accidental overflow

if currentPlantCount >= 50 then

-- Turn off auto-plant functionality

isAutoPlantEnabled = false

if autoPlantThread then

task.cancel(autoPlantThread)

autoPlantThread = nil

end

return

end

-- Find all Can_Plant parts

local plantSpots = {}

local allCanPlantParts = {}

for _, obj in pairs(playerPlot:GetDescendants()) do

if obj.Name == "Can_Plant" and obj:IsA("BasePart") then

table.insert(allCanPlantParts, obj)

end

-- Only use the second Can_Plant or the last one if there aren't at least 2

if #allCanPlantParts >= 2 then

plantSpots = {allCanPlantParts[2]} -- Use only the second Can_Plant

else

plantSpots = {allCanPlantParts[#allCanPlantParts]} -- Use the last one if not enough

end

if #plantSpots == 0 then return end

-- Find seeds in inventory

local seedsToPlant = {}

for uuid, itemData in pairs(playerData.InventoryData) do

if itemData.ItemType == "Seed" and itemData.ItemData then

local seedName = itemData.ItemData.ItemName

local quantity = itemData.ItemData.Quantity or 0

if Plant_Seeds[seedName] and quantity > 0 then

table.insert(seedsToPlant, {

uuid = uuid,

name = seedName,

quantity = quantity

})

end

-- If we have seeds, try to plant them

if #seedsToPlant > 0 then

for _, seedInfo in pairs(seedsToPlant) do

if seedInfo.quantity > 0 then

-- Check plant count again before each seed type

if playerPlot:FindFirstChild("Important") and

playerPlot.Important:FindFirstChild("Plants_Physical") then

-- Check for special plants again

if CheckForSpecialPlants() then

isAutoPlantEnabled = false

if autoPlantThread then

task.cancel(autoPlantThread)

autoPlantThread = nil

end

return

end

currentPlantCount = #playerPlot.Important.Plants_Physical:GetChildren()

if currentPlantCount >= 50 then

isAutoPlantEnabled = false

if autoPlantThread then

task.cancel(autoPlantThread)

autoPlantThread = nil

end

return

end

-- Find tool by name pattern instead of UUID

local seedTool = nil

for _, tool in ipairs(player.Backpack:GetChildren()) do

-- Only consider tools tagged as Seed

if tool:GetAttribute("ItemType") == "Seed" then

-- Match by the Seed attribute

if tool:GetAttribute("Seed") == seedInfo.name then

seedTool = tool

break

end

-- Fallback: tool name contains seed name (case-insensitive)

if tool.Name:lower():find(seedInfo.name:lower()) then

seedTool = tool

break

end

if seedTool then

-- Equip the seed

seedTool.Parent = player.Character

task.wait(0.5)

-- Calculate how many more plants we can place (with safety margin)

local remainingSlots = 50 - currentPlantCount

-- Use each Can_Plant position with offset

for i, spot in ipairs(plantSpots) do

-- Stop if we hit near the limit

if currentPlantCount >= 50 or remainingSlots <= 0 then

-- Turn off auto-plant functionality

isAutoPlantEnabled = false

if autoPlantThread then

task.cancel(autoPlantThread)

autoPlantThread = nil

end

break

end

-- Stop if we run out of seeds

if seedInfo.quantity <= 0 then

break

end

-- Create planting position with offset

local plantPosition = Vector3.new(

spot.Position.X,

spot.Position.Y,

spot.Position.Z + 7

)

-- Plant the seed

ReplicatedStorage.GameEvents.Plant_RE:FireServer(plantPosition, seedInfo.name)

-- Short wait between plants

task.wait(0.1)

-- Update our counters

seedInfo.quantity = seedInfo.quantity - 1

currentPlantCount = currentPlantCount + 1

remainingSlots = remainingSlots - 1

-- Recheck plant count every 10 plants as safety measure

if i % 10 == 0 then

if playerPlot:FindFirstChild("Important") then

-- Check for special plants again

if CheckForSpecialPlants() then

isAutoPlantEnabled = false

if autoPlantThread then

task.cancel(autoPlantThread)

autoPlantThread = nil

end

break

end

currentPlantCount = #playerPlot.Important.Plants_Physical:GetChildren()

remainingSlots = 50 - currentPlantCount

if currentPlantCount >= 50 then

isAutoPlantEnabled = false

if autoPlantThread then

task.cancel(autoPlantThread)

autoPlantThread = nil

end

break

end

-- Unequip when done

if player.Character:FindFirstChild(seedTool.Name) then

seedTool.Parent = player.Backpack

end

end)

-- Wait before checking again

task.wait(1)

end

autoPlantThread = nil

end)

else

if autoPlantThread then

task.cancel(autoPlantThread)

end

autoPlantThread = nil

end

return isAutoPlantEnabled

end

function Auto_Delete_Plant()

isAutoDeletePlantEnabled = not isAutoDeletePlantEnabled

-- If we know there are no more plants to delete, don't even start

if noMorePlantsToDelete and isAutoDeletePlantEnabled then

isAutoDeletePlantEnabled = false

return false

end

if isAutoDeletePlantEnabled then

autoDeletePlantThread = spawn(function()

local Remove_Item = game.ReplicatedStorage.GameEvents:WaitForChild("Remove_Item")

local player = game.Players.LocalPlayer

local consecutiveEmptyCycles = 0 -- Counter for consecutive cycles with nothing to delete

while isAutoDeletePlantEnabled do

local deletedAny = false

pcall(function()

local playerPlot = GetFarm(player)

if playerPlot

and playerPlot:FindFirstChild("Important")

and playerPlot.Important:FindFirstChild("Plants_Physical") then

-- Equip the shovel if it's not already equipped

local backpack = player:FindFirstChild("Backpack")

if backpack

and not player.Character:FindFirstChild("Shovel [Destroy Plants]") then

local shovel = backpack:FindFirstChild("Shovel [Destroy Plants]")

if shovel then

shovel.Parent = player.Character

task.wait(0.2)

end

-- Loop through all plants in your plot

for _, plant in ipairs(playerPlot.Important.Plants_Physical:GetChildren()) do

if Delete_Plants[plant.Name] then

if plant:GetAttribute("Favorited") then

-- Skip favorited plants

else

-- Find the numbered child (e.g. plant["1"])

local toDelete

for _, child in ipairs(plant:GetChildren()) do

if tonumber(child.Name) then

toDelete = child

break

end

if toDelete then

Remove_Item:FireServer(toDelete)

deletedAny = true

task.wait(0.2)

end

end)

if not deletedAny then

-- If nothing was deleted, unequip the shovel

local char = player.Character

local backpack = player:FindFirstChild("Backpack")

if char and backpack then

local shovel = char:FindFirstChild("Shovel [Destroy Plants]")

if shovel then

shovel.Parent = backpack

end

-- Increment empty cycle counter

consecutiveEmptyCycles = consecutiveEmptyCycles + 1

-- If we've had 3 consecutive empty cycles, set the global flag and turn off the function

if consecutiveEmptyCycles >= 3 then

noMorePlantsToDelete = true

isAutoDeletePlantEnabled = false

break

end

-- Wait 60 seconds before next check

task.wait(60)

else

-- Reset counter and the noMorePlantsToDelete flag if we deleted something

consecutiveEmptyCycles = 0

noMorePlantsToDelete = false

-- Wait 5 seconds before next check

task.wait(5)

end

-- Make sure to unequip the shovel when we're done

pcall(function()

local char = player.Character

local backpack = player:FindFirstChild("Backpack")

if char and backpack then

local shovel = char:FindFirstChild("Shovel [Destroy Plants]")

if shovel then

shovel.Parent = backpack

end

end)

autoDeletePlantThread = nil

end)

else

-- Turn off and clean up

if autoDeletePlantThread then

task.cancel(autoDeletePlantThread)

end

-- Make sure to unequip the shovel

pcall(function()

local char = player.Character

local backpack = player:FindFirstChild("Backpack")

if char and backpack then

local shovel = char:FindFirstChild("Shovel [Destroy Plants]")

if shovel then

shovel.Parent = backpack

end

end)

autoDeletePlantThread = nil

end

return isAutoDeletePlantEnabled

end

function Auto_Feed_Pet()

isAutoFeedEnabled = not isAutoFeedEnabled

if isAutoFeedEnabled then

autoFeedThread = spawn(function()

-- Get direct reference to remote

local petRemote = ReplicatedStorage:WaitForChild("GameEvents"):WaitForChild("ActivePetService")

local player = Players.LocalPlayer

while isAutoFeedEnabled do

local allPetsFullyFed = true

pcall(function()

-- Get pet data directly from datastore

local petData = ActivePetsService:GetPlayerDatastorePetData(player.Name)

if not petData then return end

-- Check if we have equipped pets

if not petData.EquippedPets or #petData.EquippedPets == 0 then return end

-- Check for pet inventory

if not petData.PetInventory or not petData.PetInventory.Data then return end

local petInventory = petData.PetInventory.Data

-- Get reference to PetList for correct max hunger values

local PetList = require(ReplicatedStorage.Data.PetRegistry.PetList)

-- Find hungry pets using the equipped pets list directly

local hungryPets = {}

for _, uuid in ipairs(petData.EquippedPets) do

local pet = petInventory[uuid]

if pet and pet.PetData then

local hunger = pet.PetData.Hunger or 0

local petType = pet.PetType

-- Get the pet's specific max hunger from PetList

local maxHunger = (PetList[petType] and PetList[petType].DefaultHunger) or 30000

-- Only add to hungry list if below 30% of its max hunger

if hunger < maxHunger * 0.4 then

allPetsFullyFed = false

table.insert(hungryPets, {

uuid = uuid,

hunger = hunger,

type = petType,

name = pet.PetData.Name or "Unknown Pet",

maxHunger = maxHunger

})

end

-- Force allPetsFullyFed to false if we found any hungry pets

if #hungryPets > 0 then

allPetsFullyFed = false

end

-- Sort by hunger percentage (lowest first)

table.sort(hungryPets, function(a, b)

return (a.hunger / a.maxHunger) < (b.hunger / b.maxHunger)

end)

if #hungryPets == 0 then return end

-- Get all items from inventory that can be used as food

local backpack = player:FindFirstChild("Backpack")

local character = player.Character

if not backpack or not character then return end

-- Get food items that have "kg" in the name, are under 10kg, and not favorited

local foodTools = {}

for _, tool in ipairs(backpack:GetChildren()) do

if tool:IsA("Tool") then

local toolName = tool.Name

-- Skip if favorited

if tool:GetAttribute("IsFavorite") == true then continue end

-- Look for items with "kg" in the name (foods)

if toolName:find("kg") then

-- Try to extract the weight value

local weightStr = toolName:match("(%d+%.?%d*)kg")

local weight = tonumber(weightStr)

-- Only use items under 20kg

if weight and weight < 20 then

table.insert(foodTools, tool)

end

if #foodTools == 0 then return end

-- Feed pets one at a time

for _, pet in ipairs(hungryPets) do

-- Feed the pet with up to 3 food items

for i = 1, math.min(3, #foodTools) do

local food = foodTools[i]

-- Unequip any currently equipped tool

local equipped = character:FindFirstChildOfClass("Tool")

if equipped then

equipped.Parent = backpack

task.wait(0.2)

end

-- Equip food

food.Parent = character

task.wait(0.3)

-- Feed the pet

petRemote:FireServer("Feed", pet.uuid)

task.wait(0.5)

-- Check if pet is now fed

local updatedPetData = ActivePetsService:GetPetData(player.Name, pet.uuid)

if updatedPetData and updatedPetData.PetData then

local newHunger = updatedPetData.PetData.Hunger or 0

if newHunger >= pet.maxHunger * 0.9 then

break -- Stop feeding this pet if it's now full

end

-- Return any equipped tool to backpack

local equipped = character:FindFirstChildOfClass("Tool")

if equipped then

equipped.Parent = backpack

end

task.wait(0.5) -- Wait between pets

end

end)

-- Make sure we check if we found hungry pets again before waiting

if allPetsFullyFed then

task.wait(30) -- Wait 30 seconds when all pets are fed

else

task.wait(5) -- Wait time when pets need feeding

end

autoFeedThread = nil

end)

else

if autoFeedThread then

task.cancel(autoFeedThread)

end

autoFeedThread = nil

end

return isAutoFeedEnabled

end

function Auto_PlaceEgg()

isAutoPlaceEggEnabled = not isAutoPlaceEggEnabled

if isAutoPlaceEggEnabled then

autoPlaceEggThread = spawn(function()

while isAutoPlaceEggEnabled do

pcall(function()

local player = game.Players.LocalPlayer

local character = player.Character

if not character then return end

-- Get player data

local DataService = require(game.ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if not playerData then return end

-- Find player plot

local playerPlot = GetFarm(player)

if not playerPlot then return end

-- Find Can_Plant

local canPlant

for _, obj in pairs(playerPlot:GetDescendants()) do

if obj.Name == "Can_Plant" and obj:IsA("BasePart") then

canPlant = obj

break -- Use first one found

end

if not canPlant then return end

-- Count existing eggs

local currentEggCount = 0

local existingEggs = {}

for _, obj in pairs(workspace:GetDescendants()) do

if obj:HasTag("PetEggServer") and obj:GetAttribute("OWNER") == player.Name then

currentEggCount = currentEggCount + 1

existingEggs[obj:GetAttribute("OBJECT_UUID")] = obj

end

-- Check if we have reached the maximum

local maxEggSlots = playerData.PetsData.MutableStats.MaxEggsInFarm

-- Hatch ready eggs first

for _, eggObj in pairs(existingEggs) do

if eggObj:GetAttribute("TimeToHatch") and eggObj:GetAttribute("TimeToHatch") <= 0 then

game.ReplicatedStorage.GameEvents.PetEggService:FireServer("HatchPet", eggObj)

task.wait(1)

return -- Only hatch one egg per cycle

end

-- Place new eggs if we have room

if currentEggCount < maxEggSlots then

-- First unequip any current tool

if character:FindFirstChildOfClass("Tool") then

for _, tool in pairs(character:GetChildren()) do

if tool:IsA("Tool") then

tool.Parent = player.Backpack

end

task.wait(1)

end

-- Use the global egg index for detection

for _, tool in ipairs(player.Backpack:GetChildren()) do

local isEggTool = false

-- Primary check: ItemType attribute must be PetEgg

if tool:GetAttribute("ItemType") == "PetEgg" then

isEggTool = true

end

-- Secondary check: Use the egg index table

if not isEggTool and eggIndex[tool.Name] then

isEggTool = true

end

-- Explicitly exclude pet tools

if tool:GetAttribute("ItemType") == "Pet" then

isEggTool = false

end

if isEggTool then

-- Use more direct equip approach

tool.Parent = character

task.wait(1) -- Extended wait after equipping

-- Double check equip

if character:FindFirstChild(tool.Name) then

-- Use a simple position with random offset

local basePosition = canPlant.Position

local randX = math.random(-10, 10)

local randZ = math.random(-10, 10)

local eggPosition = Vector3.new(

basePosition.X + randX,

basePosition.Y,

basePosition.Z + randZ

)

-- Try with both possible remote names to be safe

local success = pcall(function()

game.ReplicatedStorage.GameEvents.PetEggService:FireServer("CreateEgg", eggPosition)

end)

if not success then

pcall(function()

game.ReplicatedStorage.GameEvents.PetEggService:FireServer("PlaceEgg", eggPosition)

end)

end

task.wait(1) -- Extended wait after placement attempt

-- Return to backpack regardless

if character:FindFirstChild(tool.Name) then

tool.Parent = player.Backpack

end

return -- Only place one egg per cycle

end

end)

-- Wait between cycles

task.wait(1)

end

end)

else

if autoPlaceEggThread then

task.cancel(autoPlaceEggThread)

autoPlaceEggThread = nil

end

return isAutoPlaceEggEnabled

end

-- AUTO-SELL PET FUNCTION

function Auto_Sell_Pet()

isAutoSellPetEnabled = not isAutoSellPetEnabled

if isAutoSellPetEnabled then

autoSellPetThread = spawn(function()

local SellPet_RE = ReplicatedStorage.GameEvents.SellPet_RE

local favoriteRemote = ReplicatedStorage:WaitForChild("GameEvents"):WaitForChild("Favorite_Item")

-- Counter for cycling through pets

local currentPetIndex = 1

while isAutoSellPetEnabled do

local foundPetToProcess = false

pcall(function()

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if not playerData or not playerData.PetsData or not playerData.PetsData.PetInventory

or not playerData.PetsData.PetInventory.Data then

return

end

local petInventoryData = playerData.PetsData.PetInventory.Data

local backpack = player.Backpack

local character = player.Character

if not backpack or not character then return end

-- First unequip any currently equipped tool

local equipped = character:FindFirstChildOfClass("Tool")

if equipped then

equipped.Parent = backpack

task.wait(0.2)

end

-- Get all pet tools from backpack

local petTools = {}

for _, tool in pairs(backpack:GetChildren()) do

if tool:IsA("Tool") and tool:GetAttribute("ItemType") == "Pet" then

table.insert(petTools, tool)

end

-- If no pet tools found, return

if #petTools == 0 then

return

end

-- Reset index if it's out of bounds

if currentPetIndex > #petTools then

currentPetIndex = 1

return

end

-- Get the current pet to process

local currentTool = petTools[currentPetIndex]

local petName = currentTool.Name

foundPetToProcess = true

-- Check if this pet is already favorited

local isFavoritedInAttribute = currentTool:GetAttribute("Favorite") == true

-- Also check in the data

local uuid = currentTool:GetAttribute("ITEM_UUID")

local isFavoritedInData = false

if uuid and petInventoryData[uuid] and petInventoryData[uuid].PetData then

isFavoritedInData = petInventoryData[uuid].PetData.IsFavorite == true

end

-- If it's already favorited in either place, skip processing

if isFavoritedInAttribute or isFavoritedInData then

currentPetIndex = currentPetIndex + 1

return

end

-- Extract pet type from name (before first bracket)

local petType = petName:match("^([^%[]+)")

if petType then petType = petType:gsub("%s+$", "") end

-- Extract weight from name

local petWeight = tonumber(petName:match("(%d+%.?%d*)%s*KG")) or 0

-- Extract age from name

local age = tonumber(petName:match("Age%s+(%d+)")) or 1

-- Check if this pet should be sold based on type and weight

local shouldSell = false

if Sell_Pets[petType] == true then

shouldSell = petWeight <= MAX_PET_KG and age < 5

end

if shouldSell then

-- Equip and sell

currentTool.Parent = character

task.wait(0.5)

SellPet_RE:FireServer(currentTool)

task.wait(0.5)

-- Return to backpack if needed

if character:FindFirstChild(currentTool.Name) then

currentTool.Parent = backpack

end

else

-- Only favorite if not already favorited

favoriteRemote:FireServer(currentTool)

task.wait(0.5)

end

-- Increment the pet index for next time

currentPetIndex = currentPetIndex + 1

end)

-- If no pets were found to process, wait longer

if not foundPetToProcess then

task.wait(10)

currentPetIndex = 1 -- Reset index after waiting

else

task.wait(1)

end

autoSellPetThread = nil

end)

else

if autoSellPetThread then

task.cancel(autoSellPetThread)

end

autoSellPetThread = nil

end

return isAutoSellPetEnabled

end

function Auto_Submit_Honey()

isAutoSubmitHoneyEnabled = not isAutoSubmitHoneyEnabled

if isAutoSubmitHoneyEnabled then

autoSubmitHoneyThread = spawn(function()

while isAutoSubmitHoneyEnabled do

pcall(function()

-- Get player data

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if not playerData then return end

-- Check machine state

local machineState = "empty"

if playerData.HoneyMachine then

if playerData.HoneyMachine.IsRunning == true and playerData.HoneyMachine.TimeLeft and playerData.HoneyMachine.TimeLeft > 0 then

machineState = "processing"

elseif playerData.HoneyMachine.HoneyStored and playerData.HoneyMachine.HoneyStored > 0 then

machineState = "readyToCollect"

end

-- Handle each machine state

if machineState == "processing" then

-- Machine is processing, just wait

task.wait(10)

return

elseif machineState == "readyToCollect" then

-- Machine has honey to collect, just fire the remote

local honeyMachineRemote = ReplicatedStorage:WaitForChild("GameEvents"):WaitForChild("HoneyMachineService_RE")

honeyMachineRemote:FireServer("MachineInteract")

task.wait(1)

return

elseif machineState == "empty" and playerData.InventoryData then

-- Machine is empty, try to find a pollinated fruit to submit

-- Find pollinated fruits in inventory

local pollinatedFruit = nil

for uuid, itemData in pairs(playerData.InventoryData) do

if itemData.ItemType == "Holdable" and itemData.ItemData then

-- Check if item has the Pollinated mutation and is NOT favorited

if itemData.ItemData.MutationString and

itemData.ItemData.MutationString:find("Pollinated") and

not itemData.ItemData.IsFavorite then

-- Find the tool in the backpack

for _, t in pairs(player.Backpack:GetChildren()) do

if t:IsA("Tool") and t:GetAttribute("ITEM_UUID") == uuid then

-- Double-check it's not favorited using the tool attribute

if not t:GetAttribute("Favorite") and

not t:GetAttribute("IsFavorite") then

pollinatedFruit = t

break

end

if pollinatedFruit then break end

end

-- If we found a pollinated fruit, equip and submit it

if pollinatedFruit then

-- Ensure character exists

local char = player.Character or player.CharacterAdded:Wait()

if not char then return end

-- Equip the fruit

pollinatedFruit.Parent = char

task.wait(0.3) -- Wait to ensure it equips

-- Submit the fruit to the honey machine

local honeyMachineRemote = ReplicatedStorage:WaitForChild("GameEvents"):WaitForChild("HoneyMachineService_RE")

honeyMachineRemote:FireServer("MachineInteract")

-- Return tool to backpack

task.wait(0.5)

if pollinatedFruit.Parent == char then

pollinatedFruit.Parent = player.Backpack

end

else

-- No pollinated fruit found, wait

task.wait(5)

end

end)

task.wait(1) -- Base wait between cycles

end

autoSubmitHoneyThread = nil

end)

else

if autoSubmitHoneyThread then

task.cancel(autoSubmitHoneyThread)

end

autoSubmitHoneyThread = nil

end

return isAutoSubmitHoneyEnabled

end

-- AUTO-BUY HONEY SHOP FUNCTION

function Auto_BuyHoneyShop()

isAutoBuyHoneyShopEnabled = not isAutoBuyHoneyShopEnabled

if isAutoBuyHoneyShopEnabled then

autoBuyHoneyShopThread = spawn(function()

while isAutoBuyHoneyShopEnabled do

pcall(function()

-- Get player data

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if playerData and playerData.EventShopStock and playerData.EventShopStock.Stocks then

-- Create a list of items to buy based on priority

local itemsToBuy = {}

-- Collect available items

for itemName, stockData in pairs(playerData.EventShopStock.Stocks) do

-- For ANY item in stock, if we don't have it in our Buy_HoneyShop table yet, add it

if Buy_HoneyShop[itemName] == nil then

Buy_HoneyShop[itemName] = {buy = true, priority = 50} -- Default priority

end

-- If it's set to buy and in stock, add to our list

local itemConfig = Buy_HoneyShop[itemName]

if itemConfig.buy == true and stockData.Stock > 0 then

table.insert(itemsToBuy, {

name = itemName,

stock = stockData.Stock,

priority = itemConfig.priority

})

end

-- Sort by priority (lower number = higher priority)

table.sort(itemsToBuy, function(a, b)

return a.priority < b.priority

end)

-- Buy items in priority order

for _, item in ipairs(itemsToBuy) do

-- Try to buy all available stock

local stockAmount = item.stock

for i = 1, stockAmount do

-- Make purchase request

ReplicatedStorage.GameEvents.BuyEventShopStock:FireServer(item.name)

-- Wait between purchases

task.wait(0.5)

-- Check if purchase was successful

local updatedData = DataService:GetData()

if updatedData and updatedData.EventShopStock and

updatedData.EventShopStock.Stocks[item.name] then

local newStock = updatedData.EventShopStock.Stocks[item.name].Stock

if newStock < stockAmount then

stockAmount = newStock -- Update remaining stock

if stockAmount == 0 then break end

else

task.wait(1)

break

end

end)

-- Check for honey shop items every 5 seconds

task.wait(5)

end

autoBuyHoneyShopThread = nil

end)

else

if autoBuyHoneyShopThread then

task.cancel(autoBuyHoneyShopThread)

autoBuyHoneyShopThread = nil

end

return isAutoBuyHoneyShopEnabled

end

-- Variables for gift system

local MIN_FRUIT_VALUE_TO_GIFT = 200000000000 -- 200 billion (default)

local MAX_FRUIT_VALUE_TO_GIFT = 900000000000 -- 900 billion (default)

local GIFT_FRUIT_AMOUNT = 1 -- Default number of fruits to gift

local isAutoGiftEnabled = false

local autoGiftThread = nil

local WAIT_FOR_GIFT_ACCEPTANCE = false

-- Create GUI for fruit gifting

local fruitGiftGui = Instance.new("ScreenGui")

fruitGiftGui.Name = "FruitGiftGui"

fruitGiftGui.ResetOnSpawn = false

fruitGiftGui.Parent = playerGui

local giftFrame = Instance.new("Frame")

giftFrame.Name = "GiftFrame"

giftFrame.Size = UDim2.new(0, 250, 0, 245)

giftFrame.Position = UDim2.new(0, 10, 0, 250)

giftFrame.BackgroundColor3 = Color3.fromRGB(45, 45, 65)

giftFrame.BackgroundTransparency = 0.1

giftFrame.BorderSizePixel = 0

giftFrame.Parent = fruitGiftGui

giftFrame.ClipsDescendants = true

-- Corner radius for main frame

local cornerRadius = Instance.new("UICorner")

cornerRadius.CornerRadius = UDim.new(0, 8)

cornerRadius.Parent = giftFrame

-- Title bar

local titleBar = Instance.new("Frame")

titleBar.Name = "TitleBar"

titleBar.Size = UDim2.new(1, 0, 0, 30)

titleBar.BackgroundColor3 = Color3.fromRGB(35, 35, 55)

titleBar.BorderSizePixel = 0

titleBar.Parent = giftFrame

-- Corner radius for title bar

local titleCorner = Instance.new("UICorner")

titleCorner.CornerRadius = UDim.new(0, 8)

titleCorner.Parent = titleBar

-- Title label

local titleLabel = Instance.new("TextLabel")

titleLabel.Name = "TitleLabel"

titleLabel.Size = UDim2.new(1, 0, 1, 0)

titleLabel.BackgroundTransparency = 1

titleLabel.Text = "Fruit Gifting"

titleLabel.TextColor3 = Color3.fromRGB(255, 255, 255)

titleLabel.Font = Enum.Font.GothamBold

titleLabel.TextSize = 16

titleLabel.Parent = titleBar

-- Gift amount section

local giftAmountLabel = Instance.new("TextLabel")

giftAmountLabel.Name = "GiftAmountLabel"

giftAmountLabel.Size = UDim2.new(0.6, 0, 0, 25)

giftAmountLabel.Position = UDim2.new(0.05, 0, 0, 40)

giftAmountLabel.BackgroundTransparency = 1

giftAmountLabel.Text = "Gift Amount:"

giftAmountLabel.TextColor3 = Color3.fromRGB(220, 220, 255)

giftAmountLabel.TextXAlignment = Enum.TextXAlignment.Left

giftAmountLabel.Font = Enum.Font.Gotham

giftAmountLabel.TextSize = 14

giftAmountLabel.Parent = giftFrame

local giftAmountInput = Instance.new("TextBox")

giftAmountInput.Name = "GiftAmountInput"

giftAmountInput.Size = UDim2.new(0.3, 0, 0, 25)

giftAmountInput.Position = UDim2.new(0.65, 0, 0, 40)

giftAmountInput.BackgroundColor3 = Color3.fromRGB(60, 60, 85)

giftAmountInput.BorderSizePixel = 0

giftAmountInput.Text = tostring(GIFT_FRUIT_AMOUNT)

giftAmountInput.TextColor3 = Color3.fromRGB(255, 255, 255)

giftAmountInput.Font = Enum.Font.Gotham

giftAmountInput.TextSize = 14

giftAmountInput.Parent = giftFrame

-- Input box corner radius

local amountCorner = Instance.new("UICorner")

amountCorner.CornerRadius = UDim.new(0, 6)

amountCorner.Parent = giftAmountInput

-- Min price section

local minPriceLabel = Instance.new("TextLabel")

minPriceLabel.Name = "MinPriceLabel"

minPriceLabel.Size = UDim2.new(0.6, 0, 0, 25)

minPriceLabel.Position = UDim2.new(0.05, 0, 0, 75)

minPriceLabel.BackgroundTransparency = 1

minPriceLabel.Text = "Min Value (B):"

minPriceLabel.TextColor3 = Color3.fromRGB(220, 220, 255)

minPriceLabel.TextXAlignment = Enum.TextXAlignment.Left

minPriceLabel.Font = Enum.Font.Gotham

minPriceLabel.TextSize = 14

minPriceLabel.Parent = giftFrame

local minPriceInput = Instance.new("TextBox")

minPriceInput.Name = "MinPriceInput"

minPriceInput.Size = UDim2.new(0.3, 0, 0, 25)

minPriceInput.Position = UDim2.new(0.65, 0, 0, 75)

minPriceInput.BackgroundColor3 = Color3.fromRGB(60, 60, 85)

minPriceInput.BorderSizePixel = 0

minPriceInput.Text = "200" -- Default 200B

minPriceInput.TextColor3 = Color3.fromRGB(255, 255, 255)

minPriceInput.Font = Enum.Font.Gotham

minPriceInput.TextSize = 14

minPriceInput.Parent = giftFrame

-- Input box corner radius

local minCorner = Instance.new("UICorner")

minCorner.CornerRadius = UDim.new(0, 6)

minCorner.Parent = minPriceInput

-- Max price section

local maxPriceLabel = Instance.new("TextLabel")

maxPriceLabel.Name = "MaxPriceLabel"

maxPriceLabel.Size = UDim2.new(0.6, 0, 0, 25)

maxPriceLabel.Position = UDim2.new(0.05, 0, 0, 110)

maxPriceLabel.BackgroundTransparency = 1

maxPriceLabel.Text = "Max Value (B):"

maxPriceLabel.TextColor3 = Color3.fromRGB(220, 220, 255)

maxPriceLabel.TextXAlignment = Enum.TextXAlignment.Left

maxPriceLabel.Font = Enum.Font.Gotham

maxPriceLabel.TextSize = 14

maxPriceLabel.Parent = giftFrame

local maxPriceInput = Instance.new("TextBox")

maxPriceInput.Name = "MaxPriceInput"

maxPriceInput.Size = UDim2.new(0.3, 0, 0, 25)

maxPriceInput.Position = UDim2.new(0.65, 0, 0, 110)

maxPriceInput.BackgroundColor3 = Color3.fromRGB(60, 60, 85)

maxPriceInput.BorderSizePixel = 0

maxPriceInput.Text = "900" -- Default 900B

maxPriceInput.TextColor3 = Color3.fromRGB(255, 255, 255)

maxPriceInput.Font = Enum.Font.Gotham

maxPriceInput.TextSize = 14

maxPriceInput.Parent = giftFrame

-- Input box corner radius

local maxCorner = Instance.new("UICorner")

maxCorner.CornerRadius = UDim.new(0, 6)

maxCorner.Parent = maxPriceInput

-- Wait for gift acceptance toggle

local waitAcceptLabel = Instance.new("TextLabel")

waitAcceptLabel.Name = "WaitAcceptLabel"

waitAcceptLabel.Size = UDim2.new(0.6, 0, 0, 25)

waitAcceptLabel.Position = UDim2.new(0.05, 0, 0, 145)

waitAcceptLabel.BackgroundTransparency = 1

waitAcceptLabel.Text = "Wait for Accept:"

waitAcceptLabel.TextColor3 = Color3.fromRGB(220, 220, 255)

waitAcceptLabel.TextXAlignment = Enum.TextXAlignment.Left

waitAcceptLabel.Font = Enum.Font.Gotham

waitAcceptLabel.TextSize = 14

waitAcceptLabel.Parent = giftFrame

-- Toggle button for wait for acceptance

local waitAcceptToggle = Instance.new("TextButton")

waitAcceptToggle.Name = "WaitAcceptToggle"

waitAcceptToggle.Size = UDim2.new(0.3, 0, 0, 25)

waitAcceptToggle.Position = UDim2.new(0.65, 0, 0, 145)

waitAcceptToggle.BackgroundColor3 = Color3.fromRGB(60, 60, 85)

waitAcceptToggle.BorderSizePixel = 0

waitAcceptToggle.Text = "OFF"

waitAcceptToggle.TextColor3 = Color3.fromRGB(255, 255, 255)

waitAcceptToggle.Font = Enum.Font.GothamBold

waitAcceptToggle.TextSize = 14

waitAcceptToggle.Parent = giftFrame

-- Toggle button corner radius

local waitToggleCorner = Instance.new("UICorner")

waitToggleCorner.CornerRadius = UDim.new(0, 6)

waitToggleCorner.Parent = waitAcceptToggle

-- Auto gift toggle section

local autoGiftLabel = Instance.new("TextLabel")

autoGiftLabel.Name = "AutoGiftLabel"

autoGiftLabel.Size = UDim2.new(0.6, 0, 0, 25)

autoGiftLabel.Position = UDim2.new(0.05, 0, 0, 180)

autoGiftLabel.BackgroundTransparency = 1

autoGiftLabel.Text = "Auto Gift:"

autoGiftLabel.TextColor3 = Color3.fromRGB(220, 220, 255)

autoGiftLabel.TextXAlignment = Enum.TextXAlignment.Left

autoGiftLabel.Font = Enum.Font.Gotham

autoGiftLabel.TextSize = 14

autoGiftLabel.Parent = giftFrame

-- Toggle button for auto gift

local autoGiftToggle = Instance.new("TextButton")

autoGiftToggle.Name = "AutoGiftToggle"

autoGiftToggle.Size = UDim2.new(0.3, 0, 0, 25)

autoGiftToggle.Position = UDim2.new(0.65, 0, 0, 180)

autoGiftToggle.BackgroundColor3 = Color3.fromRGB(60, 60, 85)

autoGiftToggle.BorderSizePixel = 0

autoGiftToggle.Text = "OFF"

autoGiftToggle.TextColor3 = Color3.fromRGB(255, 255, 255)

autoGiftToggle.Font = Enum.Font.GothamBold

autoGiftToggle.TextSize = 14

autoGiftToggle.Parent = giftFrame

-- Toggle button corner radius

local toggleCorner = Instance.new("UICorner")

toggleCorner.CornerRadius = UDim.new(0, 6)

toggleCorner.Parent = autoGiftToggle

-- Buttons row

local setButton = Instance.new("TextButton")

setButton.Name = "SetButton"

setButton.Size = UDim2.new(0.45, 0, 0, 30)

setButton.Position = UDim2.new(0.05, 0, 0, 215)

setButton.BackgroundColor3 = Color3.fromRGB(80, 170, 100)

setButton.BorderSizePixel = 0

setButton.Text = "Set Values"

setButton.TextColor3 = Color3.fromRGB(255, 255, 255)

setButton.Font = Enum.Font.GothamBold

setButton.TextSize = 14

setButton.Parent = giftFrame

-- Button corner radius

local setCorner = Instance.new("UICorner")

setCorner.CornerRadius = UDim.new(0, 6)

setCorner.Parent = setButton

local giftButton = Instance.new("TextButton")

giftButton.Name = "GiftButton"

giftButton.Size = UDim2.new(0.45, 0, 0, 30)

giftButton.Position = UDim2.new(0.5, 0, 0, 215)

giftButton.BackgroundColor3 = Color3.fromRGB(130, 80, 170)

giftButton.BorderSizePixel = 0

giftButton.Text = "Send Gift"

giftButton.TextColor3 = Color3.fromRGB(255, 255, 255)

giftButton.Font = Enum.Font.GothamBold

giftButton.TextSize = 14

giftButton.Parent = giftFrame

-- Button corner radius

local giftCorner = Instance.new("UICorner")

giftCorner.CornerRadius = UDim.new(0, 6)

giftCorner.Parent = giftButton

-- Make GUI draggable

local dragging = false

local dragInput

local dragStart

local startPos

titleBar.InputBegan:Connect(function(input)

if input.UserInputType == Enum.UserInputType.MouseButton1 or input.UserInputType == Enum.UserInputType.Touch then

dragging = true

dragStart = input.Position

startPos = giftFrame.Position

input.Changed:Connect(function()

if input.UserInputState == Enum.UserInputState.End then

dragging = false

end

end)

end

end)

titleBar.InputChanged:Connect(function(input)

if input.UserInputType == Enum.UserInputType.MouseMovement or input.UserInputType == Enum.UserInputType.Touch then

dragInput = input

end

end)

game:GetService("UserInputService").InputChanged:Connect(function(input)

if input == dragInput and dragging then

local delta = input.Position - dragStart

giftFrame.Position = UDim2.new(

startPos.X.Scale,

startPos.X.Offset + delta.X,

startPos.Y.Scale,

startPos.Y.Offset + delta.Y

)

end

end)

-- Wait for acceptance toggle functionality

waitAcceptToggle.MouseButton1Click:Connect(function()

WAIT_FOR_GIFT_ACCEPTANCE = not WAIT_FOR_GIFT_ACCEPTANCE

if WAIT_FOR_GIFT_ACCEPTANCE then

waitAcceptToggle.Text = "ON"

waitAcceptToggle.BackgroundColor3 = Color3.fromRGB(80, 170, 100) -- Green

else

waitAcceptToggle.Text = "OFF"

waitAcceptToggle.BackgroundColor3 = Color3.fromRGB(60, 60, 85) -- Default

end

end)

-- Auto gift toggle functionality

autoGiftToggle.MouseButton1Click:Connect(function()

isAutoGiftEnabled = not isAutoGiftEnabled

if isAutoGiftEnabled then

autoGiftToggle.Text = "ON"

autoGiftToggle.BackgroundColor3 = Color3.fromRGB(80, 170, 100) -- Green

-- Start auto gift thread

if not autoGiftThread then

autoGiftThread = spawn(function()

while isAutoGiftEnabled do

-- Only gift if the button is not already in "Gifting..." state

if giftButton.Text == "Send Gift" then

GiftFruitToNearestPlayer()

end

-- Wait until gifting is complete

while giftButton.Text == "Gifting..." and isAutoGiftEnabled do

task.wait(1)

end

-- Wait between gift attempts

task.wait(5)

end

autoGiftThread = nil

end)

end

else

autoGiftToggle.Text = "OFF"

autoGiftToggle.BackgroundColor3 = Color3.fromRGB(60, 60, 85) -- Default

-- Stop auto gift thread

if autoGiftThread then

task.cancel(autoGiftThread)

autoGiftThread = nil

end

end)

-- Set button functionality

setButton.MouseButton1Click:Connect(function()

-- Update Gift Amount value

local giftAmount = tonumber(giftAmountInput.Text)

if giftAmount and giftAmount > 0 and giftAmount <= 1000 then

GIFT_FRUIT_AMOUNT = giftAmount

else

giftAmountInput.Text = tostring(GIFT_FRUIT_AMOUNT)

end

-- Update Min Price value (convert from billions to actual value)

local minPriceValue = tonumber(minPriceInput.Text)

if minPriceValue and minPriceValue > 0 then

MIN_FRUIT_VALUE_TO_GIFT = minPriceValue * 1e9 -- Convert billions to actual value

else

minPriceInput.Text = tostring(MIN_FRUIT_VALUE_TO_GIFT / 1e9)

end

-- Update Max Price value (convert from billions to actual value)

local maxPriceValue = tonumber(maxPriceInput.Text)

if maxPriceValue and maxPriceValue > minPriceValue then

MAX_FRUIT_VALUE_TO_GIFT = maxPriceValue * 1e9 -- Convert billions to actual value

else

maxPriceInput.Text = tostring(MAX_FRUIT_VALUE_TO_GIFT / 1e9)

end

-- Update GUI

giftAmountInput.Text = tostring(GIFT_FRUIT_AMOUNT)

minPriceInput.Text = tostring(MIN_FRUIT_VALUE_TO_GIFT / 1e9)

maxPriceInput.Text = tostring(MAX_FRUIT_VALUE_TO_GIFT / 1e9)

-- Notification

print("Values set: Gift Amount = " .. GIFT_FRUIT_AMOUNT ..

", Min Price = " .. formatNumber(MIN_FRUIT_VALUE_TO_GIFT) ..

", Max Price = " .. formatNumber(MAX_FRUIT_VALUE_TO_GIFT))

end)

-- Gift button functionality

giftButton.MouseButton1Click:Connect(function()

GiftFruitToNearestPlayer()

end)

-- Function to gift fruits to nearest player

function GiftFruitToNearestPlayer()

-- Prevent multiple runs

if giftButton.Text ~= "Send Gift" then return end

-- Update button state

giftButton.Text = "Gifting..."

giftButton.BackgroundColor3 = Color3.fromRGB(100, 50, 130)

spawn(function()

pcall(function()

-- Find the nearest player

local nearestPlayer = nil

local shortestDistance = math.huge

local character = player.Character

if not character then

print("Character not found!")

giftButton.Text = "Send Gift"

giftButton.BackgroundColor3 = Color3.fromRGB(130, 80, 170)

return

end

local rootPart = character:FindFirstChild("HumanoidRootPart")

if not rootPart then

print("HumanoidRootPart not found!")

giftButton.Text = "Send Gift"

giftButton.BackgroundColor3 = Color3.fromRGB(130, 80, 170)

return

end

for _, otherPlayer in pairs(Players:GetPlayers()) do

if otherPlayer ~= player and otherPlayer.Character then

local otherRootPart = otherPlayer.Character:FindFirstChild("HumanoidRootPart")

if otherRootPart then

local distance = (rootPart.Position - otherRootPart.Position).Magnitude

if distance < shortestDistance then

shortestDistance = distance

nearestPlayer = otherPlayer

end

if not nearestPlayer then

print("No players found nearby to gift to!")

giftButton.Text = "Send Gift"

giftButton.BackgroundColor3 = Color3.fromRGB(130, 80, 170)

return

end

print("Gifting to nearest player: " .. nearestPlayer.Name)

-- Get player data

local DataService = require(ReplicatedStorage.Modules.DataService)

local playerData = DataService:GetData()

if not playerData or not playerData.InventoryData then

print("Player data not found!")

giftButton.Text = "Send Gift"

giftButton.BackgroundColor3 = Color3.fromRGB(130, 80, 170)

return

end

-- Find fruits within value range

local validFruits = {}

for uuid, itemData in pairs(playerData.InventoryData) do

if itemData.ItemType == "Holdable" and itemData.ItemData then

-- Find the tool

local tool = nil

for _, t in pairs(player.Backpack:GetChildren()) do

if t:IsA("Tool") and t:GetAttribute("ITEM_UUID") == uuid then

tool = t

break

end

-- If tool is found, calculate its value

if tool and tool:GetAttribute("ItemType") ~= "Pet" then

-- Calculate the item's value

local itemValue = CalculatePlantValue(tool)

-- Add to the list if within value range

if itemValue >= MIN_FRUIT_VALUE_TO_GIFT and itemValue <= MAX_FRUIT_VALUE_TO_GIFT then

table.insert(validFruits, {

tool = tool,

value = itemValue,

uuid = uuid,

isFavorite = itemData.ItemData.IsFavorite or false

})

end

-- Sort by value (highest first)

table.sort(validFruits, function(a, b)

return a.value > b.value

end)

-- Gift each fruit one by one (make sure they have different UUIDs)

local giftsToSend = {}

local uniqueUUIDs = {}

-- Filter for unique UUIDs

for _, fruitData in ipairs(validFruits) do

if not uniqueUUIDs[fruitData.uuid] then

uniqueUUIDs[fruitData.uuid] = true

table.insert(giftsToSend, fruitData)

if #giftsToSend >= GIFT_FRUIT_AMOUNT then

break

end

if #giftsToSend == 0 then

print("No fruits found within value range to gift!")

giftButton.Text = "Send Gift"

giftButton.BackgroundColor3 = Color3.fromRGB(130, 80, 170)

return

end

-- Gift each fruit one by one

print("Gifting " .. #giftsToSend .. " fruits...")

local giftsCompleted = 0

for i, fruitData in ipairs(giftsToSend) do

-- Unequip any current tool

for _, tool in pairs(character:GetChildren()) do

if tool:IsA("Tool") then

tool.Parent = player.Backpack

end

task.wait(0.5)

-- Equip the fruit

local favoriteStatus = fruitData.isFavorite and " [⭐]" or ""

print("Gifting #" .. i .. ": " .. fruitData.tool.Name .. favoriteStatus ..

" - Value: " .. formatNumber(fruitData.value))

fruitData.tool.Parent = character

task.wait(0.5) -- Wait longer after equipping

-- Find and trigger proximity prompts on target player

local giftSuccess = false

if nearestPlayer.Character then

local targetHRP = nearestPlayer.Character:FindFirstChild("HumanoidRootPart")

if targetHRP then

for _, obj in pairs(targetHRP:GetChildren()) do

if obj:IsA("ProximityPrompt") and obj.Enabled then

-- Trigger the proximity prompt

fireproximityprompt(obj)

-- If waiting for acceptance is enabled, actively wait until item is gone

if WAIT_FOR_GIFT_ACCEPTANCE then

local waitStartTime = tick()

local maxWaitTime = 15 -- Maximum wait time in seconds

-- Update status in GUI

giftButton.Text = "Waiting..."

-- Wait loop - check every 1 second if tool is gone

while tick() - waitStartTime < maxWaitTime do

-- Check if tool is gone (gift succeeded)

if not fruitData.tool:IsDescendantOf(game) then

print("Successfully gifted: " .. fruitData.tool.Name)

giftSuccess = true

giftsCompleted = giftsCompleted + 1

break

end

-- Short wait between checks

task.wait(1)

end

-- Update status back

giftButton.Text = "Gifting..."

else

-- Fixed wait time from the original working code

task.wait(1)

-- Check if tool is gone (gift succeeded)

if not fruitData.tool:IsDescendantOf(game) then

print("Successfully gifted: " .. fruitData.tool.Name)

giftSuccess = true

giftsCompleted = giftsCompleted + 1

end

if giftSuccess then break end

end

-- Return to backpack if still in character and gift failed

if not giftSuccess and character:FindFirstChild(fruitData.tool.Name) then

print("Failed to gift: " .. fruitData.tool.Name)

fruitData.tool.Parent = player.Backpack

end

task.wait(0.3)

end

print("Gifting complete! Successfully gifted " .. giftsCompleted ..

" out of " .. #giftsToSend .. " fruits.")

end)

-- Ensure button is reset in case of error

giftButton.Text = "Send Gift"

giftButton.BackgroundColor3 = Color3.fromRGB(130, 80, 170)

end)

end