Esp Aimbot Dinas Hub

 LibraryUrl = 
 Success, Library = (()
     (:(LibraryUrl))()
)

  Success   Library  
     () 


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

 .PlaceId ~=  
    ()


 Config = {
    Aimbot = {
        Enabled = ,
        MobileMode = ,
        AimPart = ,
        FOV = ,
        ShowFOV = ,
        RainbowFOV = ,
        FOVColor = .(, , ),
        Smoothness = ,
        WallCheck = ,
        Key = .UserInputType.MouseButton2,
        IsAiming = 
    },
    ESP = {
        Enabled = ,
        Boxes = ,
        Names = ,
        Health = ,
        Tracers = ,
        TeamCheck = ,
        TextSize = ,
        MaxDistance = ,
        BoxColor = .(, , ),
        TracerColor = .(, , )
    },
    Chams = {
        Enabled = ,
        FillColor = .(, , ),
        OutlineColor = .(, , ),
        Transparency = ,
        AlwaysOnTop = 
    }
}

Library:()
 Window = Library:()

Window:()
 CombatTab = Window:(, )
 VisualsTab = Window:(, )

Window:()
 SettingsTab = Window:(, )

 AimbotPage = CombatTab:()
 ESPPage = VisualsTab:()
 SettingsPage = SettingsTab:()

 AimMainGroup = AimbotPage:(, )
 AimSettingsGroup = AimbotPage:(, )

 ESPMainGroup = ESPPage:(, )
 ChamsGroup = ESPPage:(, )

 ThemeGroup = SettingsPage:(, )
 UIControlGroup = SettingsPage:(, )

AimMainGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.Aimbot.Enabled = Value 
})

AimMainGroup:({
    Title = ,
    Default = ,
    Description = ,
    Callback = (Value) Config.Aimbot.MobileMode = Value 
})

AimMainGroup:({
    Title = ,
    Default = ,
    Description = ,
    Callback = (Value) Config.Aimbot.WallCheck = Value 
})

AimMainGroup:({
    Title = ,
    Values = {, },
    Default = ,
    Multi = ,
    Callback = (Value) Config.Aimbot.AimPart = Value 
})

AimSettingsGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.Aimbot.ShowFOV = Value 
})

AimSettingsGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.Aimbot.RainbowFOV = Value 
})

AimSettingsGroup:({
    Title = ,
    Min = ,
    Max = ,
    Default = ,
    Rounding = ,
    Callback = (Value) Config.Aimbot.FOV = Value 
})

AimSettingsGroup:({
    Title = ,
    Min = ,
    Max = ,
    Default = ,
    Rounding = ,
    Suffix = ,
    Description = ,
    Callback = (Value) Config.Aimbot.Smoothness = Value 
})

ESPMainGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.ESP.Enabled = Value 
})

ESPMainGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.ESP.Boxes = Value 
})

ESPMainGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.ESP.Names = Value 
})

ESPMainGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.ESP.Health = Value 
})

ESPMainGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.ESP.Tracers = Value 
})

ESPMainGroup:({
    Title = ,
    Min = ,
    Max = ,
    Default = ,
    Rounding = ,
    Suffix = ,
    Callback = (Value) Config.ESP.MaxDistance = Value 
})


ChamsGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.Chams.Enabled = Value 
})

ChamsGroup:({
    Title = ,
    Default = ,
    Callback = (Value) Config.Chams.AlwaysOnTop = Value 
})

ChamsGroup:({
    Title = ,
    Default = .(, , ),
    Callback = (Value) Config.Chams.FillColor = Value 
})

ChamsGroup:({
    Title = ,
    Default = .(, , ),
    Callback = (Value) Config.ESP.BoxColor = Value 
})

UIControlGroup:({
    Title = ,
    Callback = () 
        Library:(, , )
         gui = :():()  :():()
         gui  gui:() 
    
})

 ThemeList = {}
 Library.ThemePresets 
     ThemeName, _  (Library.ThemePresets)  .(ThemeList, ThemeName) 
    .(ThemeList)
    ThemeGroup:({
        Title = , Values = ThemeList, Default = , Multi = ,
        Callback = (Value)  Library.SetTheme  Library:(Value)  
    })


 FOV_ScreenGui = .()
