Autobackstab improvements?

include/hacks/Backtrack.hpp

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

src/hacks/AutoBackstab.cpp

@@ -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[YAW]), &sy, &cy);
-    SinCos( DEG2RAD( angles[PITCH] ), &sp, &cp );
+    SinCos(DEG2RAD(angles[PITCH]), &sp, &cp);
 
-    forward->x = cp*cy;
+    forward->x = cp * cy;
-    forward->y = cp*sy;
+    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,
+bool unifiedCanBackstab(CachedEntity *tar, Vector &vecAngle,
-                        Vector hitboxLoc, CachedEntity *besttarget)
+                        Vector targetOrigin, Vector min, Vector max)
 {
     // Get melee range
     float meleeRange = re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
-    if (fabsf(vecAngle.y -
+    Vector tarAngle  = CE_VECTOR(tar, netvar.m_angEyeAngles);
-              NET_VECTOR(RAW_ENT(besttarget), netvar.m_angEyeAngles).y) >=
-        60.0f)
-        return false;
-    if (!min.x && !max.x)
-        return false;
 
     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 wsc_spy_to_victim = (targetOrigin - LOCAL_E->m_vecOrigin());
-    Vector tr = (hitboxLoc - head);
+    wsc_spy_to_victim.z      = 0;
-    Vector xAngle;
+    wsc_spy_to_victim.NormalizeInPlace();
-    VectorAngles(tr, xAngle);
+
-    fClampAngle(xAngle);
+    Vector eye_spy;
-    vecAngle.x = xAngle.x;
+    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))
+    if (!hacks::shared::triggerbot::CheckLineBox(minz, maxz, head, forward,
-        return true;
+                                                 hit))
-    return false;
+        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(
+                if (!unifiedCanBackstab(besttarget, angle, origin, min, max))
-                        angle,
-                        besttarget->hitboxes
-                            .GetHitbox(ClosestDistanceHitbox(besttarget))
-                            ->min,
-                        besttarget->hitboxes
-                            .GetHitbox(ClosestDistanceHitbox(besttarget))
-                            ->max,
-                        hitboxLoc, besttarget))
                     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,
+                    if (unifiedCanBackstab(besttarget, angle, i.entorigin, i.collidable.min, i.collidable.max))
-                                           hitbox.center, besttarget))
                     {
                         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;
-//    rgba_t col1 = IsBehind ? colors::green : colors::red;
+    //    AddCenterString(format("Behind target" /*, dot1*/), col1);
-//    rgba_t col2 = LookingAtVic ? colors::green : colors::red;
+    //    AddCenterString(format("Looking at Target" /*, dot2*/), col2);
-//    rgba_t col3 = InBackstabAngleRange ? colors::green : colors::red;
+    //    AddCenterString(format("In Angle Range" /*, dot3*/), col3);
-//    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)
+    Vector eye_spy;
-        toclamp -= 360;
+    AngleVectors2(VectorToQAngle(angle), &eye_spy);
+    eye_spy.z = 0;
+    eye_spy.NormalizeInPlace();
 
-    while (toclamp < -180)
+    Vector eye_victim;
-        toclamp += 360;
+    AngleVectors2(VectorToQAngle(tarAngle), &eye_victim);
+    eye_victim.z = 0;
+    eye_victim.NormalizeInPlace();
 
-    // Get the forward view vector of the target, ignore Z
+    IsBehind             = DotProduct(wsc_spy_to_victim, eye_victim) <= 0.0f;
-    Vector vecVictimForward;
+    LookingAtVic         = DotProduct(wsc_spy_to_victim, eye_spy) <= 0.5f;
-    AngleVectors2(VectorToQAngle(tarAngle), &vecVictimForward);
+    InBackstabAngleRange = DotProduct(eye_spy, eye_victim) <= -0.3f;
-    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);
 }
 
 } // namespace hacks::tf2::autobackstab

src/hacks/Backtrack.cpp

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

src/hoovy.cpp

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