local menu = require("oop_menu")

if not MENU_LIB_ERROR_OUTDATED then

return error("Outdated \"Object-oriented gui\" lib.")
elseif MENU_LIB_VER < 1.1 then
return MENU_LIB_ERROR_OUTDATED()
end

function table.find(t, value)

for _, v in pairs(t) do
if v == value then
return true
end
end
return false
end

function math.clamp(v, min, max)

return v < min and min or v > max and max or v
end

function math.calc_fov(Start, End, Angle)

local Direction = (End - Start):normalize()
local Forward, Right, Up = math.angle_vectors(Angle)
return math.max(math.deg(math.acos(Forward:dot(Direction))), 0)
end

local function SetAllVisible(t, v)

for _, element in pairs(t) do
if element and element.set_visible then
element:set_visible(v)
end
end
end

local function MenuElementName(p, n)

return string.format("[%s] %s", p, n)
end

local References =
{
Pitch = menu.get_reference("rage>anti-aim>angles>pitch"),
Yaw = menu.get_reference("rage>anti-aim>angles>yaw"),
YawAdd = menu.get_reference("rage>anti-aim>angles>yaw add"),
YawAddValue = menu.get_reference("rage>anti-aim>angles>add"),
FreeStand = menu.get_reference("rage>anti-aim>angles>freestand"),
AtFOVTarget = menu.get_reference("rage>anti-aim>angles>at fov target"),
Spin = menu.get_reference("rage>anti-aim>angles>spin"),
SpinRange = menu.get_reference("rage>anti-aim>angles>spin range"),
SpinSpeed = menu.get_reference("rage>anti-aim>angles>spin speed"),
Jitter = menu.get_reference("rage>anti-aim>angles>jitter"),
RandomJitter = menu.get_reference("rage>anti-aim>angles>random"),
JitterRange = menu.get_reference("rage>anti-aim>angles>jitter range"),
AntiAimOverride = menu.get_reference("rage>anti-aim>angles>antiaim
override"),
Back = menu.get_reference("rage>anti-aim>angles>back"),
Left = menu.get_reference("rage>anti-aim>angles>left"),
Right = menu.get_reference("rage>anti-aim>angles>right"),
 Fake = menu.get_reference("rage>anti-aim>desync>fake"),
FakeAmount = menu.get_reference("rage>anti-aim>desync>fake amount"),
CompensateAngle = menu.get_reference("rage>anti-aim>desync>compensate
angle"),
FreestandFake = menu.get_reference("rage>anti-aim>desync>freestand
fake"),
FlipFakeWithJitter = menu.get_reference("rage>anti-aim>desync>flip fake with
jitter"),
LegSlide = menu.get_reference("rage>anti-aim>desync>leg slide"),
RollLean = menu.get_reference("rage>anti-aim>desync>roll lean"),
LeanAmount = menu.get_reference("rage>anti-aim>desync>lean amount"),
EnsureLean = menu.get_reference("rage>anti-aim>desync>ensure lean"),
FlipLeanWithJitter = menu.get_reference("rage>anti-aim>desync>flip lean with
jitter"),
}
SetAllVisible(References, false)

local ExtraRefs =
{
FakeDuck = menu.get_reference("misc>movement>fake duck"),
Slide = menu.get_reference("misc>movement>slide")
}

local AAStates = {"General", "Standing", "Crouching", "Fake duck", "Moving",

"Accelerating", "Slow walk", "In air", "In air crouch", "In air knife", "Taser",
"Enemy missed"}
local AAStateCombo = menu.add_combo("AA State", "rage>anti-aim>angles", AAStates)

local AAStateMenuElements = {}
for i, State in pairs(AAStates) do

local function FormatStateName(n)

return MenuElementName(State, n)
end

local NewTable =
{
OverrideGeneralConfig = (i ~= 1) and
menu.add_checkbox(FormatStateName((State:len() >= 12) and "Override general" or
"Override general config"), "rage>anti-aim>angles"),
CrouchOnly = (State == "In air knife") and
menu.add_checkbox(FormatStateName("Crouching only"), "rage>anti-aim>angles"),
FovThreshhold = (State == "Enemy missed") and
menu.add_slider(FormatStateName("Fov threshhold"), "rage>anti-aim>angles", 0, 90,
1),
HoldTime = (State == "Enemy missed") and
menu.add_slider(FormatStateName("Hold time (MS)"), "rage>anti-aim>angles", 500,
3000, 1),
Pitch = menu.add_combo(FormatStateName("Pitch"),
"rage>anti-aim>angles", References.Pitch:get_combo_items()),
Yaw = menu.add_combo(FormatStateName("Yaw"),
"rage>anti-aim>angles", References.Yaw:get_combo_items()),
YawAdd = menu.add_checkbox(FormatStateName("Yaw add"),
"rage>anti-aim>angles"),
YawAddValue = menu.add_slider(FormatStateName("Add"),
"rage>anti-aim>angles", -180, 180, 1),
AtFOVTarget = menu.add_checkbox(FormatStateName("At fov
target"), "rage>anti-aim>angles"),
Spin = menu.add_checkbox(FormatStateName("Spin"),
"rage>anti-aim>angles"),
SpinRange = menu.add_slider(FormatStateName("Range"),
"rage>anti-aim>angles", 0, 360, 1),
SpinSpeed = menu.add_slider(FormatStateName("Speed"),
"rage>anti-aim>angles", 0, 360, 1),
Jitter = menu.add_checkbox(FormatStateName("Jitter"),
"rage>anti-aim>angles"),
JitterRange = menu.add_slider(FormatStateName("Range "),
"rage>anti-aim>angles", 0, 360, 1),
RandomJitter = menu.add_checkbox(FormatStateName("Random
jitter"), "rage>anti-aim>angles"),
JitterFreeze = menu.add_checkbox(FormatStateName("Jitter
freeze"), "rage>anti-aim>angles"),
HoldChance = menu.add_slider(FormatStateName("Freeze chance"),
"rage>anti-aim>angles", 10, 95, 1),
Fake = menu.add_checkbox(FormatStateName("Fake"),
"rage>anti-aim>desync"),
FakeAmount = menu.add_slider(FormatStateName("Amount"),
"rage>anti-aim>desync", -100, 100, 1),
CompensateAngle = menu.add_slider(FormatStateName("Compensate
angle"), "rage>anti-aim>desync", 0, 100, 1),
RandomFake = menu.add_combo(FormatStateName("Random fake"),
"rage>anti-aim>desync", {"Off", "Random value", "Random side"}),
FreestandFake = menu.add_combo(FormatStateName("Freestand fake"),
"rage>anti-aim>desync", References.FreestandFake:get_combo_items()),
FlipFakeWithJitter = menu.add_checkbox(FormatStateName("Flip fake with
jitter"), "rage>anti-aim>desync"),
LegSlide = menu.add_combo(FormatStateName("Leg slide"),
"rage>anti-aim>desync", References.LegSlide:get_combo_items()),
RollLean = menu.add_combo(FormatStateName("Roll"),
"rage>anti-aim>desync", References.RollLean:get_combo_items()),
LeanAmount = menu.add_slider(FormatStateName("Amount "),
"rage>anti-aim>desync", -100, 100, 1),
FlipLeanWithJitter = menu.add_checkbox(FormatStateName("Flip roll with
jitter"), "rage>anti-aim>desync"),
Callbacks = {}
}

local function BindVisible(a, b, custom_compare)

if not a or not b then
utils.error_print("Cannot bind visible. %s %s", tostring(a),
tostring(b))
return
end

local cb = function ()
local Value = b:get()
local ActiveState = AAStates[AAStateCombo:get() + 1] == State

if custom_compare then
a:set_visible(custom_compare(Value) and ActiveState)
else
a:set_visible(Value and ActiveState)
end
end

b:add_callback(cb)
table.insert(NewTable.Callbacks, cb)
utils.run_delayed(500, cb)
 end

local JitterFreezeFunc = function (v)

return v and NewTable.JitterFreeze:get()
end

BindVisible(NewTable.YawAddValue, NewTable.YawAdd)
BindVisible(NewTable.SpinRange, NewTable.Spin)
BindVisible(NewTable.SpinSpeed, NewTable.Spin)
BindVisible(NewTable.RandomJitter, NewTable.Jitter)
BindVisible(NewTable.JitterRange, NewTable.Jitter)
BindVisible(NewTable.JitterFreeze, NewTable.Jitter)
BindVisible(NewTable.HoldChance, NewTable.Jitter, JitterFreezeFunc)
BindVisible(NewTable.HoldChance, NewTable.JitterFreeze, JitterFreezeFunc)
BindVisible(NewTable.FakeAmount, NewTable.Fake)
BindVisible(NewTable.CompensateAngle, NewTable.Fake)
BindVisible(NewTable.FreestandFake, NewTable.Fake)
BindVisible(NewTable.FlipFakeWithJitter, NewTable.Fake)
BindVisible(NewTable.LeanAmount, NewTable.RollLean, function (v) return v ~= 0
end)
BindVisible(NewTable.FlipLeanWithJitter, NewTable.RollLean, function (v) return
v ~= 0 end)

AAStateMenuElements[State] = NewTable
end

AAStateCombo:add_callback(function (value)
for StateName, Elements in pairs(AAStateMenuElements) do
SetAllVisible(Elements, AAStates[value + 1] == StateName)

for _, Callback in pairs(Elements.Callbacks) do

if Callback then
Callback()
end
end
end
end, true)

local FreestandOverride = menu.add_checkbox("Freestand ", "rage>anti-

aim>angles")
local ClampFreestandingJitter = menu.add_checkbox("Freestand clamp jitter",
"rage>anti-aim>angles")

local AntiAimOverride = menu.add_checkbox("Antiaim override ", "rage>anti-

aim>angles")
local Back = menu.add_checkbox("Back ", "rage>anti-aim>angles")
local Left = menu.add_checkbox("Left ", "rage>anti-aim>angles")
local Right = menu.add_checkbox("Right ", "rage>anti-aim>angles")
local EnsureLean = menu.add_checkbox("Ensure lean ", "rage>anti-aim>desync")

-- Do this so they are at the bottom of everything

menu.add_keybind(FreestandOverride)
menu.add_keybind(Back)
menu.add_keybind(Left)
menu.add_keybind(Right)
menu.add_keybind(EnsureLean)

References.FreeStand:bind_to(FreestandOverride)
References.AntiAimOverride:bind_to(AntiAimOverride)

AntiAimOverride:add_callback(function (v)
Back:set_visible(v)
Left:set_visible(v)
Right:set_visible(v)
end, true)

References.Back:bind_to(Back)
References.Left:bind_to(Left)
References.Right:bind_to(Right)
References.EnsureLean:bind_to(EnsureLean)

local OnGroundTicks = 1
local OldSpeed = 0
local EnemyMissedTime = 0
local CustomJitterSwitch = 1

local function IsOvr(state)

local Elements = AAStateMenuElements[state]
return Elements.OverrideGeneralConfig ~= nil and
Elements.OverrideGeneralConfig:get()
end

local DrawAAState = false

local CurrentState = "General"

function on_setup_move(cmd)

local LocalPlayer = entities[engine.get_local_player()]

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

local State = "General"

local Buttons = cmd:get_buttons()
local OnGround = bit.band(LocalPlayer:get_prop("m_fFlags") or 0, 1) ==
1
local Velocity = math.vec3(LocalPlayer:get_prop("m_vecVelocity[0]") or
0, LocalPlayer:get_prop("m_vecVelocity[1]") or 0,
LocalPlayer:get_prop("m_vecVelocity[2]") or 0)
local Speed = Velocity:length2d()
local FakeDucking = ExtraRefs.FakeDuck:get() == 1
local Crouching = bit.band(Buttons, csgo.in_duck) ~= 0
local SlowWalking = ExtraRefs.Slide:get() == 1
local ActiveWeapon = LocalPlayer:get_weapon()
local WeaponInfo = ActiveWeapon and
utils.get_weapon_info(ActiveWeapon:get_prop("m_iItemDefinitionIndex") or -1)

if OnGround then
OnGroundTicks = OnGroundTicks + 1
else
OnGroundTicks = 0
end

if IsOvr("Enemy missed") and global_vars.realtime - EnemyMissedTime <

AAStateMenuElements["Enemy missed"].HoldTime:get() / 1000 then
State = "Enemy missed"
elseif WeaponInfo and WeaponInfo.console_name == "weapon_taser" and
IsOvr("Taser") then
State = "Taser"
elseif FakeDucking and IsOvr("Fake duck") then
State = "Fake duck"
else
-- In air
if OnGroundTicks <= 1 then
if Crouching and IsOvr("In air crouch") then
State = "In air crouch"
else
State = "In air"
end

if IsOvr("In air knife") and ActiveWeapon then

if WeaponInfo then
if string.find(WeaponInfo.console_name, "knife_") then
if AAStateMenuElements["In air knife"].CrouchOnly:get()
then
if Crouching then
State = "In air knife"
end
else
State = "In air knife"
end
end
end
end
-- On ground
else
if Crouching and IsOvr("Crouching") then
State = "Crouching"
elseif SlowWalking and IsOvr("Slow walk") then
State = "Slow walk"
elseif Speed - OldSpeed > 2 and IsOvr("Accelerating") then
State = "Accelerating"
elseif Speed > 5 then
State = "Moving"
else
State = "Standing"
end
end
end
OldSpeed = Speed

local Settings = AAStateMenuElements[State]

if Settings.OverrideGeneralConfig and not Settings.OverrideGeneralConfig:get()
then
State = "General"
Settings = AAStateMenuElements["General"]
end

CurrentState = State

for ItemName, Item in pairs(Settings) do

if References[ItemName] and Item then
References[ItemName]:set(Item:get())
end
end
 local RandomFake = Settings.RandomFake:get()
if RandomFake == 1 then
References.FakeAmount:set(utils.random_int(-100, 100))
elseif RandomFake == 2 then
References.FakeAmount:set(References.FakeAmount:get() *
(utils.random_int(0, 1) == 0 and 1 or -1))
end

if FreestandOverride:get() and ClampFreestandingJitter:get() then

References.JitterRange:set(math.clamp(References.JitterRange:get(), 0, 30))
end

-- Cant jitter while defusing cuz retarded valve feature

if Settings.Jitter:get() and Settings.JitterFreeze:get() and not
LocalPlayer:get_prop("m_bIsDefusing") then
References.Jitter:set(false)
local HadYawAdd = References.YawAdd:get() == 1
References.YawAdd:set(true)
References.YawAddValue:set((HadYawAdd and References.YawAddValue:get() or
0) + (References.JitterRange:get() / 2) * CustomJitterSwitch)

if info.fatality.lag_ticks == 0 and utils.random_int(0, 100) <= (100 -

Settings.HoldChance:get()) then
CustomJitterSwitch = -CustomJitterSwitch
end
end
end

function on_player_hurt(event)
local Hurt = engine.get_player_for_user_id(event:get_int("userid"))
local Attacker =
entities[engine.get_player_for_user_id(event:get_int("attacker"))]

if Hurt ~= engine.get_local_player() or not Attacker:is_enemy() then

return
end

EnemyMissedTime = 0
end

if DrawAAState then
function on_paint()
local LP = entities[engine.get_local_player()]
if CurrentState == "General" or not LP or not LP:is_alive() then
return
end

local ScreenSizeX, ScreenSizeY = render.get_screen_size()

render.text(render.font_control, ScreenSizeX - 5, 5, string.format("aa->%s",
string.lower(CurrentState)), render.color("#FFFFFF"), render.align_right)
end
end

local FovHitboxes = {0, 2, 5}

function on_bullet_impact(event)

local Settings = AAStateMenuElements["Enemy missed"]

 if not Settings.OverrideGeneralConfig:get() then
return
end

local LocalPlayer = entities[engine.get_local_player()]

local Shooter =
entities[engine.get_player_for_user_id(event:get_int("userid"))]
if not LocalPlayer or not Shooter or not Shooter:is_enemy() then
return
end

local LEyePos = math.vec3(LocalPlayer:get_eye_position())

local EyePos = math.vec3(Shooter:get_eye_position())
local ImpactPos = math.vec3(event:get_float("x"), event:get_float("y"),
event:get_float("z"))
local Angle = math.vector_angles((ImpactPos - EyePos):normalize())

local HasFov = false

for _, Hitbox in pairs(FovHitboxes) do
local HitboxPos = math.vec3(LocalPlayer:get_hitbox_position(Hitbox))
local FovToHitbox = math.calc_fov(EyePos, HitboxPos, Angle)
if FovToHitbox <= Settings.FovThreshhold:get() then
HasFov = true
break
end
end

if not HasFov then

return
end

-- Prob a better way to do this

if (EyePos:dist(ImpactPos) + 32) - EyePos:dist(LEyePos) < 0 then
return
end

EnemyMissedTime = global_vars.realtime
end