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

Merge pull request #541 from TotallyNotElite/master

Browse Source 
Autobacktrackstab
This commit is contained in:
LightCat 2018-08-03 23:05:49 +02:00 committed by GitHub
commit 511bddc6ef
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 227 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -276,4 +276,5 @@ cathook.cbp
.project
.cproject
.settings
.settings
\.directory

10
include/hacks/AntiAntiAim.hpp
View File

@ -3,10 +3,18 @@
*/
#pragma once
#include <core/interfaces.hpp>
#include <core/sdk.hpp>
#include <globals.h>
#include <core/netvars.hpp>
#include <settings/Bool.hpp>
#include <localplayer.hpp>
#include <entitycache.hpp>
namespace hacks::shared::anti_anti_aim
{
void createMove();
void resolveEnt(int IDX, IClientEntity *entity = nullptr);
}
}

4
include/hacks/Backtrack.hpp
View File

@ -17,7 +17,9 @@ struct BacktrackData
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 };
Vector spine{ 0.0f, 0.0f, 0.0f };
Vector spineMin{ 0.0f, 0.0f, 0.0f };
Vector spineMax{ 0.0f, 0.0f, 0.0f };
float viewangles{ 0.0f };
float simtime{ 0.0f };
Vector entorigin{ 0.0f, 0.0f, 0.0f };

4
src/MiscTemporary.cpp
View File

@ -16,8 +16,8 @@ int prevflowticks = 0;
bool *bSendPackets{ nullptr };
settings::Bool crypt_chat{ "chat.crypto", "false" };
settings::Bool crypt_chat{ "chat.crypto", "true" };
settings::Bool clean_screenshots{ "visual.clean-screenshots", "false" };
settings::Bool nolerp{ "misc.no-lerp", "false" };
settings::Bool no_zoom{ "remove.scope", "false" };
settings::Bool disable_visuals{ "visual.disable", "false" };
settings::Bool disable_visuals{ "visual.disable", "false" };

139
src/hacks/AntiAntiAim.cpp
View File

