Open Source

 ().AutoPoopCleanup 
    (().AutoPoopCleanup)
    ().AutoPoopCleanup = 


 ().AutoPoopLibrary 
    (()
        ().AutoPoopLibrary:()
    )
    ().AutoPoopLibrary = 


 libraryUrl = 

 success, Library = (()
     (:(libraryUrl))()
)

  success   Library 
    


().AutoPoopLibrary = Library

 ReplicatedStorage = :()
 Players = :()
 GuiService = :()
 RunService = :()
 VirtualInputManager = :()

 LocalPlayer = Players.LocalPlayer
 PlayerScripts = LocalPlayer:()
 PlayerGui = LocalPlayer:()

 Packets = (ReplicatedStorage:())
 minigameActive = PlayerScripts:()

 okFood, FoodData = (, ReplicatedStorage:())
 okMoney, FormatMoney = (, ReplicatedStorage:())

 PoopUI = PlayerGui:()
 lineTrigger = PoopUI:():()
 slider = PoopUI.CatchBar:():()
 target = slider:()

 BACKPACK_LIMIT = 

 state = {
    running = ,
    notifications = {},
    remotePoop = ,
    legitPoop = ,
    instantLine = ,
    remoteDelay = ,
    pause = ,
    cycles = ,
    autoSell = ,
    sellMode = ,
    sellValue = ,
    sellAction = ,
    sellOneMode = ,
    lastSell = .(),
    autoBuy = ,
    buyInterval = ,
    selectedFoods = {},
    stock = {},
}

 connections = {}

  (minValue, maxValue)
     minValue + .() * (maxValue - minValue)


  (value)
     okMoney  (value) ==  
         ok, text = (FormatMoney, value, )
         ok 
             text
        
    
     (value)


  (tool)
     tool:()  tool.Name:(, ) == 


  ()
     list = {}
     _, tool  (LocalPlayer.Backpack:()) 
         (tool) 
            .(list, tool)
        
    
     character = LocalPlayer.Character
     held = character  character:()
     held  (held) 
        .(list, held)
    
     list


  ()
     #LocalPlayer.Backpack:()


  (tool)
     (tool.Name:())  


 CLICK_LATENCY = 

 lastCenter = 
 lastTime = .()

  ()
     now = .()
     center = lineTrigger.AbsolutePosition.X + lineTrigger.AbsoluteSize.X / 
     elapsed = .(now - lastTime,  / )
     velocity = (center - lastCenter) / elapsed
    lastCenter = center
    lastTime = now
     predicted = center + velocity * CLICK_LATENCY
     margin = lineTrigger.AbsoluteSize.X * 
     left = target.AbsolutePosition.X
     left - margin < predicted  predicted < left + target.AbsoluteSize.X + margin


  (position, down)
    VirtualInputManager:(position.X, position.Y, , down, , )


 CLICK_SPOTS = {}

 _, x  ({ , , ,  }) 
     _, y  ({ , , , ,  }) 
        .(CLICK_SPOTS, .(x, y))
    


  (point)
     inset = GuiService:()
     _, gui  (PlayerGui:(point.X - inset.X, point.Y - inset.Y)) 
          gui:(PoopUI)  (gui:()  gui.Active) 
             
        
    
     


  ()
     size = .CurrentCamera.ViewportSize
     _, spot  (CLICK_SPOTS) 
         point = size * spot
         (point) 
             point
        
    
     


  ()
     position = ()
      position 
        
    
    (position, )
    .()
    (position, )


  ()
     chargeUi = :()
     bar = chargeUi  chargeUi:(, )
     bar  bar:()


  ()
     position = ()
      position 
        .()
        
    
    (position, )
     startTime = .()
     fill
    
        .()
        fill = ()
     fill  .() - startTime > 
     .() - startTime <  
         fill  fill.Parent  fill.Size.Y.Scale >=  
            
        
          fill  .() - startTime >=  
            
        
        .()
    
    (position, )


 targetAspect = target:()
 defaultAspectRatio = targetAspect  targetAspect.AspectRatio
 WIDE_ASPECT_RATIO = 

  ()
     lineCenter = lineTrigger.AbsolutePosition.X + lineTrigger.AbsoluteSize.X / 
     targetCenter = target.AbsolutePosition.X + target.AbsoluteSize.X / 
     position = slider.Position
    slider.Position = .(position.X.Scale, position.X.Offset + lineCenter - targetCenter, position.Y.Scale, position.Y.Offset)


  ()
     targetAspect 
        targetAspect.AspectRatio = WIDE_ASPECT_RATIO
    


  ()
     targetAspect 
        targetAspect.AspectRatio = defaultAspectRatio
    


  ()
      minigameActive.Value 
        ()
        .()
    
     deadline = .() + 
     state.running  minigameActive.Value  .() < deadline 
         state.instantLine 
            ()
            ()
            RunService.Heartbeat:()
            ()
            ()
            .((, ))
         () 
            ()
            .((, ))
        
        .()
    
    ()
    state.cycles += 
    .(state.pause * (, ))


  ()
    Packets.RequestPoop:()
    state.cycles += 
      = state.remoteDelay * (, )
     .() <  
         += (, )
    
    .()


  (mode)
     poops = ()
     #poops ==  
         
    
     mode ==  
         character = LocalPlayer.Character
         held = character  character:()
         held  (held)  held  
    
     mode ==   mode ==  
        .(poops, (a, b)
             mode ==  
                 (a) < (b)
            
             (a) > (b)
        )
    
     poops[]


  (mode)
     tool = (mode)
     uuid = tool  tool:()
      uuid 
         
    
     ok, result = (()
         Packets.SellCurrentlyHeldPoop:(uuid)
    )
     ok 
        Library:( .. (result), )
    
     ok


  ()
     ok, result = (()
         Packets.SellInventory:()
    )
     ok 
        state.lastSell = .()
        Library:( .. (result), )
    
     ok


  ()
     state.sellAction ==  
         (state.sellOneMode ==     state.sellOneMode)
    
     ()


  ()
    (()
        Packets.FoodStock:()
    )


  (name)
    (()
        Packets.PurchaseFood:(name)
    )


  ()
     names = {}
     okFood  (FoodData) ==  
         name  (FoodData) 
            .(names, name)
        
        .(names, (a, b)
             FoodData[a].Price < FoodData[b].Price
        )
    
     names


  ()
     names = {}
     name  (state.stock) 
        .(names, name)
    
    .(names)
     #names >   .(names, )  


