-- instancing

local drawing_new = Drawing.new

local instance_new = Instance.new

-- workspace
local vector2_new = Vector2.new
local vector3_new = Vector3.new
local cframe_new = CFrame.new
local cframe_angles = CFrame.Angles
local raycast_params_new = RaycastParams.new
local raycast = workspace.Raycast

-- color
local color3_rgb = Color3.fromRGB
local color3_hsv = Color3.fromHSV
local color3_new = Color3.new

-- math
local math_floor = math.floor
local math_ceil = math.ceil
local math_atan2 = math.atan2
local math_rad = math.rad
local math_random = math.random
local math_randomseed = math.randomseed

-- string
local string_char = string.char
local string_format = string.format

-- table
local table_sort = table.sort

-- task
local task_wait = task.wait

-- namecall
local gdbd = game.GetDebugId
local get_children = game.GetChildren
local get_descendants = game.GetDescendants
local find_first_child_of_class = game.FindFirstChildOfClass
local find_first_child = game.FindFirstChild
local is_descendant_of = game.IsDescendantOf
local world_to_view_point = find_first_child_of_class(workspace,
"Camera").WorldToViewportPoint
local point_world_space = cframe_new().pointToWorldSpace
local point_object_space = cframe_new().pointToObjectSpace
local vector_world_space = cframe_new().vectorToWorldSpace
local is_a = game.IsA

-- globals
local workspace = workspace
local pairs = pairs
local pcall = pcall
local tostring = tostring
local tick = tick
local getgenv = getgenv
local mousemoverel = mousemoverel
local mouse1press = mouse1press
local mouse1release = mouse1release
-- random
math_randomseed(tick())
function random_string(len)
local str = ""
for i = 1, len do
str = str .. string_char(math_random(97, 122))
end
return str
end

getgenv().render_loop_stepped_name = renderloop_stepped_name or
random_string(math_random(15, 35))
getgenv().update_loop_stepped_name = update_loop_stepped_name or
random_string(math_random(15, 35))

-- services
local players = game:GetService("Players")
local run_service = game:GetService("RunService")
local uis = game:GetService("UserInputService")

-- other
local local_player = players.LocalPlayer
local mouse = local_player:GetMouse()

local cam = find_first_child_of_class(workspace, "Camera")

local screen_size = cam.ViewportSize

local center_screen = vector2_new(screen_size.X / 2, screen_size.Y / 2)

local enum_rft_blk = Enum.RaycastFilterType.Blacklist

local glass = Enum.Material.Glass

local white = color3_rgb(255, 255, 255)

local green = color3_rgb(0, 255, 0)

local dummy_part = instance_new("Part", nil)

drawing_new("Square").Visible = false -- initialize drawing lib

local pi = math.pi

-- dont touch lol

local custom_players = true
local refresh_que = false
local start_aim = false
local aim_head = false
local added_fov = 0