@ -3,13 +3,6 @@
*/
#include <hacks/AntiAntiAim.hpp>
#include <core/interfaces.hpp>
#include <core/sdk.hpp>
#include <globals.h>
#include <core/netvars.hpp>
#include <settings/Bool.hpp>
#include <localplayer.hpp>
#include <entitycache.hpp>
static settings::Bool enable{ "anti-anti-aim.enable", "false" };
@ -23,70 +16,74 @@ void hacks::shared::anti_anti_aim::createMove()
IClientEntity *entity{ nullptr };
for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
{
if (i == g_IEngine->GetLocalPlayer())
continue;
entity = g_IEntityList->GetClientEntity(i);
if (entity && !entity->IsDormant() && !NET_BYTE(entity, netvar.iLifeState))
{
float quotat = 0;
float quotaf = 0;
if (!g_Settings.brute.choke[i].empty())
for (auto it : g_Settings.brute.choke[i])
{
if (it)
quotat++;
else
quotaf++;
}
float quota = quotat / quotaf;
Vector &angles = NET_VECTOR(entity, netvar.m_angEyeAngles);
static bool brutepitch = false;
if (g_Settings.brute.brutenum[i] > 5)
{
g_Settings.brute.brutenum[i] = 0;
brutepitch = !brutepitch;
}
angles.y = fmod(angles.y + 180.0f, 360.0f);
if (angles.y < 0)
angles.y += 360.0f;
angles.y -= 180.0f;
if (quota < 0.8f)
switch (g_Settings.brute.brutenum[i])
{
case 0:
break;
case 1:
angles.y += 180.0f;
break;
case 2:
angles.y -= 90.0f;
break;
case 3:
angles.y += 90.0f;
break;
case 4:
angles.y -= 180.0f;
break;
case 5:
angles.y = 0.0f;
break;
}
if (brutepitch || quota < 0.8f)
switch (g_Settings.brute.brutenum[i] % 4)
{
case 0:
break;
case 1:
angles.x = -89.0f;
break;
case 2:
angles.x = 89.0f;
break;
case 3:
angles.x = 0.0f;
break;
}
}
resolveEnt(i, entity);
}
}
void hacks::shared::anti_anti_aim::resolveEnt(int IDX, IClientEntity *entity)
{
if (IDX == g_IEngine->GetLocalPlayer())
return;
entity = g_IEntityList->GetClientEntity(IDX);
if (entity && !entity->IsDormant() && !NET_BYTE(entity, netvar.iLifeState))
{
float quotat = 0;
float quotaf = 0;
if (!g_Settings.brute.choke[IDX].empty())
for (auto it : g_Settings.brute.choke[IDX])
{
if (it)
quotat++;
else
quotaf++;
}
float quota = quotat / quotaf;
Vector &angles = NET_VECTOR(entity, netvar.m_angEyeAngles);
static bool brutepitch = false;
if (g_Settings.brute.brutenum[IDX] > 5)
{
g_Settings.brute.brutenum[IDX] = 0;
brutepitch = !brutepitch;
}
angles.y = fmod(angles.y + 180.0f, 360.0f);
if (angles.y < 0)
angles.y += 360.0f;
angles.y -= 180.0f;
if (quota < 0.8f)
switch (g_Settings.brute.brutenum[IDX])
{
case 0:
break;
case 1:
angles.y += 180.0f;
break;
case 2:
angles.y -= 90.0f;
break;
case 3:
angles.y += 90.0f;
break;
case 4:
angles.y -= 180.0f;
break;
case 5:
angles.y = 0.0f;
break;
}
if (brutepitch || quota < 0.8f)
switch (g_Settings.brute.brutenum[IDX] % 4)
{
case 0:
break;
case 1:
angles.x = -89.0f;
break;
case 2:
angles.x = 89.0f;
break;
case 3:
angles.x = 0.0f;
break;
}
}
}

150
src/hacks/AutoBackstab.cpp
View File

