nullworks/cathook
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Don't use a seperate class for backtrack

Browse Source
This commit is contained in:
BenCat07 2020-05-14 13:23:14 +02:00
parent a61290188b
commit 8f22a56a23
13 changed files with 170 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
include/hacks/Backtrack.hpp
View File

@ -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<CIncomingSequence> sequences;
int current_tickcount;
std::array<std::unique_ptr<std::array<BacktrackData, 67>>, 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<BacktrackData> bt_data;
bool isEnabled();
float getLatency();
int getTicks();
bool getBestInternalTick(CachedEntity *, BacktrackData &, std::optional<BacktrackData> &);
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<BacktrackData> getGoodTicks(int);
std::optional<BacktrackData> getBestTick(CachedEntity *, std::function<bool(CachedEntity *, BacktrackData &, std::optional<BacktrackData> &)>);
std::optional<BacktrackData> getClosestEntTick(CachedEntity *, Vector, std::function<bool(CachedEntity *, BacktrackData)>);
std::optional<std::pair<CachedEntity *, BacktrackData>> getClosestTick(Vector, std::function<bool(CachedEntity *)>, std::function<bool(CachedEntity *, BacktrackData)>);
// Various functions for getting backtrack ticks
std::vector<BacktrackData> getGoodTicks(int);
std::optional<BacktrackData> getBestTick(CachedEntity *, std::function<bool(CachedEntity *, BacktrackData &, std::optional<BacktrackData> &)>);
std::optional<BacktrackData> getClosestEntTick(CachedEntity *, Vector, std::function<bool(CachedEntity *, BacktrackData)>);
std::optional<std::pair<CachedEntity *, BacktrackData>> getClosestTick(Vector, std::function<bool(CachedEntity *)>, std::function<bool(CachedEntity *, BacktrackData)>);
void SetBacktrackData(CachedEntity *ent, BacktrackData);
};
extern hacks::tf2::backtrack::Backtrack backtrack;
void SetBacktrackData(CachedEntity *ent, BacktrackData);
} // namespace hacks::tf2::backtrack

7
include/hacks/Trigger.hpp
View File

@ -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<hacks::tf2::backtrack::BacktrackData> 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();

4
src/crits.cpp
View File

@ -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)
{

24
src/hacks/Aimbot.cpp
View File

@ -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> &, 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);

12
src/hacks/AutoBackstab.cpp
View File

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

9
src/hacks/AutoJoin.cpp
View File

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

100
src/hacks/Backtrack.cpp
View File

@ -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<CIncomingSequence> sequences;
static int current_tickcount;
static std::array<std::unique_ptr<std::array<BacktrackData, 67>>, 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<BacktrackData> bt_data;
static bool isEnabled();
static float getLatency();
static int getTicks();
static bool getBestInternalTick(CachedEntity *, BacktrackData &, std::optional<BacktrackData> &);
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<BacktrackData> &best_tick)
bool getBestInternalTick(CachedEntity *, BacktrackData &data, std::optional<BacktrackData> &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<BacktrackData> data = getBestTick(ent, std::bind(&Backtrack::getBestInternalTick, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
std::optional<BacktrackData> 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<BacktrackData> Backtrack::getGoodTicks(int entidx)
std::vector<BacktrackData> getGoodTicks(int entidx)
{
std::vector<BacktrackData> to_return;
// Invalid
@ -377,7 +416,7 @@ std::vector<BacktrackData> Backtrack::getGoodTicks(int entidx)
}
// This function is so other files can Easily get the best tick matching their criteria
std::optional<BacktrackData> Backtrack::getBestTick(CachedEntity *ent, std::function<bool(CachedEntity *ent, BacktrackData &data, std::optional<BacktrackData> &best_tick)> callback)
std::optional<BacktrackData> getBestTick(CachedEntity *ent, std::function<bool(CachedEntity *ent, BacktrackData &data, std::optional<BacktrackData> &best_tick)> callback)
{
std::optional<BacktrackData> best_tick;
@ -396,7 +435,7 @@ std::optional<BacktrackData> 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<BacktrackData> Backtrack::getClosestEntTick(CachedEntity *ent, Vector vec, std::function<bool(CachedEntity *, BacktrackData)> tick_filter)
std::optional<BacktrackData> getClosestEntTick(CachedEntity *ent, Vector vec, std::function<bool(CachedEntity *, BacktrackData)> tick_filter)
{
std::optional<BacktrackData> return_value;
// No entry
@ -444,7 +483,7 @@ std::optional<BacktrackData> 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<std::pair<CachedEntity *, BacktrackData>> Backtrack::getClosestTick(Vector vec, std::function<bool(CachedEntity *)> ent_filter, std::function<bool(CachedEntity *, BacktrackData)> tick_filter)
std::optional<std::pair<CachedEntity *, BacktrackData>> getClosestTick(Vector vec, std::function<bool(CachedEntity *)> ent_filter, std::function<bool(CachedEntity *, BacktrackData)> tick_filter)
{
float distance = FLT_MAX;
CachedEntity *best_ent = nullptr;
@ -476,13 +515,12 @@ std::optional<std::pair<CachedEntity *, BacktrackData>> 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

21
src/hacks/Misc.cpp
View File

@ -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> &, 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> &, bool after) {

13
src/hacks/MiscAimbot.cpp
View File

@ -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<CachedEntity *, Vector> 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<CachedEntity *, Vector> 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;

11
src/hacks/Trigger.cpp
View File

@ -11,6 +11,7 @@
#include <hacks/Backtrack.hpp>
#include <PlayerTools.hpp>
#include <settings/Bool.hpp>
#include "Backtrack.hpp"
namespace hacks::shared::triggerbot
{
@ -96,7 +97,7 @@ void CreateMove()
CachedEntity *ent = nullptr;
std::optional<hacks::tf2::backtrack::BacktrackData> 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<hacks::tf2::backtrack::BacktrackData> tick)
bool IsTargetStateGood(CachedEntity *entity, hacks::tf2::backtrack::BacktrackData *tick)
{
// Check for Players
if (entity->m_Type() == ENTITY_PLAYER)

4
src/hooks/SendDatagram.cpp
View File

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

14
src/hooks/visual/DrawModelExecute.cpp
View File

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

8
src/visual/EffectChams.cpp
View File

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