XENO COMPATIBLE VERSION AIM ESP RADAR SOURCE CODE

 Players = :()
 RunService = :()
 UserInputService = :()
 Teams = :()

 LocalPlayer = Players.LocalPlayer
 camera = .CurrentCamera

 mousemoverel = mousemoverel  (Input  Input.MouseMove)  

 Config = {
    ESP_Enabled = ,
    ESP_Box = ,
    ESP_Name = ,
    ESP_Distance = ,
    ESP_Tracer = ,
    ESP_Rainbow = ,
    ESP_TeamCheck = ,
    
    AIM_Enabled = ,
    AIM_FOVEnabled = ,
    AIM_FOV = ,
    AIM_Smooth = ,
    
    RADAR_Enabled = ,
    RADAR_Size = ,
    RADAR_Range = ,
    
    MISC_Watermark = ,
    MISC_ActiveList = 
}

 Tuning = {
    PanelWidth = ,
    PanelHeaderH = ,
    ItemHeight = ,
    FontSize = ,
    SliderHeight = ,
    RadarDotSize = 
}

 Palette = {
    PanelBg = .(, , ),
    PanelHeader = .(, , ),
    PanelBorder = .(, , ),
    ItemOn = .(, , ),
    ItemOff = .(, , ),
    ItemHover = .(, , ),
    Text = .(, , ),
    TextDim = .(, , ),
    Accent = .(, , ),
    
    ESP_Enemy = .(, , ),
    ESP_Visible = .(, , ),
    
    FOV_Circle = .(, , ),
    FOV_Active = .(, , ),
    
    RadarBg = .(, , ),
    RadarBorder = .(, , ),
    RadarGrid = .(, , ),
    RadarYou = .(, , ),
    RadarEnemy = .(, , )
}

 State = {
    Unloaded = ,
    RainbowHue = ,
    Aiming = 
}

 Cache = {
    Teams = {},
    TeamUpdateTime = ,
    Visibility = {},
    VisUpdateTime = ,
    CharactersFolder = ,
    LocalChar = ,
    LocalCharTime = 
}

 CacheIntervals = {
    Team = ,
    Visibility = ,
    LocalChar = 
}

 Connections = {}
 espObjects = {}
 radarDots = {}
 targetEnemy = 

 UI = {}
UI.ScreenGui = .()
UI.ScreenGui.Name = 
UI.ScreenGui.ResetOnSpawn = 
UI.ScreenGui.ZIndexBehavior = .ZIndexBehavior.Sibling
UI.ScreenGui.DisplayOrder = 
UI.ScreenGui.IgnoreGuiInset = 

(() UI.ScreenGui.Parent = :() )
  UI.ScreenGui.Parent 
    UI.ScreenGui.Parent = LocalPlayer:()


