PizdecWare crack OPEN SOURCE

.Status = 
()
 getinfo = getinfo  debug.getinfo
 DEBUG = 
 Hooked = {}

 Detected, Kill

()

 i, v  (()) 
     (v) ==  
         DetectFunc = (v, )
         KillFunc = (v, )

         (DetectFunc) ==    Detected 
            Detected = DetectFunc

             Old; Old = (DetectFunc, (Action, Info, NoCrash)
                 Action ~=  
                     DEBUG 
                        ()
                    
                
                 
            )

            .(Hooked, DetectFunc)
        

         (v, )  (v, )  (KillFunc) ==    Kill 
            Kill = KillFunc
             Old; Old = (KillFunc, (Info)
                 DEBUG 
                    ()
                
                 
            )

            .(Hooked, KillFunc)
        
    


 Old; Old = (().debug.info, ((...)
     LevelOrFunc, Info = ...

     Detected  LevelOrFunc == Detected 
         DEBUG 
            ()
        
         .()
    

     (...)
))

()


()






 UILibrary = (:())()

 ui = UILibrary.({
    Info = ,
    discordURL = ,
    FileName = 
})



()

 Players = :()
 RunService = :()
 UserInputService = :()
 Workspace = :()
 GuiService = :()

 player = Players.LocalPlayer
 Camera = Workspace.CurrentCamera




 Aimbot = {
    Enabled = ,
    ShowFOV = ,
    FieldOfView = ,
    Smoothness = ,
    TargetPart = ,
    UseFOVLimit = ,
    PlayerExceptions = {}
}




