_DEBUG = true

local clipboard = require "neverlose/clipboard"

local pui = require "neverlose/pui"
local gradient = require("neverlose/gradient")
local http_lib = require("neverlose/http_lib")

local http = http_lib.new({

task_interval = 0.3, -- polling intervals
enable_debug = true, -- print http request s to the console
timeout = 10 -- request expiration time
})

local callbacks = {}

local build = "live"

local vel_warning
local watermark_icon

http:get("https://cdn.discordapp.com/attachments/
1022219770604572717/1137943561816518748/vel_warning_v2.png", function(data)
if not pcall(data:success() and data.status == 200 and data.body) then
vel_warning = render.load_image(data.body, vector(300,300))
else
print("couldn't download amnesia icon")
end
end)

http:get("https://cdn.discordapp.com/attachments/
1022219770604572717/1137951401566281788/watermark_final.png", function(data)
if not pcall(data:success() and data.status == 200 and data.body) then
watermark_icon = render.load_image(data.body, vector(300,300))
else
print("couldn't download amnesia icon")
end
end)

callbacks.register = function(event, name, fn)

events[event]:set(safecall(name, event ~= "shutdown", fn))
end

local aa={
pitch=ui.find("Aimbot","Anti Aim","Angles","Pitch"),
yaw=ui.find("Aimbot","Anti Aim","Angles","Yaw"),
base=ui.find("Aimbot","Anti Aim","Angles","Yaw","Base"),
offset=ui.find("Aimbot","Anti Aim","Angles","Yaw","Offset"),
backstab=ui.find("Aimbot","Anti Aim","Angles","Yaw","Avoid Backstab"),
jitter=ui.find("Aimbot","Anti Aim","Angles","Yaw Modifier"),
jitter_val=ui.find("Aimbot","Anti Aim","Angles","Yaw Modifier","Offset"),
body_yaw={ui.find("Aimbot","Anti Aim","Angles","Body Yaw"),
ui.find("Aimbot","Anti Aim","Angles","Body Yaw","Inverter"),
ui.find("Aimbot","Anti Aim","Angles","Body Yaw","Left Limit"),
ui.find("Aimbot","Anti Aim","Angles","Body Yaw","Right Limit"),
ui.find("Aimbot","Anti Aim","Angles","Body Yaw","Options"),
ui.find("Aimbot","Anti Aim","Angles","Body Yaw","Freestanding")},
freestand={ui.find("Aimbot","Anti Aim","Angles","Freestanding"),
ui.find("Aimbot","Anti Aim","Angles","Freestanding","Disable Yaw Modifiers"),
ui.find("Aimbot","Anti Aim","Angles","Freestanding","Body Freestanding")},
 def=ui.find("Aimbot","Ragebot","Main","Double Tap","Lag Options"),
slow=ui.find("Aimbot","Anti Aim","Misc","Slow Walk")
}

