Universal esp and aimbot by gemini

--[[

    FULL LUA SCRIPT FOR DELTA EXECUTOR
    WITH ESP, AIMBOT, FOV CHANGER, AND PERSISTENT GUI
    Created by: lua

    This version fixes the issue of the GUI disappearing on respawn.

]]--

---------------------------------------------------------------------------------
--                                  SETTINGS                                   --
---------------------------------------------------------------------------------

-- A table to hold our ESP settings
local esp_settings = {
    enabled = false,
    box = true,
    corner_box = false,
    _3d_box = false,
    skeleton = false,
    circle_head = false,
    name = true,
    health = true,
    tracer = false,
    distance = true,
    rainbow_mode = false,
    
    -- Visual filters
    team_check = true,
    
    -- Aimbot settings
    aimbot_enabled = false,
    aimbot_fov = 120,
}

---------------------------------------------------------------------------------
--                                 GUI LOGIC                                   --
---------------------------------------------------------------------------------

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")
local UserInputService = game:GetService("UserInputService")
local CoreGui = game:GetService("CoreGui")
local LocalPlayer = Players.LocalPlayer
local camera = workspace.CurrentCamera

-- Create a top-level ScreenGui instance and parent it to CoreGui
local ScreenGui = Instance.new("ScreenGui")
ScreenGui.Name = "ESPPanelGui"
ScreenGui.Parent = CoreGui

-- Create the main GUI frame (non-movable)
local MainFrame = Instance.new("Frame")
MainFrame.Size = UDim2.new(0.4, 0, 0.95, 0)
MainFrame.Position = UDim2.new(0.3, 0, 0.025, 0)
MainFrame.BackgroundColor3 = Color3.new(0.1, 0.1, 0.1)
MainFrame.BorderSizePixel = 0
MainFrame.Parent = ScreenGui

-- Use a ScrollingFrame for more options
local ScrollingFrame = Instance.new("ScrollingFrame")
ScrollingFrame.Size = UDim2.new(1, 0, 1, 0)
ScrollingFrame.BackgroundTransparency = 1
ScrollingFrame.CanvasSize = UDim2.new(0, 0, 0, 715)
ScrollingFrame.ScrollBarImageColor3 = Color3.new(0.2, 0.2, 0.2)
ScrollingFrame.Parent = MainFrame

-- Create the hide/show button outside the main frame
local toggle_button = Instance.new("TextButton")
toggle_button.Size = UDim2.new(0, 100, 0, 30)
toggle_button.Position = UDim2.new(0.05, 0, 0.05, 0)
toggle_button.Text = "Show GUI"
toggle_button.Font = Enum.Font.SourceSans
toggle_button.TextSize = 14
toggle_button.TextColor3 = Color3.new(1, 1, 1)
toggle_button.BackgroundColor3 = Color3.new(0.15, 0.15, 0.15)
toggle_button.Parent = ScreenGui

toggle_button.MouseButton1Click:Connect(function()
    MainFrame.Visible = not MainFrame.Visible
    if MainFrame.Visible then
        toggle_button.Text = "Hide GUI"
    else
        toggle_button.Text = "Show GUI"
    end
end)

local function create_toggle(name, key, default_state, y_pos)
    local button = Instance.new("TextButton")
    button.Size = UDim2.new(1, -20, 0, 40)
    button.Position = UDim2.new(0, 10, 0, y_pos)
    button.Text = name .. " (" .. tostring(default_state) .. ")"
    button.Font = Enum.Font.SourceSansBold
    button.TextSize = 18
    button.TextColor3 = Color3.new(1, 1, 1)
    button.BackgroundColor3 = Color3.new(0.2, 0.2, 0.2)
    button.Parent = ScrollingFrame

    button.MouseButton1Click:Connect(function()
        local newState = not esp_settings[key]
        esp_settings[key] = newState
        button.Text = name .. " (" .. tostring(newState) .. ")"
    end)
end

local function create_label(text, y_pos)
    local label = Instance.new("TextLabel")
    label.Size = UDim2.new(1, -20, 0, 30)
    label.Position = UDim2.new(0, 10, 0, y_pos)
    label.Text = text
    label.Font = Enum.Font.SourceSansBold
    label.TextSize = 20
    label.TextColor3 = Color3.new(1, 1, 1)
    label.BackgroundTransparency = 1
    label.Parent = ScrollingFrame
    return label
