ArzenaI aimbot and esp keyless

 Luna = (:())()

 Window = Luna:({
    Name = ,
    LoadingTitle = ,
    LoadingSubtitle = ,
    ConfigurationSaving = {
        Enabled = ,
        FolderName = ,
        FileName = 
    },
    Discord = {
        Enabled = ,
        Invite = ,
        RememberJoins = 
    },
    KeySystem = 
})


 Players = :()
 RunService = :()
 UserInputService = :()
 Camera = .CurrentCamera
 LocalPlayer = Players.LocalPlayer


 aimlockEnabled = 
 aimbotEnabled = 
 smoothAim = 
 aimPart = 
 fovEnabled = 
 fovSize = 
 fovCircle = 
 smoothness = 
 wallCheck = 
 teamCheck = 
 targetPlayer = 

 espEnabled = 
 ESPObjects = {}

 xrayEnabled = 
 originalTransparencies = {}

 infiniteJumpEnabled = 
 infiniteJumpConnection = 


  (player)
      teamCheck    
      player   LocalPlayer    
    
    
     player.Team  LocalPlayer.Team 
         player.Team ~= LocalPlayer.Team
    
    
      



  ()
     fovCircle  fovCircle:() 
    fovCircle = .()
    fovCircle.Thickness = 
    fovCircle.NumSides = 
    fovCircle.Radius = fovSize
    fovCircle.Filled = 
    fovCircle.Transparency = 
    fovCircle.Color = .(, , )
    fovCircle.Visible = 
    fovCircle.ZIndex = 



  ()
     fovCircle 
         centerX = Camera.ViewportSize.X / 
         centerY = Camera.ViewportSize.Y / 
        fovCircle.Position = .(centerX, centerY)
        fovCircle.Radius = fovSize
        fovCircle.Visible = fovEnabled  (aimlockEnabled  aimbotEnabled)
    



  ()
     closestPlayer = 
     shortestDistance = fovEnabled  fovSize  .huge
     mousePos = UserInputService:()
    
     _, player  (Players:()) 
         player ~= LocalPlayer  (player)  player.Character  player.Character:() 
             humanoid = player.Character:()
             humanoid  humanoid.Health >  
                 targetPart = player.Character:(aimPart)
                 targetPart 
                     screenPos, onScreen = Camera:(targetPart.Position)
                    
                     onScreen 
                         distance = (.(screenPos.X, screenPos.Y) - mousePos).Magnitude
                        
                         wallCheck 
                             ray = Ray.(Camera.CFrame.Position, (targetPart.Position - Camera.CFrame.Position).Unit * )
                             hit, position = :(ray, {LocalPlayer.Character})
                            
                             hit  hit:(player.Character) 
                                 distance < shortestDistance 
                                    closestPlayer = player
                                    shortestDistance = distance
                                
                            
                        
                             distance < shortestDistance 
                                closestPlayer = player
                                shortestDistance = distance
                            
                        
                    
                
            
        
    
    
     closestPlayer



  ()
      aimlockEnabled   
    
     target = ()
     target  target.Character 
         targetPart = target.Character:(aimPart)
         targetPart 
             aimPosition = targetPart.Position
             cameraPosition = Camera.CFrame.Position
             direction = (aimPosition - cameraPosition).Unit
            
             smoothAim 
                 targetCFrame = .(cameraPosition, cameraPosition + direction)
                Camera.CFrame = Camera.CFrame:(targetCFrame, smoothness)
            
                Camera.CFrame = .(cameraPosition, cameraPosition + direction)
            
        
    



  ()
      aimbotEnabled   
    
     target = ()
     target 
        targetPlayer = target
    
        targetPlayer = 
    



  (Player)
     ESPObjects[Player]  Player == LocalPlayer   (Player)   
    
     ESPHolder = {
        Box = .(),
        BoxOutline = .(),
        CornerTL = .(),
        CornerTR = .(),
        CornerBL = .(),
        CornerBR = .(),
        Tracer = .(),
        Name = .(),
        Distance = .(),
        Health = .(),
        HealthBar = .(),
        HealthBarOutline = .()
    }
    
    
    ESPHolder.Box.Thickness = 
    ESPHolder.Box.Filled = 
    ESPHolder.Box.Color = .(, , )
    ESPHolder.Box.Visible = 
    ESPHolder.Box.ZIndex = 
    ESPHolder.Box.Transparency = 
    
    
    ESPHolder.BoxOutline.Thickness = 
    ESPHolder.BoxOutline.Filled = 
    ESPHolder.BoxOutline.Color = .(, , )
    ESPHolder.BoxOutline.Visible = 
    ESPHolder.BoxOutline.ZIndex = 
    ESPHolder.BoxOutline.Transparency = 
    
    
     _, corner  ({ESPHolder.CornerTL, ESPHolder.CornerTR, ESPHolder.CornerBL, ESPHolder.CornerBR}) 
        corner.Thickness = 
        corner.Color = .(, , )
        corner.Visible = 
        corner.ZIndex = 
        corner.Transparency = 
    
    
    
    ESPHolder.Tracer.Thickness = 
    ESPHolder.Tracer.Color = .(, , )
    ESPHolder.Tracer.Visible = 
    ESPHolder.Tracer.ZIndex = 
    ESPHolder.Tracer.Transparency = 
    
    
    ESPHolder.Name.Size = 
    ESPHolder.Name.Center = 
    ESPHolder.Name.Outline = 
    ESPHolder.Name.Font = 
    ESPHolder.Name.Color = .(, , )
    ESPHolder.Name.Visible = 
    ESPHolder.Name.ZIndex = 
    ESPHolder.Name.Transparency = 
    
    
    ESPHolder.Distance.Size = 
    ESPHolder.Distance.Center = 
    ESPHolder.Distance.Outline = 
    ESPHolder.Distance.Font = 
    ESPHolder.Distance.Color = .(, , )
    ESPHolder.Distance.Visible = 
    ESPHolder.Distance.ZIndex = 
    ESPHolder.Distance.Transparency = 
    
    
    ESPHolder.Health.Size = 
    ESPHolder.Health.Center = 
    ESPHolder.Health.Outline = 
    ESPHolder.Health.Font = 
    ESPHolder.Health.Color = .(, , )
    ESPHolder.Health.Visible = 
    ESPHolder.Health.ZIndex = 
    ESPHolder.Health.Transparency = 
    
    
    ESPHolder.HealthBar.Thickness = 
    ESPHolder.HealthBar.Color = .(, , )
    ESPHolder.HealthBar.Visible = 
    ESPHolder.HealthBar.ZIndex = 
    ESPHolder.HealthBar.Transparency = 
    
    
    ESPHolder.HealthBarOutline.Thickness = 
    ESPHolder.HealthBarOutline.Color = .(, , )
    ESPHolder.HealthBarOutline.Visible = 
    ESPHolder.HealthBarOutline.ZIndex = 
    ESPHolder.HealthBarOutline.Transparency = 
    
    ESPObjects[Player] = ESPHolder


  (Player)
     ESPObjects[Player] 
         _,   (ESPObjects[Player]) 
            :()
        
        ESPObjects[Player] = 
    


  ()
     Player, ESP  (ESPObjects) 
        (()
            
              (Player) 
                (Player)
                
            
            
             Player  Player.Character  Player ~= LocalPlayer 
                 Character = Player.Character
                 Humanoid = Character:()
                 RootPart = Character:()
                 Head = Character:()
                
                 Humanoid  RootPart  Head  Humanoid.Health >   LocalPlayer.Character  LocalPlayer.Character:() 
                     Distance = (LocalPlayer.Character.HumanoidRootPart.Position - RootPart.Position).Magnitude
                    
                     Distance >  
                        ESP.Box.Visible = 
                        ESP.BoxOutline.Visible = 
                        ESP.CornerTL.Visible = 
                        ESP.CornerTR.Visible = 
                        ESP.CornerBL.Visible = 
                        ESP.CornerBR.Visible = 
                        ESP.Tracer.Visible = 
                        ESP.Name.Visible = 
                        ESP.Distance.Visible = 
                        ESP.Health.Visible = 
                        ESP.HealthBar.Visible = 
                        ESP.HealthBarOutline.Visible = 
                        
                    
                    
                     Vector, OnScreen = Camera:(RootPart.Position)
                    
                     OnScreen  espEnabled 
                         HeadPos = Camera:(Head.Position + .(, , ))
                         LegPos = Camera:(RootPart.Position - .(, , ))
                        
                         Height = .(HeadPos.Y - LegPos.Y)
                         Width = Height / 
                        
                         IsTarget = (targetPlayer == Player)
                         BoxColor = IsTarget  .(, , )  .(, , )
                        
                        
                         IsTarget 
                             pulse = .(.(() * )) *  + 
                            BoxColor = .(,  * pulse, )
                        
                        
                        
                        ESP.Box.Size = .(Width, Height)
                        ESP.Box.Position = .(Vector.X - Width / , Vector.Y - Height / )
                        ESP.Box.Color = BoxColor
                        ESP.Box.Visible = 
                        
                        
                        ESP.BoxOutline.Size = .(Width, Height)
                        ESP.BoxOutline.Position = .(Vector.X - Width / , Vector.Y - Height / )
                        ESP.BoxOutline.Visible = 
                        
                        
                         cornerLength = .(Width, Height) / 
                        
                        
                        ESP.CornerTL.From = .(Vector.X - Width / , Vector.Y - Height / )
                        ESP.CornerTL.To = .(Vector.X - Width /  + cornerLength, Vector.Y - Height / )
                        ESP.CornerTL.Color = BoxColor
                        ESP.CornerTL.Visible = 
                        
                        
                        ESP.CornerTR.From = .(Vector.X + Width / , Vector.Y - Height / )
                        ESP.CornerTR.To = .(Vector.X + Width /  - cornerLength, Vector.Y - Height / )
                        ESP.CornerTR.Color = BoxColor
                        ESP.CornerTR.Visible = 
                        
                        
                        ESP.CornerBL.From = .(Vector.X - Width / , Vector.Y + Height / )
                        ESP.CornerBL.To = .(Vector.X - Width /  + cornerLength, Vector.Y + Height / )
                        ESP.CornerBL.Color = BoxColor
                        ESP.CornerBL.Visible = 
                        
                        
                        ESP.CornerBR.From = .(Vector.X + Width / , Vector.Y + Height / )
                        ESP.CornerBR.To = .(Vector.X + Width /  - cornerLength, Vector.Y + Height / )
                        ESP.CornerBR.Color = BoxColor
                        ESP.CornerBR.Visible = 
                        
                        
                        ESP.Tracer.Visible = 
                        
                        
                        ESP.Name.Text = Player.Name .. (IsTarget    )
                        ESP.Name.Position = .(Vector.X, HeadPos.Y - )
                        ESP.Name.Color = IsTarget  .(, , )  .(, , )
                        ESP.Name.Visible = 
                        
                        
                         distColor = Distance <   .(, , )  
                                         Distance <   .(, , )  
                                         .(, , )
                        ESP.Distance.Text = .(Distance) .. 
                        ESP.Distance.Position = .(Vector.X, LegPos.Y + )
                        ESP.Distance.Color = distColor
                        ESP.Distance.Visible = 
                        
                        
                         HealthPercent = .((Humanoid.Health / Humanoid.MaxHealth) * )
                        ESP.Health.Text = HealthPercent .. 
                        ESP.Health.Position = .(Vector.X, LegPos.Y + )
                        
                        
                         HealthPercent >  
                            ESP.Health.Color = .(, , )
                         HealthPercent >  
                            ESP.Health.Color = .(, , )
                         HealthPercent >  
                            ESP.Health.Color = .(, , )
                        
                            ESP.Health.Color = .(, , )
                        
                        ESP.Health.Visible = 
                        
                        
                         healthBarHeight = Height * (Humanoid.Health / Humanoid.MaxHealth)
                         healthBarX = Vector.X - Width /  - 
                        
                        ESP.HealthBarOutline.From = .(healthBarX, Vector.Y - Height / )
                        ESP.HealthBarOutline.To = .(healthBarX, Vector.Y + Height / )
                        ESP.HealthBarOutline.Visible = 
                        
                        ESP.HealthBar.From = .(healthBarX, Vector.Y + Height / )
                        ESP.HealthBar.To = .(healthBarX, Vector.Y + Height /  - healthBarHeight)
                        ESP.HealthBar.Color = ESP.Health.Color
                        ESP.HealthBar.Visible = 
                    
                        ESP.Box.Visible = 
                        ESP.BoxOutline.Visible = 
                        ESP.CornerTL.Visible = 
                        ESP.CornerTR.Visible = 
                        ESP.CornerBL.Visible = 
                        ESP.CornerBR.Visible = 
                        ESP.Tracer.Visible = 
                        ESP.Name.Visible = 
                        ESP.Distance.Visible = 
                        ESP.Health.Visible = 
                        ESP.HealthBar.Visible = 
                        ESP.HealthBarOutline.Visible = 
                    
                
                    ESP.Box.Visible = 
                    ESP.BoxOutline.Visible = 
                    ESP.CornerTL.Visible = 
                    ESP.CornerTR.Visible = 
                    ESP.CornerBL.Visible = 
                    ESP.CornerBR.Visible = 
                    ESP.Tracer.Visible = 
                    ESP.Name.Visible = 
                    ESP.Distance.Visible = 
                    ESP.Health.Visible = 
                    ESP.HealthBar.Visible = 
                    ESP.HealthBarOutline.Visible = 
                
            
        )
    



  (enabled)
     enabled 
         _, obj  (:()) 
             obj:()   obj:(LocalPlayer.Character) 
                originalTransparencies[obj] = obj.Transparency
                obj.Transparency = 
            
        
    
         obj, transparency  (originalTransparencies) 
             obj  obj.Parent 
                obj.Transparency = transparency
            
        
        originalTransparencies = {}
    



  (enabled)
     enabled 
        infiniteJumpConnection = UserInputService.JumpRequest:(()
             LocalPlayer.Character  LocalPlayer.Character:() 
                LocalPlayer.Character:():(.HumanoidStateType.Jumping)
            
        )
    
         infiniteJumpConnection 
            infiniteJumpConnection:()
            infiniteJumpConnection = 
        
    