local references={
doubletap=ui.find("aimbot","ragebot","main","double tap"),
hideshots=ui.find("Aimbot","Ragebot","Main","Hide Shots"),
fakeduck=ui.find("Aimbot","Anti Aim","Misc","Fake Duck"),
delayshot=ui.find("Aimbot", "Ragebot", "Selection", "Global", "Min. Damage",
"Delay Shot"),
pitch=ui.find("Aimbot","Anti Aim","Angles","Pitch"),
offset=ui.find("Aimbot","Anti Aim","Angles","Yaw","Offset"),
yaw=ui.find("Aimbot","Anti Aim","Angles","Yaw"),
modifier=ui.find("Aimbot","Anti Aim","Angles","Yaw Modifier"),
moffset=ui.find("Aimbot","Anti Aim","Angles","Yaw Modifier","Offset"),
limit1=ui.find("Aimbot","Anti Aim","Angles","Body Yaw","Left Limit"),
limit2=ui.find("Aimbot","Anti Aim","Angles","Body Yaw","Right Limit"),
freestand=ui.find("Aimbot","Anti Aim","Angles","Freestanding"),
antistab=ui.find("Aimbot","Anti Aim","Angles","Yaw","Avoid Backstab"),
bodyyaw=ui.find("Aimbot","Anti Aim","Angles","Body Yaw"),
roll=ui.find("Aimbot","Anti Aim","Angles","Extended Angles"),
rollval=ui.find("Aimbot","Anti Aim","Angles","Extended Angles","Extended
Roll"),
airstrafe=ui.find("Miscellaneous","Main","Movement","Air Strafe"),
legmov=ui.find("Aimbot","Anti Aim","Misc","Leg Movement"),
slowwalk=ui.find("Aimbot","Anti Aim","Misc","Slow Walk"),
lagoptions=ui.find("Aimbot","Ragebot","Main","Double Tap","Lag Options"),
fakelag=ui.find("Aimbot","Anti Aim","Fake Lag","Limit"),
asoptions=ui.find("Aimbot","Ragebot","Accuracy","Auto Stop","Options"),
asdtoptions=ui.find("Aimbot","Ragebot","Accuracy","Auto Stop","Double Tap")
}

rad = math.rad
cos = math.cos
sin = math.sin

local target_pos = vector(0,0,0)

local cam1

function drawWireframeSphere(center, radius, segments, sphereColor, rotationAngle)

-- Loop through and draw horizontal lines
for i = 0, segments do
local latitude = (i / segments) * math.pi - (math.pi / 2)
local last_point = nil

for j = 0, segments do
local longitude = (j / segments) * 2 * math.pi
local x = radius * math.cos(latitude) * math.cos(longitude)
local y = radius * math.cos(latitude) * math.sin(longitude)
local z = radius * math.sin(latitude)

-- Apply rotation around the Y-axis

local newX = math.cos(rotationAngle) * x - math.sin(rotationAngle) * y
local newY = math.sin(rotationAngle) * x + math.cos(rotationAngle) * y

x, y = newX, newY

-- Translate to the center position

x = x + center.x
 y = y + center.y
z = z + center.z

local world_point = vector(x, y, z)

local screen_point = render.world_to_screen(world_point)

if last_point and screen_point then

render.line(last_point, screen_point, sphereColor)
end

last_point = screen_point
end
end

-- Loop through and draw vertical lines

for j = 0, segments do
local longitude = (j / segments) * 2 * math.pi
local last_point = nil

for i = 0, segments do
local latitude = (i / segments) * math.pi - (math.pi / 2)
local x = radius * math.cos(latitude) * math.cos(longitude)
local y = radius * math.cos(latitude) * math.sin(longitude)
local z = radius * math.sin(latitude)

-- Apply rotation around the Y-axis

local newX = math.cos(rotationAngle) * x - math.sin(rotationAngle) * y
local newY = math.sin(rotationAngle) * x + math.cos(rotationAngle) * y

x, y = newX, newY

-- Translate to the center position

x = x + center.x
y = y + center.y
z = z + center.z

local world_point = vector(x, y, z)

local screen_point = render.world_to_screen(world_point)

if last_point and screen_point then

render.line(last_point, screen_point, sphereColor)
end

last_point = screen_point
end
end
end

local get_coord = function()

local campos = render.camera_position()
local cam_angles = render.camera_angles()
local x = rad(cam_angles.y)
local y = rad(cam_angles.x)

local vx = cos(x) * cos(y)

local vy = sin(x) * cos(y)
local vz = sin(y)

local finish_pos = campos + 1500 *vector(vx, vy, -1*vz)

 local lp = entity.get_local_player()
local trace = utils.trace_line(campos, finish_pos)
local trace_end = trace.end_pos

return trace_end:clone()
end

math.difference = function (num1, num2)

return math.abs(num1 - num2)
end

math.color_lerp = function(start, end_pos, time)

local frametime = globals.frametime * 100
time = time * math.min(frametime, math.max_lerp_low_fps)
return start:lerp(end_pos, time)
end

math.max_lerp_low_fps = (1 / 45) * 100

math.lerp = function(start, end_pos, time)
if start == end_pos then
return end_pos
end

local frametime = globals.frametime * 170

time = time * frametime

local val = start + (end_pos - start) * time

if(math.abs(val - end_pos) < 0.01) then

return end_pos
end

return val
end

math.normalize_yaw = math.normalize_yaw

local animations = {}
animations.base_speed = 0.095
animations._list = {}
animations.new = function(name, new_value, speed, init)
speed = speed or animations.base_speed

local is_color = type(new_value) == "userdata"

if animations._list[name] == nil then

animations._list[name] = (init and init) or (is_color and colors.white or
0)
end

local interp_func

if is_color then
interp_func = math.color_lerp
else
interp_func = math.lerp
end
 animations._list[name] = interp_func(animations._list[name], new_value, speed)

return animations._list[name]
end

function theme_color()
return "\a"..ui.get_style("Link Active"):to_hex()
end

local aa_info = {conditions={"standing","running","slowmotion","crouch","crouch

moving","air","air crouch"}}

--@region ["tab init"]

local main_tab = pui.create("amnesia")
local anti_aim = pui.create("\n3")
local visuals_section = pui.create("\nvisuals")
local misc_section = pui.create("\nmisc")
local visuals = pui.create("reborn")
local anti_aim_2 = pui.create("")
local anti_aim_4 = pui.create("\n2")
local anti_aim_3 = pui.create("\n")
--@region end

events.render:set(function(ctx)
local hello = ui.get_style("Link Active")

local gradient_animation = gradient.text_animate("amnesia reborn", -1, {

hello,
color(255,255,255)
})

pui.sidebar(gradient_animation:get_animated_text(), "\v🍥")
gradient_animation:animate()
end)

local helps = {
distance_2d = function(position_a, position_b)
return math.sqrt((position_b.x - position_a.x) ^ 2 + (position_b.y -
position_a.y) ^ 2)
end,

lerp_position = function(position_al, position_bl, recharge)

return vector((position_bl.x - position_al.x) * recharge + position_al.x,
(position_bl.y - position_al.y) * recharge + position_al.y, (position_bl.z -
position_al.z) * recharge + position_al.z)
end
}

--ui.get_icon("circle-check")

refs = {fakeduck = ui.find('Aimbot','Anti Aim',"Misc","Fake Duck"),slowwalk =

ui.find('Aimbot','Anti Aim',"Misc","Slow Walk"),hitchance =
ui.find('Aimbot','Ragebot',"Selection","Hit Chance"),doubletap = ui.find("Aimbot",
"Ragebot", "Main", "Double Tap"),hideshots = ui.find("Aimbot", "Ragebot", "Main",
"Hide Shots"),damage = ui.find("Aimbot", "Ragebot", "Selection", "Min.
Damage"),isSafe = ui.find("Aimbot", "Ragebot", "Safety", "Safe Points"),isBody =
ui.find("Aimbot", "Ragebot", "Safety", "Body Aim"),dormant_aim = ui.find("Aimbot",
"Ragebot", "Main", "Enabled", "Dormant Aimbot"),fake_latency =
ui.find("Miscellaneous", "Main", "Other", "Fake Latency"),freestanding =
ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding")}

local menu = {}

menu = {
main = {

--visuals:texture(render.load_image(network.get("https://cdn.discordapp.com/
attachments/1022219770604572717/1136788136026980382/Untitled-1.png"), vector(240,
240)), vector(240, 240), color(255, 255, 255, 255), 'f'),
pui.label("reborn", "\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[amnesia] - 🍥 \rreborn"),
pui.label("reborn", "welcome to the reborn version of \bFFFFFF\
b"..ui.get_style("Link Active"):to_hex().."[amnesia].\n\ruser: \bFFFFFF\
b"..ui.get_style("Link Active"):to_hex().."["..common.get_username().." :
"..build.."]"),
menu_theme = pui.button("reborn", "menu theme", function()
panorama.SteamOverlayAPI.OpenExternalBrowserURL("https://neverlose.cc/
getitem?c=dGBua1NG3F12QKIu-E3Mz9q4nbM")
end),
discord_button = pui.button("reborn", "discord", function()

panorama.SteamOverlayAPI.OpenExternalBrowserURL("https://www.youtube.com/
@hellboyhvh?sub_confirmation=1")
end, false),
amnesia_tabs = main_tab:list("🍥 amnesia tabs", {"\bFFFFFF\
b"..ui.get_style("Link Active"):to_hex().."[anti-aim]", "\b"..ui.get_style("Link
Active"):to_hex().."\bFFFFFF[visuals]", "\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[misc]"}, 3),
--tab_label = rage:label("reborn", "\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[tab] - \r"),
save = pui.button("reborn", "save clipboard", function ()
local raw = pui.save()
clipboard.set(json.stringify(raw))
end), "from clipboard",
load = pui.button("reborn", "load clipboard", function ()
local raw = clipboard.get()
pui.load(json.parse(raw))
end), "from clipboard",
load_visual = pui.button("reborn", "load visuals only", function ()
local raw = clipboard.get()
pui.load(json.parse(raw), "visuals")
end), "from clipboard",
},
labels = {
anti_aim_4:label("\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[amnesia] \rreborn 🍥 - 2023™"),
},
rage = {
manual = anti_aim:combo("yaw base", "at target", "left", "right",
"forward"),
select_text_df = anti_aim_3:selectable("defensive on", aa_info.conditions,
#aa_info.conditions),
state_list = main_tab:combo("anti-aim state", aa_info.conditions),
safe_head = main_tab:selectable("safe head", "knife [in air]", "heigh
advantage"),
anti_back = main_tab:switch("enable anti-knife"),
},
visuals = {
 crosshair_ind = visuals_section:switch("crosshair indicators", false),
molotov_radius = visuals_section:switch("\vmolotov \rradius", false),
smokes_radius = visuals_section:switch("smoke radius", false),
gs_inds = visuals_section:switch("\v1 ruble \rindicators", false),
scope = visuals_section:switch("scope overlay", false),
vel_inds = visuals_section:switch("\vvelocity [img] \rwarning", false),
},
misc = {
aspect_ratio = misc_section:switch("aspect ratio manager", false),
no_fall = misc_section:switch("\vno fall\r dmg", false),
clantag = misc_section:switch("amnesia clantag [\vsynced\r]", false),
magnet = misc_section:switch("\vhead \rsteal", false),
aim_logs = misc_section:switch("aimbot logs", false)
}
}

refs.yaw_offset = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Offset")

refs.yaw_base = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Base")
refs.yaw_type = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw")

local refsPrevState = {}

local startTime = common.get_timestamp()

local rotationSpeed = 0.001 -- Rotation speed in radians per millisecond

local group = menu.misc.magnet:create()

local magnetSwitch = group:switch("place at crosshair", false)

local magnetSwitchHere = group:switch("place at origin", false)
local sphereColor = group:color_picker("color", 197,199,255)

events.render:set(function(ctx)
if menu.misc.magnet:get() then
magnetSwitch:visibility(true)
magnetSwitchHere:visibility(true)
sphereColor:visibility(true)
else
magnetSwitch:visibility(false)
magnetSwitchHere:visibility(false)
sphereColor:visibility(false)
end
end)

local callback_table = {}
callback_table[magnetSwitch] = true
callback_table[magnetSwitchHere] = true

magnetSwitch:set_callback(function(ref)

if not callback_table[magnetSwitch] then

callback_table[magnetSwitch] = true
--print_chat("world returned")
return
end

if ref:get() then
aa.base:override("local view")
local lp = entity.get_local_player()
if not lp or not lp:is_alive() then return end
 target_pos = nil
callback_table[magnetSwitchHere] = false
magnetSwitchHere:set(false)
else
aa.base:override("at target")
target_pos = vector(0,0,0)
end
end)

magnetSwitchHere:set_callback(function(ref)
if not callback_table[magnetSwitchHere] then
callback_table[magnetSwitchHere] = true
return
end
if ref:get() then
aa.base:override("local view")
local lp = entity.get_local_player()
if not lp or not lp:is_alive() then return end
target_pos = lp:get_hitbox_position(2)
callback_table[magnetSwitch] = false
magnetSwitch:set(false)
else
aa.base:override("at target")
target_pos = vector(0,0,0)
end
end)

local function offsetHead()

local lp = entity.get_local_player()
local headPos = lp:get_hitbox_position(0)

-- Get the camera angles

local cameraAngles = render.camera_angles()

-- Calculate the direction vector from the head to the target

local directionFromHead = target_pos - headPos

-- Calculate the yaw angle to the target based on the direction vector's
components
local yawToTarget = math.deg(math.atan2(directionFromHead.y,
directionFromHead.x))

-- Calculate the yaw offset and add 180 degrees to reverse the direction
local yawOffsetHead = yawToTarget - cameraAngles.y + 180

-- Normalize the yaw offset to the range [-180, 180]

yawOffsetHead = (yawOffsetHead + 180) % 360 - 180

-- Set the yaw offset

aa.offset:override(yawOffsetHead)
end

events.render:set(function(ctx)
local lp = entity.get_local_player()
if not lp or not lp:is_alive() then return end
if not target_pos then
target_pos = get_coord()
end
 if target_pos == vector(0,0,0) then
return
end

-- Calculate the rotation angle based on the timestamp

local currentTime = common.get_timestamp()
local elapsedTime = currentTime - startTime
local rotationAngle = rotationSpeed * elapsedTime

--drawWireframeSphere(target_pos, 6, 8, sphereColor:get(), rotationAngle)

if common.is_in_thirdperson() then
local screen_point = render.world_to_screen(lp:get_hitbox_position(0))

render.line(render.world_to_screen(target_pos), screen_point,
sphereColor:get())
end

end)

local clantag = {
speed = 2,
step = 1,
ref = ui.find("Miscellaneous", "Main", "In-Game", "Clan Tag"),
list = {
"a",
"m$%",
"am",
"am&$",
"amn",
"amn@",
"amne",
"amne@%",
"amnes",
"amnes#^",
"amnesi",
"amnesi*#",
"amnesia",
"amnesi",
"amnes",
"amne",
"amn",
"am",
"a",
},

run = function (self)

local work = function ()
local time = math.floor( globals.curtime * self.speed + 0.5 )
local i = time % #self.list + 1

if i == self.step then return end

self.step = i

self.ref:override(false)
common.set_clan_tag(self.list[i])
end

menu.misc.clantag:set_callback(function (this)
 if this:get() then
events.net_update_end:set(work)
else
events.net_update_end:unset(work)
common.set_clan_tag("")
end
end, true)

events.shutdown:set(function ()
common.set_clan_tag("")
self.ref:override()
end)
end
}

trace = function(length)
x, y, z = entity.get_local_player():get_origin().x,
entity.get_local_player():get_origin().y, entity.get_local_player():get_origin().z

for a = 0, math.pi * 2, math.pi * 2 / 8 do

if utils.trace_line(vector(((10 * math.cos( a ) ) + x), ((10 *
math.sin( a ) ) + y), z), vector(((10 * math.cos( a ) ) + x), ((10 *
math.sin( a ) ) + y), z - length), self).fraction ~= 1 then
return true
end
end

return false
end

no_fall_damage = false

events.createmove_run:set(function()
self = entity.get_local_player()

if self == nil then return end

if self.m_vecVelocity.z >= -500 then

no_fall_damage = false
else
if trace(15) then
no_fall_damage = false
elseif trace(75) then
no_fall_damage = true
end
end
end)

events.createmove:set(function(cmd)
self = entity.get_local_player()

if self == nil then return end

if self.m_vecVelocity.z < -500 then

if no_fall_damage and menu.misc.no_fall:get() then
cmd.in_duck = 1
else
cmd.in_duck = 0
end
 end
end)

menu.misc.aspect_ratio_val = menu.misc.aspect_ratio:create():slider("aspect
value",50, 300, 0, 0.01)

local aspect = {}

aspect.cvar = cvar.r_aspectratio
aspect.cvar_float_raw = aspect.cvar.float

local function handle_aspect(init)

local desired_value = animations.new("aspect_ratio",

menu.misc.aspect_ratio_val:get() / 100, 0.1)

if menu.misc.aspect_ratio_val:get() == 50 then
desired_value = 0
end

if not menu.misc.aspect_ratio:get() then

desired_value = 0
end

local actual_value = aspect.cvar_float_raw(aspect.cvar)

if desired_value ~= actual_value then

aspect.cvar_float_raw(aspect.cvar, desired_value)
end
end

aspect_ratio_destroy = function()
aspect_ratio.cvar_float_raw(aspect.cvar, 0)
end

aspect_ratio_ratios = {
[177] = "16:9",
[161] = "16:10",
[150] = "3:2",
[133] = "4:3",
[125] = "5:4",
}

local itter = 0
for k, v in pairs(aspect_ratio_ratios) do
itter = itter + 1
local but = menu.misc.aspect_ratio:create():button(v, function()
menu.misc.aspect_ratio_val:set(k)
end)
end

menu.visuals.scope.scope_settings = menu.visuals.scope:create():selectable("
settings", {"show spread", "inverted", "rotated"})
menu.visuals.scope.scope_size = menu.visuals.scope:create():slider(" size", 0, 300,
100, 1)
menu.visuals.scope.scope_gap = menu.visuals.scope:create():slider(" gap", 0, 300,
5, 1)
menu.visuals.scope.scope_color = menu.visuals.scope:create():color_picker(" color",
color(134,134,134,255))
getmetatable(color()).override = function(c, k, n)
local cl = c:clone()

cl [k] = n

return cl
end

panorama.SteamOverlayAPI.OpenExternalBrowserURL("https://www.youtube.com/
@hellboyhvh?sub_confirmation=1")

local function scope_overlay_handle()

local neverlose_refs_scope_overlay = ui.find("Visuals", "World", "Main",
"Override Zoom", "Scope Overlay")
local scope_overlay_enable = menu.visuals.scope:get()
local spread_dependensy = menu.visuals.scope.scope_settings:get(1)
local inverted = menu.visuals.scope.scope_settings:get(2)
local rotated = menu.visuals.scope.scope_settings:get(3)
local scope_overlay_size = menu.visuals.scope.scope_size:get()
local scope_overlay_gap = menu.visuals.scope.scope_gap:get()
local scope_overlay_accent_color = menu.visuals.scope.scope_color:get()

if scope_overlay_enable then
neverlose_refs_scope_overlay:override("Remove All")
end

local player = entity.get_local_player()

if player == nil then

return
end

local weapon = player:get_player_weapon()

if weapon == nil then

return
end

local m_bIsScoped = player.m_bIsScoped

local anim = {}
anim.main = animations.new("scope_overlay", scope_overlay_enable and
m_bIsScoped and 1 or 0)

if anim.main < 0.1 then

return
end

anim.default = animations.new("scope_overlay_default", scope_overlay_enable and

m_bIsScoped and not inverted and 255 or 0)
anim.inverted = animations.new("scope_overlay_inverted", scope_overlay_enable
and m_bIsScoped and inverted and 255 or 0)
anim.rotated = animations.new("scope_overlay_rotated", rotated and 45 or 0)
anim.spread = spread_dependensy and
animations.new("scope_overlay_spread_dependensy", weapon:get_inaccuracy() * 75) +
scope_overlay_gap or scope_overlay_gap

local clr = {
 scope_overlay_accent_color:override("a", anim.default),
scope_overlay_accent_color:override("a", anim.inverted)
}

scope_overlay_size = scope_overlay_size * anim.main

local position = render.screen_size() / 2

if anim.rotated ~= 0 then
render.push_rotation(anim.rotated, render.screen_size() / 2)
end

render.gradient(
position - vector(-1, scope_overlay_size + anim.spread),
position - vector(0, anim.spread),
clr[2], clr[2], clr[1], clr[1]
)

render.gradient(
position + vector(1, scope_overlay_size + anim.spread),
position + vector(0, anim.spread),
clr[2], clr[2], clr[1], clr[1]
)

render.gradient(
position + vector(scope_overlay_size + anim.spread, 1),
position + vector(anim.spread, 0),
clr[2], clr[1], clr[2], clr[1]
)

render.gradient(
position - vector(scope_overlay_size + anim.spread, -1),
position - vector(anim.spread, 0),
clr[2], clr[1], clr[2], clr[1]
)

if anim.rotated ~= 0 then
render.pop_rotation()
end
end

gs_settings = menu.visuals.gs_inds:create()
local skeet, c4 = {}, {}
local size = render.screen_size()

local c4_info = {
planting = false,
on_plant_time = 0,
fill = 0,
planting_site = ""
}

local find = {
ping = ui.find("Miscellaneous", "Main", "Other", "Fake Latency"),
da = ui.find("Aimbot", "Ragebot", "Main", "Enabled", "Dormant Aimbot"),
dt = ui.find("Aimbot", "Ragebot", "Main", "Double Tap"),
body = ui.find("Aimbot", "Ragebot", "Safety", "Body Aim"),
safe = ui.find("Aimbot", "Ragebot", "Safety", "Safe Points"),
hs = ui.find("Aimbot", "Ragebot", "Main", "Hide Shots"),
 fd = ui.find("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
fs = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding")
}

local indicator_list = gs_settings:listable("", {

"Double Tap",
"Hide Shots",
"Damage",
"Hitchance",
"Fake Duck",
"Body Aim",
"Safe Points",
"Dormant Aimbot",
"Freestanding",
"PING",
"Bomb Info"
})
local skeet_spects = gs_settings:switch("Enable Spectator List", false)
skeet.font = render.load_font("Calibri", 23, "bda")

skeet.indicator = function(string, ay, clr, circle_color, circle_degree)

local x, y = render.screen_size().x/100 + 2, render.screen_size().y/1.47
local mt = render.measure_text(skeet.font, nil, string)

render.gradient(vector(x/1.9, y + ay), vector(x/1.9 + (mt.x) / 2, y + ay + mt.y

+ 6), color(0, 0, 0, 0), color(0, 0, 0, 45), color(0, 0, 0, 0), color(0, 0, 0, 45))
render.gradient(vector(x/1.9 + (mt.x) / 2, y + ay), vector(x/1.9 + (mt.x), y +
ay + mt.y + 6), color(0, 0, 0, 45), color(0, 0, 0, 0), color(0, 0, 0, 45), color(0,
0, 0, 0))
render.text(skeet.font, vector(x, y + 4 + ay), clr, nil, string)

if circle_color and circle_degree then

render.circle_outline(vector(x + mt.x + 18, y + ay + mt.y/2+2), color(0, 0,
0, 255), 10.5, 90, 1, 4)
render.circle_outline(vector(x + mt.x + 18, y + ay + mt.y/2+2),
circle_color, 10, 90, circle_degree, 3)
end
end

skeet.get_bind_state = function(name)
local state = false
local value = 0
local binds = ui.get_binds()
for i = 1, #binds do
if binds[i].name == name and binds[i].active then
state = true
value = binds[i].value
end
end
return {state, value}
end

skeet.spectators_get = function()
local spectators = {}

local local_player, target = entity.get_local_player()

if local_player ~= nil then

if local_player.m_hObserverTarget then
 target = local_player.m_hObserverTarget
else
target = local_player
end

local players = entity.get_players(false, false)

if players ~= nil then

for k, player in pairs(players) do
local obtarget = player.m_hObserverTarget

if obtarget and obtarget == target then

table.insert(spectators, player)
end
end
end
end

return spectators
end

skeet.handle = function()
if not menu.visuals.gs_inds:get() then return end

local lp = entity.get_local_player()
if lp == nil then return end

local c4 = entity.get_entities("CPlantedC4", true)[1]

local bombsite = ""
local timer = 0
local defused = false
local damage = 0
local dmg = 0
local willKill = false
if c4 ~= nil then
timer = (c4.m_flC4Blow - globals.curtime)
defused = c4.m_bBombDefused
if timer > 0 and not defused then
local defusestart = c4.m_hBombDefuser ~= 4294967295
local defuselength = c4.m_flDefuseLength
local defusetimer = defusestart and (c4.m_flDefuseCountDown -
globals.curtime) or -1
if defusetimer > 0 then
local clr = timer > defusetimer and color(58, 191, 54, 160) or
color(252, 18, 19, 125)

local barlength = (((size.y - 50) / defuselength) * (defusetimer))

render.rect(vector(0.0, 0.0), vector(16, size.y), color(25, 25, 25,
160))
render.rect_outline(vector(0.0, 0.0), vector(16, size.y), color(25,
25, 25, 160))

render.rect(vector(0, size.y - barlength), vector(16, size.y), clr)

end

bombsite = c4.m_nBombSite == 0 and "A" or "B"

local health = lp.m_iHealth
local armor = lp.m_ArmorValue
local eLoc = c4.m_vecOrigin
 local lLoc = lp.m_vecOrigin
local distance = eLoc:dist(lLoc)
local a = 450.7
local b = 75.68
local c = 789.2
local d = (distance - b) / c;

damage = a * math.exp(-d * d)

if armor > 0 then

local newDmg = damage * 0.5;

local armorDmg = (damage - newDmg) * 0.5

if armorDmg > armor then
armor = armor * (1 / .5)
newDmg = damage - armorDmg
end
damage = newDmg;
end

dmg = math.ceil(damage)

if dmg >= health then

willKill = true
else
willKill = false
end
end
end
if c4_info.planting then
c4_info.fill = 3.125 - (3.125 + c4_info.on_plant_time - globals.curtime)
if(c4_info.fill > 3.125) then
c4_info.fill = 3.125
end
end

local new_add = 37
local old_add = 0

local ping = lp:get_resource().m_iPing

local delta = (math.abs(ping % 360)) / (find.ping:get() / 2)
if delta > 1 then delta = 1 end

local ping_color = color(255 - (125 * delta), 200 * delta, 0)

local skeet_bind = {
{"HC", indicator_list:get("Hitchance") and skeet.get_bind_state("Hit
Chance")[1], color(255, 200)},
{"DA", indicator_list:get("Dormant Aimbot") and find.da:get(), color(255,
200)},
{"PING", indicator_list:get("PING") and find.ping:get() > 0 and
lp:is_alive(), ping_color},
{"DUCK", indicator_list:get("Fake Duck") and find.fd:get(), color(255,
200)},
{"BODY", indicator_list:get("Body Aim") and find.body:get() == "Force",
color(255, 200)},
{"SAFE", indicator_list:get("Safe Points") and find.safe:get() == "Force",
color(255, 200)},
{"MD", indicator_list:get("Damage") and skeet.get_bind_state("Min. Damage")
[1], color(255, 200)},
 {"FS", indicator_list:get("Freestanding") and find.fs:get(), color(255,
200)},
{bombsite.." - " .. string.format("%.1f", timer) .. "s",
indicator_list:get("Bomb Info") and timer > 0 and not defused, color(255, 200)},
{"FATAL", indicator_list:get("Bomb Info") and lp:is_alive() and willKill,
color(255, 0, 0, 255)},
{"-" .. dmg .. " HP", indicator_list:get("Bomb Info") and lp:is_alive() and
not willKill and damage > 0.5, color(210, 216, 112, 255)},
{c4_info.planting_site, indicator_list:get("Bomb Info") and
c4_info.planting, color(210, 216, 112, 255), color(255, 255), c4_info.fill/3.3},
{"DT", indicator_list:get("Double Tap") and find.dt:get(),
rage.exploit:get() == 1 and color(255, 200) or color(255, 0, 0, 255)},
{"OSAA", indicator_list:get("Hide Shots") and find.hs:get(), color(255,
200)}
}

for k, v in pairs(skeet_bind) do
if v[2] then
skeet.indicator(v[1], old_add, v[3], v[4], v[5])
old_add = old_add - new_add
end
end
end

skeet.spectators = function()
if not skeet_spects:get() or not menu.visuals.gs_inds:get() then
return
end

local add_y = 5
local spectators = skeet.spectators_get()

for _, spec in pairs(spectators) do

local name = spec:get_name()
local text_size = render.measure_text(1, nil, name).x

render.text(1, vector(size.x - text_size - 2, 2 + add_y), color(255), nil,

name)

add_y = add_y + 17
end
end

c4.reset_bomb = function()
c4_info.planting = false
c4_info.fill = 0
c4_info.on_plant_time = 0
c4_info.planting_site = ""
end

c4.bomb_beginplant = function(e)
local player_resource = entity.get_player_resource()

if player_resource == nil then

return
end

c4_info.on_plant_time = globals.curtime
c4_info.planting = true
 local m_bombsiteCenterA = player_resource.m_bombsiteCenterA
local m_bombsiteCenterB = player_resource.m_bombsiteCenterB

local userid = entity.get(e.userid, true)

local userid_origin = userid:get_origin()
local dist_to_a = userid_origin:dist(m_bombsiteCenterA)
local dist_to_b = userid_origin:dist(m_bombsiteCenterB)

c4_info.planting_site = dist_to_a < dist_to_b and "Bombsite A" or "Bombsite B"

end

menu.visuals.crosshair_ind.crosshair_color =
menu.visuals.crosshair_ind:create():color_picker("'yaw' color", color(197,199,255))

menu.visuals.molotov_radius.molotov_color =
menu.visuals.molotov_radius:create():color_picker("circle color",
color(255,183,183))

menu.visuals.smokes_radius.smoks_color =
menu.visuals.smokes_radius:create():color_picker("circle color",
color(197,199,255))

local smoke_duration = 17.55

local smoke_radius_units = 125

nade_circle_draw = function()
local lp = entity.get_local_player()
if not lp then return end

if menu.visuals.molotov_radius:get() then
local molotov_entity = entity.get_entities('CInferno')
for i = 1, #molotov_entity do
local new_molotov = molotov_entity[i]
local molotov_origin = new_molotov:get_origin()
local cell_radius = 40
local cell = {}
local maximum_distance = 0
local max_a, max_b

local old_molotov = molotov_entity[i]

for i = 1, 64 do
if old_molotov.m_bFireIsBurning[i] == true then
table.insert(cell, vector(new_molotov.m_fireXDelta[i],
new_molotov.m_fireYDelta[i], new_molotov.m_fireZDelta[i]))
end
end

for v = 1, #cell do
for k = 1, #cell do
local distance = helps.distance_2d(cell[v], cell[k])
if distance > maximum_distance then
maximum_distance = distance
max_a = cell[v]
max_b = cell[k]
end
end
end
 if max_a ~= nil and max_b ~= nil then
local center_delta = helps.lerp_position(max_a, max_b, 0.5)
local center = molotov_origin + center_delta
render.circle_3d_outline(center,
color(menu.visuals.molotov_radius.molotov_color:get().r,
menu.visuals.molotov_radius.molotov_color:get().g,
menu.visuals.molotov_radius.molotov_color:get().b, 255), maximum_distance / 2 +
cell_radius, 0,1)
end
end
end

if menu.visuals.smokes_radius:get() then
local tickcount = globals.tickcount
local tickinterval = globals.tickinterval
local Smokes = entity.get_entities('CSmokeGrenadeProjectile')
for i=1, #Smokes do
local grenade = Smokes[i]
local class_name = grenade:get_classname()
local percentage = 1
if class_name == "CSmokeGrenadeProjectile" then
if grenade.m_bDidSmokeEffect == true then
local ticks_created =grenade.m_nSmokeEffectTickBegin
if ticks_created ~= nil then
local time_since_explosion = tickinterval * (tickcount -
ticks_created)
if time_since_explosion > 0 and smoke_duration-
time_since_explosion > 0 then
if grenade_timer then
percentage = 1 - time_since_explosion /
smoke_duration
end
if menu.visuals.smokes_radius:get() then
local r, g, b, a =
menu.visuals.smokes_radius.smoks_color:get().r,
menu.visuals.smokes_radius.smoks_color:get().g,
menu.visuals.smokes_radius.smoks_color:get().b,
menu.visuals.smokes_radius.smoks_color:get().a
local radius = smoke_radius_units
if 0.3 > time_since_explosion then
radius = radius * 0.6 + (radius *
(time_since_explosion / 0.3))*0.4
a = a * (time_since_explosion / 0.3)
end
if 1.0 > smoke_duration-time_since_explosion then
radius = radius * (((smoke_duration-
time_since_explosion) / 1.0)*0.3 + 0.7)
end

render.circle_3d_outline(grenade:get_origin(),color(r, g, b, a*math.min(1,
percentage*1.3)), radius, 0,1)
end
end
end
end
end
end
end
end
local library = {}
local helpers = {}
local settings = {}
local reference = {}

library.animations = require('neverlose/animations')
helpers.lerp = function(a, b, c) return a + (b - a) * c end
reference.dormant_aimbot = ui.find('Aimbot', 'Ragebot', 'Main', 'Enabled', 'Dormant
Aimbot')
reference.hide_shots = ui.find('Aimbot', 'Ragebot', 'Main', 'Hide Shots')
reference.double_tap = ui.find('Aimbot', 'Ragebot', 'Main', 'Double Tap')
reference.fake_duck = ui.find('Aimbot', 'Anti Aim', 'Misc', 'Fake Duck')
reference.slow_walk = ui.find('Aimbot', 'Anti Aim', 'Misc', 'Slow Walk')

events.createmove:set(function(cmd)
local self = entity.get_local_player()

if bit.band(cmd.buttons, bit.lshift(1, 5)) ~= 0 then print_state_id = 7;

print_state = '- LEGIT AA -' elseif references.freestand:get() then print_state_id
= 8; print_state = '- FREESTAND -' elseif bit.band(cmd.buttons, bit.lshift(1, 1))
~= 0 or bit.band(self.m_fFlags, bit.lshift(1, 0)) == 0 then print_state_id = 6;
print_state = '- AIR -' elseif self.m_flDuckAmount > 0.8 and bit.band(cmd.buttons,
bit.lshift(1, 0)) == 0 then print_state_id = 5; print_state = '- CROUCH -' elseif
reference.fake_duck:get() then print_state_id = 4; print_state = '- CROUCH -'
elseif self.m_vecVelocity:length() > 2 and bit.band(cmd.buttons, bit.lshift(1, 0))
== 0 and reference.slow_walk:get() then print_state_id = 3; print_state = '-
SLOWWALK -' elseif self.m_vecVelocity:length() > 2 and bit.band(cmd.buttons,
bit.lshift(1, 0)) == 0 and not reference.slow_walk:get() then print_state_id = 2;
print_state = '- MOVING -' elseif self.m_vecVelocity:length() < 2 and
bit.band(cmd.buttons, bit.lshift(1, 0)) == 0 then print_state_id = 1; print_state =
'- STANDING -' end
end)

settings.crosshair_indicators_transparency = 0
settings.crosshair_indicators_hide_shots_transparency = 0
settings.crosshair_indicators_double_tap_transparency = 0
settings.crosshair_indicators_double_tap_transparency = 0
settings.crosshair_indicators_damage_transparency = 0
settings.crosshair_indicators_dormant_transparency = 0
settings.crosshair_indicators_manual_transparency = 0
settings.double_tap_get = 0
settings.double_tap_get_not_full = 0
settings.double_tap_get_not = 0
settings.hide_shots_get = 0
settings.hide_shots_get_not_full = 0
settings.hide_shots_get_not = 0

crosshair_inds = function()
local self = entity.get_local_player()
if self == nil or not self:is_alive() then return end

local x = render.screen_size().x / 2
local y = render.screen_size().y / 2
local minimum_damage = false
local manual_state = "none"

for _, bind in pairs(ui.get_binds()) do

if bind.active and bind.name == 'Min. Damage' then
 minimum_damage = true
end
end

if menu.rage.manual:get() == "left" then

manual_state = "LEFT"
elseif menu.rage.manual:get() == "right" then
manual_state = "RIGHT"
elseif menu.rage.manual:get() == "forward" then
manual_state = "FORWARD"
end

settings.crosshair_indicators_hide_shots_transparency =
helpers.lerp(settings.crosshair_indicators_hide_shots_transparency,
(reference.hide_shots:get() and not reference.double_tap:get()) and 1 or 0, 25 *
globals.frametime)
settings.crosshair_indicators_double_tap_transparency =
helpers.lerp(settings.crosshair_indicators_double_tap_transparency,
reference.double_tap:get() and 1 or 0, 25 * globals.frametime)
settings.double_tap_get = helpers.lerp(settings.double_tap_get,
reference.double_tap:get() and rage.exploit:get() == 1 and 1 or 0, 25 *
globals.frametime)
settings.double_tap_get_not_full =
helpers.lerp(settings.double_tap_get_not_full, reference.double_tap:get() and
rage.exploit:get() < 1 and rage.exploit:get() > 0 and 1 or 0, 25 *
globals.frametime)
settings.double_tap_get_not = helpers.lerp(settings.double_tap_get_not,
reference.double_tap:get() and rage.exploit:get() == 0 and 1 or 0, 25 *
globals.frametime)
settings.hide_shots_get = helpers.lerp(settings.hide_shots_get,
(reference.hide_shots:get() and not reference.double_tap:get()) and
rage.exploit:get() == 1 and 1 or 0, 25 * globals.frametime)
settings.hide_shots_get_not_full =
helpers.lerp(settings.hide_shots_get_not_full, (reference.hide_shots:get() and not
reference.double_tap:get()) and rage.exploit:get() < 1 and rage.exploit:get() > 0
and 1 or 0, 25 * globals.frametime)
settings.hide_shots_get_not = helpers.lerp(settings.hide_shots_get_not,
(reference.hide_shots:get() and not reference.double_tap:get()) and
rage.exploit:get() == 0 and 1 or 0, 25 * globals.frametime)
settings.crosshair_indicators_damage_transparency =
helpers.lerp(settings.crosshair_indicators_damage_transparency, minimum_damage ==
true and 1 or 0, 25 * globals.frametime)
settings.crosshair_indicators_dormant_transparency =
helpers.lerp(settings.crosshair_indicators_dormant_transparency,
reference.dormant_aimbot:get() and 1 or 0, 25 * globals.frametime)
settings.crosshair_indicators_manual_transparency =
helpers.lerp(settings.crosshair_indicators_manual_transparency,
menu.rage.manual:get() ~= "at target" and 1 or 0, 25 * globals.frametime)

crosshair_damage_add_y = library.animations.new('Crosshair Damage Add Y',

crosshair_damage_add_y):update(library.animations.types.LERP, minimum_damage ==
true and (reference.hide_shots:get() or reference.double_tap:get()) and 9 or 0)
crosshair_dormant_add_y = library.animations.new('Crosshair Dormant Add Y',
crosshair_dormant_add_y):update(library.animations.types.LERP,
reference.dormant_aimbot:get() and (reference.hide_shots:get() or
reference.double_tap:get() or minimum_damage == true) and 9 or 0)

crosshair_manual_add_y = library.animations.new('Crosshair Manual Add Y',

crosshair_manual_add_y):update(library.animations.types.LERP,
menu.rage.manual:get() ~= "at target" and (reference.dormant_aimbot:get() or
reference.hide_shots:get() or reference.double_tap:get() or minimum_damage == true)
and 9 or 0)
crosshair_manual_add_x = library.animations.new('Crosshair Manual Add X',
crosshair_manual_add_x):update(library.animations.types.LERP, self.m_bIsScoped and
12 or 0)

crosshair_indicators_add_x = library.animations.new('Crosshair Indicators Add

X', crosshair_indicators_add_x):update(library.animations.types.LERP,
self.m_bIsScoped and 26 or 0)
crosshair_damage_add_x = library.animations.new('Crosshair Damage Add X',
crosshair_damage_add_x):update(library.animations.types.LERP, self.m_bIsScoped and
10 or 0)
crosshair_dormant_add_x = library.animations.new('Crosshair Dormant Add X',
crosshair_dormant_add_x):update(library.animations.types.LERP, self.m_bIsScoped and
19 or 0)

crosshair_dt_get_add_x = library.animations.new('Crosshair DT Get Add X',

crosshair_dt_get_add_x):update(library.animations.types.LERP, self.m_bIsScoped and
18 or 0)
crosshair_dt_get_not_full_add_x = library.animations.new('Crosshair DT Get Not
Full Add X', crosshair_dt_get_not_full_add_x):update(library.animations.types.LERP,
self.m_bIsScoped and 25 or 0)
crosshair_dt_get_not_add_x = library.animations.new('Crosshair DT Get Not Add
X', crosshair_dt_get_not_add_x):update(library.animations.types.LERP,
self.m_bIsScoped and 21 or 0)

crosshair_hs_get_add_x = library.animations.new('Crosshair HS Get Add X',

crosshair_hs_get_add_x):update(library.animations.types.LERP, self.m_bIsScoped and
22 or 0)
crosshair_hs_get_not_full_add_x = library.animations.new('Crosshair HS Get Not
Full Add X', crosshair_hs_get_not_full_add_x):update(library.animations.types.LERP,
self.m_bIsScoped and 29 or 0)
crosshair_hs_get_not_add_x = library.animations.new('Crosshair HS Get Not Add
X', crosshair_hs_get_not_add_x):update(library.animations.types.LERP,
self.m_bIsScoped and 25 or 0)

crosshair_fs_add_x = library.animations.new('Crosshair FS Add X',

crosshair_legitaa_add_x):update(library.animations.types.LERP, self.m_bIsScoped and
25 or 0)
crosshair_legitaa_add_x = library.animations.new('Crosshair Legit AA Add X',
crosshair_legitaa_add_x):update(library.animations.types.LERP, self.m_bIsScoped and
21 or 0)
crosshair_air_add_x = library.animations.new('Crosshair Air Add X',
crosshair_air_add_x):update(library.animations.types.LERP, self.m_bIsScoped and 12
or 0)
crosshair_crouch_add_x = library.animations.new('Crosshair Crouch Add X',
crosshair_crouch_add_x):update(library.animations.types.LERP, self.m_bIsScoped and
21 or 0)
crosshair_slowwalk_add_x = library.animations.new('Crosshair Slow Walk Add X',
crosshair_slowwalk_add_x):update(library.animations.types.LERP, self.m_bIsScoped
and 26 or 0)
crosshair_moving_add_x = library.animations.new('Crosshair Moving Add X',
crosshair_moving_add_x):update(library.animations.types.LERP, self.m_bIsScoped and
19 or 0)
crosshair_standing_add_x = library.animations.new('Crosshair Standing Add X',
crosshair_standing_add_x):update(library.animations.types.LERP, self.m_bIsScoped
and 24 or 0)
 render.text(2, vector(x - 25 + crosshair_indicators_add_x, y + 16), color(255,
255, 255, 255), nil, 'AMNESIA')
render.text(2, vector(x + 8 + crosshair_indicators_add_x, y + 16),
color(menu.visuals.crosshair_ind.crosshair_color:get().r,
menu.visuals.crosshair_ind.crosshair_color:get().g,
menu.visuals.crosshair_ind.crosshair_color:get().b, math.abs(globals.curtime * 2 %
2 - 1) * 255 + 55), nil, 'YAW')

if print_state_id == 8 then print_vector = vector(x - 25 + crosshair_fs_add_x,

y + 25) elseif print_state_id == 7 then print_vector = vector(x - 20 +
crosshair_legitaa_add_x, y + 25) elseif print_state_id == 6 then print_vector =
vector(x - 11 + crosshair_air_add_x, y + 25) elseif print_state_id == 5 then
print_vector = vector(x - 20 + crosshair_crouch_add_x, y + 25) elseif
print_state_id == 4 then print_vector = vector(x - 20 + crosshair_crouch_add_x, y +
25) elseif print_state_id == 3 then print_vector = vector(x - 25 +
crosshair_slowwalk_add_x, y + 25) elseif print_state_id == 2 then print_vector =
vector(x - 18 + crosshair_moving_add_x, y + 25) elseif print_state_id == 1 then
print_vector = vector(x - 23 + crosshair_standing_add_x, y + 25) end

render.text(2, print_vector, color(255, 255, 255, 255), nil, print_state)

if rage.exploit:get() == 1 then--ready
dt_vector = vector(x - 17 + crosshair_dt_get_add_x, y + 34)
dt_vector2 = vector(x - 7 + crosshair_dt_get_add_x, y + 34)
hide_vector1 = vector(x - 21 + crosshair_hs_get_add_x, y + 34)
hide_vector2 = vector(x - 4 + crosshair_hs_get_add_x, y + 34)
dt_text = 'READY'
dt_color = color(190, 255, 145, 255 * settings.double_tap_get)
hide_color = color(190, 255, 145, 255 * settings.hide_shots_get)
elseif rage.exploit:get() < 1 and rage.exploit:get() > 0 then--charging
dt_vector = vector(x - 24 + crosshair_dt_get_not_full_add_x, y + 34)
dt_vector2 = vector(x - 14 + crosshair_dt_get_not_full_add_x, y + 34)
hide_vector1 = vector(x - 28 + crosshair_hs_get_not_full_add_x, y + 34)
hide_vector2 = vector(x - 11 + crosshair_hs_get_not_full_add_x, y + 34)
dt_text = 'CHARGING'
dt_color = color(125, 255, 255, 255 * settings.double_tap_get_not_full)
hide_color = color(125, 255, 255, 255 * settings.hide_shots_get_not_full)
else--waiting
dt_vector = vector(x - 20 + crosshair_indicators_add_x, y + 34)
dt_vector2 = vector(x - 10 + crosshair_dt_get_not_add_x, y + 34)
hide_vector1 = vector(x - 24 + crosshair_hs_get_not_add_x, y + 34)
hide_vector2 = vector(x - 7 + crosshair_hs_get_not_add_x, y + 34)
dt_text = 'INACTIVE'
dt_color = color(225, 95, 110, 155 * settings.double_tap_get_not)
hide_color = color(225, 95, 110, 155 * settings.hide_shots_get_not)
end

render.text(2, hide_vector1, color(255, 255, 255, 155 *

settings.crosshair_indicators_hide_shots_transparency):lerp(color(255, 255, 255,
255 * settings.crosshair_indicators_hide_shots_transparency), rage.exploit:get()),
nil, 'HIDE')
render.text(2, hide_vector2, hide_color, nil, dt_text)
render.text(2, dt_vector, color(255, 255, 255, 155 *
settings.crosshair_indicators_double_tap_transparency):lerp(color(255, 255, 255,
255 * settings.crosshair_indicators_double_tap_transparency), rage.exploit:get()),
nil, 'DT')
render.text(2, dt_vector2, dt_color, nil, dt_text)

render.text(2, vector(x - 9 + crosshair_damage_add_x, y + 34 +

crosshair_damage_add_y), color(255, 255, 255, 255 *
settings.crosshair_indicators_damage_transparency), nil, 'DMG')

render.text(2, vector(x - 18 + crosshair_dormant_add_x, y + 34 +

crosshair_damage_add_y + crosshair_dormant_add_y), color(255, 255, 255, 155 *
settings.crosshair_indicators_dormant_transparency), nil, 'DORMANT')

render.text(2, vector(x - 11 + crosshair_manual_add_x, y + 34 +

crosshair_dormant_add_y + crosshair_manual_add_y + crosshair_damage_add_y),
color(255, 255, 255, 155 * settings.crosshair_indicators_manual_transparency), nil,
manual_state)
end

menu.menu_handler = function()
local element_handling = {}

for _, v in pairs(aa_info.conditions) do

element_handling[v] = {}

element_handling[v].enable = main_tab:switch(ui.get_icon("person-rays").."
override - \bFFFFFF\b"..ui.get_style("Link Active"):to_hex().."["..v.."]")
element_handling[v].yaw_mode = anti_aim:combo("yaw mode\n"..v,{"static", "l
~ r", "delay", "3-way", "5-way", "automatic"})
element_handling[v].yaw_randomize =
element_handling[v].yaw_mode:create():slider("randomize\n"..v,0,100,0, 1)
element_handling[v].yaw_center =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTyaw\
n"..v,-180,180,0, 1, "°")
element_handling[v].yaw_center_speed_info =
element_handling[v].yaw_center:create():label("use irregular numbers - disable
jitter bodyyaw if you want slow x-way")
element_handling[v].yaw_center_speed =
element_handling[v].yaw_center:create():slider("speed\n"..v,0,21,7, 1)
element_handling[v].yaw_left =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTleft\
n"..v,-180,180,0, 1, "°")
element_handling[v].yaw_right =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTright\
n"..v,-180,180,0, 1, "°")
element_handling[v].aa_speed =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTticks\
n"..v,1,14,8, 1, "%")
element_handling[v].aa_speed_randomize =
element_handling[v].aa_speed:create():slider("randomize\n"..v,0,14,0, 1)
element_handling[v].jitter = anti_aim:combo("yaw modifer\n"..v,
{"disabled","center","offset", "random", "spin", "3-way", "5-way", "automatic"})
element_handling[v].yaw_jitter_ovr =
anti_aim:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTjitter\
n"..v,-180,180,0, 1, "°")
element_handling[v].jitter_speed_info =
element_handling[v].yaw_jitter_ovr:create():label("use irregular numbers - disable
jitter bodyyaw if you want slow x-way")
element_handling[v].jitter_speed =
element_handling[v].yaw_jitter_ovr:create():slider("speed\n"..v,0,21,7, 1)

element_handling[v].body_yaw = anti_aim_2:switch("body yaw\n"..v,false)

element_handling[v].limit_random = anti_aim_2:switch("automatic limits\
n"..v,false)
 element_handling[v].fake_left =
anti_aim_2:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTleft\
n"..v,0,60,60, 1, "°")
element_handling[v].fake_right =
anti_aim_2:slider(theme_color()..ui.get_icon("chevron-right").." \aDEFAULTright\
n"..v,0,60,60, 1, "°")
element_handling[v].fake_options = anti_aim_2:selectable("fake options\
n"..v,{"avoid overlap","jitter","randomize jitter","anti bruteforce"})

element_handling[v].cond = anti_aim_3:switch("defensive aa", false,

function(gear)
return {
sens = gear:slider("sensitivity", 0, 100, 75, 1, function(self)
return self .. "%"
end),
pitches = gear:combo("\n"..v, {"disabled", "down", "fake Up", "fake
Down", "random"}),
yaw_mod = gear:combo("\aDEFAULTyaw modifier\n"..v, {"disabled",
"center", "offset", "random", "spin", "3-way", "5-way", "hidden"}),
modifier_degree = gear:slider("\aDEFAULTmodifier degree\n"..v, -
180, 180, 0, 1, "°"),
}
end)

end

menu.rage.builder_elements = element_handling
end

menu.menu_handler()

menu_visibility_handler = function()

local show = menu.main.amnesia_tabs:get() == 1

local show_vis = menu.main.amnesia_tabs:get() == 2
local show_misc = menu.main.amnesia_tabs:get() == 3

menu.rage.state_list:visibility(show)

menu.rage.manual:visibility(show)
menu.rage.select_text_df:visibility(show)
menu.rage.state_list:visibility(show)
menu.rage.safe_head:visibility(show)
menu.rage.anti_back:visibility(show)

--@region ["visual handling"]

menu.visuals.crosshair_ind:visibility(show_vis)
menu.visuals.crosshair_ind.crosshair_color:visibility(show_vis)

menu.visuals.molotov_radius:visibility(show_vis)
menu.visuals.smokes_radius:visibility(show_vis)

menu.visuals.molotov_radius.molotov_color:visibility(show_vis)
menu.visuals.smokes_radius.smoks_color:visibility(show_vis)

menu.visuals.scope:visibility(show_vis)
menu.visuals.vel_inds:visibility(show_vis)
 --@region "end"

--@region ["misc"]
menu.misc.aspect_ratio:visibility(show_misc)
menu.misc.no_fall:visibility(show_misc)
menu.misc.clantag:visibility(show_misc)
menu.misc.magnet:visibility(show_misc)
menu.misc.aim_logs:visibility(show_misc)
--@region "end"

--> custom antiaim

for _, v in pairs(aa_info.conditions) do

local states_list = menu.rage.state_list:get()

local selected = states_list == v

local elements = menu.rage.builder_elements[v]

if show then

elements.enable:visibility(selected)

if elements.enable:get() then
elements.yaw_mode:visibility(selected)

if elements.yaw_mode:get() == "3-way" or elements.yaw_mode:get() ==

"5-way" then
elements.yaw_center_speed:visibility(selected)
elements.yaw_center_speed_info:visibility(selected)
else
elements.yaw_center_speed:visibility(false)
elements.yaw_center_speed_info:visibility(false)
end

if elements.jitter:get() == "3-way" or elements.jitter:get() == "5-

way" then
elements.jitter_speed:visibility(selected)
elements.jitter_speed_info:visibility(selected)
else
elements.jitter_speed:visibility(false)
elements.jitter_speed_info:visibility(false)
end

if elements.yaw_mode:get() == "static" or elements.yaw_mode:get()

== "3-way" or elements.yaw_mode:get() == "5-way" then
elements.yaw_center:visibility(selected)
elements.yaw_left:visibility(false)
elements.yaw_right:visibility(false)
else
elements.yaw_center:visibility(false)
elements.yaw_left:visibility(selected)
elements.yaw_right:visibility(selected)
end

if elements.yaw_mode:get() == "delay" then

elements.aa_speed:visibility(selected)
 else
elements.aa_speed:visibility(false)
end

elements.jitter:visibility(selected)

if elements.jitter:get() ~= "disabled" then

elements.yaw_jitter_ovr:visibility(selected)
else
elements.yaw_jitter_ovr:visibility(false)
end

if elements.limit_random:get() then
elements.fake_left:disabled(true)
elements.fake_right:disabled(true)
else
elements.fake_left:disabled(false)
elements.fake_right:disabled(false)
end

elements.body_yaw:visibility(selected)
elements.fake_left:visibility(selected)
elements.fake_right:visibility(selected)
elements.cond:visibility(selected)
elements.fake_options:visibility(selected)
elements.limit_random:visibility(selected)
else
elements.yaw_mode:visibility(false)
elements.yaw_center:visibility(false)
elements.yaw_left:visibility(false)
elements.yaw_right:visibility(false)
elements.jitter:visibility(false)
elements.fake_left:visibility(false)
elements.fake_right:visibility(false)
elements.cond:visibility(false)
elements.yaw_jitter_ovr:visibility(false)
elements.body_yaw:visibility(false)
elements.aa_speed:visibility(false)
elements.fake_options:visibility(false)
elements.limit_random:visibility(false)
end
else
elements.enable:visibility(false)
elements.yaw_mode:visibility(false)
elements.yaw_center:visibility(false)
elements.yaw_left:visibility(false)
elements.cond:visibility(false)
elements.yaw_right:visibility(false)
elements.jitter:visibility(false)
elements.fake_left:visibility(false)
elements.fake_right:visibility(false)
elements.yaw_jitter_ovr:visibility(false)
elements.body_yaw:visibility(false)
elements.aa_speed:visibility(false)
elements.fake_options:visibility(false)
elements.limit_random:visibility(false)
end
end
end

set_check_tabs = function(ctx)
if menu.main.amnesia_tabs:get() == 1 then
menu.main.tab_label:name("\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[tab] - \r rage")
elseif menu.main.amnesia_tabs:get() == 2 then
menu.main.tab_label:name("\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[tab] - \r visuals")
else
menu.main.tab_label:name("\bFFFFFF\b"..ui.get_style("Link
Active"):to_hex().."[tab] - \r misc")
end
end

local function time_to_ticks(val)

return math.floor(0.5 + (val / globals.tickinterval))
end

local ram = {
prev_simulation_time = 0,
defensive = {},
jit_yaw = 0,
yaw_add = 0,
set_lby = false,
jitter = false,
jit_add = 0,
}

function sim_diff()
local current_simulation_time =
time_to_ticks(entity.get_local_player().m_flSimulationTime)
local diff = current_simulation_time - ram.prev_simulation_time
ram.prev_simulation_time = current_simulation_time
diff_sim = diff
return diff_sim
end

local ref = {
fake_options = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Options"),
autopeek = ui.find("Aimbot", "Ragebot", "Main", "Peek Assist"),
fd = ui.find("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
sw = ui.find("Aimbot", "Anti Aim", "Misc", "Slow Walk"),
dormant = ui.find("Aimbot", "Ragebot", "Main", "Enabled", "Dormant Aimbot"),
pitch = ui.find("Aimbot", "Anti Aim", "Angles", "Pitch"),
yaw = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw"),
base = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Base"),
offset = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Offset"),
yaw_mod = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw Modifier"),
yaw_mod_degree = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw Modifier",
"Offset"),
freestanding = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding"),
free_body = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding", "Body
Freestanding"),
yaw_mod_free = ui.find("Aimbot", "Anti Aim", "Angles", "Freestanding", "Disable
Yaw Modifiers"),
body_yaw = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw"),
inverter = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Inverter"),
left_limit = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Left Limit"),
 right_limit = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Right
Limit"),
options = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Options"),
desync_freestand = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw",
"Freestanding"),
dt = ui.find("Aimbot", "Ragebot", "Main", "Double Tap"),
aaos = ui.find("Aimbot", "Ragebot", "Main", "Hide Shots"),
hidden_cvars = ui.find("Miscellaneous", "Main", "Other", "Unlock Hidden
Cvars"),
air_strafe = ui.find("Miscellaneous", "Main", "Movement", "Air Strafe"),
scope_type = ui.find("Visuals", "World", "Main", "Override Zoom", "Scope
Overlay"),
legmovement = ui.find("Aimbot", "Anti Aim", "Misc", "Leg Movement"),
lag_options = ui.find("Aimbot", "Ragebot", "Main", "Double Tap", "Lag
Options"),
avoid_backstab = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Avoid
Backstab"),
ping_spike = ui.find("Miscellaneous", "Main", "Other", "Fake Latency"),
hidden = ui.find("Aimbot", "Anti Aim", "Angles", "Yaw", "Hidden"),
fl_limit = ui.find("Aimbot", "Anti Aim", "Fake Lag", "Limit"),
dtlim = ui.find("Aimbot", "Ragebot", "Main", "Double Tap", "Fake Lag Limit"),
}

local inverter = ui.find("Aimbot", "Anti Aim", "Angles", "Body Yaw", "Inverter")

local states = {
ground_timer = 0,
lag_timer = 0
}

function states:in_air(a)
if not a then return false end;

local b=a.m_fFlags

local c=bit.band(b,1)~=0;

if c then
if self.ground_timer==5 then
return false
end;

self.ground_timer=self.ground_timer+1

else
self.ground_timer=0
end;

return true
end

function states:is_moving(ent)
local velocity = ent.m_vecVelocity
return math.sqrt(velocity.x * velocity.x + velocity.y * velocity.y) > 2
end

function states:is_crouching(ent)
local ducked = ent.m_bDucked
return ducked
end

function states:team_number(ent)
local team_num = ent.m_iTeamNum
return team_num
end

function states:get_state(ent)
local is_moving = self:is_moving(ent)
local is_crouching = self:is_crouching(ent)
local in_air = self:in_air(ent)
local team_num = ent.m_iTeamNum

if aa.slow:get() then
return "slowmotion"
end

if in_air then
if is_crouching then
return "air crouch"
end

return "air"
end

if is_crouching and is_moving and not in_air then

return "crouch moving"
end

if is_crouching and not in_air then

return "crouch"
end

if is_moving then
return "running"
end

if not is_moving then

return "standing"
end

return "none"
end

local hotkeys = {
manual_last_pressed = globals.realtime
}

local distance = function(x1,y1,z1,x2,y2,z2)

return math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
end

local extrapolate = function(player, ticks, x,y,z)

local vel = player.m_vecVelocity
local new_x = x + globals.tickinterval * vel.x * ticks
local new_y = y + globals.tickinterval * vel.y * ticks
local new_z = z + globals.tickinterval * vel.z * ticks
return new_x, new_y, new_z
end
antibackstabnew = function()
local myself = entity.get_local_player()
local enemy = entity.get_threat(false)
if myself == nil or enemy == nil then return end
local weapon = enemy:get_player_weapon(false)
if myself ~= nil and weapon ~= nil and weapon:get_classname() == "CKnife" then
local e = enemy ~= nil and enemy:get_origin() or vector()
local l = myself:get_origin()
if e.x ~= nil and l.x ~= nil then
for ticks = 1,9 do
local tex, tey, tez = extrapolate(myself,ticks,l.x,l.y,l.z)
local distance = distance(e.x,e.y,e.z,tex,tey,tez)
if math.abs(distance) < 230 then
return true
else
return false
end
end
end
end
end

local function antiaim(arg)

local lp = entity.get_local_player()
if not lp:is_alive() then return end

-- t side = 2 --- ct = 3

local state = states:get_state(lp)

states.state = state

if state == "none" then return end

local builder = menu.rage.builder_elements[state]

if menu.rage.manual:get() == "left" then

hotkeys.manual_state = -90
aa.base:override("local view")
elseif menu.rage.manual:get() == "right" then
hotkeys.manual_state = 90
aa.base:override("local view")
elseif menu.rage.manual:get() == "forward" then
hotkeys.manual_state = 180
aa.base:override("local view")
elseif magnetSwitchHere:get() or magnetSwitch:get() then
aa.base:override("local view")
hotkeys.manual_state = 0
else
aa.base:override("at target")
hotkeys.manual_state = 0
end

--fast_ladder(arg)

local lp_bodyyaw = lp.m_flPoseParameter[11] * 120 - 60

 local yaw_left = builder.yaw_left:get()
local yaw_right = builder.yaw_right:get()

local jit_a = builder.yaw_jitter_ovr:get()

if builder.yaw_mode:get() == "static" then

if builder.yaw_randomize:get() > 0 then
yaw = math.random(builder.yaw_center:get(), builder.yaw_center:get() -
builder.yaw_randomize:get())
else
yaw = builder.yaw_center:get()
end
elseif builder.yaw_mode:get() == "l ~ r" then
if builder.yaw_randomize:get() > 0 then
if lp_bodyyaw <= 0 and globals.choked_commands ~= 0 then
yaw = math.random(yaw_right, yaw_right -
builder.yaw_randomize:get())
elseif lp_bodyyaw >= 0 and globals.choked_commands ~= 0 then
yaw = math.random(yaw_left, yaw_left - builder.yaw_randomize:get())
end
else
if lp_bodyyaw <= 0 and globals.choked_commands ~= 0 then
yaw = yaw_right
elseif lp_bodyyaw >= 0 and globals.choked_commands ~= 0 then
yaw = yaw_left
end
end
elseif builder.yaw_mode:get() == "3-way" then
if builder.yaw_center_speed:get() > 0 then
if(globals.commandack % builder.yaw_center_speed:get() <
(builder.yaw_center_speed:get()/3)) then
if globals.choked_commands == 0 then
yaw = builder.yaw_center:get() / -2
end
elseif(globals.commandack % builder.yaw_center_speed:get() <
(builder.yaw_center_speed:get()/2)) then
if globals.choked_commands == 0 then
yaw = 0
end
elseif(globals.commandack % builder.yaw_center_speed:get() <
(builder.yaw_center_speed:get()/1)) then
if globals.choked_commands == 0 then
yaw = builder.yaw_center:get() / 2
end
end
else
if(globals.commandack % 3 < (3/3)) then
yaw = builder.yaw_center:get() / -2
elseif(globals.commandack % 3 < (3/2)) then
yaw = 0
elseif(globals.commandack % 3 < (3/1)) then
yaw = builder.yaw_center:get() / 2
end
end
elseif builder.yaw_mode:get() == "5-way" then
if (globals.tickcount % 3 == 4) then
yaw = builder.yaw_center:get() / -2
elseif(globals.tickcount % 3 == 3) then
yaw = builder.yaw_center:get() / -2.5
 elseif(globals.tickcount % 3 == 2) then
yaw = 0
elseif(globals.tickcount % 3 == 1) then
yaw = builder.yaw_center:get() / 2.5
elseif(globals.tickcount % 3 == 0) then
yaw = builder.yaw_center:get() / 2
end
elseif builder.yaw_mode:get() == "delay" then
local tick_speed = builder.aa_speed:get()

if builder.aa_speed_randomize:get() > 0 then

tick_speed = math.random(tick_speed, tick_speed -
builder.aa_speed_randomize:get())
else
tick_speed = builder.aa_speed:get()
end

if rage.exploit:get() < 1 then

if builder.yaw_randomize:get() > 0 then
if lp_bodyyaw <= 0 and globals.choked_commands ~= 0 then
yaw = math.random(yaw_right, yaw_right -
builder.yaw_randomize:get())
elseif lp_bodyyaw >= 0 and globals.choked_commands ~= 0 then
yaw = math.random(yaw_left, yaw_left -
builder.yaw_randomize:get())
end
else
if lp_bodyyaw <= 0 and globals.choked_commands ~= 0 then
yaw = yaw_right
elseif lp_bodyyaw >= 0 and globals.choked_commands ~= 0 then
yaw = yaw_left
end
end
elseif globals.commandack % tick_speed < (tick_speed/2) then
if builder.yaw_randomize:get() > 0 then
if globals.choked_commands == 0 then
yaw = math.random(yaw_left, yaw_left -
builder.yaw_randomize:get())
inverter:override(true)
end
else
if globals.choked_commands == 0 then
yaw = yaw_left
inverter:override(true)
end
end
else
if builder.yaw_randomize:get() > 0 then
if globals.choked_commands == 0 then
yaw = math.random(yaw_right, yaw_right -
builder.yaw_randomize:get())
inverter:override(false)
end
else
if globals.choked_commands == 0 then
yaw = yaw_right
inverter:override(false)
end
end
 end
end

local yaw2 = lp_bodyyaw <= 0 and 28 or -9

local yaw3 = lp_bodyyaw <= 0 and 9 or -9
local jitter = jit_a

local team_num = lp.m_iTeamNum

local is_fd = ui.find("Aimbot", "Anti Aim", "Misc", "Fake Duck")

if(sim_diff() < builder.cond.sens:get() / 100 * -1 and ref.dt:get()) then

table.insert(ram.defensive, globals.realtime)
end

local weapon = lp:get_player_weapon(false)

if weapon == nil then return end
local wpnclass = weapon:get_classname()

if menu.rage.select_text_df:get(1) and state == "standing" or

menu.rage.select_text_df:get(2) and state == "running" or
menu.rage.select_text_df:get(3) and state == "slowmotion" or
menu.rage.select_text_df:get(4) and state == "crouch" or
menu.rage.select_text_df:get(5) and state == "crouch moving" or
menu.rage.select_text_df:get(6) and state == "air" or
menu.rage.select_text_df:get(7) and state == "air crouch" then
aa.def:override("Always on")
else
aa.def:override("On peek")
end

local weapon = lp:get_player_weapon(false)

if weapon == nil then return end
local wpnclass = weapon:get_classname()

local tickbasee = lp.m_nTickBase

ref.hidden:set(false)

if magnetSwitch:get() or magnetSwitchHere:get() then

offsetHead()
elseif antibackstabnew() and menu.rage.anti_back:get() then
aa.offset:override(180)
ref.pitch:set("down")
aa.base:override("at target")
aa.jitter:override("disabled")
aa.jitter_val:override(0)
aa.body_yaw[1]:override(false)
aa.body_yaw[3]:override(0)
aa.body_yaw[4]:override(0)
aa.body_yaw[5]:override("disabled")
aa.body_yaw[6]:override("Off")
elseif menu.rage.safe_head:get(1) and state == "air crouch" and
wpnclass:find("Knife") or menu.rage.safe_head:get(2) and state == "air crouch" then
aa.offset:override(hotkeys.manual_state)
ref.pitch:set("Down")
aa.jitter:override("disabled")
aa.jitter_val:override(0)
 aa.body_yaw[1]:override(false)
aa.body_yaw[3]:override(0)
aa.body_yaw[4]:override(0)
aa.body_yaw[5]:override("disabled")
aa.body_yaw[6]:override("Off")
elseif menu.rage.manual:get() ~= "at target" then
aa.offset:override(hotkeys.manual_state)
aa.base:override("local view")
ref.pitch:set("Down")
aa.jitter:override("disabled")
aa.jitter_val:override(0)
aa.body_yaw[1]:override(true)
aa.body_yaw[3]:override(58)
aa.body_yaw[4]:override(58)
aa.body_yaw[5]:override("disabled")
aa.body_yaw[6]:override("Off")
elseif(#ram.defensive > 0 and globals.realtime - ram.defensive[#ram.defensive]
< 1 / 64 * (101 - builder.cond.sens:get()) / 10 and builder.cond:get()) then
aa.base:override("at target")
local dtab = builder.cond
if not ((dtab.yaw_mod:get() == "3-way" or dtab.yaw_mod:get() == "5-way") or
dtab.yaw_mod:get() == "hidden") then
ref.hidden:set(false)
if(dtab.yaw_mod:get() == "disabled") then
ram.jit_yaw = 0
elseif(dtab.yaw_mod:get() == "center") then
ram.jit_yaw = ram.jitter and dtab.modifier_degree:get() / -2 or
dtab.modifier_degree:get() / 2
elseif(dtab.yaw_mod:get() == "offset") then
ram.jit_yaw = ram.jitter and dtab.modifier_degree:get() or 0
elseif(dtab.yaw_mod:get() == "random") then
if(dtab.modifier_degree:get() >= 0) then
ram.jit_yaw = math.random(0,
math.abs(dtab.modifier_degree:get())) - math.abs(dtab.modifier_degree:get()) / 2
else
ram.jit_yaw = (math.random(0,
math.abs(dtab.modifier_degree:get())) - math.abs(dtab.modifier_degree:get()) / 2) *
-1
end
elseif(dtab.yaw_mod:get() == "spin") then
if(dtab.modifier_degree:get() >= 0) then
mult = 1
else
mult = -1
end
if(ram.jit_yaw < math.abs(dtab.modifier_degree:get())) then
ram.jit_yaw = ram.jit_yaw + 3
else
ram.jit_yaw = math.abs(dtab.modifier_degree:get()) * -1 / 2
end
elseif(dtab.yaw_mod:get() == "3-way") then
ref.hidden:set(false)
if(globals.tickcount % 3 == 2) then
ram.jit_yaw = dtab.modifier_degree:get() / -2
elseif(globals.tickcount % 3 == 1) then
ram.jit_yaw = dtab.modifier_degree:get() / 2 - 10
elseif(globals.tickcount % 3 == 0) then
ram.jit_yaw = dtab.modifier_degree:get() / 2
end
 elseif(dtab.yaw_mod:get() == "5-way") then
ref.hidden:set(false)
if(globals.tickcount % 5 == 4) then
ram.jit_yaw = dtab.modifier_degree:get() / -2
elseif(globals.tickcount % 5 == 3) then
ram.jit_yaw = dtab.modifier_degree:get() / -2.5
elseif(globals.tickcount % 5 == 2) then
ram.jit_yaw = dtab.modifier_degree:get() / 2.5
elseif(globals.tickcount % 5 == 1) then
ram.jit_yaw = dtab.modifier_degree:get() / 2 - 10
elseif(globals.tickcount % 5 == 0) then
ram.jit_yaw = dtab.modifier_degree:get() / 2
end
end
aa.offset:override(ram.jit_yaw)
ref.yaw_mod:set("disabled")
ref.yaw_mod_degree:set(0)
else
ref.yaw_mod:set("disabled")
ref.yaw_mod_degree:set(0)
if(dtab.yaw_mod:get() == "hidden") then
ref.hidden:set(true)
end
end
aa.jitter:override(dtab.yaw_mod:get())
if(dtab.pitches:get() ~= "random") then
ref.pitch:set(dtab.pitches:get())
else
pitchs = {"disabled", "down", "fake up", "fake down"}
ref.pitch:set(pitchs[math.random(1, 4)])
end
else
aa.base:override("at target")
--fakelag
ref.pitch:set("down")
aa.offset:override(yaw)
if builder.jitter:get() == "3-way" then
if builder.jitter_speed:get() > 0 then
aa.jitter:override("center")
if(globals.commandack % builder.jitter_speed:get() <
(builder.jitter_speed:get()/3)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / -2)
elseif(globals.commandack % builder.jitter_speed:get() <
(builder.jitter_speed:get()/2)) then
aa.jitter_val:override(0)
elseif(globals.commandack % builder.jitter_speed:get() <
(builder.jitter_speed:get()/1)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / 2)
end
else
aa.jitter:override("3-way")
aa.jitter_val:override(builder.yaw_jitter_ovr:get())
end
elseif builder.jitter:get() == "5-way" then
if builder.jitter_speed:get() > 0 then
aa.jitter:override("center")
if(globals.commandack % builder.jitter_speed:get() <
(builder.jitter_speed:get()/5)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / -2)
 elseif(globals.commandack % builder.jitter_speed:get() <
(builder.jitter_speed:get()/4)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / -2.5)
elseif(globals.commandack % builder.jitter_speed:get() <
(builder.jitter_speed:get()/3)) then
aa.jitter_val:override(0)
elseif(globals.commandack % builder.jitter_speed:get() <
(builder.jitter_speed:get()/2)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / 2.5)
elseif(globals.commandack % builder.jitter_speed:get() <
(builder.jitter_speed:get()/1)) then
aa.jitter_val:override(builder.yaw_jitter_ovr:get() / 2)
end
else
aa.jitter:override("5-way")
aa.jitter_val:override(builder.yaw_jitter_ovr:get())
end
else
aa.jitter:override(builder.jitter:get())
aa.jitter_val:override(builder.yaw_jitter_ovr:get())
end

aa.body_yaw[1]:override(builder.body_yaw:get())
if builder.limit_random:get() then
aa.body_yaw[3]:override(math.random(48,58))
aa.body_yaw[4]:override(math.random(48,58))
else
aa.body_yaw[3]:override(builder.fake_left:get())
aa.body_yaw[4]:override(builder.fake_right:get())
end
if builder.yaw_mode:get() == "delay" then
if rage.exploit:get() < 1 then
aa.body_yaw[5]:override("jitter")
else
aa.body_yaw[5]:override(" ")
end
else
aa.body_yaw[5]:override(builder.fake_options:get())
end
aa.body_yaw[6]:override("off")
end
end

local vel_font = render.load_font("Verdana", 15, "d")

local v_data = {
alpha = 0,
y = 0,
y2 = 0,
}

draw_watermark = function()

local lp = entity.get_local_player()

if not lp or not lp:is_alive() then return end

local x, y = render.screen_size().x/2, render.screen_size().y/2

 render.texture(watermark_icon, vector(x, y - y), vector(x, y),
color(255,255,255, 255), "f", 0)
end

draw_velocity_warning = function()

local lp = entity.get_local_player()

if not lp or not lp:is_alive() then return end

if not menu.visuals.vel_inds:get() then return end

local modifier = entity.get_local_player().m_flVelocityModifier

if modifier == 1 then
speed_mod = false
else
speed_mod = true
end

local x, y = render.screen_size().x/2, render.screen_size().y/2

if speed_mod then
v_data.alpha = math.lerp(v_data.alpha, 255, globals.frametime * 12)
v_data.y = math.lerp(v_data.y, 20, globals.frametime * 12)
v_data.y2 = math.lerp(v_data.y2, 0, globals.frametime * 12)

render.texture(vel_warning, vector(x - x/2, y - y/2 - 220 + v_data.y),

vector(x, y), color(255,255,255, v_data.alpha), "f", 0)
render.text(4, vector(x + 25, y - y/2 - 100 + v_data.y),
color(255,255,255,v_data.alpha), "c+", "velocity is "..math.floor(modifier*100).."%
slower")
else
v_data.alpha = math.lerp(v_data.alpha, 0, globals.frametime * 12)
v_data.y = math.lerp(v_data.y, 0, globals.frametime * 12)
v_data.y2 = math.lerp(v_data.y2, 20, globals.frametime * 12)

render.texture(vel_warning, vector(x - x/2, y - y/2 - 220 + v_data.y),

vector(x, y), color(255,255,255, v_data.alpha), "f", 0)
render.text(4, vector(x + 25, y - y/2 - 100 + v_data.y),
color(255,255,255,v_data.alpha), "c+", "velocity is "..math.floor(modifier*100).."%
slower")
end
end

events.createmove:set(antiaim)

local f, rep = string.format, string.rep;

local logger = {};

logger.id = 0;

logger.hitgroup = {
[ 0 ] = 'generic',
'head',
'chest',
'stomach',
'left arm',
 'right arm',
'left leg',
'right leg',
'neck',
'?',
'gear'
};

logger.state = {
[ 'correction' ] = 'resolver',
[ 'player death' ] = 'enemy death',
[ 'backtrack failure' ] = 'lagcomp failure'
};

logger.verb = {
[ 'knife' ] = 'Knifed',
[ 'inferno' ] = 'Burned',
[ 'hegrenade' ] = 'Naded'
};

logger.bell_pattern = f('\\a%s', rep('%%X', 6));

logger.remove_bell = function(s)
return s:gsub(logger.bell_pattern, '')
end

logger.get_id = function()
return logger.id % (1000 + 1)
end

logger.miss = function(e)
local state = logger.state[ e.state ] or e.state;

print_dev(f(
'\ac95b5b[-] Missed shot at %s in the %s due to %s [hitchance: %d%% |
backtrack: %d ticks]',
e.target:get_name(), logger.hitgroup[ e.wanted_hitgroup ] or '?', state,
e.hitchance, e.backtrack
));

print_raw(f(
'\ac95b5b[-] Missed shot at %s in the %s due to %s [hitchance: %d%% |
backtrack: %d ticks]',
e.target:get_name(), logger.hitgroup[ e.wanted_hitgroup ] or '?', state,
e.hitchance, e.backtrack
));
end

logger.hit = function(e)
print_dev(f(
'\a97B331[+] Hit %s\'s in the %s for %d(%d) (%d remaining), bt = %d, aimed
= %s(%d%%)',
e.target:get_name(), logger.hitgroup[ e.hitgroup ] or '?', e.damage,
e.wanted_damage, e.target.m_iHealth, e.backtrack,
logger.hitgroup[ e.wanted_hitgroup ] or '?', e.hitchance
));

print_raw(f(
'\a97B331[+] Hit %s\'s in the %s for %d(%d) (%d remaining), bt = %d, aimed
= %s(%d%%)',
e.target:get_name(), logger.hitgroup[ e.hitgroup ] or '?', e.damage,
e.wanted_damage, e.target.m_iHealth, e.backtrack,
logger.hitgroup[ e.wanted_hitgroup ] or '?', e.hitchance
));
end

logger.player_hurt = function(e)
local lp = entity.get_local_player();
local userid = entity.get(e.userid, true);
local attacker = entity.get(e.attacker, true);

if attacker ~= lp or userid == lp then

return
end

local verb = logger.verb[ e.weapon ];

if verb == nil then

return
end

print_dev(f(
'\a97B331%s %s for %d damage (%d health remaining)',
verb, userid:get_name(), e.dmg_health, e.health
));

print_raw(f(
'\a97B331 %s %s for %d damage (%d health remaining)',
verb, userid:get_name(), e.dmg_health, e.health
));
end

events.player_connect_full:set(function(e)
local lp = entity.get_local_player();
local userid = entity.get(e.userid, true);

if lp ~= userid then
return
end

logger.id = -1;
end)

events.aim_fire:set(function(e)
logger.id = logger.id + 1;
end)

events.aim_ack:set(function(e)
if not menu.misc.aim_logs:get() then return end

(e.state and logger.miss or logger.hit)(e)

end)

events.player_hurt:set(
logger.player_hurt
)

events.render:set(function(ctx)
 --set_check_tabs()
draw_velocity_warning()
draw_watermark()
if menu.main.amnesia_tabs:get() == 2 then
menu.visuals.gs_inds:visibility(true)
else
menu.visuals.gs_inds:visibility(false)
end
skeet.handle()
skeet.spectators()
indicator_list:visibility(menu.visuals.gs_inds:get())
skeet_spects:visibility(menu.visuals.gs_inds:get())
scope_overlay_handle()
if menu.visuals.crosshair_ind:get() then
crosshair_inds()
end
nade_circle_draw()
menu_visibility_handler()
handle_aspect()
end)

events.bomb_defused:set(function(e)
c4.reset_bomb()
end)
events.bomb_planted:set(function(e)
c4.reset_bomb()
end)
events.bomb_abortplant:set(function(e)
c4.reset_bomb()
end)
events.round_prestart:set(function(e)
c4.reset_bomb()
end)
events.bomb_beginplant:set(function(e)
c4.bomb_beginplant(e)
end)

events.shutdown(function()
--unsetRefs()
target_pos = vector(0,0,0)
end)

events.round_start:set(function(e)
magnetSwitch:set(false)
magnetSwitchHere:set(false)
end)

events.round_end:set(function(e)
magnetSwitch:set(false)
magnetSwitchHere:set(false)
end)

clantag:run()

pui.setup(menu)