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

Improved Autobackstab and Backtrack

Browse Source
This commit is contained in:
TotallyNotElite 2018-08-09 22:30:13 +02:00
parent f4fa2527ed
commit 91d1f45542
5 changed files with 110 additions and 135 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/hacks/Backtrack.hpp
View File

@ -57,11 +57,9 @@ struct CIncomingSequence
typedef boost::circular_buffer_space_optimized<CIncomingSequence> circular_buf;
extern circular_buf sequences;
extern BacktrackData headPositions[32][66];
extern BestTickData sorted_ticks[66];
bool isBacktrackEnabled();
float getLatency();
int getTicks();
// FIXME
int getTicks2();
bool ValidTick(BacktrackData &i, CachedEntity *ent);
}

20
src/hacks/Aimbot.cpp
View File

@ -102,33 +102,23 @@ bool BacktrackAimbot()
if (zoomed_only && !g_pLocalPlayer->bZoomed &&
!(current_user_cmd->buttons & IN_ATTACK))
return false;
int iBestTarget = hacks::shared::backtrack::iBestTarget;
if (iBestTarget == -1)
return true;
CachedEntity *tar = ENTITY(iBestTarget);
if (CE_BAD(tar))
return false;
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[iBestTarget])
{
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 (hacks::shared::backtrack::ValidTick(i, tar))
continue;
if (!i.hitboxpos.z)
continue;
if (!good_tick)
continue;
if (!IsVectorVisible(g_pLocalPlayer->v_Eye, i.hitboxpos, true))
continue;
float scr = abs(g_pLocalPlayer->v_OrigViewangles.y - i.viewangles);
CachedEntity *tar = ENTITY(iBestTarget);
// ok just in case
if (CE_BAD(tar))
continue;
// target_eid = tar->m_IDX;
Vector &angles = NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles);
float &simtime = CE_FLOAT(tar, netvar.m_flSimulationTime);
angles.y = i.viewangles;

77
src/hacks/AutoBackstab.cpp
View File

