Wither dyton prop leak by Hendra

 Players = :()
 LP = Players.LocalPlayer
 RS = :()
 UIS = :()
 CoreGui = :()

 OwnerName = LP.Name
 petMode = 
 rampageMode = 
 wingRemoteCache = {}
 PERMANENT_PROP_LOCK = {}
 currentCFrames = {}
 lastNetworkUpdate = 
 lastColorUpdate = 
 lastScanTime = 
 colorIndex = 


 isSummoning = 
 summonStartTime = 
 summonOriginPos = .zero
 rampageBlacklist = {}
 targetAttackTrack = { player = , startTime = , initialPos = .zero }
 hasFetchedBall = 


 estimatedPing = 
 witherCurrentPos = .zero
 lastAttackTime = 
 activeProjectiles = {}
 lastLookAtPos = .zero




 WITHER_SPEED =          
 PROJECTILE_SPEED =     
 ATTACK_COOLDOWN =     
 HOVER_HEIGHT =         
 RANDOM_DRIFT_SCALE =    
 RAMPAGE_RADIUS =      

 SUMMON_DURATION =    
 IMPACT_LINGER_TIME =  
 MAX_STUCK_TIME =     


 PET_OFFSET = .(-, , ) 

 MANUAL_ROTATION = .(-, , )
 TargetPlayer = 


 COLORS = {
    AbyssRed = .(, , ),
    DarkAbyss = .(, , ),
    Void = .(, , ),
    Accent = .(, , ),
    SuccessGreen = .(, , ),
    WarningRed = .(, , ),

    PureWhiteOnly = .(, , ),
    SoulArmorWhite = .(, , ),
    SoulAuraBlue = .(, , )
}

  (t, offset)
     isSummoning 
         COLORS.PureWhiteOnly
     rampageMode 
         cycle = (t *  + (offset * )) % 
         cycle <   COLORS.SoulArmorWhite:(COLORS.SoulAuraBlue, cycle * )  COLORS.SoulAuraBlue:(COLORS.SoulArmorWhite, (cycle - ) * )
    
         cycle = (t *  + (offset * )) % 
         cycle <   COLORS.AbyssRed:(COLORS.DarkAbyss, cycle * )  COLORS.DarkAbyss:(COLORS.Void, (cycle - ) * )
    


  (base, target)  base:(target) 

 baseRef = .(, , -, -, , -, , , , , , -)

 WitherParts = {
    (baseRef, .(, , -, -, , -, , , , , , -)), 
    (baseRef, .(, , -, -, , , , , , -, , -)), 
    (baseRef, .(, , -, -, , -, -, , , , , -)), 
    (baseRef, .(, , -, , -, , -, -, -, , -, -)),
    (baseRef, .(, , -, -, -, , -, , , -, , -)),
    (baseRef, .(, , -, -, -, , -, , , -, , -)),
    (baseRef, .(, , -, -, -, , -, , , -, , -)),
    (baseRef, .(, , -, -, -, , -, , , -, , -)),
    (baseRef, .(, , -, -, -, , -, , , -, , -)),
    (baseRef, .(, , -, , -, , -, -, , -, -, -))
}

  ()
     b = LP.Backpack:()  (LP.Character  LP.Character:())

      b   hasFetchedBall 
        hasFetchedBall = 
        (()
            :().RE:():(, )
        )
    

     ballsFolder = :()  .WorkspaceCom:()
     ballsFolder 
         ball = ballsFolder:( .. LP.Name)
         ball 
            ball.CanCollide = 
             ball
        
    
     


  ()
     nearestPlayer = 
     shortestDistance = RAMPAGE_RADIUS
     myPos = witherCurrentPos

     _, p  (Players:()) 
         p ~= LP  Players:(p.Name)   rampageBlacklist[p.Name] 
             char = p.Character
             char 
                 hum = char:()
                 hum  hum.Health >    hum.Sit 
                     torso = char:()  char:()  char:()
                     torso 
                         dist = (myPos - torso.Position).Magnitude
                         dist < shortestDistance 
                            shortestDistance = dist
                            nearestPlayer = p
                        
                    
                
            
        
    
     nearestPlayer



 sg = .(, CoreGui)
sg.Name = 
 main = .(, sg)
