Pun Aimbot

 WindUI = (:())()
 Players = :()
 RS = :()
 Player = Players.LocalPlayer
 Camera = .CurrentCamera

 State = { 
    AimEnabled = , 
    AimFOV = , 
    LockHead = , 
    LockClosest = , 
    AimWallbang = ,
    ESPEnabled = , 
    ESPThroughWalls = ,
    Language = 
}
 CurrentLock, TargetPart = , 


 Translations = {
    [] = {
        WindowTitle = ,
        MainTab = ,
        AimbotSection = ,
        AimbotDesc = ,
        AimbotToggle = ,
        AimHead = ,
        AimClosest = ,
        Wallbang = ,
        FOVSection = ,
        FOVDesc = ,
        FOVSize = ,
        ESPSection = ,
        ESPDesc = ,
        ESPToggle = ,
        ThroughWalls = ,
        SettingsTab = ,
        ThemeSection = ,
        SelectTheme = ,
        LangSection = ,
        SelectLang = 
    },
    [] = {
        WindowTitle = ,
        MainTab = ,
        AimbotSection = ,
        AimbotDesc = ,
        AimbotToggle = ,
        AimHead = ,
        AimClosest = ,
        Wallbang = ,
        FOVSection = ,
        FOVDesc = ,
        FOVSize = ,
        ESPSection = ,
        ESPDesc = ,
        ESPToggle = ,
        ThroughWalls = ,
        SettingsTab = ,
        ThemeSection = ,
        SelectTheme = ,
        LangSection = ,
        SelectLang = 
    }
}

 Player.PlayerGui:()  
    Player.PlayerGui.AimbotFOV:() 


 fovGui = .()
fovGui.Name = 
fovGui.IgnoreGuiInset = 
fovGui.DisplayOrder = 
fovGui.ResetOnSpawn = 
fovGui.Parent = Player:()

 circ = .(, fovGui)
circ.AnchorPoint, circ.BackgroundTransparency, circ.Visible = .(, ), , 
 stroke = .(, circ)