UI.ESPFolder = .()
UI.ESPFolder.Name = 
UI.ESPFolder.Parent = UI.ScreenGui

  (player)
      player    
     :() 
         vo = .VoiceOrigins
         vo:()  vo.ORANGE:(player.Name) 
             Teams:()  
         vo:()  vo.BLUE:(player.Name) 
             Teams:()  
        
    
     


  (player)
      player    
     now = ()
     now - Cache.TeamUpdateTime > CacheIntervals.Team 
        Cache.Teams = {}
        Cache.TeamUpdateTime = now
    
     Cache.Teams[player] ==  
        Cache.Teams[player] = (player)  
    
     result = Cache.Teams[player]
     result ~=   result  


  ()
      Cache.CharactersFolder 
        Cache.CharactersFolder = :()
    
     Cache.CharactersFolder


  ()
     now = ()
     now - Cache.LocalCharTime > CacheIntervals.LocalChar   Cache.LocalChar   Cache.LocalChar.Parent 
         chars = ()
        Cache.LocalChar = chars  chars:(LocalPlayer.Name)
        Cache.LocalCharTime = now
    
     Cache.LocalChar


  (character)
     parts = {, , , , , }
     _, name  (parts) 
         part = character:(name)
         part   part 
    
     _, part  (character:()) 
         part:()   part 
    
     


  (targetPart)
     localChar = ()
      localChar   targetPart    
     localPart = (localChar)
      localPart    
    
     targetChar = targetPart:()
    
     origin = localPart.Position
     direction = (targetPart.Position - origin)
     params = RaycastParams.()
    params.FilterDescendantsInstances = {localChar, targetChar}
    params.FilterType = .RaycastFilterType.Blacklist
    
     result = :(origin, direction, params)
     result == 


  (targetPart)
      targetPart    
     now = ()
     now - Cache.VisUpdateTime > CacheIntervals.Visibility 
        Cache.Visibility = {}
        Cache.VisUpdateTime = now
    
     Cache.Visibility[targetPart] ==  
        Cache.Visibility[targetPart] = (targetPart)
    
     Cache.Visibility[targetPart]


  (pos)
     char = ()
      char    
     root = (char)
      root    
     (pos - root.Position).Magnitude


  ()
     .(State.RainbowHue, , )


  (player)
     espObjects[player]   
    
     container = .()
    container.Name = player.Name
    container.BackgroundTransparency = 
    container.BorderSizePixel = 
    container.Size = .(, , , )
    container.Parent = UI.ESPFolder
    
     box = .()
    box.Name = 
    box.BackgroundTransparency = 
    box.BorderSizePixel = 
    box.Parent = container
    
     boxStroke = .()
    boxStroke.Name = 
    boxStroke.Color = Palette.ESP_Enemy
    boxStroke.Thickness = 
    boxStroke.Parent = box
    
     nameLabel = .()
    nameLabel.Name = 
    nameLabel.BackgroundTransparency = 
    nameLabel.Font = .Font.RobotoMono
    nameLabel.TextSize = 
    nameLabel.TextColor3 = .(, , )
    nameLabel.TextStrokeTransparency = 
    nameLabel.TextStrokeColor3 = .(, , )
    nameLabel.Text = player.Name
    nameLabel.Size = .(, , , )
    nameLabel.Parent = container
    
     distLabel = .()
    distLabel.Name = 
    distLabel.BackgroundTransparency = 
    distLabel.Font = .Font.RobotoMono
    distLabel.TextSize = 
    distLabel.TextColor3 = .(, , )
    distLabel.TextStrokeTransparency = 
    distLabel.TextStrokeColor3 = .(, , )
    distLabel.Size = .(, , , )
    distLabel.Parent = container
    
     tracer = .()
    tracer.Name = 
    tracer.BackgroundColor3 = Palette.ESP_Enemy
    tracer.BorderSizePixel = 
    tracer.AnchorPoint = .(, )
    tracer.Parent = container
    
    espObjects[player] = {
        Container = container,
        Box = box,
        BoxStroke = boxStroke,
        Name = nameLabel,
        Distance = distLabel,
        Tracer = tracer
    }


  (player)
     espObjects[player] 
         espObjects[player].Container 
            espObjects[player].Container:()
        
        espObjects[player] = 
    


  ()
     player, esp  (espObjects) 
         esp.Container 
            esp.Container:()
        
    
    espObjects = {}


  ()
    camera = .CurrentCamera
      camera    
    
     localTeam = (LocalPlayer)
     closestPos = 
     closestDist = Config.AIM_FOVEnabled  Config.AIM_FOV  .huge
     mousePos = UserInputService:()
     charsFolder = ()
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         character = charsFolder  charsFolder:(player.Name)
          character   
        
         playerTeam = (player)
        
         isEnemy = 
         Config.ESP_TeamCheck  localTeam  playerTeam 
            isEnemy = localTeam ~= playerTeam
        
        
         isEnemy 
             part = (character)
             part 
                 screenPos, onScreen = camera:(part.Position)
                 onScreen 
                     screenVec = .(screenPos.X, screenPos.Y)
                     dist = (mousePos - screenVec).Magnitude
                     dist < closestDist 
                        closestDist = dist
                        closestPos = screenVec
                        targetEnemy = part
                    
                
            
        
    
    
     closestPos


  ()
    camera = .CurrentCamera
      camera   
    
      Config.AIM_Enabled   State.Aiming 
        targetEnemy = 
        
    
    
     mousePos = UserInputService:()
     aimPos = 
    
     targetEnemy  targetEnemy.Parent 
         screenPos, onScreen = camera:(targetEnemy.Position)
         onScreen 
            aimPos = .(screenPos.X, screenPos.Y)
        
            targetEnemy = 
        
    
    
      aimPos 
        aimPos = ()
    
    
      aimPos   
    
     deltaX = (aimPos.X - mousePos.X) / Config.AIM_Smooth
     deltaY = (aimPos.Y - mousePos.Y) / Config.AIM_Smooth
    
     mousemoverel 
        (deltaX, deltaY)
    
         currentCFrame = camera.CFrame
         worldPos = camera:(aimPos.X, aimPos.Y).Origin
         goalCFrame = .(currentCFrame.Position, worldPos)
        camera.CFrame = currentCFrame:(goalCFrame, )
    


  ()
    camera = .CurrentCamera
      camera   
    
      Config.ESP_Enabled 
         _, esp  (espObjects) 
            esp.Container.Visible = 
        
        
    
    
     localTeam = (LocalPlayer)
     charsFolder = ()
     screenSize = camera.ViewportSize
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         character = charsFolder  charsFolder:(player.Name)
         playerTeam = (player)
        
          character   playerTeam 
             espObjects[player] 
                espObjects[player].Container.Visible = 
            
            
        
        
          espObjects[player] 
            (player)
        
        
         esp = espObjects[player]
          esp   
        
         targetPart = (character)
          targetPart 
            esp.Container.Visible = 
            
        
        
         rootPos, onScreen = camera:(targetPart.Position)
          onScreen  rootPos.Z <=  
            esp.Container.Visible = 
            
        
        
         distance = (targetPart.Position)
        
         isEnemy = 
         Config.ESP_TeamCheck  localTeam  playerTeam 
            isEnemy = localTeam ~= playerTeam
        
        
          isEnemy 
            esp.Container.Visible = 
            
        
        
        esp.Container.Visible = 
        
         visible = (targetPart)
         col = Config.ESP_Rainbow  ()  (visible  Palette.ESP_Visible  Palette.ESP_Enemy)
        
         boxHeight =  / .(rootPos.Z, )
        boxHeight = .(boxHeight, , )
         boxWidth = boxHeight * 
        
         boxX = rootPos.X - boxWidth / 
         boxY = rootPos.Y - boxHeight * 
        
         Config.ESP_Box 
            esp.Box.Position = .(, boxX, , boxY)
            esp.Box.Size = .(, boxWidth, , boxHeight)
            esp.BoxStroke.Color = col
            esp.Box.Visible = 
        
            esp.Box.Visible = 
        
        
         Config.ESP_Name 
            esp.Name.Position = .(, rootPos.X - , , boxY - )
            esp.Name.Visible = 
        
            esp.Name.Visible = 
        
        
         Config.ESP_Distance 
            esp.Distance.Text = .(distance) .. 
            esp.Distance.Position = .(, rootPos.X - , , boxY + boxHeight + )
            esp.Distance.Visible = 
        
            esp.Distance.Visible = 
        
        
         Config.ESP_Tracer 
             tracerStartY = boxY + boxHeight
             tracerEndY = screenSize.Y
             tracerHeight = tracerEndY - tracerStartY
            esp.Tracer.Position = .(, rootPos.X, , tracerStartY)
            esp.Tracer.Size = .(, , , tracerHeight)
            esp.Tracer.BackgroundColor3 = col
            esp.Tracer.Visible = 
        
            esp.Tracer.Visible = 
        
    


 FOVCircle = .()
