Universal esp and aimbot by gemini

 esp_settings = {
    enabled = ,
    box = ,
    corner_box = ,
    _3d_box = ,
    skeleton = ,
    circle_head = ,
    name = ,
    health = ,
    tracer = ,
    distance = ,
    rainbow_mode = ,
    
    
    team_check = ,
    
    
    aimbot_enabled = ,
    aimbot_fov = ,
}





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


 ScreenGui = .()
ScreenGui.Name = 
ScreenGui.Parent = CoreGui


 MainFrame = .()
MainFrame.Size = .(, , , )
MainFrame.Position = .(, , , )
MainFrame.BackgroundColor3 = .(, , )
MainFrame.BorderSizePixel = 
MainFrame.Parent = ScreenGui


 ScrollingFrame = .()
ScrollingFrame.Size = .(, , , )
ScrollingFrame.BackgroundTransparency = 
ScrollingFrame.CanvasSize = .(, , , )
ScrollingFrame.ScrollBarImageColor3 = .(, , )
ScrollingFrame.Parent = MainFrame


 toggle_button = .()
toggle_button.Size = .(, , , )
toggle_button.Position = .(, , , )
toggle_button.Text = 
toggle_button.Font = .Font.SourceSans
toggle_button.TextSize = 
toggle_button.TextColor3 = .(, , )
toggle_button.BackgroundColor3 = .(, , )
toggle_button.Parent = ScreenGui

toggle_button.MouseButton1Click:(()
    MainFrame.Visible =  MainFrame.Visible
     MainFrame.Visible 
        toggle_button.Text = 
    
        toggle_button.Text = 
    
)

  (name, key, default_state, y_pos)
     button = .()
    button.Size = .(, -, , )
    button.Position = .(, , , y_pos)
    button.Text = name ..  .. (default_state) .. 
    button.Font = .Font.SourceSansBold
    button.TextSize = 
    button.TextColor3 = .(, , )
    button.BackgroundColor3 = .(, , )
    button.Parent = ScrollingFrame

    button.MouseButton1Click:(()
         newState =  esp_settings[key]
        esp_settings[key] = newState
        button.Text = name ..  .. (newState) .. 
    )


  (text, y_pos)
     label = .()
    label.Size = .(, -, , )
    label.Position = .(, , , y_pos)
    label.Text = text
    label.Font = .Font.SourceSansBold
    label.TextSize = 
    label.TextColor3 = .(, , )
    label.BackgroundTransparency = 
    label.Parent = ScrollingFrame
     label


  (y_pos)
     fov_label = ( .. (esp_settings.aimbot_fov), y_pos)
    
     button_frame = .()
    button_frame.Size = .(, -, , )
    button_frame.Position = .(, , , y_pos + )
    button_frame.BackgroundTransparency = 
    button_frame.Parent = ScrollingFrame
    
     minus_button = .()
    minus_button.Size = .(, , , )
    minus_button.Position = .(, , , )
    minus_button.Text = 
    minus_button.Font = .Font.SourceSansBold
    minus_button.TextSize = 
    minus_button.TextColor3 = .(,,)
    minus_button.BackgroundColor3 = .(, , )
    minus_button.Parent = button_frame
    
     plus_button = .()
    plus_button.Size = .(, , , )
    plus_button.Position = .(, , , )
    plus_button.Text = 
    plus_button.Font = .Font.SourceSansBold
    plus_button.TextSize = 
    plus_button.TextColor3 = .(,,)
    plus_button.BackgroundColor3 = .(, , )
    plus_button.Parent = button_frame
    
    minus_button.MouseButton1Click:(()
        esp_settings.aimbot_fov = .(, esp_settings.aimbot_fov - )
        fov_label.Text =  .. (esp_settings.aimbot_fov)
    )
    
    plus_button.MouseButton1Click:(()
        esp_settings.aimbot_fov = .(, esp_settings.aimbot_fov + )
        fov_label.Text =  .. (esp_settings.aimbot_fov)
    )



(, )
(, , esp_settings.enabled, )
(, , esp_settings.box, )
(, , esp_settings.corner_box, )
(, , esp_settings._3d_box, )
(, , esp_settings.skeleton, )
(, , esp_settings.circle_head, )
(, , esp_settings.name, )
(, , esp_settings.health, )
(, , esp_settings.tracer, )
(, , esp_settings.distance, )
(, , esp_settings.rainbow_mode, )


(, )
(, , esp_settings.team_check, )