-- execute to apply
local options = {
-- global settings
frame_delay = 10, -- delay between rendering each frame (in miliseconds)
refresh_delay = 0.25, -- delay between refreshing script (in seconds)
max_dist = 9e9, -- 9e9 = very big
team_check = true,
wall_check = true,

loop_all_humanoids = false, -- loop through workspace to find npc's to lock

onto
ignore_player_humanoids = true, -- will not lock onto/esp players (only if
loop_all_humanoids is enabled)

-- ui settings (sort of ui)

fov_circle = true,
aiming_at = true,

-- aimbot settings
aimbot = true,
smoothness = 3,
fov = 200,
fov_increase_on_aim = 0, -- increases your fov by this value while the aimbot
is active
rage_mode = false, -- disregards fov, smoothness, odds and will lock onto
people behind you

-- aim type settings

mouse_emulation = true, -- the default, will emulate user input (and is more
natural)
camera_cframe = false, -- aimlock, easier to detect, does not obey the
smoothness setting but locks instantly

-- will not lock on to people with this *username*, do not use a displayname
for this, use the username
ignore_people = {
["name"] = true, -- example of how you would exclude someone
},

-- will try to prefire when aiming

triggerbot = false,

-- aimbot activation settings

acts_as_toggle = false,

-- https://developer.roblox.com/en-us/api-reference/enum/UserInputType
mouse_key = Enum.UserInputType["MouseButton2"],
-- how to disable: mouse_key = nil,
-- how to enable: mouse_key = Enum.UserInputType["*"],

-- https://developer.roblox.com/en-us/api-reference/enum/KeyCode
keyboard_key = Enum.KeyCode["E"],
-- how to disable: keyboard_key = nil,
-- how to enable: keyboard_key = Enum.KeyCode["*"],

-- headshot odds
headshot_chance = 100, -- odds for aiming on the head in percentage, 0 = no
head (lol) and 100 = always head
update_on_refresh_delay = false, -- less nauseating, will recalculate odds
every refresh instead of every frame

-- aiming prioritization options

looking_at_you = false, -- whoever is most likely to hit you
closest_to_center_screen = true,
closest_to_you = false,

-- taxing, usually useless, will iterate backwards through players list if the
"best player to lock onto" cant be locked onto
backwards_iteration = false,
 -- global esp settings
esp = true,
esp_thickness = 2,

-- esp settings
tracers = true,
box = true,

-- overhead esp settings

overhead = true, -- disables name health and distance entirely
name = true,
distance = true,
health = true,
outline = true, -- text outline, laggier

-- rainbow settings
rainbow = false,
rainbow_speed = 5, -- lower is faster, 0.000001 is the lowest you can go

-- looking_at_tracer settings (lat = looking_at_tracer in short)

looking_at_tracer = true, -- will show where a player is looking

--https://www.google.com/search?q=color+picker
lat_color = color3_rgb(200, 0, 255), -- color in rgb
lat_thickness = 2,
lat_length = 3, -- how far the tracer will go (in studs)

-- crosshair settings
crosshair = false,

crosshair_distance = 4,
crosshair_thickness = 1,
crosshair_length = 8;
}

-- script already running?

if remove_all_esp then
run_service:UnbindFromRenderStep(render_loop_stepped_name)
run_service:UnbindFromRenderStep(update_loop_stepped_name)

task_wait() -- wait for a frame to pass

remove_all_esp()

if descendant_hum_added then
descendant_hum_added:Disconnect()
descendant_hum_removing:Disconnect()
player_name_added:Disconnect()
player_name_removed:Disconnect()
end

player_added:Disconnect()
player_removed:Disconnect()

input_began:Disconnect()
input_ended:Disconnect()

getgenv().remove_all_esp = nil
 return;
end

-- how the script will find the players

local characters = {}
local player_names = {}

local function get_players()

local place = game.PlaceId

if options.loop_all_humanoids then
if not player_names[local_player.Name] then -- ran for the first time
-- get player names
for _, val in pairs(get_children(players)) do
player_names[val.Name] = true
end

getgenv().player_name_added =
players.ChildAdded:Connect(function(added)
player_names[added.Name] = true
end)

getgenv().player_name_removed =
players.ChildRemoved:Connect(function(added)
player_names[added.Name] = nil
end)

-- get players with events

for _, val in pairs(workspace:GetDescendants()) do
if is_a(val, "Humanoid") and val.Parent ~= local_player.Character
and not (options.ignore_player_humanoids and player_names[val.Parent.Name]) then
characters[gdbd(val.Parent)] = val.Parent
end
end

getgenv().descendant_hum_added =
workspace.DescendantAdded:Connect(function(added)
if is_a(added, "Humanoid") and added.Parent ~=
local_player.Character and not (options.ignore_player_humanoids and
player_names[added.Parent.Name]) then
characters[gdbd(added.Parent)] = added.Parent
end
end)

getgenv().descendant_hum_removing =
workspace.DescendantRemoving:Connect(function(removing)
if is_a(removing, "Humanoid") then
characters[gdbd(removing.Parent)] = nil
end
end)
end

