diff --git a/include/helpers.hpp b/include/helpers.hpp index effb9db3..0356f549 100644 --- a/include/helpers.hpp +++ b/include/helpers.hpp @@ -143,8 +143,9 @@ bool IsVectorVisible(Vector a, Vector b, bool enviroment_only = false, CachedEnt // A Special function for navparser to check if a Vector is visible. bool IsVectorVisibleNavigation(Vector a, Vector b, unsigned int mask = MASK_SHOT_HULL); float ProjGravMult(int class_id, float x_speed); -bool didProjectileHit(Vector start_point, Vector end_point, CachedEntity *entity, float projectile_size, bool grav_comp, trace_t* tracer = nullptr); +bool didProjectileHit(Vector start_point, Vector end_point, CachedEntity *entity, float projectile_size, bool grav_comp, trace_t *tracer = nullptr); Vector getShootPos(Vector angle); +bool is_rocket(int); Vector GetForwardVector(Vector origin, Vector viewangles, float distance, CachedEntity *punch_entity = nullptr); Vector GetForwardVector(float distance, CachedEntity *punch_entity = nullptr); CachedEntity *getClosestEntity(Vector vec); diff --git a/src/hacks/Aimbot.cpp b/src/hacks/Aimbot.cpp index f80a4e6c..1c3d832c 100644 --- a/src/hacks/Aimbot.cpp +++ b/src/hacks/Aimbot.cpp @@ -199,14 +199,14 @@ inline float projectileHitboxSize(int projectile_size) case CL_CLASS(CTFPipebombLauncher): case CL_CLASS(CTFGrenadeLauncher): case CL_CLASS(CTFCannon): - return 6.5f; + return 4.0f; case CL_CLASS(CTFFlareGun): case CL_CLASS(CTFFlareGun_Revenge): case CL_CLASS(CTFDRGPomson): - return 3.0f; + return 2.0f; case CL_CLASS(CTFSyringeGun): case CL_CLASS(CTFCompoundBow): - return 2.0f; + return 1.0f; default: return 3.0f; } @@ -1169,6 +1169,15 @@ bool IsTargetStateGood(CachedEntity *entity) return false; } + +float secant_x(float in) +{ + return 1.0f / (cos(in)); +} +float csc_x(float in) +{ + return 1.0f / (sin(in)); +} bool Aim(CachedEntity *entity) { if (*miss_chance > 0 && UniformRandomInt(0, 99) < *miss_chance) @@ -1180,47 +1189,52 @@ bool Aim(CachedEntity *entity) if (!IsEntityVectorVisible(entity, is_it_good, true, MASK_SHOT_HULL, nullptr, true)) return false; - Vector angles = GetAimAtAngles(g_pLocalPlayer->v_Eye, is_it_good, LOCAL_E); + Vector player_velocity; + velocity::EstimateAbsVelocity(RAW_ENT(LOCAL_E), player_velocity); + Vector angles = GetAimAtAngles(g_pLocalPlayer->v_Eye + player_velocity * TICKS_TO_TIME(1), is_it_good, LOCAL_E); if (projectileAimbotRequired) // unfortunately you have to check this twice, otherwise you'd have to run GetAimAtAngles far too early { - const Vector &orig = getShootPos(angles); const bool grav_comp = (0.01f < cur_proj_grav); + Vector shot_orig = getShootPos(angles); if (grav_comp) { - const QAngle &angl = VectorToQAngle(angles); - Vector end_targ = is_it_good; - Vector fwd, right, up; - AngleVectors3(angl, &fwd, &right, &up); - // I have no clue why this is 200.0f, No where in the SDK explains this. - // It appears to work though - Vector vel = 0.9f * ((fwd * cur_proj_speed) + (up * 200.0f)); - fwd.z = 0.0f; - fwd.NormalizeInPlace(); - float alongvel = std::sqrt(vel.x * vel.x + vel.y * vel.y); - fwd *= alongvel; - const float gravity = cur_proj_grav * g_ICvar->FindVar("sv_gravity")->GetFloat() * -1.0f; - const float maxTime = 2.5f; - const float timeStep = 0.01f; - Vector curr_pos = orig; - trace_t ptr_trace; - Vector last_pos = orig; - const IClientEntity *rawest_ent = RAW_ENT(entity); - for (float t = 0.0f; t < maxTime; t += timeStep, last_pos = curr_pos) + float max_vel = cur_proj_speed; + float sv_gravity = g_ICvar->FindVar("sv_gravity")->GetFloat() * cur_proj_grav; + float dist = (cur_proj_speed * cur_proj_speed) / (sv_gravity); + if (g_pLocalPlayer->v_Eye.DistTo(is_it_good) > dist) + return false; + float angles_x = DEG2RAD(angles.x); + float angles_y = DEG2RAD(angles.y); + float t_x = ((is_it_good.x - shot_orig.x) * secant_x(angles_x) * secant_x(angles_y)) / cur_proj_speed; + float t_y = ((is_it_good.y - shot_orig.y) * secant_x(angles_x) * csc_x(angles_y)) / cur_proj_speed; + float t_z = -1.0f * (cur_proj_speed * sin(angles_x) + std::sqrt(-2 * sv_gravity * is_it_good.z + 2 * sv_gravity * shot_orig.z + cur_proj_speed * cur_proj_speed * sin(angles_x) * sin(angles_x))) / (cur_proj_grav); + if (!t_z) + t_z = 9999999999.0f; + + if (t_z < 0.0f) + t_z = 9999999999.0f; + if (t_x < 0.0f) + t_x = 999999999.0f; + if (t_y < 0.0f) + t_y = 99999999.0f; + float t_min = std::min(t_x, t_y); + t_min = std::min(t_min, t_z); + const float t_min_inc = t_min / 10.0f; + Vector second_iter = shot_orig; + for (float t = 0.0f; t < t_min; t += t_min_inc) { - curr_pos.x = orig.x + fwd.x * t; - curr_pos.y = orig.y + fwd.y * t; - curr_pos.z = orig.z + vel.z * t + 0.5f * gravity * t * t; - if (!didProjectileHit(last_pos, curr_pos, entity, projectileHitboxSize(LOCAL_W->m_iClassID()), true, &ptr_trace) || (IClientEntity *) ptr_trace.m_pEnt == rawest_ent) - break; + Vector loop_vec = shot_orig; + loop_vec.x += (cur_proj_speed * cos(angles_x) * cos(angles_y)) * t; + loop_vec.y += (cur_proj_speed * cos(angles_x) * sin(angles_y)) * t; + loop_vec.z += (cur_proj_speed * -1.0f * sin(angles_x)) * t - 0.5f * sv_gravity * t * t; + if (!didProjectileHit(second_iter, loop_vec, entity, projectileHitboxSize(LOCAL_W->m_iClassID()), grav_comp)) + return false; + + second_iter = loop_vec; } - if (!didProjectileHit(end_targ, ptr_trace.endpos, entity, projectileHitboxSize(LOCAL_W->m_iClassID()), true, &ptr_trace)) - return false; - Vector ent_check = entity->m_vecOrigin(); - if (!didProjectileHit(last_pos, ent_check, entity, projectileHitboxSize(LOCAL_W->m_iClassID()), false)) - return false; } - else if (!didProjectileHit(orig, is_it_good, entity, projectileHitboxSize(LOCAL_W->m_iClassID()), grav_comp)) + else if (!didProjectileHit(shot_orig, is_it_good, entity, projectileHitboxSize(LOCAL_W->m_iClassID()), grav_comp)) return false; } if (fov > 0 && cd.fov > fov) @@ -1512,7 +1526,7 @@ int autoHitbox(CachedEntity *target) } // Rockets and stickies should aim at the foot if the target is on the ground - else if (ci == CL_CLASS(CTFPipebombLauncher) || ci == CL_CLASS(CTFRocketLauncher) || ci == CL_CLASS(CTFParticleCannon) || ci == CL_CLASS(CTFRocketLauncher_AirStrike) || ci == CL_CLASS(CTFRocketLauncher_Mortar) || ci == CL_CLASS(CTFRocketLauncher_DirectHit)) + else if (ci == CL_CLASS(CTFPipebombLauncher) || is_rocket(ci)) { bool ground = CE_INT(target, netvar.iFlags) & (1 << 0); if (ground) diff --git a/src/hacks/ESP.cpp b/src/hacks/ESP.cpp index 0d068f7f..da026392 100644 --- a/src/hacks/ESP.cpp +++ b/src/hacks/ESP.cpp @@ -76,13 +76,12 @@ static settings::Boolean proj_enemy{ "esp.projectile.enemy-only", "true" }; static settings::Boolean entity_info{ "esp.debug.entity", "false" }; static settings::Boolean entity_model{ "esp.debug.model", "false" }; static settings::Boolean entity_id{ "esp.debug.id", "true" }; - // Forward declarations class ESPData { public: int string_count{ 0 }; - boost::unordered_flat_map strings{}; + std::vector> strings{}; rgba_t color{ colors::empty }; bool needs_paint{ false }; bool has_collide{ false }; @@ -95,8 +94,8 @@ boost::unordered_flat_map data; inline void AddEntityString(CachedEntity *entity, const std::string &string, const rgba_t &color = colors::empty) { ESPData &entity_data = data[entity->m_IDX]; - if (entity_data.strings.try_emplace(string, color).second) - ++(entity_data.string_count); + entity_data.strings.emplace_back(string, color); + ++(entity_data.string_count); entity_data.needs_paint = true; } inline bool hitboxUpdate(CachedEntity *ent) @@ -926,6 +925,8 @@ void ProcessEntityPT() if (ent_data.string_count) DrawStrings(type, transparent, screen, ent_data, ent); } + for (auto &[key, esp_data] : data) + esp_data.strings.clear(); } static std::string write_str; // Used to process entities from CreateMove diff --git a/src/hacks/Warp.cpp b/src/hacks/Warp.cpp index d1c40ada..00d2a171 100644 --- a/src/hacks/Warp.cpp +++ b/src/hacks/Warp.cpp @@ -17,6 +17,7 @@ #include "Think.hpp" #include "Aimbot.hpp" #include +#include namespace hacks::tf2::warp { static settings::Boolean enabled{ "warp.enabled", "false" }; @@ -47,7 +48,7 @@ static settings::Boolean warp_left{ "warp.on-hit.left", "true" }; static settings::Boolean warp_right{ "warp.on-hit.right", "true" }; static settings::Boolean debug_seqout{ "debug.warp_seqout", "false" }; -static std::vector> proj_map; +static boost::unordered_flat_map proj_map; // Hidden control rvars for communtiy servers static settings::Int maxusrcmdprocessticks("warp.maxusrcmdprocessticks", "24"); @@ -261,118 +262,169 @@ bool shouldRapidfire() return buttons_pressed; } + void dodgeProj(CachedEntity *proj_ptr) { Vector eav; - + const Vector player_origin = RAW_ENT(LOCAL_E)->GetAbsOrigin(); velocity::EstimateAbsVelocity(RAW_ENT(proj_ptr), eav); // Sometimes EstimateAbsVelocity returns completely BS values (as in 0 for everything on say a rocket) // The ent could also be an in-place sticky which we don't care about - we want to catch it while it's in the air if (1 < eav.Length()) { - Vector proj_pos = RAW_ENT(proj_ptr)->GetAbsOrigin(); - Vector player_pos = RAW_ENT(LOCAL_E)->GetAbsOrigin(); - - float displacement = proj_pos.DistToSqr(player_pos); - float displacement_temp = displacement - 1; - float min_displacement = displacement_temp - 1; - float multipler = 0.01f; + Vector proj_pos = RAW_ENT(proj_ptr)->GetAbsOrigin(); + float multipler = 2.0f; bool add_grav = false; + float high_time = 10; + float low_time = 0; + float high_displacement = std::numeric_limits::max(); float curr_grav = g_ICvar->FindVar("sv_gravity")->GetFloat(); - if (proj_ptr->m_Type() == ENTITY_PROJECTILE) + if (proj_ptr->m_Type() == ENTITY_PROJECTILE && ProjGravMult(proj_ptr->m_iClassID(), eav.Length()) > 0.001f) add_grav = true; // Couldn't find a cleaner way to get the projectiles gravity based on just having a pointer to the projectile itself curr_grav = curr_grav * ProjGravMult(proj_ptr->m_iClassID(), eav.Length()); // Optimization loop. Just checks if the projectile can possibly hit within ~141HU - while (displacement_temp < displacement) + + if (!add_grav) + { + float c_1 = ((float) (player_origin - proj_pos).Dot(eav)) / ((float) eav.Dot(eav)); + // logging::Info("C_1 is %f for the entity id %d, the velocity is %f. The distance is %f", c_1, proj_ptr->m_Type(), eav.Length(), (eav * c_1 + proj_pos).DistTo(player_origin)); + if (c_1 > 0) + { + float dist = (eav * c_1 + proj_pos).DistToSqr(player_origin); + if (dist > 40000) + proj_map.insert({ proj_ptr, Vector(0, 0, 0) }); + else + proj_map.insert({ proj_ptr, eav }); + } + return; + } + float last_displacement = high_displacement; + int sign = 1; + int repeats = 0; + while (high_time > 0.01f) { - Vector temp_pos = (eav * multipler) + proj_pos; - if (add_grav) - temp_pos.z = temp_pos.z - 0.5 * curr_grav * multipler * multipler; - displacement_temp = temp_pos.DistToSqr(player_pos); - if (displacement_temp < min_displacement) - min_displacement = displacement_temp; + Vector temp_pos = (eav * high_time) + proj_pos; + temp_pos.z = temp_pos.z - 0.5 * curr_grav * high_time * high_time; + float curr_disp = temp_pos.DistToSqr(player_origin); + if (curr_disp < high_displacement) + { + repeats = 0; + high_displacement = curr_disp; + high_time -= multipler * sign; + if (multipler > 0.05f) + multipler /= 2.0f; + } + else if (last_displacement < curr_disp) + { + ++repeats; + sign *= -1; + } else - break; - - multipler += 0.01f; + { + repeats = 0; + } + if (repeats > 2) + { + // logging::Info(" entity id %d, the velocity is %f. The distance is %f", proj_ptr->m_Type(), eav.Length(), curr_disp); + proj_map.insert({ proj_ptr, Vector(0, 0, 0) }); + return; + } + last_displacement = curr_disp; + if (high_displacement < 40000) + { + // logging::Info(" entity id %d, the velocity is %f. The distance is %f", proj_ptr->m_Type(), eav.Length(), curr_disp); + proj_map.insert({ proj_ptr, eav }); + return; + } + else + { + // logging::Info(" entity id %d, the velocity is %f. The distance is %f", proj_ptr->m_Type(), eav.Length(), curr_disp); + proj_map.insert({ proj_ptr, Vector(0, 0, 0) }); + return; + } } - if (min_displacement < 20000) - proj_map.emplace_back((std::make_tuple(eav, proj_ptr))); - else - proj_map.emplace_back((std::make_tuple(Vector{ 0, 0, 0 }, proj_ptr))); } } +float hitbox_size_proj(int class_id) +{ + switch (class_id) + { + case CL_CLASS(CTFProjectile_Rocket): + return 4.0f; + case CL_CLASS(CTFGrenadePipebombProjectile): + return 4.0f; + case CL_CLASS(CTFProjectile_Flare): + return 3.0f; + case CL_CLASS(CTFProjectile_EnergyBall): + return 8.0f; + case CL_CLASS(CTFProjectile_GrapplingHook): + case CL_CLASS(CTFProjectile_HealingBolt): + case CL_CLASS(CTFProjectile_Arrow): + return 1.0f; + case CL_CLASS(CTFProjectile_SentryRocket): + return 2.0f; + case CL_CLASS(CTFProjectile_Throwable): + return 4.0f; + } + return 1.0f; +} static void dodgeProj_cm() { if (!LOCAL_E->m_bAlivePlayer() || proj_map.empty() || !dodge_projectile) return; - Vector player_pos = RAW_ENT(LOCAL_E)->GetAbsOrigin(); - const int max_size = proj_map.size(); - for (int i = 0; i < max_size; ++i) + Vector player_pos = RAW_ENT(LOCAL_E)->GetAbsOrigin(); + for (const auto &[proj_ptr, proj_vec] : proj_map) { - auto curr_tuple = proj_map[i]; - Vector key = std::get<0>(curr_tuple); - CachedEntity *val = std::get<1>(curr_tuple); - if (key.Length() < 0.1f) + if (proj_vec.Length() < 0.1f) { - if (CE_GOOD(val)) + if (CE_GOOD(proj_ptr)) continue; else - proj_map.erase((proj_map.begin() + i)); + proj_map.erase(proj_ptr); continue; } - if (CE_GOOD(val)) + if (CE_GOOD(proj_ptr)) { // Since we are sending this warp next tick we need to compensate for fast moving projectiles // 2 Ticks in advance is a fairly safe interval - Vector velocity_comp = key * 2 * TICK_INTERVAL; - velocity_comp.z -= 2 * TICK_INTERVAL * g_ICvar->FindVar("sv_gravity")->GetFloat() * ProjGravMult(val->m_iClassID(), key.Length()); - - Vector proj_next_tik = RAW_ENT(val)->GetAbsOrigin() + velocity_comp; - float diff = proj_next_tik.DistToSqr(player_pos); + float c_1 = ((float) (g_pLocalPlayer->v_Origin - RAW_ENT(proj_ptr)->GetAbsOrigin()).Dot(proj_vec)) / ((float) proj_vec.Dot(proj_vec)); + float ticks = TIME_TO_TICKS(c_1); + if (ticks > 30) + continue; + float max_speed = CE_FLOAT(LOCAL_E, netvar.m_flMaxspeed); + Vector dist = RAW_ENT(proj_ptr)->GetAbsOrigin(); + float proj_hitbox = hitbox_size_proj(proj_ptr->m_iClassID()); // Warp sooner for fast moving projectiles. - if (diff < (15000 * (key.Length() / 1000))) + trace_t trace; + Ray_t ray; + ray.Init(dist, player_pos, Vector(-proj_hitbox, -proj_hitbox, -proj_hitbox), Vector(proj_hitbox, proj_hitbox, proj_hitbox)); + g_ITrace->TraceRay(ray, MASK_SHOT_HULL, NULL, &trace); + if (((IClientEntity *) trace.m_pEnt) != RAW_ENT(LOCAL_E) && trace.endpos.DistToSqr(player_pos) < 10000 && (ProjGravMult(proj_ptr->m_iClassID(), proj_vec.Length()) < 0.001f || proj_ptr->m_iClassID() == CL_CLASS(CTFGrenadePipebombProjectile))) { - trace_t trace; - Ray_t ray; - ray.Init(proj_next_tik, player_pos, Vector(0, -8, -8), Vector(0, 8, 8)); - g_ITrace->TraceRay(ray, MASK_SHOT_HULL, &trace::filter_default, &trace); - if (trace.DidHit()) - { - // We need to determine wether the projectile is coming in from the left or right of us so we don't warp into the projectile. - Vector result = GetAimAtAngles(g_pLocalPlayer->v_Eye, RAW_ENT(val)->GetAbsOrigin(), LOCAL_E) - g_pLocalPlayer->v_OrigViewangles; + ray.Init(trace.endpos, player_pos, Vector(0, 0, 0), Vector(0, 0, 0)); + g_ITrace->TraceRay(ray, MASK_SHOT_HULL, NULL, &trace); + } + if (((IClientEntity *) trace.m_pEnt) == RAW_ENT(LOCAL_E) || trace.DidHit() || trace.endpos.DistToSqr(player_pos) < 10) + { + // logging::Info("ENTERED"); + // We need to determine wether the projectile is coming in from the left or right of us so we don't warp into the projectile. + Vector result = GetAimAtAngles(g_pLocalPlayer->v_Eye, RAW_ENT(proj_ptr)->GetAbsOrigin(), LOCAL_E) - g_pLocalPlayer->v_OrigViewangles; - if (0 <= result.y) - yaw_amount = -90.0f; - else - yaw_amount = 90.0f; - if ((IClientEntity *) trace.m_pEnt == RAW_ENT(LOCAL_E)) - { - was_hurt = true; - warp_dodge = true; - proj_map.erase((proj_map.begin() + i)); - } - } // It didn't hit anything but it has been proven to be very close to us. Dodge. (This is for the huntsman+pills) + if (0 <= result.y) + yaw_amount = -90.0f; else - { - was_hurt = true; - warp_dodge = true; - Vector result = GetAimAtAngles(g_pLocalPlayer->v_Eye, RAW_ENT(val)->GetAbsOrigin(), LOCAL_E) - g_pLocalPlayer->v_OrigViewangles; - if (0 <= result.y) - yaw_amount = -90.0f; - else - yaw_amount = 90.0f; - - proj_map.erase((proj_map.begin() + i)); - } + yaw_amount = 90.0f; + was_hurt = true; + warp_dodge = true; + proj_map.erase(proj_ptr); } } else - proj_map.erase((proj_map.begin() + i)); + proj_map.erase(proj_ptr); } } // Should we warp? @@ -720,7 +772,7 @@ static void CreateMove() warpLogic(); if ((bool) hacks::tf2::warp::dodge_projectile && CE_GOOD(g_pLocalPlayer->entity)) for (auto const &ent : entity_cache::valid_ents) - if (ent->m_Type() == ENTITY_PROJECTILE && ent->m_bEnemy() && std::find_if(proj_map.begin(), proj_map.end(), [=](const auto &item) { return std::get<1>(item) == ent; }) == proj_map.end()) + if (ent->m_Type() == ENTITY_PROJECTILE && ent->m_bEnemy() && proj_map.find(ent) == proj_map.end()) dodgeProj(ent); // Either in rapidfire, or the tick just after. Either way we need to force bSendPackets in some way. bool should_rapidfire = shouldRapidfire(); @@ -1223,7 +1275,7 @@ static InitRoutine init( EC::Register(EC::CreateMove, CreateMove, "warp_createmove", EC::very_late); EC::Register(EC::CreateMoveWarp, CreateMove, "warp_createmovew", EC::very_late); EC::Register(EC::CreateMove_NoEnginePred, CreateMovePrePredict, "warp_prepredict"); - EC::Register(EC::CreateMove, dodgeProj_cm, "warp_dodgeproj", EC::very_early); + EC::Register(EC::CreateMove, dodgeProj_cm, "warp_dodgeproj", EC::average); EC::Register(EC::CreateMoveEarly, CreateMoveEarly, "warp_createmove_early", EC::very_early); g_IEventManager2->AddListener(&listener, "player_hurt", false); EC::Register( diff --git a/src/helpers.cpp b/src/helpers.cpp index fb879df3..f5db1708 100644 --- a/src/helpers.cpp +++ b/src/helpers.cpp @@ -28,7 +28,22 @@ std::vector &RegisteredCommandsList() static std::vector list{}; return list; } +bool is_rocket(int class_id) +{ + switch (class_id) + { + case CL_CLASS(CTFRocketLauncher): + case CL_CLASS(CTFParticleCannon): + case CL_CLASS(CTFRocketLauncher_AirStrike): + case CL_CLASS(CTFRocketLauncher_Mortar): + case CL_CLASS(CTFRocketLauncher_DirectHit): + return true; + default: + return false; + } + return false; +} void BeginConVars() { logging::Info("Begin ConVars"); @@ -661,7 +676,7 @@ bool didProjectileHit(Vector start_point, Vector end_point, CachedEntity *entity trace_obj = tracer; else trace_obj = new trace_t; - ray.Init(start_point, end_point, Vector(0, -projectile_size, -projectile_size), Vector(0, projectile_size, projectile_size)); + ray.Init(start_point, end_point, Vector(-projectile_size, -projectile_size, -projectile_size), Vector(projectile_size, projectile_size, projectile_size)); g_ITrace->TraceRay(ray, MASK_SHOT_HULL, &trace::filter_default, trace_obj); return (((IClientEntity *) trace_obj->m_pEnt) == RAW_ENT(entity) || (grav_comp ? !trace_obj->DidHit() : false)); } @@ -1880,7 +1895,7 @@ Vector getShootPos(Vector angle) // Huntsman case CL_CLASS(CTFCompoundBow): - vecOffset = Vector(23.5f, 8.0f, -3.0f); + vecOffset = Vector(23.5f, -8.0f, -3.0f); break; default: diff --git a/src/prediction.cpp b/src/prediction.cpp index 861f6c41..d55ddcd2 100644 --- a/src/prediction.cpp +++ b/src/prediction.cpp @@ -319,7 +319,7 @@ void Prediction_PaintTraverse() for (auto const &ent : entity_cache::player_cache) { - + if (CE_BAD(ent) || !ent->m_bAlivePlayer()) continue; @@ -504,11 +504,10 @@ Vector EnginePrediction(CachedEntity *entity, float time, Vector *vecVelocity) } std::pair ProjectilePrediction_Engine(CachedEntity *ent, int hb, float speed, float gravity, float entgmod, float proj_startvelocity) { - Vector origin = ent->m_vecOrigin(); + Vector origin = RAW_ENT(ent)->GetAbsOrigin(); Vector velocity; velocity::EstimateAbsVelocity(RAW_ENT(ent), velocity); - Vector hitbox; - GetHitbox(ent, hb, hitbox); + Vector hitbox = ent->hitboxes.GetHitbox(hb)->center; Vector hitbox_offset = hitbox - origin; if (!sv_gravity) @@ -561,7 +560,7 @@ std::pair ProjectilePrediction_Engine(CachedEntity *ent, int hb, // Compensate for ping besttime += g_IEngine->GetNetChannelInfo()->GetLatency(FLOW_OUTGOING) + cl_interp->GetFloat(); bestpos.z += (sv_gravity->GetFloat() / 2.0f * besttime * besttime * gravity); - // S = at^2/2 ; t = sqrt(2S/a)*/ + // S = at^2/2 ; t = sqrt(2S/a)*/ Vector result = bestpos + hitbox_offset; Vector result_initialvel = result; result_initialvel.z -= proj_startvelocity * besttime; @@ -732,9 +731,9 @@ static InitRoutine init( // Don't run if we don't use it if (!hacks::shared::aimbot::engine_projpred && !debug_pp_draw) return; - for (auto const &ent: entity_cache::player_cache) + for (auto const &ent : entity_cache::player_cache) { - + auto &buffer = previous_positions.at(ent->m_IDX - 1); if (CE_BAD(LOCAL_E) || CE_BAD(ent) || !ent->m_bAlivePlayer())