utils.

console_exec("clear")

local base64 = require("neverlose/base64")

local clipboard = require("neverlose/clipboard")
local prefix = "[malibu] - "
local JSON = panorama.loadstring([[
return {
stringify: JSON.stringify,
parse: JSON.parse
};
]])()
local function rgbToHex(r, g, b)
r = tostring(r);g = tostring(g);b = tostring(b)
r = (r:len() == 1) and '0'..r or r;g = (g:len() == 1) and '0'..g or g;b =
(b:len() == 1) and '0'..b or b

local rgb = (r * 0x10000) + (g * 0x100) + b

return (r == '00' and g == '00' and b == '00') and '000000' or
string.format('%x', rgb)
end

--local colours.lightblue = '\a'..rgbToHex(181, 209, 255)..'ff' --

database.read('enterprise_color') ~= nil and database.read('enterprise_color') or
rgbToHex(196, 217, 255)

local colours = { -- 255, 110, 75, 255

orange = '\a'..rgbToHex(255, 110, 75)..'ff',
lightblue = '\a'..rgbToHex(181, 209, 255)..'ff',
darkerblue = '\a9AC9FFFF',
steezy = '\a4BF7FFFF',
grey = '\a898989FF',
red = '\aff441fFF',
pink = '\a'..rgbToHex(255,182,193),
pink2 = '\a'..rgbToHex(255,182,193).. 'ff',
default = '\ac8c8c8',
white = '\a'..rgbToHex(255,255,255)..'ff',
}
local username = common.get_username()
local version = "1.9"
local build = "beta"
local function textt()
utils.console_exec("sv lan 1")
utils.console_exec("cam_collision 0")
utils.console_exec("cam_collision 0")
utils.console_exec("playvol \"survival/buy_item_01.wav\" 1")
print(" ▄▄▄▄███▄▄▄▄ ▄████████ ▄█ ▄█ ▀█████████▄ ███ █▄ ")
print(" ▄██▀▀▀███▀▀▀██▄ ███ ███ ███ ███ ███ ███ ███ ███ ")
print(" ███ ███ ███ ███ ███ ███ ███▌ ███ ███ ███ ███ ")
print(" ███ ███ ███ ███ ███ ███ ███▌ ▄███▄▄▄██▀ ███ ███ ")
print(" ███ ███ ███ ▀███████████ ███ ███▌ ▀▀███▀▀▀██▄ ███ ███ ")
print(" ███ ███ ███ ███ ███ ███ ███ ███ ██▄ ███ ███ ")
print(" ███ ███ ███ ███ ███ ███▌ ▄ ███ ███ ███ ███ ███ ")
print(" ▀█ ███ █▀ ███ █▀ █████▄▄██ █▀ ▄█████████▀ ████████▀ ")
print(" ▀ ")
print(" ")
print_raw(colours.pink..prefix..colours.default..string.format("welcome
"..colours.pink.."%s"..colours.default.." to malibu beta < build:
"..colours.pink.."%s"..colours.default.." > < version:
"..colours.pink.."%s"..colours.default.." >", username, build, version))
 print_raw(colours.pink..prefix..colours.default,"If you have any questions,
please open a "..colours.pink.."ticket"..colours.default.." or ask another
"..colours.pink.."user"..colours.default.." in our discord!")
end
utils.execute_after(0.1, textt)

local refs = {
dt = ui.find("aimbot", "ragebot", "main", "double tap"),
hs = ui.find("aimbot", "ragebot", "main", "hide shots"),
dmg = ui.find("aimbot", "ragebot", "selection", "minimum damage"),
pitch = ui.find("aimbot", "anti aim", "angles", "pitch"),
yaw = ui.find("aimbot", "anti aim", "angles", "yaw"),
modifier = ui.find("aimbot", "anti aim", "angles", "Yaw Modifier"),
bodyyaw = ui.find("aimbot", "anti aim", "angles", "body yaw"),

fakelagenable = ui.find("aimbot", "anti aim", "fake lag", "enabled"),

fakelaglimit = ui.find("aimbot", "anti aim", "fake lag", "limit"),

baim = ui.find("aimbot", "ragebot", "safety", "Body Aim"),

safe = ui.find("aimbot", "ragebot", "safety", "safe points"),

-- body yaw
yawmodifieradd = ui.find("aimbot", "anti aim", "angles", "Yaw Modifier",
"offset"),
yawbase = ui.find("aimbot", "anti aim", "angles", "yaw", "base"),
yawadd = ui.find("aimbot", "anti aim", "angles", "yaw", "offset"),
inverter = ui.find("aimbot", "anti aim", "angles", "body yaw", "inverter"),
leftlimit = ui.find("aimbot", "anti aim", "angles", "body yaw", "left limit"),
rightlimit = ui.find("aimbot", "anti aim", "angles", "body yaw", "right
limit"),
options = ui.find("aimbot", "anti aim", "angles", "body yaw", "options"),
freestanding = ui.find("aimbot", "anti aim", "angles", "body yaw",
"freestanding"),
onshot = ui.find("aimbot", "anti aim", "angles", "body yaw", "on shot"),
lbymode = ui.find("aimbot", "anti aim", "angles", "body yaw", "lby mode"),
--
freestand = ui.find("aimbot", "anti aim", "angles", "Freestanding"), -- one
slowwalk = ui.find("Aimbot", "Anti Aim", "Misc", "Slow Walk"),
removescope = ui.find("Visuals", "World", "Main", "Override Zoom", "Scope
Overlay")
}

local aa_init = { }
local vars = {
p_states = {"standing", "moving", "slowwalk", "air", "ducking", "air-
crouching", "fakelag"},
s_to_int = {["air-crouching"] = 6,["fakelag"] = 7, ["standing"] = 1, ["moving"]
= 2, ["slowwalk"] = 3, ["air"] = 4, ["ducking"] = 5},
player_states = {"S", "M", "SW", "A", "C", "AC", "FL"},
state_to_int = {["AC"] = 6,["FL"] = 7, ["S"] = 1, ["M"] = 2, ["SW"] = 3, ["A"]
= 4, ["C"] = 5},
p_state = 1,
aa_dir = 0
}
local mode = ""

local url =
"https://github.com/ryanbleach/hahalme/blob/c8854d7d02ed5da84b3441538f12dac6a9050af
2/newlogo.png?raw=true"
local function main()
local antiaim_global = ui.create("Anti-aim","Anti-aim")
local antiaim_enable = antiaim_global:switch("enable
"..colours.pink2.."malibu"..colours.default.." antiaim", false)
local antiaim_presets = antiaim_global:combo("anti-aim presets", "dynamic",
"alternative","custom")
local antiaim_attarget = antiaim_global:combo("at-target anti-aim", "at
target", "local view")
local antiaim_yawjitter = antiaim_global:combo("anti-aim yaw jitter",
"prefered", "center", "offset")
-- air stand/slow
local antiaim_standing = antiaim_global:combo("standing anti-aim", "jitter",
"static")
local antiaim_slowwalk = antiaim_global:combo("slowwalk anti-aim", "jitter",
"static")
local antiaim_air = antiaim_global:combo("in-air anti-aim", "risky", "safe")
local antiaim_antibruteforce = antiaim_global:switch("anti-bruteforce")

local antiaim_preventfreestanding = antiaim_global:selectable("prevent

freestanding on", "crouch", "in-air", "moving")
local antiaim_preventjitteratlow = antiaim_global:switch("prevent high jitter
at lower velocity", false)
local antiaim_epeek = antiaim_global:hotkey("legit anti-aim on key", 0x45)
-----------------------------------------------------------------------------------
---
local antiaim_global = ui.create("Anti-aim","Builder")
local neverlosecondit = antiaim_global:combo("Builder", "standing", "running",
"slowwalk", "in-air","ducking","air duck")

local conditions = {
--neverlosecondit = Menu.Combo("Anti-aim »","Conditions", "Conditions",
{"standing", "moving", "slow walk", "air","crouch"}, 0),
-- Standing

--sinv = Menu.Switch("Anti-aim »","Conditions", "[S] Inverter", false),

sleftadd = antiaim_global:slider("[S] Yaw Add Left", -180, 180, 0),
srightadd = antiaim_global:slider("[S] Yaw Add Right", -180, 180, 0),
syawmod = antiaim_global:combo("[S] Yaw Modifier", "Disabled", "Center",
"Offset"),
syawmod2 = antiaim_global:slider("[S] Modifier Degree", -180, 180, 0),
sleft = antiaim_global:slider("[S] Left Limit", 0, 60, 0),
sright = antiaim_global:slider("[S] Right Limit", 0, 60, 0),
sbodyyaw = antiaim_global:switch("[S] Body yaw", false),
sfkopt = antiaim_global:selectable("[S] Options", "Avoid Overlap",
"Jitter"),
sfr = antiaim_global:combo("[S] Freestanding", "Off", "Peek Fake", "Peek
Real"),
sdes = antiaim_global:combo("[S] On-shot", "Default", "Opposite",
"Freestanding", "Switch"),
slby = antiaim_global:combo("[S] LBY mode", "Disabled", "Opposite",
"Sway"),
-- Walking
wleftadd = antiaim_global:slider("[W] Yaw Add Left", -180, 180, 0),
wrightadd = antiaim_global:slider("[W] Yaw Add Right", -180, 180, 0),
wyawmod = antiaim_global:combo("[W] Yaw Modifier", "Disabled", "Center",
"Offset"),
wyawmod2 = antiaim_global:slider("[W] Modifier Degree", -180, 180, 0),
wleft = antiaim_global:slider("[W] Left Limit", 0, 60, 0),
wright = antiaim_global:slider("[W] Right Limit", 0, 60, 0),
 wbodyyaw = antiaim_global:switch("[W] Body yaw", false),
wfkopt = antiaim_global:selectable("[W] Options", "Avoid Overlap",
"Jitter"),
wfr = antiaim_global:combo("[W] Freestanding", "Off", "Peek Fake", "Peek
Real"),
wdes = antiaim_global:combo("[W] On-shot", "Default", "Opposite",
"Freestanding", "Switch"),
wlby = antiaim_global:combo("[W] LBY mode", "Disabled", "Opposite",
"Sway"),
-- Slow Walking
--swinv = Menu.Switch("Anti-aim »","Conditions", "[SW] Inverter", false),
swleftadd = antiaim_global:slider("[SW] Yaw Add Left", -180, 180, 0),
swrightadd = antiaim_global:slider("[SW] Yaw Add Right", -180, 180, 0),
swyawmod = antiaim_global:combo("[SW] Yaw Modifier", "Disabled", "Center",
"Offset"),
swyawmod2 = antiaim_global:slider("[SW] Modifier Degree", -180, 180, 0),
swleft = antiaim_global:slider("[SW] Left Limit", 0, 60, 0),
swright = antiaim_global:slider("[SW] Right Limit", 0, 60, 0),
swbodyyaw = antiaim_global:switch("[SW] Body yaw", false),
swfkopt = antiaim_global:selectable("[SW] Options", "Avoid Overlap",
"Jitter"),
swfr = antiaim_global:combo("[SW] Freestanding", "Off", "Peek Fake", "Peek
Real"),
swdes = antiaim_global:combo("[SW] On-shot", "Default", "Opposite",
"Freestanding", "Switch"),
swlby = antiaim_global:combo("[SW] LBY mode", "Disabled", "Opposite",
"Sway"),
-- Air
--ainv = Menu.Switch("Anti-aim »","Conditions", "[A] Inverter", false),
aleftadd = antiaim_global:slider("[A] Yaw Add Left", -180, 180, 0),
arightadd = antiaim_global:slider("[A] Yaw Add Right", -180, 180, 0),
ayawmod = antiaim_global:combo("[A] Yaw Modifier", "Disabled", "Center",
"Offset"),
ayawmod2 = antiaim_global:slider("[A] Modifier Degree", -180, 180, 0),
aleft = antiaim_global:slider("[A] Left Limit", 0, 60, 0),
aright = antiaim_global:slider("[A] Right Limit", 0, 60, 0),
abodyyaw = antiaim_global:switch("[A] Body yaw", false),
afkopt = antiaim_global:selectable("[A] Options", "Avoid Overlap",
"Jitter"),
afr = antiaim_global:combo("[A] Freestanding", "Off", "Peek Fake", "Peek
Real"),
ades = antiaim_global:combo("[A] On-shot", "Default", "Opposite",
"Freestanding", "Switch"),
alby = antiaim_global:combo("[A] LBY mode", "Disabled", "Opposite",
"Sway"),
-- crouch air
--cainv = Menu.Switch("Anti-aim »","Conditions", "Inverter", false),
caleftadd = antiaim_global:slider("[CA] Yaw Add Left", -180, 180, 0),
carightadd = antiaim_global:slider("[CA] Yaw Add Right", -180, 180, 0),
cayawmod = antiaim_global:combo("[CA] Yaw Modifier", "Disabled", "Center",
"Offset"),
cayawmod2 = antiaim_global:slider("[CA] Modifier Degree", -180, 180, 0),
caleft = antiaim_global:slider("[CA] Left Limit", 0, 60, 0),
caright = antiaim_global:slider("[CA] Right Limit", 0, 60, 0),
cabodyyaw = antiaim_global:switch("[CA] Body yaw", false),
cafkopt = antiaim_global:selectable("[CA] Options", "Avoid Overlap",
"Jitter"),
cafr = antiaim_global:combo("[CA] Freestanding", "Off", "Peek Fake", "Peek
Real"),
 cades = antiaim_global:combo("[CA] On-shot", "Default", "Opposite",
"Freestanding", "Switch"),
calby = antiaim_global:combo("[CA] LBY mode", "Disabled", "Opposite",
"Sway"),
-- crouch
--cinv = Menu.Switch("Anti-aim »","Conditions", "[C] Inverter", false),
cleftadd = antiaim_global:slider("[C] Yaw Add Left", -180, 180, 0),
crightadd = antiaim_global:slider("[C] Yaw Add Right", -180, 180, 0),
cyawmod = antiaim_global:combo("[C] Yaw Modifier", "Disabled", "Center",
"Offset"),
cyawmod2 = antiaim_global:slider("[C] Modifier Degree", -180, 180, 0),
cleft = antiaim_global:slider("[C] Left Limit", 0, 60, 0),
cright = antiaim_global:slider("[C] Right Limit", 0, 60, 0),
cbodyyaw = antiaim_global:switch("[C] Body yaw", false),
cfkopt = antiaim_global:selectable("[C] Options", "Avoid Overlap",
"Jitter"),
cfr = antiaim_global:combo("[C] Freestanding", "Off", "Peek Fake", "Peek
Real"),
cdes = antiaim_global:combo("[C] On-shot", "Default", "Opposite",
"Freestanding", "Switch"),
clby = antiaim_global:combo("[C] LBY mode", "Disabled", "Opposite",
"Sway"),
}
-----------------------------------------------------------------------------------
-------------------------------------------
local visual_global = ui.create("Misc","Visuals")
local visual_enable = visual_global:switch("enable
"..colours.pink2.."malibu"..colours.default.." visuals", false)
local visual_indicators = visual_global:combo("enable indicators",
"default","alternative")
local visual_indicators_color = visual_global:color_picker("accent colour")
local visual_indicators_color2 = visual_global:color_picker("second accent
colour")
local visual_mindmg = visual_global:switch("enable min damage indicator",
false)
local visual_killsay = visual_global:switch("enable killsay", false)
local visual_clantag = visual_global:switch("enable clantag", false)
local visual_watermark = visual_global:switch("enable watermark", false)
local visual_debugpanel = visual_global:switch("enable debug panel", false)

-----------------------------------------------------------------------------------
-------------------------------------------
local global_global = ui.create("Misc","General")
local global_doubletap = global_global:switch("enable
"..colours.pink2.."malibu"..colours.default.." global")
local global_doubletapspeed = global_global:switch("automatic doubletap speed")
local global_doubletapspeed_slider = global_global:slider("doubletap speed",
14, 18, 16, 1,false)
local global_detailedshotlogger= global_global:switch("detailed shot logger")
local global_disablefakelag = global_global:selectable("disable fakelag on",
"hide shots", "double tap")
local global_customscope = global_global:switch("enable custom scope")
local global_customscopeoffset = global_global:slider("custom scope offset",
300, 1000, 300, 1,false)
local global_customscopelength = global_global:slider("custom scope length",
500, 2000, 900, 1,false)
local global_customscopecolour = global_global:color_picker("colour")
local global_customscopecolour2 = global_global:color_picker("second colour")
local cfg_data = {
bools = {
-- switches
antiaim_enable,
antiaim_antibruteforce,
antiaim_preventjitteratlow,
visual_enable,
visual_mindmg,
visual_killsay,
visual_watermark,
visual_clantag,
visual_debugpanel,
global_doubletap,
global_doubletapspeed,
global_detailedshotlogger,
global_customscope,

conditions.sbodyyaw,
conditions.wbodyyaw,
conditions.swbodyyaw,
conditions.abodyyaw,
conditions.cbodyyaw,
conditions.cabodyyaw
},

ints = {
-- combos/multis
antiaim_presets,
antiaim_attarget,
antiaim_yawjitter,
antiaim_standing,
antiaim_slowwalk,
antiaim_air,
antiaim_preventfreestanding,
visual_indicators,
global_doubletapspeed_slider,
global_disablefakelag,
global_customscopeoffset,
global_customscopelength,
--antiaim_epeek

neverlosecondit,
conditions.sleftadd,
conditions.srightadd,
conditions.syawmod,
conditions.syawmod2,
conditions.sleft,
conditions.sright,
conditions.sfkopt,
conditions.sfr,
conditions.sdes,
conditions.slby,
--
conditions.wleftadd,
conditions.wrightadd,
conditions.wyawmod,
conditions.wyawmod2,
 conditions.wleft,
conditions.wright,
conditions.wfkopt,
conditions.wfr,
conditions.wdes,
conditions.wlby,
--
conditions.swleftadd,
conditions.swrightadd,
conditions.swyawmod,
conditions.swyawmod2,
conditions.swleft,
conditions.swright,
conditions.swfkopt,
conditions.swfr,
conditions.swdes,
conditions.swlby,
--
conditions.aleftadd,
conditions.arightadd,
conditions.ayawmod,
conditions.ayawmod2,
conditions.aleft,
conditions.aright,
conditions.afkopt,
conditions.afr,
conditions.ades,
conditions.alby,
--
conditions.cleftadd,
conditions.crightadd,
conditions.cyawmod,
conditions.cyawmod2,
conditions.cleft,
conditions.cright,
conditions.cfkopt,
conditions.cfr,
conditions.cdes,
conditions.clby,
--
conditions.caleftadd,
conditions.carightadd,
conditions.cayawmod,
conditions.cayawmod2,
conditions.caleft,
conditions.caright,
conditions.cafkopt,
conditions.cafr,
conditions.cades,
conditions.calby,
},
floats = {
--ui.my_sliderfloat
},

strings = {
--ui.my_textbox
},
 colors = {
--ui.my_color_switch,
--ui.my_color_edit
--ui.color,
-- ui.colorsecond
}

global_global:button("export config to clipboard", function()

print("config has been exported to clipboard.")

local Code = {{}, {}, {}, {}, {}}

for _, bools in pairs(cfg_data.bools) do

table.insert(Code[1], bools:get())
end

for _, ints in pairs(cfg_data.ints) do

table.insert(Code[2], ints:get())
end

for _, floats in pairs(cfg_data.floats) do

--table.insert(Code[3], floats:get())
end

for _, strings in pairs(cfg_data.strings) do

--table.insert(Code[4], strings:get())
end

for _, colors in pairs(cfg_data.colors) do

--local clr = colors:get()
--table.insert(Code[5], string.format("%02X%02X%02X%02X",
math.floor(clr.r * 255), math.floor(clr.g * 255), math.floor(clr.b * 255),
math.floor(clr.a * 255)))
end

clipboard.set(base64.encode(JSON.stringify(Code)))
end)

global_global:button("import config from clipboard", function()

print("config has been imported from clipboard.")

for k, v in pairs(JSON.parse(base64.decode(clipboard.get()))) do

k = ({[1] = "bools", [2] = "ints", [3] = "floats", [4] = "strings", [5]

= "colors"})[k]

for k2, v2 in pairs(v) do

if (k == "bools") then
cfg_data[k][k2]:set(v2)
end

if (k == "ints") then
cfg_data[k][k2]:set(v2)
 end
if (k == "floats") then
--cfg_data[k][k2]:set(v2)
end

if (k == "strings") then
--cfg_data[k][k2]:set(v2)
end

if (k == "colors") then
--cfg_data[k][k2]:set(Color.new(tonumber("0x"..v2:sub(1,
2))/255, tonumber("0x"..v2:sub(3, 4))/255, tonumber("0x"..v2:sub(5, 6))/255,
tonumber("0x"..v2:sub(7, 8))/255))
end
end
end
end)

function default()
-- switch
antiaim_enable:set(true)
antiaim_antibruteforce:set(true)
antiaim_preventjitteratlow:set(true)
visual_enable:set(true)
visual_mindmg:set(true)
visual_watermark:set(true)
visual_debugpanel:set(true)
global_doubletap:set(true)
global_doubletapspeed:set(true)
global_detailedshotlogger:set(true)
-- ints
antiaim_presets:set("dynamic")
antiaim_attarget:set("at target")
antiaim_yawjitter:set("prefered")
antiaim_standing:set("jitter")
antiaim_slowwalk:set("jitter")
antiaim_air:set("risky")
antiaim_preventfreestanding:set({"in-air", "crouch"})
visual_indicators:set("default")
global_disablefakelag:set("hide shots")
end
global_global:button("load default config", function()

print("loaded default config")

default()
end)
global_global:button("join discord", function()
panorma.open().SteamOverlayAPI.OpenExternalBrowserURL("https://discord.gg/
qn72UPpZse")
print("If the popup didnt open use this link:
https://discord.gg/qn72UPpZse")
end)

local start_curtime = globals.curtime

antiaimlegitaa_time = 0
antiaimcheck = false
local function legitaa(cmd)
 local local_player = entity.get_local_player()
if not common.is_button_down(0x45) then antiaimlegitaa_time = globals.realtime
refs.pitch:set("down") end
if antiaim_epeek:get() then
if common.is_button_down(0x45) and not off_legit_aa then
local C4 = entity.get_entities(129);
for C4i = 1, #C4 do
defuse = local_player:get_origin():dist(C4[C4i]:get_origin()) <
100
end
local plant = local_player.m_bInBombZone
local host = local_player.m_bIsGrabbingHostage

if defuse or (weapon_id == 49 and plant) or host then

antiaimcheck = true
else
antiaimcheck = false
end

if not antiaimcheck then

--print("aa")
--state_aa = 'legit aa'
refs.pitch:set("disabled")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(0)
else
refs.yawadd:set(0)
end

refs.yawmodifieradd:set(0)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("Avoid Overlap")
refs.freestanding:set("Peek fake")
refs.onshot:set("Opposite")
refs.lbymode:set("Opposite")

end

end
end
end

local customaav = function()

local neverlose = antiaim_presets:get() == "custom"
--print(ui.antiaim_modes:GetInt())
local s = neverlosecondit:get() == "standing"
local w = neverlosecondit:get() == "running"
local sw = neverlosecondit:get() == "slowwalk"
local a = neverlosecondit:get() == "in-air"
local ca = neverlosecondit:get() == "air duck"
local c = neverlosecondit:get() == "ducking"
if neverlose then
neverlosecondit:set_visible(neverlose)
conditions.sleftadd:set_visible(s)
conditions.srightadd:set_visible(s)
conditions.syawmod:set_visible(s)
conditions.syawmod2:set_visible(s)
conditions.sleft:set_visible(s)
conditions.sright:set_visible(s)
conditions.sbodyyaw:set_visible(s)
conditions.sfkopt:set_visible(s)
conditions.slby:set_visible(s)
conditions.sfr:set_visible(s)
conditions.sdes:set_visible(s)
conditions.wleftadd:set_visible(w)
conditions.wrightadd:set_visible(w)
conditions.wyawmod:set_visible(w)
conditions.wyawmod2:set_visible(w)
conditions.wleft:set_visible(w)
conditions.wright:set_visible(w)
conditions.wbodyyaw:set_visible(w)
conditions.wfkopt:set_visible(w)
conditions.wlby:set_visible(w)
conditions.wfr:set_visible(w)
conditions.wdes:set_visible(w)
conditions.swleftadd:set_visible(sw)
conditions.swrightadd:set_visible(sw)
conditions.swyawmod:set_visible(sw)
conditions.swyawmod2:set_visible(sw)
conditions.swleft:set_visible(sw)
conditions.swright:set_visible(sw)
conditions.swbodyyaw:set_visible(sw)
conditions.swfkopt:set_visible(sw)
conditions.swlby:set_visible(sw)
conditions.swfr:set_visible(sw)
conditions.swdes:set_visible(sw)
conditions.aleftadd:set_visible(a)
conditions.arightadd:set_visible(a)
conditions.ayawmod:set_visible(a)
conditions.ayawmod2:set_visible(a)
conditions.aleft:set_visible(a)
conditions.aright:set_visible(a)
conditions.abodyyaw:set_visible(a)
conditions.afkopt:set_visible(a)
conditions.alby:set_visible(a)
conditions.afr:set_visible(a)
conditions.ades:set_visible(a)
conditions.caleftadd:set_visible(ca)
conditions.carightadd:set_visible(ca)
conditions.cayawmod:set_visible(ca)
conditions.cayawmod2:set_visible(ca)
conditions.caleft:set_visible(ca)
conditions.caright:set_visible(ca)
conditions.cabodyyaw:set_visible(ca)
conditions.cafkopt:set_visible(ca)
conditions.calby:set_visible(ca)
conditions.cafr:set_visible(ca)
conditions.cades:set_visible(ca)
conditions.cleftadd:set_visible(c)
conditions.crightadd:set_visible(c)
conditions.cyawmod:set_visible(c)
conditions.cyawmod2:set_visible(c)
conditions.cleft:set_visible(c)
conditions.cright:set_visible(c)
 conditions.cbodyyaw:set_visible(c)
conditions.cfkopt:set_visible(c)
conditions.clby:set_visible(c)
conditions.cfr:set_visible(c)
conditions.cdes:set_visible(c)
else
neverlosecondit:set_visible(neverlose)
conditions.sleftadd:set_visible(false)
conditions.srightadd:set_visible(false)
conditions.syawmod:set_visible(false)
conditions.syawmod2:set_visible(false)
conditions.sleft:set_visible(false)
conditions.sright:set_visible(false)
conditions.sbodyyaw:set_visible(false)
conditions.sfkopt:set_visible(false)
conditions.slby:set_visible(false)
conditions.sfr:set_visible(false)
conditions.sdes:set_visible(false)
conditions.wleftadd:set_visible(false)
conditions.wrightadd:set_visible(false)
conditions.wyawmod:set_visible(false)
conditions.wyawmod2:set_visible(false)
conditions.wleft:set_visible(false)
conditions.wright:set_visible(false)
conditions.wbodyyaw:set_visible(false)
conditions.wfkopt:set_visible(false)
conditions.wlby:set_visible(false)
conditions.wfr:set_visible(false)
conditions.wdes:set_visible(false)
conditions.swleftadd:set_visible(false)
conditions.swrightadd:set_visible(false)
conditions.swyawmod:set_visible(false)
conditions.swyawmod2:set_visible(false)
conditions.swleft:set_visible(false)
conditions.swright:set_visible(false)
conditions.swbodyyaw:set_visible(false)
conditions.swfkopt:set_visible(false)
conditions.swlby:set_visible(false)
conditions.swfr:set_visible(false)
conditions.swdes:set_visible(false)
conditions.aleftadd:set_visible(false)
conditions.arightadd:set_visible(false)
conditions.ayawmod:set_visible(false)
conditions.ayawmod2:set_visible(false)
conditions.aleft:set_visible(false)
conditions.aright:set_visible(false)
conditions.abodyyaw:set_visible(false)
conditions.afkopt:set_visible(false)
conditions.alby:set_visible(false)
conditions.afr:set_visible(false)
conditions.ades:set_visible(false)
conditions.caleftadd:set_visible(false)
conditions.carightadd:set_visible(false)
conditions.cayawmod:set_visible(false)
conditions.cayawmod2:set_visible(false)
conditions.caleft:set_visible(false)
conditions.caright:set_visible(false)
conditions.cabodyyaw:set_visible(false)
conditions.cafkopt:set_visible(false)
 conditions.calby:set_visible(false)
conditions.cafr:set_visible(false)
conditions.cades:set_visible(false)
conditions.cleftadd:set_visible(false)
conditions.crightadd:set_visible(false)
conditions.cyawmod:set_visible(false)
conditions.cyawmod2:set_visible(false)
conditions.cleft:set_visible(false)
conditions.cright:set_visible(false)
conditions.cbodyyaw:set_visible(false)
conditions.cfkopt:set_visible(false)
conditions.clby:set_visible(false)
conditions.cfr:set_visible(false)
conditions.cdes:set_visible(false)
end
end

events.player_death:set(function(e)

local phrases = {"1"}

local function get_phrase()

return phrases[Utils.RandomInt(1, #phrases)]:gsub('\"', '')
end

if visual_killsay:get() then
local me = entity.get_local_player()
local victim = entity.get("userid",true)
local attacker = entity.get("attacker", true)

if victim == attacker or attacker ~= me then return end

utils.console_exec('say "' .. get_phrase() .. '"')

end

end)

local function get_velocity(player)

local player = entity.get_local_player()
local x,y,z = player.m_vecVelocity[0]
if x == nil then return end
return (x*0.5 + y*0.5 + z*0.5)
end
local function in_air(player)
local player = entity.get_local_player()
local flags = player.m_fFlags
if bit.band(flags, 1) == 0 then
return true
end
return false
end
local mode = ""
local function antiaim(c)
local player = entity.get_local_player()
local bodyyaw = player.m_flPoseParameter[11] * 120 - 60
local side = bodyyaw > 0 and 1 or -1
local crouch = common.is_button_down(0x11)
local velocity = player.m_vecVelocity
local speed = velocity:length()
local p_still = speed < 1.2
local on_ground = not in_air()
if refs.dt:get() and refs.hs:get() and speed > 1.2 then
vars.p_state = 7 -- fakelag
elseif crouch and on_ground then
vars.p_state = 5 -- crouch
elseif crouch and not on_ground then
vars.p_state = 6 -- crouch in air
elseif not on_ground then
vars.p_state = 4 -- air
elseif refs.slowwalk:get() then
vars.p_state = 3 -- slowwalk
elseif speed < 1.2 then
vars.p_state = 1 -- standing
elseif speed > 1.2 then
vars.p_state = 2 -- MOVING
end
--print(antiaim_attarget:get())
if antiaim_attarget:get() == "at target" then
refs.yawbase:set("at target")
else
refs.yawbase:set("local view")
end
if antiaim_yawjitter:get() == "prefered" then
if vars.p_state == 1 then
if antiaim_standing:get() == "jitter" then
refs.modifier:set("center")
elseif antiaim_standing:get() == "static" then
refs.modifier:set("disabled")
end
elseif vars.p_state == 2 then
-- moving
refs.modifier:set("center")
elseif vars.p_state == 3 then
-- slowwalk
if antiaim_slowwalk:get() == "jitter" then
refs.modifier:set("center")
elseif antiaim_slowwalk:get() == "static" then
refs.modifier:set("disabled")
end
elseif vars.p_state == 4 then
-- air
refs.modifier:set("center")
elseif vars.p_state == 5 then
-- crouch
refs.modifier:set("center")
elseif vars.p_state == 6 then
-- in air crouch
if antiaim_air:get() == "risky" then
refs.modifier:set("center")
elseif antiaim_air:get() == "safe" then
refs.modifier:set("disabled") -- safe no jitter
end
end
elseif antiaim_yawjitter:get() == "center" then
refs.modifier:set("center")
elseif antiaim_yawjitter:get() == "offset" then
refs.modifier:set("offset")
end
 if refs.freestand:get() then
if antiaim_preventfreestanding:get(2) then
if vars.p_states == 2 then
refs.freestand:set(false)
end
--elseif "crouch" then
elseif antiaim_preventfreestanding:get(1) then
if vars.p_states == 4 or vars.p_states == 6 then
refs.freestand:set(false)
end
elseif antiaim_preventfreestanding:get(0) then
if vars.p_states == 5 then
refs.freestand:set(false)
end
end
end

if antiaim_presets:get() == "dynamic" then

if vars.p_state == 1 then -- was left ahdn right
-- standing
mode = "STANDING"
if antiaim_standing:get() == "jitter" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(0)
else
refs.yawadd:set(0)
end

refs.yawmodifieradd:set(18)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("Avoid Overlap")
refs.freestanding:set("Off")
refs.onshot:set("Opposite")
refs.lbymode:set("disabled")
elseif antiaim_standing:get() == "static" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(-7)
else
refs.yawadd:set(-7)
end
refs.yawmodifieradd:set(0)
refs.bodyyaw:set(true)
refs.leftlimit:set(0)
refs.rightlimit:set(60)
refs.options:set("")
refs.freestanding:set("peek fake")
refs.onshot:set("freestanding")
refs.lbymode:set("sway")
end
elseif vars.p_state == 2 then
if antiaim_preventjitteratlow:get() and speed > 1.2 and speed < 150
then
mode = "LOW JITTER"
 -- moving
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(15)
else
refs.yawadd:set(-15)
end
--[[if side == 1 then
refs.yawadd:set(-15) -- right
else
-refs.yawadd:set(12)
end--]]
refs.yawmodifieradd:set(-36)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("opposite")
refs.lbymode:set("disabled")
else
mode = "RUNNING"
-- moving
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(0)
else
refs.yawadd:set(-9)
end
--[[if side == 1 then
refs.yawadd:set(-15) -- right
else
refs.yawadd:set(12)
end--]]
refs.yawmodifieradd:set(-47)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("opposite")
refs.lbymode:set("disabled")
end
elseif vars.p_state == 3 then
-- slowwalk
mode = "SLOW-WALK"
if antiaim_slowwalk:get() == "jitter" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(-15)
else
refs.yawadd:set(15)
end
--[[if side == 1 then
refs.yawadd:set(-15)
else
 refs.yawadd:set(15)
end--]]
refs.yawmodifieradd:set(50)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("opposite")
refs.lbymode:set("disabled")
elseif antiaim_slowwalk:get() == "static" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(4)
else
refs.yawadd:set(4)
end
refs.yawmodifieradd:set(-74)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("disabled")
end
elseif vars.p_state == 4 then
-- air
mode = "AIR"
if antiaim_air:get() == "risky" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(0)
else
refs.yawadd:set(0)
end
refs.yawmodifieradd:set(0)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set({"Avoid Overlap","jitter"})
refs.freestanding:set("off")
refs.onshot:set("opposite")
refs.lbymode:set("disabled")
elseif antiaim_air:get() == "safe" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(5)
else
refs.yawadd:set(5)
end
refs.yawmodifieradd:set(0)
refs.bodyyaw:set(false)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
 refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("opposite")
end
elseif vars.p_state == 5 then
-- crouch
mode = "CROUCH"
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(0)
else
refs.yawadd:set(0)
end
--[[if side == 1 then
refs.yawadd:set(-11) -- right
else
refs.yawadd:set(7)
end--]]
refs.yawmodifieradd:set(0)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set({"Avoid Overlap","jitter"})
refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("disabled")
elseif vars.p_state == 6 then
-- in air crouch
mode = "C-AIR"
if antiaim_air:get() == "risky" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(0)
else
refs.yawadd:set(0)
end
--[[if side == 1 then
refs.yawadd:set(-10)
else
refs.yawadd:set(7)
end--]]
refs.yawmodifieradd:set(0)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set({"Avoid Overlap","jitter"})
refs.freestanding:set("off")
refs.onshot:set("opposite")
refs.lbymode:set("opposite")
elseif antiaim_air:get() == "safe" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(5)
else
refs.yawadd:set(5)
end
 refs.yawmodifieradd:set(0)
refs.bodyyaw:set(false)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("opposite")
end
end
elseif antiaim_presets:get() == "alternative" then
if vars.p_state == 1 then
-- standing
mode = "STANDING"
if antiaim_standing:get() == "jitter" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(-5)
else
refs.yawadd:set(9)
end
refs.yawmodifieradd:set(35)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("peek fake")
refs.onshot:set("freestanding")
refs.lbymode:set("disabled")
elseif antiaim_standing:get() == "static" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(-7)
else
refs.yawadd:set(-7)
end
refs.yawmodifieradd:set(0)
refs.bodyyaw:set(true)
refs.leftlimit:set(0)
refs.rightlimit:set(60)
refs.options:set("")
refs.freestanding:set("peek fake")
refs.onshot:set("freestanding")
refs.lbymode:set("sway")
end
elseif vars.p_state == 2 then
if antiaim_preventjitteratlow:get() and speed > 1.2 and speed < 150
then
mode = "LOW JITTER"
-- moving
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(-23)
else
refs.yawadd:set(20)
end
 refs.yawmodifieradd:set(36)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("switch")
refs.lbymode:set("disabled")
else
mode = "RUNNING"
-- moving
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(-23)
else
refs.yawadd:set(20)
end
refs.yawmodifieradd:set(36)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("switch")
refs.lbymode:set("disabled")
end
elseif vars.p_state == 3 then
-- slowwalk
mode = "SLOW-WALK"
if antiaim_slowwalk:get() == "jitter" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(-15)
else
refs.yawadd:set(15)
end
refs.yawmodifieradd:set(50)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("opposite")
refs.lbymode:set("opposite")
elseif antiaim_slowwalk:get() == "static" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(4)
else
refs.yawadd:set(4)
end
refs.yawmodifieradd:set(-74)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
 refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("disabled")
end
elseif vars.p_state == 4 then
-- air
mode = "AIR"
if antiaim_air:get() == "risky" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(8)
else
refs.yawadd:set(14)
end
refs.yawmodifieradd:set(63)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("opposite")
elseif antiaim_air:get() == "safe" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(5)
else
refs.yawadd:set(5)
end
refs.yawmodifieradd:set(0)
refs.bodyyaw:set(false)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("opposite")
end
elseif vars.p_state == 5 then
-- crouch
mode = "CROUCH"
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(-7)
else
refs.yawadd:set(-7)
end
refs.yawmodifieradd:set(-54)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("opposite")
elseif vars.p_state == 6 then
 -- in air crouch
mode = "C-AIR"
if antiaim_air:get() == "risky" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(8)
else
refs.yawadd:set(14)
end
refs.yawmodifieradd:set(35)
refs.bodyyaw:set(true)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("opposite")
elseif antiaim_air:get() == "safe" then
refs.pitch:set("down")
refs.yaw:set("backward")
if side == 1 then
refs.yawadd:set(5)
else
refs.yawadd:set(5)
end
refs.yawmodifieradd:set(0)
refs.bodyyaw:set(false)
refs.leftlimit:set(60)
refs.rightlimit:set(60)
refs.options:set("jitter")
refs.freestanding:set("off")
refs.onshot:set("default")
refs.lbymode:set("opposite")
end
end
elseif antiaim_presets:get() == "custom" then
refs.pitch:set("Down")
refs.yaw:set("backward")
if vars.p_state == 1 then
mode = "STANDING"
if side == 1 then
refs.yawadd:set(conditions.srightadd:get())
else
refs.yawadd:set(conditions.sleftadd:get())
end
refs.modifier:set(conditions.syawmod:get())
refs.yawmodifieradd:set(conditions.syawmod2:get())
refs.bodyyaw:set(conditions.sbodyyaw:get())
refs.leftlimit:set(conditions.sleft:get())
refs.rightlimit:set(conditions.sright:get())
refs.options:set(conditions.sfkopt:get())
refs.freestanding:set(conditions.sfr:get())
refs.onshot:set(conditions.sdes:get())
refs.lbymode:set(conditions.slby:get())
elseif vars.p_state == 2 then
mode = "RUNNING"
if side == 1 then
refs.yawadd:set(conditions.wrightadd:get())
 else
refs.yawadd:set(conditions.wleftadd:get())
end
refs.modifier:set(conditions.wyawmod:get())
refs.yawmodifieradd:set(conditions.wyawmod2:get())
refs.bodyyaw:set(conditions.wbodyyaw:get())
refs.leftlimit:set(conditions.wleft:get())
refs.rightlimit:set(conditions.wright:get())
refs.options:set(conditions.wfkopt:get())
refs.freestanding:set(conditions.wfr:get())
refs.onshot:set(conditions.wdes:get())
refs.lbymode:set(conditions.wlby:get())
elseif vars.p_state == 3 then
mode = "SLOW-WALK"
if side == 1 then
refs.yawadd:set(conditions.swrightadd:get())
else
refs.yawadd:set(conditions.swleftadd:get())
end
refs.modifier:set(conditions.swyawmod:get())
refs.yawmodifieradd:set(conditions.swyawmod2:get())
refs.bodyyaw:set(conditions.swbodyyaw:get())
refs.leftlimit:set(conditions.swleft:get())
refs.rightlimit:set(conditions.swright:get())
refs.options:set(conditions.swfkopt:get())
refs.freestanding:set(conditions.swfr:get())
refs.onshot:set(conditions.swdes:get())
refs.lbymode:set(conditions.swlby:get())
elseif vars.p_state == 4 then
mode = "AIR"
if side == 1 then
refs.yawadd:set(conditions.arightadd:get())
else
refs.yawadd:set(conditions.aleftadd:get())
end
refs.modifier:set(conditions.ayawmod:get())
refs.yawmodifieradd:set(conditions.ayawmod2:get())
refs.bodyyaw:set(conditions.abodyyaw:get())
refs.leftlimit:set(conditions.aleft:get())
refs.rightlimit:set(conditions.aright:get())
refs.options:set(conditions.afkopt:get())
refs.freestanding:set(conditions.afr:get())
refs.onshot:set(conditions.ades:get())
refs.lbymode:set(conditions.alby:get())
elseif vars.p_state == 5 then
-- crouch
mode = "CROUCH"
if side == 1 then
refs.yawadd:set(conditions.crightadd:get())
else
refs.yawadd:set(conditions.cleftadd:get())
end
refs.modifier:set(conditions.cyawmod:get())
refs.yawmodifieradd:set(conditions.cyawmod2:get())
refs.bodyyaw:set(conditions.cbodyyaw:get())
refs.leftlimit:set(conditions.cleft:get())
refs.rightlimit:set(conditions.cright:get())
refs.options:set(conditions.cfkopt:get())
refs.freestanding:set(conditions.cfr:get())
 refs.onshot:set(conditions.cdes:get())
refs.lbymode:set(conditions.clby:get())
elseif vars.p_state == 6 then
-- in air duck
mode = "C-AIR"
if side == 1 then
refs.yawadd:set(conditions.carightadd:get())
else
refs.yawadd:set(conditions.caleftadd:get())
end
refs.modifier:set(conditions.cayawmod:get())
refs.yawmodifieradd:set(conditions.cayawmod2:get())
refs.bodyyaw:set(conditions.cabodyyaw:get())
refs.leftlimit:set(conditions.caleft:get())
refs.rightlimit:set(conditions.caright:get())
refs.options:set(conditions.cafkopt:get())
refs.freestanding:set(conditions.cafr:get())
refs.onshot:set(conditions.cades:get())
refs.lbymode:set(conditions.calby:get())
end
end
--if c.chokedcommands ~= 0 then
--else
-- ui.set(ref.yaw[2],(side == 1 and -5 or 9)) -- lefgt and right
--end
--ui.set(ref.fakeyawlimit, 60)
end
local function indicators()
local screensize = render.screen_size() * 0.5
local scrx, scry = screensize, screensize
local local_player = entity.get_local_player()
if not local_player or not local_player:is_alive() then
return
end
--add_x = animations.anim_new('m_bIsScoped add 1', local_player.m_bIsScoped
and 40 or 0)
local round = function(value, multiplier) local multiplier = 10 ^
(multiplier or 0); return math.floor(value * multiplier + 0.5) / multiplier end
local body_yaw = math.abs(math.max(-58, math.min(58,
math.floor((local_player.m_flPoseParameter[12] or 0) * 120 - 60 + 0.5, 1))))
body_yaw = (body_yaw < 1 and body_yaw > 0.0001) and math_floor(body_yaw, 1)
or body_yaw
local abs_yaw = math.abs(body_yaw)
local desync = rage.antiaim:get_max_desync()
if visual_enable:get() then
if visual_indicators:get() == "default" then
render.text(2, vector(screensize.x, screensize.y + 30),
color(255,255,255,255),"c", "MALIBU")
render.text(2, vector(screensize.x, screensize.y + 38),
color(255,255,255,255),"c", string.format("%s",round(desync)),"°")
if refs.dt:get() then
render.text(2, vector(screensize.x, screensize.y + 48),
color(255,255,255,255),"c", "DT")
elseif refs.hs:get() then
render.text(2, vector(screensize.x, screensize.y + 48),
color(255,255,255,255),"c", "HS")
end
 if refs.dt:get() or refs.hs:get() then
if refs.baim:get() == "Force" then
render.text(2, vector(screensize.x , screensize.y + 56),
color(255,255,255,255),"c", "BAIM")
else
render.text(2, vector(screensize.x , screensize.y + 56),
color(255,255,255,65),"c", "BAIM")
end
if refs.safe:get() == "Force" then
render.text(2, vector(screensize.x -17 , screensize.y +
56), color(255,255,255,255),"c", "SP")
else
render.text(2, vector(screensize.x -17, screensize.y + 56),
color(255,255,255,65),"c", "SP")
end
if refs.freestand:get() then
render.text(2, vector(screensize.x +17, screensize.y + 56),
color(255,255,255,255),"c", "FS")
else
render.text(2, vector(screensize.x +17 , screensize.y +
56), color(255,255,255,65),"c", "FS")
end
else -- if not dt or hs
if refs.baim:get() == "Force" then
render.text(2, vector(screensize.x , screensize.y + 48),
color(255,255,255,255),"c", "BAIM")
else
render.text(2, vector(screensize.x , screensize.y + 48),
color(255,255,255,65),"c", "BAIM")
end
if refs.safe:get() == "Force" then
render.text(2, vector(screensize.x- 17 , screensize.y +
48), color(255,255,255,255),"c", "SP")
else
render.text(2, vector(screensize.x- 17 , screensize.y +
48), color(255,255,255,65),"c", "SP")
end
if refs.freestand:get() then
render.text(2, vector(screensize.x+ 17 , screensize.y +
48), color(255,255,255,255),"c", "FS")
else
render.text(2, vector(screensize.x+ 17 , screensize.y +
48), color(255,255,255,65),"c", "FS")
end
end
elseif visual_indicators:get() == "alternative" then
--print("this isnt made yet give me some ideas")
-- render.text(2, vector(screensize.x , screensize.y + 30),
color(255,255,255,65),"c", "not finished.")
end

if visual_watermark:get() then

local text = string.format("MALIBU BETA | USER:

[ "..colours.pink2.."%s"..colours.white.." ] | BUILD:
[ "..colours.pink2.."%s"..colours.white.." ] | VERSION:
[ "..colours.pink2.."%s"..colours.white.." ]", string.upper(username),
string.upper(build), version)
render.text(2, vector(screensize.x+ 17 , screensize.y + 530),
color(255,255,255,255),"cs", text)
end
if visual_debugpanel:get() then
local isactive = refs.dt:get() or refs.hs:get()
local target = entity.get_threat(false)
if target == nil then return end
local thealth = target.m_iHealth or "0"
render.text(1, vector(screensize.x- 950 , screensize.y + 0),
color(255,255,255,255),"s", string.format("malibu.lua - "..colours.pink2.."%s",
string.lower(username)))
render.text(1, vector(screensize.x- 950 , screensize.y + 10),
color(255,255,255,255),"s", string.format("version: "..colours.pink2.."%s",
string.lower(version)))
render.text(1, vector(screensize.x- 950 , screensize.y + 20),
color(255,255,255,255),"s", string.format("exploit active: "..colours.pink2.."%s",
isactive and "true" or "false"))
render.text(1, vector(screensize.x- 950 , screensize.y + 30),
color(255,255,255,255),"s", string.format("desync amount: "..colours.pink2.."%s",
round(desync)))
render.text(1, vector(screensize.x- 950 , screensize.y + 40),
color(255,255,255,255),"s", string.format("target:
"..colours.pink2.."%s"..colours.white.."
["..colours.pink2.."%s"..colours.white.."]",
string.lower(target:get_name()),thealth))
render.text(1, vector(screensize.x- 950 , screensize.y + 50),
color(255,255,255,255),"s", string.format("antiaim: "..colours.pink2.."%s",
string.lower(mode)))
end

if visual_mindmg:get() then
local hehehe = refs.dmg:get()
--Render.Text(string.format("%s", hehehe),
Vector2.new(screen_size.x +0, screen_size.y - 36), Color.RGBA(255, 200, 0, 255),
10, pixel, true, true)
if hehehe < 10 then
render.text(2, vector(screensize.x + 20 , screensize.y - 30),
color(255,255,255,255),"s", "DMG")
end
end
local scope_line = {}
scope_line.anim_num = 0
local hitler = {}

hitler.lerp = function(start, vend, time)

return start + (vend - start) * time
end
if global_customscope:get() then
refs.removescope:set("Remove all") -- scopeline

local local_player = entity.get_local_player()

local state = (not local_player or not local_player:is_alive() or

not local_player.m_bIsScoped)

scope_line.anim_num = hitler.lerp(scope_line.anim_num, state and 0

or 255, 0.095)

local alpha = scope_line.anim_num / 255

 scope_line.offset = global_customscopeoffset:get() * alpha
scope_line.length = global_customscopelength:get() * alpha
scope_line.width = 1
scope_line.col_1 = color(255,255,255,255)
scope_line.col_2 = color(255,255,255,255)

scope_line.start_x = screensize.x
scope_line.start_y = screensize.y

--Left
--render.gradient(vector(scope_line.start_x - scope_line.offset,
scope_line.start_y), vector(scope_line.start_x - scope_line.offset -
scope_line.length, scope_line.start_y + scope_line.width),scope_line.col_1,
scope_line.col_2, scope_line.col_1, scope_line.col_2)
render.gradient(vector(scope_line.start_x - scope_line.offset,
scope_line.start_y), vector(scope_line.start_x - scope_line.offset -
scope_line.length, scope_line.start_y + scope_line.width), color(255,255,255,255),
color(255,255,255,5),color(255,255,255,255), color(255,255,255,5))

--Right
render.gradient(vector(scope_line.start_x + scope_line.offset,
scope_line.start_y), vector(scope_line.start_x + scope_line.offset +
scope_line.length, scope_line.start_y + scope_line.width), color(255,255,255,255),
color(255,255,255,5),color(255,255,255,255), color(255,255,255,5))

--Up
render.gradient(vector(scope_line.start_x, scope_line.start_y +
scope_line.offset), vector(scope_line.start_x + scope_line.width,
scope_line.start_y + scope_line.offset + scope_line.length),
color(255,255,255,255), color(255,255,255,255), color(255,255,255,5),
color(255,255,255,5))

--Down
render.gradient(vector(scope_line.start_x, scope_line.start_y -
scope_line.offset), vector(scope_line.start_x + scope_line.width,
scope_line.start_y - scope_line.offset - scope_line.length),
color(255,255,255,255),color(255,255,255,255), color(255,255,255,5),
color(255,255,255,5))

end

if global_doubletapspeed:get() and global_doubletap:get() then

global_doubletapspeed_slider:set_visible(false)
--if ui.doubletapautospeed:GetBool() then
--Exploits.OverrideDoubleTapSpeed(16)
--else
--
Exploits.OverrideDoubleTapSpeed(ui.doubletapspeedslider:GetInt())
--end
--print(doubletapspeedslider:GetInt())
else
--Exploits.OverrideDoubleTapSpeed(16)
global_doubletapspeed_slider:set_visible(true)
end
end
end
 local function global()
local screensize = render.screen_size() * 0.5
local scrx, scry = screensize, screensize
local local_player = entity.get_local_player()
if not local_player or not local_player:is_alive() then
return
end
--add_x = animations.anim_new('m_bIsScoped add 1', local_player.m_bIsScoped
and 40 or 0)
local round = function(value, multiplier) local multiplier = 10 ^
(multiplier or 0); return math.floor(value * multiplier + 0.5) / multiplier end
--print(global_disablefakelag:get_name())
if global_disablefakelag:get() == "hide shots" then

--print("hs")
if refs.hs:get() then
refs.fakelagenable:set(false)
refs.fakelaglimit:set(1)
else
refs.fakelagenable:set(true)
refs.fakelaglimit:set(14)
end
elseif global_disablefakelag:get() == "double tap" then
--print("dt")
if refs.dt:get() then
refs.fakelagenable:set(false)
refs.fakelaglimit:set(1)
else
refs.fakelagenable:set(true)
refs.fakelaglimit:set(14)
end
end
end

local helpers = {

clantag_cache = "",

clantag_fn = ffi.cast('int(__fastcall*)(const char*, const char*)',

utils.opcode_scan('engine.dll', '53 56 57 8B DA 8B F9 FF 15')),

set_clantag = function (self, tag)

if tag ~= self.clantag_cache then
self.clantag_fn(tag, tag)

self.clantag_cache = tag
end
end,
}
local clantag_restore = false
local function clantag()
local localplayer = entity.get_local_player()
if not localplayer then return end

if visual_clantag:get() then
local tag =
{
 " m- ",
" ma ",
" ma- ",
" mal ",
" mal- ",
" mali ",
" mali- ",
" malib ",
" malib- ",
" malibu ",
" malibu- ",
" malibu. ",
" malibu.- ",
" malibu.l ",
" malibu.l- ",
" malibu.lu ",
" malibu.lu- ",
" malibu.lua ",
" malibu.lua ",
" ",
}

local netchann_info = utils.net_channel()

if netchann_info == nil then

return
end

local latency = netchann_info.latency[0] / globals.server_tick

local tickcount_pred = globals.tickcount + latency
local iter = math.floor(math.fmod(tickcount_pred / 16, #tag) + 1)

helpers:set_clantag(tag[iter])
clantag_restore = false

elseif not clantag_restore then

helpers:set_clantag("")
end

end

local hitgroup_str = {
[0] = 'generic',
'head', 'chest', 'stomach',
'left arm', 'right arm',
'left leg', 'right leg',
'neck', 'generic', 'gear'
}
events.player_hurt:set(function(e)
local me = entity.get_local_player()
local attacker = entity.get(e.attacker, true)

if me == attacker then
local user = entity.get(e.userid, true)
local hitgroup = hitgroup_str[e.hitgroup]
local backtrack = tostring(e.backtrack or 0)
print_raw(colours.pink..prefix,string.format(colours.default.."hit <
"..colours.pink.."%s"..colours.default.." > in <
"..colours.pink.."%s"..colours.default.." > for <
"..colours.pink.."%s"..colours.default.." > damage | backtrack <
"..colours.pink.."%s"..colours.default.." > remain <
"..colours.pink.."%s"..colours.default.." >", user:get_name(), hitgroup,
e.dmg_health, backtrack, e.health))
end
end)

events.aim_ack:set(function(e)
local round = function(value, multiplier) local multiplier = 10 ^
(multiplier or 0); return math.floor(value * multiplier + 0.5) / multiplier end
local hitgroup = hitgroup_str[e.wanted_hitgroup]
if global_detailedshotlogger:get() then
if e.state == nil then return
else

print_raw(colours.pink..prefix,string.format(colours.default.."missed <
"..colours.pink.."%s"..colours.default.." > in <
"..colours.pink.."%s"..colours.default.." > for <
"..colours.pink.."%s"..colours.default.." > | reason: <
"..colours.pink.."%s"..colours.default.." > ",e.target:get_name(), hitgroup,
e.wanted_damage, e.state))
end
end

end)

local function handlers()

events.render:set(indicators)
events.render:set(global)
events.render:set(clantag)
events.createmove:set(antiaim)
events.render:set(customaav)
events.createmove:set(customaav)
events.createmove:set(legitaa)
end
handlers()
end
main()