FOVCircle.Name = 
FOVCircle.BackgroundTransparency = 
FOVCircle.BorderSizePixel = 
FOVCircle.AnchorPoint = .(, )
FOVCircle.Parent = UI.ScreenGui

 FOVStroke = .()
FOVStroke.Color = Palette.FOV_Circle
FOVStroke.Thickness = 
FOVStroke.Parent = FOVCircle

 FOVCorner = .()
FOVCorner.CornerRadius = .(, )
FOVCorner.Parent = FOVCircle

  ()
     Config.AIM_Enabled  Config.AIM_FOVEnabled 
         mousePos = UserInputService:()
         guiInset = :():()
        FOVCircle.Position = .(, mousePos.X, , mousePos.Y + guiInset.Y)
        FOVCircle.Size = .(, Config.AIM_FOV * , , Config.AIM_FOV * )
        FOVStroke.Color = State.Aiming  Palette.FOV_Active  Palette.FOV_Circle
        FOVCircle.Visible = 
    
        FOVCircle.Visible = 
    


 RadarFrame = .()
RadarFrame.Name = 
RadarFrame.BackgroundColor3 = Palette.RadarBg
RadarFrame.BackgroundTransparency = 
RadarFrame.BorderSizePixel = 
RadarFrame.AnchorPoint = .(, )
RadarFrame.Parent = UI.ScreenGui

 RadarStroke = .()
