Autobacktrackstab

.gitignore

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

include/hacks/Backtrack.hpp

@@ -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 };

src/hacks/AutoBackstab.cpp

@@ -9,12 +9,31 @@
 #include "common.hpp"
 #include "hacks/Backtrack.hpp"
 #include "hacks/Aimbot.hpp"
+#include "hacks/Trigger.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)
@@ -28,12 +47,13 @@ const Vector GetWorldSpaceCenter(CachedEntity *ent)
 
 std::pair<Vector, Vector> GetHitboxBounds(CachedEntity *it, int hitbox)
 {
-	std::pair<Vector, Vector> result(it->hitboxes.GetHitbox(hitbox)->min,it->hitboxes.GetHitbox(hitbox)->max);
+    std::pair<Vector, Vector> result(it->hitboxes.GetHitbox(hitbox)->min,
-	return result;
+                                     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 +68,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 +87,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 +101,50 @@ 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 meleeRange = re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
+    float targetAngle = i.viewangles;
+    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 +182,76 @@ void CreateMove()
     }
     if (CE_GOOD(besttarget))
     {
-        Vector hitboxLoc =
-            besttarget->hitboxes.GetHitbox(spine_2)
-                ->center;
         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;
+                angle.x = xAngle.x;
-                if (canBackstab(besttarget, angle, g_pLocalPlayer->v_Eye, hitboxLoc))
+                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;
+                    if (canBacktrackStab(i, angle, g_pLocalPlayer->v_Eye,
-                    current_user_cmd->buttons |= IN_ATTACK;
+                                         i.spine))
-                    besttarget = nullptr;
+                    {
-                    if (silent)
+                        current_user_cmd->tick_count = i.tickcount;
-                        g_pLocalPlayer->bUseSilentAngles = true;
+                        current_user_cmd->viewangles = angle;
-                    return;
+                        current_user_cmd->buttons |= IN_ATTACK;
+                        if (silent)
+                            g_pLocalPlayer->bUseSilentAngles = true;
+                    }
                 }
+            }
         }
     }
 }

src/hacks/Backtrack.cpp

@@ -65,10 +65,10 @@ void Init()
 {
     for (int i = 0; i < 32; i++)
         for (int j = 0; j < 66; j++)
-            headPositions[i][j] =
+            headPositions[i][j] = BacktrackData{
-                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,           { 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,
+            BacktrackData{ cmd->tick_count, hitboxpos,  min,        max,
-                           hitbox_spine,    viewangles, simtime, ent_orig };
+                           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)