From dcdfec46092104b81b02938987606e907788b09a Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Fri, 20 Jul 2018 19:28:14 +0200
Subject: [PATCH 01/20] Improvements and fixes

---
 include/helpers.hpp     |  1 -
 src/hacks/Aimbot.cpp    |  2 +-
 src/hacks/Backtrack.cpp |  2 +-
 src/hacks/FollowBot.cpp | 27 ++++++++++--------
 src/helpers.cpp         | 61 ++++++++++-------------------------------
 5 files changed, 33 insertions(+), 60 deletions(-)

diff --git a/include/helpers.hpp b/include/helpers.hpp
index 03751cd8..ac11ce6d 100755
--- a/include/helpers.hpp
+++ b/include/helpers.hpp
@@ -82,7 +82,6 @@ Vector VischeckWall(CachedEntity *player, CachedEntity *target, float maxdist,
 float vectorMax(Vector i);
 Vector vectorAbs(Vector i);
 bool canReachVector(Vector loc, Vector dest = {0,0,0});
-bool isJumping(Vector vec);
 
 bool LineIntersectsBox(Vector &bmin, Vector &bmax, Vector &lmin, Vector &lmax);
 
diff --git a/src/hacks/Aimbot.cpp b/src/hacks/Aimbot.cpp
index 1c52c229..70ef0763 100644
--- a/src/hacks/Aimbot.cpp
+++ b/src/hacks/Aimbot.cpp
@@ -201,7 +201,7 @@ bool BacktrackAimbot()
     {
         bool good_tick = false;
         for (int j = 0; j < 12; ++j)
-            if (tickcnt == hacks::shared::backtrack::sorted_ticks[j].tick && hacks::shared::backtrack::sorted_ticks[j].tickcount != FLT_MAX)
+            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)
diff --git a/src/hacks/Backtrack.cpp b/src/hacks/Backtrack.cpp
index 7cbc34ee..b2793586 100644
--- a/src/hacks/Backtrack.cpp
+++ b/src/hacks/Backtrack.cpp
@@ -174,7 +174,7 @@ void Run()
         {
             bool good_tick = false;
             for (int i = 0; i < 12; ++i)
-                if (t == sorted_ticks[i].tick && sorted_ticks[i].tickcount != FLT_MAX)
+                if (t == sorted_ticks[i].tick && sorted_ticks[i].tickcount != INT_MAX)
                     good_tick = true;
             if (!good_tick)
                 continue;
diff --git a/src/hacks/FollowBot.cpp b/src/hacks/FollowBot.cpp
index bb205159..ac090181 100644
--- a/src/hacks/FollowBot.cpp
+++ b/src/hacks/FollowBot.cpp
@@ -63,9 +63,10 @@ static const int crumb_limit = 64; // limit
 
 // Followed entity, externed for highlight color
 int follow_target = 0;
-bool inited;
+static bool inited;
 
 Timer lastTaunt{}; // time since taunt was last executed, used to avoid kicks
+Timer lastJump{};
 std::array<Timer, 32> afkTicks; // for how many ms the player hasn't been moving
 
 void checkAFK()
@@ -75,7 +76,7 @@ void checkAFK()
         auto entity = ENTITY(i);
         if (CE_BAD(entity))
             continue;
-        if (!CE_VECTOR(entity, netvar.vVelocity).IsZero(5.0f))
+        if (!CE_VECTOR(entity, netvar.vVelocity).IsZero(40.0f))
         {
             afkTicks[i].update();
         }
@@ -306,12 +307,6 @@ void WorldTick()
         }
     }
 
-//    if(!checkPath()) //wip do not merge if you see this
-//    {
-//        follow_target = 0;
-//        return;
-//    }
-
     // Update timer on new target
     static Timer idle_time{};
     if (breadcrumbs.empty())
@@ -331,7 +326,7 @@ void WorldTick()
     // New crumbs, we add one if its empty so we have something to follow
     if ((breadcrumbs.empty() ||
          tar_orig.DistTo(breadcrumbs.at(breadcrumbs.size() - 1)) > 40.0F) &&
-        DistanceToGround(ENTITY(follow_target)) < 30)
+        DistanceToGround(ENTITY(follow_target)) < 45)
         breadcrumbs.push_back(tar_orig);
 
     // Prune old and close crumbs that we wont need anymore, update idle timer
@@ -357,14 +352,24 @@ void WorldTick()
     if (dist_to_target > (float) follow_distance)
     {
         // Check for jump
-        if (autojump && (idle_time.check(2000) || isJumping(breadcrumbs[0])))
+        if (autojump && lastJump.check(1000) && (idle_time.check(2000) || DistanceToGround(breadcrumbs[0]) > 42))
+        {
             g_pUserCmd->buttons |= IN_JUMP;
-        // Check for idle
+            lastJump.update();
+        }
+        // Check if still moving. 70 HU = Sniper Zoomed Speed
+        if (idle_time.check(3000) && CE_VECTOR(g_pLocalPlayer->entity, netvar.vVelocity).IsZero(60.0f))
+        {
+            follow_target = 0;
+            return;
+        }
+        // Basic idle check
         if (idle_time.test_and_set(5000))
         {
             follow_target = 0;
             return;
         }
+
         static float last_slot_check = 0.0f;
         if (g_GlobalVars->curtime < last_slot_check)
             last_slot_check = 0.0f;
diff --git a/src/helpers.cpp b/src/helpers.cpp
index 1867137e..ddfb6f40 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -192,16 +192,10 @@ bool canReachVector(Vector loc, Vector dest)
         int maxiterations = floor(dest.DistTo(loc)) / 40;
         for (int i = 0; i < maxiterations; i++)
         {
+            // math to get the next vector 40.0f in the direction of dest
             Vector vec = loc + dist / vectorMax(vectorAbs(dist)) * 40.0f * (i + 1);
 
-            trace_t trace;
-            Ray_t ray;
-            Vector down = vec;
-            down.z      = down.z - 50;
-            ray.Init(vec, down);
-            g_ITrace->TraceRay(ray, 0x4200400B, &trace::filter_no_player,
-                               &trace);
-            if (!(trace.startpos.DistTo(trace.endpos) <= 45))
+            if (DistanceToGround(vec) >= 45)
                 return false;
 
             for (int j = 0; j < 4; j++)
@@ -223,13 +217,13 @@ bool canReachVector(Vector loc, Vector dest)
                     directionalLoc.y = directionalLoc.y - 40;
                     break;
                 }
-                trace_t trace2;
-                Ray_t ray2;
-                ray2.Init(vec, directionalLoc);
-                g_ITrace->TraceRay(ray2, 0x4200400B, &trace::filter_no_player,
-                                   &trace2);
+                trace_t trace;
+                Ray_t ray;
+                ray.Init(vec, directionalLoc);
+                g_ITrace->TraceRay(ray, 0x4200400B, &trace::filter_no_player,
+                                   &trace);
                 // distance of trace < than 26
-                if (trace2.startpos.DistTo(trace2.endpos) < 26.0f)
+                if (trace.startpos.DistTo(trace.endpos) < 26.0f)
                     return false;
             }
         }
@@ -237,16 +231,11 @@ bool canReachVector(Vector loc, Vector dest)
     else
     {
         // check if the vector is too high above ground
-        trace_t trace;
-        Ray_t ray;
-        Vector down = loc;
-        down.z      = down.z - 50;
-        ray.Init(loc, down);
-        g_ITrace->TraceRay(ray, 0x4200400B, &trace::filter_no_player, &trace);
         // higher to avoid small false positives, player can jump 42 hu according to
         // the tf2 wiki
-        if (!(trace.startpos.DistTo(trace.endpos) <= 45))
+        if (DistanceToGround(loc) >= 45)
             return false;
+
         // check if there is enough space arround the vector for a player to fit
         // for loop for all 4 directions
         for (int i = 0; i < 4; i++)
@@ -268,38 +257,18 @@ bool canReachVector(Vector loc, Vector dest)
                 directionalLoc.y = directionalLoc.y - 40;
                 break;
             }
-            trace_t trace2;
-            Ray_t ray2;
-            ray2.Init(loc, directionalLoc);
-            g_ITrace->TraceRay(ray, 0x4200400B, &trace::filter_no_player, &trace2);
+            trace_t trace;
+            Ray_t ray;
+            ray.Init(loc, directionalLoc);
+            g_ITrace->TraceRay(ray, 0x4200400B, &trace::filter_no_player, &trace);
             // distance of trace < than 26
-            if (trace2.startpos.DistTo(trace2.endpos) < 26.0f)
+            if (trace.startpos.DistTo(trace.endpos) < 26.0f)
                 return false;
         }
     }
     return true;
 }
 