return characters
end

if place == 292439477 then -- phantom forces

local leaderboard = local_player.PlayerGui.Leaderboard.Main
 if leaderboard then
if options.team_check then
local is_ghost = pcall(function()
return leaderboard.Ghosts.DataFrame.Data[local_player.Name]
end)

return get_children(workspace.Players[(is_ghost and "Bright blue")

or "Bright orange"])
else
local instance_table = {}

for idx, val in pairs(get_children(workspace.Players["Bright

blue"])) do
if is_a(val, "Model") then
instance_table[#instance_table + 1] = val
end
end

for idx, val in pairs(get_children(workspace.Players["Bright

orange"])) do
if is_a(val, "Model") then
instance_table[#instance_table + 1] = val
end
end

return instance_table -- return both teams

end
end

return {} -- wtf???
end

if place == 3837841034 then

return get_children(workspace.characters)
end

if place == 5938036553 then

local chars = {}

for _, val in pairs(get_children(workspace)) do

if val.Name == "r15_rig" then
chars[#chars + 1] = val
end
end

return chars
end

custom_players = false
return get_children(players)
end

local aiming = {
fov_circle_obj = nil,
line = nil,
circle = nil;
}

local crosshair = {
 top = nil,
bottom = nil,
right = nil,
left = nil;
}

local players_table = {}
local tracers = {}
local quads = {}
local overheads = {}
local looking_at_tracers = {}

-- needed functions
local function to_screen(vec3)
local screen_pos, in_screen = world_to_view_point(cam, vec3)

return vector2_new(screen_pos.X, screen_pos.Y), in_screen, screen_pos,

options.rage_mode
end

local function get_part_corners(part)

local size = part.Size * vector3_new(1, 1.5, 0)

local cf = part.CFrame

return {
top_right = (cf * cframe_new(-size.X, -size.Y, 0)).Position,
bottom_right = (cf * cframe_new(-size.X, size.Y, 0)).Position,
top_left = (cf * cframe_new(size.X, -size.Y, 0)).Position,
bottom_left = (cf * cframe_new(size.X, size.Y, 0)).Position,
}
end

local function new_drawing(class_name)

return function(props)
local inst = drawing_new(class_name)

for idx, val in pairs(props) do

if idx ~= "instance" then
inst[idx] = val
end
end

return inst
end
end

local function add_or_update_instance(tbl, child, props)

local inst = tbl[child]
if not inst then
tbl[child] = new_drawing(props.instance)(props)

return inst;
end

for idx, val in pairs(props) do

if idx ~= "instance" then
inst[idx] = val
end
 end

return inst
end

local function get_rainbow()

return color3_hsv((tick() % options.rainbow_speed / options.rainbow_speed), 1,
1)
end

local function remove_esp(idx)

add_or_update_instance(tracers, idx, {
Visible = false,
instance = "Line"
})

add_or_update_instance(quads, idx, {
Visible = false,
instance = "Quad"
})

add_or_update_instance(overheads, idx, {
Visible = false,
instance = "Text"
})

add_or_update_instance(looking_at_tracers, idx, {
Visible = false,
instance = "Line"
})
end

local ignored_instances = {}

local raycast_params = raycast_params_new()

raycast_params.FilterType = enum_rft_blk
raycast_params.IgnoreWater = true

local function can_hit(origin_pos, part)

if not options.wall_check then
return true
end

local ignore_list = {cam, local_player.Character}

for idx, val in pairs(ignored_instances) do

ignore_list[#ignore_list + 1] = val
end

raycast_params.FilterDescendantsInstances = ignore_list

local raycast_result = raycast(workspace, origin_pos, (part.Position -

origin_pos).Unit * options.max_dist, raycast_params)

local result_part = ((raycast_result and raycast_result.Instance) or

dummy_part)

if result_part ~= dummy_part then

if result_part.Transparency >= 0.3 then -- ignore low transparency
 ignored_instances[#ignored_instances + 1] = result_part
end

if result_part.Material == glass then -- ignore glass

ignored_instances[#ignored_instances + 1] = result_part
end
end

return is_descendant_of(result_part, part.Parent)

end

local function hitting_what(origin_cframe)

if not options.wall_check then
return dummy_part
end

local ignore_list = {cam, local_player.Character}

for idx, val in pairs(ignored_instances) do

ignore_list[#ignore_list + 1] = val
end

raycast_params.FilterDescendantsInstances = ignore_list

local raycast_result = raycast(workspace, origin_cframe.p,

origin_cframe.LookVector * options.max_dist, raycast_params)

local result_part = ((raycast_result and raycast_result.Instance) or

dummy_part)

if result_part ~= dummy_part then

if result_part.Transparency >= 0.3 then -- ignore low transparency
ignored_instances[#ignored_instances + 1] = result_part
end

if result_part.Material == glass then -- ignore glass

ignored_instances[#ignored_instances + 1] = result_part
end
end

return result_part
end

local function is_inside_fov(point)

return options.rage_mode or ((point.x - center_screen.X) ^ 2 + (point.y -
center_screen.Y) ^ 2 <= aiming.fov_circle_obj.Radius ^ 2)
end

local function chanced() -- shanced 2 - 0 gf *tabs*

return options.rage_mode or math_random(1, 100) <= options.headshot_chance
end

local function screen_height(yval)

if yval > (screen_size.Y / 2) then
return -0.5
end

return 0.5
end
local function _refresh()
for idx in pairs(tracers) do -- hide all esp instances
remove_esp(idx)
end

players_table = get_players() -- fetch new player list

end

local function refresh()

refresh_que = true -- queue refresh before next render
end

-- player events
getgenv().player_added = players.ChildAdded:Connect(refresh)
getgenv().player_removed = players.ChildRemoved:Connect(refresh)

-- aimbot triggers
getgenv().input_began = uis.InputBegan:Connect(function(input)
if input.KeyCode == options.keyboard_key then
if options.acts_as_toggle then
start_aim = not start_aim
else
start_aim = true
end

if options.fov_increase_on_aim > 0 then

for i = 1, options.fov_increase_on_aim * 0.3 do
added_fov = added_fov + 3
task_wait()
end

added_fov = options.fov_increase_on_aim
end
end

if input.UserInputType == options.mouse_key then

if options.acts_as_toggle then
start_aim = not start_aim
else
start_aim = true
end

if options.fov_increase_on_aim > 0 then

for i = 1, options.fov_increase_on_aim * 0.3 do
added_fov = added_fov + 3
task_wait()
end

added_fov = options.fov_increase_on_aim
end
end
end)

getgenv().input_ended = uis.InputEnded:Connect(function(input)
if input.KeyCode == options.keyboard_key then
if not options.acts_as_toggle then
start_aim = false
end
 if options.fov_increase_on_aim > 0 then
for i = 1, options.fov_increase_on_aim * 0.3 do
added_fov = added_fov - 3

task_wait()
end

added_fov = 0
end
end

if input.UserInputType == options.mouse_key then

if not options.acts_as_toggle then
start_aim = false
end

if options.fov_increase_on_aim > 0 then

for i = 1, options.fov_increase_on_aim * 0.3 do
added_fov = added_fov - 3

task_wait()
end

added_fov = 0
end
end
end)

local last_tick = 0;

local function stepped()

if (tick() - last_tick) > (options.frame_delay / 1000) then
last_tick = tick()

if refresh_que then -- refresh queed?

_refresh()

refresh_que = false
end

add_or_update_instance(aiming, "fov_circle_obj", {
Visible = options.fov_circle,
Thickness = options.esp_thickness,
Radius = options.fov + added_fov,
Position = center_screen,
Color = (options.rainbow and get_rainbow()) or white,
instance = "Circle";
})

add_or_update_instance(crosshair, "top", {
Visible = options.crosshair,
Thickness = options.crosshair_thickness,
From = vector2_new(center_screen.X, center_screen.Y -
options.crosshair_length - options.crosshair_distance),
To = vector2_new(center_screen.X, center_screen.Y -
options.crosshair_distance),
Color = (options.rainbow and get_rainbow()) or white,
instance = "Line";
 })

add_or_update_instance(crosshair, "bottom", {
Visible = options.crosshair,
Thickness = options.crosshair_thickness,
From = vector2_new(center_screen.X, center_screen.Y +
options.crosshair_length + options.crosshair_distance + 1),
To = vector2_new(center_screen.X, center_screen.Y +
options.crosshair_distance + 1),
Color = (options.rainbow and get_rainbow()) or white,
instance = "Line";
})

add_or_update_instance(crosshair, "left", {
Visible = options.crosshair,
Thickness = options.crosshair_thickness,
From = vector2_new(center_screen.X - options.crosshair_length -
options.crosshair_distance, center_screen.Y),
To = vector2_new(center_screen.X - options.crosshair_distance,
center_screen.Y),
Color = (options.rainbow and get_rainbow()) or white,
instance = "Line";
})

add_or_update_instance(crosshair, "right", {
Visible = options.crosshair,
Thickness = options.crosshair_thickness,
From = vector2_new(center_screen.X + options.crosshair_length +
options.crosshair_distance + 1, center_screen.Y),
To = vector2_new(center_screen.X + options.crosshair_distance + 1,
center_screen.Y),
Color = (options.rainbow and get_rainbow()) or white,
instance = "Line";
})

local closers_chars = {}

for _, plr in pairs(players_table) do

local id = gdbd(plr)

if plr == local_player then continue; end

if options.ignore_people[plr.Name] then continue; end

if options.team_check and not options.loop_all_humanoids and not

custom_players and plr.Team then
if plr.TeamColor == local_player.TeamColor then remove_esp(id);
continue; end
if plr.Team == local_player.Team then remove_esp(id); continue; end
end

local plr_char = ((options.loop_all_humanoids or custom_players) and

plr) or plr.Character
if plr_char == nil then remove_esp(id); continue; end

local root_part =
find_first_child(plr_char, "Torso")
or find_first_child(plr_char, "UpperTorso")
or find_first_child(plr_char, "LowerTorso")
 or find_first_child(plr_char, "HumanoidRootPart")
or find_first_child(plr_char, "Head")
or find_first_child_of_class(plr_char, "BasePart")

if root_part == nil then remove_esp(id); continue; end

if not is_a(root_part, "BasePart") then remove_esp(id); continue; end

local head = find_first_child(plr_char, "Head") or root_part

if not is_a(head, "BasePart") then continue; end

local plr_screen, visible, scr_z = to_screen(head.Position)

local mag = (head.Position - cam.CFrame.Position).Magnitude

if mag > options.max_dist then remove_esp(id); continue; end

if options.esp then
local col = (options.rainbow and get_rainbow()) or white
local corners = get_part_corners(root_part)

local a_screen, a_visible = to_screen(corners.top_left)

local b_screen, b_visible = to_screen(corners.top_right)
local c_screen, c_visible = to_screen(corners.bottom_right)
local d_screen, d_visible = to_screen(corners.bottom_left)

if options.tracers then -- doesnt have a hide condition

local object_space_pos = point_object_space(cam.CFrame,
vector3_new(
(corners.top_left.X + corners.top_right.X) / 2,
(corners.top_left.Y + corners.top_right.Y) / 2,
(corners.top_left.Z + corners.top_right.Z) / 2
))

if 0 > scr_z.Z then -- thanks unnamed esp for the

math
local angle = math_atan2(object_space_pos.Y,
object_space_pos.X) + pi
object_space_pos = vector_world_space(cframe_angles(0, 0,
angle), (cframe_angles(0, math_rad(89.99), 0).LookVector))
end

local tracer_pos =
to_screen(point_world_space(cam.CFrame, object_space_pos))

add_or_update_instance(tracers, id, {
Visible = options.esp,
Thickness = options.esp_thickness,
From = vector2_new(screen_size.X / 2, screen_size.Y - 36),
To = tracer_pos,
Color = (options.rainbow and get_rainbow()) or
color3_new(255 / mag, mag / 255, 0),
instance = "Line";
})
end

if options.box then
if a_visible and b_visible and c_visible and d_visible then
add_or_update_instance(quads, id, {
Visible = options.esp,
Thickness = options.esp_thickness,
 PointA = a_screen,
PointB = b_screen,
PointC = c_screen,
PointD = d_screen,
Color = col,
instance = "Quad";
})
else
add_or_update_instance(quads, id, {
Visible = false,
instance = "Quad";
})
end
end

if options.looking_at_tracer then
local a_head_src, a_visible = to_screen(head.Position)
local b_lv_src, b_visible = to_screen(head.Position +
head.CFrame.LookVector * options.lat_length)

if a_visible and b_visible then

add_or_update_instance(looking_at_tracers, id, {
Visible = options.esp,
Thickness = options.lat_thickness,
To = a_head_src,
From = b_lv_src,
Color = options.lat_color or white,
instance = "Line";
})
else
add_or_update_instance(looking_at_tracers, id, {
Visible = false,
instance = "Line";
})
end
end

if options.overhead then
local text = "";

if options.health then
local hum = find_first_child_of_class(plr_char, "Humanoid")

if hum then
text = string_format("%s[%d/%d] ", text,
math_ceil(hum.Health), math_ceil(hum.MaxHealth))
end
end

if options.distance then
text = string_format("%s[%d]\n", text, math_floor(mag))
end

if options.name then
text = string_format("%s%s ", text, plr.Name)
end

local head_screen, h_visible = to_screen(head.Position +

head.CFrame.UpVector * 2)
 if h_visible then
local obj = overheads[id]

add_or_update_instance(overheads, id, {
Visible = options.esp,
Outline = options.outline,
Center = true,
Position = head_screen - vector2_new(0, (obj and
obj.TextBounds.Y) or 0),
Text = text,
Color = col,
instance = "Text";
})
else
add_or_update_instance(overheads, id, {
Visible = false,
instance = "Text";
})
end
end
end

if options.aimbot then
if options.looking_at_you then
closers_chars[((head.Position + head.CFrame.LookVector * mag) -
cam.CFrame.p).Magnitude] = plr_char
elseif options.closest_to_center_screen then
closers_chars[(plr_screen - center_screen).Magnitude] =
plr_char
elseif options.closest_to_you then
closers_chars[mag] = plr_char
end
end
end -- sort players, esp, teamcheck

if not options.aimbot then return; end

local mags = {}

for idx in pairs(closers_chars) do

mags[#mags + 1] = idx
end

table_sort(mags)

local idx_sorted = {}

for _, idx in pairs(mags) do

idx_sorted[#idx_sorted + 1] = closers_chars[idx]
end

local run_aimbot = nil;

run_aimbot = function(plr_offset)
local char = idx_sorted[plr_offset]

if char then
local children = get_children(char)
local parts = {}
 for _, obj in pairs(children) do
if is_a(obj, "BasePart") then
local part_screen, part_in_screen, _, rage =
to_screen(obj.Position)

if can_hit(cam.CFrame.p, obj) and (part_in_screen or rage)

and (is_inside_fov(part_screen) or rage) then
local set = {
part = obj,
screen = part_screen,
visible = part_in_screen;
}

parts[obj.Name] = set

parts[0] = set -- set last part

end
end
end

local chosen = nil;

if not options.update_on_refresh_delay then

aim_head = chanced()
end

if parts["Head"] and aim_head then

chosen = parts["Head"]
else
local torso = parts["Torso"] or parts["UpperTorso"] or
parts["LowerTorso"]
if torso then
chosen = torso
else
chosen = parts["Head"] or parts[0] -- aim on head if odds
are against the head, but the torso isnt visible, or on other visible part
end
end

if chosen then
local scale = (chosen.part.Size.Y / 2)

local top, top_z, top_visible = to_screen((chosen.part.CFrame *

cframe_new(0, scale, 0)).Position);
local bottom, bottom_z, bottom_visible =
to_screen((chosen.part.CFrame * cframe_new(0, -scale, 0)).Position);
local radius = -(top - bottom).y;

add_or_update_instance(aiming, "circle", {
Visible = top_visible and bottom_visible and
options.aiming_at,
Thickness = options.esp_thickness,
Radius = radius / 2,
Position = chosen.screen,
Color = (options.rainbow and get_rainbow()) or (start_aim
and green) or white,
instance = "Circle";
})
 if start_aim then
add_or_update_instance(aiming, "line", {
Visible = options.aiming_at,
Thickness = options.esp_thickness,
From = center_screen,
To = chosen.screen,
Color = (options.rainbow and get_rainbow()) or
(start_aim and green) or white,
instance = "Line";
})

local smoothness = (options.rage_mode and 1) or

options.smoothness

if chosen.visible then
if options.mouse_emulation then
mousemoverel((chosen.screen.X - mouse.X) /
smoothness, (chosen.screen.Y - (mouse.Y + 36)) / smoothness)
elseif options.camera_cframe then
cam.CFrame = cframe_new(cam.CFrame.p,
chosen.part.Position)
end
elseif options.rage_mode then
if options.mouse_emulation then
mousemoverel(screen_size.X / 4, (chosen.screen.Y -
(mouse.Y + 36)) * screen_height(mouse.Y))
elseif options.camera_cframe then
cam.CFrame = cframe_new(cam.CFrame.p,
chosen.part.Position)
end
end

if options.triggerbot then
if is_descendant_of(hitting_what(cam.CFrame),
chosen.part.Parent) then
mouse1press()
else
mouse1release()
end
end

return;
else
if options.triggerbot then
mouse1release()
end

add_or_update_instance(aiming, "line", {
Visible = false,
instance = "Line";
})

return;
end -- aiming?

return; -- part is on screen, and in fov, no need to find a new

player, loop ends here
end -- part exists?
 if options.triggerbot then
mouse1release()
end

add_or_update_instance(aiming, "line", {
Visible = false,
instance = "Line";
})

add_or_update_instance(aiming, "circle", {
Visible = false,
instance = "Circle";
})

if options.backwards_iteration then
run_aimbot(plr_offset + 1); -- previous player
end
end
end

run_aimbot(1);
end
end

local last_refresh = 0;

run_service:BindToRenderStep(render_loop_stepped_name, 300, function()

if (tick() - last_refresh) > options.refresh_delay then
last_refresh = tick()

if not cam or not cam.Parent or cam.Parent ~= workspace then

cam = find_first_child_of_class(workspace, "Camera")

world_to_view_point = cam.WorldToViewportPoint
end

if options.update_on_refresh_delay then
aim_head = chanced()
end

refresh()
end
end) -- refresher

run_service:BindToRenderStep(update_loop_stepped_name, 199, stepped)

-- kills esp
getgenv().remove_all_esp = function()
for idx in pairs(tracers) do -- hide all esp instances
remove_esp(idx)
end

-- aiming
add_or_update_instance(aiming, "fov_circle_obj", {
Visible = false,
instance = "Circle";
})
 add_or_update_instance(aiming, "circle", {
Visible = false,
instance = "Circle";
})

add_or_update_instance(aiming, "line", {
Visible = false,
instance = "Line";
})

-- crosshair
add_or_update_instance(crosshair, "top", {
Visible = false,
instance = "Line";
})

add_or_update_instance(crosshair, "bottom", {
Visible = false,
instance = "Line";
})

add_or_update_instance(crosshair, "left", {
Visible = false,
instance = "Line";
})

add_or_update_instance(crosshair, "right", {
Visible = false,
instance = "Line";
})
end