OPEN SOURCE AUTO STEAL

-- Execute again to disable/enable
getgenv().autoRob = not autoRob
if exists then
    return
end
getgenv().exists = true

local Mutations = require(game.ReplicatedStorage.Datas.Mutations)
function ApplyBrainrotDataMutation(data, mutationName)
    local mutationData = Mutations[mutationName]
    local mutationModifier = mutationData.Modifier
    data.Price += data.Price * mutationModifier
    data.Generation += data.Generation * mutationModifier
end

local Animals = require(game.ReplicatedStorage.Datas.Animals)
function GetPlotBrainrotData(plot, index)
    local brainrotSpawn = plot.AnimalPodiums[tostring(index)].Base.Spawn
    local attachment = brainrotSpawn:FindFirstChild('Attachment')
    if not attachment then
        return
    end

    local billboard = attachment.AnimalOverhead
    local displayName = billboard.DisplayName
    if not displayName.Visible then
        return
    end

    local mutationLabel = billboard.Mutation
    if not displayName then
        return
    end

    local data = table.clone(Animals[displayName.Text])
    if mutationLabel.Visible then
        local mutation = mutationLabel.Text
        data.Mutation = mutation
        ApplyBrainrotDataMutation(data, mutation)
    end

    return data
end

function IsPlotOpen(plot)
    for i, v in plot.LaserHitbox:GetChildren() do
        if not v.CanCollide then
            return true
        end
    end

    return false
end

local Plots = workspace.Plots
local clientPlot
for i, v in Plots:GetChildren() do
    if v.PlotSign.YourBase.Enabled then
        clientPlot = v
        break
    end
end
function GetPlotsBestBrainrot()
    local bestData
    local bestPodium = nil
    local bestGeneration = 0
    local bestPath
    local bestStealPrompt
    for _, plot in Plots:GetChildren() do
        if plot == clientPlot then
            continue
        end
        if not IsPlotOpen(plot) then
            continue
        end

        for podiumIndex, podium in plot.AnimalPodiums:GetChildren() do
            local brainrotData = GetPlotBrainrotData(plot, podiumIndex)
            if not brainrotData then
                continue
            end

            local generation = brainrotData.Generation
            if generation > bestGeneration then
                local path, stealPrompt = IsBrainrotStealable(podium)
                if not path then
                    continue
                end

                bestData = brainrotData
                bestPodium = podium
                bestGeneration = generation
                bestPath = path
                bestStealPrompt = stealPrompt
            end
        end
    end

    return bestData, bestPodium, bestPath, bestStealPrompt
end

local clientPlayer = game.Players.LocalPlayer
local PathfindingService = game:GetService('PathfindingService')
function GetPath(start, goal)
    local path = PathfindingService:CreatePath({
        AgentRadius = 3,
        AgentHeight = 6,
        AgentCanJump = false,
    })

    local success, errorMessage = pcall(path.ComputeAsync, path, start, goal)
    return success and path.Status == Enum.PathStatus.Success and path
end

function IsBrainrotStealable(podium)
    local start = clientPlayer.Character.HumanoidRootPart.Position
    local PromptAttachment = podium.Base.Spawn.PromptAttachment
    local goal = PromptAttachment.WorldCFrame.Position
    local path = GetPath(start, goal)
    if not path then
        return
    end

    local stealPrompt
    for i, v in PromptAttachment:GetChildren() do
        if v.ActionText == 'Steal' then
            stealPrompt = v
            break
        end
    end

    return path, stealPrompt
end

local part = Instance.new('Part', workspace)
part.Size = Vector3.one
part.Anchored = true
part.CanCollide = false
part.Material = 'Neon'
part.Shape = 'Ball'
function WalkPath(path)
    local character = clientPlayer.Character
    local root = character.HumanoidRootPart
    local humanoid = character.Humanoid
    for _, waypoint in path:GetWaypoints() do
        local goal = waypoint.Position
        part.Position = goal

        while autoRob and (root.Position - goal).magnitude > 5 do
            humanoid:MoveTo(goal)
            task.wait()
        end
    end
end

function StealBrainrot(podium, path, stealPrompt)
    WalkPath(path)

    print('Trying to steal brainrot.')
    stealPrompt:InputHoldBegin()
end

local deliveryGoal = clientPlot.DeliveryHitbox.Position
function DeliverBrainrot()
    local start = clientPlayer.Character.HumanoidRootPart.Position
    local path = GetPath(start, deliveryGoal)
    WalkPath(path)
end

function Loop()
    if clientPlayer:GetAttribute('Stealing') then
        DeliverBrainrot()
        return
    end

    local data, podium, path, stealPrompt = GetPlotsBestBrainrot()
    if not data then
        warn('No brainrots to steal.')
        return
    end
    if not path then
        warn('Brainrot found but not accessible.')
        return
    end

    warn('Steal target data:')
    table.foreach(data, print)

    StealBrainrot(podium, path, stealPrompt)
end

while true do
    if autoRob then
        Loop()
    end

    task.wait()
end