().ForceMouseUnlock = 
().SilentAim = {
    Enabled = ,
    Prediction = ,
    TargetPart = ,
    HealthCheck = ,
    PassiveCheck = ,
    WallCheck = ,
    Kent = ,
    FOV = {
        Radius = ,
        Visible = ,
        Color = .(, , )
    },
    ToggleKey = ,
    DynamicPrediction = ,
    FlashPartNames = {, , , },
    UseFlashPart = ,
    IgnoreTransparent = ,
    IgnoreNonCollidable = ,
    Tracer = {
        Enabled = ,
        Color = .(, , ),
        Thickness = 
    }
}




 MOD_CONFIG = {
    PerfectAccuracy = {
        params = {},
        active_value = ,
        default_value = ,
        display_name = 
    },
    NoRecoil = {
        params = {, },
        active_value = ,
        default_value = ,
        display_name = 
    },
    InsatntEquip = {
        params = {},
        active_value = ,
        default_value = ,
        display_name = 
    },
    PerfectFirerate = {
        params = {},
        active_value = ,
        default_value = ,
        display_name = 
    },
    ReloadSpeed = {
        params = {, },
        active_value = ,
        default_value = ,
        display_name = 
    },
    NoAimSway = {
        params = {},
        active_value = ,
        default_value = ,
        display_name = 
    },
    FastAiming = {
        params = {},
        active_value = ,
        default_value = ,
        display_name = 
    }
}

 ModStates = {
    AutoApply = ,
    CheckNewItems = 
}


 modName  (MOD_CONFIG) 
    ModStates[modName] = 



 OriginalValues = {}
 TrackedTools = {}




 AuraSystem = {
    MedkitAura = {
        Enabled = ,
        HealRate = ,
        TargetPlayers = {},
        Running = 
    },
    WrenchAura = {
        Enabled = ,
        HealRate = ,
        TargetPlayers = {},
        Running = 
    },
    PickaxeAura = {
        Enabled = ,
        AttackRate = ,
        ExcludedPlayers = {},
        Running = 
    }
}


 CurrentTarget = 
 IsMouseHeld = 
 AimConnection = 
 FOVCircle = 
 AutoAcquireConnection = 


 Mouse = player:()
 CurrentCamera = .CurrentCamera
 InsetY = GuiService:().Y
 SilentAimFOVCircle, TargetDot, CenterDot, TracerLine
 IsTargeting = 
 Target
 originalIndex
 lastWallCheck = 
 wallCheckCache = {}


 RunService = :()
 UserInputService = :()
 player = Players.LocalPlayer




 Workspace = :()

 player = Players.LocalPlayer
 Camera = Workspace.CurrentCamera


 isEnabled = 
 connections = {}
 mainLoopActive = 


  ()
     tools = {}
    
     backpack = player:()
     backpack 
         _, item  (backpack:()) 
             item:() 
                .(tools, item)
            
        
    
    
     player.Character 
         _, item  (player.Character:()) 
             item:() 
                .(tools, item)
            
        
    
    
     tools



  (tool)
      tool    
    
     playerFolder = :(player.Name)
      playerFolder    
    
     weapon = playerFolder:(tool.Name, )
     weapon



  (weapon)
      weapon    
      weapon:()    
      weapon.GunScript:()    
     



  (weapon)
     weapon  weapon:() 
         gunScript = weapon.GunScript
         gunScript:() 
             ammo = gunScript.ClientAmmo
             originalValue = ammo.Value
             connection = ammo.Changed:(()
                 ammo.Value ~= originalValue 
                    ammo.Value = originalValue
                
            )
            .(connections, connection)
            ammo.Value = originalValue
        
    



  (character)
      character   

     _, tool  (character:()) 
         tool:() 
            
             weapon = (tool)
              weapon   

             reloadEvent = weapon:()
              reloadEvent   

              (args)
                reloadEvent:((args, , .(args)))
            

            ({[] = })
            ({[] = , [] = })
            ({[] = , [] = })
            ({[] = , [] = })
        
    



  ()
     _, connection  (connections) 
        connection:()
    
    connections = {}



  (character)
      character   

     _, tool  (character:()) 
         tool:() 
            
             weapon = (tool)
              weapon   
            
            
             (weapon) 
                
                (weapon)
            
        
    
    
    
    (character)



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





  (tool)
      tool   tool:()    
     attachmentFolder = tool:()
      attachmentFolder    

     innerTool = attachmentFolder:()  .()
    innerTool.Name = 
    innerTool.Parent = attachmentFolder

      innerTool:() 
         isAttachment = .()
        isAttachment.Name = 
        isAttachment.Value = 
        isAttachment.Parent = innerTool
    

      innerTool:() 
         weight = .()
        weight.Name = 
        weight.Value = 
        weight.Parent = innerTool
        
         originalWeight = .()
        originalWeight.Name = 
        originalWeight.Value = 
        originalWeight.Parent = weight
    

     statsFolder = innerTool:()  .()
    statsFolder.Name = 
    statsFolder.Parent = innerTool

     


  (tool)
      (tool)   

     innerTool = tool.AttachmentFolder:()
      innerTool   

     statsFolder = innerTool:()
      statsFolder   

     modName, config  (MOD_CONFIG) 
         _, paramName  (config.params) 
              OriginalValues[tool]  OriginalValues[tool] = {} 
             OriginalValues[tool][paramName] ==  
                 currentValue = statsFolder:(paramName)
                OriginalValues[tool][paramName] = currentValue  currentValue.Value  config.default_value
            

             valueToSet = ModStates[modName]  config.active_value  OriginalValues[tool][paramName]
            
             param = statsFolder:(paramName)  .()
            param.Name = paramName
            param.Value = valueToSet
            param.Parent = statsFolder
        
    


  ()
     tools = {}
    
     player.Character 
         _, item  (player.Character:()) 
             item:()  item:() 
                .(tools, item)
            
        
    
    
     backpack = player:()
     backpack 
         _, item  (backpack:()) 
             item:()  item:() 
                .(tools, item)
            
        
    
    
     tools


  ()
     _, tool  (()) 
        (tool)
    


  ()
      ModStates.CheckNewItems   ModStates.AutoApply   
    
     currentTools = ()
     newToolsFound = 
    
     _, tool  (currentTools) 
          TrackedTools[tool] 
            TrackedTools[tool] = 
            newToolsFound = 
        
    
    
     newToolsFound 
        ()
    
    
     tool  (TrackedTools) 
          tool:() 
            TrackedTools[tool] = 
        
    





  ()
     playerNames = {}
     _, p  (Players:()) 
         p ~= player 
            .(playerNames, p.Name)
        
    
     playerNames


  ()
     FOVCircle 
        FOVCircle:()
        FOVCircle = 
    
    
      Aimbot.ShowFOV   Aimbot.Enabled   
    
    FOVCircle = .()
    FOVCircle.Visible = 
    FOVCircle.Radius = Aimbot.FieldOfView
    FOVCircle.Color = .(, , )
    FOVCircle.Thickness = 
    FOVCircle.Filled = 
    FOVCircle.Transparency = 
    FOVCircle.Position = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )


  (player)
     player  player.Character


  (character)
     character  character:()


  (character)
      character    
    
     part = character:(Aimbot.TargetPart)
     part   part 
    
     alternatives = {, , , }
     _, altPart  (alternatives) 
        part = character:(altPart)
         part   part 
    
    
     


  (character)
     humanoid = (character)
     humanoid  humanoid.Health > 


  (targetScreenPos)
      Aimbot.UseFOVLimit    
    
     screenCenter = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
     distance = (targetScreenPos - screenCenter).Magnitude
     distance <= Aimbot.FieldOfView


  ()
     targets = {}
    
     _, p  (Players:()) 
         p == player   
        
         Aimbot.PlayerExceptions[p.Name] ==  
            
        
        
         character = (p)
          character   
        
          (character)   
        
         aimPart = (character)
          aimPart   
        
         screenPoint, onScreen = Camera:(aimPart.Position)
          onScreen   
        
         screenPos = .(screenPoint.X, screenPoint.Y)
         screenCenter = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )
         screenDistance = (screenPos - screenCenter).Magnitude
        
          (screenPos)   
        
         targetData = {
            Player = p,
            Character = character,
            AimPart = aimPart,
            ScreenDistance = screenDistance,
            ScreenPosition = screenPos
        }
        
        .(targets, targetData)
    
    
     targets


  ()
     targets = ()
     bestTarget = 
     closestFOV = Aimbot.FieldOfView
    
     _, target  (targets) 
         target.ScreenDistance < closestFOV 
            closestFOV = target.ScreenDistance
            bestTarget = target
        
    
    
     bestTarget


  (targetPosition)
     currentCFrame = Camera.CFrame
     targetDirection = (targetPosition - currentCFrame.Position).Unit
    
     targetCFrame = .(currentCFrame.Position, currentCFrame.Position + targetDirection)
     smoothFactor = .(Aimbot.Smoothness, )
     newCFrame = currentCFrame:(targetCFrame,  / smoothFactor)
    
    Camera.CFrame = newCFrame


  (targetPosition)
     currentPosition = Camera.CFrame.Position
     targetDirection = (targetPosition - currentPosition).Unit
    Camera.CFrame = .(currentPosition, currentPosition + targetDirection)


  ()
      Aimbot.Enabled   CurrentTarget   
    
     character = (CurrentTarget.Player)
      character   (character) 
        ()
        
    
    
     aimPart = (character)
      aimPart  
        ()
         
    
    
     Aimbot.Smoothness >  
        (aimPart.Position)
    
        (aimPart.Position)
    


  ()
      Aimbot.Enabled   
    
     target = ()
    
     target 
        CurrentTarget = target
        
         AimConnection 
            AimConnection:()
        
        
        AimConnection = RunService.RenderStepped:(()
             CurrentTarget 
                ()
            
                ()
            
        )
    


  ()
    CurrentTarget = 
    
     AimConnection 
        AimConnection:()
        AimConnection = 
    


  ()
      IsMouseHeld   
    
     AutoAcquireConnection 
        AutoAcquireConnection:()
    
    
    AutoAcquireConnection = RunService.Heartbeat:(()
         IsMouseHeld   CurrentTarget 
             target = ()
             target 
                CurrentTarget = target
                
                 AimConnection 
                    AimConnection:()
                
                
                AimConnection = RunService.RenderStepped:(()
                     CurrentTarget 
                        ()
                    
                        ()
                    
                )
            
        
    )


  ()
     AutoAcquireConnection 
        AutoAcquireConnection:()
        AutoAcquireConnection = 
    





  ()
      SilentAimFOVCircle  SilentAimFOVCircle = .() 
      TargetDot  TargetDot = .() 
      CenterDot  CenterDot = .() 
      TracerLine  TracerLine = .() 
    
     SilentAimFOVCircle 
        SilentAimFOVCircle.Visible = SilentAim.FOV.Visible
        SilentAimFOVCircle.Transparency = 
        SilentAimFOVCircle.Thickness = 
        SilentAimFOVCircle.Filled = 
        SilentAimFOVCircle.Radius = SilentAim.FOV.Radius
        SilentAimFOVCircle.Color = SilentAim.FOV.Color
    
    
     TargetDot 
        TargetDot.Visible = 
        TargetDot.Transparency = 
        TargetDot.Thickness = 
        TargetDot.Filled = 
        TargetDot.Radius = 
        TargetDot.Color = .(, , )
    
    
     CenterDot 
        CenterDot.Visible = SilentAim.FOV.Visible
        CenterDot.Transparency = 
        CenterDot.Thickness = 
        CenterDot.Filled = 
        CenterDot.Radius = 
        CenterDot.Color = .(, , )
    
    
     TracerLine 
        TracerLine.Visible = 
        TracerLine.Transparency = 
        TracerLine.Thickness = SilentAim.Tracer.Thickness
        TracerLine.Color = SilentAim.Tracer.Color
    


  ()
      player   player.Character    
    
     tool = player.Character:()
      tool    
    
     _, name  (SilentAim.FlashPartNames) 
         flash = tool:(name)  tool:(name, )
         flash  flash:() 
             flash
        
    
    
     handle = tool:()
     handle  handle:() 
         handle
    
    
     


  (character)
     character  character:() ~= 


  (character)
      character    
     humanoid = character:()
      humanoid    
     humanoid.Health <= 


  ()
      player   player.Character    
    
     tool = player.Character:()  player.Character:()
      tool    
    
     tool:() ~= 


  ()
      CurrentCamera   .(, ) 
     viewportSize = CurrentCamera.ViewportSize
     .(viewportSize.X/, viewportSize.Y/)


  (targetPart)
      targetPart   SilentAim.Prediction 
     basePrediction = SilentAim.Prediction
    
     velocity = targetPart.Velocity.Magnitude
     velocity <  
         basePrediction * 
     velocity >  
         basePrediction * 
    
         basePrediction * ( + velocity/)
    


  (origin, destination)
      SilentAim.WallCheck    
    
     cacheKey = (origin)..(destination)
     wallCheckCache[cacheKey]  () - lastWallCheck <  
         wallCheckCache[cacheKey]
    
    
     direction = (destination - origin)
     distance = direction.Magnitude
    direction = direction.Unit
    
     raycastParams = RaycastParams.()
    raycastParams.FilterType = .RaycastFilterType.Blacklist
    raycastParams.FilterDescendantsInstances = {player.Character, CurrentCamera}
    raycastParams.IgnoreWater = 
    
     raycastResult = :(origin, direction * distance, raycastParams)
    
      raycastResult  
        wallCheckCache[cacheKey] = 
        lastWallCheck = ()
          
    
    
     hitPart = raycastResult.Instance
      hitPart  
        wallCheckCache[cacheKey] = 
        lastWallCheck = ()
          
    
    
     hitPart.CanCollide ==  
        wallCheckCache[cacheKey] = 
        lastWallCheck = ()
         
    
    
     transparency = hitPart.Transparency  
     transparency >  
        wallCheckCache[cacheKey] = 
        lastWallCheck = ()
         
    
    
     texture = hitPart:()
     texture  (texture.Transparency > ) 
        wallCheckCache[cacheKey] = 
        lastWallCheck = ()
         
    
    
     material = hitPart.Material
     material == .Material.Glass  material == .Material.ForceField 
        wallCheckCache[cacheKey] = 
        lastWallCheck = ()
         
    
    
    wallCheckCache[cacheKey] = 
    lastWallCheck = ()
     


  ()
      SilentAim.Enabled   Players   player    
    
     flashPart = ()
     origin = flashPart  flashPart.Position  (CurrentCamera  CurrentCamera.CFrame.Position  .())
     bestTarget = 
     closestDistance = .huge
     screenCenter = ()

     _, p  (Players:()) 
         p == player   
        
        
          SilentAim.Kent  (p)   
        
         character = p.Character
          character   
        
         SilentAim.PassiveCheck  (character)   
        
         humanoid = character:()
          humanoid  humanoid.Health <=    
        
         SilentAim.HealthCheck  humanoid.Health <=    
        
         targetPart = character:(SilentAim.TargetPart)
          targetPart   
        
         prediction = (targetPart)
         predictedPosition = targetPart.Position + (targetPart.Velocity * prediction)
        
          (origin, predictedPosition)   
        
         screenPos, onScreen = CurrentCamera:(predictedPosition)
          onScreen   
        
         targetPos = .(screenPos.X, screenPos.Y)
         distance = (targetPos - screenCenter).Magnitude
        
         distance < (SilentAimFOVCircle  SilentAimFOVCircle.Radius  )  distance < closestDistance 
            closestDistance = distance
            bestTarget = {
                Player = p,
                Part = targetPart,
                Distance = distance,
                PredictedPosition = predictedPosition,
                FlashPosition = origin
            }
        
    
    
    IsTargeting = bestTarget ~= 
     bestTarget


  ()
      SilentAimFOVCircle   TargetDot   CenterDot   TracerLine   
    
     center = ()
     SilentAimFOVCircle  SilentAimFOVCircle.Position = center 
     TargetDot  TargetDot.Position = center 
     CenterDot  CenterDot.Position = center 
    
     SilentAimFOVCircle  SilentAimFOVCircle.Visible = SilentAim.Enabled  SilentAim.FOV.Visible 
     CenterDot  CenterDot.Visible = SilentAim.Enabled  SilentAim.FOV.Visible 
     TargetDot  TargetDot.Visible = SilentAim.Enabled  IsTargeting 
    
     SilentAim.Tracer.Enabled  IsTargeting  SilentAim.Enabled 
         targetData = ()
         targetData 
             screenPos = CurrentCamera:(targetData.PredictedPosition)
            TracerLine.From = center
            TracerLine.To = .(screenPos.X, screenPos.Y)
            TracerLine.Visible = 
        
            TracerLine.Visible = 
        
    
        TracerLine.Visible = 
    





  (targetPlayer)
      AuraSystem.MedkitAura.TargetPlayers    
     #AuraSystem.MedkitAura.TargetPlayers ==     
     .(AuraSystem.MedkitAura.TargetPlayers, targetPlayer.Name) ~= 


  ()
     AuraSystem.MedkitAura.Running   
    AuraSystem.MedkitAura.Running = 
    
    .(()
         AuraSystem.MedkitAura.Running 
             AuraSystem.MedkitAura.Enabled 
                 _, targetPlayer  (Players:()) 
                     targetPlayer ~= player  targetPlayer.Character 
                          (targetPlayer)   
                        
                         character = targetPlayer.Character
                         medkit = player.Character  player.Character:()
                        
                         medkit  medkit:() 
                             args = {, character}
                            medkit.ActionMain:((args))
                        
                    
                
            
            
             AuraSystem.MedkitAura.HealRate ==  
                ()
            
                (AuraSystem.MedkitAura.HealRate / )
            
        
    )()


  ()
    AuraSystem.MedkitAura.Running = 


  (targetPlayer)
      AuraSystem.WrenchAura.TargetPlayers    
     #AuraSystem.WrenchAura.TargetPlayers ==     
     .(AuraSystem.WrenchAura.TargetPlayers, targetPlayer.Name) ~= 


  ()
     AuraSystem.WrenchAura.Running   
    AuraSystem.WrenchAura.Running = 
    
    .(()
         AuraSystem.WrenchAura.Running 
             AuraSystem.WrenchAura.Enabled 
                 _, targetPlayer  (Players:()) 
                     targetPlayer ~= player  targetPlayer.Character 
                          (targetPlayer)   
                        
                         character = targetPlayer.Character
                         wrench = player.Character  player.Character:()
                        
                         wrench  wrench:() 
                             args = {, character}
                            wrench.ActionMain:((args))
                        
                    
                
            
            
             AuraSystem.WrenchAura.HealRate ==  
                ()
            
                (AuraSystem.WrenchAura.HealRate / )
            
        
    )()


  ()
    AuraSystem.WrenchAura.Running = 


  (targetPlayer)
      AuraSystem.PickaxeAura.ExcludedPlayers    
     .(AuraSystem.PickaxeAura.ExcludedPlayers, targetPlayer.Name) == 


  ()
     AuraSystem.PickaxeAura.Running   
    AuraSystem.PickaxeAura.Running = 
    
    .(()
         AuraSystem.PickaxeAura.Running 
             AuraSystem.PickaxeAura.Enabled 
                 _, targetPlayer  (Players:()) 
                     targetPlayer ~= player  targetPlayer.Character 
                          (targetPlayer)   
                        
                         character = targetPlayer.Character
                         pickaxe = player.Character  player.Character:()
                        
                         pickaxe  pickaxe:() 
                             args = {
                                ,
                                ,
                                ,
                                
                            }
                            pickaxe.ActionMain:((args))
                        
                    
                
            
            
             AuraSystem.PickaxeAura.AttackRate ==  
                ()
            
                (AuraSystem.PickaxeAura.AttackRate / )
            
        
    )()


  ()
    AuraSystem.PickaxeAura.Running = 





