nullworks/cathook
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #26 from nullworks/master

Browse Source 
Fix lots of little things and add Backtrack to aimbot
This commit is contained in:
LightCat 2018-06-30 15:29:36 +02:00 committed by GitHub
commit 545ac32f3b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
26 changed files with 589 additions and 484 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/PlayerTools.hpp
View File

@ -40,5 +40,4 @@ std::optional<colors::rgba_t> forceEspColor(CachedEntity *entity);
#endif
void onKilledBy(CachedEntity *entity);
}

19
include/hacks/Backtrack.hpp
View File

@ -13,17 +13,19 @@ namespace hacks::shared::backtrack
{
struct BacktrackData
{
int tickcount;
Vector hitboxpos;
Vector min;
Vector max;
Vector origin;
float viewangles;
int tickcount{ 0 };
Vector hitboxpos{ 0.0f, 0.0f, 0.0f };
Vector min{ 0.0f, 0.0f, 0.0f };
Vector max{ 0.0f, 0.0f, 0.0f };
Vector origin{ 0.0f, 0.0f, 0.0f };
float viewangles{ 0.0f };
float simtime{ 0.0f };
Vector entorigin{ 0.0f, 0.0f, 0.0f };
};
struct BestTickData
{
int tickcount;
int tick;
int tickcount{ 0 };
int tick{ 0 };
bool operator<(const BestTickData &rhs) const
{
return tickcount < rhs.tickcount;
@ -54,6 +56,7 @@ typedef boost::circular_buffer_space_optimized<CIncomingSequence> circular_buf;
extern circular_buf sequences;
extern CatVar latency;
extern CatVar enable;
extern int ticks;
extern BacktrackData headPositions[32][66];
extern BestTickData sorted_ticks[66];
}

1
include/hacks/Trigger.hpp
View File

@ -15,6 +15,7 @@ namespace hacks::shared::triggerbot
{
void CreateMove();
CachedEntity *FindEntInSight(float range);
bool ShouldShoot();
bool IsTargetStateGood(CachedEntity *entity);
CachedEntity *FindEntInSight(float range);

1
include/online/Online.hpp
View File

@ -36,5 +36,4 @@ struct user_data
void update();
user_data *getUserData(unsigned steamId);
}

11
include/reclasses/C_BaseEntity.hpp Executable file → Normal file
View File

@ -8,6 +8,7 @@
#pragma once
#include "reclasses.hpp"
#include "copypasted/CSignature.h"
namespace re
{
@ -27,5 +28,15 @@ public:
static int placeholder = 0;
return placeholder;
}
inline static int SetAbsOrigin(IClientEntity *self, Vector const &origin)
{
typedef int (*SetAbsOrigin_t)(IClientEntity *, Vector const &);
uintptr_t addr = gSignatures.GetClientSignature(
"55 89 E5 57 56 53 83 EC ? 8B 5D ? 8B 75 ? 89 1C 24 E8 ? ? ? ? F3 "
"0F 10 06");
SetAbsOrigin_t SetAbsOrigin_fn = SetAbsOrigin_t(addr);
return SetAbsOrigin_fn(self, origin);
}
};
}

4
include/visual/colors.hpp Executable file → Normal file
View File

@ -78,12 +78,12 @@ struct rgba_t
}
};
constexpr bool operator==(const rgba_t& lhs, const rgba_t& rhs)
constexpr bool operator==(const rgba_t &lhs, const rgba_t &rhs)
{
return rhs.r == lhs.r && rhs.g == lhs.g && rhs.b == lhs.b && rhs.a == lhs.a;
}
constexpr bool operator!=(const rgba_t& lhs, const rgba_t& rhs)
constexpr bool operator!=(const rgba_t &lhs, const rgba_t &rhs)
{
return !(lhs == rhs);
}

44
src/PlayerTools.cpp
View File

@ -12,21 +12,32 @@
static std::unordered_map<unsigned, unsigned> betrayal_list{};
static CatCommand forgive_all("pt_forgive_all", "Clear betrayal list", []() {
betrayal_list.clear();
});
static CatCommand forgive_all("pt_forgive_all", "Clear betrayal list",
[]() { betrayal_list.clear(); });
namespace settings
{
static CatVar online_notarget(CV_SWITCH, "pt_ignore_notarget", "1", "Ignore notarget", "Ignore online players with notarget role");
static CatVar online_notarget(CV_SWITCH, "pt_ignore_notarget", "1",
"Ignore notarget",
"Ignore online players with notarget role");
static CatVar hoovy(CV_SWITCH, "pt_ignore_hoovy", "1", "Ignore hoovy");
static CatVar online_friendly_software(CV_SWITCH, "pt_ignore_friendly_software", "1", "Ignore friendly software", "Ignore CO-compatible software");
static CatVar online_only_verified(CV_SWITCH, "pt_ignore_only_verified", "0", "Only ignore verified", "If online checks are enabled, only apply ignore if SteamID is verified (not recommended right now)");
static CatVar online_anonymous(CV_SWITCH, "pt_ignore_anonymous", "1", "Ignore anonymous", "Apply ignore checks to anonymous accounts too");
static CatVar betrayal_limit(CV_INT, "pt_betrayal_limit", "3", "Betrayal limit", "Stop ignoring a player after N kills while you ignored them");
static CatVar taunting(CV_SWITCH, "pt_ignore_taunting", "1", "Ignore taunting", "Don't shoot taunting players");
static CatVar online_friendly_software(CV_SWITCH, "pt_ignore_friendly_software",
"1", "Ignore friendly software",
"Ignore CO-compatible software");
static CatVar online_only_verified(CV_SWITCH, "pt_ignore_only_verified", "0",
"Only ignore verified",
"If online checks are enabled, only apply "
"ignore if SteamID is verified (not "
"recommended right now)");
static CatVar online_anonymous(CV_SWITCH, "pt_ignore_anonymous", "1",
"Ignore anonymous",
"Apply ignore checks to anonymous accounts too");
static CatVar betrayal_limit(
CV_INT, "pt_betrayal_limit", "3", "Betrayal limit",
"Stop ignoring a player after N kills while you ignored them");
static CatVar taunting(CV_SWITCH, "pt_ignore_taunting", "1", "Ignore taunting",
"Don't shoot taunting players");
}
namespace player_tools
@ -43,21 +54,23 @@ IgnoreReason shouldTargetSteamId(unsigned id)
return IgnoreReason::DO_NOT_IGNORE;
}
auto& pl = playerlist::AccessData(id);
auto &pl = playerlist::AccessData(id);
if (playerlist::IsFriendly(pl.state))
return IgnoreReason::LOCAL_PLAYER_LIST;
auto *co = online::getUserData(id);
if (co)
{
bool check_verified = !settings::online_only_verified || co->is_steamid_verified;
bool check_verified =
!settings::online_only_verified || co->is_steamid_verified;
bool check_anonymous = settings::online_anonymous || !co->is_anonymous;
if (check_verified && check_anonymous)
{
if (settings::online_notarget && co->no_target)
return IgnoreReason::ONLINE_NO_TARGET;
if (settings::online_friendly_software && co->is_using_friendly_software)
if (settings::online_friendly_software &&
co->is_using_friendly_software)
return IgnoreReason::ONLINE_FRIENDLY_SOFTWARE;
}
// Always check developer status, no exceptions
@ -87,7 +100,7 @@ bool shouldAlwaysRenderEspSteamId(unsigned id)
if (id == 0)
return false;
auto& pl = playerlist::AccessData(id);
auto &pl = playerlist::AccessData(id);
if (pl.state != playerlist::k_EState::DEFAULT)
return true;
@ -155,7 +168,4 @@ void onKilledBy(CachedEntity *entity)
{
onKilledBy(entity->player_info.friendsID);
}
}