stroke.Thickness = 
stroke.Color = .(, , )
.(, circ).CornerRadius = .(, )

  (part, char)
     rayParams = RaycastParams.()
    rayParams.FilterDescendantsInstances = {Player.Character, char, Camera}
    rayParams.FilterType = .RaycastFilterType.Exclude
     :(Camera.CFrame.Position, (part.Position - Camera.CFrame.Position).Unit * (part.Position - Camera.CFrame.Position).Magnitude, rayParams) == 


  ()
      State.AimEnabled   ,  
     targetPlr, targetPart, close = , , State.AimFOV
     mid = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y/)

     _, v  (Players:()) 
         v ~= Player  v.Character  v.Character:()  v.Character.Humanoid.Health >  
             head = v.Character:()
             fallbackPart = head  v.Character:()  v.Character:()
            
             fallbackPart 
                 canAim = State.AimWallbang  (fallbackPart, v.Character)
                
                 canAim 
                     State.LockHead  head 
                         p, vis = Camera:(head.Position)
                         vis  (.(p.X, p.Y) - mid).Magnitude < close 
                            close, targetPlr, targetPart = (.(p.X, p.Y) - mid).Magnitude, v, head
                        
                     State.LockClosest 
                         _, part  (v.Character:()) 
                             part:()  (State.AimWallbang  (part, v.Character)) 
                                 p, vis = Camera:(part.Position)
                                 vis  (.(p.X, p.Y) - mid).Magnitude < close 
                                    close, targetPlr, targetPart = (.(p.X, p.Y) - mid).Magnitude, v, part
                                
                            
                        
                    
                
            
        
    
     targetPlr, targetPart


  (color, thickness)
     line = .()
    line.Visible = 
    line.From = .(, )
    line.To = .(, )
    line.Color = color
    line.Thickness = thickness
    line.Transparency = 
     line


  (plr)
     plr == Player   
    
     Library = {
        TL1 = (.(, , ), ),
        TL2 = (.(, , ), ),
        TR1 = (.(, , ), ),
        TR2 = (.(, , ), ),
        BL1 = (.(, , ), ),
        BL2 = (.(, , ), ),
        BR1 = (.(, , ), ),
        BR2 = (.(, , ), ),
        NameTag = .()
    }
    
    Library.NameTag.Visible = 
    Library.NameTag.Center = 
    Library.NameTag.Outline = 
    Library.NameTag.OutlineColor = .(, , )
    Library.NameTag.Color = .(, , )
    Library.NameTag.Size = 
    Library.NameTag.Font = 
    
     oripart = .()
    oripart.Parent = 
    oripart.Transparency = 
    oripart.CanCollide = 
    oripart.Size = .(, , )
    oripart.Position = .(, , )
    
     connection
    connection = RS.RenderStepped:(()
         char = plr.Character
         char  char:()  char:()  char.Humanoid.Health >   char:() 
            
             isTargetVisible = (char.Head, char)
             shouldShow = State.ESPEnabled  (State.ESPThroughWalls  isTargetVisible)
            
             HumPos, vis = Camera:(char.HumanoidRootPart.Position)
            
             shouldShow  vis 
                oripart.Size = .(char.HumanoidRootPart.Size.X, char.HumanoidRootPart.Size.Y * , char.HumanoidRootPart.Size.Z)
                oripart.CFrame = .(char.HumanoidRootPart.CFrame.Position, Camera.CFrame.Position)
                
                 SizeX = oripart.Size.X
                 SizeY = oripart.Size.Y
                 TL = Camera:((oripart.CFrame * .(SizeX, SizeY, )).Position)
                 TR = Camera:((oripart.CFrame * .(-SizeX, SizeY, )).Position)
                 BL = Camera:((oripart.CFrame * .(SizeX, -SizeY, )).Position)
                 BR = Camera:((oripart.CFrame * .(-SizeX, -SizeY, )).Position)
                
                 dist = (Player.Character  Player.Character:()  (Player.Character.HumanoidRootPart.Position - oripart.Position).Magnitude)  
                 thicknessValue = .( / dist * , , )
                
                 ratio = (Camera.CFrame.Position - char.HumanoidRootPart.Position).Magnitude
                 offset = .( / ratio * , , )
                
                Library.TL1.From = .(TL.X, TL.Y)
                Library.TL1.To = .(TL.X + offset, TL.Y)
                Library.TL2.From = .(TL.X, TL.Y)
                Library.TL2.To = .(TL.X, TL.Y + offset)

                Library.TR1.From = .(TR.X, TR.Y)
                Library.TR1.To = .(TR.X - offset, TR.Y)
                Library.TR2.From = .(TR.X, TR.Y)
                Library.TR2.To = .(TR.X, TR.Y + offset)

                Library.BL1.From = .(BL.X, BL.Y)
                Library.BL1.To = .(BL.X + offset, BL.Y)
                Library.BL2.From = .(BL.X, BL.Y)
                Library.BL2.To = .(BL.X, BL.Y - offset)

                Library.BR1.From = .(BR.X, BR.Y)
                Library.BR1.To = .(BR.X - offset, BR.Y)
                Library.BR2.From = .(BR.X, BR.Y)
                Library.BR2.To = .(BR.X, BR.Y - offset)
                
                 headPos, headOnScreen = Camera:(char.Head.Position + .(, , ))
                 headOnScreen 
                    Library.NameTag.Position = .(headPos.X, headPos.Y - )
                    Library.NameTag.Text = plr.Name
                    Library.NameTag.Visible = 
                
                    Library.NameTag.Visible = 
                
                
                 i, v  (Library) 
                     v ~= Library.NameTag 
                        v.Thickness = thicknessValue
                        v.Visible = 
                    
                
            
                 i, v  (Library) 
                    v.Visible = 
                
            
        
             i, v  (Library) 
                v.Visible = 
            
            
              Players:(plr.Name) 
                 i, v  (Library) 
                    v:()
                
                 oripart  oripart:() 
                connection:()
            
        
    )



 Window = WindUI:({
    Title = Translations[].WindowTitle,
    Icon = ,
    Author = ,
    Theme = 
})


 MainTab = Window:({ 
    Title = Translations[].MainTab, 
    Icon =  
})

 AimbotSec = MainTab:({ 
    Title = Translations[].AimbotSection, 
    Desc = Translations[].AimbotDesc 
})

 Row1 = MainTab:()
 ToggleAim = Row1:({ 
    Title = Translations[].AimbotToggle, 
    Value = State.AimEnabled, 
    Callback = (v) State.AimEnabled = v  
})

 Row2 = MainTab:()
 ToggleHead, ToggleClosest