.(connections, Packets.FoodStock.OnClientEvent:((list)
    state.stock = {}
     (list) ==  
         _, name  (list) 
            state.stock[name] = 
        
    
))

.(connections, Packets.PurchaseFood.OnClientEvent:((purchased, name)
     purchased 
        state.stock[name] = 
        .(state.notifications,  .. (name))
    
))

.(()
     state.running 
         hasSpace = () < BACKPACK_LIMIT
         cycle = 
         hasSpace  state.remotePoop 
            cycle = runRemoteCycle
         state.legitPoop  (hasSpace  minigameActive.Value) 
            cycle = runLegitCycle
        
         cycle 
             ok = (cycle)
              ok 
                .()
            
        
            .()
        
    
)

.(()
     state.running 
         state.autoSell 
             state.sellMode ==  
                 .() - state.lastSell >= state.sellValue 
                    state.lastSell = .()
                    ()
                
             #() >= state.sellValue 
                ()
                .()
            
        
        .()
    
)

.(()
     state.running 
         text = .(state.notifications, )
         text 
            Library:(text, )
        
        .()
    
)

 lastBuyCheck = 

.(()
     state.running 
         due = .() - lastBuyCheck >= state.buyInterval
         state.autoBuy  due  (state.selectedFoods) 
            lastBuyCheck = .()
            ()
            .()
             name  (state.selectedFoods) 
                 state.stock[name] 
                    (name)
                    .((, ))
                
            
        
        .()
    
)

 Window = Library:({
    Title = ,
    Footer = ,
    Icon = ,
    NotifySide = ,
    Center = ,
    AutoShow = ,
    ToggleKeybind = .KeyCode.RightControl,
    Folder = ,
})

  (Tab)
     Box = Tab:({
        Side = ,
        Name = ,
        IconName = ,
    })

    Box:(, {
        Text = ,
        Default = ,
        Tooltip = ,
        Callback = (value)
            state.remotePoop = value
             value  Library.Toggles.LegitPoopToggle.Value 
                Library.Toggles.LegitPoopToggle:()
            
        ,
    })

    Box:(, {
        Text = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = ,
        Suffix = ,
        Tooltip = ,
        Callback = (value)
            state.remoteDelay = value
        ,
    })

    Box:()

    Box:(, {
        Text = ,
        Default = ,
        Tooltip = ,
        Callback = (value)
            state.legitPoop = value
             value  Library.Toggles.RemotePoopToggle.Value 
                Library.Toggles.RemotePoopToggle:()
            
        ,
    })

    Box:(, {
        Text = ,
        Default = ,
        Tooltip = ,
        Callback = (value)
            state.instantLine = value
        ,
    })

    Box:(, {
        Text = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = ,
        Suffix = ,
        Callback = (value)
            state.pause = value
        ,
    })

     Info = Tab:({
        Side = ,
        Name = ,
        IconName = ,
    })

     statusLabel = Info:()
     cycleLabel = Info:()
     sizeLabel = Info:( .. BACKPACK_LIMIT)

    .(()
         state.running 
            statusLabel:( .. #())
            cycleLabel:( .. state.cycles)
            sizeLabel:(():((), BACKPACK_LIMIT))
            .()
        
    )


  (Tab)
     Manual = Tab:({
        Side = ,
        Name = ,
        IconName = ,
    })

    Manual:({
        Text = ,
        Func = sellAll,
    })

    Manual:(, {
        Text = ,
        Values = { , , ,  },
        Default = ,
        Callback = (value)
            state.sellOneMode = value
        ,
    })

    Manual:({
        Text = ,
        Func = ()
              (state.sellOneMode) 
                Library:(, )
            
        ,
    })

     Auto = Tab:({
        Side = ,
        Name = ,
        IconName = ,
    })

    Auto:(, {
        Text = ,
        Default = ,
        Callback = (value)
            state.autoSell = value
            state.lastSell = .()
        ,
    })

    Auto:(, {
        Text = ,
        Values = { ,  },
        Default = ,
        Callback = (value)
            state.sellMode = value
        ,
    })

    Auto:(, {
        Text = ,
        Default = ,
        Numeric = ,
        Finished = ,
        Placeholder = ,
        Callback = (value)
            state.sellValue = .((value)  , )
        ,
    })

    Auto:(, {
        Text = ,
        Values = { ,  },
        Default = ,
        Callback = (value)
            state.sellAction = value
        ,
    })

    Auto:({
        Text = ,
        DoesWrap = ,
    })


  (Tab)
     Buy = Tab:({
        Side = ,
        Name = ,
        IconName = ,
    })

    Buy:(, {
        Text = ,
        Values = (),
        Default = {},
        Multi = ,
        AllowNull = ,
        SelectAllButtons = ,
        Callback = (values)
            state.selectedFoods = {}
             name, enabled  (values) 
                 enabled 
                    state.selectedFoods[name] = 
                
            
        ,
    })

    Buy:({
        Text = ,
        Func = ()
            ()
            .()
             name  (state.selectedFoods) 
                 state.stock[name] 
                    (name)
                    .((, ))
                
                    Library:(name .. , )
                
            
        ,
    })

    Buy:({
        Text = ,
        Func = ()
            ()
            .()
             name  (state.stock) 
                (name)
                .((, ))
            
        ,
    })

     Auto = Tab:({
        Side = ,
        Name = ,
        IconName = ,
    })

    Auto:(, {
        Text = ,
        Default = ,
        Callback = (value)
            state.autoBuy = value
        ,
    })

    Auto:(, {
        Text = ,
        Default = ,
        Min = ,
        Max = ,
        Rounding = ,
        Suffix = ,
        Callback = (value)
            state.buyInterval = value
        ,
    })

     stockLabel = Auto:({
        Text = ,
        DoesWrap = ,
    })

    .(()
         state.running 
            stockLabel:( .. ())
            .()
        
    )

    ()


 Tabs = {
    Poop = Window:(, ),
    Sell = Window:(, ),
    Food = Window:(, ),
}

(Tabs.Poop)
(Tabs.Sell)
(Tabs.Food)

  ()
    state.running = 
    state.remotePoop = 
    state.legitPoop = 
    state.autoSell = 
    state.autoBuy = 
    ()
     _, connection  (connections) 
        connection:()
    
    connections = {}


().AutoPoopCleanup = cleanup
Library:(cleanup)