4
src/entityhitboxcache.cpp
View File

@ -47,8 +47,8 @@ void EntityHitboxCache::Update()
{
InvalidateCache();
if (CE_BAD(parent_ref))
if (GetHitbox(0))
return;
if (GetHitbox(0))
return;
}
void EntityHitboxCache::Init()

100
src/hacks/Aimbot.cpp
View File

@ -9,6 +9,7 @@
#include <hacks/CatBot.hpp>
#include <hacks/AntiAim.hpp>
#include <hacks/ESP.hpp>
#include <hacks/Backtrack.hpp>
#include <glez/draw.hpp>
#include <PlayerTools.hpp>
#include "common.hpp"
@ -174,7 +175,101 @@ bool projectileAimbotRequired;
// This array will store calculated projectile/hitscan predictions
// for current frame, to avoid performing them again
AimbotCalculatedData_s calculated_data_array[2048]{};
bool BacktrackAimbot()
{
if (!hacks::shared::backtrack::enable)
return false;
if (CE_BAD(LOCAL_E) || !LOCAL_E->m_bAlivePlayer() || !CanShoot())
return false;
if (zoomed_only && !g_pLocalPlayer->bZoomed &&
!(g_pUserCmd->buttons & IN_ATTACK))
return false;
int iBestTarget = hacks::shared::backtrack::iBestTarget;
if (iBestTarget == -1)
{
float bestscr = 999.0f;
for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
{
if (i == g_pLocalPlayer->entity_idx)
continue;
CachedEntity *it = ENTITY(i);
if (CE_BAD(it) || !it->m_bAlivePlayer() ||
it->m_Type() != ENTITY_PLAYER)
continue;
if (it->m_iTeam() == LOCAL_E->m_iTeam())
continue;
if (!hacks::shared::backtrack::headPositions[iBestTarget][0].hitboxpos.z)
continue;
if (!it->hitboxes.GetHitbox(0))
continue;
if (IsPlayerInvisible(it) && ignore_cloak)
continue;
float scr =
GetFov(g_pLocalPlayer->v_OrigViewangles, g_pLocalPlayer->v_Eye,
it->hitboxes.GetHitbox(0)->center);
if (scr < bestscr)
{
iBestTarget = it->m_IDX;
bestscr = scr;
}
}
if (iBestTarget == -1)
return true;
};
for (int t = 0; t < hacks::shared::backtrack::ticks; ++t)
hacks::shared::backtrack::sorted_ticks[t] =
hacks::shared::backtrack::BestTickData{ hacks::shared::backtrack::headPositions[iBestTarget][t].tickcount, t };
std::sort(hacks::shared::backtrack::sorted_ticks, hacks::shared::backtrack::sorted_ticks + hacks::shared::backtrack::ticks);
int tickcnt = 0;
for (auto i : hacks::shared::backtrack::headPositions[iBestTarget])
{
bool good_tick = false;
for (int j = 0; j < 12; ++j)
if (tickcnt == hacks::shared::backtrack::sorted_ticks[j].tick)
good_tick = true;
tickcnt++;
if (!i.hitboxpos.z)
continue;
if (!good_tick)
continue;
if (!IsVectorVisible(g_pLocalPlayer->v_Eye, i.hitboxpos))
continue;
float scr = abs(g_pLocalPlayer->v_OrigViewangles.y - i.viewangles);
CachedEntity *tar = ENTITY(iBestTarget);
// ok just in case
if (CE_BAD(tar))
continue;
Vector &angles = NET_VECTOR(tar, netvar.m_angEyeAngles);
float &simtime = NET_FLOAT(tar, netvar.m_flSimulationTime);
angles.y = i.viewangles;
simtime = i.simtime;
g_pUserCmd->tick_count = i.tickcount;
Vector tr = (i.hitboxpos - g_pLocalPlayer->v_Eye);
Vector angles2;
VectorAngles(tr, angles2);
// Clamping is important
fClampAngle(angles2);
// Slow aim
if (slow_aim)
DoSlowAim(angles2);
else if (silent)
g_pLocalPlayer->bUseSilentAngles = true;
// Set angles
g_pUserCmd->viewangles = angles2;
g_pUserCmd->buttons |= IN_ATTACK;
return true;
}
return true;
}
// The main "loop" of the aimbot.
void CreateMove()
{
@ -225,6 +320,8 @@ void CreateMove()
cur_proj_grav = float(proj_gravity);
}
if (BacktrackAimbot())
return;
// Refresh our best target
CachedEntity *target_entity = RetrieveBestTarget(aimkey_status);
if (CE_BAD(target_entity) || !foundTarget)
@ -574,7 +671,8 @@ bool IsTargetStateGood(CachedEntity *entity)
}
// Some global checks
if (player_tools::shouldTarget(entity) != player_tools::IgnoreReason::DO_NOT_IGNORE)
if (player_tools::shouldTarget(entity) !=
player_tools::IgnoreReason::DO_NOT_IGNORE)
return false;
if (hacks::shared::catbot::should_ignore_player(entity))
return false;

1
src/hacks/Announcer.cpp Executable file → Normal file
View File

@ -177,4 +177,3 @@ void shutdown()
g_IEventManager2->RemoveListener(&listener());
}
}

326
src/hacks/AntiAim.cpp
View File

