Store data of all hitboxes

include/hacks/Backtrack.hpp

@@ -11,15 +11,17 @@
 
 namespace hacks::shared::backtrack
 {
+struct hitboxData
+{
+    Vector center{ 0.0f, 0.0f, 0.0f };
+    Vector min{ 0.0f, 0.0f, 0.0f };
+    Vector max{ 0.0f, 0.0f, 0.0f };
+};
+
 struct BacktrackData
 {
     int tickcount{ 0 };
-    Vector hitboxpos{ 0.0f, 0.0f, 0.0f };
+    std::array<hitboxData, 18> hitboxes;
-    Vector min{ 0.0f, 0.0f, 0.0f };
-    Vector max{ 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/Aimbot.cpp

@@ -114,9 +114,9 @@ bool BacktrackAimbot()
     {
         if (hacks::shared::backtrack::ValidTick(i, tar))
              continue;
-        if (!i.hitboxpos.z)
+        if (!i.hitboxes.at(head).center.z)
             continue;
-        if (!IsVectorVisible(g_pLocalPlayer->v_Eye, i.hitboxpos, true))
+        if (!IsVectorVisible(g_pLocalPlayer->v_Eye, i.hitboxes.at(head).center, true))
             continue;
         float scr = abs(g_pLocalPlayer->v_OrigViewangles.y - i.viewangles);
         Vector &angles = NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles);
@@ -124,7 +124,7 @@ bool BacktrackAimbot()
         angles.y       = i.viewangles;
         simtime        = i.simtime;
         current_user_cmd->tick_count = i.tickcount;
-        Vector tr              = (i.hitboxpos - g_pLocalPlayer->v_Eye);
+        Vector tr              = (i.hitboxes.at(head).center - g_pLocalPlayer->v_Eye);
         Vector angles2;
         VectorAngles(tr, angles2);
         // Clamping is important

src/hacks/AutoBackstab.cpp

@@ -167,7 +167,7 @@ void CreateMove()
             return;
         // Check if besttick distance is < 200.0f
         if (backtrack::headPositions[target->m_IDX][backtrack::BestTick]
-                .spine.DistTo(g_pLocalPlayer->v_Eye) < 200.0f)
+                .hitboxes.at(spine_3).center.DistTo(g_pLocalPlayer->v_Eye) < 200.0f)
             besttarget = target;
     }
 
@@ -219,13 +219,13 @@ void CreateMove()
                         g_pLocalPlayer->v_Origin);
                 // Get dist Z to Z
                 float halfHeight =
