Improved Autobackstab and Backtrack

include/hacks/Backtrack.hpp

@@ -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
+bool ValidTick(BacktrackData &i, CachedEntity *ent);
-int getTicks2();
 }

src/hacks/Aimbot.cpp

@@ -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;
+        if (hacks::shared::backtrack::ValidTick(i, tar))
-        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 (!i.hitboxpos.z)
              continue;
-        if (!good_tick)
+        if (!i.hitboxpos.z)
             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;

src/hacks/AutoBackstab.cpp

@@ -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,6 +125,8 @@ void CreateMove()
     if (!CanShoot())
         return;
     CachedEntity *besttarget = nullptr;
+    if (!backtrack::isBacktrackEnabled())
+    {
         for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
         {
             CachedEntity *target = ENTITY(i);
@@ -133,7 +136,7 @@ void CreateMove()
                 !target->m_bAlivePlayer() || target->m_Type() != ENTITY_PLAYER)
                 continue;
             if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
-                g_pLocalPlayer->v_Eye) <= 300.0f)
+                    g_pLocalPlayer->v_Eye) <= 200.0f)
             {
                 if (CE_GOOD(besttarget))
                 {
@@ -149,11 +152,30 @@ void CreateMove()
                 }
             }
         }
+    }
+    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 : backtrack::headPositions[idx])
-            for (auto i : hacks::shared::backtrack::headPositions[idx])
             {
-                bool good_tick = false;
+                if (!backtrack::ValidTick(i, besttarget))
-                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)
                     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,

src/hacks/Backtrack.cpp

@@ -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" };
@@ -147,35 +146,20 @@ void Run()
         }
     }
     if (iBestTarget != -1 && CanShoot())
+    {
+        CachedEntity *tar = ENTITY(iBestTarget);
+        if (CE_GOOD(tar))
         {
             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)
             {
-            if (headPositions[iBestTarget][t].tickcount)
+                if (!ValidTick(headPositions[tar->m_IDX][t], tar))
-                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 =
+                tempFOV = GetFov(g_pLocalPlayer->v_OrigViewangles,
-                GetFov(g_pLocalPlayer->v_OrigViewangles, g_pLocalPlayer->v_Eye,
+                                 g_pLocalPlayer->v_Eye,
                                  headPositions[iBestTarget][t].hitboxpos);
                 if (IsMelee)
                 {
@@ -183,7 +167,7 @@ void Run()
                         headPositions[iBestTarget][t].spine);
                     if (distance < (float) mindistance)
                         continue;
-                if (distance < prev_distance_ticks && tempFOV < 90.0f)
+                    if (distance < prev_distance_ticks)
                         prev_distance_ticks = distance, bestTick = t;
                 }
                 else
@@ -196,19 +180,21 @@ void Run()
             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);
+                Vector &angles =
-            float &simtime = NET_FLOAT(RAW_ENT(tar), netvar.m_flSimulationTime);
+                    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;
             }
         }
     }
+}
 void Draw()
 {
 #if ENABLE_VISUALS
@@ -218,20 +204,16 @@ 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;
+            if (!ValidTick(headPositions[i][j], ent))
-
-            for (int i = 0; i < tickus; ++i)
-                if (j == sorted_ticks[i].tick)
-                    good_tick = true;
-            if (!good_tick)
                 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;
             if (!hbpos.x && !hbpos.y && !hbpos.z)
@@ -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 fabsf(NET_FLOAT(RAW_ENT(ent), netvar.m_flSimulationTime) * 1000.0f -
-    //return (*latency > 800 || *latency < 200) ? 12 : 24;
+                 getLatency() - i.simtime * 1000.0f) < 200.0f;
-    return 12;
-}
 }
+
+} // namespace hacks::shared::backtrack

src/hacks/Trigger.cpp

@@ -41,18 +41,12 @@ int last_hb_traced = 0;
 Vector forward;
 bool CanBacktrack()
 {
-    int target  = hacks::shared::backtrack::iBestTarget;
+    CachedEntity *tar = ENTITY(hacks::shared::backtrack::iBestTarget);
-    int tickcnt = 0;
+    if (CE_BAD(tar))
-    int tickus = hacks::shared::backtrack::getTicks2();
+        return false;
-    for (auto i : hacks::shared::backtrack::headPositions[target])
+    for (auto i : hacks::shared::backtrack::headPositions[tar->m_IDX])
     {
-        bool good_tick = false;
+        if(!hacks::shared::backtrack::ValidTick(i, tar))
-        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;
         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;