-// returns if the player is currently jumping/falling.
-bool isJumping(Vector vec)
-{
-    // check if the vector is too high above ground
-    trace_t trace;
-    Ray_t ray;
-    Vector down = vec;
-    Vector loc  = vec;
-    down.z      = down.z - 50;
-    loc.z       = loc.z + 5;
-    ray.Init(vec, down);
-    // trace::filter_no_player.SetSelf(RAW_ENT(g_pLocalPlayer->entity));
-    g_ITrace->TraceRay(ray, 0x4200400B, &trace::filter_no_player, &trace);
-    // lower to avoid small false negatives, player can jump 42 hu according to
-    // the tf2 wiki, higher because loc.z = loc.z + 5;
-    if (trace.startpos.DistTo(trace.endpos) > 45)
-        return true;
-    return false;
-}
-
 std::string GetLevelName()
 {
 

From e051c168515251d10a0eba6e723adbee5a24d336 Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Fri, 20 Jul 2018 20:27:58 +0200
Subject: [PATCH 02/20] Fix backtrack issues

---
 src/hacks/Aimbot.cpp       | 3 ++-
 src/hacks/AutoBackstab.cpp | 2 +-
 src/hacks/Backtrack.cpp    | 9 ++++++---
 src/hacks/Trigger.cpp      | 2 +-
 4 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/hacks/Aimbot.cpp b/src/hacks/Aimbot.cpp
index 70ef0763..cf1a7a21 100644
--- a/src/hacks/Aimbot.cpp
+++ b/src/hacks/Aimbot.cpp
@@ -201,7 +201,8 @@ bool BacktrackAimbot()
     {
         bool good_tick = false;
         for (int j = 0; j < 12; ++j)
-            if (tickcnt == hacks::shared::backtrack::sorted_ticks[j].tick && hacks::shared::backtrack::sorted_ticks[j].tickcount != INT_MAX)
+            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)
diff --git a/src/hacks/AutoBackstab.cpp b/src/hacks/AutoBackstab.cpp
index 3e0f853f..15cea298 100644
--- a/src/hacks/AutoBackstab.cpp
+++ b/src/hacks/AutoBackstab.cpp
@@ -52,7 +52,7 @@ void CreateMove()
         {
             bool good_tick = false;
             for (int j = 0; j < 12; ++j)
-                if (tickcnt == hacks::shared::backtrack::sorted_ticks[j].tick)
+                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)
diff --git a/src/hacks/Backtrack.cpp b/src/hacks/Backtrack.cpp
index b2793586..1b70ef1c 100644
--- a/src/hacks/Backtrack.cpp
+++ b/src/hacks/Backtrack.cpp
@@ -9,8 +9,10 @@
 #include "hacks/Backtrack.hpp"
 #include <boost/circular_buffer.hpp>
 #include <glez/draw.hpp>
-#define IsMelee GetWeaponMode() == weapon_melee
-
+bool IsMelee()
+{
+	return GetWeaponMode() == weapon_melee;
+}
 namespace hacks::shared::backtrack
 {
 CatVar enable(CV_SWITCH, "backtrack", "0", "Enable backtrack",
@@ -174,7 +176,8 @@ void Run()
         {
             bool good_tick = false;
             for (int i = 0; i < 12; ++i)
-                if (t == sorted_ticks[i].tick && sorted_ticks[i].tickcount != INT_MAX)
+                if (t == sorted_ticks[i].tick &&
+                    sorted_ticks[i].tickcount != INT_MAX && sorted_ticks[i].tickcount)
                     good_tick = true;
             if (!good_tick)
                 continue;
diff --git a/src/hacks/Trigger.cpp b/src/hacks/Trigger.cpp
index c302f412..7911e951 100644
--- a/src/hacks/Trigger.cpp
+++ b/src/hacks/Trigger.cpp
@@ -86,7 +86,7 @@ bool CanBacktrack()
     {
         bool good_tick = false;
         for (int j = 0; j < 12; ++j)
-            if (tickcnt == hacks::shared::backtrack::sorted_ticks[j].tick)
+            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)

From 5e05e151e8a07e96b961b9714293d7583dce40ed Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Fri, 20 Jul 2018 22:23:23 +0200
Subject: [PATCH 03/20] Backtrack fix V2

---
 src/hacks/Backtrack.cpp | 5 +----
 1 file changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/hacks/Backtrack.cpp b/src/hacks/Backtrack.cpp
index 1b70ef1c..450509d8 100644
--- a/src/hacks/Backtrack.cpp
+++ b/src/hacks/Backtrack.cpp
@@ -9,10 +9,6 @@
 #include "hacks/Backtrack.hpp"
 #include <boost/circular_buffer.hpp>
 #include <glez/draw.hpp>
-bool IsMelee()
-{
-	return GetWeaponMode() == weapon_melee;
-}
 namespace hacks::shared::backtrack
 {
 CatVar enable(CV_SWITCH, "backtrack", "0", "Enable backtrack",
@@ -108,6 +104,7 @@ void Run()
     float bestFov       = 99999;
     BestTick            = 0;
     iBestTarget         = -1;
+    bool IsMelee        = GetWeaponMode() == weapon_melee;
 
     float prev_distance = 9999;
 

From 8d8b7a0e41452144beeea51ea2b715717ffdcf24 Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Sat, 21 Jul 2018 11:49:44 +0200
Subject: [PATCH 04/20] FB: Autojump, AFK and canReachVector improvements

---
 src/hacks/FollowBot.cpp | 4 ++--
 src/helpers.cpp         | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/hacks/FollowBot.cpp b/src/hacks/FollowBot.cpp
index ac090181..2e2d83f5 100644
--- a/src/hacks/FollowBot.cpp
+++ b/src/hacks/FollowBot.cpp
@@ -76,7 +76,7 @@ void checkAFK()
         auto entity = ENTITY(i);
         if (CE_BAD(entity))
             continue;
-        if (!CE_VECTOR(entity, netvar.vVelocity).IsZero(40.0f))
+        if (!CE_VECTOR(entity, netvar.vVelocity).IsZero(60.0f))
         {
             afkTicks[i].update();
         }
@@ -352,7 +352,7 @@ void WorldTick()
     if (dist_to_target > (float) follow_distance)
     {
         // Check for jump
-        if (autojump && lastJump.check(1000) && (idle_time.check(2000) || DistanceToGround(breadcrumbs[0]) > 42))
+        if (autojump && lastJump.check(1000) && (idle_time.check(2000) || DistanceToGround({breadcrumbs[0].x,breadcrumbs[0].y,breadcrumbs[0].z + 5}) > 47))
         {
             g_pUserCmd->buttons |= IN_JUMP;
             lastJump.update();
diff --git a/src/helpers.cpp b/src/helpers.cpp
index ddfb6f40..3673cf82 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -195,7 +195,7 @@ bool canReachVector(Vector loc, Vector dest)
             // math to get the next vector 40.0f in the direction of dest
             Vector vec = loc + dist / vectorMax(vectorAbs(dist)) * 40.0f * (i + 1);
 
-            if (DistanceToGround(vec) >= 45)
+            if (DistanceToGround({vec.x,vec.y,vec.z + 5}) >= 40)
                 return false;
 
             for (int j = 0; j < 4; j++)
@@ -233,7 +233,7 @@ bool canReachVector(Vector loc, Vector dest)
         // check if the vector is too high above ground
         // higher to avoid small false positives, player can jump 42 hu according to
         // the tf2 wiki
-        if (DistanceToGround(loc) >= 45)
+        if (DistanceToGround({loc.x,loc.y,loc.z + 5}) >= 40)
             return false;
 
         // check if there is enough space arround the vector for a player to fit

From a7be8a88fb41af134ff9b0bcb8f7927ce9b0c5c9 Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Sat, 21 Jul 2018 13:59:16 +0200
Subject: [PATCH 05/20] Fix undef. behaviour/crash when sending msg to chat

---
 src/helpers.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/helpers.cpp b/src/helpers.cpp
index 3673cf82..6fd8b9c5 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -1211,7 +1211,7 @@ void PrintChat(const char *fmt, ...)
         va_end(list);
         std::unique_ptr<char> str(strfmt("\x07%06X[\x07%06XCAT\x07%06X]\x01 %s",
                                          0x5e3252, 0xba3d9a, 0x5e3252,
-                                         buf.get()).get());
+                                         buf.get()).release());
         // FIXME DEBUG LOG
         logging::Info("%s", str.get());
         chat->Printf(str.get());

From e2730286f4c0942b3f6086b15169c632ab93cfee Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Sat, 21 Jul 2018 14:24:56 +0200
Subject: [PATCH 06/20] Autounzoom fix

Fixed autounzoom having a fixed unzoom time instead of a dynamic time.
---
 src/hacks/Aimbot.cpp | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/src/hacks/Aimbot.cpp b/src/hacks/Aimbot.cpp
index cf1a7a21..36a6ad43 100644
--- a/src/hacks/Aimbot.cpp
+++ b/src/hacks/Aimbot.cpp
@@ -173,6 +173,8 @@ float cur_proj_grav{ 0.0f };
 // If slow aimbot allows autoshoot
 bool slow_can_shoot = false;
 bool projectileAimbotRequired;
+// Keep track of our zoom time
+Timer zoomTime{};
 
 // This array will store calculated projectile/hitscan predictions
 // for current frame, to avoid performing them again
@@ -252,13 +254,9 @@ void CreateMove()
     // Auto-Unzoom
     if (auto_unzoom)
     {
-        if (g_pLocalPlayer->holding_sniper_rifle)
+        if (g_pLocalPlayer->holding_sniper_rifle && g_pLocalPlayer->bZoomed && zoomTime.check(3000))
         {
-            if (g_pLocalPlayer->bZoomed)
-            {
-                if (g_GlobalVars->curtime - g_pLocalPlayer->flZoomBegin > 5.0f)
                     g_pUserCmd->buttons |= IN_ATTACK2;
-            }
         }
     }
     // We do this as we need to pass whether the aimkey allows aiming to both
@@ -276,6 +274,7 @@ void CreateMove()
         {
             if (g_pLocalPlayer->holding_sniper_rifle)
             {
+                zoomTime.update();
                 if (not g_pLocalPlayer->bZoomed)
                 {
                     g_pUserCmd->buttons |= IN_ATTACK2;

From 29dde1fff861f77731dec7bf70b8e9bfa450c40f Mon Sep 17 00:00:00 2001
From: TotallyNotElite <38938720+TotallyNotElite@users.noreply.github.com>
Date: Sat, 21 Jul 2018 19:45:49 +0200
Subject: [PATCH 07/20] Abuse circleci tf

---
 .circleci/config.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 2b8eef88..bf346543 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -7,4 +7,4 @@ jobs:
         - checkout
         - run: 
             name: "Compiling cathook"
-            command: git submodule update --init --recursive; mkdir build; cd build; cmake -DEnableWarnings=0 ..; make -j8; cd ..
+            command: git submodule update --init --recursive; mkdir build; cd build; cmake -DEnableWarnings=0 ..; make -j16; cd ..

From 6c27273f98b124282f97a56b82bb9f3f5cff1bd7 Mon Sep 17 00:00:00 2001
From: LightCat <BenCat07@gmail.com>
Date: Sat, 21 Jul 2018 20:13:38 +0200
Subject: [PATCH 08/20] WIP

---
 include/helpers.hpp     |  4 +-
 src/hacks/CatBot.cpp    |  9 ++---
 src/hacks/FollowBot.cpp | 45 ++++++++++++++++-----
 src/helpers.cpp         | 90 +++++++++++++++++++++++++++++++++++++++--
 4 files changed, 127 insertions(+), 21 deletions(-)

diff --git a/include/helpers.hpp b/include/helpers.hpp
index 3adc393d..53f6beaf 100644
--- a/include/helpers.hpp
+++ b/include/helpers.hpp
@@ -77,7 +77,9 @@ bool IsEntityVectorVisible(CachedEntity *entity, Vector endpos);
 bool VisCheckEntFromEnt(CachedEntity *startEnt, CachedEntity *endEnt);
 bool VisCheckEntFromEntVector(Vector startVector, CachedEntity *startEnt,
                               CachedEntity *endEnt);
-Vector VischeckWall(CachedEntity *player, CachedEntity *target, float maxdist,
+Vector VischeckCorner(CachedEntity *player, CachedEntity *target, float maxdist,
+                    bool checkWalkable);
+std::pair<Vector,Vector> VischeckWall(CachedEntity *player, CachedEntity *target, float maxdist,
                     bool checkWalkable);
 float vectorMax(Vector i);
 Vector vectorAbs(Vector i);
diff --git a/src/hacks/CatBot.cpp b/src/hacks/CatBot.cpp
index 49039be1..ef201351 100644
--- a/src/hacks/CatBot.cpp
+++ b/src/hacks/CatBot.cpp
@@ -221,7 +221,7 @@ void smart_crouch()
 {
     bool foundtar      = false;
     static bool crouch = false;
-    if (crouchcdr.test_and_set(1000))
+    if (crouchcdr.test_and_set(2000))
     {
         for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
         {
@@ -246,11 +246,8 @@ void smart_crouch()
             		continue;
             	if (!IsVectorVisible(ent->hitboxes.GetHitbox(0)->center, LOCAL_E->hitboxes.GetHitbox(j)->center) && !IsVectorVisible(ent->hitboxes.GetHitbox(0)->center, LOCAL_E->hitboxes.GetHitbox(j)->min) && !IsVectorVisible(ent->hitboxes.GetHitbox(0)->center, LOCAL_E->hitboxes.GetHitbox(j)->max))
             		continue;
-                else
-                {
-                    foundtar = true;
-                    crouch   = true;
-                }
+                foundtar = true;
+                crouch   = true;
             }
         }
         if (!foundtar && crouch)
diff --git a/src/hacks/FollowBot.cpp b/src/hacks/FollowBot.cpp
index c2041a1c..614bad96 100644
--- a/src/hacks/FollowBot.cpp
+++ b/src/hacks/FollowBot.cpp
@@ -55,7 +55,7 @@ static CatVar afktime(
     CV_INT, "fb_afk_time", "15000", "Max AFK Time",
     "Max time in ms spent standing still before player gets declared afk");
 static CatVar corneractivate(
-    CV_SWITCH, "fb_activation_corners", "1", "Activate arround corners",
+    CV_SWITCH, "fb_activation_corners", "1", "Activate around corners",
     "Try to find an activation path to an entity behind a corner.");
 
 // Something to store breadcrumbs created by followed players
@@ -143,6 +143,8 @@ int ClassPriority(CachedEntity *ent)
         return 0;
     }
 }
+Timer waittime{};
+int lastent = 0;
 void WorldTick()
 {
     if (!followbot)
@@ -195,15 +197,28 @@ void WorldTick()
 
             if (!entity->m_bAlivePlayer()) // Dont follow dead players
                 continue;
+            lastent++;
+            if (lastent > g_IEngine->GetMaxClients())
+            	lastent = 0;
             if (corneractivate)
             {
                 Vector indirectOrigin =
-                    VischeckWall(LOCAL_E, entity, 250,
+                    VischeckCorner(LOCAL_E, entity, 500,
                                  true); // get the corner location that the
                                         // future target is visible from
-                if (!indirectOrigin.z)  // if we couldn't find it, exit
-                    continue;
-                addCrumbs(entity, indirectOrigin);
+                std::pair<Vector, Vector> corners;
+                if (!indirectOrigin.z && entity->m_IDX == lastent)  // if we couldn't find it, run wallcheck instead
+                {
+                	corners = VischeckWall(LOCAL_E, entity, 500, true);
+                	if (!corners.first.z || !corners.second.z)
+                		continue;
+                	addCrumbs(LOCAL_E, corners.first);
+                	addCrumbs(entity, corners.second);
+                }
+                if (indirectOrigin.z)
+                	addCrumbs(entity, indirectOrigin);
+                else if (!indirectOrigin.z && !corners.first.z)
+                	continue;
             }
             else
             {
@@ -265,9 +280,7 @@ void WorldTick()
             if (follow_target &&
                 ENTITY(follow_target)->m_flDistance() <
                     entity->m_flDistance()) // favor closer entitys
-            {
                 continue;
-            }
             // check if new target has a higher priority than current target
             if (ClassPriority(ENTITY(follow_target)) >=
                 ClassPriority(ENTITY(i)))
@@ -276,12 +289,22 @@ void WorldTick()
             if (corneractivate)
             {
                 Vector indirectOrigin =
-                    VischeckWall(LOCAL_E, entity, 250,
+                    VischeckCorner(LOCAL_E, entity, 500,
                                  true); // get the corner location that the
                                         // future target is visible from
-                if (!indirectOrigin.z)  // if we couldn't find it, exit
-                    continue;
-                addCrumbs(entity, indirectOrigin);
+                std::pair<Vector, Vector> corners;
+                if (!indirectOrigin.z && entity->m_IDX == lastent)  // if we couldn't find it, run wallcheck instead
+                {
+                	corners = VischeckWall(LOCAL_E, entity, 500, true);
+                	if (!corners.first.z || !corners.second.z)
+                		continue;
+                	addCrumbs(LOCAL_E, corners.first);
+                	addCrumbs(entity, corners.second);
+                }
+                if (indirectOrigin.z)
+                	addCrumbs(entity, indirectOrigin);
+                else if (!indirectOrigin.z && !corners.first.z)
+                	continue;
             }
             else
             {
diff --git a/src/helpers.cpp b/src/helpers.cpp
index 005c9a90..b584e9a6 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -108,7 +108,7 @@ void WalkTo(const Vector &vector)
 
 // Function to get the corner location that a vischeck to an entity is possible
 // from
-Vector VischeckWall(CachedEntity *player, CachedEntity *target, float maxdist,
+Vector VischeckCorner(CachedEntity *player, CachedEntity *target, float maxdist,
                     bool checkWalkable)
 {
     int maxiterations = maxdist / 40;
@@ -165,6 +165,91 @@ Vector VischeckWall(CachedEntity *player, CachedEntity *target, float maxdist,
     return { 0, 0, 0 };
 }
 
+// return Two Corners that connect perfectly to ent and local player
+std::pair<Vector,Vector> VischeckWall(CachedEntity *player, CachedEntity *target, float maxdist,
+                    bool checkWalkable)
+{
+    int maxiterations = maxdist / 40;
+    Vector origin     = player->m_vecOrigin();
+
+    // if we can see an entity, we don't need to run calculations
+    if (VisCheckEntFromEnt(player, target))
+    {
+    	std::pair<Vector, Vector> orig(origin, origin);
+        if (!checkWalkable)
+            return orig;
+        else if (canReachVector(origin, target->m_vecOrigin()))
+            return orig;
+    }
+
+    for (int i = 0; i < 4; i++) // for loop for all 4 directions
+    {
+        // 40 * maxiterations = range in HU
+        for (int j = 0; j < maxiterations; j++)
+        {
+            Vector virtualOrigin = origin;
+            // what direction to go in
+            switch (i)
+            {
+            case 0:
+                virtualOrigin.x = virtualOrigin.x + 40 * (j + 1);
+                break;
+            case 1:
+                virtualOrigin.x = virtualOrigin.x - 40 * (j + 1);
+                break;
+            case 2:
+                virtualOrigin.y = virtualOrigin.y + 40 * (j + 1);
+                break;
+            case 3:
+                virtualOrigin.y = virtualOrigin.y - 40 * (j + 1);
+                break;
+            }
+            // check if player can see the players virtualOrigin
+            if (!IsVectorVisible(origin, virtualOrigin, true))
+                continue;
+            for (int i = 0; i < 4; i++) // for loop for all 4 directions
+            {
+                // 40 * maxiterations = range in HU
+                for (int j = 0; j < maxiterations; j++)
+                {
+                    Vector virtualOrigin2 = origin;
+                    // what direction to go in
+                    switch (i)
+                    {
+                    case 0:
+                        virtualOrigin2.x = virtualOrigin2.x + 40 * (j + 1);
+                        break;
+                    case 1:
+                        virtualOrigin2.x = virtualOrigin2.x - 40 * (j + 1);
+                        break;
+                    case 2:
+                        virtualOrigin2.y = virtualOrigin2.y + 40 * (j + 1);
+                        break;
+                    case 3:
+                        virtualOrigin2.y = virtualOrigin2.y - 40 * (j + 1);
+                        break;
+                    }
+                    // check if the virtualOrigin2 can see the target
+                    if (!VisCheckEntFromEntVector(virtualOrigin2, player, target))
+                        continue;
+                    if (!IsVectorVisible(virtualOrigin, virtualOrigin2, true))
+                        continue;
+                    std::pair<Vector, Vector> toret(virtualOrigin, virtualOrigin2);
+                    if (!checkWalkable)
+                        return toret;
+                    // check if the location is accessible
+                    if (!canReachVector(origin, virtualOrigin) || !canReachVector(target->m_vecOrigin(), virtualOrigin2))
+                        continue;
+                    if (canReachVector(virtualOrigin, target->m_vecOrigin()))
+                        return toret;
+                }
+            }
+        }
+    }
+    // if we didn't find anything, return an empty Vector
+    return { {0, 0, 0}, {0, 0, 0} };
+}
+
 // Returns a vectors max value. For example: {123,-150, 125} = 125
 float vectorMax(Vector i)
 {
@@ -649,8 +734,7 @@ bool IsEntityVectorVisible(CachedEntity *entity, Vector endpos)
             g_ITrace->TraceRay(ray, MASK_SHOT_HULL, &trace::filter_default,
                                &trace_object);
     }
-    return (trace_object.fraction >= 0.99f ||
-            (((IClientEntity *) trace_object.m_pEnt)) == RAW_ENT(entity));
+    return (((IClientEntity *) trace_object.m_pEnt) == RAW_ENT(entity) || trace_object.fraction >= 0.99f);
 }
 
 // For when you need to vis check something that isnt the local player

From 0057c1c74d441e159b6c555776a882368d6b165f Mon Sep 17 00:00:00 2001
From: LightCat <BenCat07@gmail.com>
Date: Sat, 21 Jul 2018 21:38:05 +0200
Subject: [PATCH 09/20] MOre wallcheck stuff

---
 src/hacks/FollowBot.cpp | 15 ++++++++-------
 src/helpers.cpp         |  6 +++---
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/hacks/FollowBot.cpp b/src/hacks/FollowBot.cpp
index 20fe0da6..0f213ea6 100644
--- a/src/hacks/FollowBot.cpp
+++ b/src/hacks/FollowBot.cpp
@@ -35,8 +35,7 @@ CatCommand follow_steam("fb_steam", "Follow Steam Id",
                                 steamid = 0x0;
                                 return;
                             }
-                            unsigned tempid = atol(args.Arg(1));
-                            steamid         = *(unsigned int *) &tempid;
+                            steamid = atol(args.Arg(1));
 
                         });
 static CatVar mimic_slot(CV_SWITCH, "fb_mimic_slot", "0", "Mimic weapon slot",
@@ -198,9 +197,6 @@ void WorldTick()
 
             if (!entity->m_bAlivePlayer()) // Dont follow dead players
                 continue;
-            lastent++;
-            if (lastent > g_IEngine->GetMaxClients())
-            	lastent = 0;
             if (corneractivate)
             {
                 Vector indirectOrigin =
@@ -290,13 +286,15 @@ void WorldTick()
             if (corneractivate)
             {
                 Vector indirectOrigin =
-                    VischeckCorner(LOCAL_E, entity, 500,
+                    VischeckCorner(LOCAL_E, entity, 250,
                                  true); // get the corner location that the
                                         // future target is visible from
                 std::pair<Vector, Vector> corners;
+                corners.first.z = 0;
+                corners.second.z = 0;
                 if (!indirectOrigin.z && entity->m_IDX == lastent)  // if we couldn't find it, run wallcheck instead
                 {
-                	corners = VischeckWall(LOCAL_E, entity, 500, true);
+                	corners = VischeckWall(LOCAL_E, entity, 250, true);
                 	if (!corners.first.z || !corners.second.z)
                 		continue;
                 	addCrumbs(LOCAL_E, corners.first);
@@ -318,6 +316,9 @@ void WorldTick()
             afkTicks[i].update(); // set afk time to 0
         }
     }
+    lastent++;
+    if (lastent > g_IEngine->GetMaxClients())
+    	lastent = 0;
     // last check for entity before we continue
     if (!follow_target)
         return;
diff --git a/src/helpers.cpp b/src/helpers.cpp
index fd1b718d..79b5feb3 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -212,7 +212,7 @@ std::pair<Vector,Vector> VischeckWall(CachedEntity *player, CachedEntity *target
                 // 40 * maxiterations = range in HU
                 for (int j = 0; j < maxiterations; j++)
                 {
-                    Vector virtualOrigin2 = origin;
+                    Vector virtualOrigin2 = target->m_vecOrigin();
                     // what direction to go in
                     switch (i)
                     {
@@ -238,9 +238,9 @@ std::pair<Vector,Vector> VischeckWall(CachedEntity *player, CachedEntity *target
                     if (!checkWalkable)
                         return toret;
                     // check if the location is accessible
-                    if (!canReachVector(origin, virtualOrigin) || !canReachVector(target->m_vecOrigin(), virtualOrigin2))
+                    if (!canReachVector(origin, virtualOrigin) || !canReachVector(virtualOrigin2, virtualOrigin) || !canReachVector(target->m_vecOrigin(), virtualOrigin2))
                         continue;
-                    if (canReachVector(virtualOrigin, target->m_vecOrigin()))
+                    if (canReachVector(virtualOrigin2, target->m_vecOrigin()))
                         return toret;
                 }
             }

From f956909c02f16220de7a05e15d699227c7a0be06 Mon Sep 17 00:00:00 2001
From: LightCat <BenCat07@gmail.com>
Date: Sun, 22 Jul 2018 12:45:17 +0200
Subject: [PATCH 10/20] press a to be gay today

---
 src/hacks/FollowBot.cpp | 4 ++--
 src/helpers.cpp         | 6 ++++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/hacks/FollowBot.cpp b/src/hacks/FollowBot.cpp
index 0f213ea6..b9c2b550 100644
--- a/src/hacks/FollowBot.cpp
+++ b/src/hacks/FollowBot.cpp
@@ -200,13 +200,13 @@ void WorldTick()
             if (corneractivate)
             {
                 Vector indirectOrigin =
-                    VischeckCorner(LOCAL_E, entity, 500,
+                    VischeckCorner(LOCAL_E, entity, float(follow_activation) / 2,
                                  true); // get the corner location that the
                                         // future target is visible from
                 std::pair<Vector, Vector> corners;
                 if (!indirectOrigin.z && entity->m_IDX == lastent)  // if we couldn't find it, run wallcheck instead
                 {
-                	corners = VischeckWall(LOCAL_E, entity, 500, true);
+                	corners = VischeckWall(LOCAL_E, entity, float(follow_activation) / 2, true);
                 	if (!corners.first.z || !corners.second.z)
                 		continue;
                 	addCrumbs(LOCAL_E, corners.first);
diff --git a/src/helpers.cpp b/src/helpers.cpp
index 79b5feb3..3e514429 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -175,7 +175,7 @@ std::pair<Vector,Vector> VischeckWall(CachedEntity *player, CachedEntity *target
     // if we can see an entity, we don't need to run calculations
     if (VisCheckEntFromEnt(player, target))
     {
-    	std::pair<Vector, Vector> orig(origin, origin);
+    	std::pair<Vector, Vector> orig(origin, target->m_vecOrigin());
         if (!checkWalkable)
             return orig;
         else if (canReachVector(origin, target->m_vecOrigin()))
@@ -234,11 +234,13 @@ std::pair<Vector,Vector> VischeckWall(CachedEntity *player, CachedEntity *target
                         continue;
                     if (!IsVectorVisible(virtualOrigin, virtualOrigin2, true))
                         continue;
+                    if (!IsVectorVisible(virtualOrigin2, target->m_vecOrigin(), true))
+                    	continue;
                     std::pair<Vector, Vector> toret(virtualOrigin, virtualOrigin2);
                     if (!checkWalkable)
                         return toret;
                     // check if the location is accessible
-                    if (!canReachVector(origin, virtualOrigin) || !canReachVector(virtualOrigin2, virtualOrigin) || !canReachVector(target->m_vecOrigin(), virtualOrigin2))
+                    if (!canReachVector(origin, virtualOrigin) || !canReachVector(virtualOrigin2, virtualOrigin))
                         continue;
                     if (canReachVector(virtualOrigin2, target->m_vecOrigin()))
                         return toret;

From fc2d1885b76fc493feaace88a75d1bebe459793a Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Sun, 22 Jul 2018 16:42:32 +0200
Subject: [PATCH 11/20] M0r3 W411CH3CK 57uff

---
 src/hacks/FollowBot.cpp | 65 ++++++++++++++++++++++++++++++++--------
 src/helpers.cpp         | 66 ++++++++++++++++++++++++++++++++++++-----
 2 files changed, 111 insertions(+), 20 deletions(-)

diff --git a/src/hacks/FollowBot.cpp b/src/hacks/FollowBot.cpp
index b9c2b550..be04d8d7 100644
--- a/src/hacks/FollowBot.cpp
+++ b/src/hacks/FollowBot.cpp
@@ -117,6 +117,43 @@ void addCrumbs(CachedEntity *target, Vector corner = g_pLocalPlayer->v_Origin)
             corner + dist / vectorMax(vectorAbs(dist)) * 40.0f * (i + 1));
     }
 }
+
+void addCrumbPair(CachedEntity *player1, CachedEntity *player2,
+                  std::pair<Vector, Vector> corners)
+{
+    Vector corner1 = corners.first;
+    Vector corner2 = corners.second;
+
+    {
+        Vector dist       = corner1 - player1->m_vecOrigin();
+        int maxiterations = floor(corner1.DistTo(player1->m_vecOrigin())) / 40;
+        for (int i = 0; i < maxiterations; i++)
+        {
+            breadcrumbs.push_back(player1->m_vecOrigin() +
+                                  dist / vectorMax(vectorAbs(dist)) * 40.0f *
+                                      (i + 1));
+        }
+    }
+    {
+        Vector dist       = corner2 - corner1;
+        int maxiterations = floor(corner2.DistTo(corner1)) / 40;
+        for (int i = 0; i < maxiterations; i++)
+        {
+            breadcrumbs.push_back(corner1 + dist / vectorMax(vectorAbs(dist)) *
+                                                40.0f * (i + 1));
+        }
+    }
+    {
+        Vector dist       = player2->m_vecOrigin() - corner2;
+        int maxiterations = floor(corner2.DistTo(player2->m_vecOrigin())) / 40;
+        for (int i = 0; i < maxiterations; i++)
+        {
+            breadcrumbs.push_back(corner2 + dist / vectorMax(vectorAbs(dist)) *
+                                                40.0f * (i + 1));
+        }
+    }
+}
+
 int ClassPriority(CachedEntity *ent)
 {
     switch (g_pPlayerResource->GetClass(ent))
@@ -209,8 +246,9 @@ void WorldTick()
                 	corners = VischeckWall(LOCAL_E, entity, float(follow_activation) / 2, true);
                 	if (!corners.first.z || !corners.second.z)
                 		continue;
-                	addCrumbs(LOCAL_E, corners.first);
-                	addCrumbs(entity, corners.second);
+                    //addCrumbs(LOCAL_E, corners.first);
+                    //addCrumbs(entity, corners.second);
+                    addCrumbPair(LOCAL_E, entity, corners);
                 }
                 if (indirectOrigin.z)
                 	addCrumbs(entity, indirectOrigin);
@@ -287,23 +325,24 @@ void WorldTick()
             {
                 Vector indirectOrigin =
                     VischeckCorner(LOCAL_E, entity, 250,
-                                 true); // get the corner location that the
-                                        // future target is visible from
+                                   true); // get the corner location that the
+                                          // future target is visible from
                 std::pair<Vector, Vector> corners;
-                corners.first.z = 0;
+                corners.first.z  = 0;
                 corners.second.z = 0;
-                if (!indirectOrigin.z && entity->m_IDX == lastent)  // if we couldn't find it, run wallcheck instead
+                if (!indirectOrigin.z &&
+                    entity->m_IDX == lastent) // if we couldn't find it, run
+                                              // wallcheck instead
                 {
-                	corners = VischeckWall(LOCAL_E, entity, 250, true);
-                	if (!corners.first.z || !corners.second.z)
-                		continue;
-                	addCrumbs(LOCAL_E, corners.first);
-                	addCrumbs(entity, corners.second);
+                    corners = VischeckWall(LOCAL_E, entity, 250, true);
+                    if (!corners.first.z || !corners.second.z)
+                        continue;
+                    addCrumbPair(LOCAL_E, entity, corners);
                 }
                 if (indirectOrigin.z)
-                	addCrumbs(entity, indirectOrigin);
+                    addCrumbs(entity, indirectOrigin);
                 else if (!indirectOrigin.z && !corners.first.z)
-                	continue;
+                    continue;
             }
             else
             {
diff --git a/src/helpers.cpp b/src/helpers.cpp
index 3e514429..ca0630a6 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -123,7 +123,7 @@ Vector VischeckCorner(CachedEntity *player, CachedEntity *target, float maxdist,
             return origin;
     }
 
-    for (int i = 0; i < 4; i++) // for loop for all 4 directions
+    for (int i = 0; i < 8; i++) // for loop for all 4 directions
     {
         // 40 * maxiterations = range in HU
         for (int j = 0; j < maxiterations; j++)
@@ -144,6 +144,22 @@ Vector VischeckCorner(CachedEntity *player, CachedEntity *target, float maxdist,
             case 3:
                 virtualOrigin.y = virtualOrigin.y - 40 * (j + 1);
                 break;
+            case 4:
+                virtualOrigin.x = virtualOrigin.x + 20 * (j + 1);
+                virtualOrigin.y = virtualOrigin.y + 20 * (j + 1);
+                break;
+            case 5:
+                virtualOrigin.x = virtualOrigin.x - 20 * (j + 1);
+                virtualOrigin.y = virtualOrigin.y - 20 * (j + 1);
+                break;
+            case 6:
+                virtualOrigin.x = virtualOrigin.x - 20 * (j + 1);
+                virtualOrigin.y = virtualOrigin.y + 20 * (j + 1);
+                break;
+            case 7:
+                virtualOrigin.x = virtualOrigin.x + 20 * (j + 1);
+                virtualOrigin.y = virtualOrigin.y - 20 * (j + 1);
+                break;
             }
             // check if player can see the players virtualOrigin
             if (!IsVectorVisible(origin, virtualOrigin, true))
@@ -182,7 +198,7 @@ std::pair<Vector,Vector> VischeckWall(CachedEntity *player, CachedEntity *target
             return orig;
     }
 
-    for (int i = 0; i < 4; i++) // for loop for all 4 directions
+    for (int i = 0; i < 8; i++) // for loop for all 4 directions
     {
         // 40 * maxiterations = range in HU
         for (int j = 0; j < maxiterations; j++)
@@ -203,11 +219,27 @@ std::pair<Vector,Vector> VischeckWall(CachedEntity *player, CachedEntity *target
             case 3:
                 virtualOrigin.y = virtualOrigin.y - 40 * (j + 1);
                 break;
+            case 4:
+                virtualOrigin.x = virtualOrigin.x + 20 * (j + 1);
+                virtualOrigin.y = virtualOrigin.y + 20 * (j + 1);
+                break;
+            case 5:
+                virtualOrigin.x = virtualOrigin.x - 20 * (j + 1);
+                virtualOrigin.y = virtualOrigin.y - 20 * (j + 1);
+                break;
+            case 6:
+                virtualOrigin.x = virtualOrigin.x - 20 * (j + 1);
+                virtualOrigin.y = virtualOrigin.y + 20 * (j + 1);
+                break;
+            case 7:
+                virtualOrigin.x = virtualOrigin.x + 20 * (j + 1);
+                virtualOrigin.y = virtualOrigin.y - 20 * (j + 1);
+                break;
             }
             // check if player can see the players virtualOrigin
             if (!IsVectorVisible(origin, virtualOrigin, true))
                 continue;
-            for (int i = 0; i < 4; i++) // for loop for all 4 directions
+            for (int i = 0; i < 8; i++) // for loop for all 4 directions
             {
                 // 40 * maxiterations = range in HU
                 for (int j = 0; j < maxiterations; j++)
@@ -228,14 +260,34 @@ std::pair<Vector,Vector> VischeckWall(CachedEntity *player, CachedEntity *target
                     case 3:
                         virtualOrigin2.y = virtualOrigin2.y - 40 * (j + 1);
                         break;
+                    case 4:
+                        virtualOrigin2.x = virtualOrigin2.x + 20 * (j + 1);
+                        virtualOrigin2.y = virtualOrigin2.y + 20 * (j + 1);
+                        break;
+                    case 5:
+                        virtualOrigin2.x = virtualOrigin2.x - 20 * (j + 1);
+                        virtualOrigin2.y = virtualOrigin2.y - 20 * (j + 1);
+                        break;
+                    case 6:
+                        virtualOrigin2.x = virtualOrigin2.x - 20 * (j + 1);
+                        virtualOrigin2.y = virtualOrigin2.y + 20 * (j + 1);
+                        break;
+                    case 7:
+                        virtualOrigin2.x = virtualOrigin2.x + 20 * (j + 1);
+                        virtualOrigin2.y = virtualOrigin2.y - 20 * (j + 1);
+                        break;
                     }
                     // check if the virtualOrigin2 can see the target
-                    if (!VisCheckEntFromEntVector(virtualOrigin2, player, target))
-                        continue;
+//                    if (!VisCheckEntFromEntVector(virtualOrigin2, player, target))
+//                        continue;
+//                    if (!IsVectorVisible(virtualOrigin, virtualOrigin2, true))
+//                        continue;
+//                    if (!IsVectorVisible(virtualOrigin2, target->m_vecOrigin(), true))
+//                    	continue;
                     if (!IsVectorVisible(virtualOrigin, virtualOrigin2, true))
                         continue;
-                    if (!IsVectorVisible(virtualOrigin2, target->m_vecOrigin(), true))
-                    	continue;
+                    if (!IsVectorVisible(virtualOrigin2, target->m_vecOrigin()))
+                        continue;
                     std::pair<Vector, Vector> toret(virtualOrigin, virtualOrigin2);
                     if (!checkWalkable)
                         return toret;

From 39929fc869f22639c277a4b6e391e9d24e29b6b1 Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Sun, 29 Jul 2018 11:51:09 +0200
Subject: [PATCH 12/20] Fix lucksman aimbot

---
 src/hacks/SpyAlert.cpp |  1 +
 src/helpers.cpp        | 11 ++++++-----
 2 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/hacks/SpyAlert.cpp b/src/hacks/SpyAlert.cpp
index f019a96d..fa69e31f 100644
--- a/src/hacks/SpyAlert.cpp
+++ b/src/hacks/SpyAlert.cpp
@@ -35,6 +35,7 @@ Timer lastVoicemenu{};
 
 void Draw()
 {
+    PROF_SECTION(DRAW_SpyAlert)
     if (!enabled)
         return;
     CachedEntity *closest_spy, *ent;
diff --git a/src/helpers.cpp b/src/helpers.cpp
index ca0630a6..ccd689aa 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -1006,11 +1006,12 @@ bool GetProjectileData(CachedEntity *weapon, float &speed, float &gravity)
     else if (classid == CL_CLASS(CTFCompoundBow))
     {
         float chargetime =
-            g_GlobalVars->curtime * g_GlobalVars->interval_per_tick -
-            CE_FLOAT(weapon, netvar.flChargeBeginTime) *
-                g_GlobalVars->interval_per_tick;
-        rspeed = (fminf(fmaxf(chargetime, 0.0f), 1.0f) * 800.0f) + 1800.0f;
-        rgrav  = (fminf(fmaxf(chargetime, 0.0f), 1.0f) * -0.40000001f) + 0.5f;
+            g_GlobalVars->curtime - CE_FLOAT(weapon, netvar.flChargeBeginTime);
+        rspeed = (float) ((float) (fminf(fmaxf(chargetime, 0.0), 1.0) * 800.0) +
+                          1800.0);
+        rgrav  = (float) ((float) (fminf(fmaxf(chargetime, 0.0), 1.0) *
+                                  -0.40000001) +
+                         0.5);
     }
     else if (classid == CL_CLASS(CTFBat_Wood))
     {

From 0249521086ca0fc92572e8e32f979679a5b09833 Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Mon, 30 Jul 2018 12:32:13 +0200
Subject: [PATCH 13/20] switch tf

---
 src/helpers.cpp        | 57 +++++++++++++++++++++++++++++-------------
 src/visual/drawing.cpp |  1 -
 2 files changed, 40 insertions(+), 18 deletions(-)

diff --git a/src/helpers.cpp b/src/helpers.cpp
index d8211af8..358cf41f 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -968,8 +968,6 @@ bool LineIntersectsBox(Vector &bmin, Vector &bmax, Vector &lmin, Vector &lmax)
     return true;
 }
 
-// TODO add bison and grapple hook
-// TODO FIX this function
 bool GetProjectileData(CachedEntity *weapon, float &speed, float &gravity)
 {
     float rspeed, rgrav;
@@ -982,16 +980,20 @@ bool GetProjectileData(CachedEntity *weapon, float &speed, float &gravity)
     rgrav  = 0.0f;
     typedef float(GetProjectileData)(IClientEntity *);
 
-    int classid = weapon->m_iClassID();
-    if (classid == CL_CLASS(CTFRocketLauncher_DirectHit))
+
+    switch (weapon->m_iClassID())
+    {
+    case CL_CLASS(CTFRocketLauncher_DirectHit):
     {
         rspeed = 1980.0f;
+        break;
     }
-    else if (classid == CL_CLASS(CTFRocketLauncher))
+    case CL_CLASS(CTFRocketLauncher):
     {
         rspeed = 1100.0f;
+        break;
     }
-    else if (classid == CL_CLASS(CTFGrenadeLauncher))
+    case CL_CLASS(CTFGrenadeLauncher):
     {
         IF_GAME(IsTF2())
         {
@@ -1003,8 +1005,9 @@ bool GetProjectileData(CachedEntity *weapon, float &speed, float &gravity)
             rspeed = 1100.0f;
             rgrav  = 0.5f;
         }
+        break;
     }
-    else if (classid == CL_CLASS(CTFPipebombLauncher))
+    case CL_CLASS(CTFPipebombLauncher):
     {
         float chargebegin = *((float *) ((unsigned) RAW_ENT(LOCAL_W) + 3152));
         float chargetime  = g_GlobalVars->curtime - chargebegin;
@@ -1012,8 +1015,9 @@ bool GetProjectileData(CachedEntity *weapon, float &speed, float &gravity)
             (fminf(fmaxf(chargetime / 4.0f, 0.0f), 1.0f) * 1500.0f) + 900.0f;
         rgrav =
             (fminf(fmaxf(chargetime / 4.0f, 0.0f), 1.0f) * -0.70000001f) + 0.5f;
+        break;
     }
-    else if (classid == CL_CLASS(CTFCompoundBow))
+    case CL_CLASS(CTFCompoundBow):
     {
         float chargetime =
             g_GlobalVars->curtime - CE_FLOAT(weapon, netvar.flChargeBeginTime);
@@ -1022,41 +1026,60 @@ bool GetProjectileData(CachedEntity *weapon, float &speed, float &gravity)
         rgrav  = (float) ((float) (fminf(fmaxf(chargetime, 0.0), 1.0) *
                                   -0.40000001) +
                          0.5);
+        break;
     }
-    else if (classid == CL_CLASS(CTFBat_Wood))
+    case CL_CLASS(CTFBat_Wood):
     {
         rspeed = 3000.0f;
         rgrav  = 0.5f;
+        break;
     }
-    else if (classid == CL_CLASS(CTFFlareGun))
+    case CL_CLASS(CTFFlareGun):
     {
         rspeed = 2000.0f;
         rgrav  = 0.25f;
+        break;
     }
-    else if (classid == CL_CLASS(CTFSyringeGun))
+    case CL_CLASS(CTFSyringeGun):
     {
         rgrav  = 0.2f;
         rspeed = 990.0f;
+        break;
     }
-    else if (classid == CL_CLASS(CTFCrossbow))
+    case CL_CLASS(CTFCrossbow):
     {
         rgrav  = 0.2f;
         rspeed = 2400.0f;
+        break;
     }
-    else if (classid == CL_CLASS(CTFShotgunBuildingRescue))
+    case CL_CLASS(CTFShotgunBuildingRescue):
     {
         rgrav  = 0.2f;
         rspeed = 2400.0f;
+        break;
     }
-    else if (classid == CL_CLASS(CTFDRGPomson))
+    case CL_CLASS(CTFDRGPomson):
     {
         rspeed = 1200.0f;
+        break;
     }
-    else if (classid == CL_CLASS(CTFWeaponFlameBall))
+    case CL_CLASS(CTFWeaponFlameBall):
     {
-        // ??
-        rspeed = 2500.0f;
+        rspeed = 3000.0f;
+        break;
     }
+    case CL_CLASS(CTFRaygun):
+    {
+        rspeed = 1200.0f;
+        break;
+    }
+    case CL_CLASS(CTFGrapplingHook):
+    {
+        rspeed = 1500.0f;
+        break;
+    }
+    }
+
     speed   = rspeed;
     gravity = rgrav;
     return (rspeed || rgrav);
diff --git a/src/visual/drawing.cpp b/src/visual/drawing.cpp
index b5657925..3d13d8dd 100644
--- a/src/visual/drawing.cpp
+++ b/src/visual/drawing.cpp
@@ -70,7 +70,6 @@ void AddCenterString(const std::string &string, const rgba_t &color)
     ++center_strings_count;
 }
 
-// TODO globals
 int draw::width  = 0;
 int draw::height = 0;
 float draw::fov  = 90.0f;

From 155af2ebb7dc04dfdc515757e22eb2ee1309b923 Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Mon, 30 Jul 2018 18:59:45 +0200
Subject: [PATCH 14/20] ToDo

---
 include/helpers.hpp       |  1 -
 src/entityhitboxcache.cpp |  2 +-
 src/hacks/AutoHeal.cpp    |  6 +++++-
 src/hacks/Walkbot.cpp     |  1 -
 src/helpers.cpp           | 27 +++++++--------------------
 5 files changed, 13 insertions(+), 24 deletions(-)

diff --git a/include/helpers.hpp b/include/helpers.hpp
index c8bf44a1..ee20e429 100644
--- a/include/helpers.hpp
+++ b/include/helpers.hpp
@@ -98,7 +98,6 @@ std::unique_ptr<char[]> strfmt(const char *fmt, ...);
 // TODO move that to weaponid.h
 bool HasWeapon(CachedEntity *ent, int wantedId);
 bool IsAmbassador(CachedEntity *ent);
-bool HasDarwins(CachedEntity *ent);
 bool AmbassadorCanHeadshot();
 
 inline const char *teamname(int team)
diff --git a/src/entityhitboxcache.cpp b/src/entityhitboxcache.cpp
index c0324ad4..99a2fcd3 100644
--- a/src/entityhitboxcache.cpp
+++ b/src/entityhitboxcache.cpp
@@ -111,7 +111,7 @@ static CatVar setupbones_time(
     setupbones_time_enum, "setupbones_time", "3", "Setupbones",
     "Defines setupbones 4th argument, change it if your aimbot misses, idk!!");
 
-std::mutex setupbones_mutex;
+static std::mutex setupbones_mutex;
 
 matrix3x4_t *EntityHitboxCache::GetBones()
 {
diff --git a/src/hacks/AutoHeal.cpp b/src/hacks/AutoHeal.cpp
index 769c538f..2491cfab 100644
--- a/src/hacks/AutoHeal.cpp
+++ b/src/hacks/AutoHeal.cpp
@@ -71,7 +71,11 @@ int BulletDangerValue(CachedEntity *patient)
         any_zoomed_snipers = true;
         // TODO VisCheck from patient.
         if ((int) vacc_sniper == 1)
-            if (!IsEntityVisible(ent, head))
+            if (!IsEntityVisible(ent, head) &&
+                !IsVectorVisible(ENTITY(m_iCurrentHealingTarget)
+                                     ->hitboxes.GetHitbox(head)
+                                     ->center,
+                                 ent->hitboxes.GetHitbox(head)->center, true))
                 continue;
         return vacc_sniper ? 2 : 1;
     }
diff --git a/src/hacks/Walkbot.cpp b/src/hacks/Walkbot.cpp
index 8cc83e8e..6d2fb256 100644
--- a/src/hacks/Walkbot.cpp
+++ b/src/hacks/Walkbot.cpp
@@ -841,7 +841,6 @@ index_t SelectNextNode()
         return FindNearestNode(true);
     }
     auto &n = state::nodes[state::active_node];
-    // TODO medkit connections and shit
     std::vector<index_t> chance{};
     for (index_t i = 0; i < MAX_CONNECTIONS; i++)
     {
diff --git a/src/helpers.cpp b/src/helpers.cpp
index 358cf41f..6aeb91d6 100644
--- a/src/helpers.cpp
+++ b/src/helpers.cpp
@@ -544,20 +544,6 @@ bool HasWeapon(CachedEntity *ent, int wantedId)
     return false;
 }
 
-bool HasDarwins(CachedEntity *ent)
-{
-    if (CE_BAD(ent))
-        return false;
-    // Check if player is sniper
-    if (CE_INT(ent, netvar.iClass) != tf_sniper)
-        return false;
-    // Check if player is using darwins, 231 is the id for darwins danger sheild
-    if (HasWeapon(ent, 231))
-        return true;
-    // Else return false
-    return false;
-}
-
 void VectorTransform(const float *in1, const matrix3x4_t &in2, float *out)
 {
     out[0] = (in1[0] * in2[0][0] + in1[1] * in2[0][1] + in1[2] * in2[0][2]) +
@@ -724,7 +710,6 @@ float RandFloatRange(float min, float max)
 
 bool IsEntityVisible(CachedEntity *entity, int hb)
 {
-    Vector hit;
     if (g_Settings.bInvalid)
         return false;
     if (entity == g_pLocalPlayer->entity)
@@ -936,7 +921,10 @@ weaponmode GetWeaponMode()
              classid == CL_CLASS(CTFSyringeGun) ||
              classid == CL_CLASS(CTFCrossbow) ||
              classid == CL_CLASS(CTFShotgunBuildingRescue) ||
-             classid == CL_CLASS(CTFDRGPomson))
+             classid == CL_CLASS(CTFDRGPomson) ||
+             classid == CL_CLASS(CTFWeaponFlameBall) ||
+             classid == CL_CLASS(CTFRaygun) ||
+             classid == CL_CLASS(CTFGrapplingHook))
     {
         return weaponmode::weapon_projectile;
     }
@@ -1382,10 +1370,9 @@ void PrintChat(const char *fmt, ...)
         va_start(list, fmt);
         vsprintf(buf.get(), fmt, list);
         va_end(list);
-        std::unique_ptr<char> str(strfmt("\x07%06X[\x07%06XCAT\x07%06X]\x01 %s",
-                                         0x5e3252, 0xba3d9a, 0x5e3252,
-                                         buf.get())
-                                      .release());
+        std::unique_ptr<char[]> str =
+            std::move(strfmt("\x07%06X[\x07%06XCAT\x07%06X]\x01 %s", 0x5e3252,
+                             0xba3d9a, 0x5e3252, buf.get()));
         // FIXME DEBUG LOG
         logging::Info("%s", str.get());
         chat->Printf(str.get());

From d8806bde440341d8f140a2e4bd41468b93a0dd5d Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Tue, 31 Jul 2018 22:56:37 +0200
Subject: [PATCH 15/20] Make Autobackstab worse

---
 src/hacks/AutoBackstab.cpp | 195 +++++++------------------------------
 1 file changed, 34 insertions(+), 161 deletions(-)

diff --git a/src/hacks/AutoBackstab.cpp b/src/hacks/AutoBackstab.cpp
index 16455995..54d62356 100644
--- a/src/hacks/AutoBackstab.cpp
+++ b/src/hacks/AutoBackstab.cpp
@@ -9,188 +9,61 @@
 #include "hacks/Backtrack.hpp"
 namespace hacks::tf2::autobackstab
 {
-
-// pPaste, thanks to F1ssi0N
-const Vector GetWorldSpaceCenter(CachedEntity *ent)
-{
-    Vector vMin, vMax;
-    RAW_ENT(ent)->GetRenderBounds(vMin, vMax);
-    Vector vWorldSpaceCenter = RAW_ENT(ent)->GetAbsOrigin();
-    vWorldSpaceCenter.z += (vMin.z + vMax.z) / 2;
-    return vWorldSpaceCenter;
-}
-
 static CatVar enabled(CV_SWITCH, "autobackstab", "0", "Auto Backstab",
                       "Does not depend on triggerbot!");
-static CatVar silent(CV_SWITCH, "autobackstab_silent", "1", "Silent");
-bool found;
-std::pair<Vector, Vector> GetHitboxBounds(CachedEntity *it, int hitbox)
+
+bool canBackstab(CachedEntity *tar)
 {
-	std::pair<Vector, Vector> result(it->hitboxes.GetHitbox(hitbox)->min,it->hitboxes.GetHitbox(hitbox)->max);
-	return result;
+    float _viewangles =
+        NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles).y;
+    float viewangles =
+        (_viewangles > 180) ? _viewangles - 360 : _viewangles;
+    float scr = abs(g_pLocalPlayer->v_OrigViewangles.y - viewangles);
+    return (scr <= 90.0f);
 }
-// TODO improve
-bool CanBackstab(CachedEntity *tar, Vector Local_ang)
-{
-    if (CE_BAD(tar))
-        return false;
-    // Get the forward view vector of the target, ignore Z
-    Vector vecVictimForward = NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles);
-    vecVictimForward.z      = 0.0f;
-    vecVictimForward.NormalizeInPlace();
 
-    // Get a vector from my origin to my targets origin
-    Vector vecToTarget;
-    vecToTarget   = GetWorldSpaceCenter(tar) - GetWorldSpaceCenter(LOCAL_E);
-    vecToTarget.z = 0.0f;
-    vecToTarget.NormalizeInPlace();
-
-    // Get a forward vector of the attacker.
-    Vector vecOwnerForward = Local_ang;
-    vecOwnerForward.z      = 0.0f;
-    vecOwnerForward.NormalizeInPlace();
-
-    float flDotOwner  = DotProduct(vecOwnerForward, vecToTarget);
-    float flDotVictim = DotProduct(vecVictimForward, vecToTarget);
-
-    // Make sure they're actually facing the target.
-    // This needs to be done because lag compensation can place target slightly
-    // behind the attacker.
-    if (flDotOwner > 0.5)
-        return (flDotVictim > -0.1);
-    return false;
-}
 void CreateMove()
 {
     if (!enabled)
         return;
-    if (!CE_GOOD(LOCAL_E) || !LOCAL_E->m_bAlivePlayer() || !CE_GOOD(LOCAL_W))
-        return;
-    if (!LOCAL_E->m_bAlivePlayer())
+    if (CE_BAD(LOCAL_E) || CE_BAD(LOCAL_W) || !LOCAL_E->m_bAlivePlayer())
         return;
     if (g_pLocalPlayer->weapon()->m_iClassID() != CL_CLASS(CTFKnife))
         return;
-    int eid = -1;
-    Vector endpos;
-    ICollideable *p    = RAW_ENT(LOCAL_E)->GetCollideable();
-    const Vector &max1 = p->OBBMaxs() + RAW_ENT(LOCAL_E)->GetAbsOrigin();
-    const Vector &min1 = p->OBBMins() + RAW_ENT(LOCAL_E)->GetAbsOrigin();
-    WhatIAmLookingAt(&eid, &endpos);
-
-    CachedEntity *target = nullptr;
-    if (eid > -1)
-        target = ENTITY(eid);
-    if (CE_GOOD(target) && target != LOCAL_E &&
-        target->m_iTeam() != LOCAL_E->m_iTeam() && target->m_bAlivePlayer() &&
-        target->m_Type() == ENTITY_PLAYER &&
-        !hacks::shared::backtrack::enable &&
-        CanBackstab(target, g_pLocalPlayer->v_OrigViewangles))
+    int meleeRange = re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
+    CachedEntity *besttarget = nullptr;
+    for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
     {
-        float swingrange =
-            re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
-        const Vector &max2 = GetHitboxBounds(target, 1).second +
-                             Vector(swingrange, swingrange, swingrange);
-        const Vector &min2 = GetHitboxBounds(target, 1).first -
-                             Vector(swingrange, swingrange, swingrange);
-        if ((min1.x <= max2.x && max1.x >= min2.x) &&
-            (min1.y <= max2.y && max1.y >= min2.y) &&
-            (min1.z <= max2.z && max1.z >= min2.z))
-            g_pUserCmd->buttons |= IN_ATTACK;
-    }
-    else if (!hacks::shared::backtrack::enable)
-    {
-        CachedEntity *tar = nullptr;
-        float bestscr     = 9999.9f;
-        int bestent       = -1;
-        for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
+        CachedEntity *target = ENTITY(i);
+        if (CE_BAD(target))
+            continue;
+        if (target == LOCAL_E || target->m_iTeam() == LOCAL_E->m_iTeam() ||
+            !target->m_bAlivePlayer() || target->m_Type() != ENTITY_PLAYER)
+            continue;
+        if (target
+                ->m_vecOrigin() /*target->hitboxes.GetHitbox(spine_3)->center*/
+                .DistTo(g_pLocalPlayer->v_Eye) <= meleeRange)
         {
-            CachedEntity *tmp = ENTITY(i);
-            if (CE_BAD(tmp))
-                continue;
-            if (tmp == LOCAL_E)
-                continue;
-            if (tmp->m_iTeam() == LOCAL_E->m_iTeam())
-                continue;
-            if (!tmp->m_bAlivePlayer())
-                continue;
-            if (tmp->m_Type() != ENTITY_PLAYER)
-                continue;
-            float swingrange =
-                re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
-            ICollideable *c    = RAW_ENT(tmp)->GetCollideable();
-            const Vector &max2 = c->OBBMaxs() + tmp->m_vecOrigin() +
-                                 Vector(swingrange, swingrange, swingrange);
-            const Vector &min2 = c->OBBMins() + tmp->m_vecOrigin() -
-                                 Vector(swingrange, swingrange, swingrange);
-            if ((min1.x <= max2.x && max1.x >= min2.x) &&
-                (min1.y <= max2.y && max1.y >= min2.y) &&
-                (min1.z <= max2.z && max1.z >= min2.z) &&
-                bestscr > tmp->m_flDistance())
+            if (CE_GOOD(besttarget))
             {
-                bestent = tmp->m_IDX;
-                bestscr = tmp->m_flDistance();
+                if (target
+                        ->m_vecOrigin() /*target->hitboxes.GetHitbox(spine_3)->center*/
+                        .DistTo(g_pLocalPlayer->v_Eye) >
+                    target
+                        ->m_vecOrigin() /* besttarget->hitboxes.GetHitbox(spine_3)->center*/
+                        .DistTo(g_pLocalPlayer->v_Eye))
+                    besttarget = target;
             }
-        }
-        if (bestent > -1)
-            tar = ENTITY(bestent);
-        if (CE_BAD(tar))
-            return;
-        Vector eyeang = g_pLocalPlayer->v_OrigViewangles;
-        for (float i = -180.0f; i < 180.0f; i += 30.0f)
-        {
-            eyeang.y = i;
-            if (CanBackstab(tar, eyeang))
+            else
             {
-                g_pUserCmd->viewangles.y = eyeang.y;
-                g_pUserCmd->buttons |= IN_ATTACK;
-                if (silent)
-                    g_pLocalPlayer->bUseSilentAngles = true;
+                besttarget = target;
             }
-            break;
         }
     }
-    else
+    if (CE_GOOD(besttarget) && canBackstab(besttarget))
     {
-        if (!hacks::shared::backtrack::enable)
-            return;
-        if (hacks::shared::backtrack::iBestTarget == -1)
-            return;
-        int iBestTarget = hacks::shared::backtrack::iBestTarget;
-        int tickcnt     = 0;
-        int tickus = (float(hacks::shared::backtrack::latency) > 800.0f || float(hacks::shared::backtrack::latency) < 200.0f) ? 12 : 24;
-        for (auto i : hacks::shared::backtrack::headPositions[iBestTarget])
-        {
-            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;
-
-            float scr = abs(g_pLocalPlayer->v_OrigViewangles.y - i.viewangles);
-
-            if (scr <= 90.0f &&
-                i.origin.DistTo(g_pLocalPlayer->v_Eye) <=
-                    re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W)))
-            {
-                CachedEntity *tar = ENTITY(iBestTarget);
-                // 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;
-                simtime                = i.simtime;
-                g_pUserCmd->tick_count = i.tickcount;
-                g_pUserCmd->buttons |= IN_ATTACK;
-                break;
-            }
-        }
+        g_pUserCmd->buttons |= IN_ATTACK;
+        besttarget = nullptr;
     }
 }
 }

From a66cd9de86037ad4f8d421b630e03995ab29043c Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Tue, 31 Jul 2018 23:53:05 +0200
Subject: [PATCH 16/20] Autobackstab Rotate

---
 src/hacks/AutoBackstab.cpp | 48 +++++++++++++++++++++++++-------------
 1 file changed, 32 insertions(+), 16 deletions(-)

diff --git a/src/hacks/AutoBackstab.cpp b/src/hacks/AutoBackstab.cpp
index 54d62356..e4b50a72 100644
--- a/src/hacks/AutoBackstab.cpp
+++ b/src/hacks/AutoBackstab.cpp
@@ -11,14 +11,13 @@ namespace hacks::tf2::autobackstab
 {
 static CatVar enabled(CV_SWITCH, "autobackstab", "0", "Auto Backstab",
                       "Does not depend on triggerbot!");
+static CatVar silent(CV_SWITCH, "autobackstab_silent", "1", "Silent");
 
-bool canBackstab(CachedEntity *tar)
+bool canBackstab(CachedEntity *tar, float angleY)
 {
-    float _viewangles =
-        NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles).y;
-    float viewangles =
-        (_viewangles > 180) ? _viewangles - 360 : _viewangles;
-    float scr = abs(g_pLocalPlayer->v_OrigViewangles.y - viewangles);
+    float _viewangles = NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles).y;
+    float viewangles  = (_viewangles > 180) ? _viewangles - 360 : _viewangles;
+    float scr         = abs(angleY - viewangles);
     return (scr <= 90.0f);
 }
 
@@ -30,6 +29,7 @@ void CreateMove()
         return;
     if (g_pLocalPlayer->weapon()->m_iClassID() != CL_CLASS(CTFKnife))
         return;
+    // Get melee range of knife
     int meleeRange = re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
     CachedEntity *besttarget = nullptr;
     for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
@@ -40,18 +40,15 @@ void CreateMove()
         if (target == LOCAL_E || target->m_iTeam() == LOCAL_E->m_iTeam() ||
             !target->m_bAlivePlayer() || target->m_Type() != ENTITY_PLAYER)
             continue;
-        if (target
-                ->m_vecOrigin() /*target->hitboxes.GetHitbox(spine_3)->center*/
-                .DistTo(g_pLocalPlayer->v_Eye) <= meleeRange)
+        if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
+                g_pLocalPlayer->v_Eye) <= meleeRange)
         {
             if (CE_GOOD(besttarget))
             {
-                if (target
-                        ->m_vecOrigin() /*target->hitboxes.GetHitbox(spine_3)->center*/
-                        .DistTo(g_pLocalPlayer->v_Eye) >
-                    target
-                        ->m_vecOrigin() /* besttarget->hitboxes.GetHitbox(spine_3)->center*/
-                        .DistTo(g_pLocalPlayer->v_Eye))
+                if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
+                        g_pLocalPlayer->v_Eye) >
+                    besttarget->hitboxes.GetHitbox(spine_3)->center.DistTo(
+                        g_pLocalPlayer->v_Eye))
                     besttarget = target;
             }
             else
@@ -60,10 +57,29 @@ void CreateMove()
             }
         }
     }
-    if (CE_GOOD(besttarget) && canBackstab(besttarget))
+    if (CE_GOOD(besttarget))
     {
+        if (canBackstab(besttarget, g_pLocalPlayer->v_OrigViewangles.y))
+        {
         g_pUserCmd->buttons |= IN_ATTACK;
         besttarget = nullptr;
+        return;
+        }
+        else
+        {
+            for (float i = -180.0f; i < 180.0f; i += 30.0f)
+            {
+                if (canBackstab(besttarget, i))
+                {
+                    g_pUserCmd->viewangles.y = i;
+                    g_pUserCmd->buttons |= IN_ATTACK;
+                    besttarget = nullptr;
+                    if (silent)
+                        g_pLocalPlayer->bUseSilentAngles = true;
+                    return;
+                }
+            }
+        }
     }
 }
 }

From 607a72878d81d708341f514a96cc513f07c02ad1 Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Wed, 1 Aug 2018 15:19:59 +0200
Subject: [PATCH 17/20] Make AutoBackstab bad again

---
 src/hacks/AutoBackstab.cpp | 57 ++++++++++++++++++++++++++++++++------
 1 file changed, 49 insertions(+), 8 deletions(-)

diff --git a/src/hacks/AutoBackstab.cpp b/src/hacks/AutoBackstab.cpp
index e4b50a72..04d4d0ce 100644
--- a/src/hacks/AutoBackstab.cpp
+++ b/src/hacks/AutoBackstab.cpp
@@ -13,12 +13,50 @@ static CatVar enabled(CV_SWITCH, "autobackstab", "0", "Auto Backstab",
                       "Does not depend on triggerbot!");
 static CatVar silent(CV_SWITCH, "autobackstab_silent", "1", "Silent");
 
-bool canBackstab(CachedEntity *tar, float angleY)
+
+void hitEntity(int *result_eindex, Vector *result_pos, QAngle angle)
 {
-    float _viewangles = NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles).y;
-    float viewangles  = (_viewangles > 180) ? _viewangles - 360 : _viewangles;
-    float scr         = abs(angleY - viewangles);
-    return (scr <= 90.0f);
+    Ray_t ray;
+    Vector forward;
+    float sp, sy, cp, cy;
+    trace_t trace;
+
+    trace::filter_default.SetSelf(RAW_ENT(g_pLocalPlayer->entity));
+    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 * 8192.0f + g_pLocalPlayer->v_Eye;
+    ray.Init(g_pLocalPlayer->v_Eye, forward);
+    g_ITrace->TraceRay(ray, 0x4200400B, &trace::filter_default, &trace);
+    if (result_pos)
+        *result_pos = trace.endpos;
+    if (result_eindex)
+    {
+        *result_eindex = 0;
+    }
+    if (trace.m_pEnt && result_eindex)
+    {
+        *result_eindex = ((IClientEntity *) (trace.m_pEnt))->entindex();
+    }
+}
+
+
+bool canBackstab(CachedEntity *tar, Vector angle)
+{
+    Vector targetAngle = NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles);
+    if (fabsf(angle.y - targetAngle.y) < 90)
+    {
+        int IDX;
+        Vector hitLoc;
+        hitEntity(&IDX, &hitLoc, QAngle(angle.x, angle.y, angle.z));
+        if (IDX == tar->m_IDX)
+            return true;
+    }
+    return false;
 }
 
 void CreateMove()
@@ -59,7 +97,8 @@ void CreateMove()
     }
     if (CE_GOOD(besttarget))
     {
-        if (canBackstab(besttarget, g_pLocalPlayer->v_OrigViewangles.y))
+        Vector angle = NET_VECTOR(RAW_ENT(LOCAL_E), netvar.m_angEyeAngles);
+        if (canBackstab(besttarget, angle))
         {
         g_pUserCmd->buttons |= IN_ATTACK;
         besttarget = nullptr;
@@ -67,9 +106,11 @@ void CreateMove()
         }
         else
         {
-            for (float i = -180.0f; i < 180.0f; i += 30.0f)
+
+            for (float i = -180.0f; i < 180.0f; i += 5.0f)
             {
-                if (canBackstab(besttarget, i))
+                angle.y = i;
+                if (canBackstab(besttarget, angle))
                 {
                     g_pUserCmd->viewangles.y = i;
                     g_pUserCmd->buttons |= IN_ATTACK;

From b2bc660e8f106643c9ffcf9ff4724b3813263c2a Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Wed, 1 Aug 2018 17:36:37 +0200
Subject: [PATCH 18/20] Improve autobackstab

---
 src/hacks/AutoBackstab.cpp | 55 +++++++++++++++++++++++---------------
 1 file changed, 34 insertions(+), 21 deletions(-)

diff --git a/src/hacks/AutoBackstab.cpp b/src/hacks/AutoBackstab.cpp
index 04d4d0ce..e280cd4a 100644
--- a/src/hacks/AutoBackstab.cpp
+++ b/src/hacks/AutoBackstab.cpp
@@ -7,14 +7,15 @@
 
 #include "common.hpp"
 #include "hacks/Backtrack.hpp"
+#include "hacks/Aimbot.hpp"
 namespace hacks::tf2::autobackstab
 {
 static CatVar enabled(CV_SWITCH, "autobackstab", "0", "Auto Backstab",
                       "Does not depend on triggerbot!");
 static CatVar silent(CV_SWITCH, "autobackstab_silent", "1", "Silent");
 
-
-void hitEntity(int *result_eindex, Vector *result_pos, QAngle angle)
+void traceEntity(int *result_eindex, Vector *result_pos, QAngle angle,
+                 Vector loc)
 {
     Ray_t ray;
     Vector forward;
@@ -29,9 +30,9 @@ void hitEntity(int *result_eindex, Vector *result_pos, QAngle angle)
     forward.x = cp * cy;
     forward.y = cp * sy;
     forward.z = -sp;
-    forward   = forward * 8192.0f + g_pLocalPlayer->v_Eye;
-    ray.Init(g_pLocalPlayer->v_Eye, forward);
-    g_ITrace->TraceRay(ray, 0x4200400B, &trace::filter_default, &trace);
+    forward   = forward * 8192.0f + loc;
+    ray.Init(loc, forward);
+    g_ITrace->TraceRay(ray, MASK_SHOT_HULL, &trace::filter_default, &trace);
     if (result_pos)
         *result_pos = trace.endpos;
     if (result_eindex)
@@ -44,17 +45,20 @@ void hitEntity(int *result_eindex, Vector *result_pos, QAngle angle)
     }
 }
 
-
-bool canBackstab(CachedEntity *tar, Vector angle)
+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) < 90)
+    if (fabsf(angle.y - targetAngle.y) < 85)
     {
         int IDX;
         Vector hitLoc;
-        hitEntity(&IDX, &hitLoc, QAngle(angle.x, angle.y, angle.z));
+        traceEntity(&IDX, &hitLoc, QAngle(angle.x, angle.y, angle.z), loc);
         if (IDX == tar->m_IDX)
-            return true;
+        {
+            if (loc.DistTo(hitboxLoc) < meleeRange)
+                return true;
+        }
     }
     return false;
 }
@@ -68,7 +72,6 @@ void CreateMove()
     if (g_pLocalPlayer->weapon()->m_iClassID() != CL_CLASS(CTFKnife))
         return;
     // Get melee range of knife
-    int meleeRange = re::C_TFWeaponBaseMelee::GetSwingRange(RAW_ENT(LOCAL_W));
     CachedEntity *besttarget = nullptr;
     for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
     {
@@ -79,12 +82,12 @@ void CreateMove()
             !target->m_bAlivePlayer() || target->m_Type() != ENTITY_PLAYER)
             continue;
         if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
-                g_pLocalPlayer->v_Eye) <= meleeRange)
+                g_pLocalPlayer->v_Eye) <= 300.0f)
         {
             if (CE_GOOD(besttarget))
             {
                 if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
-                        g_pLocalPlayer->v_Eye) >
+                        g_pLocalPlayer->v_Eye) <
                     besttarget->hitboxes.GetHitbox(spine_3)->center.DistTo(
                         g_pLocalPlayer->v_Eye))
                     besttarget = target;
@@ -97,22 +100,32 @@ void CreateMove()
     }
     if (CE_GOOD(besttarget))
     {
+        Vector hitboxLoc =
+            besttarget->hitboxes.GetHitbox(hacks::shared::aimbot::ClosestHitbox(besttarget))
+                ->center;
         Vector angle = NET_VECTOR(RAW_ENT(LOCAL_E), netvar.m_angEyeAngles);
-        if (canBackstab(besttarget, angle))
+        if (canBackstab(besttarget, angle, g_pLocalPlayer->v_Eye, hitboxLoc))
         {
-        g_pUserCmd->buttons |= IN_ATTACK;
-        besttarget = nullptr;
-        return;
+            g_pUserCmd->buttons |= IN_ATTACK;
+            besttarget = nullptr;
+            return;
         }
         else
         {
 
-            for (float i = -180.0f; i < 180.0f; i += 5.0f)
+            for (float i = -180.0f; i < 180.0f; i += 1.0f)
             {
+                // Get angles
+                Vector tr = (hitboxLoc - g_pLocalPlayer->v_Eye);
+                Vector xAngle;
+                VectorAngles(tr, xAngle);
+                // Clamping is important
+                fClampAngle(xAngle);
+                angle.x                = xAngle.x;
                 angle.y = i;
-                if (canBackstab(besttarget, angle))
+                if (canBackstab(besttarget, angle, g_pLocalPlayer->v_Eye, hitboxLoc))
                 {
-                    g_pUserCmd->viewangles.y = i;
+                    g_pUserCmd->viewangles = angle;
                     g_pUserCmd->buttons |= IN_ATTACK;
                     besttarget = nullptr;
                     if (silent)
@@ -123,4 +136,4 @@ void CreateMove()
         }
     }
 }
-}
+} // namespace hacks::tf2::autobackstab

From 662d1f1e4adc4896b4b6144ce2b46ace2e0150ce Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Wed, 1 Aug 2018 22:45:55 +0200
Subject: [PATCH 19/20] Autobackstab improvements

---
 src/hacks/AutoBackstab.cpp | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

diff --git a/src/hacks/AutoBackstab.cpp b/src/hacks/AutoBackstab.cpp
index e280cd4a..fd40c5e6 100644
--- a/src/hacks/AutoBackstab.cpp
+++ b/src/hacks/AutoBackstab.cpp
@@ -14,6 +14,8 @@ static CatVar enabled(CV_SWITCH, "autobackstab", "0", "Auto Backstab",
                       "Does not depend on triggerbot!");
 static CatVar silent(CV_SWITCH, "autobackstab_silent", "1", "Silent");
 
+int checkNextTick = -1;
+
 void traceEntity(int *result_eindex, Vector *result_pos, QAngle angle,
                  Vector loc)
 {
@@ -56,8 +58,10 @@ bool canBackstab(CachedEntity *tar, Vector angle, Vector loc, Vector hitboxLoc)
         traceEntity(&IDX, &hitLoc, QAngle(angle.x, angle.y, angle.z), loc);
         if (IDX == tar->m_IDX)
         {
-            if (loc.DistTo(hitboxLoc) < meleeRange)
+            if (loc.DistTo(hitboxLoc) <= meleeRange)
                 return true;
+            else
+                checkNextTick = tar->m_IDX;
         }
     }
     return false;
@@ -71,8 +75,11 @@ void CreateMove()
         return;
     if (g_pLocalPlayer->weapon()->m_iClassID() != CL_CLASS(CTFKnife))
         return;
-    // Get melee range of knife
     CachedEntity *besttarget = nullptr;
+
+    //Check if we need to check a player again. We do this because our backstab range may be different after we have rotated
+    if (checkNextTick == -1)
+    {
     for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
     {
         CachedEntity *target = ENTITY(i);
@@ -98,22 +105,20 @@ void CreateMove()
             }
         }
     }
+    }
+    else
+    {
+        // If we need to check a player again, set besttarget to the idx of the player
+        besttarget = ENTITY(checkNextTick);
+        checkNextTick = -1;
+    }
     if (CE_GOOD(besttarget))
     {
         Vector hitboxLoc =
             besttarget->hitboxes.GetHitbox(hacks::shared::aimbot::ClosestHitbox(besttarget))
                 ->center;
         Vector angle = NET_VECTOR(RAW_ENT(LOCAL_E), netvar.m_angEyeAngles);
-        if (canBackstab(besttarget, angle, g_pLocalPlayer->v_Eye, hitboxLoc))
-        {
-            g_pUserCmd->buttons |= IN_ATTACK;
-            besttarget = nullptr;
-            return;
-        }
-        else
-        {
-
-            for (float i = -180.0f; i < 180.0f; i += 1.0f)
+            for (angle.y = -180.0f; angle.y < 180.0f; angle.y += 1.0f)
             {
                 // Get angles
                 Vector tr = (hitboxLoc - g_pLocalPlayer->v_Eye);
@@ -122,7 +127,6 @@ void CreateMove()
                 // Clamping is important
                 fClampAngle(xAngle);
                 angle.x                = xAngle.x;
-                angle.y = i;
                 if (canBackstab(besttarget, angle, g_pLocalPlayer->v_Eye, hitboxLoc))
                 {
                     g_pUserCmd->viewangles = angle;
@@ -132,7 +136,6 @@ void CreateMove()
                         g_pLocalPlayer->bUseSilentAngles = true;
                     return;
                 }
-            }
         }
     }
 }