-                    (i.spineMin.DistTo(
+                    (i.hitboxes.at(spine_3).min.DistTo(
-                        Vector{ i.spineMin.x, i.spineMin.y, i.spineMax.z })) /
+                        Vector{ i.hitboxes.at(spine_3).min.x, i.hitboxes.at(spine_3).min.y, i.hitboxes.at(spine_3).max.z })) /
                     2;
                 // Make our first diagonal line
                 std::pair<Vector, Vector> line1(
-                    { i.spineMin.x, i.spineMin.y, i.spineMin.z + halfHeight },
+                    { i.hitboxes.at(spine_3).min.x, i.hitboxes.at(spine_3).min.y, i.hitboxes.at(spine_3).min.z + halfHeight },
-                    { i.spineMax.x, i.spineMax.y, i.spineMax.z - halfHeight });
+                    { i.hitboxes.at(spine_3).max.x, i.hitboxes.at(spine_3).max.y, i.hitboxes.at(spine_3).max.z - halfHeight });
                 // Make our second diagonal line
                 std::pair<Vector, Vector> line2(
                     { line1.second.x, line1.first.y, line1.first.z },
@@ -241,8 +241,8 @@ void CreateMove()
 
                 for (angle.y = -180.0f; angle.y < 180.0f; angle.y += 20.0f)
                 {
-                    if (unifiedCanBackstab(angle, i.spineMin, i.spineMax,
+                    if (unifiedCanBackstab(angle, i.hitboxes.at(spine_3).min, i.hitboxes.at(spine_3).max,
-                                           i.spine, besttarget))
+                                           i.hitboxes.at(spine_3).center, besttarget))
                     {
                         current_user_cmd->tick_count = i.tickcount;
                         current_user_cmd->viewangles = angle;

src/hacks/Backtrack.cpp

@@ -20,9 +20,8 @@ static settings::Int slots{ "backtrack.slots", "0" };
 
 namespace hacks::shared::backtrack
 {
-
+void EmptyBacktrackData(BacktrackData &i);
 BacktrackData headPositions[32][66]{};
-BestTickData sorted_ticks[66]{};
 int highesttick[32]{};
 int lastincomingsequencenumber = 0;
 static bool shouldDrawBt;
@@ -64,10 +63,7 @@ void Init()
 {
     for (int i = 0; i < 32; i++)
         for (int j = 0; j < 66; j++)
-            headPositions[i][j] = BacktrackData{
+            EmptyBacktrackData(headPositions[i][j]);
-                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;
@@ -102,10 +98,7 @@ void Run()
         if (CE_BAD(pEntity) || !pEntity->m_bAlivePlayer())
         {
             for (BacktrackData &btd : headPositions[i])
-                btd = BacktrackData{ 0,           { 0, 0, 0 }, { 0, 0, 0 },
+                EmptyBacktrackData(btd);
-                                     { 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())
@@ -113,27 +106,26 @@ void Run()
         if (pEntity->m_Type() != ENTITY_PLAYER)
             continue;
         if (!pEntity->hitboxes.GetHitbox(0))
-            continue;
+            continue; 
-        Vector hitboxpos = pEntity->hitboxes.GetHitbox(0)->center;
-        Vector min       = pEntity->hitboxes.GetHitbox(0)->min;
-        Vector max       = pEntity->hitboxes.GetHitbox(0)->max;
         float _viewangles =
             NET_VECTOR(RAW_ENT(pEntity), netvar.m_angEyeAngles).y;
         float viewangles =
             (_viewangles > 180) ? _viewangles - 360 : _viewangles;
         float simtime       = CE_FLOAT(pEntity, netvar.m_flSimulationTime);
-        Vector hitbox_spine = pEntity->hitboxes.GetHitbox(spine_3)->center;
+        std::array<hitboxData, 18> hbdArray;
-        Vector hitbox_min   = pEntity->hitboxes.GetHitbox(spine_3)->min;
+        for (size_t i = 0; i < hbdArray.max_size(); i++)
-        Vector hitbox_max   = pEntity->hitboxes.GetHitbox(spine_3)->max;
+        {
+            hbdArray.at(i).center = pEntity->hitboxes.GetHitbox(i)->center;
+            hbdArray.at(i).min = pEntity->hitboxes.GetHitbox(i)->min;
+            hbdArray.at(i).max = pEntity->hitboxes.GetHitbox(i)->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, hbdArray, 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);
+                                   g_pLocalPlayer->v_Eye, hbdArray.at(head).center);
-        float distance    = g_pLocalPlayer->v_Eye.DistTo(hitbox_spine);
+        float distance    = g_pLocalPlayer->v_Eye.DistTo(hbdArray.at(spine_3).center);
         if (!IsMelee && bestFov > FOVDistance && FOVDistance < 60.0f)
         {
             bestFov     = FOVDistance;
@@ -160,11 +152,11 @@ void Run()
                     continue;
                 tempFOV = GetFov(g_pLocalPlayer->v_OrigViewangles,
                                  g_pLocalPlayer->v_Eye,
-                                 headPositions[iBestTarget][t].hitboxpos);
+                                 headPositions[iBestTarget][t].hitboxes.at(head).center);
                 if (IsMelee)
                 {
                     distance = g_pLocalPlayer->v_Eye.DistTo(
-                        headPositions[iBestTarget][t].spine);
+                        headPositions[iBestTarget][t].hitboxes.at(spine_3).center);
                     if (distance < (float) mindistance)
                         continue;
                     if (distance < prev_distance_ticks)
@@ -213,9 +205,9 @@ void Draw()
         {
             if (!ValidTick(headPositions[i][j], ent))
                 continue;
-            auto hbpos = headPositions[i][j].hitboxpos;
+            auto hbpos = headPositions[i][j].hitboxes.at(head).center;
-            auto min   = headPositions[i][j].min;
+            auto min   = headPositions[i][j].hitboxes.at(head).min;
-            auto max   = headPositions[i][j].max;
+            auto max   = headPositions[i][j].hitboxes.at(head).max;
             if (!hbpos.x && !hbpos.y && !hbpos.z)
                 continue;
             Vector out;
@@ -297,4 +289,9 @@ bool ValidTick(BacktrackData &i, CachedEntity *ent)
                  getLatency() - i.simtime * 1000.0f) < 200.0f;
 }
 
+void EmptyBacktrackData(BacktrackData &i)
+{
+    i = {};
+}
+
 } // namespace hacks::shared::backtrack

src/hacks/Trigger.cpp

@@ -48,8 +48,8 @@ bool CanBacktrack()
     {
         if(!hacks::shared::backtrack::ValidTick(i, tar))
             continue;
-        auto min = i.min;
+        auto min = i.hitboxes.at(head).min;
-        auto max = i.max;
+        auto max = i.hitboxes.at(head).max;
         if (!min.x && !max.x)
             continue;