if u need lite or live vers. source leak dm me: @keqx1
Код:
local AntiAim_GetCurrentRealRotation, AntiAim_GetInverterState, AntiAim_GetMaxDesyncDelta, AntiAim_GetMinDesyncDelta, AntiAim_OverrideInverter, AntiAim_OverrideLimit, AntiAim_OverrideYawOffset, bit_band, bit_bnot, bit_bor, bit_lshift, cheat_AddEvent, Cheat_AddNotify, cheat_AngleToForward, Cheat_AngleToForward, cheat_FireBullet, Cheat_GetBinds, Cheat_GetCheatUserName, Cheat_GetMousePos, Cheat_IsKeyDown, Cheat_IsMenuVisible, cheat_RegisterCallback, cheat_SetThirdPersonAnim, cheat_VectorToAngle, Cheat_VectorToAngle, Color_new, Color_RGBA, CVar_FindVar, EngineClient_GetScreenSize, EntityList_GetClientEntity, EntityList_GetLocalPlayer, EntityList_GetPlayer, EntityList_GetPlayerResource, ffi_cast, ffi_cdef, ffi_new, ffi_typeof, math_abs, math_ceil, math_clamp, math_cos, math_floor, math_lerp, math_max, math_min, math_normalize, math_rad, math_round, Menu_Combo, Menu_FindVar, Menu_SliderInt, Menu_Switch, print, pairs, RageBot_OverrideHitchance, Render_InitFont, string_format, table_insert, table_reference_condition, Utils_CreateInterface, Utils_CreateInterface, Utils_PatternScan, utils_RandomFloat, Vector_new, Vector2_new, fn, type, tonumber, error, condition, EngineClient_GetLocalPlayer, EngineClient_GetViewAngles, EngineClient_IsConnected, EngineClient_IsInGame, EngineTrace_TraceRay, EntityList_GetEntitiesByName, EntityList_GetPlayerForUserID, exploits_GetCharge, Exploits_OverrideDoubleTapSpeed, math_closest_point_on_ray, math_percent_to_pix, math_sin, math_vector_lerp, MatSystem_FirstMaterial, MatSystem_GetMaterial, MatSystem_NextMaterial, Menu_Button, Menu_ColorEdit, Menu_ComboColor, Menu_DestroyItem, Menu_MultiCombo, menu_SliderInt, menu_SwitchColor, Menu_SwitchColor, QAngle_new, Render_BoxFilled, Render_CalcTextSize, Render_Circle, Render_CircleFilled, Render_GradientBoxFilled, Render_Line, Render_PolyFilled, Render_Text, Render_WorldToScreen, table_remove, table_sort, unpack, Utils_RandomFloat, Utils_RandomInt, ipairs, pcall, tostring = AntiAim.GetCurrentRealRotation, AntiAim.GetInverterState, AntiAim.GetMaxDesyncDelta, AntiAim.GetMinDesyncDelta, AntiAim.OverrideInverter, AntiAim.OverrideLimit, AntiAim.OverrideYawOffset, bit.band, bit.bnot, bit.bor, bit.lshift, Cheat.AddEvent, Cheat.AddNotify, Cheat.AngleToForward, Cheat.AngleToForward, Cheat.FireBullet, Cheat.GetBinds, Cheat.GetCheatUserName, Cheat.GetMousePos, Cheat.IsKeyDown, Cheat.IsMenuVisible, Cheat.RegisterCallback, Cheat.SetThirdPersonAnim, Cheat.VectorToAngle, Cheat.VectorToAngle, Color.new, Color.RGBA, CVar.FindVar, EngineClient.GetScreenSize, EntityList.GetClientEntity, EntityList.GetLocalPlayer, EntityList.GetPlayer, EntityList.GetPlayerResource, ffi.cast, ffi.cdef, ffi.new, ffi.typeof, math.abs, math.ceil, math.clamp, math.cos, math.floor, math.lerp, math.max, math.min, math.normalize, math.rad, math.round, Menu.Combo, Menu.FindVar, Menu.SliderInt, Menu.Switch, print, pairs, RageBot.OverrideHitchance, Render.InitFont, string.format, table.insert, table.reference_condition, Utils.CreateInterface, Utils.CreateInterface, Utils.PatternScan, Utils.RandomFloat, Vector.new, Vector2.new, fn, type, tonumber, error, condition, EngineClient.GetLocalPlayer, EngineClient.GetViewAngles, EngineClient.IsConnected, EngineClient.IsInGame, EngineTrace.TraceRay, EntityList.GetEntitiesByName, EntityList.GetPlayerForUserID, Exploits.GetCharge, Exploits.OverrideDoubleTapSpeed, math.closest_point_on_ray, math.percent_to_pix, math.sin, math.vector_lerp, MatSystem.FirstMaterial, MatSystem.GetMaterial, MatSystem.NextMaterial, Menu.Button, Menu.ColorEdit, Menu.ComboColor, Menu.DestroyItem, Menu.MultiCombo, Menu.SliderInt, Menu.SwitchColor, Menu.SwitchColor, QAngle.new, Render.BoxFilled, Render.CalcTextSize, Render.Circle, Render.CircleFilled, Render.GradientBoxFilled, Render.Line, Render.PolyFilled, Render.Text, Render.WorldToScreen, table.remove, table.sort, unpack, Utils.RandomFloat, Utils.RandomInt, ipairs, pcall, tostring
local Render_GetMenuPos = Render.GetMenuPos
local Render_GetMenuSize = Render.GetMenuSize
--[[
@module Ataraxia
@build alpha
@author Aslier
@lastupdatetime 2022/5/5
]]
local cat = [[
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%$$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$'''''')$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$C''''''$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$''''''''''''#$$$$$$$$$$$$$$$$$$$$$''''''''''''$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$'''''''''''''''''!pU/))))/Ym)'''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$o''''''''''''''''''''''''''''''''''''''''''''''j$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''w$$$$$$$$$$$$$$$$$$$
$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$
$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$
$$!'''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$
$$$$$$$$$t'''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$
$$$$$$$www''''''''''''''''''''''''''''''''''''''''''''''''''www8$$$$$$$$$$$$$$$$
$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''''''''''$$$$$$$$$$$$$$$$
$$$$$$$$$$$$/'''''''''''''''''''''''''''''''''''''''''''':$$$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$i'''''''''''''''''''''''''''''''''''''''''$$$$qf!:!?L$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$W''''''''''''''''''''''''''''''''''Z$$@''''''''''''''''$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$U''''''''''''''''''''''x@$$$$$$'''''''$$$$$$$$$''''$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$a''''''''''''''|$$$$$$$$$$'''''$$$$$$$$$$$$''''''$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$-'''''''''''''''$$$$$$$$$;''''$$$$$$$$$$$$$$d''''$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$p''''''''''''''''{$$$$$$$$-''''B$$$$$$Y''`$$$$'''''8$$
$$$$$$$$$$$$$$$$$$$$$$$$$$''''''''''''''''''Q$$$$$$$$''''''''''''''''$$$n''''{$$
$$$$$$$$$$$$$$$$$$$$$$$$-'''''''''''''''''''''$$$$$$$$f''''''''''''/$$$$+'''']$$
$$$$$$$$$$$$$$$$$$$$$$$o''''''''''''''''''''''/$$$$$$$$$$$t<;?w$$$$$$$$$'''''0$$
$$$$$$$$$$$$$$$$$$$$$$-'''''''''''''''''''''''''$$$$$$$$$$$$$$$$$$$$$$$,'''''$$$
$$$$$$$$$$$$$$$$$$$$$h''''''''''''''''''''''''''|$$$$$$$$$$$$$$$$$$$$$''''''$$$$
$$$$$$$$$$$$$$$$$$$$L''''''''''''''''''''''''''''~$$$$$$$$$$$$$$$$$&'''''''B$$$$
$$$$$$$$$$$$$$$$$$$$''''''''''''''''''''''''''''''$$$$$$$$$$$$$$C''''''''-$$$$$$
$$$$$$$$$$$$$$$$$$$<'''''''''''''''''''''''''''''''$$$$$$$$$<''''''''''>$$$$$$$$
$$$$$$$$$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''''''B$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$''''''''''''''''''''''''''''''''''''''''''''''|$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$8''''''''''''''''''''''''''''''''''''''\#$$$$$$$$$$$$$$$$$$$$
$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$%%$$$$$$$$$$$$$$$$$$$$$$$
]]
local _ataraxia_ = function()
local userdata = {
username = Cheat_GetCheatUserName(),
build = "beta",
last_updatetime = "22/5/29"
}
local ffi = require('ffi')
local bit = require "bit"
ffi_cdef [[
typedef struct {
uint8_t r;
uint8_t g;
uint8_t b;
uint8_t a;
} color_struct_t;
typedef void (__cdecl* console_color_print)(void*,const color_struct_t&, const char*, ...);
typedef float*(__thiscall* bound)(void*);
typedef int(__thiscall* get_clipboard_text_count)(void*);
typedef void(__thiscall* set_clipboard_text)(void*, const char*, int);
typedef void(__thiscall* get_clipboard_text)(void*, int, const char*, int);
typedef int(__fastcall* clantag_t)(const char*, const char*);
]]
ffi_cdef[[
void* GetProcAddress(void* hModule, const char* lpProcName);
void* GetModuleHandleA(const char* lpModuleName);
typedef uintptr_t (__thiscall* GetClientEntity_4242425_t)(void*, int);
struct Animstate_t
{
char pad[3];
char m_bForceWeaponUpdate;
char pad1[91];
void* m_pBaseEntity;
void* m_pActiveWeapon;
void* m_pLastActiveWeapon;
float m_flLastClientSideAnimationUpdateTime;
int m_iLastClientSideAnimationUpdateFramecount;
float m_flAnimUpdateDelta;
float m_flEyeYaw;
float m_flPitch;
float m_flGoalFeetYaw;
float m_flCurrentFeetYaw;
float m_flCurrentTorsoYaw;
float m_flUnknownVelocityLean;
float m_flLeanAmount;
char pad2[4];
float m_flFeetCycle;
float m_flFeetYawRate;
char pad3[4];
float m_fDuckAmount;
float m_fLandingDuckAdditiveSomething;
char pad4[4];
float m_vOriginX;
float m_vOriginY;
float m_vOriginZ;
float m_vLastOriginX;
float m_vLastOriginY;
float m_vLastOriginZ;
float m_vVelocityX;
float m_vVelocityY;
char pad5[4];
float m_flUnknownFloat1;
char pad6[8];
float m_flUnknownFloat2;
float m_flUnknownFloat3;
float m_flUnknown;
float m_flSpeed2D;
float m_flUpVelocity;
float m_flSpeedNormalized;
float m_flFeetSpeedForwardsOrSideWays;
float m_flFeetSpeedUnknownForwardOrSideways;
float m_flTimeSinceStartedMoving;
float m_flTimeSinceStoppedMoving;
bool m_bOnGround;
bool m_bInHitGroundAnimation;
float m_flTimeSinceInAir;
float m_flLastOriginZ;
float m_flHeadHeightOrOffsetFromHittingGroundAnimation;
float m_flStopToFullRunningFraction;
char pad7[4];
float m_flMagicFraction;
char pad8[60];
float m_flWorldForce;
char pad9[462];
float m_flMaxYaw;
};
int VirtualProtect(void* lpAddress, unsigned long dwSize, unsigned long flNewProtect, unsigned long* lpflOldProtect);
void* VirtualAlloc(void* lpAddress, unsigned long dwSize, unsigned long flAllocationType, unsigned long flProtect);
int VirtualFree(void* lpAddress, unsigned long dwSize, unsigned long dwFreeType);
typedef uintptr_t (__thiscall* GetClientEntity_4242425_t)(void*, int);
typedef struct
{
float x;
float y;
float z;
} Vector_t;
typedef struct
{
char pad0[0x60]; // 0x00
void* pEntity; // 0x60
void* pActiveWeapon; // 0x64
void* pLastActiveWeapon; // 0x68
float flLastUpdateTime; // 0x6C
int iLastUpdateFrame; // 0x70
float flLastUpdateIncrement; // 0x74
float flEyeYaw; // 0x78
float flEyePitch; // 0x7C
float flGoalFeetYaw; // 0x80
float flLastFeetYaw; // 0x84
float flMoveYaw; // 0x88
float flLastMoveYaw; // 0x8C // changes when moving/jumping/hitting ground
float flLeanAmount; // 0x90
char pad1[0x4]; // 0x94
float flFeetCycle; // 0x98 0 to 1
float flMoveWeight; // 0x9C 0 to 1
float flMoveWeightSmoothed; // 0xA0
float flDuckAmount; // 0xA4
float flHitGroundCycle; // 0xA8
float flRecrouchWeight; // 0xAC
Vector_t vecOrigin; // 0xB0
Vector_t vecLastOrigin;// 0xBC
Vector_t vecVelocity; // 0xC8
Vector_t vecVelocityNormalized; // 0xD4
Vector_t vecVelocityNormalizedNonZero; // 0xE0
float flVelocityLenght2D; // 0xEC
float flJumpFallVelocity; // 0xF0
float flSpeedNormalized; // 0xF4 // clamped velocity from 0 to 1
float flRunningSpeed; // 0xF8
float flDuckingSpeed; // 0xFC
float flDurationMoving; // 0x100
float flDurationStill; // 0x104
bool bOnGround; // 0x108
bool bHitGroundAnimation; // 0x109
char pad2[0x2]; // 0x10A
float flNextLowerBodyYawUpdateTime; // 0x10C
float flDurationInAir; // 0x110
float flLeftGroundHeight; // 0x114
float flHitGroundWeight; // 0x118 // from 0 to 1, is 1 when standing
float flWalkToRunTransition; // 0x11C // from 0 to 1, doesnt change when walking or crouching, only running
char pad3[0x4]; // 0x120
float flAffectedFraction; // 0x124 // affected while jumping and running, or when just jumping, 0 to 1
char pad4[0x208]; // 0x128
float flMinBodyYaw; // 0x330
float flMaxBodyYaw; // 0x334
float flMinPitch; //0x338
float flMaxPitch; // 0x33C
int iAnimsetVersion; // 0x340
} CCSGOPlayerAnimationState_534535_t;
typedef struct {
char pad_0000[20];
int m_nOrder; //0x0014
int m_nSequence; //0x0018
float m_flPrevCycle; //0x001C
float m_flWeight; //0x0020
float m_flWeightDeltaRate; //0x0024
float m_flPlaybackRate; //0x0028
float m_flCycle; //0x002C
void *m_pOwner; //0x0030
char pad_0038[4]; //0x0034
} CAnimationLayer_t;
]]
ffi_cdef([[
typedef struct
{
void* steam_client;
void* steam_user;
void* steam_friends;
void* steam_utils;
void* steam_matchmaking;
void* steam_user_stats;
void* steam_apps;
void* steam_matchmakingservers;
void* steam_networking;
void* steam_remotestorage;
void* steam_screenshots;
void* steam_http;
void* steam_unidentifiedmessages;
void* steam_controller;
void* steam_ugc;
void* steam_applist;
void* steam_music;
void* steam_musicremote;
void* steam_htmlsurface;
void* steam_inventory;
void* steam_video;
} S_steamApiCtx_t;
]])
ffi_cdef[[
void* CreateFileA(
const char* lpFileName,
unsigned long dwDesiredAccess,
unsigned long dwShareMode,
unsigned long lpSecurityAttributes,
unsigned long dwCreationDisposition,
unsigned long dwFlagsAndAttributes,
void* hTemplateFile
);
bool ReadFile(
void* hFile,
char* lpBuffer,
unsigned long nNumberOfBytesToRead,
unsigned long* lpNumberOfBytesRead,
int lpOverlapped
);
bool WriteFile(
void* hFile,
char* lpBuffer,
unsigned long nNumberOfBytesToWrite,
unsigned long* lpNumberOfBytesWritten,
void* lpOverlapped
);
bool DeleteFileA(
const char* lpFileName
);
unsigned long GetFileSize(
void* hFile,
unsigned long* lpFileSizeHigh
);
bool CreateDirectoryA(
const char* lpPathName,
void* lpSecurityAttributes
);
void* CloseHandle(void *hFile);
typedef int(__fastcall* clantag_t)(const char*, const char*);
typedef struct _OVERLAPPED {
unsigned long* Internal;
unsigned long* InternalHigh;
union {
struct {
unsigned long Offset;
unsigned long OffsetHigh;
} DUMMYSTRUCTNAME;
void* Pointer;
} DUMMYUNIONNAME;
void* hEvent;
} OVERLAPPED, *LPOVERLAPPED;
typedef struct _class
{
void** this;
}aclass;
]]
ffi.C.CreateDirectoryA("nl\\ataraxia", nil)
local pS_SteamApiCtx = ffi.cast(
"S_steamApiCtx_t**", ffi.cast(
"char*",
Utils.PatternScan(
"client.dll",
"FF 15 ?? ?? ?? ?? B9 ?? ?? ?? ?? E8 ?? ?? ?? ?? 6A"
)
) + 7
)[0] or error("invalid interface", 2)
local Png = {}
Png.__index = Png
local png_ihdr_t = ffi.typeof([[
struct {
char type[4];
uint32_t width;
uint32_t height;
char bitDepth;
char colorType;
char compression;
char filter;
char interlace;
} *
]])
local jpg_segment_t = ffi.typeof([[
struct {
char type[2];
uint16_t size;
} *
]])
local jpg_segment_sof0_t = ffi.typeof([[
struct {
uint16_t size;
char precision;
uint16_t height;
uint16_t width;
} __attribute__((packed)) *
]])
local uint16_t_ptr = ffi.typeof("uint16_t*")
local charbuffer = ffi.typeof("unsigned char[?]")
local uintbuffer = ffi.typeof("unsigned int[?]")
--
-- constants
--
local INVALID_TEXTURE = -1
local PNG_MAGIC = "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A"
local JPG_MAGIC_1 = "\xFF\xD8\xFF\xDB"
local JPG_MAGIC_2 = "\xFF\xD8\xFF\xE0\x00\x10\x4A\x46\x49\x46\x00\x01"
local JPG_SEGMENT_SOI = "\xFF\xD8"
local JPG_SEGMENT_SOF0 = "\xFF\xC0"
local JPG_SEGMENT_SOS = "\xFF\xDA"
local JPG_SEGMENT_EOI = "\xFF\xD9"
local DEFLATE_MAX_BLOCK_SIZE = 65535
local function putBigUint32(val, tbl, index)
for i=0,3 do
tbl[index + i] = bit.band(bit.rshift(val, (3 - i) * 8), 0xFF)
end
end
function Png:writeBytes(data, index, len)
index = index or 1
len = len or #data
for i=index,index+len-1 do
table.insert(self.output, string.char(data[i]))
end
end
function Png:write(pixels)
local count = #pixels -- Byte count
local pixelPointer = 1
while count > 0 do
if self.positionY >= self.height then
error("All image pixels already written")
end
if self.deflateFilled == 0 then -- Start DEFLATE block
local size = DEFLATE_MAX_BLOCK_SIZE;
if (self.uncompRemain < size) then
size = self.uncompRemain
end
local header = { -- 5 bytes long
bit.band((self.uncompRemain <= DEFLATE_MAX_BLOCK_SIZE and 1 or 0), 0xFF),
bit.band(bit.rshift(size, 0), 0xFF),
bit.band(bit.rshift(size, 8), 0xFF),
bit.band(bit.bxor(bit.rshift(size, 0), 0xFF), 0xFF),
bit.band(bit.bxor(bit.rshift(size, 8), 0xFF), 0xFF),
}
self:writeBytes(header)
self:crc32(header, 1, #header)
end
assert(self.positionX < self.lineSize and self.deflateFilled < DEFLATE_MAX_BLOCK_SIZE);
if (self.positionX == 0) then -- Beginning of line - write filter method byte
local b = {0}
self:writeBytes(b)
self:crc32(b, 1, 1)
self:adler32(b, 1, 1)
self.positionX = self.positionX + 1
self.uncompRemain = self.uncompRemain - 1
self.deflateFilled = self.deflateFilled + 1
else -- Write some pixel bytes for current line
local n = DEFLATE_MAX_BLOCK_SIZE - self.deflateFilled;
if (self.lineSize - self.positionX < n) then
n = self.lineSize - self.positionX
end
if (count < n) then
n = count;
end
assert(n > 0);
self:writeBytes(pixels, pixelPointer, n)
-- Update checksums
self:crc32(pixels, pixelPointer, n);
self:adler32(pixels, pixelPointer, n);
-- Increment positions
count = count - n;
pixelPointer = pixelPointer + n;
self.positionX = self.positionX + n;
self.uncompRemain = self.uncompRemain - n;
self.deflateFilled = self.deflateFilled + n;
end
if (self.deflateFilled >= DEFLATE_MAX_BLOCK_SIZE) then
self.deflateFilled = 0; -- End current block
end
if (self.positionX == self.lineSize) then -- Increment line
self.positionX = 0;
self.positionY = self.positionY + 1;
if (self.positionY == self.height) then -- Reached end of pixels
local footer = { -- 20 bytes long
0, 0, 0, 0, -- DEFLATE Adler-32 placeholder
0, 0, 0, 0, -- IDAT CRC-32 placeholder
-- IEND chunk
0x00, 0x00, 0x00, 0x00,
0x49, 0x45, 0x4E, 0x44,
0xAE, 0x42, 0x60, 0x82,
}
putBigUint32(self.adler, footer, 1)
self:crc32(footer, 1, 4)
putBigUint32(self.crc, footer, 5)
self:writeBytes(footer)
self.done = true
end
end
end
end
function Png:crc32(data, index, len)
self.crc = bit.bnot(self.crc)
for i=index,index+len-1 do
local byte = data[i]
for j=0,7 do -- Inefficient bitwise implementation, instead of table-based
local nbit = bit.band(bit.bxor(self.crc, bit.rshift(byte, j)), 1);
self.crc = bit.bxor(bit.rshift(self.crc, 1), bit.band((-nbit), 0xEDB88320));
end
end
self.crc = bit.bnot(self.crc)
end
function Png:adler32(data, index, len)
local s1 = bit.band(self.adler, 0xFFFF)
local s2 = bit.rshift(self.adler, 16)
for i=index,index+len-1 do
s1 = (s1 + data[i]) % 65521
s2 = (s2 + s1) % 65521
end
self.adler = bit.bor(bit.lshift(s2, 16), s1)
end
local function begin(width, height, colorMode)
-- Default to rgb
colorMode = colorMode or "rgb"
-- Determine bytes per pixel and the PNG internal color type
local bytesPerPixel, colorType
if colorMode == "rgb" then
bytesPerPixel, colorType = 3, 2
elseif colorMode == "rgba" then
bytesPerPixel, colorType = 4, 6
else
error("Invalid colorMode")
end
local state = setmetatable({ width = width, height = height, done = false, output = {} }, Png)
-- Compute and check data siezs
state.lineSize = width * bytesPerPixel + 1
-- TODO: check if lineSize too big
state.uncompRemain = state.lineSize * height
local numBlocks = math.ceil(state.uncompRemain / DEFLATE_MAX_BLOCK_SIZE)
-- 5 bytes per DEFLATE uncompressed block header, 2 bytes for zlib header, 4 bytes for zlib Adler-32 footer
local idatSize = numBlocks * 5 + 6
idatSize = idatSize + state.uncompRemain;
-- TODO check if idatSize too big
local header = { -- 43 bytes long
-- PNG header
0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A,
-- IHDR chunk
0x00, 0x00, 0x00, 0x0D,
0x49, 0x48, 0x44, 0x52,
0, 0, 0, 0, -- 'width' placeholder
0, 0, 0, 0, -- 'height' placeholder
0x08, colorType, 0x00, 0x00, 0x00,
0, 0, 0, 0, -- IHDR CRC-32 placeholder
-- IDAT chunk
0, 0, 0, 0, -- 'idatSize' placeholder
0x49, 0x44, 0x41, 0x54,
-- DEFLATE data
0x08, 0x1D,
}
putBigUint32(width, header, 17)
putBigUint32(height, header, 21)
putBigUint32(idatSize, header, 34)
state.crc = 0
state:crc32(header, 13, 17)
putBigUint32(state.crc, header, 30)
state:writeBytes(header)
state.crc = 0
state:crc32(header, 38, 6); -- 0xD7245B6B
state.adler = 1
state.positionX = 0
state.positionY = 0
state.deflateFilled = 0
return state
end
local native_ISteamFriends = ffi.cast("void***", pS_SteamApiCtx.steam_friends)
local native_ISteamUtils = ffi.cast("void***", pS_SteamApiCtx.steam_utils)
local native_ISteamFriends_GetSmallFriendAvatar = ffi.cast("int(__thiscall*)(void*, uint64_t)" ,native_ISteamFriends[0][34] )
local native_ISteamUtils_GetImageSize = ffi.cast("bool(__thiscall*)(void*, int, uint32_t*, uint32_t*)" , native_ISteamUtils[0][5])
local native_ISteamUtils_GetImageRGBA = ffi.cast("bool(__thiscall*)(void*, int, unsigned char*, int)" , native_ISteamUtils[0][6])
local VGUI_System010 = Utils_CreateInterface("vgui2.dll", "VGUI_System010") or print("Error finding VGUI_System010")
local VGUI_System = ffi.cast(ffi.typeof('void***'), VGUI_System010)
local cvar_interface = ffi_cast(ffi.typeof("uintptr_t**"), Utils_CreateInterface("vstdlib.dll", "VEngineCvar007")) or error ("Fail")
local color_print_fn = ffi.cast("console_color_print", cvar_interface[0][25]) or error ("Fail")
local function vtable_thunk(index, typedef)
return function(v0, ...)
local instance = ffi.cast(ffi.typeof('void***'), v0)
local tdef = nil
if seen[typedef] then
tdef = seen[typedef]
else
tdef = ffi.typeof(typedef)
seen[typedef] = tdef
end
return ffi.cast(tdef, instance[0][index])(instance, ...)
end
end
local function vtable_bind(interface, index, typedef)
local instance = ffi.cast('void***', interface);
return function(...)
return ffi.cast(typedef, instance[0][index])(instance, ...)
end
end
local entity_list_pointer = ffi.cast("void***", Utils.CreateInterface("client.dll", "VClientEntityList003"))
local get_client_entity_fn = ffi.cast("GetClientEntity_4242425_t", entity_list_pointer[0][3])
local get_entity_address = function(ent_index)
local addr = get_client_entity_fn(entity_list_pointer, ent_index)
return addr
end
local hook_helpers = {
copy = function(dst, src, len)
return ffi.copy(ffi.cast('void*', dst), ffi.cast('const void*', src), len)
end,
virtual_protect = function(lpAddress, dwSize, flNewProtect, lpflOldProtect)
return ffi.C.VirtualProtect(ffi.cast('void*', lpAddress), dwSize, flNewProtect, lpflOldProtect)
end,
virtual_alloc = function(lpAddress, dwSize, flAllocationType, flProtect, blFree)
local alloc = ffi.C.VirtualAlloc(lpAddress, dwSize, flAllocationType, flProtect)
if blFree then
table.insert(buff.free, function()
ffi.C.VirtualFree(alloc, 0, 0x8000)
end)
end
return ffi.cast('intptr_t', alloc)
end
}
local buff = {free = {}}
local vmt_hook = {hooks = {}}
function vmt_hook.new(vt)
local new_hook = {}
local org_func = {}
local old_prot = ffi.new('unsigned long[1]')
local virtual_table = ffi.cast('intptr_t**', vt)[0]
new_hook.this = virtual_table
new_hook.hookMethod = function(cast, func, method)
org_func[method] = virtual_table[method]
hook_helpers.virtual_protect(virtual_table + method, 4, 0x4, old_prot)
virtual_table[method] = ffi.cast('intptr_t', ffi.cast(cast, func))
hook_helpers.virtual_protect(virtual_table + method, 4, old_prot[0], old_prot)
return ffi.cast(cast, org_func[method])
end
new_hook.unHookMethod = function(method)
hook_helpers.virtual_protect(virtual_table + method, 4, 0x4, old_prot)
local alloc_addr = hook_helpers.virtual_alloc(nil, 5, 0x1000, 0x40, false)
local trampoline_bytes = ffi.new('uint8_t[?]', 5, 0x90)
trampoline_bytes[0] = 0xE9
ffi.cast('int32_t*', trampoline_bytes + 1)[0] = org_func[method] - tonumber(alloc_addr) - 5
hook_helpers.copy(alloc_addr, trampoline_bytes, 5)
virtual_table[method] = ffi.cast('intptr_t', alloc_addr)
hook_helpers.virtual_protect(virtual_table + method, 4, old_prot[0], old_prot)
org_func[method] = nil
end
new_hook.unHookAll = function()
for method, func in pairs(org_func) do
new_hook.unHookMethod(method)
end
end
table.insert(vmt_hook.hooks, new_hook.unHookAll)
return new_hook
end
local hooked_function = nil
local is_jumping = false
local display_duration = 2
local speed = 1
local check_headshot = false
local get_fake_amount = 0
local noti_table = {}
local sc_x,sc_y = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
local M = {}
local JSON = Panorama.LoadString([[
return {
stringify: JSON.stringify,
parse: JSON.parse
};
]])()
local shl, shr, band = bit.lshift, bit.rshift, bit.band
local char, byte, gsub, sub, format, concat, tostring, error, pairs = string.char, string.byte, string.gsub, string.sub, string.format, table.concat, tostring, error, pairs
local extract = function(v, from, width)
return band(shr(v, from), shl(1, width) - 1)
end
local function makeencoder(alphabet)
local encoder, decoder = {}, {}
for i=1, 65 do
local chr = byte(sub(alphabet, i, i)) or 32 -- or " "
if decoder[chr] ~= nil then
error("invalid alphabet: duplicate character " .. tostring(chr), 3)
end
encoder[i-1] = chr
decoder[chr] = i-1
end
return encoder, decoder
end
local encoders, decoders = {}, {}
encoders["base64"], decoders["base64"] = makeencoder("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=")
encoders["base64url"], decoders["base64url"] = makeencoder("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_")
local alphabet_mt = {
__index = function(tbl, key)
if type(key) == "string" and key:len() == 64 or key:len() == 65 then
-- if key is a valid looking base64 alphabet, try to make an encoder/decoder pair from it
encoders[key], decoders[key] = makeencoder(key)
return tbl[key]
end
end
}
setmetatable(encoders, alphabet_mt)
setmetatable(decoders, alphabet_mt)
function M.encode(str, encoder)
encoder = encoders[encoder or "base64"] or error("invalid alphabet specified", 2)
str = tostring(str)
local t, k, n = {}, 1, #str
local lastn = n % 3
local cache = {}
for i = 1, n-lastn, 3 do
local a, b, c = byte(str, i, i+2)
local v = a*0x10000 + b*0x100 + c
local s = cache[v]
if not s then
s = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[extract(v,0,6)])
cache[v] = s
end
t[k] = s
k = k + 1
end
if lastn == 2 then
local a, b = byte(str, n-1, n)
local v = a*0x10000 + b*0x100
t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[extract(v,6,6)], encoder[64])
elseif lastn == 1 then
local v = byte(str, n)*0x10000
t[k] = char(encoder[extract(v,18,6)], encoder[extract(v,12,6)], encoder[64], encoder[64])
end
return concat(t)
end
function M.decode(b64, decoder)
decoder = decoders[decoder or "base64"] or error("invalid alphabet specified", 2)
local pattern = "[^%w%+%/%=]"
if decoder then
local s62, s63
for charcode, b64code in pairs(decoder) do
if b64code == 62 then s62 = charcode
elseif b64code == 63 then s63 = charcode
end
end
pattern = format("[^%%w%%%s%%%s%%=]", char(s62), char(s63))
end
b64 = gsub(tostring(b64), pattern, '')
local cache = {}
local t, k = {}, 1
local n = #b64
local padding = sub(b64, -2) == "==" and 2 or sub(b64, -1) == "=" and 1 or 0
for i = 1, padding > 0 and n-4 or n, 4 do
local a, b, c, d = byte(b64, i, i+3)
local v0 = a*0x1000000 + b*0x10000 + c*0x100 + d
local s = cache[v0]
if not s then
local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40 + decoder[d]
s = char(extract(v,16,8), extract(v,8,8), extract(v,0,8))
cache[v0] = s
end
t[k] = s
k = k + 1
end
if padding == 1 then
local a, b, c = byte(b64, n-3, n-1)
local v = decoder[a]*0x40000 + decoder[b]*0x1000 + decoder[c]*0x40
t[k] = char(extract(v,16,8), extract(v,8,8))
elseif padding == 2 then
local a, b = byte(b64, n-3, n-2)
local v = decoder[a]*0x40000 + decoder[b]*0x1000
t[k] = char(extract(v,16,8))
end
return concat(t)
end
local get_clipboard_text_count = ffi.cast("get_clipboard_text_count", VGUI_System[0][7]) or print("get_clipboard_text_count Invalid")
local set_clipboard_text = ffi.cast("set_clipboard_text", VGUI_System[0][9]) or print("set_clipboard_text Invalid")
local get_clipboard_text = ffi.cast("get_clipboard_text", VGUI_System[0][11]) or print("get_clipboard_text Invalid")
local function str_to_sub(input, sep)
local t = {}
for str in string.gmatch(input, "([^" .. sep .. "]+)") do
t[#t + 1] = string.gsub(str, "\n", "")
end
return t
end
local ffi_handler = {}
ffi_handler.bind_argument = function(fn, arg)
return function(...)
return fn(arg, ...)
end
end
ffi_handler.interface_type = ffi_typeof("uintptr_t**")
ffi_handler.vgui_system = ffi_cast(ffi_handler.interface_type, Utils.CreateInterface("vgui2.dll", "VGUI_System010"))
ffi_handler.get_clipboard_text_count = ffi_handler.bind_argument(ffi.cast("int(__thiscall*)(void*)", ffi_handler.vgui_system[0][7]), ffi_handler.vgui_system)
ffi_handler.set_clipboard_text = ffi_handler.bind_argument(ffi.cast("void(__thiscall*)(void*, const char*, int)", ffi_handler.vgui_system[0][9]), ffi_handler.vgui_system)
ffi_handler.get_clipboard_text_fn = ffi_handler.bind_argument(ffi.cast("void(__thiscall*)(void*, int, const char*, int)", ffi_handler.vgui_system[0][11]), ffi_handler.vgui_system)
ffi_handler.clipboard_import = function()
local clipboard_text_length = ffi_handler.get_clipboard_text_count()
if clipboard_text_length > 0 then
local buffer = ffi.new("char[?]", clipboard_text_length)
local size = clipboard_text_length * ffi.sizeof("char[?]", clipboard_text_length)
ffi_handler.get_clipboard_text_fn(0, buffer, size )
return ffi.string( buffer, clipboard_text_length-1)
end
return ""
end
local function clipboard_export(string)
if string then
set_clipboard_text(VGUI_System, string, string:len())
end
end
local debugger = function(...)
local color_print = function(color,tel)
if color == nil then
return
end
local col = ffi.new("color_struct_t")
col.r = color.r * 255
col.g = color.g * 255
col.b = color.b * 255
col.a = color.a * 255
color_print_fn(cvar_interface, col, tel)
end
local r,g,b,a = 224/255,159/255,154/255,1
color_print(Color_new(r,g,b,a),"[Ataraxia] ")
print(...)
end
local ui_reference = function(tab1,tab2,tab3,tab4)
return Menu_FindVar(tab1,tab2,tab3,tab4)
end
local ui_set = function(type,elements,val,state)
if type == "value" then
return elements:Set(val)
elseif type == "bool" then
return elements:SetBool(val,state)
end
end
local ui_get = function(type,elements,val)
if type == "value" then
return elements:Get()
elseif type == "color" then
local r,g,b,a = elements:GetColor().r,elements:GetColor().g,elements:GetColor().b,elements:GetColor().a
return {r = r ,g = g,b = b,a = a }
elseif type == "bool" then
return elements:GetBool(val)
end
end
local ui_set_visible = function(elements,val)
return elements:SetVisible(val)
end
local ui_set_callback = function(elements,val)
return elements:RegisterCallback(val)
end
local ui_new_multiselect = function(tab1,tab2,elements,combo,val,tooltips)
return Menu_MultiCombo(tab1,tab2,elements,combo,val,tooltips)
end
local ui_new_combobox = function(tab1,tab2,elements,combo,val,tooltips)
return Menu_Combo(tab1,tab2,elements,combo,val,tooltips)
end
local ui_new_colorpicker = function(tab1,tab2,elements,r,g,b,a,tooltips)
return Menu_ColorEdit(tab1,tab2,elements,Color_RGBA(r,g,b,a),tooltips)
end
local ui_new_textbox = function(tab1,tab2,elements,max_size,val,tooltips)
return Menu.TextBox(tab1,tab2,elements,max_size,val,tooltips)
end
local ui_new_label = function(tab1,tab2,elements)
return Menu.Text(tab1,tab2,elements)
end
local ui_new_checkbox = function(type,tab1,tab2,elements,states,tooltips,r,g,b,a)
if type == "bool" then
return Menu_Switch(tab1,tab2,elements,states,tooltips)
elseif type == "color" then
return Menu_SwitchColor(tab1,tab2,elements,states,Color_RGBA(r,g,b,a),tooltips)
end
end
local ui_new_slider = function(type,tab1,tab2,elements,min,max,val,tooltips)
if type == "int" then
return Menu_SliderInt(tab1,tab2,elements,val,min,max,tooltips)
elseif type == "float" then
return Menu.SliderFloat(tab1,tab2,elements,val,min,max,tooltips)
end
end
local client_set_event_callback = function(events,func)
return cheat_RegisterCallback(events,func)
end
local entity_get_prop = function(inx,prop)
return inx:GetProp(prop)
end
local entity_get_localplayer = function()
return EntityList_GetLocalPlayer()
end
Render.Texts = function(text, pos, col, size, font, bool)
if font == nil then
Render.Text(text, pos + Vector2.new(1, 1), Color.new(0, 0, 0, col.a), size, false , bool)
Render.Text(text, pos, col, size, false , bool)
else
Render.Text(text, pos + Vector2.new(1, 1), Color.new(0, 0, 0, col.a), size, font, false , bool and bool or false)
Render.Text(text, pos, col, size, font, false , bool and bool or false )
end
end
local noscope_weapons = {
[261] = true,
[242] = true,
[233] = true,
[267] = true
}
local reference = {
enable = ui_reference("Aimbot","Anti Aim","Main","Enable Anti Aim"),
pitch = ui_reference("Aimbot","Anti Aim","Main","Pitch"),
yaw_base = ui_reference("Aimbot","Anti Aim","Main","Yaw Base"),
yaw_add = ui_reference("Aimbot","Anti Aim","Main","Yaw Add"),
yaw_jitter_mode = ui_reference("Aimbot","Anti Aim","Main","Yaw Modifier"),
yaw_jitter_slider = ui_reference("Aimbot","Anti Aim","Main","Modifier Degree"),
fake_angle = ui_reference("Aimbot","Anti Aim","Fake Angle", "Enable Fake Angle"),
inverter = ui_reference("Aimbot","Anti Aim","Fake Angle", "Inverter"),
left_limit = ui_reference("Aimbot","Anti Aim", "Fake Angle", "Left Limit"),
right_limit = ui_reference("Aimbot","Anti Aim","Fake Angle", "Right Limit"),
fake_option = ui_reference("Aimbot","Anti Aim","Fake Angle", "Fake Options"),
lby = ui_reference("Aimbot","Anti Aim", "Fake Angle", "LBY Mode"),
freestanding_yaw = ui_reference("Aimbot","Anti Aim", "Fake Angle", "Freestanding Desync"),
desync_shot = ui_reference("Aimbot","Anti Aim","Fake Angle", "Desync On Shot"),
slow_motion = ui_reference("Aimbot","Anti Aim", "Misc", "Slow Walk"),
leg_movement = ui_reference("Aimbot","Anti Aim","Misc", "Leg Movement"),
autopeek = ui_reference("Miscellaneous", 'Main', 'Movement', 'Auto Peek'),
windows = ui_reference("Miscellaneous", 'Main', 'Other', 'Windows'),
auto_starfe = ui_reference("Miscellaneous", 'Main', 'Movement', 'Auto Strafe'),
dmg = ui_reference("Aimbot", 'Ragebot', 'Accuracy', 'Minimum Damage'),
ragebot = ui_reference("Aimbot", "Ragebot", "Main", "Enable Ragebot"),
dt = ui_reference("Aimbot", "Ragebot", "Exploits", "Double Tap"),
fl_main = ui_reference("Aimbot", "Anti Aim", "Fake Lag", "Enable Fake Lag"),
fl_limit = ui_reference("Aimbot","Anti Aim", "Fake Lag", "Limit"),
fl_jitter = ui_reference("Aimbot","Anti Aim","Fake Lag", "Randomization"),
hs = ui_reference("Aimbot", "Ragebot", "Exploits", "Hide Shots"),
hitchance = ui_reference("Aimbot", "Ragebot", "Accuracy", "Hit Chance"),
body_aim = ui_reference("Aimbot", "Ragebot", "Misc", "Body Aim"),
safe_point = ui_reference("Aimbot", "Ragebot", "Misc", "Safe Points"),
tb = CVar.FindVar("sv_maxusrcmdprocessticks"),
clock = CVar.FindVar("cl_clock_correction"),
fakeduck = ui_reference("Aimbot", "Anti Aim", "Misc", "Fake Duck"),
lagCompensation = CVar.FindVar("cl_lagcompensation"),
remove_scope = ui_reference("Visuals", "View", "Camera", "Remove Scope"),
}
local doubletap_charged = function()
if not ui_get("value",reference.dt) or ui_get("value",reference.fakeduck) then
return false
end
if entity_get_localplayer() == nil then
return
end
local weap = entity_get_localplayer():GetActiveWeapon()
if weap == nil then
return
end
local next_attack = entity_get_prop(entity_get_localplayer(), "m_flNextAttack") + 0.25
local jewfag = entity_get_prop(weap, "m_flNextPrimaryAttack")
if jewfag == nil then
return
end
local next_primary_attack = jewfag + 0.5
if next_attack == nil or next_primary_attack == nil then
return false
end
return next_attack - GlobalVars.curtime < 0 and next_primary_attack -GlobalVars.curtime < 0
end
table.insert(noti_table, {
text = "Welcome to Ataraxia , "..userdata.username.." Current build: "..userdata.build.." Last update time: "..userdata.last_updatetime,
timer = GlobalVars.realtime,
smooth_y = sc_y + 100,
alpha = 0,
})
local menu = {}
menu.ui_data = {
bool = {},
int = {},
float = {},
str = {},
color = {}
}
menu.callback_data = {}
menu.new_elements = function(type,cheatVar)
if type == "bool" then
table_insert(menu.ui_data.bool,cheatVar)
end
if type == "int" then
table_insert(menu.ui_data.int,cheatVar)
end
if type == "float" then
table_insert(menu.ui_data.float,cheatVar)
end
if type == "str" then
table_insert(menu.ui_data.str,cheatVar)
end
if type == "color" then
table_insert(menu.ui_data.color,cheatVar)
end
if type == "button" then
debugger("invoked button")
end
table_insert(menu.callback_data,cheatVar)
return cheatVar
end
menu.interface = {}
menu.interface.type = {"[Ataraxia] Info","[Ataraxia] Visuals","[Ataraxia] Antiaim","[Ataraxia] Misc"}
menu.interface.info = {}
menu.interface.antiaim = {}
menu.interface.visuals = {}
menu.interface.misc = {}
local t1 = menu.interface.type[1]
local t2 = menu.interface.type[2]
local t3 = menu.interface.type[3]
local t4 = menu.interface.type[4]
local info = menu.interface.info
local antiaim = menu.interface.antiaim
local visuals = menu.interface.visuals
local misc = menu.interface.misc
local _state = {"Stand","Move","Slow walk","Duck","Air","Air + D"}
local __state = {"1","2","3","4","5","6"}
local g_config = {
export_process = function(self)
local data = {{},{},{},{},{}}
for k, v in pairs(menu.ui_data.bool) do
table_insert(data[1],v:GetBool())
end
for k, v in pairs(menu.ui_data.int) do
table_insert(data[2],ui_get("value",v))
end
for k, v in pairs(menu.ui_data.float) do
table_insert(data[3],ui_get("value",v))
end
for k, v in pairs(menu.ui_data.str) do
table_insert(data[4],ui_get("value",v))
end
for _, colors in pairs(menu.ui_data.color) do
local clr = colors:GetColor()
table_insert(data[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_export(M.encode(JSON.stringify(data)))
end,
load_process = function(self,text)
local protected = function()
local clipboard = text == nil and ffi_handler.clipboard_import() or text
local json_config = M.decode(clipboard)
json_config = JSON.parse(json_config)
if json_config == nil then
error("wrong_json")
return
end
for k, v in pairs(json_config) do
k = ({[1] = "bool", [2] = "int", [3] = "float", [4] = "str", [5] = "color"})[k]
for k2, v2 in pairs(v) do
if (k == "bool") then
if type(v2) == "boolean" then
menu.ui_data[k][k2]:SetBool(v2)
else
return debugger("Fail to load due to incorrect data type, expect boolean received "..type(v2))
end
end
if (k == "int") then
if type(v2) == "number" then
menu.ui_data[k][k2]:SetInt(v2)
else
return debugger("Fail to load due to incorrect data type, expect number received "..type(v2))
end
end
if (k == "float") then
if type(v2) == "number" then
menu.ui_data[k][k2]:SetFloat(v2)
else
return debugger("Fail to load due to incorrect data type, expect number received "..type(v2))
end
end
if (k == "string") then
menu.ui_data[k][k2]:SetString(v2)
end
if (k == "color") then
menu.ui_data[k][k2]:SetColor(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
Cheat_AddNotify("Ataraxia", "Config loaded!")
debugger("Loaded config from clipboard")
table.insert(noti_table, {
text = "Loaded config from clipboard",
timer = GlobalVars.realtime,
smooth_y = sc_y + 100,
alpha = 0,
})
table.insert(noti_table, {
text = "Reload lua to use config",
timer = GlobalVars.realtime,
smooth_y = sc_y + 100,
alpha = 0,
})
end
local status, message = pcall(protected)
if not status then
debugger("Fail to load config "..message)
table.insert(noti_table, {
text = "Failed to load config,check error message and send it to support",
timer = GlobalVars.realtime,
smooth_y = sc_y + 100,
alpha = 0,
})
Cheat_AddNotify("Ataraxia", "Failed to load config due to "..message)
return
end
end,
menu = function(self)
end,
}
local clamp = function(num, min, max)
if num < min then
num = min
elseif num > max then
num = max
end
return num
end
local get_icon_size = Vector2.new(32,28)
local bytes = Http.Get("https://i.imgur.com/WEZaLSo.png")
local pfile = ffi.cast("void*", ffi.C.CreateFileA(ffi.cast("const char *", "nl\\ataraxia\\icon.png"), 0xC0000000, 0x00000003, 0, 0x4, 0x80, nil))
if (not pfile) then
debugger("Failed to create file, please restart the script or create a ticket.")
return
end
local overlapped = ffi.new("OVERLAPPED")
overlapped.DUMMYUNIONNAME.DUMMYSTRUCTNAME.Offset = 0xFFFFFFFF
overlapped.DUMMYUNIONNAME.DUMMYSTRUCTNAME.OffsetHigh = 0xFFFFFFFF
ffi.C.WriteFile(pfile, ffi.cast("char*" , bytes) , 25600 , nil , ffi.cast("void*", overlapped))
ffi.C.CloseHandle(pfile)
local icon = Render.LoadImageFromFile("nl\\ataraxia\\icon.png", get_icon_size)
local g_menu = {
create_data = function(self)
info.announcement = ui_new_label(t1,"[Announcement]","Thanks for all small8-yaw user's long waiting.")
info.user = ui_new_label(t1,"[Userdata]","Welcome! "..userdata.username)
info.build = ui_new_label(t1,"[Userdata]","Current build: "..userdata.build)
info.last_updatetime = ui_new_label(t1,"[Userdata]","Last update time: "..userdata.last_updatetime)
info.master_switch = menu.new_elements("bool",ui_new_checkbox("bool",t1,"[Announcement]","Enable Ataraxia",false,"[~] All features master switch"))
info.feature_list = menu.new_elements("int",ui_new_multiselect(t1,"[Announcement]","Features list",{"Indicators","Built-in presets","Extra antiaim settings","Misc features"},0,"[~] Features list"))
antiaim.import = menu.new_elements("button",Menu_Button(t1,"[Config]"," Load config from clipboard ","[~] Check here to load config",function()
g_config:load_process()
end))
antiaim.export = menu.new_elements("button",Menu_Button(t1,"[Config]"," Export config to clipboard ","[~] Check here to export config",function()
g_config:export_process()
Cheat_AddNotify("Ataraxia", "Config Copied!")
table.insert(noti_table, {
text = "Exported config!",
timer = GlobalVars.realtime,
smooth_y = sc_y + 100,
alpha = 0,
})
debugger("Exported config")
end))
info.download = menu.new_elements("button",Menu_Button(t1,"[Userdata]","Download userdata from clipboard ","[~] Check here to download userdata",function()
end))
visuals.info = ui_new_label(t2,"[Notice]","Enable in the main interface")
antiaim.info = ui_new_label(t3,"[Notice]","Enable in the main interface")
misc.info = ui_new_label(t4,"[Notice]","Enable in the main interface")
visuals.indicator_settings = menu.new_elements("int",ui_new_multiselect(t2,"[Indicator settings]","Features list",{"Manual Arrows","Center","Watermark","Menu effect","Damage marker","Scope line","Solus render","Damage indicator"},0,"[~] Indicator features list"))
visuals.disable_glow = menu.new_elements("bool",ui_new_checkbox("bool",t2,"[Indicator settings]","Disable glow",false,"[~] Disable all cointainer's glow"))
visuals.indicator_color = menu.new_elements("color",ui_new_colorpicker(t2,"[Indicator settings]","Main color",224,159,154,255,"[~] Center & Arrows & Effect & Scopeline color"))
visuals.watermark_color = menu.new_elements("color",ui_new_colorpicker(t2,"[Indicator settings]","Watermark color",224,159,154,255,"[~] Watermark color"))
visuals.arrows_mode = menu.new_elements("int",ui_new_combobox(t2,"[Manual Arrows]","Arrows mode",{"+","-"},0,"[~] Arrows mode"))
visuals.arrows_background = menu.new_elements("bool",ui_new_checkbox("bool",t2,"[Manual Arrows]","Background shadow",false,"[~] Arrows background shadow"))
visuals.arrows_distance = menu.new_elements("int",ui_new_slider("int",t2,"[Manual Arrows]","Arrows distance",10,100,15,"[~] Distance between arrows"))
visuals.center_mode = menu.new_elements("int",ui_new_combobox(t2,"[Center]","Center mode",{"Text","Gradient","Pixel","Icon"},0,"[~] Arrows mode"))
visuals.center_scoped_anim = menu.new_elements("int",ui_new_multiselect(t2,"[Center]","Scoped animations",{"Alpha","Postion"},0,"[~] Scoped animations"))
visuals.center_color_2 = menu.new_elements("color",ui_new_colorpicker(t2,"[Center]","Gradient color",170,170,170,255,"[~] Second color"))
visuals.temp_keybind_x = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","TEMP_X",0,sc_x,500,"[~]"))
visuals.temp_keybind_y = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","TEMP_Y",0,sc_y,500,"[~]"))
visuals.temp_spec_x = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","STEMP_X",0,sc_x,500,"[~]"))
visuals.temp_spec_y = menu.new_elements("int",ui_new_slider("int",t2,"[Solus render]","STEMP_Y",0,sc_y,500,"[~]"))
visuals.dmgmarker_mode = menu.new_elements("int",ui_new_combobox(t2,"[Damage marker]","Display mode",{"-","+","++"},0,"[~] Display mode"))
visuals.dmgmarker_display_time = menu.new_elements("int",ui_new_slider("int",t2,"[Damage marker]","Display Duration",1,10,4,"[~] Maker's display time"))
visuals.dmgmarker_speed = menu.new_elements("int",ui_new_slider("int",t2,"[Damage marker]","Speed",1,8,2,"[~] Maker's speed"))
visuals.dmgmarker_color_2 = menu.new_elements("color",ui_new_colorpicker(t2,"[Damage marker]","Normal color",255,255,255,255,"[~] Second color"))
visuals.scopeline_origin = menu.new_elements("int",ui_new_slider("int",t2,"[Scope line]","Scope origin",0,500,100,"[~] Scope origin"))
visuals.scopeline_width = menu.new_elements("int",ui_new_slider("int",t2,"[Scope line]","Scope width",0,500,100,"[~] Scope origin"))
visuals.solus_select = menu.new_elements("int",ui_new_multiselect(t2,"[Solus render]","Solus feature",{"Watermark","Keybind","Spectator"},0,"[~] Solus features"))
visuals.solus_watermark_name = menu.new_elements("str",ui_new_textbox(t2,"[Solus render]","User name",30,userdata.username,"[~] Watermark main text"))
visuals.dmgind_mode = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display mode",{"-","+"},0,"[~] Display mode"))
visuals.dmgind_pos = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display postion",{"Top left","Top right","Bottom left","Bottom Right"},0,"[~] Display mode"))
antiaim.preset_mode = menu.new_elements("int",ui_new_combobox(t3,"[Built-in presets]","Presets manager",{"#1","Custom"},0,"[~] ."))
antiaim.preset_static = menu.new_elements("int",ui_new_multiselect(t3,"[Built-in presets]","Suppress jitter select",_state,0,"[~] Disable jitter when choking commands"))
antiaim.custom_states = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","Condition selection",_state,0,"[~] Select for custom states"))
antiaim.ex_info = ui_new_label(t3,"[Extra-Notice]","Enable in the main interface")
antiaim.ex_select = menu.new_elements("int",ui_new_multiselect(t3,"[Extra antiaim settings]","Extra settings",{"Manual antiaim","Antiaim on use","Edge yaw","Roll"},0,"[~] Select for extra antiaim settings"))
antiaim.ex_manual_yawbase = menu.new_elements("int",ui_new_combobox(t3,"[Extra antiaim settings]","Manual Yawbase",{"At Target", "Forward", "Backward", "Right", "Left", "Freestanding"},0,"[~] Manual yaw base"))
antiaim.on_use_select = menu.new_elements("int",ui_new_multiselect(t3,"[Extra antiaim settings]","Antiaim on use",{"Disable use to plant"},0,"[~] Antiaim on use setting"))
antiaim.ex_prevent_jitter = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Extra antiaim settings]","Prevent sideways jitter",false,"[~] Prevent jitter on sideways"))
antiaim.ex_edge_yaw = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Extra antiaim settings]","Edge yaw",false,"[~] Edge yaw"))
antiaim.ex_roll_states = menu.new_elements("int",ui_new_multiselect(t3,"[Roll settings]","Roll states",{"Stand","Slow walk","Duck","Manual","Use"},0,"[~] Force roll states"))
antiaim.ex_roll_options = menu.new_elements("int",ui_new_multiselect(t3,"[Roll settings]","Extra roll options",{"Jitter","Disable roll when peeking","Unsafe"},0,"[~] Force roll states"))
antiaim.ex_roll_key = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Roll settings]","Roll key",false,"[~] Force roll"))
-- antiaim.ex_roll_inverter = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Roll settings]","Roll inverter",false,"[~] only work on Stand"))
antiaim.custom_data = {}
for k, v in pairs(_state) do
antiaim.custom_data[k] = {
enable = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Custom modifier]","Enable ".._state[k].." setting",false,"[~] Switch states")),
extra_options = menu.new_elements("int",ui_new_multiselect(t3,"[Custom modifier]","["..__state[k].."] Extra options",{"Suppress jitter","Freestand yaw","Desync on shot","Lby modifier","Avert concide","Anti bruteforce"},0,"[~] Extra antiaim options")),
lby_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] LBY mode",{"Opposite","Sway"},0,"[~] LBY modifier funtions")),
desync_on_shot = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Desync on shot",{"Opposite","Freestanding","Switch"},0,"[~] Desync on shot")),
freestanding_bodyyaw = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Freestand yaw",{"Peek fake","Peek real"},0,"[~] Freestanding bodyyaw")),
yaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Yaw built-in funcs",{"Static","Period jitter [Tick]","Period jitter [Choke]","Period jitter [Desync]"},0,"[~] Yaw modifier funtions")),
static_yaw = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw",-90,90,0,"[~] Yaw modifier")),
tick_yaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw left [Tick]",-90,90,0,"[~] Yaw left will jitter by tick")),
tick_yaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw right [Tick]",-90,90,0,"[~] Yaw right will jitter by tick")),
choke_yaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw left [Choke]",-90,90,0,"[~] Yaw left will jitter by choke")),
choke_yaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw right [Choke]",-90,90,0,"[~] Yaw right will jitter by choke")),
desync_yaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw left [Desync]",-90,90,0,"[~] Yaw left will jitter by desync side")),
desync_yaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Yaw right [Desync]",-90,90,0,"[~] Yaw right will jitter by desync side")),
yaw_jitter = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Native yaw mode",{"Disabled","Center","Offset","Random","Spin"},0,"[~] Yaw native funtions")),
yaw_jitter_degree = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Native yaw degree",0,120,0,"[~] Yaw native degree")),
self_bodyyaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Body yaw mode",{"Disabled","Static","Jitter"},0,"[~] Bodyyaw native funtions")),
bodyyaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Body built-in funcs",{"Static","Period jitter","Recursion"},0,"[~] Bodyyaw modifier funtions")),
bodyyaw_degree = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw modifier",-180,180,0,"[~] Body yaw degree modifier")),
jitter_bodyyaw_degree_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw left",-180,180,0,"[~] Body yaw will jitter by your desync side")),
jitter_bodyyaw_degree_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw right",-180,180,0,"[~] Body yaw will jitter by your desync side")),
body_yaw_step_ticks = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Recursion ticks",1,15,0,"[~] Recursion ticks")),
body_yaw_step_value = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Recursion value",0,180,0,"[~] Recursion value")),
step_bodyyaw_degree_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw min",-180,180,0,"[~] Body yaw recursion min")),
step_bodyyaw_degree_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Body yaw max",-180,180,0,"[~] Body yaw recursion max")),
fake_yaw_mode = menu.new_elements("int",ui_new_combobox(t3,"[Custom modifier]","["..__state[k].."] Fake built-in funcs",{"Static","Period tick jitter","Progressive"},0,"[~] Bodyyaw modifier funtions")),
static_fakeyaw = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake yaw limit",0,60,0,"[~] Fake yaw limit")),
jitter_fakeyaw_left = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake left [Period]",0,60,0,"[~] Fake yaw will jitter by period")),
jitter_fakeyaw_right = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake right [Period]",0,60,0,"[~] Fake yaw will jitter by period")),
step_ticks = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Progressive ticks",1,15,7,"[~] Progressive ticks")),
step_value = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Progressive value",1,60,10,"[~] Progressive value")),
step_abs = menu.new_elements("bool",ui_new_checkbox("bool",t3,"[Custom modifier]","["..__state[k].."] Increment absolute value",false,"[~] Progressive will only progress abs value")),
step_fake_min = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake yaw limit min",0,60,0,"[~] Fake yaw limit min ")),
step_fake_max = menu.new_elements("int",ui_new_slider("int",t3,"[Custom modifier]","["..__state[k].."] Fake yaw limit max",0,60,0,"[~] Fake yaw limit max ")),
}
end
misc.select = menu.new_elements("int",ui_new_multiselect(t4,"[Misc features]","Misc settings",{"Anti knife","Animation breaker","Jump scout fix","Trash talk","Hit sound","Extra ragebot settings"},0,"[~] Misc list"))
misc.hitsound_vol = menu.new_elements("int",ui_new_slider("int",t4,"[Hit sound]","Vol",0,100,100,"[~] Hitsound vol"))
misc.antiknife_pitch = menu.new_elements("bool",ui_new_checkbox("bool",t4,"[Anti knife]","Reset pitch on knife",false,"[~] Disable pitch when knife"))
misc.antiknife_distance = menu.new_elements("int",ui_new_slider("int",t4,"[Anti knife]","Anti knife radius",0,1000,280,"[~] Antiknife radius"))
misc.anim_list = menu.new_elements("int",ui_new_multiselect(t4,"[Animation breaker]","Break anims",{"Pitch 0 on land","Static legs in air","Leg fucker"},0,"[~] Break anims list"))
misc.dormant_aimbot = menu.new_elements("int",ui_new_checkbox("bool",t4,"[Dormant aimbot]","Dormant aimbot",false,"[~] Dormant Aimbot"))
misc.dormant_aimbot_dmg = menu.new_elements("int",ui_new_slider("int",t4,"[Dormant aimbot]","Dormant aimbot damage",1,100,10,"[~] Dormant Aimbot damage"))
misc.hitchance_noscope = menu.new_elements("int",ui_new_slider("int",t4,"[Hitchance modifier]","Noscope hitchance",0,100,50,"[~] Noscoped hitchance"))
misc.hitchance_inair = menu.new_elements("int",ui_new_slider("int",t4,"[Hitchance modifier]","In air hitchance",0,100,50,"[~] Noscoped hitchance"))
end,
visible_data = function(self)
local master_switch = ui_get("value",info.master_switch)
ui_set_visible(antiaim.import,master_switch)
ui_set_visible(antiaim.export,master_switch)
ui_set_visible(info.feature_list,master_switch)
local e_ind = ui_get("bool",info.feature_list,1) == true and master_switch
local e_antiaim = ui_get("bool",info.feature_list,2) == true and master_switch
local e_ex_antiaim = ui_get("bool",info.feature_list,3) == true and master_switch
local e_misc = ui_get("bool",info.feature_list,4) == true and master_switch
ui_set_visible(visuals.info,ui_get("bool",info.feature_list,1) == false and master_switch == true and true or false)
ui_set_visible(antiaim.info,ui_get("bool",info.feature_list,2) == false and master_switch == true and true or false)
ui_set_visible(antiaim.ex_info,ui_get("bool",info.feature_list,3) == false and master_switch == true and true or false)
ui_set_visible(misc.info,ui_get("bool",info.feature_list,4) == false and master_switch == true and true or false)
ui_set_visible(visuals.indicator_settings,e_ind)
local e_arrows = ui_get("bool",visuals.indicator_settings,1) == true and e_ind
local e_center = ui_get("bool",visuals.indicator_settings,2) == true and e_ind
local e_watermark = ui_get("bool",visuals.indicator_settings,3) == true and e_ind
local e_menu_effect = ui_get("bool",visuals.indicator_settings,4) == true and e_ind
local e_dmgmarker = ui_get("bool",visuals.indicator_settings,5) == true and e_ind
local e_scopeline = ui_get("bool",visuals.indicator_settings,6) == true and e_ind
local e_solus = ui_get("bool",visuals.indicator_settings,7) == true and e_ind
local e_dmgind = ui_get("bool",visuals.indicator_settings,8) == true and e_ind
ui_set_visible(visuals.dmgind_mode,e_dmgind)
ui_set_visible(visuals.dmgind_pos,e_dmgind)
ui_set_visible(visuals.indicator_color,e_arrows or e_center or e_menu_effect)
ui_set_visible(visuals.disable_glow,e_arrows or e_center or e_menu_effect or e_solus or e_scopeline)
ui_set_visible(visuals.watermark_color,e_watermark or e_solus)
ui_set_visible(visuals.arrows_mode,e_arrows)
ui_set_visible(visuals.arrows_background,e_arrows)
ui_set_visible(visuals.arrows_distance,e_arrows)
ui_set_visible(visuals.center_mode,e_center)
ui_set_visible(visuals.center_scoped_anim,e_center)
ui_set_visible(visuals.center_color_2,e_center and ui_get("value",visuals.center_mode) == 1)
ui_set_visible(visuals.dmgmarker_mode,e_dmgmarker)
ui_set_visible(visuals.dmgmarker_display_time,e_dmgmarker)
ui_set_visible(visuals.dmgmarker_speed,e_dmgmarker)
ui_set_visible(visuals.dmgmarker_color_2,e_dmgmarker)
ui_set_visible(visuals.scopeline_origin,e_scopeline)
ui_set_visible(visuals.scopeline_width,e_scopeline)
ui_set_visible(visuals.solus_select,e_solus)
ui_set_visible(visuals.temp_keybind_x,false)
ui_set_visible(visuals.temp_keybind_y,false)
ui_set_visible(visuals.temp_spec_x,false)
ui_set_visible(visuals.temp_spec_y,false)
ui_set_visible(visuals.solus_watermark_name,e_solus and ui_get("bool",visuals.solus_select,1) == true)
ui_set_visible(antiaim.preset_mode,e_antiaim)
ui_set_visible(antiaim.preset_static,e_antiaim and ui_get("value",antiaim.preset_mode) == 0)
local custom = e_antiaim and ui_get("value",antiaim.preset_mode) == 1
ui_set_visible(antiaim.custom_states,custom)
local selection = ui_get("value",antiaim.custom_states) + 1
for k, v in pairs(_state) do
local switch = ui_get("value",antiaim.custom_data[selection].enable)
local show = custom and switch
for n, c in pairs(antiaim.custom_data[k]) do
ui_set_visible(c,selection == k and e_antiaim and custom)
end
local m = antiaim.custom_data[selection]
ui_set_visible(m.extra_options,show)
local lby = ui_get("bool",m.extra_options,4) == true
local desync = ui_get("bool",m.extra_options,3) == true
local freestand = ui_get("bool",m.extra_options,2) == true
ui_set_visible(m.lby_mode,show and lby)
ui_set_visible(m.desync_on_shot,show and desync)
ui_set_visible(m.freestanding_bodyyaw,show and freestand)
ui_set_visible(m.yaw_mode,show)
local static = ui_get("value",m.yaw_mode) == 0
local tick = ui_get("value",m.yaw_mode) == 1
local choke = ui_get("value",m.yaw_mode) == 2
local desync = ui_get("value",m.yaw_mode) == 3
ui_set_visible(m.static_yaw,show and static)
ui_set_visible(m.tick_yaw_left,show and tick)
ui_set_visible(m.tick_yaw_right,show and tick)
ui_set_visible(m.choke_yaw_left,show and choke)
ui_set_visible(m.choke_yaw_right,show and choke)
ui_set_visible(m.desync_yaw_left,show and desync)
ui_set_visible(m.desync_yaw_right,show and desync)
ui_set_visible(m.yaw_jitter,show)
local yaw_jitter_c = ui_get("value",m.yaw_jitter) ~= 0
ui_set_visible(m.yaw_jitter_degree,show and yaw_jitter_c)
ui_set_visible(m.self_bodyyaw_mode,show)
local bodyyaw_c = ui_get("value",m.self_bodyyaw_mode) ~= 0
ui_set_visible(m.bodyyaw_mode,show and bodyyaw_c)
local static_body = ui_get("value",m.bodyyaw_mode) == 0 and bodyyaw_c
local jitter_body = ui_get("value",m.bodyyaw_mode) == 1 and bodyyaw_c
local step = ui_get("value",m.bodyyaw_mode) == 2 and bodyyaw_c
ui_set_visible(m.bodyyaw_degree,show and static_body)
ui_set_visible(m.jitter_bodyyaw_degree_left,show and jitter_body)
ui_set_visible(m.jitter_bodyyaw_degree_right,show and jitter_body)
ui_set_visible(m.body_yaw_step_ticks,show and step)
ui_set_visible(m.body_yaw_step_value,show and step)
ui_set_visible(m.step_bodyyaw_degree_left,show and step)
ui_set_visible(m.step_bodyyaw_degree_right,show and step)
local fake_c = show and bodyyaw_c
ui_set_visible(m.fake_yaw_mode,fake_c)
local static_fake = ui_get("value",m.fake_yaw_mode) == 0 and fake_c
local jitter_fake = ui_get("value",m.fake_yaw_mode) == 1 and fake_c
local step_fake = ui_get("value",m.fake_yaw_mode) == 2 and fake_c
ui_set_visible(m.static_fakeyaw,fake_c and static_fake)
ui_set_visible(m.jitter_fakeyaw_left,fake_c and jitter_fake)
ui_set_visible(m.jitter_fakeyaw_right,fake_c and jitter_fake)
ui_set_visible(m.step_ticks,fake_c and step_fake)
ui_set_visible(m.step_value,fake_c and step_fake)
ui_set_visible(m.step_abs,fake_c and step_fake)
ui_set_visible(m.step_fake_min,fake_c and step_fake)
ui_set_visible(m.step_fake_max,fake_c and step_fake)
end
ui_set_visible(antiaim.ex_select,e_ex_antiaim)
local e_manual = ui_get("bool",antiaim.ex_select,1) == true and master_switch and e_ex_antiaim
local e_on_use = ui_get("bool",antiaim.ex_select,2) == true and master_switch and e_ex_antiaim
local e_edge_yaw = ui_get("bool",antiaim.ex_select,3) == true and master_switch and e_ex_antiaim
local e_roll = ui_get("bool",antiaim.ex_select,4) == true and master_switch and e_ex_antiaim
ui_set_visible(antiaim.ex_manual_yawbase,e_manual)
ui_set_visible(antiaim.on_use_select,e_on_use)
ui_set_visible(antiaim.ex_prevent_jitter,e_manual)
ui_set_visible(antiaim.ex_edge_yaw,e_edge_yaw)
ui_set_visible(antiaim.ex_roll_states,e_roll)
ui_set_visible(antiaim.ex_roll_options,e_roll)
ui_set_visible(antiaim.ex_roll_key,e_roll)
ui_set_visible(misc.select,e_misc)
local knife = ui_get("bool",misc.select,1) == true and e_misc
local anim = ui_get("bool",misc.select,2) == true and e_misc
local sound = ui_get("bool",misc.select,5) == true and e_misc
local hitchance = ui_get("bool",misc.select,6) == true and e_misc
ui_set_visible(misc.hitsound_vol,sound)
ui_set_visible(misc.antiknife_pitch,knife)
ui_set_visible(misc.antiknife_distance,knife)
ui_set_visible(misc.anim_list,anim)
ui_set_visible(misc.dormant_aimbot,hitchance)
ui_set_visible(misc.dormant_aimbot_dmg,hitchance)
ui_set_visible(misc.hitchance_inair,hitchance)
ui_set_visible(misc.hitchance_noscope,hitchance)
end,
register = function(self)
self.create_data()
self.visible_data()
end
}
g_config:menu()
g_menu:register()
local desync = 0
local IN_FORWARD = bit_lshift(1, 3) -- Walk forward
local IN_JUMP = bit_lshift(1, 1) -- Jump
local check_roll = false
local g_antiaim = {
value_table = {
randomseed = 0,
states = 1,
choke = 0,
antiaim = {
pitch = 0, --0 Disabled --1 Down
yaw_base = 0,
yaw_add = 0,
yaw_jitter = 0, --0 Disabled --1 Center --2 Offset --3 Random --4 Spin
yaw_jitter_degree = 0,
fake_angle = true,
inverter = false,
left_limit = 0,
right_limit = 0,
fake_options = {false,false,false,false}, -- avoid overlap -- jitter -- Randomize jitter -- Anti bruteforce
lby_mode = 0, --0disabled --1 Opposite --2 sway
freestanding_desync = 0, --0 off -- 1peek fake --2 peek real
desync_onshot = 0,--0 disabled --1 Opposite --2 Freestanding --3 Switch
},
on_use = {
using = false,
in_use = bit_lshift(1, 5)
},
on_ground_ticks = 0
},
bodyyaw_jitter = function(c, d, e)
local f = {}
if e == -180 then
f[1] = 0.0
else
if e ~= 0 then
if e == 180 then
f[0] = 0.0
f[1] = d
else
math.randomseed(e)
f[0] = math.random(-d, d)
f[1] = math.random(-d, d)
end
return f[c % 2]
end
f[1] = d
end
f[0] = -d
return f[c % 2]
end,
override_limit = function(self,g, h, i, j, f )
local b = 60
local k = f
local l = self.bodyyaw_jitter(self.value_table.randomseed, 60, k)
self.value_table.antiaim.inverter = l < 0 and true
b = math.abs(l)
AntiAim_OverrideLimit(math.min(b, j))
end,
bodyyaw_jitter_funcs = function(self,f,j)
local m = ClientState.m_choked_commands
local g = EntityList.GetLocalPlayer()
local h = g:GetPlayer():GetActiveWeapon()
if g == nil or h == nil then
return
end
if m == 1 then
self.value_table.randomseed = self.value_table.randomseed + 1
end
self:override_limit(g, h, m, j, f)
end,
bodyyaw_static_funcs = function(self,a, b)
if a > b and a > 0 then
AntiAim_OverrideLimit(math.min(b, 60))
self.value_table.antiaim.inverter = false
elseif a < b and a > 0 then
AntiAim_OverrideLimit(math.min(a, 60))
self.value_table.antiaim.inverter = true
elseif math.abs(a) > b and a < 0 then
AntiAim_OverrideLimit(math.min(b, 60))
self.value_table.antiaim.inverter = true
elseif math.abs(a) < b and a < 0 then
AntiAim_OverrideLimit(math.min(math.abs(a), 60))
self.value_table.antiaim.inverter = true
end
end,
clamp = function(num, min, max)
if num < min then
num = min
elseif num > max then
num = max
end
return num
end,
calculate_angles = function(from, to)
local sub = to - from
local pitch = -math.deg(math.atan2(sub.z, math.sqrt(sub.x ^ 2 + sub.y ^ 2)))
local yaw = math.deg(math.atan2(sub.y, sub.x))
return pitch, yaw
end,
normalize_yaw = function(yaw)
while yaw > 180 do
yaw = yaw - 360
end
while yaw < -180 do
yaw = yaw + 360
end
return yaw
end,
run_onuse = function(self,cmd)
local v = self.value_table.on_use
v.using = false
if ui_get("bool",antiaim.ex_select,2) == true and ui_get("bool",info.feature_list,3) == true then
local is_holding_using = bit_band(cmd.buttons, v.in_use) > 0
local me = entity_get_localplayer()
local active_weapon = me:GetActiveWeapon()
if active_weapon == nil then
return
end
local is_bomb_in_hand = false
if active_weapon then
is_bomb_in_hand = active_weapon:GetClassName() == "CC4"
end
local is_in_bombzone = me:GetProp("m_bInBombZone")
local is_planting = is_in_bombzone and is_bomb_in_hand
local planted_c4_table = EntityList_GetEntitiesByName("CPlantedC4")
local is_c4_planted = #planted_c4_table > 0
local bomb_distance = 100
if is_c4_planted then
local c4_entity = planted_c4_table[#planted_c4_table]
local c4_origin = c4_entity:GetRenderOrigin()
local my_origin = me:GetRenderOrigin()
bomb_distance = my_origin:DistTo(c4_origin)
end
local is_defusing = bomb_distance < 62 and me:GetProp("m_iTeamNum") == 3
if is_defusing then
return
end
local camera_angles = EngineClient_GetViewAngles()
local eye_position = me:GetEyePosition()
local forward_vector = cheat_AngleToForward(camera_angles)
local trace_end = eye_position + forward_vector * 8192
local trace = EngineTrace_TraceRay(eye_position, trace_end, me, 0x4600400B)
local is_using = is_holding_using
if trace and trace.fraction < 1 and trace.hit_entity then
local class_name = trace.hit_entity:GetClassName()
is_using = class_name ~= "CWorld" and class_name ~= "CFuncBrush" and class_name ~= "CCSPlayer"
end
if not is_using and not is_planting then
cmd.buttons = bit_band(cmd.buttons, bit_bnot(v.in_use))
v.using = true
end
end
end,
get_distance = function(x1, y1, z1, x2, y2, z2)
return math.sqrt((x2 - x1) ^ 2 + (y2 - y1) ^ 2 + (z2 - z1) ^ 2)
end,
run_antiknife = function(self)
if ui_get("bool",misc.select,1) == true and ui_get("bool",info.feature_list,4) == true then
local player = EntityList.GetPlayers()
local entity_or = entity_get_prop(entity_get_localplayer(),"m_vecOrigin")
for i = 1, #player do
if player[i] == entity_get_localplayer() or player[i]:IsTeamMate() then
goto skip
end
if Cheat.IsKeyDown(0x45) then
goto skip
end
local entity_e_or = entity_get_prop(player[i], "m_vecOrigin")
local active_weapon = player[i]:GetActiveWeapon()
local distance = self.get_distance(entity_or.x, entity_or.y, entity_or.z, entity_e_or.x, entity_e_or.y, entity_e_or.z)
if active_weapon == nil then
return
end
if active_weapon:IsKnife() and distance <= ui_get("value",misc.antiknife_distance) then
if ui_get("value",misc.antiknife_pitch) then
self.value_table.antiaim.pitch = 0
end
AntiAim.OverrideYawOffset(180)
end
::skip::
end
end
end,
run_direction = function(self)
if ui_get("bool",antiaim.ex_select,1) == true then
local antiaim_yawbase = ui_get("value",antiaim.ex_manual_yawbase)
if antiaim_yawbase == 0 then
self.value_table.antiaim.yaw_base = 4
elseif antiaim_yawbase == 1 then
self.value_table.antiaim.yaw_base = 0
elseif antiaim_yawbase == 2 then
self.value_table.antiaim.yaw_base = 1
elseif antiaim_yawbase == 3 then
self.value_table.antiaim.yaw_base = 2
elseif antiaim_yawbase == 4 then
self.value_table.antiaim.yaw_base = 3
elseif antiaim_yawbase == 5 then
self.value_table.antiaim.yaw_base = 5
end
if ui_get("value",antiaim.ex_prevent_jitter) and (self.value_table.antiaim.yaw_base == 2 or self.value_table.antiaim.yaw_base == 3) then
self.value_table.antiaim.yaw_add = 0
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
AntiAim_OverrideLimit(60)
end
end
end,
run_edge = function(self)
if ui_get("value",antiaim.ex_edge_yaw) and ui_get("bool",antiaim.ex_select,3) == true then
local entity = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
local player = entity:GetPlayer()
local eye_pos = player:GetEyePosition()
local view_angles = EngineClient.GetViewAngles()
local distance = 8192
local closest_point = nil
for i = view_angles.yaw - 180, view_angles.yaw + 180, 15 do
local rotation = math.rad(i)
local point = Vector.new(eye_pos.x + math.cos(rotation) * 100, eye_pos.y + math.sin(rotation) * 100, eye_pos.z)
local trace = EngineTrace.TraceRay(eye_pos, point, entity, 0x4600400b)
if trace.fraction * 100 < distance then
distance = trace.fraction * 100
closest_point = point
end
end
if distance > 30 then
return
end
local _, yaw = self.calculate_angles(eye_pos, closest_point)
local delta = self.normalize_yaw(view_angles.yaw - 180)
local final_yaw = self.normalize_yaw(yaw - delta)
AntiAim.OverrideYawOffset(final_yaw)
end
end,
run_aa_logic = (function()
local aa = {}
local choke_var = 0
local choke_reverse = 0
local clamp = function(num, min, max)
if num < min then
num = min
elseif num > max then
num = max
end
return num
end
aa.get_tick = function(a,b)
return GlobalVars.tickcount % 4 >= 2 and a or b
end
aa.get_choke = function(a,b)
if GlobalVars.tickcount - choke_var > 1 then
choke_reverse = choke_reverse == 1 and 0 or 1
choke_var = GlobalVars.tickcount
end
return choke_reverse >= 1 and a or b
end
aa.get_desync = function(a,b)
return AntiAim_GetInverterState() and a or b
end
local return_value = 0
aa.get_step = function(a,b,step_value,step_tick)
local step_min = a
local step_max = b
local step_v = step_value
local step_t = GlobalVars.tickcount % step_tick
if step_t == step_tick - 1 then
if return_value < step_max then
return_value = return_value + step_v
elseif return_value >= step_max then
return_value = step_min
end
end
return clamp(return_value,step_min,step_max)
end
return aa
end)(),
run_custom = function(self,cmd)
local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)
if on_ground == 1 then
self.value_table.on_ground_ticks = self.value_table.on_ground_ticks + 1
else
self.value_table.on_ground_ticks = 0
end
if ui_get("value",reference.slow_motion) and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[3].enable) then
self.value_table.states = 3
elseif in_air and duck and ui_get("value",antiaim.custom_data[6].enable) then
self.value_table.states = 6
elseif in_air and ui_get("value",antiaim.custom_data[5].enable) then
self.value_table.states = 5
elseif duck and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[4].enable) then
self.value_table.states = 4
elseif velocity > 10 and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[2].enable) and not ui_get("value",reference.slow_motion) then
self.value_table.states = 2
elseif velocity < 2 and self.value_table.on_ground_ticks > 8 and ui_get("value",antiaim.custom_data[1].enable) then
self.value_table.states = 1
end
local m = antiaim.custom_data
local s = self.value_table.states
self.value_table.antiaim.pitch = 1
self.value_table.antiaim.lby_mode = ui_get("bool",m[s].extra_options,4) == true and ui_get("value",m[s].lby_mode) + 1 or 0
self.value_table.antiaim.freestanding_desync = ui_get("bool",m[s].extra_options,2) == true and ui_get("value",m[s].freestanding_bodyyaw) + 1 or 0
self.value_table.antiaim.desync_onshot = ui_get("bool",m[s].extra_options,3) == true and ui_get("value",m[s].desync_on_shot) + 1 or 0
self.value_table.antiaim.fake_options[1] = ui_get("bool",m[s].extra_options,5) == true and true or false
self.value_table.antiaim.fake_options[4] = ui_get("bool",m[s].extra_options,6) == true and true or false
if s == 1 and ui_get("bool",m[1].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 0
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif s == 2 and ui_get("bool",m[2].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 0
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif s == 3 and ui_get("bool",m[3].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 18
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif s == 4 and ui_get("bool",m[4].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 24
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif s == 5 and ui_get("bool",m[5].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 25
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif s == 6 and ui_get("bool",m[5].extra_options,1) == true and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 25
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
else
local static_yaw = ui_get("value",m[s].yaw_mode) == 0
local tick_yaw = ui_get("value",m[s].yaw_mode) == 1
local choke_yaw = ui_get("value",m[s].yaw_mode) == 2
local desync_yaw = ui_get("value",m[s].yaw_mode) == 3
local static_yaw_value = ui_get("value",m[s].static_yaw)
local tick_yaw_value_left = ui_get("value",m[s].tick_yaw_left)
local tick_yaw_value_right = ui_get("value",m[s].tick_yaw_right)
local choke_yaw_value_left = ui_get("value",m[s].choke_yaw_left)
local choke_yaw_value_right = ui_get("value",m[s].choke_yaw_right)
local desync_yaw_value_left = ui_get("value",m[s].desync_yaw_left)
local desync_yaw_value_right = ui_get("value",m[s].desync_yaw_right)
local yaw_jitter = ui_get("value",m[s].yaw_jitter)
local yaw_jitter_value = ui_get("value",m[s].yaw_jitter_degree)
self.value_table.antiaim.yaw_jitter = yaw_jitter
self.value_table.antiaim.yaw_jitter_degree = yaw_jitter_value
if ui_get("value",m[s].yaw_mode) == 3 or ui_get("value",m[s].bodyyaw_mode) == 1 or ui_get("value",m[s].fake_yaw_mode) == 1 then
self.value_table.antiaim.fake_options[2] = true
else
self.value_table.antiaim.fake_options[2] = false
end
if ui_get("value",m[s].yaw_mode) == 0 then
self.value_table.antiaim.yaw_add = static_yaw_value
elseif ui_get("value",m[s].yaw_mode) == 1 then
self.value_table.antiaim.yaw_add = self.run_aa_logic.get_tick(tick_yaw_value_left,tick_yaw_value_right)
elseif ui_get("value",m[s].yaw_mode) == 2 then
self.value_table.antiaim.yaw_add = self.run_aa_logic.get_choke(choke_yaw_value_left,choke_yaw_value_right)
elseif ui_get("value",m[s].yaw_mode) == 3 then
self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(desync_yaw_value_left,desync_yaw_value_right)
end
local fake = ui_get("value",m[s].static_fakeyaw)
if ui_get("value",m[s].fake_yaw_mode) == 0 then
desync = fake
elseif ui_get("value",m[s].fake_yaw_mode) == 1 then
desync = self.run_aa_logic.get_desync(ui_get("value",m[s].jitter_fakeyaw_left),ui_get("value",m[s].jitter_fakeyaw_right))
elseif ui_get("value",m[s].fake_yaw_mode) == 2 then
if ui_get("value",m[s].step_abs) == true then
desync = math.abs(self.run_aa_logic.get_step(ui_get("value",m[s].step_fake_min),ui_get("value",m[s].step_fake_max),ui_get("value",m[s].step_value),ui_get("value",m[s].step_ticks)))
else
desync = self.run_aa_logic.get_step(ui_get("value",m[s].step_fake_min),ui_get("value",m[s].step_fake_max),ui_get("value",m[s].step_value),ui_get("value",m[s].step_ticks))
end
end
if ui_get("value",m[s].self_bodyyaw_mode) == 0 then
self:bodyyaw_static_funcs(0,0)
elseif ui_get("value",m[s].self_bodyyaw_mode) == 1 then
if ui_get("value",m[s].bodyyaw_mode) == 0 then
self:bodyyaw_static_funcs(ui_get("value",m[s].bodyyaw_degree),desync)
elseif ui_get("value",m[s].bodyyaw_mode) == 1 then
self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(ui_get("value",m[s].jitter_bodyyaw_degree_left),ui_get("value",m[s].jitter_bodyyaw_degree_right)),desync)
elseif ui_get("value",m[s].bodyyaw_mode) == 2 then
self:bodyyaw_static_funcs(self.run_aa_logic.get_step(ui_get("value",m[s].step_bodyyaw_degree_left),ui_get("value",m[s].step_bodyyaw_degree_right),ui_get("value",m[s].body_yaw_step_value),ui_get("value",m[s].body_yaw_step_ticks)),desync)
end
elseif ui_get("value",m[s].self_bodyyaw_mode) == 2 then
if ui_get("value",m[s].bodyyaw_mode) == 0 then
self:bodyyaw_jitter_funcs(ui_get("value",m[s].bodyyaw_degree),desync)
elseif ui_get("value",m[s].bodyyaw_mode) == 1 then
self:bodyyaw_jitter_funcs(self.run_aa_logic.get_desync(ui_get("value",m[s].jitter_bodyyaw_degree_left),ui_get("value",m[s].jitter_bodyyaw_degree_right)),desync)
elseif ui_get("value",m[s].bodyyaw_mode) == 2 then
self:bodyyaw_jitter_funcs(self.run_aa_logic.get_step(ui_get("value",m[s].step_bodyyaw_degree_left),ui_get("value",m[s].step_bodyyaw_degree_right),ui_get("value",m[s].body_yaw_step_value),ui_get("value",m[s].body_yaw_step_ticks)),desync)
end
end
end
end,
lean_body = function(self,cmd)
if check_roll == false then
return
end
local local_player = EntityList.GetLocalPlayer()
if (math.abs(cmd.forwardmove) > 1) or (math.abs(cmd.sidemove) > 1) or bit_band(cmd.buttons, IN_JUMP) > 0 or entity_get_prop(local_player, "m_MoveType") == 9 then
return
end
local desync_amount = cmd.viewangles.yaw - desync
if desync_amount == nil then
return
end
if math.abs(desync_amount) < 15 or cmd.chokedcommands == 0 then
return
end
local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)
local inair = bit.band(entity_get_prop(local_player, "m_fFlags" ), 1 ) == 0
if velocity > 80 and not inair then return end
cmd.forwardmove = 0
cmd.buttons = bit.band(cmd.buttons, IN_FORWARD)
end,
roll_var = {
ground_ticks = 0
},
get_roll_states = function(self)
local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)
if on_ground == 1 then
self.roll_var.ground_ticks = self.roll_var.ground_ticks + 1
else
self.roll_var.ground_ticks = 0
end
if Cheat_IsKeyDown(0x45) then
return "USE"
elseif self.value_table.antiaim.yaw_base == 3 or self.value_table.antiaim.yaw_base == 2 then
return "MANUAL"
elseif in_air then
return "IN_AIR"
elseif ui_get("value",reference.slow_motion) and self.roll_var.ground_ticks > 8 then
return "SLOW_WALK"
elseif duck and self.roll_var.ground_ticks > 8 then
return "DUCK"
elseif velocity > 4 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
return "MOVE"
elseif velocity < 2 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
return "STAND"
else
return "IN_AIR"
end
end,
run_roll = function(self,cmd)
if ui_get("bool",antiaim.ex_select,4) == true then
self.value_table.antiaim.pitch = 1
local states = self:get_roll_states()
if ui_get("value",antiaim.ex_roll_key) then
check_roll = true
elseif ui_get("value",reference.autopeek) == true and ui_get("bool",antiaim.ex_roll_options,2) == true then
check_roll = false
elseif states == "USE" and ui_get("bool",antiaim.ex_roll_states,5) == true then
check_roll = true
elseif states == "MANUAL" and ui_get("bool",antiaim.ex_roll_states,4) == true then
check_roll = true
elseif states == "DUCK" and ui_get("bool",antiaim.ex_roll_states,3) == true then
check_roll = true
elseif states == "SLOW_WALK" and ui_get("bool",antiaim.ex_roll_states,2) == true then
check_roll = true
elseif states == "STAND" and ui_get("bool",antiaim.ex_roll_states,1) == true then
check_roll = true
elseif states == "MOVE" then
check_roll = false
elseif states == "IN_AIR" then
check_roll = false
else
check_roll = false
end
local degree = 0
if states == "USE" then
self.value_table.antiaim.yaw_add = 2
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.inverter = false
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
if ui_get("bool",antiaim.ex_roll_options,3) == true then
degree = 90
elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
else
degree = 50
end
end
if states == "MANUAL" then
self.value_table.antiaim.inverter = false
self.value_table.antiaim.yaw_add = -2
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
if ui_get("bool",antiaim.ex_roll_options,3) == true then
degree = -90
elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
else
degree = -50
end
end
if states == "SLOW_WALK" then
self.value_table.antiaim.inverter = false
self.value_table.antiaim.yaw_add = 51
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
if ui_get("bool",antiaim.ex_roll_options,3) == true then
degree = -90
elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
else
degree = -50
end
end
if states == "STAND" then
self.value_table.antiaim.inverter = false
self.value_table.antiaim.yaw_add = 33
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
self.value_table.antiaim.inverter = false
if ui_get("bool",antiaim.ex_roll_options,3) == true then
degree = -90
elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
else
degree = -50
end
end
if states == "DUCK" then
self.value_table.antiaim.yaw_add = 47
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
if ui_get("bool",antiaim.ex_roll_options,3) == true then
degree = -90
elseif ui_get("bool",antiaim.ex_roll_options,1) == true then
degree = GlobalVars.tickcount % 4 >= 2 and 50 or -50
else
degree = -50
end
end
if check_roll == true then
AntiAim_OverrideLimit(58)
self.value_table.antiaim.lby_mode = 0
self:lean_body(cmd)
cmd.viewangles.roll = degree
else
cmd.viewangles.roll = 0
end
else
check_roll = false
cmd.viewangles.roll = 0
end
-- antiaim.ex_roll_states = "[Roll settings]","Roll states",{"Stand","Slow walk","Duck","Manual","Use"}
-- antiaim.ex_roll_options = "[Roll settings]","Extra roll options",{"Jitter","Disable roll when peeking","Unsafe"},
-- antiaim.ex_roll_key = "[Roll settings]","Roll key",false,"[~] Force roll"))
-- antiaim.ex_roll_inverter = "[Roll settings]","Roll inverter",false,"[~] only work on Stand"))
end,
run_presets_states = function(self,cmd)
local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)
if on_ground == 1 then
self.roll_var.ground_ticks = self.roll_var.ground_ticks + 1
else
self.roll_var.ground_ticks = 0
end
if Cheat_IsKeyDown(0x45) then
return "USE"
elseif self.value_table.antiaim.yaw_base == 3 or self.value_table.antiaim.yaw_base == 2 then
return "MANUAL"
elseif in_air and duck then
return "AIR_DUCK"
elseif in_air then
return "IN_AIR"
elseif ui_get("value",reference.slow_motion) and self.roll_var.ground_ticks > 8 then
return "SLOW_WALK"
elseif duck and self.roll_var.ground_ticks > 8 then
return "DUCK"
elseif velocity > 4 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
return "MOVE"
elseif velocity < 2 and self.roll_var.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
return "STAND"
else
return "AIR_DUCK"
end
end,
run_presets_1 = function(self,cmd)
local states = self:run_presets_states(cmd)
self.value_table.antiaim.pitch = 1
if states == "STAND" and ui_get("bool",antiaim.preset_static,1) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 0
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif states == "STAND" then
self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(5,18)
self.value_table.antiaim.yaw_jitter = 1
self.value_table.antiaim.yaw_jitter_degree = 60
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
st_deysnc = self.run_aa_logic.get_step(20,60,1,2)
self:bodyyaw_static_funcs(self.run_aa_logic.get_step(90,180,1,1),st_deysnc)
self.value_table.antiaim.fake_options[2] = true
end
if states == "MOVE" and ui_get("bool",antiaim.preset_static,2) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 0
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif states == "MOVE" then
self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-14,26)
self.value_table.antiaim.yaw_jitter = 1
self.value_table.antiaim.yaw_jitter_degree = 40
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
mv_deysnc = self.run_aa_logic.get_step(20,60,5,3)
self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(180,180),mv_deysnc)
self.value_table.antiaim.fake_options[2] = true
end
if states == "SLOW_WALK" and ui_get("bool",antiaim.preset_static,3) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 18
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif states == "SLOW_WALK" then
self.value_table.antiaim.fake_options[2] = true
self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-2,20)
self.value_table.antiaim.yaw_jitter = 1
self.value_table.antiaim.yaw_jitter_degree = 60
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
sw_deysnc = self.run_aa_logic.get_step(20,60,1,2)
self:bodyyaw_static_funcs(self.run_aa_logic.get_step(90,180,1,1),sw_deysnc)
end
if states == "DUCK" and ui_get("bool",antiaim.preset_static,4) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 25
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif states == "DUCK" then
self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-5,35)
self.value_table.antiaim.yaw_jitter = 1
self.value_table.antiaim.yaw_jitter_degree = 40
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
end
if states == "IN_AIR" and ui_get("bool",antiaim.preset_static,5) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 25
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif states == "IN_AIR" then
self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(2,16)
self.value_table.antiaim.yaw_jitter = 1
self.value_table.antiaim.yaw_jitter_degree = 51
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
local arid = self.run_aa_logic.get_step(30,60,5,2)
self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(180,180),arid)
self.value_table.antiaim.fake_options[2] = true
end
if states == "AIR_DUCK" and ui_get("bool",antiaim.preset_static,6) and not ui_get("value",reference.dt) and not ui_get("value",reference.hs) then
self.value_table.antiaim.yaw_add = 25
self.value_table.antiaim.yaw_jitter = 0
self.value_table.antiaim.yaw_jitter_degree = 0
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
self.value_table.antiaim.fake_options[1] = false
self.value_table.antiaim.fake_options[2] = false
self.value_table.antiaim.fake_options[3] = false
self.value_table.antiaim.fake_options[4] = false
elseif states == "AIR_DUCK" then
self.value_table.antiaim.yaw_add = self.run_aa_logic.get_desync(-1,33)
self.value_table.antiaim.yaw_jitter = 1
self.value_table.antiaim.yaw_jitter_degree = 45
self.value_table.antiaim.fake_angle = true
self.value_table.antiaim.inverter = false
self.value_table.antiaim.left_limit = 60
self.value_table.antiaim.right_limit = 60
AIR_deysnc = self.run_aa_logic.get_step(30,60,5,2)
self:bodyyaw_static_funcs(self.run_aa_logic.get_desync(-180,180),AIR_deysnc)
self.value_table.antiaim.fake_options[2] = true
end
-- antiaim.preset_static = menu.new_elements("int",ui_new_multiselect(t3,
-- "[Built-in presets]","Suppress jitter select",_state,0,"[~] Disable jitter when choking commands"))
-- local _state = {"Stand","Move","Slow walk","Duck","Air","Air + D"}
end,
run_main = function(self,cmd)
self.value_table.choke = cmd.chokedcommands
self:run_roll(cmd)
if check_roll == false then
if ui_get("value",antiaim.preset_mode) == 0 then
self:run_presets_1(cmd)
elseif ui_get("value",antiaim.preset_mode) == 1 then
self:run_custom(cmd)
end
end
self:run_direction()
self:run_edge()
self:run_antiknife()
if Cheat.IsKeyDown(0x45) then
self.value_table.antiaim.pitch = 0
self.value_table.antiaim.yaw_add = 0
self.value_table.antiaim.yaw_base = 0
self.value_table.antiaim.freestanding_desync = 1
end
ui_set("value",reference.pitch,self.value_table.antiaim.pitch)
ui_set("value",reference.yaw_base,self.value_table.antiaim.yaw_base)
ui_set("value",reference.yaw_add,self.value_table.antiaim.yaw_add)
ui_set("value",reference.yaw_jitter_mode,self.value_table.antiaim.yaw_jitter)
ui_set("value",reference.yaw_jitter_slider,self.value_table.antiaim.yaw_jitter_degree)
ui_set("value",reference.fake_angle,self.value_table.antiaim.fake_angle)
ui_set("value",reference.inverter,self.value_table.antiaim.inverter)
ui_set("value",reference.left_limit,self.value_table.antiaim.left_limit)
ui_set("value",reference.right_limit,self.value_table.antiaim.right_limit)
ui_set("bool",reference.fake_option,1,self.value_table.antiaim.fake_options[1])
ui_set("bool",reference.fake_option,2,self.value_table.antiaim.fake_options[2])
ui_set("bool",reference.fake_option,3,self.value_table.antiaim.fake_options[3])
ui_set("bool",reference.fake_option,4,self.value_table.antiaim.fake_options[4])
ui_set("value",reference.lby,self.value_table.antiaim.lby_mode)
ui_set("value",reference.freestanding_yaw,self.value_table.antiaim.freestanding_desync)
ui_set("value",reference.desync_shot,self.value_table.antiaim.desync_onshot)
end,
run_jumpscout_fix = function()
if ui_get("bool",misc.select,3) == true then
local me = EntityList.GetLocalPlayer()
if me == nil then
return
end
local weap = me:GetActiveWeapon()
if weap == nil then
return
end
local speed_x = me:GetProp("DT_BasePlayer", "m_vecVelocity[0]")
local speed_y = me:GetProp("DT_BasePlayer", "m_vecVelocity[1]")
local speed = math.sqrt(speed_x * speed_x + speed_y * speed_y)
if weap:IsGrenade() then
ui_set("value",reference.auto_starfe,true)
else
if speed < 5 then
ui_set("value",reference.auto_starfe,false)
else
ui_set("value",reference.auto_starfe,true)
end
end
else
ui_set("value",reference.auto_starfe,ui_get("value",reference.auto_starfe))
end
end,
load_antiaim = function(self,cmd)
local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
if not localplayer then return end
local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
if not my_index then return end
if not ui_get("bool",info.feature_list,2) == true then return end
if EngineClient.IsConnected() and my_index:IsAlive() then
self:run_main(cmd)
end
end,
load_pre_antiaim = function(self,cmd)
local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
if not localplayer then return end
local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
if not my_index then return end
if not ui_get("bool",info.feature_list,2) == true then return end
if EngineClient.IsConnected() and my_index:IsAlive() then
self:run_jumpscout_fix()
self:run_onuse(cmd)
end
end
}
local damage_indicator_displays = {}
local g_misc = {
phrases = {
"by UNFAILEr hvh boss",
"sleep",
"GLhf.exe Activated",
"what you do dog??",
"1 week lou doggo ovnet",
"l2p bot",
"why you sleep dog???",
"$$$ 1 TAP UFF YA $$$",
"0 iq",
"iq ? HAHAHA",
"Best and cheap configurations for gamesense, ot and neverlose waiting for your order at ---> shoppy.gg/@Xamidimura",
"最好的AA -> Ataraxia.pub",
"中国的科技?>Ataraxia.pub,最好的AA",
"XAXAXAXAXAXA (◣_◢)",
},
get_phrase = function(self)
return self.phrases[Utils.RandomInt(1, #self.phrases)]:gsub('\"', '')
end,
run_trashtalk = function(self,event)
if event:GetName() ~= "player_death" then return end
local me = EntityList.GetLocalPlayer()
local victim = EntityList.GetPlayerForUserID(event:GetInt("userid"))
local attacker = EntityList.GetPlayerForUserID(event:GetInt("attacker"))
if victim == attacker or attacker ~= me then return end
if ui_get("bool",misc.select,4) == true then
EngineClient.ExecuteClientCmd('say "' .. self:get_phrase() .. '"')
end
end,
clant_var = {
_set_clantag = ffi.cast('int(__fastcall*)(const char*, const char*)', Utils.PatternScan('engine.dll', '53 56 57 8B DA 8B F9 FF 15')),
_last_clantag = nil,
},
set_clantag = function(self,v)
if v == self.clant_var._last_clantag then return end
self.clant_var._set_clantag(v, v)
self.clant_var._last_clantag = v
end,
set_callback_clantag = function(self)
end,
run_marker_hurt = function(self,e)
if e:GetName() ~= "player_hurt" then return end
if e:GetInt("userid") == nil or e:GetInt("attacker") == nil or e:GetInt("dmg_health",0) == nil then
return
end
local player = EntityList.GetPlayerForUserID(e:GetInt("userid"))
local get_player_origin = entity_get_prop(player,"m_vecOrigin")
if get_player_origin.x == nil or get_player_origin.y == nil or get_player_origin.z == nil then
return
end
local voZ = entity_get_prop(player,"m_vecViewOffset[2]")
if e.hitgroup == 1 then
check_headshot = true
else
check_headshot = false
end
table_insert(damage_indicator_displays,{e:GetInt("dmg_health",0),GlobalVars.realtime,get_player_origin.x,get_player_origin.y,get_player_origin.z + voZ,check_headshot})
end,
run_hitsound = function(self,e)
if e:GetName() ~= "player_hurt" then return end
local localplayer = entity_get_localplayer()
local attacker = EntityList.GetPlayerForUserID(e:GetInt("attacker"))
if attacker == localplayer then
if ui_get("bool",misc.select,5) == true then
EngineClient.ExecuteClientCmd(string.format("playvol %s %s", "buttons/arena_switch_press_02",ui_get("value",misc.hitsound_vol)/100))
end
end
end,
run_autostop = function(self,cmd, goal_speed)
local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
if not localplayer then return end
local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
if not my_index then return end
local minspeed = math.sqrt((cmd.forwardmove * cmd.forwardmove) + (cmd.sidemove * cmd.sidemove))
if goal_speed <= 0 or minspeed <= 0 then return end
local flags = my_index:GetProp("m_fFlags")
if bit.band(flags, 4) == 4 then
goal_speed = goal_speed * 2.94117647
end
if minspeed <= goal_speed then return end
local speed_factor = goal_speed / minspeed
cmd.forwardmove = cmd.forwardmove * speed_factor
cmd.sidemove = cmd.sidemove * speed_factor
end,
vars = {
player_info_prev = {},
round_started = 0,
is_dormant_flag = false,
minimal_vector = Vector.new(),
maximal_vector = Vector.new()
},
calculate_angles = function(self,source, point)
local world_to_screen = function(x_position, y_position)
if x_position == 0 and y_position == 0 then return 0 end
local atan_position = math.atan2(y_position, x_position)
local deg_position = math.deg(atan_position)
return deg_position
end
local delta_of_vectors = point - source
local hyp = math.sqrt(delta_of_vectors.x * delta_of_vectors.x + delta_of_vectors.y * delta_of_vectors.y)
local yaw = world_to_screen(delta_of_vectors.x, delta_of_vectors.y)
local pitch = world_to_screen(hyp, -delta_of_vectors.z)
return Vector.new(pitch, yaw, 0)
end,
get_hittable_damage = function(self,my_index, enemy, start_point, end_point)
if my_index ~= nil then
if enemy ~= nil then
local bullet_data = Cheat.FireBullet(my_index, start_point, end_point)
local bullet_damage = bullet_data.damage
local minimum_damage = ui_get("value",misc.dormant_aimbot_dmg)
local enemy_health = enemy:GetProp("m_iHealth")
if bullet_damage < math.min(minimum_damage, enemy_health) then
return 0
end
if bullet_data.trace.hit_entity ~= nil then
if bullet_data.trace.hit_entity:EntIndex() ~= enemy:EntIndex() then
return 0
end
end
if enemy:IsVisible(end_point) then
return 0
end
return bullet_damage
end
end
end,
run_dormant_aimbot = function(self,cmd)
if ui_get("value",misc.dormant_aimbot) then
local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
if not localplayer then return end
local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
if not my_index then return end
local my_weapon = my_index:GetActiveWeapon()
if not my_weapon then return end
local weapon_id = my_weapon:GetWeaponID()
if not weapon_id then return end
if EngineClient.IsConnected() and my_index:IsAlive() then
local get_inaccuracy = my_weapon:GetInaccuracy(my_weapon)
local tickcount = GlobalVars.tickcount
local player_resource = EntityList.GetPlayerResource()
local eye_position = my_index:GetEyePosition()
local simulation_time = my_index:GetProp("m_flSimulationTime")
local on_ground = bit.band(my_index:GetProp("m_fFlags"), bit.lshift(1, 0)) == 1 and true or false
if tickcount < self.vars.round_started then
return
end
local primary_attack = my_weapon:GetProp("m_flNextPrimaryAttack")
local next_attack = my_index:GetProp("m_flNextAttack")
local secondary_attack = my_weapon:GetProp("m_flNextSecondaryAttack")
local can_shoot = false
if weapon_id == 64 then -- revolver
can_shoot = simulation_time > primary_attack
elseif my_weapon:IsKnife() or my_weapon:IsGrenade() or weapon_id == 31 then
can_shoot = false
else
can_shoot = simulation_time > math.max(next_attack, primary_attack, secondary_attack)
end
local player_info = {}
local players = EntityList.GetEntitiesByName("CCSPlayer")
for i = 1, #players do
local enemy = players[i]:GetPlayer()
if enemy ~= my_index and not enemy:IsTeamMate() and enemy:IsAlive() then
local network_state = enemy:GetNetworkState()
if enemy:IsDormant() and network_state ~= -1 then
local can_hit = false
local origin = enemy:GetProp("m_vecOrigin")
local alpha_multiplier = enemy:GetESPAlpha()
if self.vars.player_info_prev[i] ~= nil and origin.x ~= 0 and alpha_multiplier > 0 then
local is_dormant_accurate = alpha_multiplier > 0.2
if is_dormant_accurate then
local bounds = enemy:GetRenderBounds(self.vars.minimal_vector, self.vars.maximal_vector)
local all_vector_points = {
origin + Vector.new(0, 0, 38),
origin + Vector.new(0, 0, 40),
origin + Vector.new(0, 0, 42),
origin + Vector.new(0, 0, 50)
}
local best_damage = 0
local best_point = Vector.new()
local my_eye_position = my_index:GetEyePosition()
for point = 1, #all_vector_points do
local current_point = all_vector_points[point]
local start_position = self:calculate_angles(my_eye_position, current_point)
local damage = self:get_hittable_damage(my_index, enemy, my_eye_position, current_point)
if damage > best_damage then
best_damage = damage
best_point = start_position
can_hit = true
end
end
local get_max_speed = my_weapon:GetMaxSpeed()
if can_shoot and can_hit then
self.vars.is_dormant_flag = true
self:run_autostop(cmd, get_max_speed * 0.33)
if get_inaccuracy < 0.009 then
cmd.viewangles.pitch = best_point.x
cmd.viewangles.yaw = best_point.y
cmd.viewangles.roll = 0.0
cmd.buttons = bit.bor(cmd.buttons, 1)
self.vars.is_dormant_flag = true
can_shoot = false
end
elseif not can_hit then
self.vars.is_dormant_flag = false
end
end
end
player_info[i] = {origin, alpha_multiplier, can_hit}
end
end
end
self.vars.player_info_prev = player_info
end
end
end,
reset_data = function(self, e)
if ui_get("value",misc.dormant_aimbot) then
local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
if not localplayer then return end
local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
if not my_index then return end
if EngineClient.IsConnected() and my_index:IsAlive() then
if e:GetName() == "round_prestart" then
local mp_freezetime = CVar.FindVar("mp_freezetime"):GetFloat()
local ticks = GlobalVars.interval_per_tick
local freezetime = (mp_freezetime + 1) / ticks
local tickcount = GlobalVars.tickcount
self.vars.round_started = tickcount + freezetime
end
end
end
end,
run_evets = function(self,e)
if e:GetName() == "round_start" then
table.insert(noti_table, {
text = "Reseted data due to round start",
timer = GlobalVars.realtime,
smooth_y = sc_y + 100,
alpha = 0,
})
end
if e:GetName() == "player_death" then
if EntityList.GetPlayerForUserID(e:GetInt("userid")) == EntityList.GetLocalPlayer() then
table.insert(noti_table, {
text = "Reseted data due to player death",
timer = GlobalVars.realtime,
smooth_y = sc_y + 100,
alpha = 0,
})
end
end
if e:GetName() == "player_hurt" then
if EntityList.GetPlayerForUserID(e:GetInt("userid")) == EntityList.GetLocalPlayer() and e:GetInt("hitgroup") ~= 0 then
table.insert(noti_table, {
text = "Received data due to player hurt",
timer = GlobalVars.realtime,
smooth_y = sc_y + 100,
alpha = 0,
})
end
end
end,
run_hitchance = function(self)
if ui_get("bool",misc.select,6) == true then
if entity_get_localplayer() == nil then
return
end
local is_scoped = entity_get_prop(entity_get_localplayer(),"m_bIsScoped")
local player = entity_get_localplayer()
local weapon = player:GetActiveWeapon()
local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
if weapon ~= nil then
if weapon:GetWeaponID() == 38 or 11 or 9 or 40 then
if not is_scoped then
for i = 1, 64 do
RageBot.OverrideHitchance(i, ui_get("value",misc.hitchance_noscope))
end
end
end
end
if on_ground == 0 then
for i = 1, 64 do
RageBot.OverrideHitchance(i, ui_get("value",misc.hitchance_inair))
end
end
end
end,
hit_groups = {
[0] = "body",
[1] = "head",
[2] = "chest",
[3] = "stomach",
[4] = "left arm",
[5] = "right arm",
[6] = "left leg",
[7] = "right leg",
[10] = "unknown"
},
get_round = function(self,num, numDecimalPlaces)
return tonumber(string.format("%." .. (numDecimalPlaces or 0) .. "f", num))
end,
on_shot = function(self,e)
local entity = EntityList.GetClientEntity(e.target_index)
local player = entity:GetPlayer()
local reason = ""
if (e.reason == 0) then
self:on_hurt(e)
return
elseif (e.reason == 1) then
reason = "resolver"
if (Menu.FindVar("Aimbot", "Ragebot", "Main", "Override Resolver"):GetBool()) then
reason = "resolver"
end
elseif (e.reason == 2) then
reason = "spread degree (" .. tostring(self:get_round(e.spread_degree, 3)) .."°) safepoint (false)"
elseif (e.reason == 3) then
reason = "spread degree (" .. tostring(self:get_round(e.spread_degree, 3)) .."°) safepoint (true)"
elseif (e.reason == 4) then
reason = "prediction error"
end
local hitbox = ""
if ((e.wanted_hitgroup > -1 and e.wanted_hitgroup < 8) or e.wanted_hitgroup == 10) then
hitbox = self.hit_groups[e.wanted_hitgroup]
else
hitbox = "unknown"
end
debugger("Missed ["..player:GetName().."] hitbox: [".. hitbox.."] hitchance: ["..e.hitchance.."] reason: ["..reason.."] backtrack: ".. e.backtrack.."ticks health remain: ["..entity:GetProp('m_iHealth').."]")
end,
on_hurt = function(self,e)
if e.reason > 0 and e.reason < 5 then
self:on_shot(e)
return
end
local entity = EntityList.GetClientEntity(e.target_index)
local player = entity:GetPlayer()
local hitbox = ""
if ((e.hitgroup > -1 and e.hitgroup < 8) or e.hitgroup == 10) then
hitbox = self.hit_groups[e.hitgroup]
else
hitbox = "unknown"
end
debugger("Hit ["..player:GetName().."] hitbox: ["..hitbox.."] hitchance: ["..e.hitchance.."] damage: ["..e.damage.."] backtrack: ".. e.backtrack.."ticks health remain: ["..entity:GetProp('m_iHealth').."]")
end,
run_hitlog = function(self,e)
self:on_shot(e)
end,
load_events = function(self,event)
self:run_trashtalk(event)
self:run_marker_hurt(event)
self:run_hitsound(event)
self:run_evets(event)
self:reset_data(event)
end
}
local lerp = function(start, vend, time)
return start + (vend - start) * time
end
local render_measure_text = function(size,fonts,text)
local size = Render_CalcTextSize(text,size,fonts)
return size
end
local render_text = function(x,y,fonts,size,outline,center,r,g,b,a,text)
Render_Text(text,Vector2.new(x,y),Color_RGBA(math.floor(r),math.floor(g),math.floor(b),math.floor(a)),size,fonts,outline,center)
end
local render_rectangle = function(x,y,w,h,r,g,b,a,round)
Render_BoxFilled(Vector2.new(x ,y ),Vector2.new(x + w,y + h),Color_new(r/255,g/255,b/255,a/255),round)
end
local render_Box = function(x,y,w,h,r,g,b,a,round)
Render.Box(Vector2.new(x ,y ),Vector2.new(x + w,y + h),Color_new(r/255,g/255,b/255,a/255),round)
end
local render_gradient = function(x,y,w,h,r,g,b,a,r1,g1,b1,a1,type)
local first_gradient = Color_new(r/255,g/255,b/255,a/255)
local second_gradient = Color_new(r1/255,g1/255,b1/255,a1/255)
if type == true then
Render_GradientBoxFilled(Vector2.new(x, y), Vector2.new(x + w, y + h),first_gradient,second_gradient,first_gradient, second_gradient)
elseif type == false then
Render_GradientBoxFilled(Vector2.new(x, y), Vector2.new(x + w, y + h), first_gradient, first_gradient, second_gradient, second_gradient)
end
end
local render_circle_outline = function(x,y,radius,r,g,b,a,thickness,start,enddegree)
Render.Circle(Vector2.new(x, y),radius, 32, Color.new(r/255, g/255, b/255, a/255),thickness,start,enddegree)
end
local render_circle = function(x,y,radius,r,g,b,a,start,enddegree)
Render_CircleFilled(Vector2.new(x, y), radius, 30, Color.new(r/255, g/255, b/255, a/255))
end
local render_glow_rectangle = function(x,y,w,h,r,g,b,a,round,size,g_w)
for i = 1 , size , 0.3 do
local fixpositon = (i - 1) * 2
local fixi = i - 1
render_Box(x - fixi, y - fixi, w + fixpositon , h + fixpositon , r , g ,b , (a - i * g_w) , round)
end
end
local render_glow_rectangle_gradient = function(x,y,w,h,r,g,b,a,r1,g1,b1,a1,type,size,g_w,type)
for i = 1 , size , 1.0 do
local fixpositon = (i - 1) * 2
local fixi = i - 1
render_gradient(x - fixi, y - fixi, w + fixpositon , h + fixpositon , r , g ,b , (a - i * g_w) ,r1,g1,b1, (a1 - i * g_w) , type)
end
end
local linear = function(check,val,value,speed)
if check then
return val + (value - val) * GlobalVars.frametime * speed
else
return val - (value + val) * GlobalVars.frametime * speed / 2;
end
end
local entity_is_enemy = function(index)
if index == nil then
return false
end
return index:IsTeamMate() == false
end
local entity_is_alive = function(index)
if index == nil then
return false
end
return entity_get_prop(index,"m_lifeState") == false
end
local distance_3d = function(x1,y1,z1,x2,y2,z2)
if x1 == nil or y1 == nil or z1 == nil or x2 == nil or y2 == nil or z2 == nil then
return 0
end
return math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
end
local client_threat = function()
local me = entity_get_localplayer()
if entity_get_localplayer() == nil then
return nil
end
local lm = entity_get_prop(entity_get_localplayer(),"m_vecOrigin")
local lx,ly,lz = lm.x,lm.y,lm.z
local view = EngineClient_GetViewAngles()
local viewangle_x,viewangle_y,roll = view.pitch,view.yaw,view.roll
local enemies = EntityList.GetPlayers()
if #enemies == 0 then
return nil
end
local data = {id = nil ,dis = 0 ,last_dmg = 0}
for k, v in pairs(enemies) do
if (not entity_is_enemy(enemies[k]) or (enemies[k] == me) or (not entity_is_alive(enemies[k])) or (enemies[k]:IsDormant())) then goto skip end
local em = enemies[k]:GetProp("m_vecOrigin")
local ex,ey,ez = em.x,em.y,em.z
local trace = Cheat.FireBullet(me,Vector.new(ex,ey,ez),Vector.new(lx,ly,lz))
if trace.damage > data.last_dmg then
table_insert(data,{id = enemies[k],dis = distance_3d(lx,ly,lz,ex,ey,ez),last_dmg = trace.damage})
end
::skip::
end
if data == nil then
return
end
if data.id == nil then
return
end
return data
end
local gradient_text = function(b, c, d, e, f, g, h, i, j, k, l, size, fonts, out)
local m = ""
local n = 0
local o = #l - 1
local p = (h - d) / o
local q = (i - e) / o
local r = (j - f) / o
local s = (k - g) / o
for t = 1, o + 1 do
local u = string.sub(l, t, t)
local v = Render.CalcTextSize(u, size, fonts)
Render.Text(u .. "", Vector2.new(b + n, c), Color.new(d, e, f, g), size, fonts, out)
d = d + p
e = e + q
f = f + r
g = g + s
n = n + v.x
end
end
local FONTS = {
PIXEL_10 = Render_InitFont("Smallest Pixel-7",10,{"","",""}),
PIXEL_11 = Render_InitFont("Smallest Pixel-7",11,{"","",""}),
PIXEL_12 = Render_InitFont("Smallest Pixel-7",12,{"","",""}),
PIXEL_18 = Render_InitFont("Smallest Pixel-7",18,{"","",""}),
TAHOMA_15 = Render_InitFont("Tahoma",15,{"","",""}),
TAHOMA_15_BOLD = Render_InitFont("Tahoma",15,{"b","",""}),
TAHOMA_12_BOLD = Render_InitFont("Tahoma",12,{"b","",""}),
VERDANA_12 = Render_InitFont("Verdana",11,{"","",""}),
VERDANA_12_BOLD = Render_InitFont("Verdana",11,{"b","",""}),
VERDANA_12_R = Render_InitFont("Verdana",11,{"","","r"}),
VERDANA_13 = Render_InitFont("Verdana",13,{"","",""}),
VERDANA_13_BOLD = Render_InitFont("Verdana",13,{"b","",""}),
VERDANA_36_BOLD = Render_InitFont("Verdana",36,{"b","",""}),
VERDANA_40_BOLD = Render_InitFont("Verdana",40,{"b","",""}),
ARROWS_12 = Render.InitFont("Acta Symbols W95 Arrows", 12),
ARROWS_24 = Render.InitFont("Acta Symbols W95 Arrows", 20)
}
local svg = '<svg t="1650815150236" class="icon" viewBox="0 0 1024 1024" version="1.1" xmlns="http://www.w3.org/2000/svg" p-id="1757" width="200" height="200"><path d="M750.688207 480.651786c-40.458342 65.59852-115.105654 102.817686-205.927943 117.362627 2.382361 26.853806 0.292571 62.00408 20.897903 102.232546 40.77181 79.621013 76.486328 166.28462 88.356337 229.897839 69.819896 30.824408 215.958937-42.339153 257.671154-134.540705 44.721514-98.847085 0-202.082729-74.103967-210.755359-74.083069-8.651732-117.655198 31.555835-109.902076 78.65971 7.732224 47.103875 51.868597 47.918893 96.485622 16.822812 44.617024-31.075183 85.869486 32.517138 37.992389 60.562125-47.897995 28.044987-124.133548 44.867799-168.228125-5.642434-44.094577-50.489335-40.458342-228.205109 143.65219-211.716662 184.110532 16.509344 176.127533 261.683551 118.804583 344.042189C894.465785 956.497054 823.600993 1024.519731 616.37738 1023.997283h-167.18323V814.600288 1023.997283h-168.269921c-83.424432 0-24.743118-174.267619 51.826801-323.750324 20.584435-40.228465 18.494645-75.378739 20.897904-102.232546C262.784849 583.469472 188.137536 546.250306 147.679195 480.651786H93.867093A20.814312 20.814312 0 0 1 73.031883 459.753882c0-11.535643 9.46675-20.897904 20.83521-20.897903H127.993369a236.480679 236.480679 0 0 1-10.093687-41.795808H52.071285A20.814312 20.814312 0 0 1 31.236075 376.162267c0-11.535643 9.46675-20.897904 20.83521-20.897903H114.82769v-0.877712c0-57.009481 15.171878-103.131155 41.795808-139.514406V28.379353c0-11.535643 8.630834-17.136281 19.267867-12.517844l208.979037 90.864085c20.793414-2.08979 42.318255-3.113788 64.323748-3.113787s43.530333 1.044895 64.344646 3.134685l208.979037-90.884983c10.616135-4.618437 19.246969 0.982201 19.246969 12.538742v186.471995c26.623929 36.38325 41.795807 82.504924 41.795808 139.514406V355.264364h62.756405c11.493847 0 20.83521 9.278669 20.83521 20.897903 0 11.535643-9.46675 20.897904-20.83521 20.897904h-65.828397a236.480679 236.480679 0 0 1-10.093688 41.795808h34.126277c11.493847 0 20.83521 9.278669 20.83521 20.897903 0 11.535643-9.46675 20.897904-20.83521 20.897904h-53.833z" p-id="1758" fill="#ffffff"></path></svg>'
local image_loaded = Render.LoadImage(svg, Vector2_new(32,32))
local render_stringwithshadow = function(type,x,y,center,r,g,b,a,text)
if type == "n" then
render_text(x + 1,y + 1,FONTS.VERDANA_12,11,false,center,30,30,30,a,text)
render_text(x,y,FONTS.VERDANA_12,11,false,center,r,g,b,a,text)
elseif type == "b" then
render_text(x + 1,y + 1,FONTS.VERDANA_12_BOLD,11,false,center,30,30,30,a,text)
render_text(x,y,FONTS.VERDANA_12_BOLD,11,false,center,r,g,b,a,text)
end
end
local is_breaking_lc = false
local last_sent,current_choke = 0,0
local g_visual = {
g_vars = {
check_show = false,
check_show_time = GlobalVars.realtime,
g_alpha = 0,
arrows = {
g_alpha = 0,
l=0,
r=0
},
menu_effect = {
g_alpha = 0,
o_alpha = 0,
height = 0,
cur_alpha = 200,
min_alpha = 75,
max_alpha = 200,
target_alpha = 0,
speed = 0.08,
last_change = GlobalVars.realtime - 1,
dots_alpha = 0,
key_last_press = 0,
dots = {},
dot_size = 3,
menu_open_prev = true,
},
watermark = {
g_alpha = 0,
cur_alpha = 1,
min_alpha = 0.2,
max_alpha = 1,
target_alpha = 0,
speed = 0.2,
},
center = {
g_alpha = 0,
o_alpha = 0,
add_x = 0,
cur_alpha = 22,
min_alpha = 15,
max_alpha = 22,
target_alpha = 0,
speed = 0.2,
add_y = 0,
width = 0,
r_alpha = 0,
desync_line = 0,
left_r = 0,
left_g = 0,
left_b = 0,
left_a = 0,
right_r = 0,
right_g = 0,
right_b = 0,
right_a = 0,
rect_alpha = 0,
rect_add_y = 0,
rect_width = 0,
dt_add_y = 0,
dt_r = 0,
dt_g = 0,
dt_b = 0,
dt_a = 0,
hs_add_y = 0,
ground_ticks = 0,
},
scopeline = {
toleng = 0
},
s_watermark = {
g_alpha = 0,
current_time = GlobalVars.curtime,
current_fps = 0,
fps_counter = 0,
width = 0,
--anti-aimbot & FL Text indicator
add_x = 0,
get_cmd_width = 0,
get_fake_width = 0,
get_circle_degree = 0,
GET_FAKE_AMOUNT_LERP = 0
},
s_keybind = {
g_alpha = 0,
keybinds_alpha = {},
keybinds_anime_posy = {},
keybinds_y = {},
width = 0,
is_draggable = false,
cursor_last_pos = Vector2.new(0, 0),
container_alpha = 0,
re_anim_width = 0,
re_anim_x = 0,
re_anim_y = 0,
re_anim_add_y = 0,
anims_add_y = 0,
real_add_y = 0
},
s_spec = {
g_alpha = 0,
keybinds_alpha = {},
keybinds_anime_posy = {},
keybinds_y = {},
width = 0,
is_draggable = false,
cursor_last_pos = Vector2.new(0, 0),
container_alpha = 0,
re_anim_width = 0,
re_anim_x = 0,
re_anim_y = 0,
re_anim_add_y = 0,
anims_add_y = 0,
real_add_y = 0,
binds = {},
spec_offset = 0,
size = Vector2.new(122 , 17)
}
},
solus_render = (function()
local solus_m = {}
local rounding = 4;
local rad = rounding + 2;
local n = 45;
local o = 20;
local roundedrect = function(x, y, w, h, radius, r, g, b, a)
Render.Blur(Vector2.new(x, y), Vector2.new(x + w, y + h),Color.new(255,255,255,a*255),radius)
render_rectangle(x,y,w,h,r,g,b,a,radius)
end
local outline_glow = function(x,y,w,h,radius,r,g,b,a)
render_rectangle(x + 2, y + radius + rad, 1, h - rad * 2 - radius * 2,r, g, b, a,0)
render_rectangle(x + w - 3, y + radius + rad, 1,h - rad * 2 - radius * 2, r, g, b, a,0)
render_rectangle(x + radius + rad, y + 2, w - rad * 2 - radius * 2, 1,r, g, b, a,0)
render_rectangle(x + radius + rad, y + h - 3,w - rad * 2 - radius * 2, 1, r, g, b, a,0)
render_circle_outline(x + radius + rad, y + radius + rad, radius + rounding,r,g,b,a,1,-90,-180)
render_circle_outline(x + w - radius - rad, y + radius + rad, radius + rounding,r, g, b,a,1, -90, 0)
render_circle_outline(x + radius + rad, y + h - radius - rad, radius + rounding,r, g, b,a,1, 90, 180)
render_circle_outline(x + w - radius - rad, y + h - radius - rad, radius + rounding,r, g, b,a,1, 90, 0)
end
local FadedRoundedRect = function(x, y, w, h, radius, r, g, b, a, glow)
local n = a / 255 * n;
if not ui_get("value",visuals.disable_glow) then
for radius = 4, glow do
local radius = radius / 2;
outline_glow(x - radius, y - radius, w + radius * 2,h + radius * 2, radius, r, g, b, glow - radius * 2)
end
end
render_rectangle(x + radius, y, w - radius * 2, 1, r, g, b, a,0)
render_circle_outline(x + radius, y + radius,radius, r, g, b, a, 1,-90,-180)
render_circle_outline(x + w - radius, y + radius,radius, r, g, b, a, 1,-90,0)
render_circle_outline(x + radius, y + h - radius,radius, r, g, b, n, 1,90,180)
render_circle_outline(x + w - radius, y + h - radius,radius, r, g, b, n, 1,90,0)
render_gradient(x, y + radius, 1, h - radius * 2, r, g, b, a, r, g, b,n, false)
render_gradient(x + w - 1, y + radius, 1, h - radius * 2, r, g, b, a,r, g, b, n, false)
render_rectangle(x + radius, y + h - 1, w - radius * 2, 1, r, g, b, n,0)
end;
solus_m.glow = function(x, y, w, h, radius, r, g, b, a, glow)
for radius = 1, glow do
local radius = radius / 2;
render_rectangle(x - radius, y - radius, w + radius * 2,h + radius * 2,r, g, b, glow - radius * 2,radius)
end
end
solus_m.glow_gradient = function(x, y, w, h, radius,r, g, b, a,r1,g1,b1,a1, glow)
for radius = 1, glow do
local radius = radius / 2;
render_gradient(x - radius, y - radius, w + radius * 2,h + radius * 2,r, g, b, glow - radius * 2,r1,g1,b1,glow - radius * 2,true)
end
end
solus_m.container = function(x, y, w, h, r, g, b, a, alpha)
roundedrect(x, y, w, h, rounding, 17, 17, 17,a)
FadedRoundedRect(x,y,w,h,rounding,r,g,b,alpha * 255, alpha * o)
end
solus_m.measure_multitext = function(fonts,size,_table)
local x,y = 0,0
for k, v in pairs(_table) do
local text_ = render_measure_text(size,fonts,v.text)
x = x + text_.x
y = y + text_.y
end
return {x = x ,y = y}
end
solus_m.multitext = function(x,y,fonts,size,outline,center,_table)
for k, v in pairs(_table) do
v.color = v.color or {255,255,255,255}
v.color[4] = v.color[4] or 255
render_text(x,y,fonts,size,outline,center,v.color[1],v.color[2],v.color[3],v.color[4],v.text)
x = x + render_measure_text(size,fonts,v.text).x
end
end
return solus_m
end)(),
on_script_start = function(self)
if not self.g_vars.check_show then
self.g_vars.g_alpha = lerp(self.g_vars.g_alpha,1,GlobalVars.frametime * 3.5)
else
self.g_vars.g_alpha = lerp(self.g_vars.g_alpha,0,GlobalVars.frametime * 3.5)
end
local screen = EngineClient_GetScreenSize()
local cx , cy = screen.x /2,screen.y/2
local text_size = render_measure_text(11,FONTS.VERDANA_12_BOLD,"Welcome to Ataraxia , "..userdata.username..".")
local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
Render.Blur(Vector2.new(0,0), Vector2.new(screen.x , screen.y ),Color_RGBA(255,255,255,math_floor(255 * self.g_vars.g_alpha)))
local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
render_gradient(cx - text_size.x/2 - 3,cy + text_size.y/2 ,text_size.x/2 + 6 ,2,r,g,b,0,r,g,b,255 * self.g_vars.g_alpha ,true)
render_gradient(cx + 3,cy + text_size.y/2 ,text_size.x/2 + 5 + 2 ,2,r,g,b,255 * self.g_vars.g_alpha,r,g,b,0 ,true)
render_stringwithshadow("b",cx,cy,true,255,255,255,255 * self.g_vars.g_alpha,"Welcome to Ataraxia , "..userdata.username..".")
if self.g_vars.check_show_time + 3 < GlobalVars.realtime then
self.g_vars.check_show_time = GlobalVars.realtime
self.g_vars.check_show = true
end
end,
get_center_states = function(self)
local in_air = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1) == 0
local on_ground = bit.band(entity_get_prop(entity_get_localplayer(),"m_fFlags"),1)
local duck = entity_get_prop(entity_get_localplayer(),"m_flDuckAmount") > 0.8
local vel = entity_get_prop(entity_get_localplayer(),"m_vecVelocity")
local velocity = math.sqrt(vel.x * vel.x + vel.y * vel.y)
if on_ground == 1 then
self.g_vars.center.ground_ticks = self.g_vars.center.ground_ticks + 1
else
self.g_vars.center.ground_ticks = 0
end
if Cheat_IsKeyDown(0x45) then
return "USE"
elseif check_roll == true then
return "ROLL"
elseif g_antiaim.value_table.antiaim.yaw_base == 3 or g_antiaim.value_table.antiaim.yaw_base == 2 then
return "MANUAL"
elseif in_air and duck then
return "AIR+D"
elseif in_air then
return "AIR"
elseif ui_get("value",reference.slow_motion) and self.g_vars.center.ground_ticks > 8 then
return "SLOWWALK"
elseif duck and self.g_vars.center.ground_ticks > 8 then
return "DUCK"
elseif velocity > 4 and self.g_vars.center.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
return "MOVE"
elseif velocity < 2 and self.g_vars.center.ground_ticks > 8 and not ui_get("value",reference.slow_motion) then
return "STAND"
else
return "AIR"
end
end,
run_center = function(self)
local v = self.g_vars.center
if ui_get("bool",visuals.indicator_settings,2) == true then
v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 3.5)
elseif ui_get("bool",visuals.indicator_settings,2) == false then
v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 3.5)
end
local cx ,cy = EngineClient_GetScreenSize().x /2,EngineClient_GetScreenSize().y/2
local is_scoped = entity_get_prop(entity_get_localplayer(),"m_bIsScoped")
local text_size = render_measure_text(11,FONTS.VERDANA_12_BOLD,"Ataraxia")
local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
local r_td,g_td,b_td,a_td = ui_get("color",visuals.center_color_2).r,ui_get("color",visuals.center_color_2).g,ui_get("color",visuals.center_color_2).b,ui_get("color",visuals.center_color_2).a
local r1,g1,b1,a1 = r_td*255,g_td*255,b_td *255 ,a_td *255
local modifier = entity_get_prop(entity_get_localplayer(), "m_flVelocityModifier")
local get_anims_alpha = ui_get("bool",visuals.center_scoped_anim,1)
local get_anims_pos = ui_get("bool",visuals.center_scoped_anim,2)
if is_scoped then
if get_anims_pos == true then
v.add_x = lerp(v.add_x,30,GlobalVars.frametime * 8)
end
if get_anims_alpha == true then
v.o_alpha = lerp(v.o_alpha,0.3,GlobalVars.frametime * 8)
end
else
if modifier ~= 1 then
v.add_y = lerp(v.add_y,1,GlobalVars.frametime * 8)
else
v.add_y = lerp(v.add_y,0,GlobalVars.frametime * 8)
end
v.o_alpha = lerp(v.o_alpha,1,GlobalVars.frametime * 8)
if get_anims_pos == true then
v.add_x = lerp(v.add_x,0,GlobalVars.frametime * 8)
end
end
if (v.cur_alpha < v.min_alpha + 1) then
v.target_alpha = v.max_alpha
elseif (v.cur_alpha > v.max_alpha - 1) then
v.target_alpha = v.min_alpha
end
v.cur_alpha = v.cur_alpha + (v.target_alpha - v.cur_alpha)*v.speed*(GlobalVars.absoluteframetime*10)
local inverted = AntiAim_GetInverterState()
if inverted then
v.left_r = lerp(v.left_r,r,GlobalVars.frametime * 12)
v.left_g = lerp(v.left_g,g,GlobalVars.frametime * 12)
v.left_b = lerp(v.left_b,b,GlobalVars.frametime * 12)
v.left_a = lerp(v.left_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
v.right_r = lerp(v.right_r,255,GlobalVars.frametime * 12)
v.right_g = lerp(v.right_g,255,GlobalVars.frametime * 12)
v.right_b = lerp(v.right_b,255,GlobalVars.frametime * 12)
v.right_a = lerp(v.right_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
else
v.left_r = lerp(v.left_r,255,GlobalVars.frametime * 12)
v.left_g = lerp(v.left_g,255,GlobalVars.frametime * 12)
v.left_b = lerp(v.left_b,255,GlobalVars.frametime * 12)
v.left_a = lerp(v.left_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
v.right_r = lerp(v.right_r,r,GlobalVars.frametime * 12)
v.right_g = lerp(v.right_g,g,GlobalVars.frametime * 12)
v.right_b = lerp(v.right_b,b,GlobalVars.frametime * 12)
v.right_a = lerp(v.right_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
end
if modifier ~= 1 then
v.rect_add_y = lerp(v.rect_add_y,1,GlobalVars.frametime * 12)
else
v.rect_add_y = lerp(v.rect_add_y,0,GlobalVars.frametime * 12)
end
if ui_get("value",reference.dt) then
if doubletap_charged() then
v.dt_r = lerp(v.dt_r,r,GlobalVars.frametime * 12)
v.dt_g = lerp(v.dt_g,g,GlobalVars.frametime * 12)
v.dt_b = lerp(v.dt_b,b,GlobalVars.frametime * 12)
v.dt_a = lerp(v.dt_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
else
v.dt_r = lerp(v.dt_r,255,GlobalVars.frametime * 12)
v.dt_g = lerp(v.dt_g,0,GlobalVars.frametime * 12)
v.dt_b = lerp(v.dt_b,0,GlobalVars.frametime * 12)
v.dt_a = lerp(v.dt_a,a * v.o_alpha * v.g_alpha,GlobalVars.frametime * 12)
end
v.dt_add_y = lerp(v.dt_add_y,1,GlobalVars.frametime * 12)
else
v.dt_add_y = lerp(v.dt_add_y,0,GlobalVars.frametime * 12)
end
if ui_get("value",reference.hs) then
v.hs_add_y = lerp(v.hs_add_y,1,GlobalVars.frametime * 12)
else
v.hs_add_y = lerp(v.hs_add_y,0,GlobalVars.frametime * 12)
end
if ui_get("value",visuals.center_mode) == 0 then
self.solus_render.glow(cx - text_size.x/2 - 1 + 4+ math_floor(v.add_x),cy + 25.5,text_size.x - 8,(text_size.y - 5)/2 - 4,5,r,g,b,math_floor(a*v.g_alpha),math_floor(v.cur_alpha *v.g_alpha)*v.o_alpha)
render_rectangle(
cx - text_size.x/2 + math_floor(v.add_x),cy + 18 + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 * v.add_y),text_size.x,3,25,25,25,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,0
)
render_rectangle(
cx - text_size.x/2 + math_floor(v.add_x) + 1,cy + 18 + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 * v.add_y) + 1,math_floor(((text_size.x - 1) * modifier) * v.add_y),1,r,g,b,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,0
)
render_stringwithshadow("b",cx - text_size.x/2 + math_floor(v.add_x),cy + 18 - math_floor(4 * v.add_y),false,r,g,b,math_floor(a*v.g_alpha)*v.o_alpha,"Ataraxia")
elseif ui_get("value",visuals.center_mode) == 1 then
self.solus_render.glow_gradient(cx - text_size.x/2 - 1 + 4+ math_floor(v.add_x) + 2,cy + 25.5,text_size.x - 8,(text_size.y - 5)/2 - 4,2,r,g,b,math_floor(a*v.g_alpha),r1,g1,b1,math_floor(a1*v.g_alpha),math_floor(v.cur_alpha *v.g_alpha)*v.o_alpha)
render_rectangle(
cx - text_size.x/2 + math_floor(v.add_x),cy + 18 + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 * v.add_y),text_size.x,3,25,25,25,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,0
)
render_gradient(cx - text_size.x/2 + math_floor(v.add_x) + 1,cy + 18 + text_size.y - 2 - math_floor(4 * v.add_y) + math_floor(4 * v.add_y) + 1,math_floor(((text_size.x - 1) * modifier) * v.add_y),1,r,g,b,math_floor((255 * v.add_y)*v.g_alpha)*v.o_alpha,r1,g1,b1,math_floor((a1 * v.add_y)*v.g_alpha)*v.o_alpha,true)
render_text(cx - text_size.x/2 + math_floor(v.add_x) + 1,cy + 18 - math_floor(4 * v.add_y) + 1,FONTS.VERDANA_12_BOLD,11,false,false,30,30,30,math_floor(a1*v.g_alpha)*v.o_alpha,"Ataraxia")
gradient_text(cx - text_size.x/2 + math_floor(v.add_x),cy + 18 - math_floor(4 * v.add_y),r/255,g/255,b/255,math_floor(a*v.g_alpha)*v.o_alpha/255,r1/255,g1/255,b1/255,math_floor(a1*v.g_alpha)*v.o_alpha/255,"Ataraxia",11,FONTS.VERDANA_12_BOLD,false,false)
elseif ui_get("value",visuals.center_mode) == 2 then
local text_size = render_measure_text(11,FONTS.VERDANA_12_BOLD,"Atar")
local text_size_2 = render_measure_text(11,FONTS.VERDANA_12_BOLD,"axia")
local g_x = text_size.x + text_size_2.x
local x,y = cx - g_x / 2 + math_floor(v.add_x ) ,cy + 18
local modifier = entity_get_prop(entity_get_localplayer(), "m_flVelocityModifier")
local alpha = math.floor(
math.sin(math.abs(-math.pi + (GlobalVars.curtime * (1.25 / .75)) % (math.pi * 2))) * 200
)
v.desync_line = lerp(v.desync_line,math_floor(get_fake_amount/100 ),GlobalVars.frametime * 12)
local inverted = AntiAim_GetInverterState()
local get_states = self:get_center_states()
local dt_r,dt_g,dt_b,dt_a = math_floor(v.dt_r),math_floor(v.dt_g),math_floor(v.dt_b),math_floor(v.dt_a)
local left_r,left_g,left_b,left_a = math_floor(v.left_r),math_floor(v.left_g),math_floor(v.left_b),math_floor(v.left_a)
local right_r,right_g,right_b,right_a = math_floor(v.right_r),math_floor(v.right_g),math_floor(v.right_b),math_floor(v.right_a)
render_text(x + 1,y + 1,FONTS.VERDANA_12_BOLD,11,false,false,0,0,0,left_a - 50,"Ataraxia")
render_text(x + text_size.x - 1 , y - 4 + 1,FONTS.PIXEL_10,10,true,true,r,g,b,math_floor(alpha * v.g_alpha * v.o_alpha),"|"..userdata.build.."|")
render_text(x,y,FONTS.VERDANA_12_BOLD,11,false,false,left_r,left_g,left_b,left_a,"Atar")
render_text(x + text_size.x,y,FONTS.VERDANA_12_BOLD,11,false,false,right_r,right_g,right_b,right_a,"axia")
render_rectangle(x ,y + text_size.y + math_floor( 3 * v.rect_add_y),g_x,3,25,25,25,math_floor(255 * v.g_alpha * v.o_alpha * v.rect_add_y),0)
render_rectangle(x + 1,y + text_size.y + 1 + math_floor( 3 * v.rect_add_y),math_floor((g_x - 2) * modifier),1,r,g,b,math_floor(255 * v.g_alpha * v.o_alpha * v.rect_add_y),0)
render_text(x + text_size.x/2 + 11,y + text_size.y + 5 + math_floor( 5 * v.rect_add_y) ,FONTS.PIXEL_10,10,true,true,255,255,255,math_floor(255 * v.g_alpha * v.o_alpha),get_states)
render_text(x + text_size.x/2 + 7,y + text_size.y + 7 + math_floor( 3 * v.dt_add_y) + math_floor( 4 * v.rect_add_y) ,FONTS.PIXEL_10,math_floor(10 * v.dt_add_y + 0.5),true,false,dt_r,dt_g,dt_b,dt_a,"DT")
render_text(x + text_size.x/2 + 7,y + text_size.y + 7 + math_floor( 3 * v.hs_add_y) + math_floor( 10 * v.dt_add_y) + math_floor( 4 * v.rect_add_y),FONTS.PIXEL_10,math_floor(10 * v.hs_add_y + 0.5),true,false,r,g,b,math_floor(255 * v.g_alpha * v.o_alpha),"HS")
elseif ui_get("value",visuals.center_mode) == 3 then
local x,y = (cx - 14) + math_floor(v.add_x ) ,cy + 18
local re_r,re_g,re_b = math_floor(r),math_floor(g),math_floor(b)
Render.Image(icon,Vector2_new(x + 1,y + 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
Render.Image(icon,Vector2_new(x - 1,y - 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
Render.Image(icon,Vector2_new(x + 1,y - 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
Render.Image(icon,Vector2_new(x - 1,y + 1),get_icon_size,Color_RGBA(10,10,10,math_floor(170 * v.g_alpha * v.o_alpha)))
Render.Image(icon,Vector2_new(x,y),get_icon_size,Color_RGBA(re_r,re_g,re_b,math_floor(255 * v.g_alpha * v.o_alpha)))
end
end,
run_arrows = function(self)
local v = self.g_vars.arrows
if ui_get("bool",visuals.indicator_settings,1) == true then
v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 3.5)
elseif ui_get("bool",visuals.indicator_settings,1) == false then
v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 3.5)
end
local cx ,cy = EngineClient_GetScreenSize().x /2,EngineClient_GetScreenSize().y/2
local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
local ds = (EngineClient_GetScreenSize().x/2) / 210 * ui_get("value",visuals.arrows_distance)
local mode = ui_get("value",visuals.arrows_mode)
local check_back = ui_get("value",visuals.arrows_background)
v.l = linear(g_antiaim.value_table.antiaim.yaw_base == 3,v.l,math_floor(255* v.g_alpha),6)
v.r = linear(g_antiaim.value_table.antiaim.yaw_base == 2,v.r,math_floor(255* v.g_alpha),6)
if mode == 0 then
if check_back == true then
render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(125 * v.g_alpha),"x")
render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(125 * v.g_alpha),"w")
render_text(cx+ds,cy,FONTS.ARROWS_24,20,false,true,60,60,60,math_floor(125 * v.g_alpha),"x")
render_text(cx-ds,cy,FONTS.ARROWS_24,20,false,true,60,60,60,math_floor(125 * v.g_alpha),"w")
else
render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(v.r),"x")
render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_24,20,false,true,30,30,30,math_floor(v.l),"w")
end
render_text(cx+ds,cy,FONTS.ARROWS_24,20,false,true,r,g,b,math_floor(v.r),"x")
render_text(cx-ds,cy,FONTS.ARROWS_24,20,false,true,r,g,b,math_floor(v.l),"w")
elseif mode == 1 then
if check_back == true then
render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(125 * v.g_alpha),"x")
render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(125 * v.g_alpha),"w")
render_text(cx+ds,cy,FONTS.ARROWS_12,12,false,true,60,60,60,math_floor(125 * v.g_alpha),"x")
render_text(cx-ds,cy,FONTS.ARROWS_12,12,false,true,60,60,60,math_floor(125 * v.g_alpha),"w")
else
render_text(cx + 1+ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(v.r),"x")
render_text(cx + 1-ds,cy + 1,FONTS.ARROWS_12,12,false,true,30,30,30,math_floor(v.l),"w")
end
render_text(cx+ds,cy,FONTS.ARROWS_12,12,false,true,r,g,b,math_floor(v.r),"x")
render_text(cx-ds,cy,FONTS.ARROWS_12,12,false,true,r,g,b,math_floor(v.l),"w")
end
end,
distance = function(self,x1, y1, x2, y2)
return math.sqrt((x2-x1)^2 + (y2-y1)^2)
end,
run_menueffect = function(self)
if ui_get("bool",visuals.indicator_settings,4) == true then
self.g_vars.menu_effect.g_alpha = lerp(self.g_vars.menu_effect.g_alpha,1,GlobalVars.frametime * 24)
elseif ui_get("bool",visuals.indicator_settings,4) == false then
self.g_vars.menu_effect.g_alpha = lerp(self.g_vars.menu_effect.g_alpha,0,GlobalVars.frametime * 24)
end
if self.g_vars.menu_effect.g_alpha <= 0.001 then
self.g_vars.menu_effect.g_alpha = 0
end
if Cheat_IsMenuVisible() == true then
self.g_vars.menu_effect.o_alpha = lerp(self.g_vars.menu_effect.o_alpha,self.g_vars.menu_effect.g_alpha,GlobalVars.frametime * 12)
else
self.g_vars.menu_effect.o_alpha = lerp(self.g_vars.menu_effect.o_alpha,0,GlobalVars.frametime * 12)
end
if self.g_vars.menu_effect.o_alpha <= 0.001 then
self.g_vars.menu_effect.o_alpha = 0
end
local sx,sy = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
local r_t,g_t,b_t,a_t = ui_get("color",visuals.indicator_color).r,ui_get("color",visuals.indicator_color).g,ui_get("color",visuals.indicator_color).b,ui_get("color",visuals.indicator_color).a
local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
if (self.g_vars.menu_effect.cur_alpha < self.g_vars.menu_effect.min_alpha + 2) then
self.g_vars.menu_effect.target_alpha = self.g_vars.menu_effect.max_alpha
elseif (self.g_vars.menu_effect.cur_alpha > self.g_vars.menu_effect.max_alpha - 2) then
self.g_vars.menu_effect.target_alpha = self.g_vars.menu_effect.min_alpha
end
self.g_vars.menu_effect.cur_alpha = self.g_vars.menu_effect.cur_alpha + (self.g_vars.menu_effect.target_alpha - self.g_vars.menu_effect.cur_alpha)*self.g_vars.menu_effect.speed*(GlobalVars.frametime*10)
render_gradient(0,0,sx,600 ,r,g,b,self.g_vars.menu_effect.cur_alpha*self.g_vars.menu_effect.o_alpha,r,g,b,0,false)
local v = self.g_vars.menu_effect
local menu_open = Cheat_IsMenuVisible()
local realtime = GlobalVars.realtime
if menu_open and not v.menu_open_prev then
v.last_change = realtime
end
if not menu_open then
return
end
local opacity_multiplier = menu_open and 1 or 0
local menu_fade_time = 0.2
if realtime - v.last_change < menu_fade_time then
opacity_multiplier = (realtime - v.last_change) / menu_fade_time
end
if opacity_multiplier ~= 1 then
--client.log(opacity_multiplier)
end
local screen_width, screen_height = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
if opacity_multiplier > 0 and v.o_alpha >= 0.5 then
local r, g, b, a = 255,255,255,200
a = a * opacity_multiplier
local r_connect, g_connect, b_connect, a_connect = 255,255,255,255
a_connect = a_connect * opacity_multiplier * 0.5
local speed_multiplier = 61 / 100
local dots_amount = 23
local dots_connect_distance = 307
local line_a = a/4
while #v.dots > dots_amount do
table_remove(v.dots, #v.dots)
end
while #v.dots < dots_amount do
local x, y = Utils_RandomInt(-dots_connect_distance, screen_width+dots_connect_distance), Utils_RandomInt(-dots_connect_distance, screen_height+dots_connect_distance)
local max = 12
local min = 4
local velocity_x
if Utils_RandomInt(0, 1) == 1 then
velocity_x = Utils_RandomFloat(-max, -min)
else
velocity_x = Utils_RandomFloat(min, max)
end
local velocity_y
if Utils_RandomInt(0, 1) == 1 then
velocity_y = Utils_RandomFloat(-max, -min)
else
velocity_y = Utils_RandomFloat(min, max)
end
local size = Utils_RandomFloat(v.dot_size-1, v.dot_size+1)
table_insert(v.dots, {x, y, velocity_x, velocity_y, size})
end
local dots_new = {}
for i=1, #v.dots do
local dot = v.dots[i]
local x, y, velocity_x, velocity_y, size = dot[1], dot[2], dot[3], dot[4], dot[5]
x = x + velocity_x*speed_multiplier*0.2
y = y + velocity_y*speed_multiplier*0.2
if x > -dots_connect_distance and x < screen_width+dots_connect_distance and y > -dots_connect_distance and y < screen_height+dots_connect_distance then
table_insert(dots_new, {x, y, velocity_x, velocity_y, size})
end
end
v.dots = dots_new
for i=1, #v.dots do
local dot = v.dots[i]
local x, y, velocity_x, velocity_y, size = dot[1], dot[2], dot[3], dot[4], dot[5]
for i2=1, #v.dots do
local dot2 = v.dots[i2]
local x2, y2 = dot2[1], dot2[2]
local distance = self:distance(x, y, x2, y2)
if distance <= dots_connect_distance then
local a_connect_multiplier = 1
if distance > dots_connect_distance * 0.7 then
a_connect_multiplier = (dots_connect_distance - distance) / (dots_connect_distance * 0.3)
--distance - dots_connect_distance /
end
Render.Line(Vector2.new(x, y), Vector2.new(x2, y2), Color.RGBA(r_connect, g_connect, b_connect, math_floor(a_connect*a_connect_multiplier)))
end
end
end
for i=1, #v.dots do
local dot = v.dots[i]
local x, y, velocity_x, velocity_y, size = dot[1], dot[2], dot[3], dot[4], dot[5]
Render.CircleFilled(Vector2.new(x, y), math_floor(size), 32, Color.new(r, g, b, math_floor(a)))
end
end
end,
run_watermark = function(self)
local v = self.g_vars.watermark
if ui_get("bool",visuals.indicator_settings,3) == true then
v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 3.5)
else
v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 3.5)
end
-- solus_m.container = function(x, y, w, h, r, g, b, a, alpha)
local screen = EngineClient_GetScreenSize()
local cx , cy = screen.x /2,screen.y/2
local r_t,g_t,b_t,a_t = ui_get("color",visuals.watermark_color).r,ui_get("color",visuals.watermark_color).g,ui_get("color",visuals.watermark_color).b,ui_get("color",visuals.watermark_color).a
local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
local tabled = {
{text = "ATARAXIA",color = {r,g,b,math_floor(255*v.g_alpha)}},
{text = ".PUB",color = {255,255,255,math_floor(255*v.g_alpha)}},
{text = " ",color = {255,255,255,math_floor(255*v.g_alpha)}},
{text = "@"..string.upper(userdata.username),color = {r,g,b,math_floor(255*v.g_alpha)}},
{text = " ",color = {255,255,255,math_floor(255*v.g_alpha)},flags = "-"},
{text = string.upper(userdata.build),color = {159,227,255,math_floor(255*v.g_alpha)}},
{text = " ",color = {255,255,255,math_floor(255*v.g_alpha)}},
{text = string.upper(userdata.last_updatetime),color = {255,255,255,math_floor(255*v.g_alpha)}},
}
if (v.cur_alpha < v.min_alpha + 0.02) then
v.target_alpha = v.max_alpha
elseif (v.cur_alpha > v.max_alpha - 0.02) then
v.target_alpha = v.min_alpha
end
v.cur_alpha = v.cur_alpha + (v.target_alpha - v.cur_alpha)*v.speed*(GlobalVars.frametime*10)
local lua = self.solus_render.measure_multitext(FONTS.PIXEL_10,10,tabled).x + 8
local w,h = lua+ 12 ,18
local sx,sy = EngineClient_GetScreenSize().x,EngineClient_GetScreenSize().y
local x ,y = sx/ 2 -lua/2, sy - 30
Render.Image(image_loaded, Vector2.new(500, 500), Vector2_new(32,32))
self.solus_render.container(x, y, w, h, r, g, b, a*v.g_alpha,v.cur_alpha*v.g_alpha )
self.solus_render.multitext(x + 11 , y + 3,FONTS.PIXEL_10,10,true,false, tabled)
end,
run_damage_maker = function(self)
if ui_get("bool",visuals.indicator_settings,5) == true then
local damage_indicator_displays_new = {}
local max_time_delta = ui_get("value",visuals.dmgmarker_display_time) / 2
local speed = ui_get("value",visuals.dmgmarker_speed) / 3
local realtime = GlobalVars.realtime
local max_time = realtime - max_time_delta / 2
local aimbot_enabled = ui_get("value",reference.ragebot)
local minimum_damage = 0
if aimbot_enabled then
minimum_damage = ui_get("value",reference.dmg)
end
-- local r_t,g_t,b_t,a_t = ui_get("color",visuals.dmgmarker_color_1).r,ui_get("color",visuals.dmgmarker_color_1).g,ui_get("color",visuals.dmgmarker_color_1).b,ui_get("color",visuals.dmgmarker_color_1).a
-- local r,g,b,a = r_t*255,g_t*255,b_t *255 ,a_t *255
local r_td,g_td,b_td,a_td = ui_get("color",visuals.dmgmarker_color_2).r,ui_get("color",visuals.dmgmarker_color_2).g,ui_get("color",visuals.dmgmarker_color_2).b,ui_get("color",visuals.dmgmarker_color_2).a
local r1,g1,b1,a1 = r_td*255,g_td*255,b_td *255 ,a_td *255
for i=1, #damage_indicator_displays do
local damage_indicator_display = damage_indicator_displays[i]
local damage, time, x, y, z, e = damage_indicator_display[1], damage_indicator_display[2], damage_indicator_display[3], damage_indicator_display[4], damage_indicator_display[5], damage_indicator_display[6]
local r_s, g_s, b_s, a_s = r1,g1,b1,a1
if time > max_time then
local sx, sy = Render.WorldToScreen(Vector_new( x, y, z)).x,Render.WorldToScreen(Vector_new( x, y, z)).y
-- if damage < minimum_damage and e.health ~= 0 then
-- r, g, b = r1, g1,b1
-- end
if (time - max_time) < 0.7 then
a_s = math_floor((time - max_time) / 0.7 * 255)
end
if not (sx == nil or sy == nil) then
if ui_get("value",visuals.dmgmarker_mode) == 0 then
render_text(math_floor(sx) + 1, math_floor(sy) + 1,FONTS.VERDANA_13, 13,false,false,30,30,30,a_s,tostring(damage))
render_text(math_floor(sx), math_floor(sy),FONTS.VERDANA_13, 13,false,false,r_s, g_s, b_s,a_s,tostring(damage))
elseif ui_get("value",visuals.dmgmarker_mode) == 1 then
render_text(sx + 1, sy + 1,FONTS.VERDANA_12_BOLD,11,false,false,30,30,30,a_s,tostring(damage))
render_text(sx, sy,FONTS.VERDANA_12_BOLD, 11,false,false,r_s, g_s, b_s,a_s,tostring(damage))
elseif ui_get("value",visuals.dmgmarker_mode) == 2 then
render_text(sx + 1, sy + 1,FONTS.VERDANA_36_BOLD,36,false,false,30,30,30,a_s,tostring(damage))
render_text(sx, sy,FONTS.VERDANA_36_BOLD,36,false,false,r_s, g_s, b_s,a_s,tostring(damage))
end
end
table_insert(damage_indicator_displays_new, {damage, time, x, y, z+0.4*speed, e})
end
end
damage_indicator_displays = damage_indicator_displays_new
end
end,
run_scopeline = function(self)
local v = self.g_vars.scopeline
local scoped = entity_get_prop(entity_get_localplayer(),"m_bIsScoped")
local sc = EngineClient.GetScreenSize()
local gui = CVar.FindVar("r_drawvgui")
if ui_get("bool",visuals.indicator_settings,6) == true then
ui_set("value",reference.remove_scope,2)
local Scoped_color = ui_get("color",visuals.indicator_color)
local r, g, b, a = Scoped_color.r, Scoped_color.g, Scoped_color.b, Scoped_color.a
local org = ui_get("value",visuals.scopeline_origin)
local width = ui_get("value",visuals.scopeline_width)
if scoped then
if v.toleng < (org/ 2 + width) then
v.toleng = v.toleng + 2
else
v.toleng = (org/ 2 + width)
end
Render.GradientBoxFilled(Vector2.new(sc.x / 2 - 0.1,sc.y / 2 - math.min(org, v.toleng)),Vector2.new(sc.x / 2 + 1, sc.y / 2 - math.min(org, v.toleng) -math.min(width, v.toleng)),Color.new(r , g , b , a), Color.new(r , g , b , a),Color.new(r , g , b , 0), Color.new(r, g , b , 0))
Render.GradientBoxFilled(Vector2.new(sc.x / 2 - math.min(org, v.toleng),
sc.y / 2 - 0.1), Vector2.new(sc.x / 2 - math.min(org, v.toleng) -
math.min(width, v.toleng), sc.y / 2 + 1),
Color.new(r , g , b , a), Color.new(r , g , b , 0),
Color.new(r , g , b , a), Color.new(r , g , b , 0))
Render.GradientBoxFilled(Vector2.new(sc.x / 2 - 0.1,
sc.y / 2 + math.min(org, v.toleng)),
Vector2.new(sc.x / 2 + 1, sc.y / 2 + math.min(org, v.toleng) +
math.min(width, v.toleng)),
Color.new(r , g , b , a), Color.new(r , g , b , a),
Color.new(r , g , b , 0), Color.new(r , g , b , 0))
Render.GradientBoxFilled(Vector2.new(sc.x / 2 + math.min(org, v.toleng),
sc.y / 2 - 0.1), Vector2.new(sc.x / 2 + math.min(org, v.toleng) +
math.min(width, v.toleng), sc.y / 2 + 1),
Color.new(r , g , b , a), Color.new(r , g , b , 0),
Color.new(r , g , b , a), Color.new(r , g , b , 0))
else
if v.toleng > 0 then
v.toleng = v.toleng - 2
else
v.toleng = 0
end
end
else
ui_set("value",reference.remove_scope,1)
end
end,
run_notifications = function(self)
local y = sc_y - 100
for i, info in pairs(noti_table) do
if i > 5 then
table_remove(noti_table,i)
end
if info.text ~= nil and info.text ~= "" then
if info.timer + 3.8 < GlobalVars.realtime then
info.smooth_y = lerp(info.smooth_y,sc_y + 100,GlobalVars.frametime * 2)
info.alpha = lerp(info.alpha,0,GlobalVars.frametime * 4)
else
info.alpha = lerp(info.alpha,1,GlobalVars.frametime * 4)
info.smooth_y = lerp(info.smooth_y,y,GlobalVars.frametime * 4)
end
local add_y = math_floor(info.smooth_y)
local alpha = info.alpha
local get_color = ui_get("color",visuals.watermark_color)
local r,g,b,a = get_color.r * 255,get_color.g * 255,get_color.b * 255,get_color.a * 255
local tabled = {
{text = "[Ataraxia]",color = {r,g,b,math_floor(255*alpha)}},
{text = " ",color = {r,g,b,math_floor(255*alpha)}},
{text = info.text,color = {255,255,255,math_floor(255*alpha)}},
}
local text_size = self.solus_render.measure_multitext(FONTS.VERDANA_12,11,tabled).x + 8
local text_size_y = self.solus_render.measure_multitext(FONTS.VERDANA_12,11,tabled).y/2 + 4
-- solus_m.container = function(x, y, w, h, r, g, b, a, alpha)
self.solus_render.container(sc_x/2 - text_size/2,add_y - 26 - 7 + 2 + 31,text_size + 2,text_size_y,r,g,b,math_floor(a*alpha),1*alpha)
self.solus_render.multitext(sc_x/2 - text_size/2 + 5 ,add_y - 26 - 7 + 2 + 31 + 3,FONTS.VERDANA_12,11,true,false, tabled)
y = y - 45
if info.timer + 4 < GlobalVars.realtime then
table_remove(noti_table,i)
end
end
end
end,
get_ping = function(self)
local netchann_info = EngineClient.GetNetChannelInfo()
if not netchann_info then return "0" end
local latency = netchann_info:GetLatency(0)
return math_floor(latency * 1000.0 + 0.5).."ms"
end,
get_ticks = function(self)
return math.floor(1.0 / GlobalVars.interval_per_tick)
end,
get_fps = function(self)
local get_fps = function()
self.g_vars.s_watermark.fps_counter = 0.9 * self.g_vars.s_watermark.fps_counter + (1.0 - 0.9) * GlobalVars.absoluteframetime
return math.floor((1.0 / self.g_vars.s_watermark.fps_counter) + 0.5)
end
local current_fps = get_fps()
if self.g_vars.s_watermark.current_time + 0.3 < GlobalVars.curtime then
self.g_vars.s_watermark.current_fps = current_fps
self.g_vars.s_watermark.current_time = GlobalVars.curtime
end
return self.g_vars.s_watermark.current_fps
end,
get_fl_amount = function(self,cmd)
if doubletap_charged() then
is_breaking_lc = true
else
is_breaking_lc = false
end
if ClientState.m_choked_commands == 0 then
last_sent = current_choke
end
current_choke = ClientState.m_choked_commands
return last_sent
end,
normalize_yaw = function(self,ang)
while (ang > 180.0) do
ang = ang - 360.0
end
while (ang < -180.0) do
ang = ang + 360.0
end
return ang
end,
get_desync = function(self,cmd)
local ptr = entity_get_localplayer()
local degree = self:normalize_yaw(AntiAim_GetCurrentRealRotation() - ptr:GetProp("m_angEyeAngles[1]"))
get_fake_amount = math_abs(math_floor(tonumber(string_format("%.2f", (clamp(degree, AntiAim_GetMinDesyncDelta(), AntiAim_GetMaxDesyncDelta())))) + 0.5))
return get_fake_amount
end,
run_solus_watermark = function(self)
local v = self.g_vars.s_watermark
if ui_get("bool",visuals.indicator_settings,7) == false then
return
end
if ui_get("bool",visuals.solus_select,1) == true then
v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 12)
else
v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 12)
end
local get_n_watermark = ui_get("bool",reference.windows,3)
if ui_get("bool",visuals.solus_select,1) == true then
ui_set("bool",reference.windows,3,false)
else
ui_set("bool",reference.windows,3,get_n_watermark)
end
local r,g,b,a = ui_get("color",visuals.watermark_color).r * 255,ui_get("color",visuals.watermark_color).g * 255,ui_get("color",visuals.watermark_color).b * 255,math_floor((ui_get("color",visuals.watermark_color).a*255) * v.g_alpha)
local rea = math_floor(255*v.g_alpha)
local text_Table = {
{text = "Ataraxia",color = {r,g,b,rea}},
{text = ".pub",color = {255,255,255,rea}},
{text = "[",color = {255,255,255,rea}},
{text = userdata.build,color = {159,227,255,rea}},
{text = "]",color = {255,255,255,rea}},
{text = " ",color = {255,255,255,rea}},
{text = ui_get("value",visuals.solus_watermark_name),color = {255,255,255,rea}},
{text = " ",color = {255,255,255,rea}},
{text = "delay:"..self:get_ping(),color = {255,255,255,rea}},
{text = " ",color = {255,255,255,rea}},
{text = self:get_ticks().."tick",color = {255,255,255,rea}}
}
local get_text_size_x,get_text_size_y = self.solus_render.measure_multitext(FONTS.VERDANA_12_R,11,text_Table).x,self.solus_render.measure_multitext(FONTS.PIXEL_10,10,text_Table).y
v.width = lerp(v.width,(get_text_size_x + 10) * v.g_alpha,GlobalVars.frametime * 12)
local w,h = math_floor(v.width), math_floor(18 * v.g_alpha + 0.5)
-- print(math.floor(ping * 1000 + 0.5))
-- local text_size =
-- local w,h =
self.solus_render.container(sc_x - (w+8),h/2,w,h,r,g,b,a,1 * v.g_alpha)
local reget_text = "Ataraxia.pub "..userdata.build.." "..ui_get("value",visuals.solus_watermark_name).." ".."delay:"..self:get_ping().." "..self:get_ticks().."tick"
render_text(sc_x - (w+8) + 5 + 1,h/2 + 2 +1,FONTS.VERDANA_12_R,math_floor(11*v.g_alpha + 0.5),false,false,10,10,10,rea,reget_text)
self.solus_render.multitext(sc_x - (w+8) + 5,h/2 + 2,FONTS.VERDANA_12_R,math_floor(11*v.g_alpha + 0.5),false,false, text_Table)
local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
if not localplayer then return end
local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
if not my_index then return end
local text_fl = ("FL:%s"):format(
(function()
if tonumber(last_sent) < 10 then
return "\x20"..last_sent
end
return last_sent
end)()
)
v.GET_FAKE_AMOUNT_LERP = lerp(v.GET_FAKE_AMOUNT_LERP,get_fake_amount + 0.5,GlobalVars.frametime * 3.5)
local text_fake = ("FAKE:(%.1f°)"):format(v.GET_FAKE_AMOUNT_LERP + 0.5)
local text_fake_size = render_measure_text(11,FONTS.VERDANA_12_R,text_fake)
v.get_fake_width = lerp(v.get_fake_width,(text_fake_size.x + 10 + 10)*v.g_alpha,GlobalVars.frametime * 12)
local w_f,h_f = v.get_fake_width,18
local text_tick = ""
if is_breaking_lc == true then
text_tick = " | SHIFTING"
elseif is_breaking_lc == false then
text_tick = ""
end
local text_tick_size = render_measure_text(11,FONTS.VERDANA_12_R,text_tick)
local text_fl_size = render_measure_text(11,FONTS.VERDANA_12_R,text_fl)
local text_cmd = text_fl..text_tick
local text_cmd_size = text_fl_size.x + text_tick_size.x
v.get_cmd_width = lerp(v.get_cmd_width,(text_cmd_size + 10)*v.g_alpha,GlobalVars.frametime * 12)
local w_cmd ,h_cmd = v.get_cmd_width,18
self.solus_render.container(sc_x - (w_cmd+8) ,h_cmd/2 + h_cmd + 6,w_cmd,h_cmd,r,g,b,a,1 * v.g_alpha)
self.solus_render.container(sc_x - (w_f + w_cmd +15) ,h_f/2 + h + 6,w_f,h_f,r,g,b,a,1 * v.g_alpha)
render_text(sc_x - (w_cmd+8) + 5 + 1 ,h_cmd/2 + h + 6 + 1 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,10,10,10,rea,text_cmd)
render_text(sc_x - (w_cmd+8) + 5 ,h_cmd/2 + h + 6 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,255,255,255,rea,text_cmd)
render_text(sc_x - (w_f + w_cmd +15) + 6 + 1 + 10,h_f/2 + h + 6 + 1 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,10,10,10,rea,text_fake)
render_text(sc_x - (w_f+ w_cmd + 15) + 6 + 10 ,h_f/2 + h + 6 + 1 + 1,FONTS.VERDANA_12_R,math_floor(11 * v.g_alpha + 0.5),false,false,255,255,255,rea,text_fake)
v.get_circle_degree = lerp(v.get_circle_degree,((get_fake_amount + 0.5)*6)*v.g_alpha,GlobalVars.frametime * 12)
render_circle_outline(sc_x - (w_f+ w_cmd + 15) + 6 + 3,h_f/2 + h + 6 + 1 + 8,4.5,r,g,b,rea,3,0,v.get_circle_degree)
end,
render_text_key = function(self,text, pos, color, size, text_font, outline, align)
local text_size = Render.CalcTextSize(text, size, text_font)
if align == 0 then -- To the left
Render.Text(text, Vector2.new(pos.x - text_size.x, pos.y), color, size, text_font, outline)
elseif align == 1 then -- To the center
Render.Text(text, Vector2.new(pos.x - (text_size.x / 2), pos.y), color, size, text_font, outline)
elseif align == 2 then -- To the right
Render.Text(text, pos, color, size, text_font, outline)
end
end,
run_solus_keybind = function(self)
local v = self.g_vars.s_keybind
if ui_get("bool",visuals.indicator_settings,7) == false then
return
end
if ui_get("bool",visuals.solus_select,2) == true then
v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 12)
else
v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 12)
end
local get_n_keybind = ui_get("bool",reference.windows,1)
if ui_get("bool",visuals.solus_select,2) == true then
ui_set("bool",reference.windows,1,false)
else
ui_set("bool",reference.windows,1,get_n_keybind)
end
if EngineClient.IsConnected() then
local x = ui_get("value",visuals.temp_keybind_x)
local y = ui_get("value",visuals.temp_keybind_y)
local max_width = 0
local g_res_alpha = math_floor(255 * v.g_alpha)
local render_container = function(x, y, w,alpha)
local color = ui_get("color",visuals.watermark_color)
local name_size = Render.CalcTextSize("keybinds", 11, FONTS.VERDANA_12_R)
local height = 18
local line_height = 1.5
self.solus_render.container(x - 66,y , w ,18,color.r * 255,color.g * 255,color.b * 255,math_floor((color.a * 255) * alpha),1 * alpha)
-- render_rounded_line()
render_text( x - 64 + w/2 - name_size.x /2 , y + 2 + 1,FONTS.VERDANA_12_R,11,false,false,30,30,30,255 * alpha - 50,"keybinds")
render_text( x - 64 + w/2 - name_size.x /2, y + 2,FONTS.VERDANA_12_R,11,false,false,255,255,255, 255 * alpha,"keybinds")
end
local binds = Cheat.GetBinds()
local add_y = 0
local anim_y = math_floor(v.re_anim_add_y)
v.re_anim_add_y = lerp(v.re_anim_add_y , y,GlobalVars.frametime * 24)
v.re_anim_y = lerp(v.re_anim_y,y,GlobalVars.frametime * 24)
local re_anim_width = math_floor(v.re_anim_width)
local re_anim_y = math_floor(v.re_anim_y)
for i = 1, #binds do
v.anims_add_y = lerp(v.anims_add_y,13,GlobalVars.frametime * 12)
local bind = binds[i]
local yaw_base = Menu.FindVar("Aimbot", "Anti Aim", "Main", "Yaw Base"):Get()
local isFS = yaw_base == 5
local bind_name = bind:GetName()
local stringname = tostring(bind_name)
table.insert(v.keybinds_alpha, bind_name)
if v.keybinds_alpha[stringname] == nil then
v.keybinds_alpha[stringname] = 0
end
bind_name = bind_name:gsub("Double Tap", "Double tap")
bind_name = bind_name:gsub("Fake Duck", "Duck peek assist")
bind_name = bind_name:gsub("Auto Peek", "Quick peek assist")
bind_name = isFS and bind_name:gsub("Yaw Base", "Freestanding") or bind_name:gsub("Yaw Base", "")
v.real_add_y = lerp(v.real_add_y,add_y,GlobalVars.frametime * 12)
local add_y_r = math_floor(v.real_add_y + 0.5)
add_y = add_y + v.keybinds_alpha[stringname] / 20
add_y_r = add_y_r + math_floor(v.anims_add_y)
if bind_name ~= "" then
if bind:IsActive() then
v.keybinds_alpha[stringname] = lerp(
v.keybinds_alpha[stringname],
255,
GlobalVars.frametime * 12
)
else
v.keybinds_alpha[stringname] = lerp(
v.keybinds_alpha[stringname],
0,
GlobalVars.frametime * 12
)
end
local render_binds = function(binds, name)
local x = ui_get("value",visuals.temp_keybind_x)
local bind_state = binds:GetMode() == 1 and "[holding]" or "[toggled]"
local bind_name = name
local bind_state_size = Render.CalcTextSize(bind_state, 11, FONTS.VERDANA_12_R)
local bind_name_size = Render.CalcTextSize(bind_name, 11, FONTS.VERDANA_12_R)
local smooth_alpha = math.floor(v.keybinds_alpha[stringname] * v.g_alpha)
local width = math.floor(v.width)
v.re_anim_x = lerp(v.re_anim_x,(width - bind_state_size.x) - 5 - 25 ,GlobalVars.frametime * 24)
local re_anim_x = math_floor(v.re_anim_x)
render_text(x - 63 + 1, re_anim_y + 7 + 1 + add_y,FONTS.VERDANA_12_R,11,false,false,0,0,0,smooth_alpha - 50,bind_name)
render_text(x - 63, re_anim_y + 7 + add_y,FONTS.VERDANA_12_R,11,false,false,255,255,255,smooth_alpha,bind_name)
render_text(x + re_anim_x + 1, re_anim_y + 7 + 1+ add_y,FONTS.VERDANA_12_R,11,false,false,30,30,30,smooth_alpha - 50,bind_state)
render_text(x + re_anim_x, re_anim_y + 7 + add_y,FONTS.VERDANA_12_R,11,false,false,255,255,255,smooth_alpha,bind_state)
local bind_width = bind_state_size.x + bind_name_size.x
local length = 40
if bind_width > length then
if bind_width > max_width then
max_width = bind_width
end
end
end
render_binds(bind, bind_name)
else
add_y = add_y - v.keybinds_alpha[stringname] / 20
end
end
v.width = math.max(40, max_width)
if not Cheat.IsMenuVisible() then
v.is_draggable = false
end
local width = math.floor(v.width)
if Cheat.IsMenuVisible() or #binds > 0 then
v.container_alpha = lerp(v.container_alpha,1 * v.g_alpha,GlobalVars.frametime * 12)
else
v.container_alpha = lerp(v.container_alpha,0 * v.g_alpha,GlobalVars.frametime * 12)
end
v.re_anim_width = lerp(v.re_anim_width,width + 40,GlobalVars.frametime * 24)
render_container(x, re_anim_y,re_anim_width,v.container_alpha)
if Cheat.IsMenuVisible() or #binds > 0 then
local mouse = Cheat.GetMousePos()
if Cheat.IsKeyDown(0x1) then
if not v.is_draggable then
if mouse.x >= x - 70 and mouse.y >= y and mouse.x <= x + width and mouse.y <= y + 18 then
v.is_draggable = true
end
else
local x_pos = x + (mouse.x - v.cursor_last_pos.x)
local y_pos = y + (mouse.y - v.cursor_last_pos.y)
ui_set("value",visuals.temp_keybind_x, math.floor(x_pos))
ui_set("value",visuals.temp_keybind_y, math.floor(y_pos))
end
else
v.is_draggable = false
end
v.cursor_last_pos = mouse
end
end
end,
get_specs = function(self)
if not EngineClient.IsConnected() or not EngineClient.IsInGame() then
return
end
local spectators = {}
local local_player = EntityList.GetLocalPlayer()
if not local_player then
return
end
local local_player_ent_index = local_player:EntIndex()
local local_target = bit.band(local_player:GetProp("m_hObserverTarget"), 0xFFF)
local is_local_alive = entity_is_alive(local_player)
for i = 1, EngineClient.GetMaxClients() do
local entity = EntityList.GetClientEntity(i)
if not entity then
goto continue
end
local observer = bit.band(entity:GetProp("m_hObserverTarget"), 0xFFF)
if not observer then
goto continue
end
if is_local_alive then
if observer ~= local_player_ent_index then
goto continue
end
local player = entity:GetPlayer()
if not player then
goto continue
end
if player:IsDormant() then
goto continue
end
local name = player:GetName()
if not name then
goto continue
end
spectators[#spectators+1] ={
name = name,
id = player:EntIndex(),
}
else
if observer ~= local_target then
goto continue
end
local player = entity:GetPlayer()
if not player then
goto continue
end
if player:IsDormant() then
goto continue
end
local name = player:GetName()
if not name then
goto continue
end
spectators[#spectators+1] ={
name = name,
id = player:EntIndex(),
}
end
::continue::
end
return spectators
end,
run_solus_spectators = function(self)
local global_alpha = 0
local function get_steam_id_fn(ent_idx)
local panorama_handle = Panorama.Open()
local huy = panorama_handle.GameStateAPI.GetPlayerXuidStringFromEntIndex(ent_idx)
return huy
end
local spec = self:get_specs()
if spec == nil then
return
end
local v = self.g_vars.s_spec
if ui_get("bool",visuals.indicator_settings,7) == false then
return
end
local get_n_keybind = ui_get("bool",reference.windows,2)
if ui_get("bool",visuals.solus_select,3) == true then
ui_set("bool",reference.windows,2,false)
else
ui_set("bool",reference.windows,2,get_n_keybind)
end
local should_work = true
if not spec then should_work = false goto c end
if spec then if #spec==0 then should_work = false end end
if not ui_get("bool",visuals.solus_select,3) then
should_work = false
end
::c::
if should_work or (Cheat.IsMenuVisible() and ui_get("bool",visuals.solus_select,3)) then
v.g_alpha = lerp(v.g_alpha,1,GlobalVars.frametime * 12)
else
v.g_alpha = lerp(v.g_alpha,0,GlobalVars.frametime * 12)
end
if v.g_alpha < 0.01 then return end
local max_size = 75
local clamp_alpha = visuals.watermark_color:GetColor().a
local start = {x = ui_get("value",visuals.temp_spec_x),y = ui_get("value",visuals.temp_spec_y)}
-- local colors = ui_get("color",visuals.watermark_color)
-- local colors = {
-- Color.new(colors[1].r, colors[1].g, colors[1].b, colors[1].a * (v.g_alpha )),
-- Color.new(colors[2].r, colors[2].g, colors[2].b, colors[2].a * (v.g_alpha )),
-- Color.new(colors[3].r, colors[3].g, colors[3].b, colors[3].a * (v.g_alpha ))
-- }
local offset = Vector2.new(v.size.x / 2, 2)
if start.x + v.size.x/2 < sc_x/2 then
v.spec_offset = lerp(v.spec_offset,1,GlobalVars.frametime * 12)
else
v.spec_offset = lerp(v.spec_offset,0,GlobalVars.frametime * 12)
end
local y_off = 0
if spec then
for i = 1 , #spec do
local bind = spec[i]
local bind_name = bind.name
if not v.binds[bind_name] then
v.binds[bind_name] = 0
end
v.binds[bind_name] = lerp(v.binds[bind_name] , 1 , GlobalVars.frametime * 12)
if v.binds[bind_name] <0.01 then goto skip end
local alpha = v.binds[bind_name]
local text_size = Vector2.new(11,11)
local text_size2 = Render.CalcTextSize(bind_name, 11, FONTS.VERDANA_12_R) + Vector2.new(11,11)
local off = start.y + (y_off ) + 20
Render.Texts(bind_name, Vector2.new(start.x + 5, off), Color.new(1.0, 1.0, 1.0, alpha*v.g_alpha ), 11, FONTS.VERDANA_12_R)
-- Render.Image(val , Vector2.new(start.x + (size.x - 15)*(1-v.spec_offset) + 2*v.spec_offset , off) , Vector2.new(12,12) , Color.new(1,1,1,v.g_alpha) )
if max_size < (text_size2.x)+18 then max_size = (text_size2.x+18 ) end
y_off = y_off + 14
::skip::
end
end
local r,g,b,a = ui_get("color",visuals.watermark_color).r * 255,ui_get("color",visuals.watermark_color).g * 255,ui_get("color",visuals.watermark_color).b * 255,math_floor((ui_get("color",visuals.watermark_color).a*255) * v.g_alpha)
v.size.x = lerp(v.size.x,max_size,GlobalVars.frametime * 12)
-- if box_alpha~=0 then
-- Render.BoxFilled(start, start + kbinds.size, color(17, 17, 17, g_alpha * accent_alpha*255 * box_alpha))
-- end
-- if blur_alpha~=0 then
-- local blur_col = Color.new(ui.vis.blur_bg:GetColor().r , ui.vis.blur_bg:GetColor().g, ui.vis.blur_bg:GetColor().b, g_alpha*accent_alpha * blur_alpha* ui.vis.blur_bg:GetColor().a)
-- Render.Blur(start, start + kbinds.size, blur_col)
-- end
-- Render.GradientBoxFilled(start, start + offset, colors[1], colors[2], colors[1], colors[2])
-- Render.GradientBoxFilled(start + offset, start + offset + Vector2.new(offset.x, -offset.y), colors[2], colors[3], colors[2], colors[3])
self.solus_render.container(start.x, start.y,math_floor(v.size.x) ,18,r,g,b,a,1 * v.g_alpha)
Render.Texts("spectators", Vector2.new(start.x+ v.size.x/2 , start.y + 8), Color.new(1.0, 1.0, 1.0, v.g_alpha ), 11, FONTS.VERDANA_12_R , true)
if Cheat.IsMenuVisible() or #spec > 0 then
local mouse = Cheat.GetMousePos()
if Cheat.IsKeyDown(0x1) then
if not v.is_draggable then
if mouse.x >= start.x - 70 and mouse.y >= start.y and mouse.x <= start.x + v.size.x and mouse.y <= start.y + 18 then
v.is_draggable = true
end
else
local x_pos = start.x + (mouse.x - v.cursor_last_pos.x)
local y_pos = start.y + (mouse.y - v.cursor_last_pos.y)
ui_set("value",visuals.temp_spec_x, math.floor(x_pos))
ui_set("value",visuals.temp_spec_y, math.floor(y_pos))
end
else
v.is_draggable = false
end
v.cursor_last_pos = mouse
end
end,
-- PLAYERS_INFO = {},
-- getsteam_id = function(self, steamid)
-- return string.sub(tostring(ffi.new('uint64_t', 76561197960265728) + ffi.new('uint64_t', steamid)), 1, -4)
-- end,
-- get_spectators = function(self,player)
-- local buffer = { }
-- local players = EntityList.GetPlayers()
-- for tbl_idx, player_pointer in pairs(players) do
-- if player_pointer:EntIndex() ~= player:EntIndex() then
-- if not player_pointer:IsAlive() then
-- local spectatingMode = player_pointer:GetProp('m_iObserverMode')
-- local spectatingPlayer = player_pointer:GetProp('m_hObserverTarget')
-- if spectatingPlayer then
-- if spectatingMode >= 4 or spectatingMode <= 5 then
-- local spectatingEntity = EntityList.GetClientEntityFromHandle(spectatingPlayer)
-- if spectatingEntity ~= nil and spectatingEntity:EntIndex() == player:EntIndex() then
-- local player_info = player_pointer:GetPlayerInfo()
-- table.insert(buffer, 1, {
-- ['id'] = player_info.iSteamID,
-- ['id64'] = self:getsteam_id(player_info.iSteamID),
-- ['name'] = player_pointer:GetName()
-- })
-- end
-- end
-- end
-- end
-- end
-- end
-- return buffer
-- end,
-- getspectators = function(self)
-- if not EngineClient.IsConnected() or EngineClient.GetLocalPlayer() == nil or EntityList.GetLocalPlayer() == nil then return end
-- local local_player = EntityList.GetLocalPlayer()
-- if local_player == nil then return end
-- if local_player:IsAlive() then
-- return self:get_spectators(local_player:GetPlayer())
-- else
-- local m_hObserverTarget = local_player:GetProp('m_hObserverTarget')
-- if m_hObserverTarget then
-- local targetEntity = EntityList.GetClientEntityFromHandle(m_hObserverTarget)
-- if targetEntity ~= nil and targetEntity:IsPlayer() then
-- return self:get_spectators(targetEntity:GetPlayer())
-- end
-- end
-- end
-- end,
-- run_solus_spectators = function(self)
-- local spectators = self:getspectators()
-- if spectators ~= nil then
-- print(spectators[1]['name'])
-- end
-- end,
run_dmgind = function(self)
-- visuals.dmgind_mode = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display mode",{"-","+"},0,"[~] Display mode"))
-- visuals.dmgind_pos = menu.new_elements("int",ui_new_combobox(t2,"[Damage indicator]","Display postion",{"Top left","Top right","Bottom left","Bottom light"},0,"[~] Display mode"))
if ui_get("bool",visuals.indicator_settings,8) == true then
local font = FONTS.VERDANA_12_R
local x , y = 0,0
local damage = Menu.FindVar("Aimbot", "Ragebot", "Accuracy", "Minimum Damage"):GetInt()
local dmg = '' .. damage
-- {"Top left","Top right","Bottom left","Bottom light"}
if ui_get("value",visuals.dmgind_pos) == 0 then
x = sc_x/2 - 30
y = sc_y/2 - 20
elseif ui_get("value",visuals.dmgind_pos) == 1 then
x = sc_x/2 + 20
y = sc_y/2 - 20
elseif ui_get("value",visuals.dmgind_pos) == 2 then
x = sc_x/2 - 30
y = sc_y/2 + 20
elseif ui_get("value",visuals.dmgind_pos) == 3 then
x = sc_x/2 + 20
y = sc_y/2 + 20
end
if ui_get("value",visuals.dmgind_mode) == 0 then
render_text(x,y,FONTS.PIXEL_10,10,true,false,255,255,255,255,dmg)
elseif ui_get("value",visuals.dmgind_mode) == 1 then
render_text(x + 1,y + 1,FONTS.VERDANA_12_R,11,false,false,0,0,0,205,dmg)
render_text(x,y,FONTS.VERDANA_12_R,11,false,false,255,255,255,255,dmg)
end
end
end,
load_indicators = function(self)
self:on_script_start()
self:run_menueffect()
self:run_watermark()
self:run_damage_maker()
self:run_notifications()
self:run_solus_watermark()
self:run_solus_keybind()
self:run_solus_spectators()
-- self:run_solus_spectators()
local localplayer = EntityList.GetClientEntity(EngineClient.GetLocalPlayer())
if not localplayer then return end
local my_index = EntityList.GetClientEntity(EngineClient.GetLocalPlayer()):GetPlayer()
if not my_index then return end
if EngineClient.IsConnected() and my_index:IsAlive() then
if ui_get("bool",info.feature_list,1) == true then
self:run_arrows()
self:run_center()
self:run_scopeline()
self:run_dmgind()
end
end
end
}
local updateCSA = function(thisptr, edx)
local is_localplayer = ffi.cast("uintptr_t", thisptr) == get_entity_address(EngineClient.GetLocalPlayer())
hooked_function(thisptr, edx)
if is_localplayer then
local addons = misc.anim_list
if addons:GetBool(2) and misc.select:GetBool(2) then
ffi.cast("float*", ffi.cast("uintptr_t", thisptr) + 10104)[6] = 0.5
end
if addons:GetBool(3) and misc.select:GetBool(2) then
ffi.cast("float*", ffi.cast("uintptr_t", thisptr) + 10104)[0] = 1
Menu.FindVar("Aimbot", "Anti Aim", "Misc", "Leg Movement"):Set(1)
end
if addons:GetBool(1) and misc.select:GetBool(2) then
if ffi.cast("CCSGOPlayerAnimationState_534535_t**", ffi.cast("uintptr_t", thisptr) + 0x9960)[0].bHitGroundAnimation then
if not is_jumping then
ffi.cast("float*", ffi.cast("uintptr_t", thisptr) + 10104)[12] = 0.5
end
end
end
end
end
ESP.CustomText("Dormant aimbot", "enemies", "DA", function(ent)
if g_misc.vars.is_dormant_flag then
return "DA"
else
return false
end
end)
local all_callbacks = {
on_draw = function()
g_visual:load_indicators()
end,
on_prediction = function(cmd)
g_antiaim:load_antiaim(cmd)
g_visual:get_desync(cmd)
g_visual:get_fl_amount(cmd)
g_misc:run_hitchance()
g_misc:run_dormant_aimbot(cmd)
end,
on_pre_prediction = function(cmd)
is_jumping = bit.band(cmd.buttons, bit.lshift(1, 1)) ~= 0
g_antiaim:load_pre_antiaim(cmd)
end,
register_shot = function(e)
g_misc:run_hitlog(e)
end,
on_create_move = function()
local local_player = EntityList.GetLocalPlayer()
if not local_player then return end
local local_player_ptr = get_entity_address(local_player:EntIndex())
if not local_player_ptr or hooked_function then return end
local C_CSPLAYER = vmt_hook.new(local_player_ptr)
hooked_function = C_CSPLAYER.hookMethod("void(__fastcall*)(void*, void*)", updateCSA, 224)
end,
on_destory = function()
for i, unHookFunc in ipairs(vmt_hook.hooks) do
unHookFunc()
end
for i, free in ipairs(buff.free) do
free()
end
end,
on_event = function(events)
g_misc:load_events(events)
end,
__call = function(self)
EngineClient.ExecuteClientCmd("clear")
print(cat)
local d = 0
for k, v in pairs(menu.callback_data) do
ui_set_callback(v,g_menu.visible_data)
d = k
end
debugger("invoked ui callback: "..d)
end,
load_callbacks = function(self)
self:__call()
if not ui_get("value",info.master_switch) then
return
end
client_set_event_callback("draw",self.on_draw)
client_set_event_callback("prediction",self.on_prediction)
client_set_event_callback("pre_prediction",self.on_pre_prediction)
client_set_event_callback("createmove",self.on_create_move)
client_set_event_callback("destroy",self.on_destory)
client_set_event_callback("events",self.on_event)
client_set_event_callback("registered_shot",self.register_shot)
end
}
all_callbacks:load_callbacks()
end
_ataraxia_()
