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

Autobackstab improvements?

Browse Source
This commit is contained in:
TotallyNotElite 2018-08-29 18:08:10 +02:00
parent 460c2d752f
commit 9fd1d5d58a
4 changed files with 75 additions and 105 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/hacks/Backtrack.hpp
View File

@ -22,6 +22,7 @@ struct BacktrackData
{
int tickcount{ 0 };
std::array<hitboxData, 18> hitboxes;
hitboxData collidable{};
float viewangles{ 0.0f };
float simtime{ 0.0f };
Vector entorigin{ 0.0f, 0.0f, 0.0f };

166
src/hacks/AutoBackstab.cpp
View File

@ -18,20 +18,18 @@ namespace backtrack = hacks::shared::backtrack;
static settings::Bool enable{ "autobackstab.enable", "0" };
static settings::Bool silent{ "autobackstab.silent", "1" };
void testingFunc();
void AngleVectors2 (const QAngle &angles, Vector *forward)
void AngleVectors2(const QAngle &angles, Vector *forward)
{
float sp, sy, cp, cy;
float sp, sy, cp, cy;
SinCos( DEG2RAD( angles[YAW] ), &sy, &cy );
SinCos( DEG2RAD( angles[PITCH] ), &sp, &cp );
SinCos(DEG2RAD(angles[YAW]), &sy, &cy);
SinCos(DEG2RAD(angles[PITCH]), &sp, &cp);
forward->x = cp*cy;
forward->y = cp*sy;
forward->x = cp * cy;
forward->y = cp * sy;
forward->z = -sp;
}
// Not required anymore, keeping for future reference
Vector rotateVector(Vector center, float radianAngle, Vector p)
{
@ -75,32 +73,34 @@ int ClosestDistanceHitbox(CachedEntity *target,
return closest;
}
bool unifiedCanBackstab(Vector &vecAngle, Vector min, Vector max,
Vector hitboxLoc, CachedEntity *besttarget)
bool unifiedCanBackstab(CachedEntity *tar, Vector &vecAngle,
Vector targetOrigin, 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) >=
60.0f)
return false;
if (!min.x && !max.x)
return false;
Vector tarAngle = CE_VECTOR(tar, netvar.m_angEyeAngles);
Vector head = g_pLocalPlayer->v_Eye;
// Check if we are in range. Note: This has to be done in order to avoid
// false positives even when "forward" is only "meleeRange" away from the
// head.
if (head.DistTo(hitboxLoc) > meleeRange)
if (head.DistTo((min + max) / 2) > meleeRange)
return false;
// Calculate head x angle
Vector tr = (hitboxLoc - head);
Vector xAngle;
VectorAngles(tr, xAngle);
fClampAngle(xAngle);
vecAngle.x = xAngle.x;
Vector wsc_spy_to_victim = (targetOrigin - LOCAL_E->m_vecOrigin());
wsc_spy_to_victim.z = 0;
wsc_spy_to_victim.NormalizeInPlace();
Vector eye_spy;
AngleVectors2(VectorToQAngle(vecAngle), &eye_spy);
eye_spy.z = 0;
eye_spy.NormalizeInPlace();
Vector eye_victim;
AngleVectors2(VectorToQAngle(tarAngle), &eye_victim);
eye_victim.z = 0;
eye_victim.NormalizeInPlace();
// 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));
@ -121,14 +121,22 @@ bool unifiedCanBackstab(Vector &vecAngle, Vector min, Vector max,
Vector hit;
// Check if we our line is within the targets hitbox
if (hacks::shared::triggerbot::CheckLineBox(minz, maxz, head, forward, hit))
return true;
return false;
if (!hacks::shared::triggerbot::CheckLineBox(minz, maxz, head, forward,
hit))
return false;
if (DotProduct(wsc_spy_to_victim, eye_victim) <= 0.0f)
return false;
if (DotProduct(wsc_spy_to_victim, eye_spy) <= 0.5f)
return false;
if (DotProduct(eye_spy, eye_victim) <= -0.3f)
return false;
return true;
}
void CreateMove()
{
// testingFunc();
// testingFunc();
if (!enable)
return;
if (CE_BAD(LOCAL_E) || CE_BAD(LOCAL_W) || !LOCAL_E->m_bAlivePlayer())
@ -188,9 +196,14 @@ void CreateMove()
if (CE_GOOD(besttarget))
{
hacks::shared::anti_anti_aim::resolveEnt(besttarget->m_IDX);
Vector angle = NET_VECTOR(RAW_ENT(LOCAL_E), netvar.m_angEyeAngles);
Vector angle = NET_VECTOR(RAW_ENT(LOCAL_E), 4104);
if (!backtrack::isBacktrackEnabled)
{
IClientEntity *raw = RAW_ENT(besttarget);
Vector origin = besttarget->m_vecOrigin();
Vector min = raw->GetCollideable()->OBBMins() + origin;
Vector max = raw->GetCollideable()->OBBMaxs() + origin;
for (angle.y = -180.0f; angle.y < 180.0f; angle.y += 10.0f)
{
Vector hitboxLoc =
@ -198,15 +211,7 @@ void CreateMove()
.GetHitbox(ClosestDistanceHitbox(besttarget))
->center;
if (!unifiedCanBackstab(
angle,
besttarget->hitboxes
.GetHitbox(ClosestDistanceHitbox(besttarget))
->min,
besttarget->hitboxes
.GetHitbox(ClosestDistanceHitbox(besttarget))
->max,
hitboxLoc, besttarget))
if (!unifiedCanBackstab(besttarget, angle, origin, min, max))
continue;
current_user_cmd->viewangles = angle;
current_user_cmd->buttons |= IN_ATTACK;
@ -226,45 +231,16 @@ void CreateMove()
backtrack::hitboxData &hitbox =
i.hitboxes.at(ClosestDistanceHitbox(besttarget, i));
// Check if we are inside the target (which will in most cases
// result in a failstab)
std::pair<Vector, Vector> collidableMinMax(
RAW_ENT(LOCAL_E)->GetCollideable()->OBBMins() +
g_pLocalPlayer->v_Origin,
RAW_ENT(LOCAL_E)->GetCollideable()->OBBMaxs() +
g_pLocalPlayer->v_Origin);
// Get dist Z to Z
float halfHeight =
(hitbox.min.DistTo(
Vector{ hitbox.min.x, hitbox.min.y, hitbox.max.z })) /
2;
// Make our first diagonal line
std::pair<Vector, Vector> line1(
{ hitbox.min.x, hitbox.min.y, hitbox.min.z + halfHeight },
{ hitbox.max.x, hitbox.max.y, hitbox.max.z - halfHeight });
// Make our second diagonal line
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) ||
LineIntersectsBox(collidableMinMax.first,
collidableMinMax.second, line2.first,
line2.second))
continue;
for (angle.y = -180.0f; angle.y < 180.0f; angle.y += 20.0f)
{
if (unifiedCanBackstab(angle, hitbox.min, hitbox.max,
hitbox.center, besttarget))
if (unifiedCanBackstab(besttarget, angle, i.entorigin, i.collidable.min, i.collidable.max))
{
current_user_cmd->tick_count = i.tickcount;
current_user_cmd->viewangles = angle;
current_user_cmd->buttons |= IN_ATTACK;
if (silent)
g_pLocalPlayer->bUseSilentAngles = true;
return;
}
}
}
@ -329,15 +305,12 @@ void Draw()
// GetWorldSpaceCenter(besttarget)) <= 60.0f; bool InBackstabAngleRange =
// fabsf(tarAngle.y - angle.y) <= 107.5f;
// rgba_t col1 = IsBehind ? colors::green : colors::red;
// rgba_t col2 = LookingAtVic ? colors::green : colors::red;
// rgba_t col3 = InBackstabAngleRange ? colors::green : colors::red;
// AddCenterString(format("Behind target" /*, dot1*/), col1);
// AddCenterString(format("Looking at Target" /*, dot2*/), col2);
// AddCenterString(format("In Angle Range" /*, dot3*/), col3);
// rgba_t col1 = IsBehind ? colors::green : colors::red;
// rgba_t col2 = LookingAtVic ? colors::green : colors::red;
// rgba_t col3 = InBackstabAngleRange ? colors::green : colors::red;
// AddCenterString(format("Behind target" /*, dot1*/), col1);
// AddCenterString(format("Looking at Target" /*, dot2*/), col2);
// AddCenterString(format("In Angle Range" /*, dot3*/), col3);
}
void testingFunc()
@ -377,33 +350,24 @@ void testingFunc()
logging::Info("Loc: %f; Tar: %f", angle.y, tarAngle.y);
float toclamp = tarAngle.y - angle.y;
Vector wsc_spy_to_victim =
(besttarget->m_vecOrigin() - LOCAL_E->m_vecOrigin());
wsc_spy_to_victim.z = 0;
wsc_spy_to_victim.NormalizeInPlace();
while (toclamp > 180)
toclamp -= 360;
Vector eye_spy;
AngleVectors2(VectorToQAngle(angle), &eye_spy);
eye_spy.z = 0;
eye_spy.NormalizeInPlace();
while (toclamp < -180)
toclamp += 360;
Vector eye_victim;
AngleVectors2(VectorToQAngle(tarAngle), &eye_victim);
eye_victim.z = 0;
eye_victim.NormalizeInPlace();
// Get the forward view vector of the target, ignore Z
Vector vecVictimForward;
AngleVectors2(VectorToQAngle(tarAngle), &vecVictimForward);
vecVictimForward.z = 0.0f;
vecVictimForward.NormalizeInPlace();
// Get a vector from my origin to my targets origin
Vector vecToTarget;
vecToTarget = GetWorldSpaceCenter(besttarget) - GetWorldSpaceCenter(LOCAL_E);
vecToTarget.z = 0.0f;
vecToTarget.NormalizeInPlace();
float dot = DotProduct(vecVictimForward, vecToTarget);
LookingAtVic = GetFov(angle, g_pLocalPlayer->v_Eye,
GetWorldSpaceCenter(besttarget)) <= 60.0f;
InBackstabAngleRange = fabsf(toclamp) <= 107.5f;
IsBehind = (dot > 0.0f);
logging::Info("Dot: %f", dot);
IsBehind = DotProduct(wsc_spy_to_victim, eye_victim) <= 0.0f;
LookingAtVic = DotProduct(wsc_spy_to_victim, eye_spy) <= 0.5f;
InBackstabAngleRange = DotProduct(eye_spy, eye_victim) <= -0.3f;
}
} // namespace hacks::tf2::autobackstab