Window:({
    SupportedExecutors = {
        , , , , 
        , , , , 
    },
    DiscordInvite = ,
    Icon = 
})


 CombatTab = Window:({
    Name = ,
    Icon = ,
    ImageSource = ,
    ShowTitle = 
})

 VisualsTab = Window:({
    Name = ,
    Icon = ,
    ImageSource = ,
    ShowTitle = 
})

 MiscTab = Window:({
    Name = ,
    Icon = ,
    ImageSource = ,
    ShowTitle = 
})

 SettingsTab = Window:({
    Name = ,
    Icon = ,
    ImageSource = ,
    ShowTitle = 
})


 AimlockSection = CombatTab:()

 AimlockToggle = CombatTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        aimlockEnabled = Value
        ()
    ,
})

 SmoothAimToggle = CombatTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        smoothAim = Value
    ,
})

 SmoothnessSlider = CombatTab:({
    Name = ,
    Range = {, },
    Increment = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        smoothness = Value
    ,
})

 WallCheckToggle = CombatTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        wallCheck = Value
    ,
})

 TeamCheckToggle = CombatTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        teamCheck = Value
    ,
})

 AimPartDropdown = CombatTab:({
    Name = ,
    Options = {, , , },
    CurrentOption = {},
    MultipleOptions = ,
    Flag = ,
    Callback = (Option)
         (Option) ==  
            aimPart = Option[]
        
            aimPart = Option
        
    ,
})

 FOVSection = CombatTab:()

 FOVToggle = CombatTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        fovEnabled = Value
        ()
    ,
})

 FOVSlider = CombatTab:({
    Name = ,
    Range = {, },
    Increment = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        fovSize = Value
         fovCircle 
            fovCircle.Radius = Value
        
    ,
})

 FOVColorPicker = CombatTab:({
    Name = ,
    Color = .(, , ),
    Flag = ,
    Callback = (Value)
         fovCircle 
            fovCircle.Color = Value
        
    
})

 AimbotSection = CombatTab:()

 AimbotToggle = CombatTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        aimbotEnabled = Value
    ,
})


 ESPSection = VisualsTab:()

 ESPToggle = VisualsTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        espEnabled = Value
        
         Value 
             _, player  (Players:()) 
                 player ~= LocalPlayer  (player) 
                    (player)
                
            
            
            RunService:(, .RenderPriority.Camera.Value + , updateESP)
        
            RunService:()
            
             player, _  (ESPObjects) 
                (player)
            
        
    ,
})

 ESPColorPicker = VisualsTab:({
    Name = ,
    Color = .(, , ),
    Flag = ,
    Callback = (Value)
         _, ESP  (ESPObjects) 
            ESP.Box.Color = Value
            ESP.Tracer.Color = Value
        
    
})

 XRaySection = VisualsTab:()

 XRayToggle = VisualsTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        xrayEnabled = Value
        (Value)
    ,
})

 XRaySlider = VisualsTab:({
    Name = ,
    Range = {, },
    Increment = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
         xrayEnabled 
             obj, _  (originalTransparencies) 
                 obj  obj.Parent 
                    obj.Transparency = Value
                
            
        
    ,
})


 MovementSection = MiscTab:()

 InfiniteJumpToggle = MiscTab:({
    Name = ,
    CurrentValue = ,
    Flag = ,
    Callback = (Value)
        infiniteJumpEnabled = Value
        (Value)
    ,
})


 InfoSection = SettingsTab:()

SettingsTab:({
    Title = ,
    Content = 
})

 ControlsSection = SettingsTab:()

SettingsTab:({
    Name = ,
    CurrentKeybind = ,
    HoldToInteract = ,
    Flag = ,
    Callback = (Keybind)
    ,
})

SettingsTab:({
    Name = ,
    Callback = ()
        Luna:()
    ,
})


RunService.RenderStepped:(()
    ()
    ()
    ()
)


Players.PlayerAdded:((player)
     espEnabled  player ~= LocalPlayer  (player) 
        (player)
    
)

Players.PlayerRemoving:((player)
    (player)
)


LocalPlayer:():(()
    
     espEnabled 
         player, _  (ESPObjects) 
            (player)
        
         _, player  (Players:()) 
             player ~= LocalPlayer  (player) 
                (player)
            
        
    
)


Luna:({
    Title = ,
    Content = ,
    Icon = ,
    ImageSource = 
})