@ -15,29 +15,20 @@ CatVar communicate(CV_SWITCH, "identify", "0", "identify",
"Auto identify for other cathook users");
CatVar enabled(CV_SWITCH, "aa_enabled", "0", "Anti-Aim",
"Master AntiAim switch");
static CatVar trueang(CV_SWITCH, "aa_realfakes", "0", "Real fakes",
"Do real fakeangles (Unresolveable)");
static CatVar yaw(CV_FLOAT, "aa_yaw", "0.0", "Yaw", "Static yaw (left/right)",
360.0);
static CatVar pitch(CV_FLOAT, "aa_pitch", "-89.0", "Pitch",
"Static pitch (up/down)", -89.0, 89.0);
static CatVar yaw_real(CV_FLOAT, "aa_yaw_real", "0.0", "Real Yaw",
"Static yaw (left/right)", 360.0);
static CatVar pitch_real(CV_FLOAT, "aa_pitch_real", "-89.0", "Real Pitch",
"Static pitch (up/down)", -89.0, 89.0);
static CatEnum yaw_mode_enum({ "KEEP", "STATIC", "JITTER", "BIGRANDOM",
"RANDOM", "SPIN", "OFFSETKEEP", "EDGE", "HECK",
"FAKESIDEWAYS" });
"FAKESIDEWAYS", "FAKERIGHT", "FAKELEFT",
"FAKEFUCK" });
static CatEnum pitch_mode_enum({ "KEEP", "STATIC", "JITTER", "RANDOM", "FLIP",
"FAKEFLIP", "FAKEUP", "FAKEDOWN", "FAKECENTER",
"UP", "DOWN", "HECK" });
CatVar yaw_mode(yaw_mode_enum, "aa_yaw_mode", "0", "Yaw mode", "Yaw mode");
static CatVar pitch_mode(pitch_mode_enum, "aa_pitch_mode", "0", "Pitch mode",
"Pitch mode");
static CatVar true_yaw_mode(yaw_mode_enum, "aa_yaw_mode_real", "0",
"The Real Yaw", "Yaw mode");
static CatVar true_pitch_mode(pitch_mode_enum, "aa_pitch_mode_real", "0",
"The Real Pitch", "Pitch mode");
static CatVar roll(CV_FLOAT, "aa_roll", "0", "Roll",
"Roll angle (viewangles.z)", -180, 180);
static CatVar
@ -72,37 +63,16 @@ bool aaaa_key_pressed = false;
float GetAAAAPitch()
{
if (!trueang)
switch ((int) aaaa_mode)
{
switch ((int) aaaa_mode)
{
case 0:
return aaaa_stage ? -271 : -89;
case 1:
return aaaa_stage ? 271 : 89;
default:
break;
}
return 0;
}
else
{
if (*bSendPackets == true)
{
switch ((int) aaaa_mode)
{
case 0:
return aaaa_stage ? -271 : -89;
case 1:
return aaaa_stage ? 271 : 89;
default:
break;
}
}
else if (*bSendPackets == false)
return g_pUserCmd->viewangles.x;
return 0;
case 0:
return aaaa_stage ? -271 : -89;
case 1:
return aaaa_stage ? 271 : 89;
default:
break;
}
return 0;
}
float GetAAAATimerLength()
@ -419,12 +389,13 @@ void ProcessUserCmd(CUserCmd *cmd)
if (!ShouldAA(cmd))
return;
static bool angstate = true;
if (trueang)
if ((int) yaw_mode >= 9)
angstate = !angstate;
else
angstate = true;
if (!LOCAL_E->m_bAlivePlayer())
angstate = true;
if (lagexploit::ExploitActive() || g_pUserCmd->buttons & IN_ATTACK ||
g_pUserCmd->buttons & IN_ATTACK2)
if (g_pUserCmd->buttons & IN_ATTACK || g_pUserCmd->buttons & IN_ATTACK2)
angstate = true;
*bSendPackets = angstate;
float &p = cmd->viewangles.x;
@ -438,180 +409,103 @@ void ProcessUserCmd(CUserCmd *cmd)
g_pLocalPlayer->bUseSilentAngles = true;
return;
}
if (!*bSendPackets)
switch ((int) true_yaw_mode)
{
case 1: // FIXED
y = (float) yaw_real;
break;
case 2: // JITTER
if (flip)
y += 90;
else
y -= 90;
break;
case 3: // BIGRANDOM
y = RandFloatRange(-65536.0f, 65536.0f);
clamp = false;
break;
case 4: // RANDOM
y = RandFloatRange(-180.0f, 180.0f);
break;
case 5: // SPIN
cur_yaw += (float) spin;
if (cur_yaw > 180)
cur_yaw = -180;
if (cur_yaw < -180)
cur_yaw = 180;
y = cur_yaw;
break;
case 6: // OFFSETKEEP
y += (float) yaw_real;
break;
case 7: // Edge
// Attemt to find an edge and if found, edge
if (findEdge(y))
y = useEdge(y);
break;
case 8:
FuckYaw(y);
clamp = false;
break;
default:
break;
}
if (*bSendPackets)
switch ((int) yaw_mode)
{
case 1: // FIXED
y = (float) yaw;
break;
case 2: // JITTER
if (flip)
y += 90;
else
y -= 90;
break;
case 3: // BIGRANDOM
y = RandFloatRange(-65536.0f, 65536.0f);
clamp = false;
break;
case 4: // RANDOM
y = RandFloatRange(-180.0f, 180.0f);
break;
case 5: // SPIN
cur_yaw += (float) spin;
if (cur_yaw > 180)
cur_yaw = -180;
if (cur_yaw < -180)
cur_yaw = 180;
y = cur_yaw;
break;
case 6: // OFFSETKEEP
y += (float) yaw;
break;
case 7: // Edge
// Attemt to find an edge and if found, edge
if (findEdge(y))
y = useEdge(y);
break;
case 8:
FuckYaw(y);
clamp = false;
break;
default:
break;
}
if (yaw_mode == 9)
switch ((int) yaw_mode)
{
case 1: // FIXED
y = (float) yaw;
break;
case 2: // JITTER
if (flip)
y += 90;
else
y -= 90;
break;
case 3: // BIGRANDOM
y = RandFloatRange(-65536.0f, 65536.0f);
clamp = false;
break;
case 4: // RANDOM
y = RandFloatRange(-180.0f, 180.0f);
break;
case 5: // SPIN
cur_yaw += (float) spin;
if (cur_yaw > 180)
cur_yaw = -180;
if (cur_yaw < -180)
cur_yaw = 180;
y = cur_yaw;
break;
case 6: // OFFSETKEEP
y += (float) yaw;
break;
case 7: // Edge
// Attemt to find an edge and if found, edge
if (findEdge(y))
y = useEdge(y);
break;
case 8:
FuckYaw(y);
clamp = false;
break;
case 9:
y += *bSendPackets ? 90.0f : -90.0f;
if (!*bSendPackets)
switch (int(true_pitch_mode))
{
case 1:
p = float(pitch_real);
break;
case 2:
if (flip)
p += 30.0f;
else
p -= 30.0f;
break;
case 3:
p = RandFloatRange(-89.0f, 89.0f);
break;
case 4:
p = flip ? 89.0f : -89.0f;
break;
case 5:
p = flip ? 271.0f : -271.0f;
clamp = false;
break;
case 6:
p = -271.0f;
clamp = false;
break;
case 7:
p = 271.0f;
clamp = false;
break;
case 8:
p = -3256.0f;
clamp = false;
break;
case 9:
p = -89.0f;
break;
case 10:
p = 89.0f;
break;
case 11:
FuckPitch(p);
clamp = false;
}
if (*bSendPackets)
switch (int(pitch_mode))
{
case 1:
p = float(pitch);
break;
case 2:
if (flip)
p += 30.0f;
else
p -= 30.0f;
break;
case 3:
p = RandFloatRange(-89.0f, 89.0f);
break;
case 4:
p = flip ? 89.0f : -89.0f;
break;
case 5:
p = flip ? 271.0f : -271.0f;
clamp = false;
break;
case 6:
p = -271.0f;
clamp = false;
break;
case 7:
p = 271.0f;
clamp = false;
break;
case 8:
p = -3256.0f;
clamp = false;
break;
case 9:
p = -89.0f;
break;
case 10:
p = 89.0f;
break;
case 11:
FuckPitch(p);
clamp = false;
}
break;
case 10:
y += *bSendPackets ? 0.0f : 90.0f;
break;
case 11:
y += *bSendPackets ? 0.0f : -90.0f;
break;
case 12:
if (*bSendPackets)
FuckYaw(y);
break;
default:
break;
}
switch (int(pitch_mode))
{
case 1:
p = float(pitch);
break;
case 2:
if (flip)
p += 30.0f;
else
p -= 30.0f;
break;
case 3:
p = RandFloatRange(-89.0f, 89.0f);
break;
case 4:
p = flip ? 89.0f : -89.0f;
break;
case 5:
p = flip ? 271.0f : -271.0f;
clamp = false;
break;
case 6:
p = -271.0f;
clamp = false;
break;
case 7:
p = 271.0f;
clamp = false;
break;
case 8:
p = -3256.0f;
clamp = false;
break;
case 9:
p = -89.0f;
break;
case 10:
p = 89.0f;
break;
case 11:
FuckPitch(p);
clamp = false;
}
flip = !flip;
if (clamp)
fClampAngle(cmd->viewangles);

