Juliohub kill all beta usen el auto shot o olo que quieran

 WindUI = (:())()
  WindUI  ();  

 setclipboard = setclipboard  () 
  =   ()   

 DISCORD_INVITE = 
 TIKTOK_URL = 
 UNLOAD_KEY = 
 IS_UNLOADING = 

(()
     env = ()
     (env[UNLOAD_KEY]) ==   env[UNLOAD_KEY]() 
)

 Players           = :()
 RunService        = :()
 UserInputService  = :()
 ReplicatedStorage = :()
 Lighting          = :()
 LocalPlayer       = Players.LocalPlayer

  ()
     ok, platform = (()  UserInputService:() )
     ok  (platform == .Platform.Android  platform == .Platform.IOS)    
     UserInputService.TouchEnabled   UserInputService.KeyboardEnabled

 IS_MOBILE = ()

  ()
     IS_MOBILE 
         cam = .CurrentCamera
         cam  (cam.ViewportSize / )  .zero
    
     UserInputService:()


 ALLY_LOOKUP = { [] =  }
 IsAlly = {}
 IsAlly:(player)
      player    
     ALLY_LOOKUP[player.UserId] == 


 ConnectionBucket = {}
ConnectionBucket.__index = ConnectionBucket
 ConnectionBucket.()  ({ _conns = {} }, ConnectionBucket) 
 ConnectionBucket:(obj) self._conns[#self._conns + ] = obj;  obj 
 ConnectionBucket:()
     i = #self._conns, , - 
         obj = self._conns[i]; self._conns[i] = 
         t = (obj)
         t ==   (() obj:() )
         t ==   (() obj:() )
         t ==   (obj) 
    


 Config = {
    Notifications = { Enabled =  },
    ESP = {
        Enabled = ,
        ShowName = ,
        ShowDistance = ,
        Lines = ,
        Boxes = ,
        Color = .(, , ),
        LinesColor = .(, , ),
        FilledTransparency = ,
        TeamCheck = ,
    },
    PlayerCheats = { JumpPowerEnabled = , JumpPower = , InfiniteJump = , SpeedEnabled = , Speed =  },
    AutoTeleport = { Main = , Alt = , DuelType = , PlatformRow = , BreakStreak = , BreakStreakTarget = , LowerKD = , KDTargetKills = , EventFarm =  },
    Bannable = {
        Desync = ,
        AimFollow = , AimFollowFirearmOnly = , AimFollowKnifeOnly = , AimFollowRaycast = ,
        BodyPartsEnabled = ,
        BodyParts = {
            Head=,LeftUpperArm=,LeftLowerArm=,LeftHand=,
            RightUpperArm=,RightLowerArm=,RightHand=,
            UpperTorso=,LowerTorso=,LeftUpperLeg=,LeftLowerLeg=,
            LeftFoot=,RightUpperLeg=,RightLowerLeg=,RightFoot=,
        },
        Triggerbot=, SilentAim=, AutoShoot=, Macro=,
        FOVEnabled=, FOVVisible=, FOVRadius=, HitChance=,
    },
    Boxes = { Selected = , Price = , AutoBuy =  },
    FloatingFloor = { Enabled = , HideMap = , Height =  },
    TPCircle = { Enabled = , Distance = , Speed = , KillEnabled =  },
    TPEnemy = { Enabled = , Mode = , Distance = , KillEnabled =  },
    Keybinds = { ToggleUI =  },
}

  (value, default)
     (value) ==    value 
     (value) ==  
         r = value.R  value.r  value[]
         g = value.G  value.g  value[]
         b = value.B  value.b  value[]
         (r)==  (g)==  (b)== 
             r>  g>  b>   .(.(r,,),.(g,,),.(b,,)) 
             .(r,g,b)
        
    
     default


 IS_LOADING_CONFIG = 

  (player)
     char = player  player.Character
      char    
     hrp = char:()
     (hrp  hrp:())  hrp  

  (player)
     char = player  player.Character
     char  char:()  

  (player)
      player    
     v = player:()
     (v) ==   v ~= 

  (player)
      (player)    
     v = player:()
     (v) ==   v ~= 

  (parent, name, timeout)
      parent    
    timeout = timeout  
     ok, child = (()  parent:(name, timeout) )
     ok   child 
     


 EnemyChecker = {}
EnemyChecker.__index = EnemyChecker
 EnemyChecker:(player)
     player == LocalPlayer    
      (LocalPlayer)   (player)    
     LocalPlayer:() ~= player:()    
     LocalPlayer:()  ~= player:()     
     myTeam, hisTeam = LocalPlayer:(), player:()
     (myTeam) ~=   myTeam ==     
     (hisTeam) ~=   hisTeam ==     
     myTeam ~= hisTeam

 EnemyCheckerInstance = ({}, EnemyChecker)

  (player)
      EnemyCheckerInstance:(player)    
     IsAlly:(player)    
     

  (player)
     char = player  player.Character
      char    
     hum = char:()
     hum  hum.Health > 


 BODY_PART_NAMES = {
    ,,,,,
    ,,,,,
    ,,,,,
}
 BODY_PART_LOOKUP = {}
 _, n  (BODY_PART_NAMES)  BODY_PART_LOOKUP[n] =  
 BODY_WEIGHTS = {
    UpperTorso=,LowerTorso=,HumanoidRootPart=,Head=,
    LeftUpperArm=,RightUpperArm=,LeftUpperLeg=,RightUpperLeg=,
    LeftLowerArm=,RightLowerArm=,LeftLowerLeg=,RightLowerLeg=,
    LeftHand=,RightHand=,LeftFoot=,RightFoot=,
}
  ()
     (Config.Bannable.BodyParts) ~=   Config.Bannable.BodyParts = {} 
     name, value  (Config.Bannable.BodyParts) 
          BODY_PART_LOOKUP[name]  Config.Bannable.BodyParts[name] = 
         (value) ~=   Config.Bannable.BodyParts[name] = value ==  
    
     _, name  (BODY_PART_NAMES) 
         Config.Bannable.BodyParts[name] ==   Config.Bannable.BodyParts[name] =  
    

  ()
    ()
      Config.Bannable.BodyPartsEnabled   { , ,  } 
     out = {}
     _, name  (BODY_PART_NAMES) 
         Config.Bannable.BodyParts[name] ==   out[#out+] = name 
    
     #out ==    { ,  } 
     out

  (player, names)
     char = player  player.Character
      char    
    names = names  ()
     out = {}
     _, name  (names) 
         part = char:(name)
         part  part:()  out[#out+] = part 
    
     #out >   out  

  (player, names)
     parts = (player, names)
      parts    
     total = ;  weights = {}
     _, part  (parts) 
         w = BODY_WEIGHTS[part.Name]  
        weights[#weights+] = w; total = total + w
    
     total <=    parts[] 
     roll = .() * total;  acc = 
     i, part  (parts) 
        acc = acc + weights[i]
         roll <= acc   part 
    
     parts[]

  ()  () 
  ()
     c = .((Config.Bannable.HitChance)  , , )
     c >=     
     c <=     
     (.() * ) <= c


  (tool)
      (tool  tool:())    
     fire = tool:()
     fire  fire:()    
     beam = tool:()
     beam  beam:()    
     

  (tool)
      (tool  tool:())    
     kill = tool:()
     name = (tool.Name  ):()
     (kill  kill:())  name:(, , ) ~= 

  (char, predicate)
      char    
     _, child  (char:()) 
         (child)   child 
    
     

  ()  (LocalPlayer.Character, IsKnife) 
  ()
     char = LocalPlayer.Character
      char    
     equipped = (char, IsFirearm)
     equipped   equipped 
     backpack = LocalPlayer:()
     backpack 
         candidate = (backpack, IsFirearm)
         candidate 
             hum = (LocalPlayer)
             hum 
                (() hum:(candidate) )
                .()
                 candidate.Parent == char   candidate 
            
        
    
     


  (target)
      target   target.Parent    
      (target)    
     char = LocalPlayer.Character
     hum = (LocalPlayer)
      (char  hum  hum.Health > )    
     tool = ()  ()
      tool    
    (()
         SilentAim  SilentAim.Set 
             aimPart = (target, ())
             aimPart 
                SilentAim:(aimPart)
                SilentAim:()
            
        
    )
     backpack = LocalPlayer:()
     wasEquipped = tool.Parent == char
    (()
          wasEquipped  hum:(tool); .() 
        tool:()
    )
    .(, ()
          wasEquipped  tool.Parent == LocalPlayer.Character  backpack 
            (() tool.Parent = backpack )
        
        (()
             SilentAim  SilentAim.Set 
                SilentAim:()
                SilentAim:()
            
        )
    )
     


 SharedRaycast = { _params = , _lastFilter =  }
  (ignoreChar)
      SharedRaycast._params  SharedRaycast._lastFilter ~= ignoreChar 
         p = SharedRaycast._params
          p 
            p = RaycastParams.()
            p.FilterType = .RaycastFilterType.Exclude
            p.IgnoreWater = 
            SharedRaycast._params = p
        
        p.FilterDescendantsInstances = ignoreChar  { ignoreChar }  {}
        SharedRaycast._lastFilter = ignoreChar
    
     SharedRaycast._params

  (target, targetPart)
     myChar = LocalPlayer.Character
     myHRP  = (LocalPlayer)
      (myChar  myHRP  target  target.Character  targetPart  targetPart:())    
     dir = targetPart.Position - myHRP.Position
     dir.Magnitude <=     
     params = (myChar)
     hit = :(myHRP.Position, dir, params)
     ( hit)  (hit.Instance  hit.Instance:(target.Character))

  (targetPart, origin, params)
     size = targetPart.Size
     offsets = {
        .zero,
        .(size.X / , , ),
        .(-size.X / , , ),
        .(, size.Y / , ),
        .(, -size.Y / , ),
    }
     _, off  (offsets) 
         targetPos = targetPart.CFrame * off
          :(origin, targetPos - origin, params)    
    
     

  ()
     (gethui) ==  
         ok, hui = (gethui)
         ok  hui   hui 
    
     ok, cg = (()  :() )
     ok  cg   cg 
     LocalPlayer:()

  ()
     pg = LocalPlayer:()
     main = (pg  pg:())  pg
     frame = main  main:()
     score = frame  frame:()
     timer = score  score:()
      timer    
     (timer.Text  ):() ~= 





 WindWindow = WindUI:({
    Title = ,
    Icon = ,
    Author = ,
    Folder = ,
    Theme = ,
    NewElements = ,
    OpenButton = {
        Title = ,
        Icon = ,
        CornerRadius = .(, ),
        StrokeThickness = ,
        Color = ColorSequence.(.(,,), .(,,)),
        OnlyMobile = ,
        Enabled = ,
        Draggable = ,
    },
})

(()
    WindWindow:({
        Title = ,
        Icon = ,
        Color = .(, , ),
        Radius = ,
    })
)

(()
    WindWindow:({
        Title = ,
        Icon = ,
        CornerRadius = .(, ),
        StrokeThickness = ,
        Color = ColorSequence.(.(,,), .(,,)),
        OnlyMobile = ,
        Enabled = ,
        Draggable = ,
    })
)

 CONFIG_MANAGER = 
(()
     WindWindow.ConfigManager 
        CONFIG_MANAGER = WindWindow.ConfigManager:()
    
)

 SKIP_SAVE = 
  ()
      IS_LOADING_CONFIG   SKIP_SAVE  CONFIG_MANAGER 
        (() CONFIG_MANAGER:() )
    

 AUTO_SAVE_ACC = 
 CONFIG_AUTOSAVE_CONN = RunService.Heartbeat:((dt)
    AUTO_SAVE_ACC = AUTO_SAVE_ACC + dt
     AUTO_SAVE_ACC <    
    AUTO_SAVE_ACC = 
    ()
)

  (title, content, icon, duration)
     Config.Notifications.Enabled 
        (()
            WindUI:({ Title = title, Content = content, Duration = duration  , Icon = icon   })
        )
    






 JumpPowerHandler = {}
JumpPowerHandler.__index = JumpPowerHandler
 JumpPowerHandler.()
     ({ _running=, _conns=ConnectionBucket.(), _humanoid=, _original= }, JumpPowerHandler)

 JumpPowerHandler:()  (LocalPlayer) 
 JumpPowerHandler:(h)
      h  h == self._humanoid   
    self._humanoid = h
    self._original = { UseJumpPower=h.UseJumpPower, JumpPower=h.JumpPower, JumpHeight=h.JumpHeight }

 JumpPowerHandler:()
     char = LocalPlayer.Character
      char    
     hum = char:()
     hum  self:(hum) 
     hum

 JumpPowerHandler:(h)
    h = h  self:()
      h   self._original   
    (()
        h.UseJumpPower = self._original.UseJumpPower
         self._original.UseJumpPower  h.JumpPower = self._original.JumpPower
         h.JumpHeight = self._original.JumpHeight 
    )

 JumpPowerHandler:(h)
    h = h  self:()
      h   
    self:(h)
     Config.PlayerCheats.JumpPowerEnabled  self:() 
         p = .(, (Config.PlayerCheats.JumpPower)  )
        (() h.UseJumpPower = ; h.JumpPower = p *  )
    
        self:(h)
    

 JumpPowerHandler:()
     self._running   
    self._running = 
    self._conns:(LocalPlayer:():(()  self._running  self:()  ))
    self._conns:(LocalPlayer.CharacterAdded:((char)
        .(()
             hum = (char, , )
             hum  self._humanoid = ; self:(hum) 
        )
    ))
    self._conns:(UserInputService.JumpRequest:(()
          Config.PlayerCheats.InfiniteJump   
          self:()   
         hum = self:()
         hum  (() hum:(.HumanoidStateType.Jumping) ) 
    ))

 JumpPowerHandler:()
      self._running  self:();  
    self._running = ; self._conns:(); self:()

 JumpPowerHandler:()
     Config.PlayerCheats.JumpPowerEnabled  Config.PlayerCheats.InfiniteJump  self:(); self:()  self:() 


 SpeedHandler = {}
SpeedHandler.__index = SpeedHandler
 SpeedHandler.()
     ({ _running=, _conns=ConnectionBucket.(), _humanoid=, _originalSpeed=, _watchConn=, _watchedHumanoid= }, SpeedHandler)

 SpeedHandler:()  (LocalPlayer) 
 SpeedHandler:()  .(, (Config.PlayerCheats.Speed)  ) 
 SpeedHandler:(h)
      h  h == self._humanoid   
    self._humanoid = h; self._originalSpeed = h.WalkSpeed

 SpeedHandler:()
     char = LocalPlayer.Character
      char    
     hum = char:()
     hum  self:(hum) 
     hum

 SpeedHandler:(h)
      h  h == self._watchedHumanoid   
    self:()
    self._watchedHumanoid = h
    self._watchConn = h:():(()
          self._running   Config.PlayerCheats.SpeedEnabled   self:()   
         target = self:()
         .(((h.WalkSpeed)  ) - target) >  
            (() h.WalkSpeed = target )
        
    )

 SpeedHandler:()
     self._watchConn  (() self._watchConn:() ); self._watchConn =  
    self._watchedHumanoid = 

 SpeedHandler:(h)
    h = h  self:()
      h   
    self:(h); self:(h)
     Config.PlayerCheats.SpeedEnabled 
         s = self:()
        (() h.WalkSpeed = s )
    
        self:(h)
    

 SpeedHandler:(h)
    h = h  self:()
      h  self._originalSpeed ==    
    (() h.WalkSpeed = self._originalSpeed )

 SpeedHandler:()
     self._running   
    self._running = 
    self._conns:(LocalPlayer:():(()  self._running  self:()  ))
    self._conns:(LocalPlayer.CharacterAdded:((char)
        .(()
             hum = (char, , )
             hum  self._humanoid = ; self:(hum) 
        )
    ))

 SpeedHandler:()
      self._running  self:(); self:();  
    self._running = ; self._conns:(); self:(); self:()

 SpeedHandler:()
     Config.PlayerCheats.SpeedEnabled  self:(); self:()  self:() 


 FloatingFloorHandler = {}
FloatingFloorHandler.__index = FloatingFloorHandler
 FLOOR_SIZE, FLOOR_OFFSET = .(,,), 
 FLOOR_MIN_Y, FLOOR_MAX_Y = -, 
 FloatingFloorHandler.()
     ({ _running=, _hideMapActive=, _conns=ConnectionBucket.(), _floorPart=, _baseY=, _offsetY=, _hiddenMoved={}, _hiddenRoot= }, FloatingFloorHandler)

 FloatingFloorHandler:()  (LocalPlayer) 
 FloatingFloorHandler:()  (LocalPlayer) 
 FloatingFloorHandler:()
     base = self._baseY  
     .(base + (self._offsetY  ), FLOOR_MIN_Y, FLOOR_MAX_Y)

 FloatingFloorHandler:()
     self._floorPart  self._floorPart.Parent   self._floorPart 
     part = .()
    part.Name = 
    part.Size = FLOOR_SIZE
    part.Anchored = 
    part.CanCollide = 
    part.Transparency = 
    part.Material = .Material.SmoothPlastic
    part.Parent = 
    self._floorPart = part
     part

 FloatingFloorHandler:()
     self._floorPart  (() self._floorPart:() ); self._floorPart =  

 FloatingFloorHandler:()
      self._running   
     hrp = self:()
      hrp   
      self._baseY  self._baseY = hrp.Position.Y - FLOOR_OFFSET 
     part = self:()
    part.CFrame = .(hrp.Position.X, self:(), hrp.Position.Z)

 FloatingFloorHandler:()
      self:()  self._hideMapActive = ;  
     activeMaps = :()
      activeMaps   
     matchId = LocalPlayer:()
     map = 
     (matchId) ==   matchId ~=   map = activeMaps:(matchId) 
      map   
    self:()
     folder = self._hiddenRoot
      folder   folder.Parent 
        folder = .()
        folder.Name = 
        folder.Parent = Lighting
        self._hiddenRoot = folder
    
     _, name  ({,,,}) 
         child = map:(name)
         child  self._hiddenMoved[child] = child.Parent; child.Parent = folder 
    
    self._hideMapActive = 

 FloatingFloorHandler:()
     obj, parent  (self._hiddenMoved) 
         obj  obj.Parent 
             ok = 
            (() ok = parent  parent:() )
             ok  (() obj.Parent = parent )
             (() obj:() ) 
        
    
    .(self._hiddenMoved); self._hideMapActive = 

 FloatingFloorHandler:()
     self._running  self:();  
    self._running = 
    self._offsetY = 
    Config.FloatingFloor.Height = 
     hrp = self:()
     hrp  self._baseY = hrp.Position.Y - FLOOR_OFFSET 
    self:(); self:()
    self._conns:(RunService.Heartbeat:(()
        self:()
         Config.FloatingFloor.HideMap   self._hideMapActive  self:() 
    ))
    self._conns:(LocalPlayer.CharacterAdded:(()
        .(()
              self._running   
             h = self:()
             h  self._baseY = h.Position.Y - FLOOR_OFFSET 
        )
    ))

 FloatingFloorHandler:()
      self._running  self:();  
    self._running = ; self._conns:(); self._baseY = 
    Config.FloatingFloor.Height = 
    self:()

 FloatingFloorHandler:()
    Config.FloatingFloor.HideMap = 
    self:()
     self._hiddenRoot  (() self._hiddenRoot:() ); self._hiddenRoot =  
    self._running = ; self._conns:(); self._baseY = 
    self:()

 FloatingFloorHandler:()
     Config.FloatingFloor.Enabled  Config.FloatingFloor.HideMap 
        self:()
         Config.FloatingFloor.HideMap  self:()  self:() 
        self:()
    
        self:(); self:()
    


 SilentAim = {
    _hookInstalled=, _hookFailed=, _target=, _holding=,
    _maxDistance=, _minRayLength=, _origNamecall=,
}
 SilentAim:(target) self._target = target 
 SilentAim:()  self._target ~=   self._target.Parent ~=  
 SilentAim:(v) self._holding = v ==  
 SilentAim:()  self._holding ==   self:() 
 SilentAim:(contextName)
     self._hookInstalled    
     () ~=   () ~= 
         (getnamecallmethod) ~=   (checkcaller) ~=  
          self._hookFailed 
            self._hookFailed = 
            (contextName  , , , )
        
         
    
     selfRef = self
     wrap = (() == )    (fn)  fn 
     ok = (()
         mt = ()
         oldNamecall = mt.__namecall
         newNamecall = ((obj, ...)
             target = selfRef._target
             target  target.Parent  obj ==    () 
                 method = ()
                 method ==  
                     origin, dir, params = ...
                     (dir) ==   dir.Magnitude > selfRef._minRayLength 
                         newDir = (target.Position - origin).Unit * selfRef._maxDistance
                         (obj, origin, newDir, params)
                    
                 .(method, ) 
                     ray, ignore, terr, mat = ...
                     (ray) ==   ray.Direction.Magnitude > selfRef._minRayLength 
                         newRay = Ray.(ray.Origin, (target.Position - ray.Origin).Unit * selfRef._maxDistance)
                         (obj, newRay, ignore, terr, mat)
                    
                
            
             (obj, ...)
        )
        (mt, ); mt.__namecall = newNamecall; (mt, )
        selfRef._origNamecall = oldNamecall; selfRef._hookWrapper = newNamecall
    )
     ok  self._hookInstalled =  
     self._hookInstalled

 SilentAim:()
      self._hookInstalled   
    (()
         mt = ()
         self._hookWrapper  self._origNamecall  (mt.__namecall, self._hookWrapper) 
            (mt, ); mt.__namecall = self._origNamecall; (mt, )
        
    )
    self._hookInstalled = ; self._origNamecall = ; self._hookWrapper = 

 SilentAim:(useRaycast)
     myChar = LocalPlayer.Character
     myHRP = (LocalPlayer)
      (myChar  myHRP)   ,  
     parts = ()
     cursor = ()
     bestPlayer, bestPart, bestDist = , , .huge
      self._rayParams 
        self._rayParams = RaycastParams.()
        self._rayParams.FilterType = .RaycastFilterType.Exclude
        self._rayParams.IgnoreWater = 
    
     _, player  (Players:()) 
         player ~= LocalPlayer  (player)  (player) 
             pp = (player, parts)
             pp 
                self._rayParams.FilterDescendantsInstances = { myChar, player.Character }
                 _, part  (pp) 
                      useRaycast  (player, part) 
                         screenPos, onScreen = .CurrentCamera:(part.Position)
                         onScreen 
                             d = (.(screenPos.X, screenPos.Y) - cursor).Magnitude
                             d < bestDist  bestPlayer, bestPart, bestDist = player, part, d 
                        
                    
                
            
        
    
     bestPlayer, bestPart

 SilentAim:()
      self:()   
     self._running   
    self._running = 
    self._loopConn = RunService.RenderStepped:(()
          self._running   
         _, part = self:(Config.Bannable.AimFollowRaycast)
        self:(part  )
    )
    self._inputConn1 = UserInputService.InputBegan:((input, processed)
          self._running  processed   
         input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
            self:()
        
    )
    self._inputConn2 = UserInputService.InputEnded:((input, processed)
          self._running  processed   
         input.UserInputType == .UserInputType.MouseButton1  input.UserInputType == .UserInputType.Touch 
            self:()
        
    )

 SilentAim:()
      self._running  self:();  
    self._running = ; self._target = ; self._holding = 
     self._loopConn  (() self._loopConn:() ) 
     self._inputConn1  (() self._inputConn1:() ) 
     self._inputConn2  (() self._inputConn2:() ) 
    self._loopConn, self._inputConn1, self._inputConn2 = , , 
    self:()


 TriggerbotHandler = {}
TriggerbotHandler.__index = TriggerbotHandler
TriggerbotHandler.FIRE_COOLDOWN = 
TriggerbotHandler.RELEASE_DELAY = 
 TriggerbotHandler.()
     ({ _running=, _conns=ConnectionBucket.(), _target=, _lastFire=, _firing=, _fingerDown=, _fingerTime=, _rayParams= }, TriggerbotHandler)

 TriggerbotHandler:()
     hrp = (LocalPlayer)
      (LocalPlayer.Character  hrp)    
     origin = hrp.Position
     bodyParts = ()
     result = 
     _, player  (Players:()) 
         (player)  (player) 
             parts = (player, bodyParts)
             parts 
                  self._rayParams 
                    self._rayParams = RaycastParams.()
                    self._rayParams.FilterType = .RaycastFilterType.Exclude
                    self._rayParams.IgnoreWater = 
                
                self._rayParams.FilterDescendantsInstances = { LocalPlayer.Character, player.Character }
                 _, part  (parts) 
                     dist = (part.Position - origin).Magnitude
                     (player, part) 
                        result = result  {}
                        result[#result+] = { player = player, parts = parts, distance = dist }
                    
                
            
        
    
     result

 TriggerbotHandler:()
     list = self._target
      list    
     _, entry  (list) 
         aimPart = (entry.player, ())
         aimPart  ()   aimPart 
    
     

 TriggerbotHandler:()
      self._running  self._firing   
     char = LocalPlayer.Character
     hum = (LocalPlayer)
      (char  hum  hum.Health > )   
     tool = ()  ()
      tool   
     target = self:()
      (target  target.Parent)   
    SilentAim:(()  target  )
    SilentAim:()
    self._firing = 
    .(()
         backpack = LocalPlayer:()
         wasEquipped = tool.Parent == char
        (()
              wasEquipped  hum:(tool); .(TriggerbotHandler.RELEASE_DELAY) 
            tool:()
        )
        .(TriggerbotHandler.FIRE_COOLDOWN)
          wasEquipped  tool.Parent == LocalPlayer.Character  backpack 
            (() tool.Parent = backpack )
        
        SilentAim:(); SilentAim:(); self._firing = 
    )

 TriggerbotHandler:()
    self._target = self:()
      self._target   
     now = .()
     now - self._lastFire < TriggerbotHandler.FIRE_COOLDOWN   
    self._lastFire = now
    self:()

 TriggerbotHandler:()
     self._running   
    self._running = 
    self._lastFire = ; self._firing = ; self._fingerDown = ; self._target = 
    self._conns:(RunService.RenderStepped:(()  self._running  self:()  ))
    self._conns:(UserInputService.InputBegan:((input, processed)
          self._running  processed   
         input.UserInputType == .UserInputType.MouseButton1  self:()
         input.UserInputType == .UserInputType.Touch 
            self._fingerDown = input.Position; self._fingerTime = .()
        
    ))
    self._conns:(UserInputService.InputEnded:((input, processed)
          self._running  processed  input.UserInputType ~= .UserInputType.Touch   
          self._fingerDown   
         delta = (input.Position - self._fingerDown).Magnitude
         elapsed = .() - (self._fingerTime  )
        self._fingerDown = 
         delta <   elapsed <   self:() 
    ))

 TriggerbotHandler:()
      self._running   
    self._running = ; self._target = ; self._fingerDown = 
    SilentAim:(); SilentAim:(); self._conns:()


 MacroHandler = {}
MacroHandler.__index = MacroHandler
MacroHandler.EQUIP_DELAY = 
MacroHandler.FIRE_DELAY = 
 MacroHandler.()
     ({ _running=, _conns=ConnectionBucket.(), _candidates=, _busy=, _rayParams= }, MacroHandler)

 MacroHandler:()
     hrp = (LocalPlayer)
      (LocalPlayer.Character  hrp)    
     origin = hrp.Position
     bodyParts = ()
     out = 
     _, player  (Players:()) 
         (player)  (player) 
             parts = (player, bodyParts)
             parts 
                 best = .huge
                 _, part  (parts) 
                     d = (part.Position - origin).Magnitude
                     d < best  best = d 
                
                out = out  {}
                out[#out+] = { player = player, parts = parts, distance = best }
            
        
    
     out  .(out, (a,b)  a.distance < b.distance ) 
     out

 MacroHandler:()
     list = self._candidates
      list    
     myChar = LocalPlayer.Character
     myHRP = (LocalPlayer)
      (myChar  myHRP)    
      self._rayParams 
        self._rayParams = RaycastParams.()
        self._rayParams.FilterType = .RaycastFilterType.Exclude
        self._rayParams.IgnoreWater = 
    
     _, entry  (list) 
         char = entry.player.Character
         char  (entry.player)  (entry.player) 
            self._rayParams.FilterDescendantsInstances = { myChar, char }
             _, part  (entry.parts) 
                 (part, myHRP.Position, self._rayParams)   part 
            
        
    
     

 MacroHandler:()
      self._running  self._busy   
     char = LocalPlayer.Character
     hum = (LocalPlayer)
      (char  hum  hum.Health > )   
     knife = ()
      knife   
     target = self:()
      (target  target.Parent)   
    SilentAim:(()  target  )
    SilentAim:()
    self._busy = 
    .(()
         backpack = LocalPlayer:()
         wasEquipped = knife.Parent == char
        (()
              wasEquipped  hum:(knife); .(MacroHandler.EQUIP_DELAY) 
            knife:()
        )
        .(MacroHandler.FIRE_DELAY)
          wasEquipped  knife.Parent == LocalPlayer.Character  backpack 
            (() knife.Parent = backpack )
        
        SilentAim:(); SilentAim:(); self._busy = 
    )

 MacroHandler:()
     self._running   
    self._running = ; self._busy = ; self._candidates = 
    self._conns:(RunService.Heartbeat:(()
         self._running  self._candidates = self:() 
    ))
    self._conns:(UserInputService.InputBegan:((input, processed)
          self._running  processed   
         input.UserInputType == .UserInputType.MouseButton1  self:() 
    ))

 MacroHandler:()
      self._running   
    self._running = ; self._candidates = 
    SilentAim:(); SilentAim:(); self._conns:()


 AutoShootHandler = {}
AutoShootHandler.__index = AutoShootHandler
AutoShootHandler.COOLDOWN = 
AutoShootHandler.HOLD_EXTRA = 
 AutoShootHandler.()
     ({ _running=, _conns=ConnectionBucket.(), _target=, _lastFire=, _rayParams= }, AutoShootHandler)

 AutoShootHandler:()
     myChar = LocalPlayer.Character
     myHRP = (LocalPlayer)
      (myChar  myHRP)    
     bodyParts = ()
     best, bestDist = , .huge
      self._rayParams 
        self._rayParams = RaycastParams.()
        self._rayParams.FilterType = .RaycastFilterType.Exclude
        self._rayParams.IgnoreWater = 
    
     _, player  (Players:()) 
         (player)  (player) 
             parts = (player, bodyParts)
             parts 
                self._rayParams.FilterDescendantsInstances = { myChar, player.Character }
                 _, part  (parts) 
                     d = (part.Position - myHRP.Position).Magnitude
                     d < bestDist  (part, myHRP.Position, self._rayParams) 
                        best, bestDist = part, d
                    
                
            
        
    
     best

 AutoShootHandler:()
      self._running   
     char = LocalPlayer.Character
     hum = (LocalPlayer)
      (char  hum  hum.Health > )   
     tool = ()  ()
      tool   
     target = self:()
      (target  target.Parent)   
    SilentAim:(target); SilentAim:()
    self._lastFire = .()
    (() tool:() )
    .(AutoShootHandler.HOLD_EXTRA, ()
         tool.Parent == LocalPlayer.Character  (() tool:() ) 
    )

 AutoShootHandler:()
      SilentAim:()   
     self._running   
    self._running = ; self._lastFire = ; self._target = 
    self._conns:(RunService.Heartbeat:(()
          self._running   
        self._target = self:()
        SilentAim:(self._target)
          self._target   
         now = .()
         now - self._lastFire < AutoShootHandler.COOLDOWN   
        self._lastFire = now
        self:()
    ))

 AutoShootHandler:()
      self._running   
    self._running = ; self._target = 
    SilentAim:(); SilentAim:(); self._conns:()


 AimFollowHandler = {}
AimFollowHandler.__index = AimFollowHandler
 AimFollowHandler.()
     ({ _running=, _conns=ConnectionBucket.(), _cachedPlayer=, _cachedPart=, _cacheTime=, _cacheInterval= }, AimFollowHandler)

  ()
     onlyFire = Config.Bannable.AimFollowFirearmOnly
     onlyKnife = Config.Bannable.AimFollowKnifeOnly
      onlyFire   onlyKnife    
     char = LocalPlayer.Character
     (onlyFire  (char, IsFirearm) ~= )
         (onlyKnife  (char, IsKnife) ~= )

 AimFollowHandler:(useRaycast)
     now = .()
     self._cachedPart  self._cachedTime  self._cachedPlayer
         (now - self._cacheTime) < self._cacheInterval
         (self._cachedPlayer)  (self._cachedPlayer)
         self._cachedPart.Parent  self._cachedPart:(self._cachedPlayer.Character) 
         self._cachedPlayer, self._cachedPart
    
    self._cacheTime = now
     myHRP = (LocalPlayer)
      myHRP   ,  
     bodyParts = ()
     bestPlayer, bestPart, bestDist = , , .huge
     _, player  (Players:()) 
         player ~= LocalPlayer  (player)  (player) 
             part = (player, bodyParts)
             part  ( useRaycast  (player, part)) 
                 d = (myHRP.Position - part.Position).Magnitude
                 d < bestDist  bestPlayer, bestPart, bestDist = player, part, d 
            
        
    
    self._cachedPlayer, self._cachedPart = bestPlayer, bestPart
     bestPlayer, bestPart

 AimFollowHandler:()
      self._running   ()   
     cam = .CurrentCamera
     _, part = self:(Config.Bannable.AimFollowRaycast)
     cam  part  cam.CFrame = .(cam.CFrame.Position, part.Position) 

 AimFollowHandler:()
     self._running   
    self._running = 
    self._cachedPlayer, self._cachedPart, self._cacheTime = , , 
    self._conns:(RunService.RenderStepped:(() self:() ))

 AimFollowHandler:()
      self._running   
    self._running = 
    self._cachedPlayer, self._cachedPart, self._cacheTime = , , 
    self._conns:()





 ESPHandler = {}
ESPHandler.__index = ESPHandler
 ESPHandler.()
     ({
        _running = ,
        _conns = ConnectionBucket.(),
        _container = ,
        _highlights = {},
        _billboards = {},
    }, ESPHandler)

 ESPHandler:()
     self._container  self._container.Parent   self._container 
     parent = ()
      parent    
     sg = .()
    sg.Name = 
    sg.ResetOnSpawn = 
    sg.IgnoreGuiInset = 
    sg.DisplayOrder = 
    sg.ZIndexBehavior = .ZIndexBehavior.Sibling
    sg.Enabled = 
    sg.Parent = parent
    self._container = sg
     sg

 ESPHandler:()
     self._container  (() self._container:() ); self._container =  

 ESPHandler:(player)
      player  player == LocalPlayer    
      (player)    
     Config.ESP.TeamCheck 
          (player)    
    
     

 ESPHandler:(player)
      self:(player)  self:(player);  
     char = player.Character
      char  self:(player);  

     highlight = self._highlights[player]
      highlight   highlight.Parent 
         container = self:()
          container   
        highlight = .()
        highlight.Name = 
        highlight.DepthMode = .HighlightDepthMode.AlwaysOnTop
        highlight.Parent = container
        self._highlights[player] = highlight
    

     color = (Config.ESP.Color, .(, , ))
    highlight.Adornee = char
    highlight.FillColor = color
    highlight.OutlineColor = color
    highlight.FillTransparency = .(Config.ESP.FilledTransparency, , )
    highlight.OutlineTransparency = 
    highlight.Enabled = 

 ESPHandler:(player)
     h = self._highlights[player]
    self._highlights[player] = 
     h  (() h:() ) 
    self:(player)

 ESPHandler:(player)
      (Config.ESP.ShowName  Config.ESP.ShowDistance) 
        self:(player)
        
    
      self:(player)  self:(player);  
     char = player.Character
     head = char  (char:()  char:())
      head   head:()  self:(player);  

     bb = self._billboards[player]
      bb   bb.Parent  bb.Adornee ~= head 
         bb  (() bb:() ) 
        bb = .()
        bb.Name = 
        bb.AlwaysOnTop = 
        bb.Size = .(, )
        bb.StudsOffset = .(, , )
        bb.Adornee = head
        bb.Parent = self:()

         label = .()
        label.Name = 
        label.BackgroundTransparency = 
        label.Size = .(, , , )
        label.Font = .Font.GothamBold
        label.TextScaled = 
        label.TextSize = 
        label.TextStrokeTransparency = 
        label.TextStrokeColor3 = .(,,)
        label.TextColor3 = .(, , )
        label.Text = 
        label.Parent = bb
        self._billboards[player] = bb
    

     myHRP = (LocalPlayer)
     tHRP = (player)
     distText = 
     Config.ESP.ShowDistance  myHRP  tHRP 
        distText = .(, .((tHRP.Position - myHRP.Position).Magnitude))
    

     label = bb:()
     label 
         color = (Config.ESP.Color, .(, , ))
        label.TextColor3 = color
         Config.ESP.ShowName 
            label.Text = player.Name .. distText
        
            label.Text = distText ~=   distText  
        
    

 ESPHandler:(player)
     bb = self._billboards[player]
    self._billboards[player] = 
     bb  (() bb:() ) 

 ESPHandler:()
      self._running   
     _, player  (Players:()) 
         player ~= LocalPlayer 
            self:(player)
            self:(player)
        
    

 ESPHandler:()
     self._running   
    self._running = 
    self:()
    self:()
    self._conns:(Players.PlayerAdded:((p)
        .(() self:(p); self:(p) )
    ))
    self._conns:(Players.PlayerRemoving:((p) self:(p) ))
    self._conns:(RunService.Heartbeat:(()
          self._running   
        self:()
    ))

 ESPHandler:()
      self._running  self:();  
    self._running = 
    self._conns:()
     player  (self._highlights)  self:(player) 
     player  (self._billboards)  self:(player) 
    .(self._highlights)
    .(self._billboards)
    self:()


 ESPLinesHandler = {}
ESPLinesHandler.__index = ESPLinesHandler
 ESPLinesHandler.()
     ({ _running=, _conns=ConnectionBucket.(), _drawingLib=, _lines={}, _playerList={}, _lastUpdate=, _updateInterval= }, ESPLinesHandler)

  ()
     d = (, )
     d  (d.new) ==    d 
     () ==  
         env = ()
         env  env.Drawing  (env.Drawing.new) ==    env.Drawing 
    
     

 ESPLinesHandler:()
     self._drawingLib   self._drawingLib 
    self._drawingLib = ()
     self._drawingLib

 ESPLinesHandler:(player)
     char = player  player.Character
      char    
     char:()  char:()  char:()

 ESPLinesHandler:(player)
     self._lines[player]   self._lines[player] 
     lib = self:()
      lib    
     ok, line = (()
         l = lib.()
        l.Visible = 
        l.Color = (Config.ESP.LinesColor, .(, , ))
        l.Thickness = ; l.Transparency = 
         l
    )
     ok  line  self._lines[player] = line;  line 
     

 ESPLinesHandler:(player)
     line = self._lines[player]
    self._lines[player] = 
     line 
        (() line.Visible =  )
        (()  line.Remove  line:()  line.Destroy  line:()  )
    

 ESPLinesHandler:()
     keys = {}
     p  (self._lines)  keys[#keys+] = p 
     _, p  (keys)  self:(p) 

 ESPLinesHandler:()
     list = {}
     _, player  (Players:()) 
         player ~= LocalPlayer  (player)  (player)  list[#list+] = player 
    
    self._playerList = list

 ESPLinesHandler:()
     cam = .CurrentCamera
     myHRP = (LocalPlayer)
      (cam  myHRP)  self:();  
     now = .()
     (now - (self._lastUpdate  )) >= self._updateInterval 
        self._lastUpdate = now
        self:()
    
     viewport = cam.ViewportSize
     sx, sy, onScreen = cam:(myHRP.Position)
     from = .(sx, sy)
      onScreen  sx <=   from = .(viewport.X * , viewport.Y - ) 
     color = (Config.ESP.LinesColor, .(, , ))
     shown = {}
     _, player  (self._playerList) 
         part = self:(player)
         line = self:(player)
         part  line 
             line.Color ~= color  line.Color = color 
             px, py, pz = cam:(part.Position)
             pz >  
                line.From = from; line.To = .(px, py); line.Visible = 
                shown[player] = 
            
                line.Visible = 
            
        
    
     player, line  (self._lines) 
          shown[player]  line  line.Visible =  
    

 ESPLinesHandler:()
     _, line  (self._lines) 
         line  (() line.Visible =  ) 
    

 ESPLinesHandler:()
     self._running   
    self._running = ; self._playerList = {}; self._lastUpdate = 
    self._conns:(RunService.RenderStepped:(()  self._running  self:()  ))

 ESPLinesHandler:()
      self._running  self:();  
    self._running = ; self._conns:(); self:(); self._playerList = {}


 InvisibleHandler = {}
InvisibleHandler.__index = InvisibleHandler
 InvisibleHandler.()
     ({ _running=, _conns=ConnectionBucket.(), _saved={} }, InvisibleHandler)

 InvisibleHandler:()
     char = LocalPlayer.Character
      char   
     _, desc  (char:()) 
         desc:() 
             self._saved[desc] ==   self._saved[desc] = desc.Transparency 
            desc.Transparency = .(desc.Transparency, )
         desc:()  desc:() 
            desc.Transparency = 
        
    

 InvisibleHandler:()
     part, original  (self._saved) 
         part  part.Parent  (() part.Transparency = original ) 
    
    .(self._saved)

 InvisibleHandler:()
     self._running   
    self._running = ; self._saved = {}
    self._conns:(RunService.Stepped:(()  self._running  self:()  ))
    self._conns:(LocalPlayer.CharacterAdded:(()
        .(()
            self._running = ; self._conns:(); self:()
        )
    ))

 InvisibleHandler:()
      self._running  self:();  
    self._running = ; self._conns:(); self:()


 DesyncHandler = {}
DesyncHandler.__index = DesyncHandler
 DesyncHandler.()
     ({ _running=, _conns=ConnectionBucket.(), _hrp=, _humanoid=, _velY=, _grounded= }, DesyncHandler)

 DesyncHandler:(dt)
     hrp = self._hrp
      (hrp  hrp.Parent)  self:();  
      hrp.Anchored  (() hrp.Anchored =  ) 
    dt = dt  
     hum = self._humanoid
     moveDir = hum  hum.MoveDirection  .zero
     moving = moveDir.Magnitude > 
     speed = hum  (hum.WalkSpeed)  
      speed  speed <=   speed =  
     cf = hrp.CFrame;  pos = cf.Position
     moving 
         np = pos + (moveDir * speed * dt)
        cf = .(np, np + moveDir); pos = cf.Position
    
    self._velY = (self._velY  ) - (.Gravity * dt)
    local newY = pos.Y + (self._velY * dt)
    if not self._rayParams then
        self._rayParams = RaycastParams.new()
        self._rayParams.FilterType = Enum.RaycastFilterType.Exclude
        self._rayParams.IgnoreWater = true
    end
    self._rayParams.FilterDescendantsInstances = { LocalPlayer.Character }
    local hit = workspace:Raycast(pos, Vector3.new(0, -200, 0), self._rayParams)
    local groundY = hit and hit.Position.Y
    local floorY = groundY and (groundY + (hum and hum.HipHeight or 2) + (hrp.Size.Y / 2)) or nil
    if floorY and newY <= floorY then
        newY = floorY; self._velY = 0; self._grounded = true
    else
        self._grounded = false
    end
    cf = CFrame.new(pos.X, newY, pos.Z) * (cf - cf.Position)
    pcall(function() hrp.CFrame = cf end)
end
function DesyncHandler:Start()
    if self._running then return end
    local hrp = GetHRP(LocalPlayer)
    if not hrp then return end
    self._running = true; self._hrp = hrp
    self._humanoid = GetHumanoid(LocalPlayer); self._velY = 0; self._grounded = true
    pcall(function()
        hrp.AssemblyLinearVelocity = Vector3.zero
        hrp.AssemblyAngularVelocity = Vector3.zero
        hrp.Anchored = true
    end)
    self._conns:add(RunService.RenderStepped:Connect(function(dt)
        if self._running then self:Update(dt) end
    end))
    self._conns:add(UserInputService.JumpRequest:Connect(function()
        if not (self._running and self._grounded) then return end
        local hum = GetHumanoid(LocalPlayer)
        if hum then
            local jp = 50
            if hum.UseJumpPower then jp = tonumber(hum.JumpPower) or jp
            else jp = math.sqrt(2 * workspace.Gravity * (tonumber(hum.JumpHeight) or 7)) end
            self._velY = jp; self._grounded = false
        end
    end))
    self._conns:add(LocalPlayer.CharacterAdded:Connect(function()
        task.defer(function()
            self._running = false; self._conns:clear()
            Config.Bannable.Desync = false
            if self._hrp then pcall(function() self._hrp.Anchored = false end) end
            self._hrp = nil
        end)
    end))
end
function DesyncHandler:Stop()
    if not self._running then return end
    self._running = false; self._conns:clear()
    local hrp = self._hrp
    self._hrp = nil; self._humanoid = nil; self._velY = 0; self._grounded = true
    if hrp and hrp.Parent then
        pcall(function()
            hrp.Anchored = false
            hrp.AssemblyLinearVelocity = Vector3.zero
            hrp.AssemblyAngularVelocity = Vector3.zero
        end)
    end
end

local EventFarmHandler = {}
EventFarmHandler.__index = EventFarmHandler
function EventFarmHandler.new()
    return setmetatable({ _running=false, _conns=ConnectionBucket.new(), _tick=0 }, EventFarmHandler)
end
function EventFarmHandler:TouchSpawnables()
    if type(firetouchinterest) ~= "function" then return end
    local hrp = GetHRP(LocalPlayer)
    if not hrp then return end
    local spawnables = workspace:FindFirstChild("SpawnablesClient")
    if not spawnables then return end
    for _, spawn in ipairs(spawnables:GetChildren()) do
        local touch = spawn:FindFirstChild("Touch", true)
        if touch and touch:IsA("BasePart") then
            pcall(function()
                firetouchinterest(hrp, touch, 0)
                firetouchinterest(hrp, touch, 1)
            end)
        end
    end
end
function EventFarmHandler:Start()
    if self._running then return end
    self._running = true; self._tick = 0
    self._conns:add(RunService.Heartbeat:Connect(function(dt)
        if not self._running then return end
        self._tick = self._tick + dt
        if self._tick < 0.5 then return end
        self._tick = 0
        if not HasGameAttribute(LocalPlayer) then return end
        self:TouchSpawnables()
    end))
end
function EventFarmHandler:Stop()
    if not self._running then return end
    self._running = false; self._tick = 0; self._conns:clear()
end

local BoxBuyerHandler = {}
BoxBuyerHandler.__index = BoxBuyerHandler
local BOX_LIST = {
    "Knife Box #1","Knife Box #2","Gun Box #1","Gun Box #2",
    "Mythic Box #1","Mythic Box #2","Mythic Box #3","Mythic Box #4",
}
local function GetBoxPrice(name)
    if type(name) == "string" and string.find(name, "Mythic", 1, true) then return 1500 end
    return 500
end
local function SetSelectedBox(name)
    if type(name) ~= "string" or name == "" then return end
    Config.Boxes.Selected = name
    Config.Boxes.Price = GetBoxPrice(name)
end
function BoxBuyerHandler.new()
    return setmetatable({ _running=false, _conns=ConnectionBucket.new(), _tick=0, _remote=nil }, BoxBuyerHandler)
end
function BoxBuyerHandler:GetBuyCaseRemote()
    if self._remote and self._remote.Parent then return self._remote end
    local packages = ReplicatedStorage:FindFirstChild("Packages")
    local net = packages and packages:FindFirstChild("Networking")
    local rf = net and net:FindFirstChild("RF/Shop/BuyCase")
    if rf and rf:IsA("RemoteFunction") then self._remote = rf; return rf end
    return nil
end
function BoxBuyerHandler:Purchase()
    local remote = self:GetBuyCaseRemote()
    if not remote then return false, "missing_remote" end
    local selected = tostring(Config.Boxes.Selected or "")
    if selected == "" then return false, "missing_selection" end
    local ok = pcall(function() remote:InvokeServer(selected) end)
    if not ok then return false, "invoke_failed" end
    return true, "ok"
end
function BoxBuyerHandler:Start()
    if self._running then return end
    self._running = true; self._tick = 0
    self._conns:add(RunService.Heartbeat:Connect(function(dt)
        if not self._running then return end
        self._tick = self._tick + dt
        if self._tick < 1 then return end
        self._tick = 0
        self:Purchase()
    end))
end
function BoxBuyerHandler:Stop()
    if not self._running then return end
    self._running = false; self._conns:clear()
end
SetSelectedBox(Config.Boxes.Selected)

local FOVHelper = {}
FOVHelper.__index = FOVHelper
function FOVHelper.new()
    return setmetatable({ _running=false, _conns=ConnectionBucket.new(), _ring=nil, _container=nil }, FOVHelper)
end
function FOVHelper:GetContainer()
    if self._container and self._container.Parent then return self._ring end
    local parent = GetGuiParent()
    if not parent then return nil end
    local sg = Instance.new("ScreenGui")
    sg.Name = "ErenHub_FOV"
    sg.ResetOnSpawn = false
    sg.IgnoreGuiInset = true
    sg.DisplayOrder = 999999
    sg.Enabled = false
    sg.Parent = parent
    local ring = Instance.new("Frame")
    ring.Name = "Ring"
    ring.AnchorPoint = Vector2.new(0.5, 0.5)
    ring.BackgroundTransparency = 1
    ring.BorderSizePixel = 0
    ring.Size = UDim2.fromOffset(400, 400)
    ring.Parent = sg
    local corner = Instance.new("UICorner")
    corner.CornerRadius = UDim.new(1, 0)
    corner.Parent = ring
    local stroke = Instance.new("UIStroke")
    stroke.Thickness = 1.5
    stroke.Color = Color3.fromRGB(255, 255, 255)
    stroke.Parent = ring
    self._container = sg; self._ring = ring
    return ring
end
function FOVHelper:DestroyContainer()
    self._ring = nil
    if self._container then pcall(function() self._container:Destroy() end); self._container = nil end
end
function FOVHelper:IsVisible() return Config.Bannable.FOVEnabled and Config.Bannable.FOVVisible end
function FOVHelper:Render()
    if not self:IsVisible() then
        if self._container then self._container.Enabled = false end
        return
    end
    local ring = self:GetContainer()
    if not ring then return end
    local cursor = GetCursorPosition()
    local radius = math.max(1, tonumber(Config.Bannable.FOVRadius) or 200)
    ring.Size = UDim2.fromOffset(radius * 2, radius * 2)
    ring.Position = UDim2.fromOffset(cursor.X, cursor.Y)
    self._container.Enabled = true
end
function FOVHelper:Start()
    if self._running then return end
    self._running = true
    self._conns:add(RunService.RenderStepped:Connect(function() self:Render() end))
end
function FOVHelper:Destroy()
    self._running = false; self._conns:clear(); self:DestroyContainer()
end

local PLATFORM_ROWS = { "Right Platforms", "Left Platforms" }
local PAD_TABLE = {
    ["Right Platforms"] = {
        ["1v1"] = { zone="PadZone1", Main="Pad1", Alt="Pad2" },
        ["2v2"] = { zone="PadZone2", Main="Pad1", Alt="Pad2" },
        ["3v3"] = { zone="PadZone3", Main="Pad1", Alt="Pad2" },
        ["4v4"] = { zone="PadZone4", Main="Pad1", Alt="Pad2" },
    },
    ["Left Platforms"] = {
        ["1v1"] = { zone="PadZone5", Main="Pad1", Alt="Pad2" },
        ["2v2"] = { zone="PadZone6", Main="Pad1", Alt="Pad2" },
        ["3v3"] = { zone="PadZone7", Main="Pad1", Alt="Pad2" },
        ["4v4"] = { zone="PadZone8", Main="Pad1", Alt="Pad2" },
    },
}
local function GetPadPart(role)
    local row = PAD_TABLE[Config.AutoTeleport.PlatformRow] and Config.AutoTeleport.PlatformRow or "Right Platforms"
    local duel = PAD_TABLE[row][Config.AutoTeleport.DuelType] and Config.AutoTeleport.DuelType or "1v1"
    local entry = PAD_TABLE[row][duel]
    local padZones = workspace:FindFirstChild("PadZones")
    local zone = padZones and padZones:FindFirstChild(entry.zone)
    local container = zone and zone:FindFirstChild(entry[role] or entry.Main)
    local pad = container and container:FindFirstChild("Pad")
    return (pad and pad:IsA("BasePart")) and pad or nil
end

local AutoTeleportHandler = {}
AutoTeleportHandler.__index = AutoTeleportHandler
function AutoTeleportHandler.new(role)
    return setmetatable({ _role=role or "Main", _running=false, _conns=ConnectionBucket.new(), _tick=0, _lastMove=0, _highlightedPad=nil, _savedPadColor=nil }, AutoTeleportHandler)
end
function AutoTeleportHandler:IsEnabled()
    if self._role == "Main" then return Config.AutoTeleport.Main end
    return Config.AutoTeleport.Alt
end
function AutoTeleportHandler:IsOnPad()
    local pad = GetPadPart(self._role)
    local hrp = GetHRP(LocalPlayer)
    if not (pad and hrp) then return false end
    local lp = pad.CFrame:PointToObjectSpace(hrp.Position)
    local half = pad.Size / 2
    return math.abs(lp.X) <= half.X + 0.5 and math.abs(lp.Z) <= half.Z + 0.5
        and lp.Y >= -(half.Y + 6) and lp.Y <= (half.Y + 14)
end
function AutoTeleportHandler:TimerVisible() return IsMatchTimerVisible() end
function AutoTeleportHandler:TeleportToPad()
    if not self:IsEnabled() then return end
    local pad = GetPadPart(self._role)
    if not pad or self:IsOnPad() then return end
    if os.clock() - self._lastMove < 0.5 then return end
    self._lastMove = os.clock()
    local hum = GetHumanoid(LocalPlayer)
    if hum then pcall(function() hum:MoveTo(pad.Position) end) end
end
function AutoTeleportHandler:HighlightPad(pad)
    if not pad then
        if self._highlightedPad and self._savedPadColor then
            local p, s = self._highlightedPad, self._savedPadColor
            pcall(function() if p.Parent then p.Color = s.Color; p.Transparency = s.Transparency end end)
        end
        self._highlightedPad, self._savedPadColor = nil, nil
        return
    end
    if self._highlightedPad ~= pad then
        if self._highlightedPad and self._savedPadColor then
            local p, s = self._highlightedPad, self._savedPadColor
            pcall(function() if p.Parent then p.Color = s.Color; p.Transparency = s.Transparency end end)
        end
        self._highlightedPad = pad
        self._savedPadColor = { Color=pad.Color, Transparency=pad.Transparency }
    end
    pad.Color = self._role == "Alt" and Color3.fromRGB(255, 70, 70) or Color3.fromRGB(70, 145, 255)
    pad.Transparency = 0.5
end
function AutoTeleportHandler:Refresh()
    if not self._running then return end
    if HasGameAttribute(LocalPlayer) and LocalPlayer.Character then self:HighlightPad(nil); return end
    local pad = GetPadPart(self._role)
    self:HighlightPad(pad)
    if self:TimerVisible() or self:IsOnPad() then return end
    self:TeleportToPad()
end
function AutoTeleportHandler:Start()
    if not self:IsEnabled() then return end
    if self._running then return end
    self._running = true; self._tick = 0
    self._conns:add(RunService.Heartbeat:Connect(function(dt)
        if not self._running then return end
        self._tick = self._tick + dt
        if self._tick < 0.5 then return end
        self._tick = 0
        self:Refresh()
    end))
    self:Refresh()
end
function AutoTeleportHandler:Stop()
    if not self._running then self:HighlightPad(nil); return end
    self._running = false; self._conns:clear(); self:HighlightPad(nil)
end

--=================================================================
-- TP CIRCLE (con Kill)
--=================================================================
local TPCircleHandler = {}
TPCircleHandler.__index = TPCircleHandler
function TPCircleHandler.new()
    return setmetatable({ _running=false, _conns=ConnectionBucket.new(), _angle=0, _killTick=0 }, TPCircleHandler)
end
function TPCircleHandler:FindTarget()
    local myHRP = GetHRP(LocalPlayer)
    if not myHRP then return nil end
    local myTeam = LocalPlayer:GetAttribute("Team")
    if typeof(myTeam) ~= "string" or myTeam == "" then return nil end
    local myGame = LocalPlayer:GetAttribute("Game")
    local myMap = LocalPlayer:GetAttribute("Map")
    local best, bestDist = nil, math.huge
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer and not IsAlly:check(player) then
            local hisTeam = player:GetAttribute("Team")
            local sameGame = (myGame == player:GetAttribute("Game"))
            local sameMap  = (myMap == player:GetAttribute("Map"))
            local isEnemyTeam = (typeof(hisTeam) == "string" and hisTeam ~= "" and hisTeam ~= myTeam)
            if isEnemyTeam and sameGame and sameMap and IsAlive(player) then
                local hrp = GetHRP(player)
                if hrp then
                    local d = (hrp.Position - myHRP.Position).Magnitude
                    if d < bestDist then best, bestDist = player, d end
                end
            end
        end
    end
    return best
end
function TPCircleHandler:Update(dt)
    if not self._running then return end
    local target = self:FindTarget()
    if not target then return end
    local targetHRP = GetHRP(target)
    local myHRP = GetHRP(LocalPlayer)
    if not (targetHRP and myHRP) then return end
    local distance = tonumber(Config.TPCircle.Distance) or 7
    local speed = tonumber(Config.TPCircle.Speed) or 3
    self._angle = (self._angle + speed * dt) % (math.pi * 2)
    local offset = Vector3.new(math.cos(self._angle) * distance, 0, math.sin(self._angle) * distance)
    local newPos = targetHRP.Position + offset
    pcall(function()
        myHRP.CFrame = CFrame.new(newPos, Vector3.new(targetHRP.Position.X, newPos.Y, targetHRP.Position.Z))
    end)
    if Config.TPCircle.KillEnabled then
        self._killTick = self._killTick + dt
        if self._killTick >= 0.15 then
            self._killTick = 0
            KillTarget(target)
        end
    end
end
function TPCircleHandler:Start()
    if self._running then return end
    self._running = true; self._angle = 0; self._killTick = 0
    self._conns:add(RunService.Heartbeat:Connect(function(dt)
        if self._running then self:Update(dt) end
    end))
end
function TPCircleHandler:Stop()
    if not self._running then return end
    self._running = false; self._conns:clear()
end
function TPCircleHandler:KillOnce()
    local target = self:FindTarget()
    if not target then
        Notify("TP Circle Kill", "No hay enemigo cercano.", "alert-triangle", 3)
        return
    end
    local targetHRP = GetHRP(target)
    local myHRP = GetHRP(LocalPlayer)
    if not (targetHRP and myHRP) then return end
    local distance = tonumber(Config.TPCircle.Distance) or 7
    local offset = Vector3.new(math.cos(self._angle) * distance, 0, math.sin(self._angle) * distance)
    local newPos = targetHRP.Position + offset
    pcall(function()
        myHRP.CFrame = CFrame.new(newPos, Vector3.new(targetHRP.Position.X, newPos.Y, targetHRP.Position.Z))
    end)
    KillTarget(target)
end

--=================================================================
-- TP ENEMY (Behind / Right / Left / Above) + Kill
--=================================================================
local TPEnemyHandler = {}
TPEnemyHandler.__index = TPEnemyHandler
function TPEnemyHandler.new()
    return setmetatable({ _running=false, _conns=ConnectionBucket.new(), _killTick=0 }, TPEnemyHandler)
end
function TPEnemyHandler:FindTarget()
    local myHRP = GetHRP(LocalPlayer)
    if not myHRP then return nil end
    local myTeam = LocalPlayer:GetAttribute("Team")
    if typeof(myTeam) ~= "string" or myTeam == "" then return nil end
    local myGame = LocalPlayer:GetAttribute("Game")
    local myMap = LocalPlayer:GetAttribute("Map")
    local best, bestDist = nil, math.huge
    for _, player in ipairs(Players:GetPlayers()) do
        if player ~= LocalPlayer and not IsAlly:check(player) then
            local hisTeam = player:GetAttribute("Team")
            local sameGame = (myGame == player:GetAttribute("Game"))
            local sameMap  = (myMap == player:GetAttribute("Map"))
            local isEnemyTeam = (typeof(hisTeam) == "string" and hisTeam ~= "" and hisTeam ~= myTeam)
            if isEnemyTeam and sameGame and sameMap and IsAlive(player) then
                local hrp = GetHRP(player)
                if hrp then
                    local d = (hrp.Position - myHRP.Position).Magnitude
                    if d < bestDist then best, bestDist = player, d end
                end
            end
        end
    end
    return best
end
function TPEnemyHandler:GetOffsetCFrame(targetHRP, myHRP)
    local distance = tonumber(Config.TPEnemy.Distance) or 4
    local mode = Config.TPEnemy.Mode or "Behind"
    local enemyLook = targetHRP.CFrame.LookVector
    local enemyRight = targetHRP.CFrame.RightVector
    local offset
    if mode == "Behind" then
        offset = -enemyLook * distance
    elseif mode == "Right" then
        offset = enemyRight * distance
    elseif mode == "Left" then
        offset = -enemyRight * distance
    elseif mode == "Above" then
        offset = Vector3.new(0, distance, 0)
    else
        offset = -enemyLook * distance
    end
    local newPos = targetHRP.Position + offset
    return CFrame.new(newPos, Vector3.new(targetHRP.Position.X, newPos.Y, targetHRP.Position.Z))
end
function TPEnemyHandler:TeleportOnce()
    local target = self:FindTarget()
    if not target then
        Notify("TP Enemy", "No hay enemigo cercano.", "alert-triangle", 3)
        return
    end
    local targetHRP = GetHRP(target)
    local myHRP = GetHRP(LocalPlayer)
    if not (targetHRP and myHRP) then return end
    local newCF = self:GetOffsetCFrame(targetHRP, myHRP)
    pcall(function() myHRP.CFrame = newCF end)
end
function TPEnemyHandler:KillOnce()
    local target = self:FindTarget()
    if not target then
        Notify("TP Enemy Kill", "No hay enemigo cercano.", "alert-triangle", 3)
        return
    end
    local targetHRP = GetHRP(target)
    local myHRP = GetHRP(LocalPlayer)
    if not (targetHRP and myHRP) then return end
    local newCF = self:GetOffsetCFrame(targetHRP, myHRP)
    pcall(function() myHRP.CFrame = newCF end)
    KillTarget(target)
end
function TPEnemyHandler:Update(dt)
    if not self._running then return end
    local target = self:FindTarget()
    if not target then return end
    local targetHRP = GetHRP(target)
    local myHRP = GetHRP(LocalPlayer)
    if not (targetHRP and myHRP) then return end
    local newCF = self:GetOffsetCFrame(targetHRP, myHRP)
    pcall(function() myHRP.CFrame = newCF end)
    if Config.TPEnemy.KillEnabled then
        self._killTick = (self._killTick or 0) + (dt or 0)
        if self._killTick >= 0.15 then
            self._killTick = 0
            KillTarget(target)
        end
    end
end
function TPEnemyHandler:Start()
    if self._running then return end
    self._running = true; self._killTick = 0
    self._conns:add(RunService.Heartbeat:Connect(function(dt)
        if self._running then self:Update(dt) end
    end))
end
function TPEnemyHandler:Stop()
    if not self._running then return end
    self._running = false; self._conns:clear()
end

--=================================================================
-- INSTANCIAS
--=================================================================
local JumpPowerInstance     = JumpPowerHandler.new()
local SpeedInstance         = SpeedHandler.new()
local FloatingFloorInstance = FloatingFloorHandler.new()
local TriggerbotInstance    = TriggerbotHandler.new()
local MacroInstance         = MacroHandler.new()
local AutoShootInstance     = AutoShootHandler.new()
local AimFollowInstance     = AimFollowHandler.new()
local ESPInstance           = ESPHandler.new()
local ESPLinesInstance      = ESPLinesHandler.new()
local InvisibleInstance     = InvisibleHandler.new()
local DesyncInstance        = DesyncHandler.new()
local EventFarmInstance     = EventFarmHandler.new()
local AutoTeleportMainInstance = AutoTeleportHandler.new("Main")
local AutoTeleportAltInstance  = AutoTeleportHandler.new("Alt")
local BoxBuyerInstance      = BoxBuyerHandler.new()
local FOVInstance           = FOVHelper.new()
local TPCircleInstance      = TPCircleHandler.new()
local TPEnemyInstance       = TPEnemyHandler.new()

FOVInstance:Start()

local function RefreshJump()
    if Config.PlayerCheats.JumpPowerEnabled or Config.PlayerCheats.InfiniteJump then
        JumpPowerInstance:Start(); JumpPowerInstance:ApplyJumpPower()
    else JumpPowerInstance:Stop() end
end
local function RefreshSpeed()
    if Config.PlayerCheats.SpeedEnabled then SpeedInstance:Start(); SpeedInstance:ApplySpeed()
    else SpeedInstance:Stop() end
end
local function RefreshFloatingFloor()
    if Config.FloatingFloor.Enabled or Config.FloatingFloor.HideMap then
        FloatingFloorInstance:Start()
        if Config.FloatingFloor.HideMap then FloatingFloorInstance:ApplyHideMap() else FloatingFloorInstance:RestoreHideMap() end
        FloatingFloorInstance:UpdateFloor()
    else FloatingFloorInstance:Stop(); FloatingFloorInstance:RestoreHideMap() end
end
local function RefreshTriggerbot()
    if Config.Bannable.Triggerbot then TriggerbotInstance:Start() else TriggerbotInstance:Stop() end
end
local function RefreshMacro()
    if Config.Bannable.Macro then MacroInstance:Start() else MacroInstance:Stop() end
end
local function RefreshSilentAim()
    if Config.Bannable.SilentAim then SilentAim:Start() else SilentAim:Stop() end
end
local function RefreshAutoShoot()
    if Config.Bannable.AutoShoot then AutoShootInstance:Start() else AutoShootInstance:Stop() end
end
local function RefreshAimFollow()
    if Config.Bannable.AimFollow then AimFollowInstance:Start() else AimFollowInstance:Stop() end
end
local function RefreshESP()
    if Config.ESP.Enabled then ESPInstance:Start() else ESPInstance:Stop() end
end
local function RefreshESPLines()
    if Config.ESP.Lines then ESPLinesInstance:Start() else ESPLinesInstance:Stop() end
end
local function RefreshInvisible()
    if Config.Bannable.Invisible then InvisibleInstance:Start() else InvisibleInstance:Stop() end
end
local function RefreshDesync()
    if Config.Bannable.Desync then DesyncInstance:Start() else DesyncInstance:Stop() end
end
local function RefreshEventFarm()
    if Config.AutoTeleport.EventFarm then EventFarmInstance:Start() else EventFarmInstance:Stop() end
end
local function RefreshAutoTeleport()
    if Config.AutoTeleport.Main then AutoTeleportMainInstance:Start() else AutoTeleportMainInstance:Stop() end
    if Config.AutoTeleport.Alt then AutoTeleportAltInstance:Start() else AutoTeleportAltInstance:Stop() end
end
local function RefreshBoxBuyer()
    if Config.Boxes.AutoBuy then BoxBuyerInstance:Start() else BoxBuyerInstance:Stop() end
end
local function RefreshTPCircle()
    if Config.TPCircle.Enabled then TPCircleInstance:Start() else TPCircleInstance:Stop() end
end
local function RefreshTPEnemy()
    if Config.TPEnemy.Enabled then TPEnemyInstance:Start() else TPEnemyInstance:Stop() end
end

--=================================================================
-- TABS
--=================================================================

local InfoTab = WindWindow:Tab({ Title = "Info", Icon = "info" })
InfoTab:Section({ Title = "✨ Eren Hub" })
InfoTab:Paragraph({
    Title = "Discord Oficial",
    Desc = "Únete a nuestro servidor para soporte, actualizaciones y más.\n\nLink: discord.gg/SkH7uEm6a",
    Buttons = {
        { Title = "Copiar Discord",
          Callback = function()
              pcall(function() setclipboard(DISCORD_INVITE) end)
              Notify("Discord", "Link copiado: discord.gg/SkH7uEm6a", "link", 3)
          end, },
    },
})
InfoTab:Space()
InfoTab:Paragraph({
    Title = "TikTok: @Juliohub4",
    Desc = "Sígueme en TikTok para más contenido.\n\nLink: tiktok.com/@Juliohub4",
    Buttons = {
        { Title = "Copiar TikTok",
          Callback = function()
              pcall(function() setclipboard(TIKTOK_URL) end)
              Notify("TikTok", "Link copiado: @Juliohub4", "link", 3)
          end, },
    },
})
InfoTab:Space(); InfoTab:Divider(); InfoTab:Space()
InfoTab:Section({ Title = "Información del Script" })
InfoTab:Paragraph({
    Title = "Versión: v0.1",
    Desc = "Script privado de Eren Hub.\nNo compartas sin permiso.",
})
InfoTab:Space()
InfoTab:Button({
    Title = "Unload Script",
    Desc = "Descarga el script y cierra todo.",
    Callback = function()
        local fn = getgenv()[UNLOAD_KEY]
        if type(fn) == "function" then pcall(fn) end
    end,
})

local PlayerCheatsTab = WindWindow:Tab({ Title = "Player Cheats", Icon = "user" })
PlayerCheatsTab:Toggle({
    Title = "Enable Jump Power",
    Value = Config.PlayerCheats.JumpPowerEnabled,
    Callback = function(state)
        Config.PlayerCheats.JumpPowerEnabled = state
        RefreshJump()
        if not IS_LOADING_CONFIG and not SKIP_SAVE then SaveConfig() end
    end,
})
PlayerCheatsTab:Slider({
    Title = "Jump Power Value", Step = 1,
    Value = { Min=0, Max=100, Default=Config.PlayerCheats.JumpPower },
    Callback = function(value) Config.PlayerCheats.JumpPower = value; RefreshJump(); SaveConfig() end,
})
PlayerCheatsTab:Toggle({
    Title = "Enable Infinite Jump",
    Value = Config.PlayerCheats.InfiniteJump,
    Callback = function(state)
        Config.PlayerCheats.InfiniteJump = state
        RefreshJump()
        if not IS_LOADING_CONFIG and not SKIP_SAVE then SaveConfig() end
    end,
})
PlayerCheatsTab:Space()
PlayerCheatsTab:Toggle({
    Title = "Enable Speed Hack",
    Value = Config.PlayerCheats.SpeedEnabled,
    Callback = function(state)
        Config.PlayerCheats.SpeedEnabled = state
        RefreshSpeed()
        if not IS_LOADING_CONFIG and not SKIP_SAVE then SaveConfig() end
    end,
})
PlayerCheatsTab:Slider({
    Title = "Speed Value", Step = 1,
    Value = { Min=0, Max=100, Default=Config.PlayerCheats.Speed },
    Callback = function(value) Config.PlayerCheats.Speed = value; RefreshSpeed(); SaveConfig() end,
})

local AimLegitTab = WindWindow:Tab({ Title = "Aim Legit", Icon = "crosshair" })
local MacroToggle = AimLegitTab:Toggle({
    Title = "Macro",
    Value = Config.Bannable.Macro,
    Callback = function(state) Config.Bannable.Macro = state; RefreshMacro() end,
})
AimLegitTab:Space()
local TriggerbotToggle = AimLegitTab:Toggle({
    Title = "Triggerbot",
    Value = Config.Bannable.Triggerbot,
    Callback = function(state)
        Config.Bannable.Triggerbot = state
        if state and MacroToggle then MacroToggle:Set(false) end
        RefreshTriggerbot(); RefreshMacro()
    end,
})
AimLegitTab:Space(); AimLegitTab:Divider(); AimLegitTab:Space()
AimLegitTab:Toggle({
    Title = "Aim at Player",
    Value = Config.Bannable.AimFollow,
    Callback = function(state) Config.Bannable.AimFollow = state; RefreshAimFollow() end,
})
AimLegitTab:Toggle({
    Title = "Only with firearm",
    Value = Config.Bannable.AimFollowFirearmOnly,
    Callback = function(state) Config.Bannable.AimFollowFirearmOnly = state; SaveConfig() end,
})
AimLegitTab:Toggle({
    Title = "Only with knife",
    Value = Config.Bannable.AimFollowKnifeOnly,
    Callback = function(state) Config.Bannable.AimFollowKnifeOnly = state; SaveConfig() end,
})
AimLegitTab:Toggle({
    Title = "Use raycast",
    Value = Config.Bannable.AimFollowRaycast,
    Callback = function(state) Config.Bannable.AimFollowRaycast = state; SaveConfig() end,
})

local AimBannableTab = WindWindow:Tab({ Title = "Aim Bannable", Icon = "crosshair" })
AimBannableTab:Toggle({
    Title = "Silent Aim",
    Value = Config.Bannable.SilentAim,
    Callback = function(state)
        Config.Bannable.SilentAim = state
        if state then
            if MacroToggle then MacroToggle:Set(false) end
            if TriggerbotToggle then TriggerbotToggle:Set(false) end
        end
        RefreshSilentAim()
    end,
})
AimBannableTab:Space(); AimBannableTab:Divider(); AimBannableTab:Space()
AimBannableTab:Toggle({
    Title = "Auto Shoot",
    Value = Config.Bannable.AutoShoot,
    Callback = function(state) Config.Bannable.AutoShoot = state; RefreshAutoShoot() end,
})
AimBannableTab:Space(); AimBannableTab:Divider(); AimBannableTab:Space()
AimBannableTab:Toggle({
    Title = "FOV",
    Value = Config.Bannable.FOVEnabled,
    Callback = function(state) Config.Bannable.FOVEnabled = state == true; SaveConfig() end,
})
AimBannableTab:Toggle({
    Title = "Visible FOV",
    Value = Config.Bannable.FOVVisible,
    Callback = function(state) Config.Bannable.FOVVisible = state == true; SaveConfig() end,
})
AimBannableTab:Slider({
    Title = "FOV Radius", Step = 5,
    Value = { Min=20, Max=600, Default=Config.Bannable.FOVRadius },
    Callback = function(value) Config.Bannable.FOVRadius = value; SaveConfig() end,
})
AimBannableTab:Slider({
    Title = "Hit Chance", Step = 5,
    Value = { Min=0, Max=100, Default=Config.Bannable.HitChance },
    Callback = function(value) Config.Bannable.HitChance = math.clamp(tonumber(value) or 100, 0, 100); SaveConfig() end,
})

local BannableTab = WindWindow:Tab({ Title = "Bannable", Icon = "skull" })
BannableTab:Toggle({
    Title = "Invisible",
    Value = Config.Bannable.Invisible,
    Callback = function(state) Config.Bannable.Invisible = state; RefreshInvisible(); SaveConfig() end,
})
BannableTab:Space()
BannableTab:Toggle({
    Title = "Desync",
    Value = Config.Bannable.Desync,
    Callback = function(state) Config.Bannable.Desync = state; RefreshDesync(); SaveConfig() end,
})
BannableTab:Space(); BannableTab:Divider(); BannableTab:Space()
BannableTab:Toggle({
    Title = "Floating Floor",
    Value = Config.FloatingFloor.Enabled,
    Callback = function(state) Config.FloatingFloor.Enabled = state; RefreshFloatingFloor(); SaveConfig() end,
})
BannableTab:Toggle({
    Title = "Hide Map",
    Value = Config.FloatingFloor.HideMap,
    Callback = function(state) Config.FloatingFloor.HideMap = state; RefreshFloatingFloor(); SaveConfig() end,
})

local TPCircleTab = WindWindow:Tab({ Title = "TP Circle", Icon = "rotate-cw" })
TPCircleTab:Toggle({
    Title = "Enable TP Circle",
    Value = Config.TPCircle.Enabled,
    Callback = function(state) Config.TPCircle.Enabled = state; RefreshTPCircle() end,
})
TPCircleTab:Slider({
    Title = "Distancia", Step = 1,
    Value = { Min = 1, Max = 30, Default = Config.TPCircle.Distance },
    Callback = function(value) Config.TPCircle.Distance = value; SaveConfig() end,
})
TPCircleTab:Slider({
    Title = "Velocidad", Step = 0.5,
    Value = { Min = 0.5, Max = 20, Default = Config.TPCircle.Speed },
    Callback = function(value) Config.TPCircle.Speed = value; SaveConfig() end,
})
TPCircleTab:Space()
TPCircleTab:Toggle({
    Title = "Enable Kill on Circle",
    Value = Config.TPCircle.KillEnabled,
    Callback = function(state) Config.TPCircle.KillEnabled = state; SaveConfig() end,
})
TPCircleTab:Button({
    Title = "🌀 KILL CIRCLE (1 vez)",
    Callback = function() TPCircleInstance:KillOnce() end,
})
TPCircleTab:Button({
    Title = "Detener TP Circle",
    Callback = function()
        Config.TPCircle.Enabled = false
        Config.TPCircle.KillEnabled = false
        TPCircleInstance:Stop()
    end,
})

local TPEnemyTab = WindWindow:Tab({ Title = "TP Enemy", Icon = "user-check" })
TPEnemyTab:Toggle({
    Title = "Enable TP Enemy",
    Value = Config.TPEnemy.Enabled,
    Callback = function(state) Config.TPEnemy.Enabled = state; RefreshTPEnemy() end,
})
TPEnemyTab:Dropdown({
    Title = "Posición",
    Values = { "Behind", "Right", "Left", "Above" },
    Value = Config.TPEnemy.Mode,
    Callback = function(value) Config.TPEnemy.Mode = value; SaveConfig() end,
})
TPEnemyTab:Slider({
    Title = "Distancia", Step = 1,
    Value = { Min = 1, Max = 20, Default = Config.TPEnemy.Distance },
    Callback = function(value) Config.TPEnemy.Distance = value; SaveConfig() end,
})
TPEnemyTab:Space()
TPEnemyTab:Toggle({
    Title = "Enable Kill on TP",
    Value = Config.TPEnemy.KillEnabled,
    Callback = function(state) Config.TPEnemy.KillEnabled = state; SaveConfig() end,
})
TPEnemyTab:Space(); TPEnemyTab:Divider(); TPEnemyTab:Space()
TPEnemyTab:Button({
    Title = "🗡️ KILL ABOVE (Arriba)",
    Callback = function() Config.TPEnemy.Mode = "Above"; TPEnemyInstance:KillOnce() end,
})
TPEnemyTab:Button({
    Title = "🗡️ KILL BEHIND (Atrás)",
    Callback = function() Config.TPEnemy.Mode = "Behind"; TPEnemyInstance:KillOnce() end,
})
TPEnemyTab:Button({
    Title = "🗡️ KILL RIGHT (Derecha)",
    Callback = function() Config.TPEnemy.Mode = "Right"; TPEnemyInstance:KillOnce() end,
})
TPEnemyTab:Button({
    Title = "🗡️ KILL LEFT (Izquierda)",
    Callback = function() Config.TPEnemy.Mode = "Left"; TPEnemyInstance:KillOnce() end,
})
TPEnemyTab:Space()
TPEnemyTab:Button({
    Title = "Detener TP Enemy",
    Callback = function()
        Config.TPEnemy.Enabled = false
        Config.TPEnemy.KillEnabled = false
        TPEnemyInstance:Stop()
    end,
})

-- ============ ESP (MEJORADO) ============
local ESPTab = WindWindow:Tab({ Title = "ESP", Icon = "eye" })

ESPTab:Toggle({
    Title = "Enable ESP",
    Desc = "Muestra a los enemigos a través de paredes.",
    Value = Config.ESP.Enabled,
    Callback = function(state)
        Config.ESP.Enabled = state
        RefreshESP()
        if not IS_LOADING_CONFIG and not SKIP_SAVE then
            Notify("ESP", state and "Enabled" or "Disabled", "scan-eye", 3)
        end
    end,
})
ESPTab:Toggle({
    Title = "Team Check",
    Desc = "Solo muestra enemigos (no aliados).",
    Value = Config.ESP.TeamCheck,
    Callback = function(state)
        Config.ESP.TeamCheck = state
        if Config.ESP.Enabled then ESPInstance:RefreshAll() end
        SaveConfig()
    end,
})
ESPTab:Toggle({
    Title = "Show Enemy Name",
    Value = Config.ESP.ShowName,
    Callback = function(state)
        Config.ESP.ShowName = state
        if Config.ESP.Enabled then ESPInstance:RefreshAll() end
        SaveConfig()
    end,
})
ESPTab:Toggle({
    Title = "Show Distance",
    Value = Config.ESP.ShowDistance,
    Callback = function(state)
        Config.ESP.ShowDistance = state
        if Config.ESP.Enabled then ESPInstance:RefreshAll() end
        SaveConfig()
    end,
})
ESPTab:Toggle({
    Title = "ESP Lines",
    Value = Config.ESP.Lines,
    Callback = function(state) Config.ESP.Lines = state; RefreshESPLines(); SaveConfig() end,
})
ESPTab:Slider({
    Title = "Fill Transparency", Step = 0.05,
    Value = { Min = 0, Max = 1, Default = Config.ESP.FilledTransparency },
    Callback = function(value)
        Config.ESP.FilledTransparency = value
        if Config.ESP.Enabled then ESPInstance:RefreshAll() end
        SaveConfig()
    end,
})
ESPTab:Colorpicker({
    Title = "ESP Color", Default = Config.ESP.Color, Transparency = 0,
    Callback = function(color)
        Config.ESP.Color = ToColor3(color, Config.ESP.Color)
        if Config.ESP.Enabled then ESPInstance:RefreshAll() end
        SaveConfig()
    end,
})
ESPTab:Colorpicker({
    Title = "ESP Lines Color", Default = Config.ESP.LinesColor, Transparency = 0,
    Callback = function(color) Config.ESP.LinesColor = ToColor3(color, Config.ESP.LinesColor); SaveConfig() end,
})

local EventsTab = WindWindow:Tab({ Title = "Events & Boxes", Icon = "gift" })
EventsTab:Toggle({
    Title = "Event Farm",
    Value = Config.AutoTeleport.EventFarm,
    Callback = function(state) Config.AutoTeleport.EventFarm = state; RefreshEventFarm(); SaveConfig() end,
})
EventsTab:Space(); EventsTab:Divider(); EventsTab:Space()
EventsTab:Dropdown({
    Title = "Selected Box",
    Values = BOX_LIST, Value = Config.Boxes.Selected,
    Callback = function(value) SetSelectedBox(value); SaveConfig() end,
})
EventsTab:Button({
    Title = "Buy Box",
    Callback = function()
        local ok, reason = BoxBuyerInstance:Purchase()
        if ok then Notify("Boxes", "Bought " .. tostring(Config.Boxes.Selected), "package", 3)
        else Notify("Boxes", "Could not buy the box.", "alert-triangle", 3) end
    end,
})
EventsTab:Toggle({
    Title = "Auto Buy",
    Value = Config.Boxes.AutoBuy,
    Callback = function(state) Config.Boxes.AutoBuy = state; RefreshBoxBuyer(); SaveConfig() end,
})

local TeleportTab = WindWindow:Tab({ Title = "Auto Teleport", Icon = "repeat" })
local AutoTeleportMainToggle = TeleportTab:Toggle({
    Title = "Auto Teleport Main",
    Value = Config.AutoTeleport.Main,
    Callback = function(state)
        Config.AutoTeleport.Main = state
        if state then
            Config.AutoTeleport.Alt = false
            if AutoTeleportAltToggle then AutoTeleportAltToggle:Set(false) end
        end
        RefreshAutoTeleport()
    end,
})
local AutoTeleportAltToggle = TeleportTab:Toggle({
    Title = "Auto Teleport Alt",
    Value = Config.AutoTeleport.Alt,
    Callback = function(state)
        Config.AutoTeleport.Alt = state
        if state then
            Config.AutoTeleport.Main = false
            if AutoTeleportMainToggle then AutoTeleportMainToggle:Set(false) end
        end
        RefreshAutoTeleport()
    end,
})
TeleportTab:Dropdown({
    Title = "Duel Type",
    Values = { "1v1", "2v2", "3v3", "4v4" },
    Value = Config.AutoTeleport.DuelType,
    Callback = function(value)
        Config.AutoTeleport.DuelType = PAD_TABLE["Right Platforms"][value] and value or "1v1"
        RefreshAutoTeleport(); SaveConfig()
    end,
})
TeleportTab:Dropdown({
    Title = "Platform Row",
    Values = PLATFORM_ROWS,
    Value = Config.AutoTeleport.PlatformRow,
    Callback = function(value)
        Config.AutoTeleport.PlatformRow = PAD_TABLE[value] and value or "Right Platforms"
        RefreshAutoTeleport(); SaveConfig()
    end,
})

--=================================================================
-- INICIALIZACION
--=================================================================
task.defer(function()
    Notify("Eren Hub", "Loaded! - discord.gg/SkH7uEm6a", "sparkles", 5)
end)

pcall(function()
    getgenv()[UNLOAD_KEY] = function()
        IS_UNLOADING = true
        Config.AutoTeleport.Main = false
        Config.AutoTeleport.Alt = false
        Config.AutoTeleport.EventFarm = false
        Config.Bannable.AimFollow = false
        Config.Bannable.Triggerbot = false
        Config.Bannable.SilentAim = false
        Config.Bannable.AutoShoot = false
        Config.Bannable.Macro = false
        Config.Bannable.Invisible = false
        Config.Bannable.Desync = false
        Config.PlayerCheats.JumpPowerEnabled = false
        Config.PlayerCheats.InfiniteJump = false
        Config.PlayerCheats.SpeedEnabled = false
        Config.ESP.Enabled = false
        Config.ESP.Lines = false
        Config.Boxes.AutoBuy = false
        Config.FloatingFloor.Enabled = false
        Config.FloatingFloor.HideMap = false
        Config.TPCircle.Enabled = false
        Config.TPCircle.KillEnabled = false
        Config.TPEnemy.Enabled = false
        Config.TPEnemy.KillEnabled = false

        local function safeCall(obj, method)
            if not obj then return end
            pcall(function()
                local fn = obj[method]
                if type(fn) == "function" then fn(obj) end
            end)
        end
        safeCall(AutoTeleportMainInstance, "Stop")
        safeCall(AutoTeleportAltInstance, "Stop")
        safeCall(TriggerbotInstance, "Stop")
        safeCall(MacroInstance, "Stop")
        safeCall(AutoShootInstance, "Stop")
        safeCall(AimFollowInstance, "Stop")
        safeCall(InvisibleInstance, "Stop")
        safeCall(DesyncInstance, "Stop")
        safeCall(EventFarmInstance, "Stop")
        safeCall(ESPInstance, "Stop")
        safeCall(ESPLinesInstance, "Stop")
        safeCall(JumpPowerInstance, "Stop")
        safeCall(SpeedInstance, "Stop")
        safeCall(FloatingFloorInstance, "Destroy")
        safeCall(BoxBuyerInstance, "Stop")
        safeCall(FOVInstance, "Destroy")
        safeCall(TPCircleInstance, "Stop")
        safeCall(TPEnemyInstance, "Stop")
        safeCall(SilentAim, "Stop")
        SilentAim:RemoveHook()

        if CONFIG_AUTOSAVE_CONN then pcall(function() CONFIG_AUTOSAVE_CONN:Disconnect() end); CONFIG_AUTOSAVE_CONN = nil end

        pcall(function() WindWindow:Destroy() end)
    end
end)

SKIP_SAVE = false

--=================================================================
-- FIN - Eren Hub v0.1
-- Discord: https://discord.gg/SkH7uEm6a
-- TikTok: @Juliohub4
--=================================================================