end

local function create_fov_control(y_pos)
    local fov_label = create_label("FOV: " .. tostring(esp_settings.aimbot_fov), y_pos)
    
    local button_frame = Instance.new("Frame")
    button_frame.Size = UDim2.new(1, -20, 0, 40)
    button_frame.Position = UDim2.new(0, 10, 0, y_pos + 40)
    button_frame.BackgroundTransparency = 1
    button_frame.Parent = ScrollingFrame
    
    local minus_button = Instance.new("TextButton")
    minus_button.Size = UDim2.new(0.3, 0, 1, 0)
    minus_button.Position = UDim2.new(0, 0, 0, 0)
    minus_button.Text = "-5"
    minus_button.Font = Enum.Font.SourceSansBold
    minus_button.TextSize = 18
    minus_button.TextColor3 = Color3.new(1,1,1)
    minus_button.BackgroundColor3 = Color3.new(0.3, 0.3, 0.3)
    minus_button.Parent = button_frame
    
    local plus_button = Instance.new("TextButton")
    plus_button.Size = UDim2.new(0.3, 0, 1, 0)
    plus_button.Position = UDim2.new(0.7, 0, 0, 0)
    plus_button.Text = "+5"
    plus_button.Font = Enum.Font.SourceSansBold
    plus_button.TextSize = 18
    plus_button.TextColor3 = Color3.new(1,1,1)
    plus_button.BackgroundColor3 = Color3.new(0.3, 0.3, 0.3)
    plus_button.Parent = button_frame
    
    minus_button.MouseButton1Click:Connect(function()
        esp_settings.aimbot_fov = math.max(0, esp_settings.aimbot_fov - 5)
        fov_label.Text = "FOV: " .. tostring(esp_settings.aimbot_fov)
    end)
    
    plus_button.MouseButton1Click:Connect(function()
        esp_settings.aimbot_fov = math.min(1000, esp_settings.aimbot_fov + 5)
        fov_label.Text = "FOV: " .. tostring(esp_settings.aimbot_fov)
    end)
end

-- Visuals Heading
create_label("Visuals", 10)
create_toggle("ESP Enabled", "enabled", esp_settings.enabled, 55)
create_toggle("Box ESP", "box", esp_settings.box, 100)
create_toggle("Corner Box", "corner_box", esp_settings.corner_box, 145)
create_toggle("3D Box", "_3d_box", esp_settings._3d_box, 190)
create_toggle("Skeleton", "skeleton", esp_settings.skeleton, 235)
create_toggle("Circle Head", "circle_head", esp_settings.circle_head, 280)
create_toggle("Name ESP", "name", esp_settings.name, 325)
create_toggle("Health ESP", "health", esp_settings.health, 370)
create_toggle("Tracer ESP", "tracer", esp_settings.tracer, 415)
create_toggle("Distance ESP", "distance", esp_settings.distance, 460)
create_toggle("Rainbow Mode", "rainbow_mode", esp_settings.rainbow_mode, 505)

-- Visuals Filters Heading
create_label("Filters", 550)
create_toggle("Team Check", "team_check", esp_settings.team_check, 595)

-- Aimbot Heading
create_label("Aimbot", 640)
create_toggle("Aimbot Enabled", "aimbot_enabled", esp_settings.aimbot_enabled, 685)
create_fov_control(730)


---------------------------------------------------------------------------------
--                                  ESP LOGIC                                  --
---------------------------------------------------------------------------------

local Drawing = Drawing

local visuals_frame = Instance.new("Frame")
visuals_frame.Name = "ESPVisuals"
visuals_frame.Size = UDim2.new(1, 0, 1, 0)
visuals_frame.BackgroundTransparency = 1
visuals_frame.Parent = ScreenGui
visuals_frame.ZIndex = 100

local esp_drawings = {}

-- Helper Functions
local function is_teammate(player)
    return player.Team and LocalPlayer.Team and player.Team == LocalPlayer.Team
end

local function is_visible(target_part)
    local ray_params = RaycastParams.new()
    ray_params.FilterDescendantsInstances = {LocalPlayer.Character}
    ray_params.FilterType = Enum.RaycastFilterType.Exclude
    local ray_result = workspace:Raycast(camera.CFrame.Position, (target_part.Position - camera.CFrame.Position).unit * 500, ray_params)
    return ray_result and ray_result.Instance.Parent == target_part.Parent