From de3faa25d48be6efbe4126aef000b0d4f304fbe5 Mon Sep 17 00:00:00 2001
From: TotallyNotElite <1yourexperiment@protonmail.com>
Date: Thu, 2 Aug 2018 14:59:05 +0200
Subject: [PATCH 20/20] Port to newui

---
 .circleci/config.yml       |  2 +-
 external/libglez           |  2 +-
 src/hacks/AutoBackstab.cpp | 41 +++++++-------------------------------
 src/hacks/FollowBot.cpp    |  2 +-
 src/hacks/SpyAlert.cpp     |  2 +-
 update                     |  4 +++-
 6 files changed, 14 insertions(+), 39 deletions(-)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index bf346543..2b8eef88 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -7,4 +7,4 @@ jobs:
         - checkout
         - run: 
             name: "Compiling cathook"
-            command: git submodule update --init --recursive; mkdir build; cd build; cmake -DEnableWarnings=0 ..; make -j16; cd ..
+            command: git submodule update --init --recursive; mkdir build; cd build; cmake -DEnableWarnings=0 ..; make -j8; cd ..
diff --git a/external/libglez b/external/libglez
index 6edbc9e4..1e03d384 160000
--- a/external/libglez
+++ b/external/libglez
@@ -1 +1 @@
-Subproject commit 6edbc9e4a2025cdae22ff134e0be57fb8bd1e232
+Subproject commit 1e03d3843fec67f313b285ec987ced90a17aba39
diff --git a/src/hacks/AutoBackstab.cpp b/src/hacks/AutoBackstab.cpp
index 555542b5..46a0eabb 100644
--- a/src/hacks/AutoBackstab.cpp
+++ b/src/hacks/AutoBackstab.cpp
@@ -26,26 +26,11 @@ const Vector GetWorldSpaceCenter(CachedEntity *ent)
     return vWorldSpaceCenter;
 }
 