45
src/hacks/AutoBackstab.cpp
View File

@ -37,7 +37,8 @@ void CreateMove()
return;
if (g_pLocalPlayer->weapon()->m_iClassID() != CL_CLASS(CTFKnife))
return;
if (CE_BYTE(g_pLocalPlayer->weapon(), netvar.m_bReadyToBackstab))
if (!hacks::shared::backtrack::enable &&
CE_BYTE(g_pLocalPlayer->weapon(), netvar.m_bReadyToBackstab))
g_pUserCmd->buttons |= IN_ATTACK;
else
{
@ -46,22 +47,34 @@ void CreateMove()
if (hacks::shared::backtrack::iBestTarget == -1)
return;
int iBestTarget = hacks::shared::backtrack::iBestTarget;
int BestTick = hacks::shared::backtrack::BestTick;
float scr =
abs(g_pLocalPlayer->v_OrigViewangles.y -
hacks::shared::backtrack::headPositions[iBestTarget][BestTick]
.viewangles);
if (scr < 40.0f &&
hacks::shared::backtrack::headPositions[iBestTarget][BestTick]
.origin.DistTo(g_pLocalPlayer->v_Eye) <=
re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W)))
int tickcnt = 0;
for (auto i : hacks::shared::backtrack::headPositions[iBestTarget])
{
g_pUserCmd->tick_count =
hacks::shared::backtrack::headPositions[iBestTarget][BestTick]
.tickcount;
g_pUserCmd->buttons |= IN_ATTACK;
bool good_tick = false;
for (int j = 0; j < 12; ++j)
if (tickcnt == hacks::shared::backtrack::sorted_ticks[j].tick)
good_tick = true;
tickcnt++;
if (!good_tick)
continue;
float scr = abs(g_pLocalPlayer->v_OrigViewangles.y - i.viewangles);
if (scr <= 90.0f &&
i.origin.DistTo(g_pLocalPlayer->v_Eye) <=
re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W)))
{
CachedEntity *tar = ENTITY(iBestTarget);
// ok just in case
if (CE_BAD(tar))
continue;
Vector &angles = NET_VECTOR(tar, netvar.m_angEyeAngles);
float &simtime = NET_FLOAT(tar, netvar.m_flSimulationTime);
angles.y = i.viewangles;
g_pUserCmd->tick_count = i.tickcount;
g_pUserCmd->buttons |= IN_ATTACK;
break;
}
}
}
}

11
src/hacks/AutoDeadringer.cpp
View File

@ -50,10 +50,13 @@ void CreateMove()
return;
if (CE_BAD(LOCAL_E))
return;
if (g_pLocalPlayer->clazz != tf_spy)
return;
if (CE_BYTE(LOCAL_E, netvar.m_bFeignDeathReady))
return;
if (HasCondition<TFCond_Cloaked>(LOCAL_E) || HasCondition<TFCond_CloakFlicker>(LOCAL_E))
return;
if (HasCondition<TFCond_Cloaked>(LOCAL_E) ||
HasCondition<TFCond_CloakFlicker>(LOCAL_E))
return;
if (CE_INT(LOCAL_E, netvar.iHealth) < (int) trigger_health &&
NearbyEntities() > 1)
g_pUserCmd->buttons |= IN_ATTACK2;
@ -64,6 +67,10 @@ void CreateMove()
continue;
if (!IsProjectile(ent) && !ent->m_bGrenadeProjectile())
continue;
if (!ent->m_bEnemy())
continue;
if (ent->m_Type() != ENTITY_PROJECTILE)
continue;
if (ent->m_bCritProjectile() && ent->m_flDistance() <= 1000.0f)
g_pUserCmd->buttons |= IN_ATTACK2;
if (ent->m_flDistance() < 300.0f)

4
src/hacks/AutoDetonator.cpp
View File