main.Size, main.Position = .(, , , ), .(, , , )
main.BackgroundColor3, main.BorderSizePixel = .(, , ), 
main.ClipsDescendants = 

 titleBar = .(, main)
titleBar.Size, titleBar.BackgroundColor3 = .(, , , ), .(, , )
titleBar.BorderSizePixel = 

 titleLabel = .(, titleBar)
titleLabel.Size, titleLabel.Position = .(, -, , ), .(, , , )
titleLabel.BackgroundTransparency, titleLabel.Text = , 
titleLabel.TextColor3, titleLabel.Font, titleLabel.TextSize = .(, , ), .Font.SourceSansBold, 
titleLabel.TextXAlignment = .TextXAlignment.Left

 ballStatusLabel = .(, main)
ballStatusLabel.Size = .(, -, , )
ballStatusLabel.Position = .(, , , -)
ballStatusLabel.BackgroundTransparency = 
ballStatusLabel.Text = 
ballStatusLabel.TextColor3 = .(, , )
ballStatusLabel.Font = .Font.Code
ballStatusLabel.TextSize = 
ballStatusLabel.TextXAlignment = .TextXAlignment.Left

 creditLabel = .(, main)
creditLabel.Size, creditLabel.Position = .(, , , ), .(, , , -)
creditLabel.BackgroundTransparency, creditLabel.Text = , 
creditLabel.TextColor3, creditLabel.Font, creditLabel.TextSize = COLORS.Accent, .Font.Code, 

 dragging, dragStart, startPos
titleBar.InputBegan:((input)
     input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
        dragging, dragStart, startPos = , input.Position, main.Position
    
)
UIS.InputChanged:((input)
     dragging  (input.UserInputType == .UserInputType.MouseMovement  input.UserInputType == .UserInputType.Touch) 
         delta = input.Position - dragStart
        main.Position = .(startPos.X.Scale, startPos.X.Offset + delta.X, startPos.Y.Scale, startPos.Y.Offset + delta.Y)
    
)
UIS.InputEnded:((input)  input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch  dragging =   )

  (b)
    b.BackgroundColor3, b.BorderSizePixel, b.BorderColor3 = COLORS.Void, , .(, , )
    b.TextColor3, b.Font, b.TextSize = .(, , ), .Font.SourceSansBold, 
    b.MouseEnter:(() b.BorderColor3 = (rampageMode  COLORS.SoulAuraBlue  COLORS.Accent) b.TextColor3 = .(,,) )
    b.MouseLeave:(() b.BorderColor3 = .(, , ) b.TextColor3 = .(,,) )


 container = .(, main)
container.Size, container.Position, container.BackgroundTransparency = .(, -, , -), .(, , , ), 

  (txt, pos, size)
     b = .(, container)
    b.Text, b.Position, b.Size = txt, pos, size (b)
     b


 SummonBtn = (, .(,,,), .(,,,))

 TargetBox = .(, container)
TargetBox.Size = .(, , , )
TargetBox.Position = .(, , , )
TargetBox.BackgroundColor3 = .(, , )
TargetBox.BorderSizePixel = 
TargetBox.BorderColor3 = .(, , )
TargetBox.TextColor3 = .(, , )
TargetBox.PlaceholderText = 
TargetBox.PlaceholderColor3 = .(, , )
TargetBox.Font = .Font.Code
TargetBox.TextSize = 
TargetBox.ClearTextOnFocus = 

 RampageBtn = (, .(, , , ), .(, , , ))

TargetBox.FocusLost:((enterPressed)
     enterPressed 
         rampageMode   
         searchKey = TargetBox.Text:()
         searchKey ==  
            TargetPlayer = 
            TargetBox.Text = 
            TargetBox.BorderColor3 = .(, , )
            
        

         found = 
         _, p  (Players:()) 
             p.Name:():(searchKey)  p.DisplayName:():(searchKey) 
                TargetPlayer = p
                TargetBox.Text = p.DisplayName
                TargetBox.BorderColor3 = COLORS.SuccessGreen
                found = 
                
            
        

          found 
            TargetPlayer = 
            TargetBox.Text = 
            TargetBox.BorderColor3 = COLORS.WarningRed
            .()
            TargetBox.Text = 
            TargetBox.BorderColor3 = .(, , )
        
    
)

