From 8f22a56a2300e84bb90663c83880c983cfe4d348 Mon Sep 17 00:00:00 2001 From: BenCat07 Date: Thu, 14 May 2020 13:23:14 +0200 Subject: [PATCH] Don't use a seperate class for backtrack --- include/hacks/Backtrack.hpp | 82 ++++++++------------- include/hacks/Trigger.hpp | 7 +- src/crits.cpp | 4 +- src/hacks/Aimbot.cpp | 24 +++---- src/hacks/AutoBackstab.cpp | 12 ++-- src/hacks/AutoJoin.cpp | 9 ++- src/hacks/Backtrack.cpp | 100 ++++++++++++++++++-------- src/hacks/Misc.cpp | 21 ++++-- src/hacks/MiscAimbot.cpp | 13 ++-- src/hacks/Trigger.cpp | 11 +-- src/hooks/SendDatagram.cpp | 4 +- src/hooks/visual/DrawModelExecute.cpp | 14 ++-- src/visual/EffectChams.cpp | 8 +-- 13 files changed, 170 insertions(+), 139 deletions(-) diff --git a/include/hacks/Backtrack.hpp b/include/hacks/Backtrack.hpp index 1fa3e25a..4a12e252 100644 --- a/include/hacks/Backtrack.hpp +++ b/include/hacks/Backtrack.hpp @@ -44,69 +44,43 @@ public: matrix3x4_t bones[128]{}; }; -// Let's try OOP for once -class Backtrack -{ - // Internal rvars - settings::Boolean enabled{ "backtrack.enabled", "false" }; - settings::Boolean draw{ "backtrack.draw", "false" }; +// Stuff that has to be accessible from outside, mostly functions - std::vector sequences; - int current_tickcount; - std::array>, PLAYER_ARRAY_SIZE> backtrack_data; - int lastincomingsequence{ 0 }; - // Used to make transition smooth(er) - float latency_rampup = 0.0f; - - // Which data to apply in the late CreateMove - CachedEntity *bt_ent; - std::optional bt_data; - - bool isEnabled(); - float getLatency(); - int getTicks(); - bool getBestInternalTick(CachedEntity *, BacktrackData &, std::optional &); - void ApplyBacktrack(); - - // Stuff that has to be accessible from outside, mostly functions -public: - settings::Float latency{ "backtrack.latency", "0" }; - settings::Int bt_slots{ "backtrack.slots", "0" }; +extern settings::Float latency; +extern settings::Int bt_slots; #if ENABLE_VISUALS - settings::Boolean chams{ "backtrack.chams", "false" }; - settings::Int chams_ticks{ "backtrack.chams.ticks", "1" }; - settings::Rgba chams_color{ "backtrack.chams.color", "646464FF" }; - settings::Boolean chams_solid{ "backtrack.chams.color.solid", "false" }; +extern settings::Boolean chams; +extern settings::Int chams_ticks; +extern settings::Rgba chams_color; +extern settings::Boolean chams_solid; #endif - // Check if backtrack is enabled - bool isBacktrackEnabled; +// Check if backtrack is enabled +extern bool isBacktrackEnabled; #if ENABLE_VISUALS - // Drawing Backtrack chams - bool isDrawing; +// Drawing Backtrack chams +extern bool isDrawing; #endif - // Event callbacks - void CreateMove(); - void CreateMoveLate(); +// Event callbacks +void CreateMove(); +void CreateMoveLate(); #if ENABLE_VISUALS - void Draw(); +void Draw(); #endif - void LevelShutdown(); +void LevelShutdown(); - void adjustPing(INetChannel *); - void updateDatagram(); - void resetData(int); - bool isGoodTick(BacktrackData &); - static bool defaultTickFilter(CachedEntity *, BacktrackData); - static bool defaultEntFilter(CachedEntity *); +void adjustPing(INetChannel *); +void updateDatagram(); +void resetData(int); +bool isGoodTick(BacktrackData &); +bool defaultTickFilter(CachedEntity *, BacktrackData); +bool defaultEntFilter(CachedEntity *); - // Various functions for getting backtrack ticks - std::vector getGoodTicks(int); - std::optional getBestTick(CachedEntity *, std::function &)>); - std::optional getClosestEntTick(CachedEntity *, Vector, std::function); - std::optional> getClosestTick(Vector, std::function, std::function); +// Various functions for getting backtrack ticks +std::vector getGoodTicks(int); +std::optional getBestTick(CachedEntity *, std::function &)>); +std::optional getClosestEntTick(CachedEntity *, Vector, std::function); +std::optional> getClosestTick(Vector, std::function, std::function); - void SetBacktrackData(CachedEntity *ent, BacktrackData); -}; -extern hacks::tf2::backtrack::Backtrack backtrack; +void SetBacktrackData(CachedEntity *ent, BacktrackData); } // namespace hacks::tf2::backtrack diff --git a/include/hacks/Trigger.hpp b/include/hacks/Trigger.hpp index 53299ee8..3634eeaf 100644 --- a/include/hacks/Trigger.hpp +++ b/include/hacks/Trigger.hpp @@ -8,14 +8,17 @@ #pragma once #include "common.hpp" -#include "Backtrack.hpp" +namespace hacks::tf2::backtrack +{ +class BacktrackData; +} namespace hacks::shared::triggerbot { void CreateMove(); bool ShouldShoot(); -bool IsTargetStateGood(CachedEntity *entity, std::optional bt_data = {}); +bool IsTargetStateGood(CachedEntity *entity, hacks::tf2::backtrack::BacktrackData *bt_data = nullptr); CachedEntity *FindEntInSight(float range, bool no_players = false); bool HeadPreferable(CachedEntity *target); bool UpdateAimkey(); diff --git a/src/crits.cpp b/src/crits.cpp index 31b15a7f..b5b632c3 100644 --- a/src/crits.cpp +++ b/src/crits.cpp @@ -275,10 +275,10 @@ bool shouldMeleeCrit() { if (!melee || g_pLocalPlayer->weapon_mode != weapon_melee) return false; - if (hacks::tf2::backtrack::backtrack.isBacktrackEnabled) + if (hacks::tf2::backtrack::isBacktrackEnabled) { // Closest tick for melee (default filter carry) - auto closest_tick = hacks::tf2::backtrack::backtrack.getClosestTick(LOCAL_E->m_vecOrigin(), hacks::tf2::backtrack::backtrack.defaultEntFilter, hacks::tf2::backtrack::backtrack.defaultTickFilter); + auto closest_tick = hacks::tf2::backtrack::getClosestTick(LOCAL_E->m_vecOrigin(), hacks::tf2::backtrack::defaultEntFilter, hacks::tf2::backtrack::defaultTickFilter); // Valid backtrack target if (closest_tick) { diff --git a/src/hacks/Aimbot.cpp b/src/hacks/Aimbot.cpp index c2e9ae59..993b09ea 100644 --- a/src/hacks/Aimbot.cpp +++ b/src/hacks/Aimbot.cpp @@ -121,7 +121,7 @@ float cur_proj_grav{ 0.0f }; bool shouldBacktrack() { - return *enable && !projectile_mode && (*backtrackAimbot || force_backtrack_aimbot) && hacks::tf2::backtrack::backtrack.isBacktrackEnabled; + return *enable && !projectile_mode && (*backtrackAimbot || force_backtrack_aimbot) && hacks::tf2::backtrack::isBacktrackEnabled; } bool IsBacktracking() @@ -606,7 +606,7 @@ bool IsTargetStateGood(CachedEntity *entity) else { // This does vischecks and everything - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); // No data found if (!data) return false; @@ -726,7 +726,7 @@ bool IsTargetStateGood(CachedEntity *entity) if (shouldBacktrack()) { // This does vischecks and everything - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); // No data found if (!data) return false; @@ -844,7 +844,7 @@ bool IsTargetStateGood(CachedEntity *entity) if (shouldBacktrack()) { // This does vischecks and everything - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); // No data found if (!data) return false; @@ -890,7 +890,7 @@ void Aim(CachedEntity *entity) if (shouldBacktrack() && entity->m_Type() == ENTITY_PLAYER) { // This does vischecks and everything - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); auto bt_hb = data->hitboxes.at(cd.hitbox); hitboxcenter = bt_hb.center; hitboxmin = bt_hb.min; @@ -943,9 +943,9 @@ void Aim(CachedEntity *entity) // Set Backtrack data if (shouldBacktrack() && entity->m_Type() == ENTITY_PLAYER) { - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); if (data) - hacks::tf2::backtrack::backtrack.SetBacktrackData(entity, *data); + hacks::tf2::backtrack::SetBacktrackData(entity, *data); } // Finish function return; @@ -1107,7 +1107,7 @@ const Vector &PredictEntity(CachedEntity *entity) } else { - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); if (data) { result = data->hitboxes.at(cd.hitbox).center; @@ -1241,7 +1241,7 @@ int BestHitbox(CachedEntity *target) // Backtracking and preferred hitbox if (IsBacktracking()) { - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(target, LOCAL_E->m_vecOrigin(), aimbotTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(target, LOCAL_E->m_vecOrigin(), aimbotTickFilter); if (data) { @@ -1264,7 +1264,7 @@ int BestHitbox(CachedEntity *target) // We already vischecked if (!*backtrackVischeckAll) { - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(target, LOCAL_E->m_vecOrigin(), aimbotTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(target, LOCAL_E->m_vecOrigin(), aimbotTickFilter); for (int i = 0; i < 18; i++) if (IsEntityVectorVisible(target, (*data).hitboxes.at(i).center)) @@ -1341,7 +1341,7 @@ bool VischeckPredictedEntity(CachedEntity *entity) } else { - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(entity, LOCAL_E->m_vecOrigin(), aimbotTickFilter); if (data && IsEntityVectorVisible(entity, data->hitboxes.at((cd.hitbox == -1 || cd.hitbox >= 18) ? 0 : cd.hitbox).center, MASK_SHOT)) cd.visible = true; else @@ -1536,7 +1536,7 @@ void rvarCallback(settings::VariableBase &, float after) force_backtrack_aimbot = after >= 200.0f; } static InitRoutine EC([]() { - hacks::tf2::backtrack::backtrack.latency.installChangeCallback(rvarCallback); + hacks::tf2::backtrack::latency.installChangeCallback(rvarCallback); EC::Register(EC::LevelInit, Reset, "INIT_Aimbot", EC::average); EC::Register(EC::LevelShutdown, Reset, "RESET_Aimbot", EC::average); EC::Register(EC::CreateMove, CreateMove, "CM_Aimbot", EC::late); diff --git a/src/hacks/AutoBackstab.cpp b/src/hacks/AutoBackstab.cpp index f2705113..5f246405 100644 --- a/src/hacks/AutoBackstab.cpp +++ b/src/hacks/AutoBackstab.cpp @@ -280,7 +280,7 @@ static bool doBacktrackStab(bool legit = false) continue; // Get the best tick for that ent - auto tick_data = hacks::tf2::backtrack::backtrack.getBestTick(ent, backtrackFilter); + auto tick_data = hacks::tf2::backtrack::getBestTick(ent, backtrackFilter); // We found something matching the criterias, break out if (tick_data) @@ -294,7 +294,7 @@ static bool doBacktrackStab(bool legit = false) // We found a good ent if (stab_ent) { - hacks::tf2::backtrack::backtrack.SetBacktrackData(stab_ent, stab_data); + hacks::tf2::backtrack::SetBacktrackData(stab_ent, stab_data); current_user_cmd->buttons |= IN_ATTACK; current_user_cmd->viewangles = newangle_apply; g_pLocalPlayer->bUseSilentAngles = true; @@ -321,9 +321,9 @@ void CreateMove() doRageBackstab(); break; case 2: - if (hacks::tf2::backtrack::backtrack.isBacktrackEnabled) + if (hacks::tf2::backtrack::isBacktrackEnabled) { - if (*hacks::tf2::backtrack::backtrack.latency <= 190 && doRageBackstab()) + if (*hacks::tf2::backtrack::latency <= 190 && doRageBackstab()) break; doBacktrackStab(false); } @@ -333,9 +333,9 @@ void CreateMove() } break; case 3: - if (hacks::tf2::backtrack::backtrack.isBacktrackEnabled) + if (hacks::tf2::backtrack::isBacktrackEnabled) { - if (*hacks::tf2::backtrack::backtrack.latency <= 190 && doLegitBackstab()) + if (*hacks::tf2::backtrack::latency <= 190 && doLegitBackstab()) break; doBacktrackStab(true); } diff --git a/src/hacks/AutoJoin.cpp b/src/hacks/AutoJoin.cpp index ce567eba..7ae12a86 100644 --- a/src/hacks/AutoJoin.cpp +++ b/src/hacks/AutoJoin.cpp @@ -152,8 +152,15 @@ static InitRoutine init([]() { else { p.Shutdown(); - p2.Patch(); + p2.Shutdown(); } }); + EC::Register( + EC::Shutdown, + []() { + p.Shutdown(); + p2.Shutdown(); + }, + "shutdown_autojoin"); }); } // namespace hacks::shared::autojoin diff --git a/src/hacks/Backtrack.cpp b/src/hacks/Backtrack.cpp index 9f1a2e19..12bfcfda 100644 --- a/src/hacks/Backtrack.cpp +++ b/src/hacks/Backtrack.cpp @@ -4,11 +4,49 @@ * */ #include "Backtrack.hpp" +#include "memory" namespace hacks::tf2::backtrack { +// Internal rvars +static settings::Boolean enabled{ "backtrack.enabled", "false" }; +static settings::Boolean draw{ "backtrack.draw", "false" }; + +static std::vector sequences; +static int current_tickcount; +static std::array>, PLAYER_ARRAY_SIZE> backtrack_data; +static int lastincomingsequence{ 0 }; +// Used to make transition smooth(er) +static float latency_rampup = 0.0f; + +// Which data to apply in the late CreateMove +static CachedEntity *bt_ent; +static std::optional bt_data; + +static bool isEnabled(); +static float getLatency(); +static int getTicks(); +static bool getBestInternalTick(CachedEntity *, BacktrackData &, std::optional &); +static void ApplyBacktrack(); + +settings::Float latency{ "backtrack.latency", "0" }; +settings::Int bt_slots{ "backtrack.slots", "0" }; +#if ENABLE_VISUALS +settings::Boolean chams{ "backtrack.chams", "false" }; +settings::Int chams_ticks{ "backtrack.chams.ticks", "1" }; +settings::Rgba chams_color{ "backtrack.chams.color", "646464FF" }; +settings::Boolean chams_solid{ "backtrack.chams.color.solid", "false" }; +#endif + +// Check if backtrack is enabled +bool isBacktrackEnabled; +#if ENABLE_VISUALS +// Drawing Backtrack chams +bool isDrawing; +#endif + // Apply Backtrack -void Backtrack::ApplyBacktrack() +void ApplyBacktrack() { if (!isBacktrackEnabled) return; @@ -22,14 +60,14 @@ void Backtrack::ApplyBacktrack() } // Update tick to apply -void Backtrack::SetBacktrackData(CachedEntity *ent, BacktrackData tick) +void SetBacktrackData(CachedEntity *ent, BacktrackData tick) { bt_ent = ent; bt_data = tick; } // Get Best tick for Backtrack (crosshair/fov based) -bool Backtrack::getBestInternalTick(CachedEntity *, BacktrackData &data, std::optional &best_tick) +bool getBestInternalTick(CachedEntity *, BacktrackData &data, std::optional &best_tick) { // Best Score float bestScore = FLT_MAX; @@ -58,19 +96,21 @@ bool Backtrack::getBestInternalTick(CachedEntity *, BacktrackData &data, std::op // Should never be called but gcc likes to complain anyways return false; } + // Is backtrack enabled? -bool Backtrack::isEnabled() +bool isEnabled() { if (!*enabled) return false; CachedEntity *wep = LOCAL_W; if (CE_BAD(wep)) return false; - if (*bt_slots == 0) - return true; int slot = re::C_BaseCombatWeapon::GetSlot(RAW_ENT(wep)); - switch ((int) bt_slots) + switch (*bt_slots) { + // Not set + case 0: + return true; case 1: if (slot == 0) return true; @@ -100,7 +140,7 @@ bool Backtrack::isEnabled() } // Main Tracking logic -void Backtrack::CreateMove() +void CreateMove() { // Update enabled status isBacktrackEnabled = isEnabled(); @@ -201,7 +241,7 @@ void Backtrack::CreateMove() current_tick.has_updated = !previous_tick.m_flSimulationTime || previous_tick.m_flSimulationTime != current_tick.m_flSimulationTime; // Get best tick for this ent - std::optional data = getBestTick(ent, std::bind(&Backtrack::getBestInternalTick, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3)); + std::optional data = getBestTick(ent, getBestInternalTick); // Check if actually the best tick we have in total if (data && (!best_data || getBestInternalTick(ent, *data, best_data))) { @@ -212,15 +252,14 @@ void Backtrack::CreateMove() if (best_data && best_ent) SetBacktrackData(best_ent, *best_data); } - -void Backtrack::CreateMoveLate() +void CreateMoveLate() { ApplyBacktrack(); } #if ENABLE_VISUALS // Drawing -void Backtrack::Draw() +void Draw() { if (!isBacktrackEnabled || !draw) return; @@ -261,7 +300,7 @@ void Backtrack::Draw() #endif // Reset things -void Backtrack::LevelShutdown() +void LevelShutdown() { lastincomingsequence = 0; sequences.clear(); @@ -270,7 +309,7 @@ void Backtrack::LevelShutdown() } // Change Datagram data -void Backtrack::adjustPing(INetChannel *ch) +void adjustPing(INetChannel *ch) { if (!isBacktrackEnabled) return; @@ -286,7 +325,7 @@ void Backtrack::adjustPing(INetChannel *ch) } // Latency to add for backtrack -float Backtrack::getLatency() +float getLatency() { INetChannel *ch = (INetChannel *) g_IEngine->GetNetChannelInfo(); // Track what actual latency we have @@ -306,7 +345,7 @@ float Backtrack::getLatency() } // Update our sequences -void Backtrack::updateDatagram() +void updateDatagram() { INetChannel *ch = (INetChannel *) g_IEngine->GetNetChannelInfo(); if (ch) @@ -324,7 +363,7 @@ void Backtrack::updateDatagram() } // Get How many ticks we should Store and use -int Backtrack::getTicks() +int getTicks() { float max_lat = getLatency() + 200.0f; @@ -336,13 +375,13 @@ int Backtrack::getTicks() return ticks; }; -void Backtrack::resetData(int entidx) +void resetData(int entidx) { // Clear everything backtrack_data[entidx].reset(); } -bool Backtrack::isGoodTick(BacktrackData &tick) +bool isGoodTick(BacktrackData &tick) { // This tick hasn't updated since the last one, Entity might be dropping packets if (!tick.has_updated) @@ -358,7 +397,7 @@ bool Backtrack::isGoodTick(BacktrackData &tick) } // Read only vector of good ticks -std::vector Backtrack::getGoodTicks(int entidx) +std::vector getGoodTicks(int entidx) { std::vector to_return; // Invalid @@ -377,7 +416,7 @@ std::vector Backtrack::getGoodTicks(int entidx) } // This function is so other files can Easily get the best tick matching their criteria -std::optional Backtrack::getBestTick(CachedEntity *ent, std::function &best_tick)> callback) +std::optional getBestTick(CachedEntity *ent, std::function &best_tick)> callback) { std::optional best_tick; @@ -396,7 +435,7 @@ std::optional Backtrack::getBestTick(CachedEntity *ent, std::func } // Default filter method. Checks for vischeck on Hitscan weapons. -bool Backtrack::defaultTickFilter(CachedEntity *ent, BacktrackData tick) +bool defaultTickFilter(CachedEntity *ent, BacktrackData tick) { // Not hitscan, no vischeck needed if (g_pLocalPlayer->weapon_mode != weapon_hitscan) @@ -405,7 +444,7 @@ bool Backtrack::defaultTickFilter(CachedEntity *ent, BacktrackData tick) return IsEntityVectorVisible(ent, tick.hitboxes.at(head).center, MASK_SHOT); } -bool Backtrack::defaultEntFilter(CachedEntity *ent) +bool defaultEntFilter(CachedEntity *ent) { // Dormant if (CE_BAD(ent)) @@ -417,7 +456,7 @@ bool Backtrack::defaultEntFilter(CachedEntity *ent) } // Get Closest tick of a specific entity -std::optional Backtrack::getClosestEntTick(CachedEntity *ent, Vector vec, std::function tick_filter) +std::optional getClosestEntTick(CachedEntity *ent, Vector vec, std::function tick_filter) { std::optional return_value; // No entry @@ -444,7 +483,7 @@ std::optional Backtrack::getClosestEntTick(CachedEntity *ent, Vec } // Get Closest tick of any (enemy) entity, Second Parameter is to allow custom filters for entity criteria, third for ticks. We provide defaults for vischecks + melee for the second one -std::optional> Backtrack::getClosestTick(Vector vec, std::function ent_filter, std::function tick_filter) +std::optional> getClosestTick(Vector vec, std::function ent_filter, std::function tick_filter) { float distance = FLT_MAX; CachedEntity *best_ent = nullptr; @@ -476,13 +515,12 @@ std::optional> Backtrack::getClosestTic } static InitRoutine init([]() { - EC::Register(EC::CreateMove, std::bind(&Backtrack::CreateMove, &hacks::tf2::backtrack::backtrack), "backtrack_cm", EC::early); - EC::Register(EC::CreateMove, std::bind(&Backtrack::CreateMoveLate, &hacks::tf2::backtrack::backtrack), "backtrack_cmlate", EC::very_late); + EC::Register(EC::CreateMove, CreateMove, "backtrack_cm", EC::early); + EC::Register(EC::CreateMove, CreateMoveLate, "backtrack_cmlate", EC::very_late); #if ENABLE_VISUALS - EC::Register(EC::Draw, std::bind(&Backtrack::Draw, &hacks::tf2::backtrack::backtrack), "backtrack_draw"); + EC::Register(EC::Draw, Draw, "backtrack_draw"); #endif - EC::Register(EC::LevelShutdown, std::bind(&Backtrack::LevelShutdown, &hacks::tf2::backtrack::backtrack), "backtrack_levelshutdown"); + EC::Register(EC::LevelShutdown, LevelShutdown, "backtrack_levelshutdown"); }); -Backtrack backtrack; + } // namespace hacks::tf2::backtrack -// Global interface diff --git a/src/hacks/Misc.cpp b/src/hacks/Misc.cpp index 833fbdba..145a6ff8 100644 --- a/src/hacks/Misc.cpp +++ b/src/hacks/Misc.cpp @@ -277,10 +277,10 @@ void CreateMove() cmdrate = g_ICvar->FindVar("cl_cmdrate"); return; } - int ping = g_pPlayerResource->GetPing(g_IEngine->GetLocalPlayer()); + int ping = g_pPlayerResource->GetPing(g_IEngine->GetLocalPlayer()); if (*force_ping <= ping && cmdrate->GetInt() != -1) { - oldCmdRate = cmdrate->GetInt(); + oldCmdRate = cmdrate->GetInt(); cmdrate->m_fMaxVal = 999999999.9f; cmdrate->m_fMinVal = -999999999.9f; cmdrate->SetValue(-1); @@ -821,16 +821,24 @@ static InitRoutine init_pyrovision([]() { cart_patch2.Shutdown(); } }); + EC::Register( + EC::Shutdown, + []() { + cart_patch1.Shutdown(); + cart_patch2.Shutdown(); + }, + "cartpatch_shutdown"); ping_reducer.installChangeCallback([](settings::VariableBase &, bool after) { static ConVar *cmdrate = g_ICvar->FindVar("cl_cmdrate"); if (cmdrate == nullptr) { - cmdrate = g_ICvar->FindVar("cl_cmdrate"); - return; + cmdrate = g_ICvar->FindVar("cl_cmdrate"); + return; } if (!after && cmdrate->GetInt() != oldCmdRate) cmdrate->SetValue(oldCmdRate); - });; + }); + ; #endif }); #endif @@ -838,8 +846,6 @@ static InitRoutine init_pyrovision([]() { static CatCommand print_eye_diff("debug_print_eye_diff", "debug", []() { logging::Info("%f", g_pLocalPlayer->v_Eye.z - LOCAL_E->m_vecOrigin().z); }); void Shutdown() { - if (CE_BAD(LOCAL_E)) - return; #if ENABLE_VISUALS && !ENFORCE_STREAM_SAFETY // unpatching local player render_zoomed = false; @@ -885,6 +891,7 @@ static InitRoutine init([]() { []() { stealth_kill.Shutdown(); cyoa_patch.Shutdown(); + tryPatchLocalPlayerShouldDraw(false); }, "shutdown_stealthkill"); dont_hide_stealth_kills.installChangeCallback([](settings::VariableBase &, bool after) { diff --git a/src/hacks/MiscAimbot.cpp b/src/hacks/MiscAimbot.cpp index 0ed76e40..926c10cb 100644 --- a/src/hacks/MiscAimbot.cpp +++ b/src/hacks/MiscAimbot.cpp @@ -10,6 +10,7 @@ #include "hacks/Trigger.hpp" #include "MiscAimbot.hpp" #include "DetourHook.hpp" +#include "Backtrack.hpp" namespace hacks::tf2::misc_aimbot { @@ -49,14 +50,14 @@ std::pair FindBestEnt(bool teammate, bool Predict, bool target = ProjectilePrediction(ent, 1, sandwich_speed, grav, PlayerGravityMod(ent)); else target = ent->hitboxes.GetHitbox(1)->center; - if (!hacks::tf2::backtrack::backtrack.isBacktrackEnabled && !IsEntityVectorVisible(ent, target)) + if (!hacks::tf2::backtrack::isBacktrackEnabled && !IsEntityVectorVisible(ent, target)) continue; if (zcheck && (ent->m_vecOrigin().z - LOCAL_E->m_vecOrigin().z) > 200.0f) continue; float scr = ent->m_flDistance(); - if (hacks::tf2::backtrack::backtrack.isBacktrackEnabled && demoknight_mode) + if (hacks::tf2::backtrack::isBacktrackEnabled && demoknight_mode) { - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(ent, LOCAL_E->m_vecOrigin(), hacks::tf2::backtrack::Backtrack::defaultTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(ent, LOCAL_E->m_vecOrigin(), hacks::tf2::backtrack::defaultTickFilter); // No entity if (!data) scr = FLT_MAX; @@ -107,14 +108,14 @@ std::pair FindBestEnt(bool teammate, bool Predict, bool target = ProjectilePrediction(ent, 1, sandwich_speed, grav, PlayerGravityMod(ent)); else target = ent->hitboxes.GetHitbox(1)->center; - if (!hacks::tf2::backtrack::backtrack.isBacktrackEnabled && !IsEntityVectorVisible(ent, target)) + if (!hacks::tf2::backtrack::isBacktrackEnabled && !IsEntityVectorVisible(ent, target)) continue; if (zcheck && (ent->m_vecOrigin().z - LOCAL_E->m_vecOrigin().z) > 200.0f) continue; float scr = ent->m_flDistance(); - if (hacks::tf2::backtrack::backtrack.isBacktrackEnabled && demoknight_mode) + if (hacks::tf2::backtrack::isBacktrackEnabled && demoknight_mode) { - auto data = hacks::tf2::backtrack::backtrack.getClosestEntTick(ent, LOCAL_E->m_vecOrigin(), hacks::tf2::backtrack::Backtrack::defaultTickFilter); + auto data = hacks::tf2::backtrack::getClosestEntTick(ent, LOCAL_E->m_vecOrigin(), hacks::tf2::backtrack::defaultTickFilter); // No entity if (!data) scr = FLT_MAX; diff --git a/src/hacks/Trigger.cpp b/src/hacks/Trigger.cpp index eb002251..86a59de7 100644 --- a/src/hacks/Trigger.cpp +++ b/src/hacks/Trigger.cpp @@ -11,6 +11,7 @@ #include #include #include +#include "Backtrack.hpp" namespace hacks::shared::triggerbot { @@ -96,7 +97,7 @@ void CreateMove() CachedEntity *ent = nullptr; std::optional bt_data; - if (!hacks::tf2::backtrack::backtrack.isBacktrackEnabled) + if (!hacks::tf2::backtrack::isBacktrackEnabled) ent = FindEntInSight(EffectiveTargetingRange()); // Backtrack, use custom filter to check if tick is in crosshair else @@ -115,7 +116,7 @@ void CreateMove() forward = forward * EffectiveTargetingRange() + g_pLocalPlayer->v_Eye; // Call closest tick with our Tick filter func - auto closest_data = hacks::tf2::backtrack::backtrack.getClosestTick(g_pLocalPlayer->v_Eye, hacks::tf2::backtrack::backtrack.defaultEntFilter, tick_filter); + auto closest_data = hacks::tf2::backtrack::getClosestTick(g_pLocalPlayer->v_Eye, hacks::tf2::backtrack::defaultEntFilter, tick_filter); // No results, try to grab a building if (!closest_data) @@ -127,7 +128,7 @@ void CreateMove() // Assign entity ent = (*closest_data).first; bt_data = (*closest_data).second; - hacks::tf2::backtrack::backtrack.SetBacktrackData(ent, *bt_data); + hacks::tf2::backtrack::SetBacktrackData(ent, *bt_data); } } @@ -136,7 +137,7 @@ void CreateMove() return; // Determine whether the triggerbot should shoot, then act accordingly - if (IsTargetStateGood(ent, bt_data)) + if (IsTargetStateGood(ent, bt_data ? &*bt_data : nullptr)) { target_time = backup_time; if (delay) @@ -242,7 +243,7 @@ bool ShouldShoot() } // A second check to determine whether a target is good enough to be aimed at -bool IsTargetStateGood(CachedEntity *entity, std::optional tick) +bool IsTargetStateGood(CachedEntity *entity, hacks::tf2::backtrack::BacktrackData *tick) { // Check for Players if (entity->m_Type() == ENTITY_PLAYER) diff --git a/src/hooks/SendDatagram.cpp b/src/hooks/SendDatagram.cpp index 53aaca6a..fc69f5c0 100644 --- a/src/hooks/SendDatagram.cpp +++ b/src/hooks/SendDatagram.cpp @@ -10,13 +10,13 @@ namespace hooked_methods { DEFINE_HOOKED_METHOD(SendDatagram, int, INetChannel *ch, bf_write *buf) { - if (!isHackActive() || !ch || CE_BAD(LOCAL_E) || std::floor(*hacks::tf2::backtrack::backtrack.latency) == 0) + if (!isHackActive() || !ch || CE_BAD(LOCAL_E) || std::floor(*hacks::tf2::backtrack::latency) == 0) return original::SendDatagram(ch, buf); int in = ch->m_nInSequenceNr; int state = ch->m_nInReliableState; // Do backtrack things - hacks::tf2::backtrack::backtrack.adjustPing(ch); + hacks::tf2::backtrack::adjustPing(ch); int ret = original::SendDatagram(ch, buf); ch->m_nInSequenceNr = in; diff --git a/src/hooks/visual/DrawModelExecute.cpp b/src/hooks/visual/DrawModelExecute.cpp index b0d1dc39..e9f7619c 100644 --- a/src/hooks/visual/DrawModelExecute.cpp +++ b/src/hooks/visual/DrawModelExecute.cpp @@ -45,7 +45,7 @@ DEFINE_HOOKED_METHOD(DrawModelExecute, void, IVModelRender *this_, const DrawMod if (!isHackActive()) return original::DrawModelExecute(this_, state, info, bone); - if (!(hacks::tf2::backtrack::backtrack.isBacktrackEnabled /*|| (hacks::shared::antiaim::force_fakelag && hacks::shared::antiaim::isEnabled())*/ || spectator_target || no_arms || no_hats || (*clean_screenshots && g_IEngine->IsTakingScreenshot()) || CE_BAD(LOCAL_E) || !LOCAL_E->m_bAlivePlayer())) + if (!(hacks::tf2::backtrack::isBacktrackEnabled /*|| (hacks::shared::antiaim::force_fakelag && hacks::shared::antiaim::isEnabled())*/ || spectator_target || no_arms || no_hats || (*clean_screenshots && g_IEngine->IsTakingScreenshot()) || CE_BAD(LOCAL_E) || !LOCAL_E->m_bAlivePlayer())) { return original::DrawModelExecute(this_, state, info, bone); } @@ -114,7 +114,7 @@ DEFINE_HOOKED_METHOD(DrawModelExecute, void, IVModelRender *this_, const DrawMod aa_draw = false; angles.y = backup; }*/ - if (hacks::tf2::backtrack::backtrack.chams && hacks::tf2::backtrack::backtrack.isBacktrackEnabled) + if (hacks::tf2::backtrack::chams && hacks::tf2::backtrack::isBacktrackEnabled) { const char *name = g_IModelInfo->GetModelName(info.pModel); if (name) @@ -129,7 +129,7 @@ DEFINE_HOOKED_METHOD(DrawModelExecute, void, IVModelRender *this_, const DrawMod { // Get Backtrack data for target entity - auto good_ticks = hacks::tf2::backtrack::backtrack.getGoodTicks(info.entity_index); + auto good_ticks = hacks::tf2::backtrack::getGoodTicks(info.entity_index); // Check if valid if (!good_ticks.empty()) @@ -145,15 +145,15 @@ DEFINE_HOOKED_METHOD(DrawModelExecute, void, IVModelRender *this_, const DrawMod rgba_t mod_original; // Save color just in case, then set to team color g_IVRenderView->GetColorModulation(mod_original.rgba); - g_IVRenderView->SetColorModulation(*hacks::tf2::backtrack::backtrack.chams_color); + g_IVRenderView->SetColorModulation(*hacks::tf2::backtrack::chams_color); // Important for Depth ptr->DepthRange(0.0f, 1.0f); // Apply our material - if (hacks::tf2::backtrack::backtrack.chams_solid) + if (hacks::tf2::backtrack::chams_solid) g_IVModelRender->ForcedMaterialOverride(mat_dme_chams); // Draw as many ticks as desired - for (unsigned i = 0; i <= (unsigned) std::max(*hacks::tf2::backtrack::backtrack.chams_ticks, 1); i++) + for (unsigned i = 0; i <= (unsigned) std::max(*hacks::tf2::backtrack::chams_ticks, 1); i++) { // Can't draw more than we have if (i >= good_ticks.size()) @@ -180,7 +180,7 @@ DEFINE_HOOKED_METHOD(DrawModelExecute, void, IVModelRender *this_, const DrawMod } // Don't do it when we are trying to enforce backtrack chams - if (!hacks::tf2::backtrack::backtrack.isDrawing) + if (!hacks::tf2::backtrack::isDrawing) return original::DrawModelExecute(this_, state, info, bone); } // namespace hooked_methods } // namespace hooked_methods diff --git a/src/visual/EffectChams.cpp b/src/visual/EffectChams.cpp index d1627c79..46c1334f 100644 --- a/src/visual/EffectChams.cpp +++ b/src/visual/EffectChams.cpp @@ -348,7 +348,7 @@ void EffectChams::Render(int x, int y, int w, int h) PROF_SECTION(DRAW_chams); if (!isHackActive() || disable_visuals) return; - if (!effect_chams::enable && !(hacks::tf2::backtrack::backtrack.chams && hacks::tf2::backtrack::backtrack.isBacktrackEnabled)) + if (!effect_chams::enable && !(hacks::tf2::backtrack::chams && hacks::tf2::backtrack::isBacktrackEnabled)) return; if (g_Settings.bInvalid) return; @@ -356,7 +356,7 @@ void EffectChams::Render(int x, int y, int w, int h) Init(); if (!isHackActive() || (g_IEngine->IsTakingScreenshot() && clean_screenshots)) return; - if (hacks::tf2::backtrack::backtrack.chams && hacks::tf2::backtrack::backtrack.isBacktrackEnabled) + if (hacks::tf2::backtrack::chams && hacks::tf2::backtrack::isBacktrackEnabled) { CMatRenderContextPtr ptr(GET_RENDER_CONTEXT); BeginRenderChams(); @@ -368,9 +368,9 @@ void EffectChams::Render(int x, int y, int w, int h) if (CE_BAD(ent) || i == g_IEngine->GetLocalPlayer() || !ent->m_bAlivePlayer() || ent->m_Type() != ENTITY_PLAYER) continue; // Entity won't draw in some cases so help the chams a bit - hacks::tf2::backtrack::backtrack.isDrawing = true; + hacks::tf2::backtrack::isDrawing = true; RAW_ENT(ent)->DrawModel(1); - hacks::tf2::backtrack::backtrack.isDrawing = false; + hacks::tf2::backtrack::isDrawing = false; } EndRenderChams(); }