Merge pull request #541 from TotallyNotElite/master

Autobacktrackstab

.gitignore

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

include/hacks/AntiAntiAim.hpp

@@ -3,10 +3,18 @@
 */
 
 #pragma once
+#include <core/interfaces.hpp>
+#include <core/sdk.hpp>
+#include <globals.h>
+#include <core/netvars.hpp>
+#include <settings/Bool.hpp>
+#include <localplayer.hpp>
+#include <entitycache.hpp>
 
 namespace hacks::shared::anti_anti_aim
 {
 
 void createMove();
+void resolveEnt(int IDX, IClientEntity *entity = nullptr);
 
-}
+}

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/MiscTemporary.cpp

@@ -16,8 +16,8 @@ int prevflowticks = 0;
 
 bool *bSendPackets{ nullptr };
 
-settings::Bool crypt_chat{ "chat.crypto", "false" };
+settings::Bool crypt_chat{ "chat.crypto", "true" };
 settings::Bool clean_screenshots{ "visual.clean-screenshots", "false" };
 settings::Bool nolerp{ "misc.no-lerp", "false" };
 settings::Bool no_zoom{ "remove.scope", "false" };
-settings::Bool disable_visuals{ "visual.disable", "false" };
+settings::Bool disable_visuals{ "visual.disable", "false" };

src/hacks/AntiAntiAim.cpp

@@ -3,13 +3,6 @@
 */
 
 #include <hacks/AntiAntiAim.hpp>
-#include <core/interfaces.hpp>
-#include <core/sdk.hpp>
-#include <globals.h>
-#include <core/netvars.hpp>
-#include <settings/Bool.hpp>
-#include <localplayer.hpp>
-#include <entitycache.hpp>
 
 static settings::Bool enable{ "anti-anti-aim.enable", "false" };
 
@@ -23,70 +16,74 @@ void hacks::shared::anti_anti_aim::createMove()
     IClientEntity *entity{ nullptr };
     for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
     {
-        if (i == g_IEngine->GetLocalPlayer())
+        resolveEnt(i, entity);
-            continue;
-        entity = g_IEntityList->GetClientEntity(i);
-        if (entity && !entity->IsDormant() && !NET_BYTE(entity, netvar.iLifeState))
-        {
-            float quotat = 0;
-            float quotaf = 0;
-            if (!g_Settings.brute.choke[i].empty())
-                for (auto it : g_Settings.brute.choke[i])
-                {
-                    if (it)
-                        quotat++;
-                    else
-                        quotaf++;
-                }
-            float quota    = quotat / quotaf;
-            Vector &angles = NET_VECTOR(entity, netvar.m_angEyeAngles);
-            static bool brutepitch = false;
-            if (g_Settings.brute.brutenum[i] > 5)
-            {
-                g_Settings.brute.brutenum[i] = 0;
-                brutepitch                   = !brutepitch;
-            }
-            angles.y = fmod(angles.y + 180.0f, 360.0f);
-            if (angles.y < 0)
-                angles.y += 360.0f;
-            angles.y -= 180.0f;
-            if (quota < 0.8f)
-                switch (g_Settings.brute.brutenum[i])
-                {
-                case 0:
-                    break;
-                case 1:
-                    angles.y += 180.0f;
-                    break;
-                case 2:
-                    angles.y -= 90.0f;
-                    break;
-                case 3:
-                    angles.y += 90.0f;
-                    break;
-                case 4:
-                    angles.y -= 180.0f;
-                    break;
-                case 5:
-                    angles.y = 0.0f;
-                    break;
-                }
-            if (brutepitch || quota < 0.8f)
-                switch (g_Settings.brute.brutenum[i] % 4)
-                {
-                case 0:
-                    break;
-                case 1:
-                    angles.x = -89.0f;
-                    break;
-                case 2:
-                    angles.x = 89.0f;
-                    break;
-                case 3:
-                    angles.x = 0.0f;
-                    break;
-                }
-        }
     }
 }
 
+void hacks::shared::anti_anti_aim::resolveEnt(int IDX, IClientEntity *entity)
+{
+    if (IDX == g_IEngine->GetLocalPlayer())
+        return;
+    entity = g_IEntityList->GetClientEntity(IDX);
+    if (entity && !entity->IsDormant() && !NET_BYTE(entity, netvar.iLifeState))
+    {
+        float quotat = 0;
+        float quotaf = 0;
+        if (!g_Settings.brute.choke[IDX].empty())
+            for (auto it : g_Settings.brute.choke[IDX])
+            {
+                if (it)
+                    quotat++;
+                else
+                    quotaf++;
+            }
+        float quota    = quotat / quotaf;
+        Vector &angles = NET_VECTOR(entity, netvar.m_angEyeAngles);
+        static bool brutepitch = false;
+        if (g_Settings.brute.brutenum[IDX] > 5)
+        {
+            g_Settings.brute.brutenum[IDX] = 0;
+            brutepitch                   = !brutepitch;
+        }
+        angles.y = fmod(angles.y + 180.0f, 360.0f);
+        if (angles.y < 0)
+            angles.y += 360.0f;
+        angles.y -= 180.0f;
+        if (quota < 0.8f)
+            switch (g_Settings.brute.brutenum[IDX])
+            {
+            case 0:
+                break;
+            case 1:
+                angles.y += 180.0f;
+                break;
+            case 2:
+                angles.y -= 90.0f;
+                break;
+            case 3:
+                angles.y += 90.0f;
+                break;
+            case 4:
+                angles.y -= 180.0f;
+                break;
+            case 5:
+                angles.y = 0.0f;
+                break;
+            }
+        if (brutepitch || quota < 0.8f)
+            switch (g_Settings.brute.brutenum[IDX] % 4)
+            {
+            case 0:
+                break;
+            case 1:
+                angles.x = -89.0f;
+                break;
+            case 2:
+                angles.x = 89.0f;
+                break;
+            case 3:
+                angles.x = 0.0f;
+                break;
+            }
+    }
+}

src/hacks/AutoBackstab.cpp

@@ -9,12 +9,32 @@
 #include "common.hpp"
 #include "hacks/Backtrack.hpp"
 #include "hacks/Aimbot.hpp"
+#include "hacks/Trigger.hpp"
+#include "hacks/AntiAntiAim.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)
@@ -26,14 +46,8 @@ const Vector GetWorldSpaceCenter(CachedEntity *ent)
     return vWorldSpaceCenter;
 }
 
-std::pair<Vector, Vector> GetHitboxBounds(CachedEntity *it, int hitbox)
-{
-	std::pair<Vector, Vector> result(it->hitboxes.GetHitbox(hitbox)->min,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 +62,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 +81,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 +95,49 @@ 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 targetAngle)
+{
+    float meleeRange = re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
+    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 +175,77 @@ void CreateMove()
     }
     if (CE_GOOD(besttarget))
     {
-        Vector hitboxLoc =
+        hacks::shared::anti_anti_aim::resolveEnt(besttarget->m_IDX);
-            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, NET_VECTOR(RAW_ENT(besttarget), netvar.m_angEyeAngles).y))
-                    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)