@ -14,6 +14,7 @@
namespace hacks::tf2::autobackstab
{
namespace backtrack = hacks::shared::backtrack;
static settings::Bool enable{ "autobackstab.enable", "0" };
static settings::Bool silent{ "autobackstab.silent", "1" };
@ -62,7 +63,7 @@ bool unifiedCanBackstab(Vector &vecAngle, Vector min, Vector max,
// Get melee range
float meleeRange = re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
if (fabsf(vecAngle.y -
NET_VECTOR(RAW_ENT(besttarget), netvar.m_angEyeAngles).y) >= 45)
NET_VECTOR(RAW_ENT(besttarget), netvar.m_angEyeAngles).y) >= 60)
return false;
if (!min.x && !max.x)
return false;
@ -124,36 +125,57 @@ void CreateMove()
if (!CanShoot())
return;
CachedEntity *besttarget = nullptr;
for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
if (!backtrack::isBacktrackEnabled())
{
CachedEntity *target = ENTITY(i);
if (CE_BAD(target))
continue;
if (target == LOCAL_E || target->m_iTeam() == LOCAL_E->m_iTeam() ||
!target->m_bAlivePlayer() || target->m_Type() != ENTITY_PLAYER)
continue;
if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
g_pLocalPlayer->v_Eye) <= 300.0f)
for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
{
if (CE_GOOD(besttarget))
CachedEntity *target = ENTITY(i);
if (CE_BAD(target))
continue;
if (target == LOCAL_E || target->m_iTeam() == LOCAL_E->m_iTeam() ||
!target->m_bAlivePlayer() || target->m_Type() != ENTITY_PLAYER)
continue;
if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
g_pLocalPlayer->v_Eye) <= 200.0f)
{
if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
g_pLocalPlayer->v_Eye) <
besttarget->hitboxes.GetHitbox(spine_3)->center.DistTo(
g_pLocalPlayer->v_Eye))
if (CE_GOOD(besttarget))
{
if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
g_pLocalPlayer->v_Eye) <
besttarget->hitboxes.GetHitbox(spine_3)->center.DistTo(
g_pLocalPlayer->v_Eye))
besttarget = target;
}
else
{
besttarget = target;
}
else
{
besttarget = target;
}
}
}
}
else
{
// Run if backtrack is enabled
if (backtrack::iBestTarget == -1)
return;
CachedEntity *target = ENTITY(backtrack::iBestTarget);
// Various valid entity checks
if (CE_BAD(target))
return;
if (target == LOCAL_E || target->m_iTeam() == LOCAL_E->m_iTeam() ||
!target->m_bAlivePlayer() || target->m_Type() != ENTITY_PLAYER)
return;
// Check if besttick distance is < 200.0f
if (backtrack::headPositions[target->m_IDX][backtrack::BestTick]
.spine.DistTo(g_pLocalPlayer->v_Eye) < 200.0f)
besttarget = target;
}
if (CE_GOOD(besttarget))
{
hacks::shared::anti_anti_aim::resolveEnt(besttarget->m_IDX);
Vector angle = NET_VECTOR(RAW_ENT(LOCAL_E), netvar.m_angEyeAngles);
if (!hacks::shared::backtrack::isBacktrackEnabled())
if (!backtrack::isBacktrackEnabled())
{
for (angle.y = -180.0f; angle.y < 180.0f; angle.y += 10.0f)
{
@ -183,18 +205,9 @@ void CreateMove()
else
{
int idx = besttarget->m_IDX;
int tickcnt = 0;
for (auto i : hacks::shared::backtrack::headPositions[idx])
for (auto i : backtrack::headPositions[idx])
{
bool good_tick = false;
for (int j = 0; j < hacks::shared::backtrack::getTicks2(); ++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)
if (!backtrack::ValidTick(i, besttarget))
continue;
// Check if we are inside the target (which will in most cases
@ -217,6 +230,7 @@ void CreateMove()
std::pair<Vector, Vector> line2(
{ line1.second.x, line1.first.y, line1.first.z },
{ line1.first.x, line1.second.y, line1.first.z });
// Check if one of the lines intersects with our collidable
if (LineIntersectsBox(collidableMinMax.first,
collidableMinMax.second, line1.first,
line1.second) ||
@ -224,6 +238,7 @@ void CreateMove()
collidableMinMax.second, line2.first,
line2.second))
continue;
for (angle.y = -180.0f; angle.y < 180.0f; angle.y += 20.0f)
{
if (unifiedCanBackstab(angle, i.spineMin, i.spineMax,

124
src/hacks/Backtrack.cpp
View File

@ -12,7 +12,6 @@
#include <settings/Bool.hpp>
#include <hacks/Backtrack.hpp>
static settings::Bool enable{ "backtrack.enable", "false" };
static settings::Bool draw_bt{ "backtrack.draw", "false" };
static settings::Int latency{ "backtrack.latency", "0" };
@ -148,64 +147,51 @@ void Run()
}
if (iBestTarget != -1 && CanShoot())
{
int bestTick = 0;
float tempFOV = 9999;
float bestFOV = 180.0f;
float distance, prev_distance_ticks = 9999;
for (int i = 0; i < getTicks(); ++i)
sorted_ticks[i] = BestTickData{ INT_MAX, i };
for (int t = 0; t < getTicks(); ++t)
CachedEntity *tar = ENTITY(iBestTarget);
if (CE_GOOD(tar))
{
if (headPositions[iBestTarget][t].tickcount)
sorted_ticks[t] =
BestTickData{ headPositions[iBestTarget][t].tickcount, t };
}
std::sort(sorted_ticks, sorted_ticks + getTicks());
int tickus = getTicks2();
for (int t = 0; t < getTicks(); ++t)
{
bool good_tick = false;
for (int i = 0; i < tickus; ++i)
if (t == sorted_ticks[i].tick &&
sorted_ticks[i].tickcount != INT_MAX &&
sorted_ticks[i].tickcount)
good_tick = true;
if (!good_tick)
continue;
tempFOV =
GetFov(g_pLocalPlayer->v_OrigViewangles, g_pLocalPlayer->v_Eye,
headPositions[iBestTarget][t].hitboxpos);
if (IsMelee)
int bestTick = 0;
float tempFOV = 9999;
float bestFOV = 180.0f;
float distance, prev_distance_ticks = 9999;
for (int t = 0; t < getTicks(); ++t)
{
distance = g_pLocalPlayer->v_Eye.DistTo(
headPositions[iBestTarget][t].spine);
if (distance < (float) mindistance)
if (!ValidTick(headPositions[tar->m_IDX][t], tar))
continue;
if (distance < prev_distance_ticks && tempFOV < 90.0f)
prev_distance_ticks = distance, bestTick = t;
tempFOV = GetFov(g_pLocalPlayer->v_OrigViewangles,
g_pLocalPlayer->v_Eye,
headPositions[iBestTarget][t].hitboxpos);
if (IsMelee)
{
distance = g_pLocalPlayer->v_Eye.DistTo(
headPositions[iBestTarget][t].spine);
if (distance < (float) mindistance)
continue;
if (distance < prev_distance_ticks)
prev_distance_ticks = distance, bestTick = t;
}
else
{
if (bestFOV > tempFOV)
bestTick = t, bestFOV = tempFOV;
}
}
else
{
if (bestFOV > tempFOV)
bestTick = t, bestFOV = tempFOV;
}
}
BestTick = bestTick;
if (cmd->buttons & IN_ATTACK)
{
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(RAW_ENT(tar), netvar.m_angEyeAngles);
float &simtime = NET_FLOAT(RAW_ENT(tar), netvar.m_flSimulationTime);
angles.y = i.viewangles;
simtime = i.simtime;
BestTick = bestTick;
if (cmd->buttons & IN_ATTACK)
{
// ok just in case
if (CE_BAD(tar))
return;
auto i = headPositions[iBestTarget][bestTick];
cmd->tick_count = i.tickcount;
Vector &angles =
NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles);
float &simtime =
NET_FLOAT(RAW_ENT(tar), netvar.m_flSimulationTime);
angles.y = i.viewangles;
simtime = i.simtime;
}
}
}
}
@ -218,22 +204,18 @@ void Draw()
return;
if (!shouldDrawBt)
return;
int tickus = getTicks2();
for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
{
CachedEntity *ent = ENTITY(i);
if (CE_BAD(ent))
continue;
for (int j = 0; j < getTicks(); j++)
{
bool good_tick = false;
for (int i = 0; i < tickus; ++i)
if (j == sorted_ticks[i].tick)
good_tick = true;
if (!good_tick)
if (!ValidTick(headPositions[i][j], ent))
continue;
auto hbpos = headPositions[i][j].hitboxpos;
auto tickount = headPositions[i][j].tickcount;
auto min = headPositions[i][j].min;
auto max = headPositions[i][j].max;
auto hbpos = headPositions[i][j].hitboxpos;
auto min = headPositions[i][j].min;
auto max = headPositions[i][j].max;
if (!hbpos.x && !hbpos.y && !hbpos.z)
continue;
Vector out;
@ -306,13 +288,13 @@ float getLatency()
int getTicks()
{
return max(min(int(*latency / 200.0f * 13.0f), 65), 12);
return max(min(int(*latency / 200.0f * 13.0f) + 12, 65), 12);
}
int getTicks2()
bool ValidTick(BacktrackData &i, CachedEntity *ent)
{
// Removed for now
//return (*latency > 800 || *latency < 200) ? 12 : 24;
return 12;
}
return fabsf(NET_FLOAT(RAW_ENT(ent), netvar.m_flSimulationTime) * 1000.0f -
getLatency() - i.simtime * 1000.0f) < 200.0f;
}
} // namespace hacks::shared::backtrack

20
src/hacks/Trigger.cpp
View File

@ -41,18 +41,12 @@ int last_hb_traced = 0;
Vector forward;
bool CanBacktrack()
{
int target = hacks::shared::backtrack::iBestTarget;
int tickcnt = 0;
int tickus = hacks::shared::backtrack::getTicks2();
for (auto i : hacks::shared::backtrack::headPositions[target])
CachedEntity *tar = ENTITY(hacks::shared::backtrack::iBestTarget);
if (CE_BAD(tar))
return false;
for (auto i : hacks::shared::backtrack::headPositions[tar->m_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)
if(!hacks::shared::backtrack::ValidTick(i, tar))
continue;
auto min = i.min;
auto max = i.max;
@ -83,10 +77,6 @@ bool CanBacktrack()
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(RAW_ENT(tar), netvar.m_angEyeAngles);
float &simtime = NET_FLOAT(RAW_ENT(tar), netvar.m_flSimulationTime);
angles.y = i.viewangles;