10
src/hacks/Backtrack.cpp
View File

@ -125,6 +125,7 @@ void Run()
float viewangles =
(_viewangles > 180) ? _viewangles - 360 : _viewangles;
float simtime = CE_FLOAT(pEntity, netvar.m_flSimulationTime);
Vector ent_orig = pEntity->InternalEntity()->GetAbsOrigin();
std::array<hitboxData, 18> hbdArray;
for (size_t i = 0; i < hbdArray.max_size(); i++)
{
@ -132,10 +133,15 @@ void Run()
hbdArray.at(i).min = pEntity->hitboxes.GetHitbox(i)->min;
hbdArray.at(i).max = pEntity->hitboxes.GetHitbox(i)->max;
}
Vector ent_orig = pEntity->InternalEntity()->GetAbsOrigin();
hitboxData collidable{};
{
collidable.min = RAW_ENT(pEntity)->GetCollideable()->OBBMins() + ent_orig;
collidable.max = RAW_ENT(pEntity)->GetCollideable()->OBBMaxs() + ent_orig;
collidable.center = (collidable.min + collidable.max)/2;
}
auto hdr = g_IModelInfo->GetStudiomodel(RAW_ENT(pEntity)->GetModel());
headPositions[i][cmd->command_number % getTicks()] =
BacktrackData{ cmd->tick_count, hbdArray,
BacktrackData{ cmd->tick_count, hbdArray, collidable,
viewangles, simtime,
ent_orig, cmd->command_number % getTicks() };
}

3
src/hoovy.cpp
View File

@ -22,8 +22,7 @@ bool HasSandvichOut(CachedEntity *entity)
weapon = ENTITY(weapon_idx);
if (CE_GOOD(weapon))
{
if (weapon->m_iClassID() == CL_CLASS(CTFLunchBox) &&
CE_INT(entity, netvar.iClass) == tf_heavy)
if (weapon->m_iClassID() == CL_CLASS(CTFLunchBox))
{
return true;
}