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