(, )
(, , esp_settings.aimbot_enabled, )
()






  = 

 visuals_frame = .()
visuals_frame.Name = 
visuals_frame.Size = .(, , , )
visuals_frame.BackgroundTransparency = 
visuals_frame.Parent = ScreenGui
visuals_frame.ZIndex = 

 esp_drawings = {}


  (player)
     player.Team  LocalPlayer.Team  player.Team == LocalPlayer.Team


  (target_part)
     ray_params = RaycastParams.()
    ray_params.FilterDescendantsInstances = {LocalPlayer.Character}
    ray_params.FilterType = .RaycastFilterType.Exclude
     ray_result = :(camera.CFrame.Position, (target_part.Position - camera.CFrame.Position).unit * , ray_params)
     ray_result  ray_result.Instance.Parent == target_part.Parent


  (pos1, pos2, color, thickness, parent)
     line = .()
    line.Color = color
    line.Thickness = thickness
    line.From = pos1
    line.To = pos2
    line.Visible = 
    .(parent, line)


  (pos, radius, color, thickness, fill, parent)
     circle = .()
    circle.Position = pos
    circle.Radius = radius
    circle.Color = color
    circle.Thickness = thickness
    circle.Filled = fill
    circle.Visible = 
    .(parent, circle)


  (pos, text, size, color, parent)
     text_draw = .()
    text_draw.Position = pos
    text_draw.Text = text
    text_draw.Size = size
    text_draw.Color = color
    text_draw.Outline = 
    text_draw.OutlineColor = .(, , )
    text_draw.Visible = 
    .(parent, text_draw)


  ()
     _, drawing  (esp_drawings) 
        drawing:()
    
    esp_drawings = {}


  (player)
     character = player.Character
     humanoid = character:()
     humanoid_root_part = character:()

      character   humanoid  humanoid.Health <=    humanoid_root_part 
        
    

     head_pos, head_on_screen = camera:(character.Head.Position)
     root_pos, root_on_screen = camera:(humanoid_root_part.Position)
     is_visible_check = (humanoid_root_part)
     esp_color = .(, , ) 
     tracer_color = esp_color
    
     esp_settings.team_check  (player) 
        
    

     esp_settings.rainbow_mode 
        esp_color = .(() % , , )
    
         (player) 
            esp_color = .(, , ) 
         is_visible_check 
            esp_color = .(, , ) 
        
    
    tracer_color = esp_color
    
      head_on_screen   root_on_screen 
        
    

     head_vector = .(head_pos.X, head_pos.Y)
     root_vector = .(root_pos.X, root_pos.Y)
     dist_from_cam = (LocalPlayer.Character.Head.Position - character.Head.Position).Magnitude
    
    
     character_screen_height = .(head_vector.Y - root_vector.Y)
     box_height = .(, character_screen_height)
     box_width = box_height * 
    
    
     esp_settings.health 
         health_percent = humanoid.Health / humanoid.MaxHealth
         health_color = .( * health_percent, , )
        (.(root_vector.X - box_width /  - , root_vector.Y), .(root_vector.X - box_width /  - , root_vector.Y + (head_vector.Y - root_vector.Y) * health_percent), health_color, , esp_drawings)
    
    
     esp_settings.name 
        (.(head_vector.X, head_vector.Y - ), player.Name, , .(,,), esp_drawings)
    
    
     esp_settings.distance 
        (.(root_vector.X, root_vector.Y + ), .(dist_from_cam) .. , , .(,,), esp_drawings)
    

    
     esp_settings.box  esp_settings.corner_box 
         box_x1 = root_vector.X - box_width / 
         box_y1 = head_vector.Y
         box_x2 = root_vector.X + box_width / 
         box_y2 = root_vector.Y

         esp_settings.box 
            (.(box_x1, box_y1), .(box_x2, box_y1), esp_color, , esp_drawings) 
            (.(box_x1, box_y2), .(box_x2, box_y2), esp_color, , esp_drawings) 
            (.(box_x1, box_y1), .(box_x1, box_y2), esp_color, , esp_drawings) 
            (.(box_x2, box_y1), .(box_x2, box_y2), esp_color, , esp_drawings) 
         esp_settings.corner_box 
             corner_size = box_width * 
            
            (.(box_x1, box_y1), .(box_x1, box_y1 + corner_size), esp_color, , esp_drawings)
            (.(box_x1, box_y1), .(box_x1 + corner_size, box_y1), esp_color, , esp_drawings)
            
            (.(box_x2, box_y1), .(box_x2, box_y1 + corner_size), esp_color, , esp_drawings)
            (.(box_x2, box_y1), .(box_x2 - corner_size, box_y1), esp_color, , esp_drawings)
            
            (.(box_x1, box_y2), .(box_x1, box_y2 - corner_size), esp_color, , esp_drawings)
            (.(box_x1, box_y2), .(box_x1 + corner_size, box_y2), esp_color, , esp_drawings)
            
            (.(box_x2, box_y2), .(box_x2, box_y2 - corner_size), esp_color, , esp_drawings)
            (.(box_x2, box_y2), .(box_x2 - corner_size, box_y2), esp_color, , esp_drawings)
        
    

     esp_settings._3d_box 
          = humanoid_root_part.CFrame
         size = humanoid_root_part.Size
        
         x = size.X / 
         y = size.Y / 
         z = size.Z / 
        
         corners = {
             * .(x, y, z).p,
             * .(x, y, -z).p,
             * .(x, -y, z).p,
             * .(x, -y, -z).p,
             * .(-x, y, z).p,
             * .(-x, y, -z).p,
             * .(-x, -y, z).p,
             * .(-x, -y, -z).p,
        }
        
          (a, b)
             pos1, on_screen1 = camera:(corners[a])
             pos2, on_screen2 = camera:(corners[b])
             on_screen1  on_screen2 
                (.(pos1.X, pos1.Y), .(pos2.X, pos2.Y), esp_color, , esp_drawings)
            
        

        (,)
        (,)
        (,)
        (,)
        (,)
        (,)
        (,)
        (,)
        (,)
        (,)
        (,)
        (,)
    
    
     esp_settings.skeleton 
         parts = {
            Head = character:(),
            Torso = character:(),
            HumanoidRootPart = humanoid_root_part,
            
            UpperTorso = character:(),
            LowerTorso = character:(),
            
            LeftUpperArm = character:(),
            LeftLowerArm = character:(),
            LeftHand = character:(),
            RightUpperArm = character:(),
            RightLowerArm = character:(),
            RightHand = character:(),
            
            LeftUpperLeg = character:(),
            LeftLowerLeg = character:(),
            LeftFoot = character:(),
            RightUpperLeg = character:(),
            RightLowerLeg = character:(),
            RightFoot = character:()
        }
        
          (p1_name, p2_name)
             p1 = parts[p1_name]
             p2 = parts[p2_name]
             p1  p2 
                 pos1, on_screen1 = camera:(p1.Position)
                 pos2, on_screen2 = camera:(p2.Position)
                 on_screen1  on_screen2 
                    (.(pos1.X, pos1.Y), .(pos2.X, pos2.Y), esp_color, , esp_drawings)
                
            
        
        
        
         parts.Torso 
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
        
        
        
         parts.UpperTorso 
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
            (, )
        
    

     esp_settings.circle_head 
         head_pos = character:()
         head_pos 
             pos, on_screen = camera:(head_pos.Position)
             on_screen 
                (.(pos.X, pos.Y), , esp_color, , , esp_drawings)
            
        
    

     esp_settings.tracer 
        (.(camera.ViewportSize.X/, camera.ViewportSize.Y), root_vector, tracer_color, , esp_drawings)
    


  ()
    ()
    
     best_target = 
     smallest_fov = esp_settings.aimbot_fov
     screen_center = .(camera.ViewportSize.X/, camera.ViewportSize.Y/)
    
    
     esp_settings.aimbot_enabled 
         _, player  (Players:()) 
             character = player.Character
             player ~= LocalPlayer  character  character:()  character:() 
                 humanoid = character.Humanoid
                 head_pos = character.Head
                 humanoid  humanoid.Health >    (esp_settings.team_check  (player)) 
                     head_on_screen, head_in_viewport = camera:(head_pos.Position)
                     head_in_viewport 
                         fov_dist = (.(head_on_screen.X, head_on_screen.Y) - screen_center).Magnitude
                         fov_dist < smallest_fov 
                             (head_pos) 
                                smallest_fov = fov_dist
                                best_target = head_pos
                            
                        
                    
                
            
        
        
         best_target 
            camera.CFrame = .(camera.CFrame.Position, best_target.Position)
        
    
    
    
     esp_settings.enabled 
         _, player  (Players:()) 
             player ~= LocalPlayer  player.Character