ToggleHead = Row2:({ 
    Title = Translations[].AimHead, 
    Value = State.LockHead, 
    Callback = (v) 
        State.LockHead = v 
         v  
            State.LockClosest =  
             ToggleClosest  ToggleClosest:() 
         
     
})

ToggleClosest = Row2:({ 
    Title = Translations[].AimClosest, 
    Value = State.LockClosest, 
    Callback = (v) 
        State.LockClosest = v 
         v  
            State.LockHead =  
             ToggleHead  ToggleHead:() 
         
     
})

 RowAimbotPlugin = MainTab:()
 ToggleWallbang = RowAimbotPlugin:({ 
    Title = Translations[].Wallbang, 
    Value = State.AimWallbang, 
    Callback = (v) State.AimWallbang = v  
})

 FOVSec = MainTab:({ 
    Title = Translations[].FOVSection, 
    Desc = Translations[].FOVDesc 
})

 SliderFOV = MainTab:({ 
    Title = Translations[].FOVSize, 
    Step = , 
    Value = { Min = , Max = , Default = State.AimFOV }, 
    Callback = (v) State.AimFOV = v  
})

 ESPSec = MainTab:({ 
    Title = Translations[].ESPSection, 
    Desc = Translations[].ESPDesc 
})

 Row3 = MainTab:()
 ToggleESP = Row3:({ 
    Title = Translations[].ESPToggle, 
    Value = State.ESPEnabled, 
    Callback = (v) State.ESPEnabled = v  
})

 RowESPPlugin = MainTab:()
 ToggleThroughWalls = RowESPPlugin:({ 
    Title = Translations[].ThroughWalls, 
    Value = State.ESPThroughWalls, 
    Callback = (v) State.ESPThroughWalls = v  
})


 SettingsTab = Window:({
    Title = Translations[].SettingsTab,
    Icon = 
})

 ThemeSec = SettingsTab:({
    Title = Translations[].ThemeSection
})

 ThemeDropdown = SettingsTab:({
    Title = Translations[].SelectTheme,
    Values = {
        , , , , , , 
        , , , , , 
        , , , , 
    },
    Value = ,
    Callback = (selected)
        WindUI:(selected)
    
})

 LangSec = SettingsTab:({
    Title = Translations[].LangSection
})


  (elem, title, desc)
      elem   
    (()
         title  (elem.SetTitle) ==   elem:(title) 
         desc  (elem.SetDesc) ==   elem:(desc) 
    )


  (lang)
    State.Language = lang
     t = Translations[lang]  Translations[]
    
    (MainTab, t.MainTab)
    (AimbotSec, t.AimbotSection, t.AimbotDesc)
    (ToggleAim, t.AimbotToggle)
    (ToggleHead, t.AimHead)
    (ToggleClosest, t.AimClosest)
    (ToggleWallbang, t.Wallbang)
    
    (FOVSec, t.FOVSection, t.FOVDesc)
    (SliderFOV, t.FOVSize)
    
    (ESPSec, t.ESPSection, t.ESPDesc)
    (ToggleESP, t.ESPToggle)
    (ToggleThroughWalls, t.ThroughWalls)
    
    (SettingsTab, t.SettingsTab)
    (ThemeSec, t.ThemeSection)
    (ThemeDropdown, t.SelectTheme)
    (LangSec, t.LangSection)
     LangDropdown  (LangDropdown, t.SelectLang) 


 LangDropdown = SettingsTab:({
    Title = Translations[].SelectLang,
    Values = { ,  },
    Value = ,
    Callback = (selected)
        (selected)
    
})


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


Players.PlayerAdded:((newplr)
    (newplr)
)


RS.RenderStepped:(()
     mid = .(Camera.ViewportSize.X/, Camera.ViewportSize.Y/)
    CurrentLock, TargetPart = ()
    
    circ.Visible = State.AimEnabled
     circ.Visible 
        circ.Size = .(State.AimFOV * , State.AimFOV * )
        circ.Position = .(mid.X, mid.Y)
    
    
     State.AimEnabled  CurrentLock  TargetPart  
        Camera.CFrame = .(Camera.CFrame.Position, TargetPart.Position) 
    
)