@ -9,12 +9,32 @@
#include "common.hpp"
#include "hacks/Backtrack.hpp"
#include "hacks/Aimbot.hpp"
#include "hacks/Trigger.hpp"
#include "hacks/AntiAntiAim.hpp"
static settings::Bool enable{ "autobackstab.enable", "0" };
static settings::Bool silent{ "autobackstab.silent", "1" };
namespace hacks::tf2::autobackstab
{
// Function to find the closest hitbox to the v_Eye for a given ent
int ClosestDistanceHitbox(CachedEntity *target)
{
int closest = -1;
float closest_dist = 0.0f, dist = 0.0f;
for (int i = 0; i < target->hitboxes.GetNumHitboxes(); i++)
{
dist =
g_pLocalPlayer->v_Eye.DistTo(target->hitboxes.GetHitbox(i)->center);
if (dist < closest_dist || closest == -1)
{
closest = i;
closest_dist = dist;
}
}
return closest;
}
// pPaste, thanks to F1ssi0N
const Vector GetWorldSpaceCenter(CachedEntity *ent)
@ -26,14 +46,8 @@ const Vector GetWorldSpaceCenter(CachedEntity *ent)
return vWorldSpaceCenter;
}
std::pair<Vector, Vector> GetHitboxBounds(CachedEntity *it, int hitbox)
{
std::pair<Vector, Vector> result(it->hitboxes.GetHitbox(hitbox)->min,it->hitboxes.GetHitbox(hitbox)->max);
return result;
}
void traceEntity(int *result_eindex, Vector *result_pos, QAngle angle,
Vector loc)
Vector loc, float meleeRange)
{
Ray_t ray;
Vector forward;
@ -48,7 +62,7 @@ void traceEntity(int *result_eindex, Vector *result_pos, QAngle angle,
forward.x = cp * cy;
forward.y = cp * sy;
forward.z = -sp;
forward = forward * 8192.0f + loc;
forward = forward * meleeRange + loc;
ray.Init(loc, forward);
g_ITrace->TraceRay(ray, MASK_SHOT_HULL, &trace::filter_default, &trace);
if (result_pos)
@ -67,11 +81,11 @@ bool canBackstab(CachedEntity *tar, Vector angle, Vector loc, Vector hitboxLoc)
{
float meleeRange = re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
Vector targetAngle = NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles);
if (fabsf(angle.y - targetAngle.y) < 80)
if (fabsf(angle.y - targetAngle.y) < 45)
{
int IDX;
Vector hitLoc;
traceEntity(&IDX, &hitLoc, QAngle(angle.x, angle.y, angle.z), loc);
traceEntity(&IDX, &hitLoc, QAngle(angle.x, angle.y, angle.z), loc, meleeRange);
if (IDX == tar->m_IDX)
{
if (loc.DistTo(hitboxLoc) <= meleeRange)
@ -81,6 +95,49 @@ bool canBackstab(CachedEntity *tar, Vector angle, Vector loc, Vector hitboxLoc)
return false;
}
bool canBacktrackStab(hacks::shared::backtrack::BacktrackData &i,
Vector vecAngle, Vector loc, Vector hitboxLoc, float targetAngle)
{
float meleeRange = re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
if (fabsf(vecAngle.y - targetAngle) >= 45)
return false;
if (loc.DistTo(hitboxLoc) > meleeRange)
return false;
auto min = i.spineMin;
auto max = i.spineMax;
if (!min.x && !max.x)
return false;
// 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));
// if (!IsVectorVisible(g_pLocalPlayer->v_Eye, minz, true) &&
// !IsVectorVisible(g_pLocalPlayer->v_Eye, maxz, true))
// return false;
Vector forward;
float sp, sy, cp, cy;
QAngle angle = VectorToQAngle(vecAngle);
// Use math to get a vector in front of the player
sy = sinf(DEG2RAD(angle[1]));
cy = cosf(DEG2RAD(angle[1]));
sp = sinf(DEG2RAD(angle[0]));
cp = cosf(DEG2RAD(angle[0]));
forward.x = cp * cy;
forward.y = cp * sy;
forward.z = -sp;
forward = forward * meleeRange + loc;
Vector hit;
if (hacks::shared::triggerbot::CheckLineBox(
minz, maxz, g_pLocalPlayer->v_Eye, forward, hit))
return true;
return false;
}
void CreateMove()
{
if (!enable)
@ -118,28 +175,77 @@ void CreateMove()
}
if (CE_GOOD(besttarget))
{
Vector hitboxLoc =
besttarget->hitboxes.GetHitbox(spine_2)
->center;
hacks::shared::anti_anti_aim::resolveEnt(besttarget->m_IDX);
Vector angle = NET_VECTOR(RAW_ENT(LOCAL_E), netvar.m_angEyeAngles);
for (angle.y = -180.0f; angle.y < 180.0f; angle.y += 1.0f)
if (!hacks::shared::backtrack::isBacktrackEnabled())
{
for (angle.y = -180.0f; angle.y < 180.0f; angle.y += 10.0f)
{
Vector hitboxLoc =
besttarget->hitboxes
.GetHitbox(ClosestDistanceHitbox(besttarget))
->center;
// Get angles
Vector tr = (hitboxLoc - g_pLocalPlayer->v_Eye);
Vector xAngle;
VectorAngles(tr, xAngle);
// Clamping is important
fClampAngle(xAngle);
angle.x = xAngle.x;
if (canBackstab(besttarget, angle, g_pLocalPlayer->v_Eye, hitboxLoc))
angle.x = xAngle.x;
if (!canBackstab(besttarget, angle, g_pLocalPlayer->v_Eye,
hitboxLoc))
continue;
current_user_cmd->viewangles = angle;
current_user_cmd->buttons |= IN_ATTACK;
besttarget = nullptr;
if (silent)
g_pLocalPlayer->bUseSilentAngles = true;
return;
}
}
else
{
int idx = besttarget->m_IDX;
int tickcnt = 0;
int tickus =
(float(hacks::shared::backtrack::getLatency()) > 800.0f ||
float(hacks::shared::backtrack::getLatency()) < 200.0f)
? 12
: 24;
for (auto i : hacks::shared::backtrack::headPositions[idx])
{
bool good_tick = false;
for (int j = 0; j < tickus; ++j)
if (tickcnt ==
hacks::shared::backtrack::sorted_ticks[j].tick &&
hacks::shared::backtrack::sorted_ticks[j].tickcount !=
INT_MAX)
good_tick = true;
tickcnt++;
if (!good_tick)
continue;
// Get angles
Vector tr = (i.spine - g_pLocalPlayer->v_Eye);
Vector xAngle;
VectorAngles(tr, xAngle);
// Clamping is important
fClampAngle(xAngle);
angle.x = xAngle.x;
for (angle.y = -180.0f; angle.y < 180.0f; angle.y += 40.0f)
{
current_user_cmd->viewangles = angle;
current_user_cmd->buttons |= IN_ATTACK;
besttarget = nullptr;
if (silent)
g_pLocalPlayer->bUseSilentAngles = true;
return;
if (canBacktrackStab(i, angle, g_pLocalPlayer->v_Eye,
i.spine, NET_VECTOR(RAW_ENT(besttarget), netvar.m_angEyeAngles).y))
{
current_user_cmd->tick_count = i.tickcount;
current_user_cmd->viewangles = angle;
current_user_cmd->buttons |= IN_ATTACK;
if (silent)
g_pLocalPlayer->bUseSilentAngles = true;
}
}
}
}
}
}

26
src/hacks/Backtrack.cpp
View File

@ -65,10 +65,10 @@ 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 }, 0,
0, { 0, 0, 0 } };
headPositions[i][j] = 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 }
};
}
int BestTick = 0;
@ -104,8 +104,9 @@ 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, 0, 0 },
{ 0, 0, 0 }, 0, 0,
{ 0, 0, 0 } };
continue;
}
if (pEntity->m_iTeam() == LOCAL_E->m_iTeam())
@ -122,15 +123,18 @@ void Run()
float viewangles =
(_viewangles > 180) ? _viewangles - 360 : _viewangles;
float simtime = CE_FLOAT(pEntity, netvar.m_flSimulationTime);
Vector hitbox_spine = pEntity->hitboxes.GetHitbox(3)->center;
Vector hitbox_spine = pEntity->hitboxes.GetHitbox(spine_3)->center;
Vector hitbox_min = pEntity->hitboxes.GetHitbox(spine_3)->min;
Vector hitbox_max = pEntity->hitboxes.GetHitbox(spine_3)->max;
Vector ent_orig = pEntity->InternalEntity()->GetAbsOrigin();
auto hdr = g_IModelInfo->GetStudiomodel(RAW_ENT(pEntity)->GetModel());
headPositions[i][cmd->command_number % getTicks()] =
BacktrackData{ cmd->tick_count, hitboxpos, min, max,
hitbox_spine, viewangles, simtime, ent_orig };
BacktrackData{ cmd->tick_count, hitboxpos, min, max,
hitbox_spine, hitbox_min, hitbox_max, 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);
float distance = g_pLocalPlayer->v_Eye.DistTo(hitbox_spine);
if (!IsMelee && bestFov > FOVDistance && FOVDistance < 60.0f)
{
bestFov = FOVDistance;
@ -176,7 +180,7 @@ void Run()
if (IsMelee)
{
distance = g_pLocalPlayer->v_Eye.DistTo(
headPositions[iBestTarget][t].origin);
headPositions[iBestTarget][t].spine);
if (distance < (float) mindistance)
continue;
if (distance < prev_distance_ticks && tempFOV < 90.0f)