end

local function create_line(pos1, pos2, color, thickness, parent)
    local line = Drawing.new("Line")
    line.Color = color
    line.Thickness = thickness
    line.From = pos1
    line.To = pos2
    line.Visible = true
    table.insert(parent, line)
end

local function create_circle(pos, radius, color, thickness, fill, parent)
    local circle = Drawing.new("Circle")
    circle.Position = pos
    circle.Radius = radius
    circle.Color = color
    circle.Thickness = thickness
    circle.Filled = fill
    circle.Visible = true
    table.insert(parent, circle)
end

local function create_text(pos, text, size, color, parent)
    local text_draw = Drawing.new("Text")
    text_draw.Position = pos
    text_draw.Text = text
    text_draw.Size = size
    text_draw.Color = color
    text_draw.Outline = true
    text_draw.OutlineColor = Color3.new(0, 0, 0)
    text_draw.Visible = true
    table.insert(parent, text_draw)
end

local function clear_drawings()
    for _, drawing in ipairs(esp_drawings) do
        drawing:Remove()
    end
    esp_drawings = {}
end

local function draw_player_esp(player)
    local character = player.Character
    local humanoid = character:FindFirstChild("Humanoid")
    local humanoid_root_part = character:FindFirstChild("HumanoidRootPart")

    if not character or not humanoid or humanoid.Health <= 0 or not humanoid_root_part then
        return
    end

    local head_pos, head_on_screen = camera:WorldToViewportPoint(character.Head.Position)
    local root_pos, root_on_screen = camera:WorldToViewportPoint(humanoid_root_part.Position)
    local is_visible_check = is_visible(humanoid_root_part)
    local esp_color = Color3.new(1, 0, 0) -- Default Red for Enemy
    local tracer_color = esp_color
    
    if esp_settings.team_check and is_teammate(player) then
        return
    end

    if esp_settings.rainbow_mode then
        esp_color = Color3.fromHSV(tick() % 1, 1, 1)
    else
        if is_teammate(player) then
            esp_color = Color3.new(0, 0, 1) -- Blue for Teammate
        elseif is_visible_check then
            esp_color = Color3.new(0, 1, 0) -- Green for Visible Enemy
        end
    end
    tracer_color = esp_color
    
    if not head_on_screen and not root_on_screen then
        return
    end

    local head_vector = Vector2.new(head_pos.X, head_pos.Y)
    local root_vector = Vector2.new(root_pos.X, root_pos.Y)
    local dist_from_cam = (LocalPlayer.Character.Head.Position - character.Head.Position).Magnitude
    
    -- Visuals Proportional to Character
    local character_screen_height = math.abs(head_vector.Y - root_vector.Y)
    local box_height = math.max(60, character_screen_height)
    local box_width = box_height * 0.6
    
    -- Health, Name, and Distance
    if esp_settings.health then
        local health_percent = humanoid.Health / humanoid.MaxHealth
        local health_color = Color3.fromHSV(0.35 * health_percent, 1, 1)
        create_line(Vector2.new(root_vector.X - box_width / 2 - 5, root_vector.Y), Vector2.new(root_vector.X - box_width / 2 - 5, root_vector.Y + (head_vector.Y - root_vector.Y) * health_percent), health_color, 4, esp_drawings)
    end
    
    if esp_settings.name then
        create_text(Vector2.new(head_vector.X, head_vector.Y - 15), player.Name, 12, Color3.new(1,1,1), esp_drawings)
    end
    
    if esp_settings.distance then
        create_text(Vector2.new(root_vector.X, root_vector.Y + 10), math.floor(dist_from_cam) .. "m", 12, Color3.new(1,1,1), esp_drawings)
    end

    -- Visuals
    if esp_settings.box or esp_settings.corner_box then
        local box_x1 = root_vector.X - box_width / 2
        local box_y1 = head_vector.Y
        local box_x2 = root_vector.X + box_width / 2
        local box_y2 = root_vector.Y

        if esp_settings.box then
            create_line(Vector2.new(box_x1, box_y1), Vector2.new(box_x2, box_y1), esp_color, 1.5, esp_drawings) -- Top
            create_line(Vector2.new(box_x1, box_y2), Vector2.new(box_x2, box_y2), esp_color, 1.5, esp_drawings) -- Bottom
            create_line(Vector2.new(box_x1, box_y1), Vector2.new(box_x1, box_y2), esp_color, 1.5, esp_drawings) -- Left
            create_line(Vector2.new(box_x2, box_y1), Vector2.new(box_x2, box_y2), esp_color, 1.5, esp_drawings) -- Right
        elseif esp_settings.corner_box then
            local corner_size = box_width * 0.2
            -- Top Left
            create_line(Vector2.new(box_x1, box_y1), Vector2.new(box_x1, box_y1 + corner_size), esp_color, 1.5, esp_drawings)
            create_line(Vector2.new(box_x1, box_y1), Vector2.new(box_x1 + corner_size, box_y1), esp_color, 1.5, esp_drawings)
            -- Top Right
            create_line(Vector2.new(box_x2, box_y1), Vector2.new(box_x2, box_y1 + corner_size), esp_color, 1.5, esp_drawings)
            create_line(Vector2.new(box_x2, box_y1), Vector2.new(box_x2 - corner_size, box_y1), esp_color, 1.5, esp_drawings)
            -- Bottom Left
            create_line(Vector2.new(box_x1, box_y2), Vector2.new(box_x1, box_y2 - corner_size), esp_color, 1.5, esp_drawings)
            create_line(Vector2.new(box_x1, box_y2), Vector2.new(box_x1 + corner_size, box_y2), esp_color, 1.5, esp_drawings)
            -- Bottom Right
            create_line(Vector2.new(box_x2, box_y2), Vector2.new(box_x2, box_y2 - corner_size), esp_color, 1.5, esp_drawings)
            create_line(Vector2.new(box_x2, box_y2), Vector2.new(box_x2 - corner_size, box_y2), esp_color, 1.5, esp_drawings)
        end
    end

    if esp_settings._3d_box then
        local CFrame = humanoid_root_part.CFrame
        local size = humanoid_root_part.Size
        
        local x = size.X / 2
        local y = size.Y / 2
        local z = size.Z / 2
        
        local corners = {
            CFrame * CFrame.new(x, y, z).p,
            CFrame * CFrame.new(x, y, -z).p,
            CFrame * CFrame.new(x, -y, z).p,
            CFrame * CFrame.new(x, -y, -z).p,
            CFrame * CFrame.new(-x, y, z).p,
            CFrame * CFrame.new(-x, y, -z).p,
            CFrame * CFrame.new(-x, -y, z).p,
            CFrame * CFrame.new(-x, -y, -z).p,
        }
        
        local function draw_line_between_corners(a, b)
            local pos1, on_screen1 = camera:WorldToViewportPoint(corners[a])
            local pos2, on_screen2 = camera:WorldToViewportPoint(corners[b])
            if on_screen1 and on_screen2 then
                create_line(Vector2.new(pos1.X, pos1.Y), Vector2.new(pos2.X, pos2.Y), esp_color, 1.5, esp_drawings)
            end
        end

        draw_line_between_corners(1,2)
        draw_line_between_corners(1,3)
        draw_line_between_corners(1,5)
        draw_line_between_corners(2,4)
        draw_line_between_corners(2,6)
        draw_line_between_corners(3,4)
        draw_line_between_corners(3,7)
        draw_line_between_corners(4,8)
        draw_line_between_corners(5,6)
        draw_line_between_corners(5,7)
        draw_line_between_corners(6,8)
        draw_line_between_corners(7,8)
    end
    
    if esp_settings.skeleton then
        local parts = {
            Head = character:FindFirstChild("Head"),
            Torso = character:FindFirstChild("Torso"),
            HumanoidRootPart = humanoid_root_part,
            
            UpperTorso = character:FindFirstChild("UpperTorso"),
            LowerTorso = character:FindFirstChild("LowerTorso"),
            
            LeftUpperArm = character:FindFirstChild("LeftUpperArm"),
            LeftLowerArm = character:FindFirstChild("LeftLowerArm"),
            LeftHand = character:FindFirstChild("LeftHand"),
            RightUpperArm = character:FindFirstChild("RightUpperArm"),
            RightLowerArm = character:FindFirstChild("RightLowerArm"),
            RightHand = character:FindFirstChild("RightHand"),
            
            LeftUpperLeg = character:FindFirstChild("LeftUpperLeg"),
            LeftLowerLeg = character:FindFirstChild("LeftLowerLeg"),
            LeftFoot = character:FindFirstChild("LeftFoot"),
            RightUpperLeg = character:FindFirstChild("RightUpperLeg"),
            RightLowerLeg = character:FindFirstChild("RightLowerLeg"),
            RightFoot = character:FindFirstChild("RightFoot")
        }
        
        local function draw_bone(p1_name, p2_name)
            local p1 = parts[p1_name]
            local p2 = parts[p2_name]
            if p1 and p2 then
                local pos1, on_screen1 = camera:WorldToViewportPoint(p1.Position)
                local pos2, on_screen2 = camera:WorldToViewportPoint(p2.Position)
                if on_screen1 and on_screen2 then
                    create_line(Vector2.new(pos1.X, pos1.Y), Vector2.new(pos2.X, pos2.Y), esp_color, 1.5, esp_drawings)
                end
            end
        end
        
        -- R6 SKELETON
        if parts.Torso then
            draw_bone("Head", "Torso")
            draw_bone("Torso", "LeftArm")
            draw_bone("Torso", "RightArm")
            draw_bone("Torso", "LeftLeg")
            draw_bone("Torso", "RightLeg")
            draw_bone("LeftArm", "LeftHand")
            draw_bone("RightArm", "RightHand")
            draw_bone("LeftLeg", "LeftFoot")
            draw_bone("RightLeg", "RightFoot")
        end
        
        -- R15 SKELETON
        if parts.UpperTorso then
            draw_bone("Head", "UpperTorso")
            draw_bone("UpperTorso", "LowerTorso")
            draw_bone("UpperTorso", "LeftUpperArm")
            draw_bone("LeftUpperArm", "LeftLowerArm")
            draw_bone("LeftLowerArm", "LeftHand")
            draw_bone("UpperTorso", "RightUpperArm")
            draw_bone("RightUpperArm", "RightLowerArm")
            draw_bone("RightLowerArm", "RightHand")
            draw_bone("LowerTorso", "LeftUpperLeg")
            draw_bone("LeftUpperLeg", "LeftLowerLeg")
            draw_bone("LeftLowerLeg", "LeftFoot")
            draw_bone("LowerTorso", "RightUpperLeg")
            draw_bone("RightUpperLeg", "RightLowerLeg")
            draw_bone("RightLowerLeg", "RightFoot")
        end
    end

    if esp_settings.circle_head then
        local head_pos = character:FindFirstChild("Head")
        if head_pos then
            local pos, on_screen = camera:WorldToViewportPoint(head_pos.Position)
            if on_screen then
                create_circle(Vector2.new(pos.X, pos.Y), 10, esp_color, 1.5, false, esp_drawings)
            end
        end
    end

    if esp_settings.tracer then
        create_line(Vector2.new(camera.ViewportSize.X/2, camera.ViewportSize.Y), root_vector, tracer_color, 1.5, esp_drawings)
    end
