Autofarm luck potion

 player = :().LocalPlayer
  = :()
 replicatedStorage = :()
 proximityService = :()
 pathfindingService = :()
 runService = :()

 CHECK_INTERVAL = 
 RAPID_INTERVAL = 
 USE_EXECUTOR_FIRE = 
 WALK_STOP_DISTANCE = 
 WALK_TIMEOUT = 
 BLACKLIST_DURATION = 
 STUCK_DETECTION_TIME = 

 USE_INTERVAL = 
 USE_CLICK_SIMULATION = 
 USE_REMOTE_FALLBACK = 

 COLLECT_ITEMS = 
 ITEM_COLLECT_RADIUS = 
 ITEM_COOLDOWN = 
 ITEM_FAIL_COOLDOWN = 

 TELEPORT_THRESHOLD = 

 isInTeleportMode = 
 TELEPORT_FOLLOW_DURATION = 

 promptBlacklist = {}
 itemCooldown = {}
 lastRootPosition = 

  (prompt)
     untilTime = promptBlacklist[prompt]
     untilTime  untilTime > .()


  (prompt, duration)
    promptBlacklist[prompt] = .() + duration


  (item)
     untilTime = itemCooldown[item]
     untilTime  untilTime > .()


  (item, duration)
    itemCooldown[item] = .() + duration


  ()
     character = player.Character
      character    
     humanoid = character:()
      humanoid    
     seatPart = humanoid.SeatPart
     seatPart  seatPart:()


  (start, target)
     path
     success = (()
        path = pathfindingService:({
            AgentRadius = ,
            AgentHeight = ,
            AgentCanJump = ,
            Costs = { Water =  }
        })
        path:(start, target)
    )
      success   path  path.Status == .PathStatus.NoPath 
         
    

     waypoints = path:()
     #waypoints ==     

     smoothed = { waypoints[] }
     lastKeptIndex = 
     i = , #waypoints -  
         from = waypoints[lastKeptIndex].Position
         to = waypoints[i + ].Position
         raycastParams = RaycastParams.()
        raycastParams.FilterType = .RaycastFilterType.Blacklist
        raycastParams.FilterDescendantsInstances = {player.Character, :()}
         result = :(from, (to - from).Unit * (to - from).Magnitude, raycastParams)
         result 
            .(smoothed, waypoints[i])
            lastKeptIndex = i
        
    
    .(smoothed, waypoints[#waypoints])
     smoothed


  (targetPart, stopDistance, targetIdentifier)
      targetPart   targetPart:() 
         
    

     character = player.Character
      character 
        character = player.CharacterAdded:()
    
     humanoid = character:()
     rootPart = character:()

     (rootPart.Position - targetPart.Position).Magnitude <= stopDistance 
         
    

     startTime = .()
     lastPosition = rootPart.Position
     stuckStart = 

     .() - startTime < WALK_TIMEOUT 
         currentPos = rootPart.Position
         distanceMoved = (currentPos - lastPosition).Magnitude
         isClimbing = humanoid:() == .HumanoidStateType.Climbing

         distanceMoved <   isClimbing 
              stuckStart 
                stuckStart = .()
             .() - stuckStart >= STUCK_DETECTION_TIME 
                (, STUCK_DETECTION_TIME, , targetIdentifier  targetPart:())
                 
            
        
            stuckStart = 
        
        lastPosition = currentPos

         waypoints = (rootPart.Position, targetPart.Position)
          waypoints 
            .()
            
        

         _, waypoint  (waypoints) 
            humanoid:(waypoint.Position)
             arrived = humanoid.MoveToFinished:()
              arrived 
                
            
        

         (rootPart.Position - targetPart.Position).Magnitude <= stopDistance 
             
        

        .()
    

    (, targetIdentifier  targetPart:())
     


  (prompt)
      prompt   prompt:()   prompt.Enabled 
         
    

     USE_EXECUTOR_FIRE   
        (, prompt)
    
        (proximityService.FirePrompt, proximityService, prompt, player)
    
     


  ()
     prompts = {}
     drop = :()
     drop 
         _, crate  (drop:()) 
             center = crate:()
             center 
                 prompt = center:()
                 prompt  prompt:()  prompt.Enabled 
                    .(prompts, prompt)
                
            
        
    
     prompts


  ()
     items = {}
     droppedFolder = :()
     droppedFolder 
         _, item  (droppedFolder:()) 
             item:()  item.Transparency <  
                .(items, item)
            
        
    
     items


  (duration)
     startTime = .()
     .() - startTime < duration 
         players = :():()
         otherPlayers = {}
         _, p  (players) 
             p ~= player 
                .(otherPlayers, p)
            
        
         #otherPlayers ==  
            ()
            
        

         target = otherPlayers[.(, #otherPlayers)]
        (, target.Name, )

         followStart = .()
         .() - followStart <   .() - startTime < duration 
             targetChar = target.Character
              targetChar   
             targetRoot = targetChar:()
              targetRoot   

             character = player.Character
              character   
             humanoid = character:()
             rootPart = character:()
              humanoid   rootPart   

             waypoints = (rootPart.Position, targetRoot.Position)
             waypoints 
                 _, waypoint  (waypoints) 
                     .() - startTime >= duration   
                    humanoid:(waypoint.Position)
                     arrived = humanoid.MoveToFinished:()
                      arrived   
                
            
            .()
        
    
    ()


  ()
     isInTeleportMode   
    isInTeleportMode = 
    .(()
        (TELEPORT_FOLLOW_DURATION)
        isInTeleportMode = 
    )


.(()
      
         isInTeleportMode 
            .(RAPID_INTERVAL)
            
        
         prompt2 = :() 
                        .Chest:() 
                        .Chest.PositionA:() 
                        .Chest.PositionA.Lock:()
         prompt2  prompt2.Enabled   (prompt2) 
            (prompt2)
        
        .(RAPID_INTERVAL)
    
)

.(()
      
         isInTeleportMode 
            .(CHECK_INTERVAL)
            
        
         prompts1 = ()
         #prompts1 >  
             character = player.Character
             rootPart = character  character:()
             rootPart 
                 currentPos = rootPart.Position
                 lastRootPosition  (currentPos - lastRootPosition).Magnitude > TELEPORT_THRESHOLD 
                    ()
                    ()
                
                lastRootPosition = currentPos

                 inVehicle = ()
                 validPrompts = {}
                 _, p  (prompts1) 
                      (p) 
                        .(validPrompts, p)
                    
                
                .(validPrompts, (a, b)
                     distA = (a.Parent.Position - rootPart.Position).Magnitude
                     distB = (b.Parent.Position - rootPart.Position).Magnitude
                     distA < distB
                )

                 _, prompt  (validPrompts) 
                     prompt  prompt.Enabled   (prompt) 
                         targetPart = prompt.Parent
                         targetPart  targetPart:() 
                             dist = (targetPart.Position - rootPart.Position).Magnitude
                             inVehicle 
                                 dist <= (prompt.MaxActivationDistance  ) 
                                    (prompt)
                                
                            
                                 success = (targetPart, WALK_STOP_DISTANCE, )
                                 success 
                                    (prompt)
                                    .()
                                
                                    (prompt, BLACKLIST_DURATION)
                                
                            
                        
                    
                
            
                ()
            
        
        .(CHECK_INTERVAL)
    
)

()

 potionTool = replicatedStorage:() 
                  replicatedStorage.AirdropSystem:() 
                  replicatedStorage.AirdropSystem.Tools:()
 useRemote = potionTool  potionTool:()

  potionTool 
    ()

    ()

      ()
         character = player.Character
          character 
            character = player.CharacterAdded:()
        
         humanoid = character:()
          humanoid   

         toolInCharacter = character:()
          toolInCharacter 
             backpack = player:()
             backpack 
                 toolInBackpack = backpack:()
                 toolInBackpack 
                    toolInBackpack.Parent = character
                    toolInCharacter = character:(, )
                
            
        

          toolInCharacter 
            ()
            
        

         humanoid:() ~= toolInCharacter 
            humanoid:(toolInCharacter)
        

         USE_CLICK_SIMULATION 
            (()
                toolInCharacter:()
                ()
            )
        

         USE_REMOTE_FALLBACK  useRemote 
             useRemote:() 
                (()
                    useRemote:()
                    ()
                )
             useRemote:() 
                (()
                     result = useRemote:()
                    (, result)
                )
            
        
    

    .(()
          
             isInTeleportMode 
                .(USE_INTERVAL)
                
            
            ()
            .(USE_INTERVAL)
        
    )

    ()


 COLLECT_ITEMS 
    .(()
          
             isInTeleportMode 
                .(CHECK_INTERVAL)
                
            
             items = ()
             now = .()
             _, item  (items) 
                 item  item.Parent   (item) 
                     success = (item, ITEM_COLLECT_RADIUS, )
                     success 
                        (item, ITEM_COOLDOWN)
                    
                        (item, ITEM_FAIL_COOLDOWN)
                    
                
            
            .(CHECK_INTERVAL)
        
    )
    ()