RadarStroke.Color = Palette.RadarBorder
RadarStroke.Thickness = 
RadarStroke.Parent = RadarFrame

 RadarCross1 = .()
RadarCross1.Name = 
RadarCross1.BackgroundColor3 = Palette.RadarGrid
RadarCross1.BorderSizePixel = 
RadarCross1.AnchorPoint = .(, )
RadarCross1.Parent = RadarFrame

 RadarCross2 = .()
RadarCross2.Name = 
RadarCross2.BackgroundColor3 = Palette.RadarGrid
RadarCross2.BorderSizePixel = 
RadarCross2.AnchorPoint = .(, )
RadarCross2.Parent = RadarFrame

 RadarCenter = .()
RadarCenter.Name = 
RadarCenter.BackgroundColor3 = Palette.RadarYou
RadarCenter.BorderSizePixel = 
RadarCenter.AnchorPoint = .(, )
RadarCenter.Size = .(, , , )
RadarCenter.Parent = RadarFrame

 RadarCenterCorner = .()
RadarCenterCorner.CornerRadius = .(, )
RadarCenterCorner.Parent = RadarCenter

 RadarDotsFolder = .()
RadarDotsFolder.Name = 
RadarDotsFolder.Parent = RadarFrame

 i = ,  
     dot = .()
    dot.Name =  .. i
    dot.BackgroundColor3 = Palette.RadarEnemy
    dot.BorderSizePixel = 
    dot.AnchorPoint = .(, )
    dot.Size = .(, Tuning.RadarDotSize, , Tuning.RadarDotSize)
    dot.Visible = 
    dot.Parent = RadarDotsFolder
    
     dotCorner = .()
    dotCorner.CornerRadius = .(, )
    dotCorner.Parent = dot
    
    radarDots[i] = dot


  ()
    camera = .CurrentCamera
      camera 
        RadarFrame.Visible = 
        
    
    
      Config.RADAR_Enabled 
        RadarFrame.Visible = 
        
    
    
     myChar = ()
      myChar 
        RadarFrame.Visible = 
        
    
     myRoot = (myChar)
      myRoot 
        RadarFrame.Visible = 
        
    
    
     charsFolder = ()
     size = Config.RADAR_Size
     screenSize = camera.ViewportSize
    
    RadarFrame.Position = .(, -, , )
    RadarFrame.Size = .(, size, , size)
    RadarFrame.Visible = 
    
    RadarCross1.Position = .(, , , )
    RadarCross1.Size = .(, , , -)
    
    RadarCross2.Position = .(, , , )
    RadarCross2.Size = .(, -, , )
    
    RadarCenter.Position = .(, , , )
    
     myLook = camera.CFrame.LookVector
     myAngle = .(-myLook.X, -myLook.Z)
     cosA, sinA = .(myAngle), .(myAngle)
     scale = (size/ - ) / Config.RADAR_Range
    
     localTeam = (LocalPlayer)
     dotIdx = 
    
     _, player  (Players:()) 
         player == LocalPlayer   
        
         character = charsFolder  charsFolder:(player.Name)
         playerTeam = (player)
        
          character   playerTeam   
        
         isEnemy = 
         Config.ESP_TeamCheck  localTeam  playerTeam 
            isEnemy = localTeam ~= playerTeam
        
        
          isEnemy   
        
         root = (character)
          root   
        
         rx = root.Position.X - myRoot.Position.X
         rz = root.Position.Z - myRoot.Position.Z
         dist2D = .(rx^ + rz^)
        
         dist2D < Config.RADAR_Range 
             rotX = rx * cosA - rz * sinA
             rotZ = rx * sinA + rz * cosA
             radarX, radarY = rotX * scale, rotZ * scale
             maxD = size/ - 
             rDist = .(radarX^ + radarY^)
             rDist > maxD 
                radarX, radarY = radarX/rDist * maxD, radarY/rDist * maxD
            
            
             dotIdx <= #radarDots 
                 dot = radarDots[dotIdx]
                dot.Position = .(, radarX, , radarY)
                
                 visible = (root)
                dot.BackgroundColor3 = visible  Palette.ESP_Visible  Palette.ESP_Enemy
                dot.Visible = 
                dotIdx = dotIdx + 
            
        
    
    
     i = dotIdx, #radarDots 
        radarDots[i].Visible = 
    


  ()
     container = .()
    container.Name = 
    container.BackgroundTransparency = 
    container.Position = .(, , , )
    container.Size = .(, , , )
    container.Parent = UI.ScreenGui
    
     label = .()
    label.Name = 
    label.BackgroundTransparency = 
    label.Position = .(, , , )
    label.Size = .(, , , )
    label.Font = .Font.RobotoMono
    label.TextSize = 
    label.TextColor3 = Palette.Accent
    label.TextXAlignment = .TextXAlignment.Left
    label.TextStrokeTransparency = 
    label.Text = 
    label.Parent = container
    
     xenoLabel = .()
    xenoLabel.Name = 
    xenoLabel.BackgroundTransparency = 
    xenoLabel.Position = .(, , , )
    xenoLabel.Size = .(, , , )
    xenoLabel.Font = .Font.RobotoMono
    xenoLabel.TextSize = 
    xenoLabel.TextColor3 = .(, , )
    xenoLabel.TextXAlignment = .TextXAlignment.Left
    xenoLabel.TextStrokeTransparency = 
    xenoLabel.Text = 
    xenoLabel.Parent = container
    
     container


  ()
     frame = .()
    frame.Name = 
    frame.BackgroundTransparency = 
    frame.AnchorPoint = .(, )
    frame.Position = .(, -, , )
    frame.Size = .(, , , )
    frame.Parent = UI.ScreenGui
    
     layout = .()
    layout.FillDirection = .FillDirection.Vertical
    layout.HorizontalAlignment = .HorizontalAlignment.Right
    layout.SortOrder = .SortOrder.Name
    layout.Padding = .(, )
    layout.Parent = frame
    
     frame


  (frame)
     _, child  (frame:()) 
         child:()  child:() 
    
    
      Config.MISC_ActiveList   
    
     features = {}
     Config.ESP_Enabled  .(features, ) 
     Config.ESP_Box  .(features, ) 
     Config.ESP_Name  .(features, ) 
     Config.ESP_Distance  .(features, ) 
     Config.ESP_Tracer  .(features, ) 
     Config.AIM_Enabled  .(features, ) 
     Config.RADAR_Enabled  .(features, ) 
    
     i, name  (features) 
         lbl = .()
        lbl.Name = .(, i) .. name
        lbl.BackgroundTransparency = 
        lbl.Size = .(, , , )
        lbl.Font = .Font.RobotoMono
        lbl.TextSize = 
        lbl.TextColor3 = Palette.ItemOn
        lbl.TextXAlignment = .TextXAlignment.Right
        lbl.TextStrokeTransparency = 
        lbl.Text = name
        lbl.Parent = frame
    


  (title, items, pos)
     totalHeight = Tuning.PanelHeaderH
     _, item  (items) 
         item.type ==  
            totalHeight = totalHeight + Tuning.SliderHeight
        
            totalHeight = totalHeight + Tuning.ItemHeight
        
    
    totalHeight = totalHeight + 
    
     panel = .()
    panel.Name = title
    panel.BackgroundColor3 = Palette.PanelBg
    panel.BackgroundTransparency = 
    panel.BorderSizePixel = 
    panel.Position = pos
    panel.Size = .(, Tuning.PanelWidth, , totalHeight)
    panel.Active = 
    panel.Draggable = 
    panel.Parent = UI.ScreenGui
    
     stroke = .()
    stroke.Color = Palette.PanelBorder
    stroke.Thickness = 
    stroke.Parent = panel
    
     header = .()
    header.Name = 
    header.BackgroundColor3 = Palette.PanelHeader
    header.BackgroundTransparency = 
    header.BorderSizePixel = 
    header.Size = .(, , , Tuning.PanelHeaderH)
    header.Parent = panel
    
     titleLabel = .()
    titleLabel.Name = 
    titleLabel.BackgroundTransparency = 
    titleLabel.Size = .(, , , )
    titleLabel.Font = .Font.GothamBold
    titleLabel.TextSize = Tuning.FontSize
    titleLabel.TextColor3 = Palette.Text
    titleLabel.Text = title
    titleLabel.Parent = header
    
     yOffset = Tuning.PanelHeaderH + 
    
     _, item  (items) 
         item.type ==  
             btn = .()
            btn.Name = item.key
            btn.BackgroundColor3 = Palette.ItemHover
            btn.BackgroundTransparency = 
            btn.BorderSizePixel = 
            btn.Position = .(, , , yOffset)
            btn.Size = .(, , , Tuning.ItemHeight)
            btn.Font = .Font.RobotoMono
            btn.TextSize = Tuning.FontSize
            btn.TextXAlignment = .TextXAlignment.Left
            btn.AutoButtonColor = 
            btn.Parent = panel
            
             pad = .()
            pad.PaddingLeft = .(, )
            pad.Parent = btn
            
              ()
                btn.TextColor3 = Config[item.key]  Palette.ItemOn  Palette.ItemOff
                btn.Text = item.name
            
            ()
            
            btn.MouseEnter:(() btn.BackgroundTransparency =  )
            btn.MouseLeave:(() btn.BackgroundTransparency =  )
            btn.MouseButton1Click:(()
                Config[item.key] =  Config[item.key]
                ()
                 UI.ActiveList  (UI.ActiveList) 
            )
            
            yOffset = yOffset + Tuning.ItemHeight
            
         item.type ==  
             container = .()
            container.Name = item.key
            container.BackgroundTransparency = 
            container.Position = .(, , , yOffset)
            container.Size = .(, -, , Tuning.SliderHeight - )
            container.Parent = panel
            
             label = .()
            label.Name = 
            label.BackgroundTransparency = 
            label.Size = .(, , , )
            label.Font = .Font.RobotoMono
            label.TextSize = 
            label.TextColor3 = Palette.TextDim
            label.TextXAlignment = .TextXAlignment.Left
            label.Parent = container
            
             track = .()
            track.Name = 
            track.BackgroundColor3 = .(, , )
            track.BorderSizePixel = 
            track.Position = .(, , , )
            track.Size = .(, , , )
            track.Parent = container
            
             trackCorner = .()
            trackCorner.CornerRadius = .(, )
            trackCorner.Parent = track
            
             fill = .()
            fill.Name = 
            fill.BackgroundColor3 = Palette.Accent
            fill.BorderSizePixel = 
            fill.Size = .(, , , )
            fill.Parent = track
            
             fillCorner = .()
            fillCorner.CornerRadius = .(, )
            fillCorner.Parent = fill
            
              ()
                 val = Config[item.key]
                 pct = (val - item.min) / (item.max - item.min)
                fill.Size = .(pct, , , )
                label.Text = item.name ..  .. (.(val * ) / )
            
            ()
            
             dragging = 
            
            track.InputBegan:((input)
                 input.UserInputType == .UserInputType.MouseButton1 
                    dragging = 
                
            )
            
            track.InputEnded:((input)
                 input.UserInputType == .UserInputType.MouseButton1 
                    dragging = 
                
            )
            
            Connections[ .. item.key] = RunService.RenderStepped:(()
                 dragging 
                     mx = UserInputService:().X
                     tx = track.AbsolutePosition.X
                     tw = track.AbsoluteSize.X
                     pct = .((mx - tx) / tw, , )
                     val = item.min + pct * (item.max - item.min)
                    val = .(val / item.step + ) * item.step
                    Config[item.key] = .(val, item.min, item.max)
                    ()
                
            )
            
            yOffset = yOffset + Tuning.SliderHeight
        
    
    
     panel