SummonBtn.MouseButton1Click:(()
    petMode =  petMode
     petMode 
        SummonBtn.TextColor3 = COLORS.Accent
        SummonBtn.Text = 
        hasFetchedBall = 

         char = LP.Character
         char  char:() 
            summonOriginPos = char.HumanoidRootPart.Position
            witherCurrentPos = summonOriginPos
            lastLookAtPos = summonOriginPos + .(, , -)
            isSummoning = 
            summonStartTime = ()
        

         p = :():()
         targetName = (OwnerName == )    ( .. OwnerName)

         rawProps = {}
         _, v  (p:()) 
             v.Name == targetName  .(rawProps, v) 
        

         id, storedProp  (PERMANENT_PROP_LOCK) 
              storedProp   storedProp.Parent  PERMANENT_PROP_LOCK[id] =  
        

         _, prop  (rawProps) 
             alreadyRegistered = 
             id, storedProp  (PERMANENT_PROP_LOCK) 
                 storedProp == prop  alreadyRegistered =   
            
              alreadyRegistered 
                 id = ,  
                      PERMANENT_PROP_LOCK[id] 
                        PERMANENT_PROP_LOCK[id] = prop
                        
                    
                
            
        

        wingRemoteCache = {}
         id = ,  
             PERMANENT_PROP_LOCK[id]  PERMANENT_PROP_LOCK[id].Parent 
                .(wingRemoteCache, PERMANENT_PROP_LOCK[id])
            
        
    
        SummonBtn.TextColor3 = .(,,)
        SummonBtn.Text = 
        rampageMode = 
        isSummoning = 
        hasFetchedBall = 
        RampageBtn.Text = 
        RampageBtn.TextColor3 = .(, , )
        TargetBox.Text = 
        TargetBox.BorderColor3 = .(, , )
        .(currentCFrames)
        .(activeProjectiles)
        .(rampageBlacklist)
    
)

RampageBtn.MouseButton1Click:(()
      petMode  isSummoning   
    rampageMode =  rampageMode
     rampageMode 
        .(rampageBlacklist)
        RampageBtn.Text = 
        RampageBtn.TextColor3 = COLORS.SoulAuraBlue
        TargetBox.Text = 
        TargetBox.BorderColor3 = COLORS.SoulAuraBlue
    
        rampageMode = 
        RampageBtn.Text = 
        RampageBtn.TextColor3 = .(, , )
        TargetPlayer = 
        TargetBox.Text = 
        TargetBox.BorderColor3 = .(, , )
    
)

  (player)
      player   player.Parent   Players:(player.Name)   player.Character    
     char = player.Character
     char:()  char:()  char:()