FOV_ScreenGui.Name = 
FOV_ScreenGui.IgnoreGuiInset = 
FOV_ScreenGui.ResetOnSpawn = 
 (() FOV_ScreenGui.Parent = CoreGui ) 
    FOV_ScreenGui.Parent = CoreGui

    FOV_ScreenGui.Parent = LocalPlayer:()


 FOV_Frame = .()
FOV_Frame.Parent = FOV_ScreenGui
FOV_Frame.BackgroundColor3 = .(, , )
FOV_Frame.BackgroundTransparency = 
FOV_Frame.AnchorPoint = .(, )
FOV_Frame.Position = .(, , , )
FOV_Frame.Size = .(, , , )
FOV_Frame.Visible = 

 FOV_Stroke = .()
FOV_Stroke.Parent = FOV_Frame
FOV_Stroke.Color = .(, , )
FOV_Stroke.Thickness = 
FOV_Stroke.ApplyStrokeMode = .ApplyStrokeMode.Border

 FOV_Corner = .()
FOV_Corner.Parent = FOV_Frame
FOV_Corner.CornerRadius = .(, )

 ESP_Storage = {}
 Chams_Storage = {}

  (player)
      Config.ESP.TeamCheck    
     player.Team ==     
     player.Team == LocalPlayer.Team


  (part)
      Config.Aimbot.WallCheck    
     origin = Camera.CFrame.Position
     direction = (part.Position - origin).Unit * (part.Position - origin).Magnitude
     rayParams = RaycastParams.()
    rayParams.FilterDescendantsInstances = {LocalPlayer.Character, Camera}
    rayParams.FilterType = .RaycastFilterType.Exclude
     hit = :(origin, direction, rayParams)
     hit ==   hit.Instance:(part.Parent)


  (char)
     Config.Aimbot.AimPart ==    char:() 
     char:()  char:()  char:()  char:()


  ()
     closestPlayer = 
     shortestDist = Config.Aimbot.FOV
     centerScreen = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y / )

     _, player  (Players:()) 
         player ~= LocalPlayer   (player) 
             char = player.Character
             char  char:()  char.Humanoid.Health >  
                 part = (char)
                 part 
                     screenPos, onScreen = Camera:(part.Position)
                     onScreen 
                         dist = (.(screenPos.X, screenPos.Y) - centerScreen).Magnitude
                         dist < shortestDist 
                             (part) 
                                shortestDist = dist
                                closestPlayer = part
                            
                        
                    
                
            
        
    
     closestPlayer


  (, props)
     obj = .()
     k, v  (props)  obj[k] = v 
     obj


  (player)
     ESP_Storage[player]   
    ESP_Storage[player] = {
        Box = (, {Thickness = , Filled = , ZIndex = , Visible = }),
        BoxOutline = (, {Thickness = , Color = .(,,), Filled = , ZIndex = , Visible = }),
        Name = (, {Center = , Size = , Outline = , Color = .(,,), ZIndex = , Visible = }),
        HealthBar = (, {Filled = , ZIndex = , Visible = }),
        Tracer = (, {Thickness = , ZIndex = , Visible = })
    }


  (player)
     ESP_Storage[player] 
         _, obj  (ESP_Storage[player])  obj:() 
        ESP_Storage[player] = 
    


  (player)
      player.Character   
     Chams_Storage[player]  ( Config.Chams.Enabled  (player)) 
        Chams_Storage[player]:()
        Chams_Storage[player] = 
        
    
      Config.Chams.Enabled   
     (player)   
    
     char = player.Character
      char:()   
    
      Chams_Storage[player]  Chams_Storage[player].Parent ~= char 
         highlight = .()
        highlight.Name = 
        highlight.Adornee = char
        highlight.Parent = char
        Chams_Storage[player] = highlight
    
    
     hl = Chams_Storage[player]
    hl.FillColor = Config.Chams.FillColor
    hl.OutlineColor = Config.Chams.OutlineColor
    hl.FillTransparency = Config.Chams.Transparency
    hl.OutlineTransparency = 
    hl.DepthMode = Config.Chams.AlwaysOnTop  .HighlightDepthMode.AlwaysOnTop  .HighlightDepthMode.Occluded