end

local function main_loop()
    clear_drawings()
    
    local best_target = nil
    local smallest_fov = esp_settings.aimbot_fov
    local screen_center = Vector2.new(camera.ViewportSize.X/2, camera.ViewportSize.Y/2)
    
    -- Aimbot Logic
    if esp_settings.aimbot_enabled then
        for _, player in ipairs(Players:GetPlayers()) do
            local character = player.Character
            if player ~= LocalPlayer and character and character:FindFirstChild("Humanoid") and character:FindFirstChild("Head") then
                local humanoid = character.Humanoid
                local head_pos = character.Head
                if humanoid and humanoid.Health > 0 and not (esp_settings.team_check and is_teammate(player)) then
                    local head_on_screen, head_in_viewport = camera:WorldToViewportPoint(head_pos.Position)
                    if head_in_viewport then
                        local fov_dist = (Vector2.new(head_on_screen.X, head_on_screen.Y) - screen_center).Magnitude
                        if fov_dist < smallest_fov then
                            if is_visible(head_pos) then
                                smallest_fov = fov_dist
                                best_target = head_pos
                            end
                        end
                    end
                end
            end
        end
        
        if best_target then
            camera.CFrame = CFrame.new(camera.CFrame.Position, best_target.Position)
        end
    end
    
    -- ESP Logic
    if esp_settings.enabled then
        for _, player in ipairs(Players:GetPlayers()) do
            if player ~= LocalPlayer and player.Character then