RS.Heartbeat:((dt)
     totalProps = #wingRemoteCache
      petMode  totalProps <    

     t = ()
     activeBall = ()
     flingActiveThisFrame = 

     _, proj  (activeProjectiles) 
         proj.IsStuck  flingActiveThisFrame =   
    

     isSummoning 
        ballStatusLabel.Text = 
        ballStatusLabel.TextColor3 = COLORS.PureWhiteOnly
      activeBall 
        ballStatusLabel.Text = 
        ballStatusLabel.TextColor3 = COLORS.WarningRed
     flingActiveThisFrame 
        ballStatusLabel.Text = 
        ballStatusLabel.TextColor3 = (rampageMode  COLORS.SoulAuraBlue  COLORS.Accent)
    
        ballStatusLabel.Text = rampageMode    
        ballStatusLabel.TextColor3 = rampageMode  COLORS.SoulAuraBlue  COLORS.SuccessGreen
    

     rampageMode   isSummoning 
         TargetPlayer 
             enemyChar = TargetPlayer.Character
             enemyHum = enemyChar  enemyChar:()
             enemyTorso = (TargetPlayer)

              enemyChar   enemyHum  enemyHum.Health <=   enemyHum.Sit  rampageBlacklist[TargetPlayer.Name]   Players:(TargetPlayer.Name) 
                TargetPlayer = 
             enemyTorso 
                 currentVelocity = enemyTorso.AssemblyLinearVelocity.Magnitude
                 distanceMoved = (enemyTorso.Position - targetAttackTrack.initialPos).Magnitude

                 currentVelocity >   (flingActiveThisFrame  distanceMoved > ) 
                    rampageBlacklist[TargetPlayer.Name] = 
                    TargetPlayer = 
                 t - targetAttackTrack.startTime > MAX_STUCK_TIME  distanceMoved <  
                    rampageBlacklist[TargetPlayer.Name] = 
                    TargetPlayer = 
                
            
        

         t - lastScanTime >  
            lastScanTime = t
              TargetPlayer 
                 prey = ()
                 prey 
                    TargetPlayer = prey
                    targetAttackTrack.player = prey
                    targetAttackTrack.startTime = t
                     prey.Character  (prey) 
                        targetAttackTrack.initialPos = (prey).Position
                    
                    TargetBox.Text =  .. prey.DisplayName
                    TargetBox.BorderColor3 = COLORS.SoulAuraBlue
                
                    TargetBox.Text = 
                    TargetBox.BorderColor3 = .(, , )
                
            
        
    

     finalPos
     isPetState = 

     isSummoning 
         elapsed = t - summonStartTime
         elapsed >= SUMMON_DURATION 
            isSummoning = 
        
             rotationSpeed = (elapsed ^ ) * 
             currentAngle = elapsed * rotationSpeed
             currentHeight = (elapsed / SUMMON_DURATION) * HOVER_HEIGHT
            witherCurrentPos = summonOriginPos + .(, currentHeight, )
            finalPos = .(witherCurrentPos) * .(, currentAngle, )
        
    

      isSummoning 
         currentTarget = TargetPlayer

          rampageMode  ( currentTarget   currentTarget.Character   (currentTarget)) 
            currentTarget = LP
            isPetState = 
        

         targetTorso = (currentTarget)

          targetTorso  rampageMode 
            finalPos = .(witherCurrentPos, lastLookAtPos)
         targetTorso 
             idealTargetPos
             isPetState 
                 ownerChar = LP.Character
                 ownerRoot = ownerChar  ownerChar:()
                 ownerRoot 
                    
                     swayY = .(t * ) * 
                     animatedOffset = PET_OFFSET + .(, swayY, )
                    idealTargetPos = (ownerRoot.CFrame * .(animatedOffset)).Position
                
                    idealTargetPos = targetTorso.Position + .(, , )
                
            
                 driftX = .(t * ) * RANDOM_DRIFT_SCALE
                 driftZ = .(t * ) * RANDOM_DRIFT_SCALE
                 driftY = .(t * ) * (RANDOM_DRIFT_SCALE * )
                idealTargetPos = targetTorso.Position + .(driftX, HOVER_HEIGHT + driftY, driftZ)
            

             moveDirection = (idealTargetPos - witherCurrentPos)
             distance = moveDirection.Magnitude

             distance >  
                 speedMod = isPetState    
                 maxMove = WITHER_SPEED * speedMod * dt
                 step = .(distance, maxMove)
                witherCurrentPos = witherCurrentPos + (moveDirection.Unit * step)
            

             rawLookAt
             isPetState 
                 ownerChar = LP.Character
                 ownerRoot = ownerChar  ownerChar:()
                 ownerRoot 
                    rawLookAt = ownerRoot.Position + (ownerRoot.CFrame.LookVector * )
                
                    rawLookAt = witherCurrentPos + .(, , -)
                
            
                rawLookAt = .(targetTorso.Position.X, witherCurrentPos.Y, targetTorso.Position.Z)
            

            lastLookAtPos = lastLookAtPos:(rawLookAt,  - .(- * dt))
            finalPos = .(witherCurrentPos, lastLookAtPos)
        
            finalPos = .(witherCurrentPos)
        
    

     rotCF = .(.(MANUAL_ROTATION.X), .(MANUAL_ROTATION.Y), .(MANUAL_ROTATION.Z))
     lerpAlpha =  - .(- * dt)

      isSummoning 
         auraId, projData  (activeProjectiles) 
             currentEnemyTorso = (TargetPlayer)

             currentEnemyTorso 
                 enemyVelocity = currentEnemyTorso.AssemblyLinearVelocity
                 pingAndFpsOffset = dt + 
                 predictedPosition = currentEnemyTorso.Position + (enemyVelocity * pingAndFpsOffset)

                 projData.IsStuck 
                    projData.CurrentPos = predictedPosition

                     activeBall 
                        activeBall.CFrame = .(predictedPosition)
                        activeBall.Velocity = .(, , )
                    

                     t - projData.ImpactTime >= IMPACT_LINGER_TIME 
                        activeProjectiles[auraId] = 
                    
                
                    projData.TargetPos = predictedPosition
                     pDir = (projData.TargetPos - projData.CurrentPos)
                     pDist = pDir.Magnitude

                     pDist >  
                         pStep = .(pDist, PROJECTILE_SPEED *  * dt)
                        projData.CurrentPos = projData.CurrentPos + (pDir.Unit * pStep)
                    
                        projData.IsStuck = 
                        projData.ImpactTime = t
                        projData.CurrentPos = predictedPosition

                         activeBall 
                            activeBall.CFrame = .(predictedPosition)
                            activeBall.Velocity = .(, , )
                        
                    
                
            
                activeProjectiles[auraId] = 
            
        
    
        .(activeProjectiles)
    

     i = , totalProps 
         targetCF
         i <=  
             offset = WitherParts[i]

            
             isPetState   isSummoning 
                 i ==   
                     breathZ = .(t * ) * 
                    offset = offset * .(, , breathZ)
                 i ==   
                     breathZ = .(t * ) * 
                    offset = offset * .(, , breathZ)
                 i ==   
                     breathZ = .(t * ) * 
                    offset = offset * .(, , breathZ)
                
            

            targetCF = finalPos * rotCF * offset
        
            
             auraId = i - 
             activeProj = activeProjectiles[auraId]

             activeProj   isSummoning 
                targetCF = .(activeProj.CurrentPos, lastLookAtPos)
            
                 targetHeadId
                 auraId ==   auraId ==  
                    targetHeadId = 
                 auraId ==   auraId ==  
                    targetHeadId = 
                
                    targetHeadId = 
                

                
                 headCFrame = currentCFrames[targetHeadId]  finalPos
                targetCF = headCFrame
            
        

        currentCFrames[i] = (currentCFrames[i]  targetCF):(targetCF, lerpAlpha)
    

     TargetPlayer  (TargetPlayer)   isSummoning 
         t - lastAttackTime > ATTACK_COOLDOWN 
            lastAttackTime = t

             availableAuras = {}
             auraId = ,  
                  activeProjectiles[auraId] 
                    .(availableAuras, auraId)
                
            

             freeCount = #availableAuras
             freeCount >  
                 burstCount = .(, .(, freeCount))
                 enemyTorso = (TargetPlayer)

                .(()
                     k = , burstCount 
                         auraId = availableAuras[k]

                         targetHeadId
                         auraId ==   auraId ==   targetHeadId = 
                         auraId ==   auraId ==   targetHeadId = 
                         targetHeadId =  

                         headCFrame = currentCFrames[targetHeadId]

                         headCFrame  enemyTorso  TargetPlayer 
                             enemyVelocity = enemyTorso.AssemblyLinearVelocity
                             predictedTargetPos = enemyTorso.Position + (enemyVelocity * (dt + ))

                            activeProjectiles[auraId] = {
                                CurrentPos = headCFrame.Position,
                                TargetPos = predictedTargetPos,
                                IsStuck = ,
                                ImpactTime = 
                            }
                        
                         k < burstCount  .(.(, ) / ) 
                    
                )
            
        
    

     t - lastNetworkUpdate >  
         canUpdateColor = (t - lastColorUpdate > )
         frameCFrames = currentCFrames
         startSend = .()

         i = , totalProps 
             prop = wingRemoteCache[i]
             targetCFrame = frameCFrames[i]

             prop  targetCFrame 
                .(()
                     cfR = prop:()
                     cfR 
                        (()
                            cfR:(targetCFrame)
                             i ==  
                                estimatedPing = (estimatedPing * ) + ((.() - startSend) * )
                            
                        )
                    

                     canUpdateColor  i == colorIndex 
                         crR = prop:()
                         crR  (() crR:((t, i)) ) 
                    
                )
            
        

         canUpdateColor 
            colorIndex = (colorIndex % totalProps) + 
            lastColorUpdate = t
        
        lastNetworkUpdate = t
    
)