@ -56,7 +56,8 @@ bool IsTarget(CachedEntity *ent)
return false;
// Global checks
if (player_tools::shouldTarget(ent) != player_tools::IgnoreReason::DO_NOT_IGNORE)
if (player_tools::shouldTarget(ent) !=
player_tools::IgnoreReason::DO_NOT_IGNORE)
return false;
IF_GAME(IsTF())
{
@ -64,7 +65,6 @@ bool IsTarget(CachedEntity *ent)
if (IsPlayerInvulnerable(ent))
return false;
// If settings allow, dont target cloaked players
if (legit && IsPlayerInvisible(ent))
return false;

32
src/hacks/AutoHeal.cpp
View File

@ -351,29 +351,31 @@ bool IsPopped()
bool ShouldChargePlayer(int idx)
{
CachedEntity *target = ENTITY(idx);
const int health = target->m_iHealth();
const int health = target->m_iHealth();
if (float(pop_uber_percent) > 0)
{
const float pophealth = target->m_iMaxHealth() * (float(pop_uber_percent) / 100);
const float pophealth =
target->m_iMaxHealth() * (float(pop_uber_percent) / 100);
if (health < pophealth)
return true;
}
else
{
const float damage_accum_duration =
g_GlobalVars->curtime - data[idx].accum_damage_start;
if (!data[idx].accum_damage_start)
const float damage_accum_duration =
g_GlobalVars->curtime - data[idx].accum_damage_start;
if (!data[idx].accum_damage_start)
return false;
if (health > 30 && data[idx].accum_damage < 45)
return false;
const float dd =
((float) data[idx].accum_damage / damage_accum_duration);
if (dd > 40)
{
return true;
}
if (health < 30 && data[idx].accum_damage > 10)
return true;
return false;
if (health > 30 && data[idx].accum_damage < 45)
return false;
const float dd = ((float) data[idx].accum_damage / damage_accum_duration);
if (dd > 40)
{
return true;
}
if (health < 30 && data[idx].accum_damage > 10)
return true;
return false;
}
return false;
}

3
src/hacks/AutoSticky.cpp
View File

@ -61,7 +61,8 @@ bool IsTarget(CachedEntity *ent)
return false;
// Global checks
if (player_tools::shouldTarget(ent) != player_tools::IgnoreReason::DO_NOT_IGNORE)
if (player_tools::shouldTarget(ent) !=
player_tools::IgnoreReason::DO_NOT_IGNORE)
return false;
IF_GAME(IsTF())

35
src/hacks/Backtrack.cpp
View File

@ -25,8 +25,8 @@ static CatEnum slots_enum({ "All", "Primary", "Secondary", "Melee",
static CatVar slots(slots_enum, "backtrack_slots", "0", "Enabled Slots",
"Select what slots backtrack should be enabled on.");
BacktrackData headPositions[32][66];
BestTickData sorted_ticks[66];
BacktrackData headPositions[32][66]{};
BestTickData sorted_ticks[66]{};
int highesttick[32]{};
int lastincomingsequencenumber = 0;
static bool shouldDrawBt;
@ -69,10 +69,11 @@ int ticks = 12;
void Init()
{
for (int i = 0; i < 32; i++)
for (int j = 0; j < 66; j++)
headPositions[i][j] = BacktrackData{
0, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 }
};
for (int j = 0; j < 66; j++)
headPositions[i][j] =
BacktrackData{ 0, { 0, 0, 0 }, { 0, 0, 0 },
{ 0, 0, 0 }, { 0, 0, 0 }, 0,
0, { 0, 0, 0 } };
if (!installed)
{
latency.InstallChangeCallback(
@ -115,7 +116,8 @@ void Run()
{
for (BacktrackData &btd : headPositions[i])
btd = BacktrackData{ 0, { 0, 0, 0 }, { 0, 0, 0 },
{ 0, 0, 0 }, { 0, 0, 0 }, 0 };
{ 0, 0, 0 }, { 0, 0, 0 }, 0,
0, { 0, 0, 0 } };
continue;
}
if (pEntity->m_iTeam() == LOCAL_E->m_iTeam())
@ -131,10 +133,12 @@ void Run()
NET_VECTOR(RAW_ENT(pEntity), netvar.m_angEyeAngles).y;
float viewangles =
(_viewangles > 180) ? _viewangles - 360 : _viewangles;
float simtime = CE_FLOAT(pEntity, netvar.m_flSimulationTime);
Vector hitbox_spine = pEntity->hitboxes.GetHitbox(3)->center;
Vector ent_orig = pEntity->InternalEntity()->GetAbsOrigin();
headPositions[i][cmd->command_number % ticks] =
BacktrackData{ cmd->tick_count, hitboxpos, min, max,
hitbox_spine, viewangles };
BacktrackData{ cmd->tick_count, hitboxpos, min, max,
hitbox_spine, viewangles, simtime, ent_orig };
float FOVDistance = GetFov(g_pLocalPlayer->v_OrigViewangles,
g_pLocalPlayer->v_Eye, hitboxpos);
float distance = g_pLocalPlayer->v_Eye.DistTo(hitbox_spine);
@ -189,7 +193,18 @@ void Run()
BestTick = bestTick;
if (cmd->buttons & IN_ATTACK)
cmd->tick_count = headPositions[iBestTarget][bestTick].tickcount;
{
CachedEntity *tar = ENTITY(iBestTarget);
// ok just in case
if (CE_BAD(tar))
return;
auto i = headPositions[iBestTarget][bestTick];
cmd->tick_count = i.tickcount;
Vector &angles = NET_VECTOR(tar, netvar.m_angEyeAngles);
float &simtime = NET_FLOAT(tar, netvar.m_flSimulationTime);
angles.y = i.viewangles;
simtime = i.simtime;
}
}
}
void Draw()

22
src/hacks/ESP.cpp
View File

@ -149,9 +149,12 @@ static CatVar entity_id(CV_SWITCH, "esp_entity_id", "1", "Entity ID",
"Used with Entity ESP. Shows entityID");
// Online
static CatVar online(CV_SWITCH, "esp_online", "1", "Show online info", "Username, etc");
static CatVar online_groups(CV_SWITCH, "esp_online_groups", "1", "Show online groups", "Admin, developer, etc");
static CatVar online_software(CV_SWITCH, "esp_online_software", "1", "Show software", "cathook, lmaobox, etc");
static CatVar online(CV_SWITCH, "esp_online", "1", "Show online info",
"Username, etc");
static CatVar online_groups(CV_SWITCH, "esp_online_groups", "1",
"Show online groups", "Admin, developer, etc");
static CatVar online_software(CV_SWITCH, "esp_online_software", "1",
"Show software", "cathook, lmaobox, etc");
// CatVar draw_hitbox(CV_SWITCH, "esp_hitbox", "1", "Draw Hitbox");
@ -356,7 +359,7 @@ void CreateMove()
ProcessEntity(ent);
// Update Bones
if (i <= 32)
ent->hitboxes.GetHitbox(0);
ent->hitboxes.GetHitbox(0);
// Dont know what this check is for
if (data[i].string_count)
{
@ -1160,7 +1163,8 @@ void _FASTCALL ProcessEntity(CachedEntity *ent)
if (!g_IEngine->GetPlayerInfo(ent->m_IDX, &info))
return;
online::user_data *data = online ? online::getUserData(info.friendsID) : nullptr;
online::user_data *data =
online ? online::getUserData(info.friendsID) : nullptr;
// TODO, check if u can just use "ent->m_bEnemy()" instead of m_iTeam
// Legit mode handling
@ -1183,14 +1187,15 @@ void _FASTCALL ProcessEntity(CachedEntity *ent)
if (data->is_steamid_verified)
AddEntityString(ent, "Verified SteamID", colors::green);
if (online_groups)
for (auto& s: data->shown_groups)
for (auto &s : data->shown_groups)
AddEntityString(ent, s, colors::orange);
if (online_software && data->has_software)
{
if (data->is_using_friendly_software)
AddEntityString(ent, "Software: " + data->software_name);
else
AddEntityString(ent, "Software: " + data->software_name, colors::red);
AddEntityString(ent, "Software: " + data->software_name,
colors::red);
}
}
@ -1203,7 +1208,8 @@ void _FASTCALL ProcessEntity(CachedEntity *ent)
}
// Dont understand reasoning for this check
if (ent->m_bEnemy() || teammates || player_tools::shouldAlwaysRenderEsp(ent))
if (ent->m_bEnemy() || teammates ||
player_tools::shouldAlwaysRenderEsp(ent))
{
// Playername

21
src/hacks/FollowBot.cpp
View File

@ -65,8 +65,8 @@ static const int crumb_limit = 64; // limit
int follow_target = 0;
bool inited;
Timer lastTaunt{}; //time since taunt was last executed, used to avoid kicks
std::array<Timer, 32> afkTicks; //for how many ms the player hasn't been moving
Timer lastTaunt{}; // time since taunt was last executed, used to avoid kicks
std::array<Timer, 32> afkTicks; // for how many ms the player hasn't been moving
void checkAFK()
{
@ -177,7 +177,9 @@ void WorldTick()
continue;
if (entity->m_bEnemy())
continue;
if (afk && afkTicks[i].check(int(afktime))) //don't follow target that was determined afk
if (afk &&
afkTicks[i].check(int(
afktime))) // don't follow target that was determined afk
continue;
if (IsPlayerDisguised(entity) || IsPlayerInvisible(entity))
continue;
@ -219,7 +221,7 @@ void WorldTick()
continue;
// ooooo, a target
follow_target = i;
afkTicks[i].update(); //set afk time to 0
afkTicks[i].update(); // set afk time to 0
}
}
// last check for entity before we continue
@ -236,7 +238,7 @@ void WorldTick()
follow_target = 0;
return;
}
//check if target is afk
// check if target is afk
if (afk)
{
if (afkTicks[follow_target].check(int(afktime)))
@ -244,7 +246,6 @@ void WorldTick()
follow_target = 0;
return;
}
}
// Update timer on new target
@ -281,9 +282,11 @@ void WorldTick()
}
}
//moved because its worthless otherwise
if (sync_taunt && HasCondition<TFCond_Taunting>(followtar) && lastTaunt.test_and_set(1000)) {
g_IEngine->ClientCmd("taunt");
// moved because its worthless otherwise
if (sync_taunt && HasCondition<TFCond_Taunting>(followtar) &&
lastTaunt.test_and_set(1000))
{
g_IEngine->ClientCmd("taunt");
}
// Follow the crumbs when too far away, or just starting to follow

117
src/hacks/Trigger.cpp
View File

@ -80,43 +80,57 @@ int last_hb_traced = 0;
Vector forward;
bool CanBacktrack()
{
int target = hacks::shared::backtrack::iBestTarget;
int BestTick = hacks::shared::backtrack::BestTick;
auto min = hacks::shared::backtrack::headPositions[target][BestTick].min;
auto max = hacks::shared::backtrack::headPositions[target][BestTick].max;
if (!min.x && !max.x)
return false;
// Get the min and max for the hitbox
Vector minz(std::min(min.x, max.x), std::min(min.y, max.y),
std::min(min.z, max.z));
Vector maxz(std::max(min.x, max.x), std::max(min.y, max.y),
std::max(min.z, max.z));
// Shrink the hitbox here
Vector size = maxz - minz;
Vector smod = size * 0.05f * (int) accuracy;
// Save the changes to the vectors
minz += smod;
maxz -= smod;
// Trace and test if it hits the smaller hitbox, if it fails
// we
// return false
Vector hit;
if (!IsVectorVisible(g_pLocalPlayer->v_Eye, minz) &&
!IsVectorVisible(g_pLocalPlayer->v_Eye, maxz))
int target = hacks::shared::backtrack::iBestTarget;
int tickcnt = 0;
for (auto i : hacks::shared::backtrack::headPositions[target])
{
return true;
}
if (CheckLineBox(minz, maxz, g_pLocalPlayer->v_Eye, forward, hit))
{
g_pUserCmd->tick_count =
hacks::shared::backtrack::headPositions[target][BestTick].tickcount;
g_pUserCmd->buttons |= IN_ATTACK;
return false;
bool good_tick = false;
for (int j = 0; j < 12; ++j)
if (tickcnt == hacks::shared::backtrack::sorted_ticks[j].tick)
good_tick = true;
tickcnt++;
if (!good_tick)
continue;
auto min = i.min;
auto max = i.max;
if (!min.x && !max.x)
continue;
// Get the min and max for the hitbox
Vector minz(fminf(min.x, max.x), fminf(min.y, max.y),
fminf(min.z, max.z));
Vector maxz(fmaxf(min.x, max.x), fmaxf(min.y, max.y),
fmaxf(min.z, max.z));
// Shrink the hitbox here
Vector size = maxz - minz;
Vector smod = size * 0.05f * (int) accuracy;
// Save the changes to the vectors
minz += smod;
maxz -= smod;
// Trace and test if it hits the smaller hitbox, if it fails
// we
// return false
Vector hit;
if (!IsVectorVisible(g_pLocalPlayer->v_Eye, minz) &&
!IsVectorVisible(g_pLocalPlayer->v_Eye, maxz))
continue;
if (CheckLineBox(minz, maxz, g_pLocalPlayer->v_Eye, forward, hit))
{
CachedEntity *tar = ENTITY(target);
// ok just in case
if (CE_BAD(tar))
continue;
Vector &angles = NET_VECTOR(tar, netvar.m_angEyeAngles);
float &simtime = NET_FLOAT(tar, netvar.m_flSimulationTime);
angles.y = i.viewangles;
g_pUserCmd->tick_count = i.tickcount;
g_pUserCmd->buttons |= IN_ATTACK;
return false;
}
}
return true;
}
@ -142,7 +156,7 @@ void CreateMove()
CachedEntity *ent = FindEntInSight(EffectiveTargetingRange());
// Check if can backtrack, shoot if we can
if (!CanBacktrack())
if (!CanBacktrack() || hacks::shared::backtrack::enable)
return;
// Check if dormant or null to prevent crashes
@ -274,7 +288,8 @@ bool IsTargetStateGood(CachedEntity *entity)
return false;
// Global checks
if (player_tools::shouldTarget(entity) != player_tools::IgnoreReason::DO_NOT_IGNORE)
if (player_tools::shouldTarget(entity) !=
player_tools::IgnoreReason::DO_NOT_IGNORE)
return false;
IF_GAME(IsTF())
@ -330,12 +345,12 @@ bool IsTargetStateGood(CachedEntity *entity)
if (hb)
{
// Get the min and max for the hitbox
Vector minz(std::min(hb->min.x, hb->max.x),
std::min(hb->min.y, hb->max.y),
std::min(hb->min.z, hb->max.z));
Vector maxz(std::max(hb->min.x, hb->max.x),
std::max(hb->min.y, hb->max.y),
std::max(hb->min.z, hb->max.z));
Vector minz(fminf(hb->min.x, hb->max.x),
fminf(hb->min.y, hb->max.y),
fminf(hb->min.z, hb->max.z));
Vector maxz(fmaxf(hb->min.x, hb->max.x),
fmaxf(hb->min.y, hb->max.y),
fmaxf(hb->min.z, hb->max.z));
// Shrink the hitbox here
Vector size = maxz - minz;
@ -614,25 +629,17 @@ bool UpdateAimkey()
float EffectiveTargetingRange()
{
if (GetWeaponMode() == weapon_melee)
{
return re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
// Pyros only have so much untill their flames hit
}
// Pyros only have so much untill their flames hit
else if (g_pLocalPlayer->weapon()->m_iClassID() ==
CL_CLASS(CTFFlameThrower))
{
return 185.0f;
}
return 200.0f;
// If user has set a max range, then use their setting,
if (max_range)
{
return (float) max_range;
// else use a pre-set range
}
// else use a pre-set range
else
{
return 8012.0f;
}
}
// Helper functions to trace for hitboxes

1
src/hacks/ac/antiaim.cpp Executable file → Normal file
View File

@ -74,4 +74,3 @@ void Event(KeyValues *event)
{
}
}

29
src/hooks/CreateMove.cpp
View File

@ -89,7 +89,8 @@ void RunEnginePrediction(IClientEntity *ent, CUserCmd *ucmd)
#else
#define antikick_time 90
#endif
const char *cmds[7] = {"use", "voicecommand", "spec_next", "spec_prev", "spec_player", "invprev", "invnext"};
const char *cmds[7] = { "use", "voicecommand", "spec_next", "spec_prev",
"spec_player", "invprev", "invnext" };
namespace hooked_methods
{
DEFINE_HOOKED_METHOD(CreateMove, bool, void *this_, float input_sample_time,
@ -338,14 +339,14 @@ DEFINE_HOOKED_METHOD(CreateMove, bool, void *this_, float input_sample_time,
if (engine_pred)
engine_prediction::RunEnginePrediction(RAW_ENT(LOCAL_E),
g_pUserCmd);
{
PROF_SECTION(CM_aimbot);
hacks::shared::aimbot::CreateMove();
}
{
PROF_SECTION(CM_backtracc);
hacks::shared::backtrack::Run();
}
{
PROF_SECTION(CM_aimbot);
hacks::shared::aimbot::CreateMove();
}
IF_GAME(IsTF2())
{
PROF_SECTION(CM_antibackstab);
@ -537,12 +538,12 @@ DEFINE_HOOKED_METHOD(CreateMove, bool, void *this_, float input_sample_time,
{
for (int i = 0; i < 7800; i += sizeof(cmds[nextdata]))
{
senddata.m_szCommand = cmds[nextdata];
senddata.m_szCommand = cmds[nextdata];
ch->SendNetMsg(senddata);
if (nextdata == 6)
nextdata = 0;
nextdata = 0;
else
nextdata++;
nextdata++;
}
ch->Transmit();
}
@ -581,12 +582,12 @@ DEFINE_HOOKED_METHOD(CreateMove, bool, void *this_, float input_sample_time,
for (int i = 0; i < 7800 + additionallag;
i += sizeof(cmds[nextdata]))
{
senddata.m_szCommand = cmds[nextdata];
senddata.m_szCommand = cmds[nextdata];
ch->SendNetMsg(senddata, false);
if (nextdata == 6)
nextdata = 0;
nextdata = 0;
else
nextdata++;
nextdata++;
}
ch->Transmit();
}
@ -595,11 +596,11 @@ DEFINE_HOOKED_METHOD(CreateMove, bool, void *this_, float input_sample_time,
{
for (int i = 0; i < (int) serverlag_amount; i++)
{
senddata.m_szCommand = cmds[nextdata];
senddata.m_szCommand = cmds[nextdata];
if (nextdata == 6)
nextdata = 0;
nextdata = 0;
else
nextdata++;
nextdata++;
ch->SendNetMsg(senddata, false);
}
ch->Transmit();

186
src/online/Online.cpp
View File

@ -31,17 +31,20 @@ static bool identify_stale{ false };
static std::string api_key{};
static CatVar enable(CV_SWITCH, "online", "1", "Enable online features");
static CatCommand login("online_login", "Login", [](const CCommand& args) {
static CatCommand login("online_login", "Login", [](const CCommand &args) {
if (args.ArgC() != 3)
{
logging::Info("\nUsage: online_login <API_KEY> \"<IP:PORT>\"\nKey will be saved in your data folder");
logging::Info("\nUsage: online_login <API_KEY> \"<IP:PORT>\"\nKey will "
"be saved in your data folder");
return;
}
std::string host(args.Arg(2));
logging::Info("[CO] Host = %s", host.c_str());
try {
try
{
cathookOnlineService.setHost(host);
} catch (std::exception& ex)
}
catch (std::exception &ex)
{
logging::Info("[CO] Error setting host: %s", ex.what());
return;
@ -49,28 +52,35 @@ static CatCommand login("online_login", "Login", [](const CCommand& args) {
std::string key(args.Arg(1));
try
{
cathookOnlineService.login(key, [key, host](co::ApiCallResult result, std::optional<co::logged_in_user> me) {
if (result == co::ApiCallResult::OK)
{
logging::Info("[CO] Successfully logged in. Welcome, %s", me->username.c_str());
api_key = key;
saveApiKeyAndHost(host);
claimSteamId();
}
else
{
logging::Info("[CO] There was an error logging in: code %d", result);
}
});
} catch (std::exception& ex) {
cathookOnlineService.login(
key, [key, host](co::ApiCallResult result,
std::optional<co::logged_in_user> me) {
if (result == co::ApiCallResult::OK)
{
logging::Info("[CO] Successfully logged in. Welcome, %s",
me->username.c_str());
api_key = key;
saveApiKeyAndHost(host);
claimSteamId();
}
else
{
logging::Info("[CO] There was an error logging in: code %d",
result);
}
});
}
catch (std::exception &ex)
{
logging::Info("[CO] Exception: %s", ex.what());
}
});
static CatCommand flush("online_flush_cache", "Flush player cache", [](const CCommand& args) {
data.clear();
identify_queue.clear();
identify_stale = true;
});
static CatCommand flush("online_flush_cache", "Flush player cache",
[](const CCommand &args) {
data.clear();
identify_queue.clear();
identify_stale = true;
});
// INTERNAL METHODS
@ -78,9 +88,12 @@ void claimSteamId()
{
auto id = g_ISteamUser->GetSteamID();
logging::Info("[CO] Claiming SteamID %u", id.GetAccountID());
try {
try
{
cathookOnlineService.gameStartup(id.GetAccountID());
} catch (std::exception& ex) {
}
catch (std::exception &ex)
{
logging::Info("[CO] Exception: %s", ex.what());
}
}
@ -94,9 +107,12 @@ bool tryLoadApiKeyAndHost()
keyfile >> api_key >> host;
if (!api_key.empty() && !host.empty())
{
try {
try
{
cathookOnlineService.setHost(host);
} catch (std::exception& ex) {
}
catch (std::exception &ex)
{
logging::Info("Error while setting host: %s", ex.what());
}
return true;
@ -130,14 +146,14 @@ void markSteamIdNonOnline(unsigned id)
data[id] = std::nullopt;
}
void processOnlineIdentity(unsigned id, co::identified_user& user)
void processOnlineIdentity(unsigned id, co::identified_user &user)
{
logging::Info("[CO] %u - online", id);
user_data udata{};
udata.username = user.username;
udata.is_anonymous = (user.username == "anonymous");
udata.username = user.username;
udata.is_anonymous = (user.username == "anonymous");
udata.is_steamid_verified = user.steamid_verified;
for (auto& i: user.groups)
for (auto &i : user.groups)
{
if (i.display_name.has_value())
udata.shown_groups.push_back(*i.display_name);
@ -155,22 +171,25 @@ void processOnlineIdentity(unsigned id, co::identified_user& user)
if (user.color.has_value())
{
udata.has_color = true;
udata.color = colors::rgba_t(user.color->c_str());
udata.color = colors::rgba_t(user.color->c_str());
}
#endif
if (user.uses_software.has_value())
{
udata.has_software = true;
udata.has_software = true;
udata.is_using_friendly_software = user.uses_software->friendly;
udata.software_name = user.uses_software->name;
udata.software_name = user.uses_software->name;
}
data[id] = std::move(udata);
}
void processIdentifyResponse(std::vector<unsigned> input, co::identified_user_group& group)
void processIdentifyResponse(std::vector<unsigned> input,
co::identified_user_group &group)
{
logging::Info("[CO] Processing identify response containing %u / %u entries", group.users.size(), input.size());
for (auto i: input)
logging::Info(
"[CO] Processing identify response containing %u / %u entries",
group.users.size(), input.size());
for (auto i : input)
{
auto u = group.users.find(i);
if (u == group.users.end())
@ -179,7 +198,8 @@ void processIdentifyResponse(std::vector<unsigned> input, co::identified_user_gr
processOnlineIdentity(i, (*u).second);
identify_queue.erase(i);
logging::Info("[CO] Removed %u from identify queue, left %u\n", i, identify_queue.size());
logging::Info("[CO] Removed %u from identify queue, left %u\n", i,
identify_queue.size());
}
}
@ -196,48 +216,68 @@ void sendIdentifyRequest()
steamIds.push_back(it->first);
}
}
logging::Info("[CO] Sending identify request for %u players", steamIds.size());
try {
cathookOnlineService.userIdentify(steamIds, (std::function<void(co::ApiCallResult, std::optional<co::identified_user_group>)>)[steamIds](co::ApiCallResult result, std::optional<co::identified_user_group> group) {
if (result == co::ApiCallResult::OK)
{
processIdentifyResponse(steamIds, *group);
}
else
logging::Info("[CO] Sending identify request for %u players",
steamIds.size());
try
{
cathookOnlineService.userIdentify(
steamIds,
(std::function<void(
co::ApiCallResult,
std::optional<co::identified_user_group>)>) [steamIds](
co::ApiCallResult result,
std::optional<co::identified_user_group> group) {
if (result == co::ApiCallResult::OK)
{
logging::Info("[CO] Something went wrong while identifying %u players: code %d", steamIds.size(), result);
for (auto i: steamIds)
processIdentifyResponse(steamIds, *group);
}
else
{
logging::Info("[CO] Something went wrong while identifying "
"%u players: code %d",
steamIds.size(), result);
for (auto i : steamIds)
{
identify_queue[i] = false;
}
identify_stale = true;
}
});
} catch (std::exception& ex) {
});
}
catch (std::exception &ex)
{
logging::Info("[CO] Exception: %s", ex.what());
}
}
InitRoutine init([]() {
cathookOnlineService.setErrorHandler((std::function<void(std::string)>)[](std::string error) {
logging::Info("[CO] Error: %s", error.c_str());
});
cathookOnlineService.setErrorHandler((std::function<void(std::string)>) [](
std::string error) { logging::Info("[CO] Error: %s", error.c_str()); });
if (tryLoadApiKeyAndHost())
{
logging::Info("[CO] API key loaded successfully");
try {
cathookOnlineService.login(api_key, [](co::ApiCallResult result, std::optional<co::logged_in_user> me) {
if (result == co::ApiCallResult::OK)
{
logging::Info("[CO] Successfully logged in. Welcome, %s", me->username.c_str());
claimSteamId();
}
else
{
logging::Info("[CO] There was an error logging in: code %d", result);
}
});
} catch (std::exception& ex) {
try
{
cathookOnlineService.login(
api_key, [](co::ApiCallResult result,
std::optional<co::logged_in_user> me) {
if (result == co::ApiCallResult::OK)
{
logging::Info(
"[CO] Successfully logged in. Welcome, %s",
me->username.c_str());
claimSteamId();
}
else
{
logging::Info(
"[CO] There was an error logging in: code %d",
result);
}
});
}
catch (std::exception &ex)
{
logging::Info("[CO] Exception: %s", ex.what());
}
}
@ -249,15 +289,20 @@ void update()
{
if (!enable)
return;
// Only send a request after 3 seconds passed since last unknown steamId was added to the queue
if (!api_key.empty() && identify_stale && identify_timer.check(3000) && !identify_queue.empty())
// Only send a request after 3 seconds passed since last unknown steamId was
// added to the queue
if (!api_key.empty() && identify_stale && identify_timer.check(3000) &&
!identify_queue.empty())
{
sendIdentifyRequest();
identify_stale = false;
}
try {
try
{
cathookOnlineService.processPendingCalls();
} catch (std::exception& ex) {
}
catch (std::exception &ex)
{
logging::Info("[CO] Exception: %s", ex.what());
}
}
@ -285,5 +330,4 @@ user_data *getUserData(unsigned steamId)
// SteamID does not belong to online user
return nullptr;
}
}

40
src/visual/EffectChams.cpp
View File

@ -8,6 +8,7 @@
#include <visual/EffectChams.hpp>
#include <MiscTemporary.hpp>
#include "common.hpp"
#include "Backtrack.hpp"
// static CatVar chams_experimental(CV_SWITCH, "chams_effect", "0",
// "Experimental Chams");
@ -320,29 +321,28 @@ void EffectChams::RenderChamsRecursive(IClientEntity *entity)
void EffectChams::RenderChams(IClientEntity *entity)
{
CMatRenderContextPtr ptr(GET_RENDER_CONTEXT);
if (ShouldRenderChams(entity))
if (ShouldRenderChams(entity))
{
rgba_t color = ChamsColor(entity);
rgba_t color_2 = color * 0.6f;
if (!legit)
{
rgba_t color = ChamsColor(entity);
rgba_t color_2 = color * 0.6f;
if (!legit)
{
mat_unlit_z->AlphaModulate(1.0f);
ptr->DepthRange(0.0f, 0.01f);
g_IVRenderView->SetColorModulation(color_2);
g_IVModelRender->ForcedMaterialOverride(flat ? mat_unlit_z
: mat_lit_z);
mat_unlit_z->AlphaModulate(1.0f);
ptr->DepthRange(0.0f, 0.01f);
g_IVRenderView->SetColorModulation(color_2);
g_IVModelRender->ForcedMaterialOverride(flat ? mat_unlit_z
: mat_lit_z);
RenderChamsRecursive(entity);
}
RenderChamsRecursive(entity);
}
if (legit || !singlepass)
{
mat_unlit->AlphaModulate(1.0f);
g_IVRenderView->SetColorModulation(color);
ptr->DepthRange(0.0f, 1.0f);
g_IVModelRender->ForcedMaterialOverride(flat ? mat_unlit
: mat_lit);
RenderChamsRecursive(entity);
if (legit || !singlepass)
{
mat_unlit->AlphaModulate(1.0f);
g_IVRenderView->SetColorModulation(color);
ptr->DepthRange(0.0f, 1.0f);
g_IVModelRender->ForcedMaterialOverride(flat ? mat_unlit : mat_lit);
RenderChamsRecursive(entity);
}
}
}

8
src/visual/colors.cpp
View File

@ -169,8 +169,8 @@ colors::rgba_t::rgba_t(const char hex[6])
auto ri = hexToByte(hex[0], hex[1]);
auto gi = hexToByte(hex[2], hex[3]);
auto bi = hexToByte(hex[4], hex[5]);
r = float(ri) / 255.0f;
g = float(gi) / 255.0f;
b = float(bi) / 255.0f;
a = 1.0f;
r = float(ri) / 255.0f;
g = float(gi) / 255.0f;
b = float(bi) / 255.0f;
a = 1.0f;
}

7
src/visual/menu/ncc/Menu.cpp
View File

@ -308,8 +308,6 @@ static const std::string list_tf2 = R"(
"aimbot_ignore_cloak"
"aimbot_ignore_deadringer"
"aimbot_ignore_vaccinator"
"ignore_taunting"
"aimbot_ignore_hoovy"
"aimbot_teammates"
]
"Auto Heal" [
@ -598,11 +596,6 @@ static const std::string list_tf2 = R"(
"Anti-Aim" [
"Anti-Aim Menu"
"aa_enabled"
"aa_realfakes"
"aa_pitch_real"
"aa_yaw_real"
"aa_pitch_mode_real"
"aa_yaw_mode_real"
"aa_pitch"
"aa_yaw"
"aa_pitch_mode"