-static CatVar enabled(CV_SWITCH, "autobackstab", "0", "Auto Backstab",
-                      "Does not depend on triggerbot!");
-static CatVar silent(CV_SWITCH, "autobackstab_silent", "1", "Silent");
-bool found;
 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;
 }
-// TODO improve
-bool CanBackstab(CachedEntity *tar, Vector Local_ang)
-{
-    if (CE_BAD(tar))
-        return false;
-    // Get the forward view vector of the target, ignore Z
-    Vector vecVictimForward = NET_VECTOR(RAW_ENT(tar), netvar.m_angEyeAngles);
-    vecVictimForward.z      = 0.0f;
-    vecVictimForward.NormalizeInPlace();
-
-int checkNextTick = -1;
 
 void traceEntity(int *result_eindex, Vector *result_pos, QAngle angle,
                  Vector loc)
@@ -82,7 +67,7 @@ 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) < 85)
+    if (fabsf(angle.y - targetAngle.y) < 80)
     {
         int IDX;
         Vector hitLoc;
@@ -91,8 +76,6 @@ bool canBackstab(CachedEntity *tar, Vector angle, Vector loc, Vector hitboxLoc)
         {
             if (loc.DistTo(hitboxLoc) <= meleeRange)
                 return true;
-            else
-                checkNextTick = tar->m_IDX;
         }
     }
     return false;