UI.Watermark = ()
UI.ActiveList = ()
(UI.ActiveList)

UI.Panels = {}

UI.Panels.ESP = (, {
    { = , name = , key = },
    { = , name = , key = },
    { = , name = , key = },
    { = , name = , key = },
    { = , name = , key = },
    { = , name = , key = },
    { = , name = , key = }
}, .(, , , ))

UI.Panels.Aimbot = (, {
    { = , name = , key = },
    { = , name = , key = },
    { = , name = , key = , min = , max = , step = },
    { = , name = , key = , min = , max = , step = }
}, .(, , , ))

UI.Panels.Radar = (, {
    { = , name = , key = },
    { = , name = , key = , min = , max = , step = },
    { = , name = , key = , min = , max = , step = }
}, .(, , , ))

UI.Panels.Misc = (, {
    { = , name = , key = },
    { = , name = , key = }
}, .(, , , ))

  ()
     State.Unloaded   
    State.Unloaded = 
    
     _, conn  (Connections) 
        (() conn:() )
    
    
    ()
    
    (() UI.ScreenGui:() )


Connections.inputDown = UserInputService.InputBegan:((input, gp)
     input.KeyCode == .KeyCode.Home 
        ()
        
    
    
     input.KeyCode == .KeyCode.Insert   gp 
        UI.ScreenGui.Enabled =  UI.ScreenGui.Enabled
        
    
    
     input.UserInputType == .UserInputType.MouseButton2 
        State.Aiming = 
    
)

Connections.inputUp = UserInputService.InputEnded:((input)
     input.UserInputType == .UserInputType.MouseButton2 
        State.Aiming = 
        targetEnemy = 
    
)

Connections.render = RunService.RenderStepped:(()
     State.Unloaded   
    
    State.RainbowHue = (State.RainbowHue + ) % 
    
    ()
    ()
    ()
    ()
    
     UI.Watermark 
        UI.Watermark.Visible = Config.MISC_Watermark
    
)

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


Connections.playerAdded = Players.PlayerAdded:((player)
    (player)
)

Connections.playerRemoving = Players.PlayerRemoving:((player)
    (player)
)