UserInputService.InputBegan:((input)
     input.UserInputType == Config.Aimbot.Key  Config.Aimbot.IsAiming =  
)
UserInputService.InputEnded:((input)
     input.UserInputType == Config.Aimbot.Key  Config.Aimbot.IsAiming =  
)

RunService.RenderStepped:(()
     Config.Aimbot.Enabled  Config.Aimbot.ShowFOV 
        FOV_Frame.Visible = 
        FOV_Frame.Size = .(, Config.Aimbot.FOV * , , Config.Aimbot.FOV * )
         Config.Aimbot.RainbowFOV 
             hue = () %  / 
            FOV_Stroke.Color = .(hue, , )
        
            FOV_Stroke.Color = Config.Aimbot.FOVColor
        
    
        FOV_Frame.Visible = 
    

     Config.Aimbot.Enabled 
         Config.Aimbot.IsAiming  Config.Aimbot.MobileMode 
             target = ()
             target 
                 currentCF = Camera.CFrame
                 targetCF = .(currentCF.Position, target.Position)
                
                 Config.Aimbot.Smoothness <=  
                    Camera.CFrame = targetCF
                
                    Camera.CFrame = currentCF:(targetCF,  - Config.Aimbot.Smoothness)
                
            
        
    

     _, player  (Players:()) 
         player ~= LocalPlayer 
            (player)
              ESP_Storage[player]  (player) 
            
             objects = ESP_Storage[player]
             char = player.Character
             hrp = char  char:()
            
             show = 
             Config.ESP.Enabled  char  hrp   (player) 
                 hum = char:()
                 hum  hum.Health >  
                     vector, onScreen = Camera:(hrp.Position)
                     dist = (Camera.CFrame.Position - hrp.Position).Magnitude
                    
                     onScreen  dist <= Config.ESP.MaxDistance 
                        show = 
                         size = (Camera:(hrp.Position - .(, , )).Y - Camera:(hrp.Position + .(, , )).Y) / 
                         width = size / 
                         currentPos = .(vector.X - width / , vector.Y - size / )

                         Config.ESP.Boxes 
                            objects.Box.Visible = ; objects.BoxOutline.Visible = 
                            objects.Box.Size = .(width, size * )
                            objects.Box.Position = currentPos
                            objects.BoxOutline.Size = objects.Box.Size
                            objects.BoxOutline.Position = objects.Box.Position
                            objects.Box.Color = Config.ESP.BoxColor
                         objects.Box.Visible = ; objects.BoxOutline.Visible =  

                         Config.ESP.Names 
                            objects.Name.Visible = 
                            objects.Name.Text = player.Name
                            objects.Name.Position = .(vector.X, currentPos.Y - )
                         objects.Name.Visible =  
                        
                         Config.ESP.Health 
                             h = hum.Health / hum.MaxHealth
                            objects.HealthBar.Visible = 
                            objects.HealthBar.Size = .(, (size * ) * h)
                            objects.HealthBar.Position = .(currentPos.X - , currentPos.Y + (size * ) - objects.HealthBar.Size.Y)
                            objects.HealthBar.Color = .(h*, , )
                         objects.HealthBar.Visible =  
                        
                         Config.ESP.Tracers 
                            objects.Tracer.Visible = 
                            objects.Tracer.From = .(Camera.ViewportSize.X / , Camera.ViewportSize.Y)
                            objects.Tracer.To = .(vector.X, vector.Y + size)
                            objects.Tracer.Color = Config.ESP.TracerColor
                         objects.Tracer.Visible =  
                    
                
            
              show   _, o  (objects)  o.Visible =   
        
    
)

Players.PlayerRemoving:((plr)
    (plr)
     Chams_Storage[plr]  Chams_Storage[plr]:() Chams_Storage[plr] =  
)