@@ -108,9 +91,6 @@ void CreateMove()
         return;
     CachedEntity *besttarget = nullptr;
 
-    //Check if we need to check a player again. We do this because our backstab range may be different after we have rotated
-    if (checkNextTick == -1)
-    {
     for (int i = 0; i < g_IEngine->GetMaxClients(); i++)
     {
         CachedEntity *target = ENTITY(i);
@@ -119,14 +99,14 @@ void CreateMove()
         if (target == LOCAL_E || target->m_iTeam() == LOCAL_E->m_iTeam() ||
             !target->m_bAlivePlayer() || target->m_Type() != ENTITY_PLAYER)
             continue;
-        if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
+        if (target->hitboxes.GetHitbox(spine_2)->center.DistTo(
                 g_pLocalPlayer->v_Eye) <= 300.0f)
         {
             if (CE_GOOD(besttarget))
             {
-                if (target->hitboxes.GetHitbox(spine_3)->center.DistTo(
+                if (target->hitboxes.GetHitbox(spine_2)->center.DistTo(
                         g_pLocalPlayer->v_Eye) <
-                    besttarget->hitboxes.GetHitbox(spine_3)->center.DistTo(
+                    besttarget->hitboxes.GetHitbox(spine_2)->center.DistTo(
                         g_pLocalPlayer->v_Eye))
                     besttarget = target;
             }
@@ -136,17 +116,10 @@ void CreateMove()
             }
         }
     }
-    }
-    else
-    {
-        // If we need to check a player again, set besttarget to the idx of the player
-        besttarget = ENTITY(checkNextTick);
-        checkNextTick = -1;
-    }
     if (CE_GOOD(besttarget))
     {
         Vector hitboxLoc =
-            besttarget->hitboxes.GetHitbox(hacks::shared::aimbot::ClosestHitbox(besttarget))
+            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)
@@ -160,8 +133,8 @@ void CreateMove()
                 angle.x                = xAngle.x;
                 if (canBackstab(besttarget, angle, g_pLocalPlayer->v_Eye, hitboxLoc))
                 {
-                    g_pUserCmd->viewangles = angle;
-                    g_pUserCmd->buttons |= IN_ATTACK;
+                    current_user_cmd->viewangles = angle;
+                    current_user_cmd->buttons |= IN_ATTACK;
                     besttarget = nullptr;
                     if (silent)
                         g_pLocalPlayer->bUseSilentAngles = true;
diff --git a/src/hacks/FollowBot.cpp b/src/hacks/FollowBot.cpp
index a9c31134..f820c0f7 100644
--- a/src/hacks/FollowBot.cpp
+++ b/src/hacks/FollowBot.cpp
@@ -12,7 +12,7 @@
 #include <settings/Bool.hpp>
 
 static settings::Bool enable{ "follow-bot.enable", "false" };
-static settings::Bool roambot{ "follow-bot.roaming", "false" };
+static settings::Bool roambot{ "follow-bot.roaming", "true" };
 static settings::Bool draw_crumb{ "follow-bot.draw-crumbs", "false" };
 static settings::Float follow_distance{ "follow-bot.distance", "175" };
 static settings::Float follow_activation{ "follow-bot.max-range", "1000" };
diff --git a/src/hacks/SpyAlert.cpp b/src/hacks/SpyAlert.cpp
index b0bb5c7b..16ef8bb7 100644
--- a/src/hacks/SpyAlert.cpp
+++ b/src/hacks/SpyAlert.cpp
@@ -27,7 +27,7 @@ Timer lastVoicemenu{};
 void Draw()
 {
     PROF_SECTION(DRAW_SpyAlert)
-    if (!enabled)
+    if (!enable)
         return;
     CachedEntity *closest_spy, *ent;
     float closest_spy_distance, distance;
diff --git a/update b/update
index 167c4b32..e51da3de 100755
--- a/update
+++ b/update
@@ -2,5 +2,7 @@
 #Get updated source code
 git fetch;git pull origin;git submodule update --init --recursive
 #Update cathook
-cd build; cmake ..; make -j$(grep -c '^processor' /proc/cpuinfo); cd ..; cd ..
+cd build; cmake ..; make -j$(grep -c '^processor' /proc/cpuinfo)
+#Update data
+sudo make data;  cd ..; cd ..
 printf "\n\n";printf '\e[1;34m%-6s\e' "Cathook update complete!";printf "\n\n"