UserInputService.InputBegan:((input, gameProcessed)
     gameProcessed   
    
     input.UserInputType == .UserInputType.MouseButton2 
        IsMouseHeld = 
        ()
        ()
    
    
     input.KeyCode == .KeyCode[SilentAim.ToggleKey] 
        SilentAim.Enabled =  SilentAim.Enabled
        ()
    
)

UserInputService.InputEnded:((input, gameProcessed)
     gameProcessed   
    
     input.UserInputType == .UserInputType.MouseButton2 
        IsMouseHeld = 
        ()
        ()
    
)


  originalIndex 
    originalIndex = (, , (self, key)
          SilentAim.Enabled   (self, key) 
        
         self:()  key ==  
              ()   (self, key) 
            
             targetData = ()
            
             targetData 
                IsTargeting = 
                 .(targetData.PredictedPosition)
            
            IsTargeting = 
        
        
         (self, key)
    )








 LocalPlayer = Players.LocalPlayer
 RunService = :()

 healingActive = 
 autoHealCoroutine = 

  ()
     autoHealCoroutine 
        .(autoHealCoroutine)
        autoHealCoroutine = 
    


  ()
    ()
    
    autoHealCoroutine = .(()
         healingActive 
            
             healingActive  ( LocalPlayer.Character  
                   LocalPlayer.Character:()  
                  LocalPlayer.Character.Humanoid.Health <= ) 
                .()
            
            
              healingActive   
            
            
             healingActive  LocalPlayer.Character  
                   LocalPlayer.Character:() 
                .()
            
            
              healingActive   
            
            
             healingActive  LocalPlayer.Character  
                  LocalPlayer.Character:()  
                  LocalPlayer.Character.Humanoid.Health >  
                  LocalPlayer.Character:() 
                
                 success, err = (()
                     args = {, LocalPlayer.Character}
                    LocalPlayer.Character.Medkit.ActionMain:((args))
                )
                
                  success 
                    (, err)
                    
                
                
                .()
            
            
            .()
        
    )
    
    .(autoHealCoroutine)



 repairingActive = 
 autoRepairCoroutine = 

  ()
     autoRepairCoroutine 
        .(autoRepairCoroutine)
        autoRepairCoroutine = 
    


  ()
    ()
    
    autoRepairCoroutine = .(()
         repairingActive 
            
             repairingActive  ( LocalPlayer.Character  
                   LocalPlayer.Character:()  
                  LocalPlayer.Character.Humanoid.Health <= ) 
                .()
            
            
              repairingActive   
            
            
             repairingActive  LocalPlayer.Character  
                   LocalPlayer.Character:() 
                .()
            
            
              repairingActive   
            
            
             repairingActive  LocalPlayer.Character  
                  LocalPlayer.Character:()  
                  LocalPlayer.Character.Humanoid.Health >  
                  LocalPlayer.Character:() 
                
                 success, err = (()
                     args = {, LocalPlayer.Character}
                    LocalPlayer.Character.Wrench.ActionMain:((args))
                )
                
                  success 
                    (, err)
                    
                
                
                .()
            
            
            .()
        
    )
    
    .(autoRepairCoroutine)








 Workspace = :()
 RunService = :()

 localPlayer = Players.LocalPlayer
 camera = Workspace.CurrentCamera


 TRACKING_FOLDER = 
 UPDATE_INTERVAL = 


 isTrackingEnabled = 
 targetPlayerName = 
 trackingConnection = 
 activeBodyPositions = {}
 exceptionParts = {} 


  ()
     playerNames = {}
     _, player  (Players:()) 
         player ~= localPlayer 
            .(playerNames, player.Name)
        
    
     playerNames



  (name)
      name  name ==     
     _, player  (Players:()) 
         player.Name == name 
             player
        
    
     


  (model)
     parts = {}
     _, part  (model:()) 
         part:() 
            .(parts, part)
        
    
     #parts >  
         parts[.(, #parts)]
    
     


  (vehicle, exceptionPart)
     _, part  (vehicle:()) 
         part:() 
            
             _, force  (part:()) 
                 force:()  force:() 
                    force:()
                
            
            
            
             part == exceptionPart 
                part.CanCollide = 
                part.Anchored = 
            
                part.CanCollide = 
                part.Anchored = 
                
                
                 bodyPos = .()
                bodyPos.MaxForce = .(.huge, .huge, .huge)
                bodyPos.P = 
                bodyPos.D = 
                bodyPos.Parent = part
                
                .(activeBodyPositions, bodyPos)
            
        
    


  ()
     trackingConnection 
        trackingConnection:()
        trackingConnection = 
    
    
    
     _, part  (exceptionParts) 
         part  part.Parent 
            part.CanCollide = 
        
    
    exceptionParts = {}
    
    
     _, bodyPos  (activeBodyPositions) 
         bodyPos  bodyPos.Parent 
            bodyPos:()
        
    
    activeBodyPositions = {}


  ()
      isTrackingEnabled  targetPlayerName ==    
    
     mouse = localPlayer:()
     targetPos = mouse.Hit.Position
     trackingFolder = Workspace:(TRACKING_FOLDER)
      trackingFolder   
    
     _, vehicle  (trackingFolder:()) 
         vehicle:() 
            
              exceptionParts[vehicle] 
                exceptionParts[vehicle] = (vehicle)
                (vehicle, exceptionParts[vehicle])
            
            
            
             _, part  (vehicle:()) 
                 part:()  part ~= exceptionParts[vehicle] 
                     _, force  (part:()) 
                         force:() 
                            force.Position = targetPos
                        
                    
                
            
        
    


  ()
    () 
    
    trackingConnection = RunService.Heartbeat:(()
        ()
    )







 objectMoverEnabled = 
 originalObjectLocations = {} 
 movedObjectsFolder = 
 currentHighlight = 
 currentModel = 
 currentTargetPart = 
 connections = {}


 currentKeybind = .KeyCode.F5


  ()
     ReplicatedStorage = :()
    
     possibleNames = {
        ,
        ,
        ,
        ,
        
    }
    
     _, name  (possibleNames) 
         found = ReplicatedStorage:(name)
         found 
             found
        
    
    
     _, child  (ReplicatedStorage:()) 
         _, name  (possibleNames) 
             child.Name == name 
                 child
            
        
    
    
     



  ()
    originalObjectLocations = {}
    
      (folder, path)
         _, child  (folder:()) 
             childPath = path ..  .. child.Name
            originalObjectLocations[child] = {
                Parent = child.Parent,
                Path = childPath
            }
            
             child:() 
                (child, childPath)
            
        
    
    
    (, )



  ()
     currentHighlight 
        currentHighlight:()
        currentHighlight = 
    
    
     movedObjectsFolder 
         object, locationInfo  (originalObjectLocations) 
             object  object.Parent 
                (()
                    object.Parent = locationInfo.Parent
                )
            
        
        movedObjectsFolder:()
        movedObjectsFolder = 
    
    
    originalObjectLocations = {}



  ()
     camera = .CurrentCamera
      camera  
         
    
    
    ()
    
      (model)
         model:() ~= 
    
    
      (folder, parentInCamera)
         _, child  (folder:()) 
             child:()   (child) 
                child.Parent = parentInCamera
             child:() 
                 newFolder = .()
                newFolder.Name = child.Name
                newFolder.Parent = parentInCamera
                (child, newFolder)
             child:()  child:()  child:() 
                 containerModel = .()
                containerModel.Name = child.Name .. 
                containerModel.Parent = parentInCamera
                child.Parent = containerModel
            
        
    
    
     movedObjectsFolder 
        movedObjectsFolder:()
    
    
    movedObjectsFolder = .()
    movedObjectsFolder.Name = 
    movedObjectsFolder.Parent = camera
    
    (, movedObjectsFolder)
    
     



  (model)
     interactValue = model:()
     interactValue  interactValue:() 
         , interactValue
    
     , 



  (target)
      target    
    
     current = target
     current 
         current:() 
             hasInteract = (current)
             hasInteract 
                 current
            
        
        current = current.Parent
    
     



  (object)

     player = Players.LocalPlayer
     character = player.Character
    
      character   .huge 
    
     humanoidRootPart = character:()
      humanoidRootPart   .huge 
    
     objectPosition = object:().Position
     playerPosition = humanoidRootPart.Position
    
     (objectPosition - playerPosition).Magnitude



  (model)
     currentHighlight 
        currentHighlight:()
        currentHighlight = 
    
    
     highlight = .()
    highlight.FillColor = .(, , ) 
    highlight.OutlineColor = .(, , )
    highlight.FillTransparency = 
    highlight.OutlineTransparency = 
    highlight.Parent = model
    
     highlight



  (targetPart, model)
     InteractFunction = ()
      InteractFunction 
        
    
    
      targetPart 
        
    
    
     _, boolValue = (model)
     currentValue = boolValue  boolValue.Value  
    
    (()
        InteractFunction:(
            targetPart,
            ,
             currentValue,
            
        )
    )



  (object)
      movedObjectsFolder    
     object:(movedObjectsFolder)



  ()
     objectMoverEnabled   
    
    objectMoverEnabled = 

     RunService = :()
     UserInputService = :()
    
     player = Players.LocalPlayer
     mouse = player:()
    
    ()
    
     heartbeatConnection = RunService.Heartbeat:(()
          objectMoverEnabled   
        
         target = mouse.Target
          target 
             currentHighlight 
                currentHighlight:()
                currentHighlight = 
                currentModel = 
                currentTargetPart = 
            
            
        
        
         modelWithInteract = (target)
        
         modelWithInteract  (modelWithInteract) 
             distance = (modelWithInteract)
             distance >  
                 currentHighlight 
                    currentHighlight:()
                    currentHighlight = 
                    currentModel = 
                    currentTargetPart = 
                
                
            
            
             currentModel ~= modelWithInteract 
                 currentHighlight 
                    currentHighlight:()
                    currentHighlight = 
                
                currentModel = modelWithInteract
                currentTargetPart = target
            
            
             modelWithInteract  modelWithInteract == currentModel   currentHighlight 
                currentHighlight = (modelWithInteract)
            
        
             currentHighlight 
                currentHighlight:()
                currentHighlight = 
                currentModel = 
                currentTargetPart = 
            
        
    )
    .(connections, heartbeatConnection)
    
     inputConnection = UserInputService.InputBegan:((input, gameProcessed)
          objectMoverEnabled   
         gameProcessed   
        
         input.KeyCode == .KeyCode.E  currentModel  currentTargetPart 
             distance = (currentModel)
             distance <=  
                 hasInteract = (currentModel)
                 hasInteract 
                    (currentTargetPart, currentModel)
                
            
        
    )
    .(connections, inputConnection)



  ()
      objectMoverEnabled   
    
    objectMoverEnabled = 
    
     _, connection  (connections) 
         connection  (connection) ==  
            connection:()
        
    
    connections = {}
    
     currentHighlight 
        currentHighlight:()
        currentHighlight = 
    
    
    ()
    
    currentModel = 
    currentTargetPart = 



  ()
     objectMoverEnabled 
        ()
    
        ()
    






 RunService = :()
 CoreGui = :()
 HttpService = :()

 player = Players.LocalPlayer
 camera = .CurrentCamera


 Distance = 

 playerEspEnabled = 
 pwareEnabled = 
 playerEspCache = {}


  (adornee, color, fillTransparency, outlineColor)
      adornee   
     highlight = .()
    highlight.FillColor = color
    highlight.FillTransparency = fillTransparency
    highlight.OutlineColor = outlineColor  color
    highlight.OutlineTransparency = 
    highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
    highlight.Adornee = adornee
    highlight.Enabled = 
     highlight


  (character)
     hrp = character:()
     hrp  hrp.Position  character:().Position


  (character)
     humanoid = character:()
     humanoid  .(humanoid.Health)  


  (targetPlayer)
      targetPlayer  targetPlayer == player   targetPlayer.Character   
     playerEspCache[targetPlayer]   

     character = targetPlayer.Character
     position = (character)
      position   

     mainContainer = .()
    mainContainer.Name =  .. targetPlayer.Name
    mainContainer.Parent = CoreGui
    
     teamColor = targetPlayer.Team  targetPlayer.Team.TeamColor.Color  .(, , )
     isPWare = (targetPlayer)
    
    
     highlightColor = isPWare  .(, , )  teamColor
    
     playerHighlight = (character, highlightColor, , highlightColor)
    playerHighlight.Parent = mainContainer
    
     head = character:()  character:()
     head 
         billboard = .()
        billboard.Adornee = head
        billboard.Size = .(, , , )
        billboard.AlwaysOnTop = 
        billboard.StudsOffset = .(, , )
        billboard.Parent = mainContainer

         label = .()
        label.Size = .(,,,)
        label.BackgroundTransparency = 
        label.Font = .Font.SourceSansSemibold
        label.TextSize = 
        label.TextColor3 = highlightColor
        label.TextStrokeTransparency = 
        label.Parent = billboard

        playerEspCache[targetPlayer] = {
            mainContainer = mainContainer, 
            label = label, 
            position = position, 
            character = character,
            highlight = playerHighlight,
            isPWare = isPWare
        }
    


  (targetPlayer)
     data = playerEspCache[targetPlayer]
      data   
     data.mainContainer  data.mainContainer:() 
    playerEspCache[targetPlayer] = 


 ()
     player  (playerEspCache) 
        (player)
    

     playerEspEnabled 
         _, p  (Players:()) 
            (p)
        
    


  ()
     cameraPos = camera.CFrame.Position
    
     p, data  (playerEspCache) 
          p   p.Character   p.Character.Parent 
            (p)
        
             newPos = (data.character)
             newPos 
                 distanceMeters = (newPos - cameraPos).Magnitude * 
                 health = (data.character)
                
                 Distance 
                    data.label.Text = .(, p.Name, health, distanceMeters)
                
                    data.label.Text = .(, p.Name, health)
                
            
        
    


  (p)
    p.CharacterAdded:(()
        (p)
         playerEspEnabled  
            .()
            (p) 
        
    )
     playerEspEnabled 
        .()
        (p)
    


Players.PlayerAdded:(onPlayerAdded)
Players.PlayerRemoving:(cleanupPlayerESP)

 _, p  (Players:())  
    (p) 


RunService.RenderStepped:(updateLabels)





 combatSection = ui:()
 aimTab = combatSection:(, )
 aimLeft = aimTab:CreateSection("AimBot", "left")
local aimRight = aimTab:CreateSection("SilentAim", "Right")

local modsTab = combatSection:CreateTab("Modifications", "rbxassetid://127904742940104")
local modsLeft = modsTab:CreateSection("Weapon Modifications", "left")
local modsRight = modsTab:CreateSection("Options", "right")
local ItemModsRight = modsTab:CreateSection("Item Modifications", "right")

local MiscSection = ui:CreateTabSection("Miscellaneous")
local MiscTab = MiscSection:CreateTab("Auras", "rbxassetid://129855843582244")
local MiscLeft = MiscTab:CreateSection("Healing Auras", "left")
local MiscRight = MiscTab:CreateSection("Killing Auras", "right")


local OthersTab = MiscSection:CreateTab("Others", "rbxassetid://136882854117051")
local ZOVCOPTERLeft = OthersTab:CreateSection("Zov Copter", "left")
local OthersRight = OthersTab:CreateSection("Others", "Right")

local VisualsTab = MiscSection:CreateTab("Visuals", "rbxassetid://13321848320")
local VisualsLeft = VisualsTab:CreateSection("Esp", "left")
local VisualsRight = VisualsTab:CreateSection("Visuals", "right")


-- Переменные для хранения элементов UI
local playerExceptionsDropdown, medkitPlayerDropdown, wrenchPlayerDropdown, pickaxeExcludeDropdown

-- AIMBOT UI ELEMENTS
CreateToggle({
    section = aimLeft,
    name = "AimBot",
    save = false,
    id = "AimBotEnableToggle",
    default = false,
    callback = function(v) 
        Aimbot.Enabled = v
        if not v then
            StopAiming()
            StopAutoAcquire()
            if FOVCircle then
                FOVCircle.Visible = false
            end
        else
            CreateFOVCircle()
        end
    end
})

CreateToggle({
    section = aimLeft,
    name = "Show Fov",
    save = false,
    id = "AimBotShowFovToggle",
    default = false,
    callback = function(v) 
        Aimbot.ShowFOV = v
        CreateFOVCircle()
    end
})

CreateSlider({
    section = aimLeft,
    name = "Aimbot Fov",
    save = true,
    id = "AimBotFovValueSlider",
    min = 0,
    max = 500,
    default = 60,
    callback = function(v) 
        Aimbot.FieldOfView = v
        if FOVCircle then
            FOVCircle.Radius = v
        end
    end
})

CreateSlider({
    section = aimLeft,
    name = "Smoothness",
    save = true,
    id = "AimBotSmoothnessValueSlider",
    min = 0,
    max = 5,
    default = 0,
    callback = function(v) 
        Aimbot.Smoothness = v
    end
})

playerExceptionsDropdown = CreateDropdown({
    section = aimLeft,
    name = "Player Exceptions",
    save = true,
    id = "AimBotPlayerExceptions",
    options = GetPlayerList(),
    default = {},
    multi = true,
    callback = function(selectedPlayers) 
        Aimbot.PlayerExceptions = {}
        for _, playerName in pairs(selectedPlayers) do
            Aimbot.PlayerExceptions[playerName] = true
        end
    end
})

CreateDropdown({
    section = aimLeft,
    name = "Target Part",
    save = true,
    id = "AimBotTargetPart",
    options = {"Head", "Torso"},
    default = "Head",
    callback = function(v) 
        Aimbot.TargetPart = v
    end
})

-- SILENT AIM UI ELEMENTS
CreateToggle({
    section = aimRight,
    name = "Silent Aim",
    save = true,
    id = "SilentAimEbableToggle",
    default = false,
    callback = function(v) 
        SilentAim.Enabled = v
        if not v and TracerLine then
            TracerLine.Visible = false
        end
        UpdateSilentAimVisuals()
    end
})

CreateToggle({
    section = aimRight,
    name = "Show Fov",
    save = true,
    id = "SilentAimFovValueSlider",
    default = false,
    callback = function(v) 
        SilentAim.FOV.Visible = v
        if SilentAimFOVCircle then
            SilentAimFOVCircle.Visible = v and SilentAim.Enabled
        end
        if CenterDot then
            CenterDot.Visible = v and SilentAim.Enabled
        end
    end
})

CreateBind({
    section = aimRight,
    name = "Keybind",
    save = true,
    id = "SilentAimKeybindValue",
    default = Enum.KeyCode.L,
    callback = function(keyCode) 
        SilentAim.ToggleKey = keyCode.Name
    end
})

CreateSlider({
    section = aimRight,
    name = "Fov Size",
    save = true,
    id = "SilentAimFovSize",
    min = 0,
    max = 500,
    default = 60,
    callback = function(v) 
        SilentAim.FOV.Radius = v
        if SilentAimFOVCircle then
            SilentAimFOVCircle.Radius = v
        end
    end
})

CreateDropdown({
    section = aimRight,
    name = "Target Part",
    save = true,
    id = "SilentAimTargetPartDropDown",
    multi = false,
    options = {"Head", "Torso"},
    default = "Head",
    callback = function(v) 
        SilentAim.TargetPart = v
    end
})

CreateToggle({
    section = aimRight,
    name = "Show Tracer",
    save = true,
    id = "SilentAimTracerToggle",
    default = true,
    callback = function(v) 
        SilentAim.Tracer.Enabled = v
        if not v and TracerLine then
            TracerLine.Visible = false
        end
    end
})



CreateToggle({
    section = aimRight,
    name = "Health Check",
    save = true,
    id = "SilentAimHealthCheckToggle",
    default = true,
    callback = function(v) 
        SilentAim.HealthCheck = v
    end
})

CreateToggle({
    section = aimRight,
    name = "Passive Check",
    save = true,
    id = "SilentAimPassiveCheckToggle",
    default = false,
    callback = function(v) 
        SilentAim.PassiveCheck = v
    end
})

CreateToggle({
    section = aimRight,
    name = "Wall Check",
    save = true,
    id = "SilentAimWallCheckToggle",
    default = false,
    callback = function(v) 
        SilentAim.WallCheck = v
    end
})

CreateToggle({
    section = aimRight,
    name = "Kent",
    save = true,
    id = "SilentAimKentToggle",
    default = false,
    callback = function(v) 
        SilentAim.Kent = v
    end
})

CreateSlider({
    section = aimRight,
    name = "Prediction",
    save = true,
    id = "SilentAimPredictionSlider",
    min = 0,
    max = 10,
    default = 0,
    step = 0.01,
    callback = function(v) 
        SilentAim.Prediction = v
    end
})

-- WEAPON MODIFICATIONS UI ELEMENTS
for modName, config in pairs(MOD_CONFIG) do
    CreateToggle({
        section = modsLeft,
        name = config.display_name,
        save = true,
        id = "mod_" .. modName,
        default = false,
        callback = function(state)
            ModStates[modName] = state
            if ModStates.AutoApply then
                ApplyModifications()
            end
        end
    })
end

-- Toggle для INF AMMO
CreateToggle({
    section = modsLeft,
    name = "Infinite Ammo",
    save = true,
    id = "InfAmmoEnableToggle",
    default = false,
    callback = function(state)
        isEnabled = state
        if state then
            cleanup()
            -- Выполняем принудительную перезарядку при активации
            if player.Character then
                forceReload(player.Character)
            end
            coroutine.wrap(mainLoop)()
        else
            cleanup()
        end
    end
})

-- Обработка респавна
player.CharacterAdded:Connect(function(character)
    -- Ожидаем полной загрузки персонажа
    task.wait(1)
    
    -- Перезапускаем Infinite Ammo
    if isEnabled then
        cleanup()
        processWeapons(character)
    end
    
    -- Перезапускаем модификации оружия
    if ModStates.AutoApply then
        ApplyModifications()
    end
    
    -- Перезапускаем ауры
    if AuraSystem.MedkitAura.Enabled then
        StartMedkitAura()
    end
    if AuraSystem.WrenchAura.Enabled then
        StartWrenchAura()
    end
    if AuraSystem.PickaxeAura.Enabled then
        StartPickaxeAura()
    end
    
    -- Перезапускаем Insta Heal и Insta Wrench
    if healingActive then
        startHealing()
    end
    if repairingActive then
        startRepairing()
    end
end)

player.CharacterRemoving:Connect(function()
    -- Очищаем все при смерти
    if isEnabled then
        cleanup()
    end
    StopMedkitAura()
    StopWrenchAura()
    StopPickaxeAura()
    stopHealing()
    stopRepairing()
end)

-- Очистка при выходе из игры
game:GetService("UserInputService").WindowFocusReleased:Connect(function()
    if isEnabled then
        cleanup()
    end
end)

CreateToggle({
    section = modsLeft,
    name = "Auto Mode",
    save = true,
    id = "AutoModeEnableToggle",
    default = false,
    callback = function(state)
        local function applyAutoSetting(tool, autoState)
            if not tool or not tool:IsA("Tool") then return end
            
            local settingsModule = tool:FindFirstChild("Settings")
            if settingsModule and settingsModule:IsA("ModuleScript") then
                local success, settings = pcall(function()
                    return require(settingsModule)
                end)
                
                if success and type(settings) == "table" then
                    settings.auto = autoState
                end
            end
        end
        
        local function updateTools(character)
            if not character then return end
            
            for _, tool in ipairs(character:GetChildren()) do
                applyAutoSetting(tool, state)
            end
            
            local connection
            connection = character.ChildAdded:Connect(function(child)
                applyAutoSetting(child, state)
            end)
            
            character.Destroying:Connect(function()
                if connection then
                    connection:Disconnect()
                end
            end)
        end
        
        if player and player.Character then
            updateTools(player.Character)
        end
        
        if player then
            player.CharacterAdded:Connect(function(character)
                updateTools(character)
                
                task.delay(1, function()
                    if character and character:IsDescendantOf(game) then
                        updateTools(character)
                    end
                end)
            end)
        end
    end
})

CreateToggle({
    section = modsRight,
    name = "Auto Apply",
    save = true,
    id = "AutoApplyEnableToggle",
    default = false,
    callback = function(state)
        ModStates.AutoApply = state
        if state then
            ApplyModifications()
        end
    end
})



CreateButton({
    section = modsRight,
    name = "Apply Once",
    position = "left",
    callback = ApplyModifications
})

-- AURA SYSTEM UI ELEMENTS
-- Medkit Aura UI Elements
CreateToggle({
    section = MiscLeft,
    name = "Medkit Aura",
    save = false,
    id = "MedkitAuraEnableToggle",
    default = false,
    callback = function(state)
        AuraSystem.MedkitAura.Enabled = state
        if state then
            StartMedkitAura()
        else
            StopMedkitAura()
        end
    end
})

CreateSlider({
    section = MiscLeft,
    name = "Heal Rate (ms)",
    save = true,
    id = "MedkitAuraHealRateSlider",
    min = 1,
    max = 9000,
    default = 1,
    callback = function(value)
        AuraSystem.MedkitAura.HealRate = value
    end
})

medkitPlayerDropdown = CreateDropdown({
    section = MiscLeft,
    name = "Heal Specific Player",
    options = GetPlayerList(),
    save = true,
    id = "MedkitHealPlayerDropdown",
    default = {},
    multi = true,
    callback = function(selectedPlayers)
        AuraSystem.MedkitAura.TargetPlayers = selectedPlayers
    end
})

-- Wrench Aura UI Elements
CreateToggle({
    section = MiscLeft,
    name = "Wrench Aura",
    save = false,
    id = "WrenchAuraEnableToggle",
    default = false,
    callback = function(state)
        AuraSystem.WrenchAura.Enabled = state
        if state then
            StartWrenchAura()
        else
            StopWrenchAura()
        end
    end
})

CreateSlider({
    section = MiscLeft,
    name = "Wrench-Heal Rate (ms)",
    save = true,
    id = "WrenchAuraHealRateSlider",
    min = 1,
    max = 9000,
    default = 1,
    callback = function(value)
        AuraSystem.WrenchAura.HealRate = value
    end
})

wrenchPlayerDropdown = CreateDropdown({
    section = MiscLeft,
    name = "Wrench-Heal Specific Player",
    options = GetPlayerList(),
    save = true,
    id = "WrenchHealPlayerDropdown",
    default = {},
    multi = true,
    callback = function(selectedPlayers)
        AuraSystem.WrenchAura.TargetPlayers = selectedPlayers
    end
})

-- Pickaxe Aura UI Elements
CreateToggle({
    section = MiscRight,
    name = "Pickaxe aura",
    save = false,
    id = "PickaxeAuraEnableToggle",
    default = false,
    callback = function(state)
        AuraSystem.PickaxeAura.Enabled = state
        if state then
            StartPickaxeAura()
        else
            StopPickaxeAura()
        end
    end
})

CreateSlider({
    section = MiscRight,
    name = "Attack Rate (ms)",
    save = true,
    id = "PickaxeAuraAttackRateSlider",
    min = 1,
    max = 9000,
    default = 1,
    callback = function(value)
        AuraSystem.PickaxeAura.AttackRate = value
    end
})

pickaxeExcludeDropdown = CreateDropdown({
    section = MiscRight,
    name = "Exclude Player",
    options = GetPlayerList(),
    save = true,
    id = "PickaxeAuraExclusionsMultiDropdown",
    default = {},
    multi = true,
    callback = function(excludedPlayers)
        AuraSystem.PickaxeAura.ExcludedPlayers = excludedPlayers
    end
})

--
-- INITIALIZATION AND BACKGROUND TASKS
--
local function UpdatePlayerLists()
    local playerList = GetPlayerList()
    
    if playerExceptionsDropdown and typeof(playerExceptionsDropdown.UpdateOptions) == "function" then
        playerExceptionsDropdown:UpdateOptions(playerList)
    end
    
    if medkitPlayerDropdown and typeof(medkitPlayerDropdown.UpdateOptions) == "function" then
        medkitPlayerDropdown:UpdateOptions(playerList)
    end
    
    if wrenchPlayerDropdown and typeof(wrenchPlayerDropdown.UpdateOptions) == "function" then
        wrenchPlayerDropdown:UpdateOptions(playerList)
    end
    
    if pickaxeExcludeDropdown and typeof(pickaxeExcludeDropdown.UpdateOptions) == "function" then
        pickaxeExcludeDropdown:UpdateOptions(playerList)
    end
end

Players.PlayerAdded:Connect(function(addedPlayer)
    wait(1)
    UpdatePlayerLists()
end)

Players.PlayerRemoving:Connect(function(removedPlayer)
    UpdatePlayerLists()
end)

-- Background tasks
spawn(function()
    while true do
        if ModStates.AutoApply then
            ApplyModifications()
        end
        wait(1)
    end
end)

spawn(function()
    while true do
        wait(0.2)
        if CurrentTarget then
            local character = GetCharacter(CurrentTarget.Player)
            if not character or not IsAlive(character) then
                StopAiming()
                if IsMouseHeld then
                    StartAiming()
                end
            end
        end
    end
end)

spawn(function()
    while task.wait(2.6) do
        wallCheckCache = {}
    end
end)

-- Rendering loops
RunService.RenderStepped:Connect(function()
    if FOVCircle then
        FOVCircle.Position = Vector2.new(Camera.ViewportSize.X / 2, Camera.ViewportSize.Y / 2)
        FOVCircle.Radius = Aimbot.FieldOfView
        FOVCircle.Visible = Aimbot.ShowFOV and Aimbot.Enabled
    end
end)

RunService.Heartbeat:Connect(function()
    UpdateSilentAimVisuals()
    
    if not SilentAim.Enabled and TracerLine then
        TracerLine.Visible = false
    end
end)

-- Очистка при отключении
player.CharacterRemoving:Connect(cleanup)
game:GetService("UserInputService").WindowFocusReleased:Connect(function()
    if isEnabled then
        cleanup()
    end
    if FOVCircle then
        FOVCircle.Visible = false
    end
    if SilentAimFOVCircle then
        SilentAimFOVCircle.Visible = false
    end
    if TracerLine then
        TracerLine.Visible = false
    end
    StopMedkitAura()
    StopWrenchAura()
    StopPickaxeAura()
end)

game:GetService("UserInputService").WindowFocused:Connect(function()
    if FOVCircle and Aimbot.ShowFOV and Aimbot.Enabled then
        FOVCircle.Visible = true
    end
    if SilentAimFOVCircle and SilentAim.FOV.Visible and SilentAim.Enabled then
        SilentAimFOVCircle.Visible = true
    end
    if AuraSystem.MedkitAura.Enabled then
        StartMedkitAura()
    end
    if AuraSystem.WrenchAura.Enabled then
        StartWrenchAura()
    end
    if AuraSystem.PickaxeAura.Enabled then
        StartPickaxeAura()
    end
end)

-- Initial setup
wait(2)
UpdatePlayerLists()
InitSilentAimDrawings()
-- Apply saved slider values after UI initialization
task.wait(0.5)
-- Update SilentAim FOV from saved slider value
local HttpService = game:GetService("HttpService")
local success, savedSettings = pcall(function()
    return HttpService:JSONDecode(readfile("Town.lua"))
end)
if success and savedSettings and savedSettings.SilentAimFovSize then
    SilentAim.FOV.Radius = savedSettings.SilentAimFovSize
end
if SilentAimFOVCircle then
    SilentAimFOVCircle.Radius = SilentAim.FOV.Radius
end
UpdateSilentAimVisuals()

for _, tool in ipairs(GetValidPlayerTools()) do
    SetupToolStructure(tool)
end

-- Insta Medkit UI Elements
CreateToggle({
    section = ItemModsRight,
    name = "Insta Heal",
    save = true,
    id = "InstaHealEnableToggle",
    default = false,
    callback = function(state)
        healingActive = state
        if state then
            startHealing()
        else
            stopHealing()
        end
    end
})

-- Insta Wrench UI Elements
CreateToggle({
    section = ItemModsRight,
    name = "Insta Wrench",
    save = true,
    id = "InstaWrenchEnableToggle",
    default = false,
    callback = function(state)
        repairingActive = state
        if state then
            startRepairing()
        else
            stopRepairing()
        end
    end
})

-- Auto-restart on respawn уже обрабатывается в основном обработчике CharacterAdded выше

-- Cleanup when disabled
RunService.Heartbeat:Connect(function()
    if not healingActive and autoHealCoroutine then
        stopHealing()
    end
    if not repairingActive and autoRepairCoroutine then
        stopRepairing()
    end
end)

-- UI Elements
CreateToggle({
    section = ZOVCOPTERLeft,
    name = "ZOV Copter",
    save = false,
    id = "ZovCopterEnableToggle",
    default = false,
    callback = function(state)
        isTrackingEnabled = state
        if state and targetPlayerName ~= "" then
            startTracking()
        else
            stopTracking()
        end
    end
})

-- Dropdown с игроками вместо TextInput
CreateDropdown({
    section = ZOVCOPTERLeft,
    name = "Select Player",
    save = false,
    id = "ZovCopterTargetDropdown",
    options = getPlayerList(),
    default = "",
    callback = function(selectedPlayer)
        targetPlayerName = selectedPlayer
        if isTrackingEnabled and selectedPlayer ~= "" then
            -- При изменении игрока перезапускаем трекинг
            startTracking()
        elseif isTrackingEnabled and selectedPlayer == "" then
            -- Если выбрана пустая строка, останавливаем трекинг
            stopTracking()
        end
    end
})


-- Автоматическое обновление списка игроков каждые 20 секунд
task.spawn(function()
    while true do
        task.wait(20)
        -- Здесь должен быть код для обновления dropdown с новым списком игроков
        -- Зависит от возможностей UI библиотеки для обновления существующего dropdown
        local currentPlayers = getPlayerList()
    end
end)

-- Автоматическая очистка при выходе из игры
game:GetService("UserInputService").WindowFocusReleased:Connect(function()
    if isTrackingEnabled then
        stopTracking()
    end
end)

Players.PlayerRemoving:Connect(function(player)
    if player == localPlayer then
        stopTracking()
    elseif player.Name == targetPlayerName then
        isTrackingEnabled = false
        stopTracking()
        warn("Target player left the game. Tracking stopped.")
    end
end)

-- Toggle для переключения WallBang системы
CreateToggle({
    section = OthersRight,
    name = "WallBang",
    save = false,
    default = false,
    callback = function(v)
        if v then
            startObjectMover()
        else
            stopObjectMover()
        end
    end
})

-- Очистка при выходе игрока
game:GetService("Players").PlayerRemoving:Connect(function(leavingPlayer)
    if leavingPlayer == game:GetService("Players").LocalPlayer then
        stopObjectMover()
    end
end)

-- Очистка при удалении скрипта
if typeof(script) == "Instance" and script:IsA("LocalScript") then
    script.Destroying:Connect(function()
        stopObjectMover()
    end)
end

CreateToggle({
    section = VisualsLeft,
    name = "Enable Player ESP",
    save = true,
    id = "EnablePlayerESP",
    default = false,
    callback = function(v)
        playerEspEnabled = v
        refreshPlayerESP()
    end
})

CreateToggle({
    section = VisualsLeft,
    name = "PWare user esp",
    save = true,
    id = "PWareUserESP",
    default = false,
    callback = function(v)
        pwareEnabled = v
        if v then
            spawn(updatePWareUsernames)
        else
            pwareUsernames = {}
            refreshPlayerESP()
        end
    end
})

local thirdPersonEnabled = false
local interactMainScript = nil

CreateToggle({
    section = OthersRight,
    name = "Third Person",
    save = false,
    default = false,
    callback = function(v)
        thirdPersonEnabled = v
        if v then
            interactMainScript = game:GetService("Players").LocalPlayer.PlayerGui.CameraClient
            if interactMainScript then
                interactMainScript.Enabled = false
            end
        else
            if interactMainScript then
                interactMainScript.Enabled = true
            end
        end
    end
})

local amongusEnabled = false
local CameraEventNamecall
local amongusConnections = {}

CreateToggle({
    section = OthersRight,
    name = "Amongus",
    save = false,
    id = "AmongusToggle",
    default = false,
    callback = function(v)
        amongusEnabled = v
        if v then
            local ReplicatedStorage = game:GetService("ReplicatedStorage")
            local CameraEvent = ReplicatedStorage:WaitForChild("CameraEvent")
            
            local movementSpeed = 50000.0
            local randomCFrame1 = CFrame.identity
            local randomCFrame2 = CFrame.identity
            local randomCFrame3 = CFrame.identity
            local randomCFrame4 = CFrame.identity
            local randomFloat1 = 0
            local randomFloat2 = 0.01
            local randomBool = false
            
            CameraEventNamecall = hookmetamethod(game, "__namecall", function(self, ...)
                local method = getnamecallmethod()
                local args = {...}
            
                if method == "FireServer" and self == CameraEvent and not checkcaller() then
                    local chaosPos1 = Vector3.new(
                        math.random(-50, 50) * movementSpeed,
                        math.random(-50, 50) * movementSpeed,
                        math.random(-50, 50) * movementSpeed
                    )
                    local chaosRot1 = Vector3.new(
                        math.random(-1440, 1440),
                        math.random(-1440, 1440),
                        math.random(-1440, 1440)
                    )
                    randomCFrame1 = CFrame.new(chaosPos1) * CFrame.Angles(math.rad(chaosRot1.X), math.rad(chaosRot1.Y), math.rad(chaosRot1.Z))
            
                    local chaosPos2 = Vector3.new(
                        math.random(-100, 100) * movementSpeed,
                        math.random(-100, 100) * movementSpeed,
                        math.random(-100, 100) * movementSpeed
                    )
                    local chaosRot2 = Vector3.new(
                        math.random(-2880, 2880),
                        math.random(-2880, 2880),
                        math.random(-2880, 2880)
                    )
                    randomCFrame2 = CFrame.new(chaosPos2) * CFrame.Angles(math.rad(chaosRot2.X), math.rad(chaosRot2.Y), math.rad(chaosRot2.Z))
            
                    randomCFrame3 = CFrame.new(
                        math.random(-200, 200) * movementSpeed,
                        math.random(-200, 200) * movementSpeed,
                        math.random(-200, 200) * movementSpeed
                    ) * CFrame.Angles(
                        math.rad(math.random(-3600, 3600)),
                        math.rad(math.random(-3600, 3600)),
                        math.rad(math.random(-3600, 3600))
                    )
            
                    randomCFrame4 = CFrame.new(
                        math.random(-500, 500) * movementSpeed,
                        math.random(-500, 500) * movementSpeed,
                        math.random(-500, 500) * movementSpeed
                    ) * CFrame.Angles(
                        math.rad(math.random(-7200, 7200)),
                        math.rad(math.random(-7200, 7200)),
                        math.rad(math.random(-7200, 7200))
                    )
            
                    randomFloat1 = math.random(-100000, 100000) / 1000
                    randomFloat2 = math.random(1, 100000) / 1000000
                    randomBool = math.random(1, 2) == 1
            
                    return CameraEventNamecall(self,
                        randomCFrame1,
                        randomFloat1,
                        randomFloat2,
                        randomBool,
                        randomCFrame2,
                        randomCFrame3,
                        randomCFrame4
                    )
                end
            
                return CameraEventNamecall(self, ...)
            end)
            
            local heartbeatConnection = RunService.Heartbeat:Connect(function(deltaTime)
                if not amongusEnabled then return end
                local jitter = Vector3.new(
                    math.random(-15, 15) * 3.0,
                    math.random(-15, 15) * 3.0,
                    math.random(-15, 15) * 3.0
                )
                randomCFrame1 = randomCFrame1 + jitter
                randomCFrame2 = randomCFrame2 + jitter * 2
                randomCFrame3 = randomCFrame3 + jitter * 5
                randomCFrame4 = randomCFrame4 + jitter * 10
            
                randomCFrame1 = randomCFrame1 * CFrame.Angles(
                    math.rad(math.random(-180, 180)),
                    math.rad(math.random(-180, 180)),
                    math.rad(math.random(-180, 180))
                )
                randomCFrame2 = randomCFrame2 * CFrame.Angles(
                    math.rad(math.random(-360, 360)),
                    math.rad(math.random(-360, 360)),
                    math.rad(math.random(-360, 360))
                )
            end)
            table.insert(amongusConnections, heartbeatConnection)
            
            spawn(function()
                while amongusEnabled do
                    task.wait(0.00000001)
                    randomFloat1 = randomFloat1 + math.random(-500, 500)
                    randomFloat2 = math.random() * 100
                    randomBool = not randomBool
            
                    if math.random() < 0.1 then
                        randomCFrame1 = CFrame.new(math.random(-1000, 1000), math.random(-1000, 1000), math.random(-1000, 1000))
                        randomCFrame4 = CFrame.new(Vector3.new(0,0,0)) * CFrame.Angles(math.rad(math.random(0, 360*10)), 0, 0)
                    end
                end
            end)
        else
            -- Отключаем все соединения
            for _, connection in ipairs(amongusConnections) do
                if connection and typeof(connection) == "RBXScriptConnection" then
                    connection:Disconnect()
                end
            end
            amongusConnections = {}
        end
    end
})

local skinToneEnabled = false
local originalMaterials = {}
local originalColors = {}

local function applySkinTone(character)
    if not character then return end
    
    for _, part in pairs(character:GetDescendants()) do
        if part:IsA("BasePart") or part:IsA("MeshPart") or part:IsA("UnionOperation") then
            originalMaterials[part] = part.Material
            originalColors[part] = part.Color
            part.Material = Enum.Material.ForceField
            part.Color = Color3.fromRGB(171, 0, 255)
        end
    end
    
    -- Apply to backpack items
    if player.Backpack then
        for _, tool in pairs(player.Backpack:GetDescendants()) do
            if tool:IsA("BasePart") or tool:IsA("MeshPart") or tool:IsA("UnionOperation") then
                originalMaterials[tool] = tool.Material
                originalColors[tool] = tool.Color
                tool.Material = Enum.Material.ForceField
                tool.Color = Color3.fromRGB(171, 0, 255)
            end
        end
    end
end

local function removeSkinTone()
    for part, material in pairs(originalMaterials) do
        if part and part.Parent then
            part.Material = material
        end
    end
    for part, color in pairs(originalColors) do
        if part and part.Parent then
            part.Color = color
        end
    end
    originalMaterials = {}
    originalColors = {}
end

CreateToggle({
    section = VisualsRight,
    name = "Skin Tone",
    save = true,
    id = "SkinToneToggle",
    default = false,
    callback = function(v)
        skinToneEnabled = v
        if v then
            if player.Character then
                applySkinTone(player.Character)
            end
        else
            removeSkinTone()
        end
    end
})

-- Handle respawn
player.CharacterAdded:Connect(function(character)
    if skinToneEnabled then
        task.wait(1)
        applySkinTone(character)
    end
end)

player.CharacterRemoving:Connect(function()
    removeSkinTone()
end)

local lightingEnabled = false
local originalTintColor

local lightingEnabled = false
local originalTintColor
local fullBrightEnabled = false
local brightLoop

CreateToggle({
    section = VisualsRight,
    name = "Lighting",
    save = true,
    id = "LightingToggle",
    default = false,
    callback = function(v)
        lightingEnabled = v
        local lighting = game:GetService("Lighting")
        local colorCorrection = lighting:FindFirstChild("ColorCorrection")
        
        if not colorCorrection then
            colorCorrection = Instance.new("ColorCorrectionEffect")
            colorCorrection.Parent = lighting
        end
        
        if v then
            originalTintColor = colorCorrection.TintColor
        else
            if originalTintColor then
                colorCorrection.TintColor = originalTintColor
            end
        end
    end
})

CreateToggle({
    section = VisualsRight,
    name = "Full Bright",
    save = true,
    id = "FullBrightToggle",
    default = false,
    callback = function(v)
        fullBrightEnabled = v
        if brightLoop then
            brightLoop:Disconnect()
            brightLoop = nil
        end
        
        if v then
            local function brightFunc()
                local Lighting = game:GetService("Lighting")
                Lighting.Brightness = 2
                Lighting.ClockTime = 14
                Lighting.FogEnd = 100000
                Lighting.GlobalShadows = false
                Lighting.OutdoorAmbient = Color3.fromRGB(128, 128, 128)
            end
            brightLoop = RunService.RenderStepped:Connect(brightFunc)
        end
    end
})

-- Continuous check loop for Skin Tone and Lighting
spawn(function()
    while true do
        task.wait(1)
        if skinToneEnabled and player.Character then
            applySkinTone(player.Character)
        end
        
        if lightingEnabled then
            local lighting = game:GetService("Lighting")
            local colorCorrection = lighting:FindFirstChild("ColorCorrection")
            if colorCorrection then
                colorCorrection.TintColor = Color3.fromRGB(171, 0, 255)
            end
        end
    end
end)