Initial commit

This commit is contained in:
drof
2026-11-05 02:19:09 +01:00
commit 13f8503697
125 changed files with 17029 additions and 0 deletions
+283
View File
@@ -0,0 +1,283 @@
#include <include.h>
using namespace features;
bool c_aim::find_target(respawn::c_player* me, cache::entry_t* result, aim::find_context_t& ctx)
{
ctx.viable_targets = 0;
ctx.closest_distance = ctx.maximum_distance;
ctx.closest_fov = ctx.maximum_fov;
ctx.me = me;
ctx.my_position = me->origin();
ctx.my_view = me->view_offset();
ctx.my_angle = me->eye_angles();
size_t viable_targets{ };
aim::find_context_t target_ctx{ };
for (auto i = 0ull; i < g::p::ent_cache.count(); i++)
{
auto entity = g::p::ent_cache.get_neutral(i);
if (!entity.valid)
continue;
if (aim::is_target_viable(entity, ctx))
{
*result = entity;
target_ctx = ctx;
++viable_targets;
}
}
ctx = target_ctx;
return viable_targets;
}
bool c_aim::is_weapon_compatible(respawn::c_weapon* wpn) noexcept
{
auto name_idx = wpn->name_index();
if (name_idx == respawn::weapon_name_indexes::hands)
return false;
return true;
}
void c_aim::create_move(respawn::c_player* me, respawn::user_cmd_t* cmd)
{
if (!cfg::aim_enabled)
return;
if (!respawn::is_playing())
return;
if (me == nullptr)
return;
if (!respawn::is_alive(me) || respawn::is_knocked(me))
return;
auto* const my_wpn = me->get_active_weapon();
if (my_wpn == nullptr || !is_weapon_compatible(my_wpn))
return;
if (cfg::aim_bullet_time && !my_wpn->can_fire(me))
{
is_aiming = false;
return;
}
cache::entry_t target{ };
aim::find_context_t find_ctx{ };
find_ctx.maximum_distance = cfg::aim_distance;
find_ctx.maximum_fov = cfg::aim_fov;
if (cfg::aim_distance <= 0.1f)
find_ctx.maximum_distance = FLT_MAX;
if (g::p::cache.local_player.zooming)
find_ctx.maximum_fov /= 2.5f;
effective_max_fov_ = find_ctx.maximum_fov;
if (!find_target(me, &target, find_ctx))
{
is_aiming = false;
return;
}
auto bone_id = respawn::bone_id::head;
if (cfg::aim_random_hitbox)
bone_id = respawn::bone_id::torso_upper;
auto my_shoot_pos = me->view_offset();
auto hit_pos = find_ctx.aim_pos;
auto aim_ang = math::Angle3{};
if (cfg::aim_bullet_prediction)
{
auto get_distance = [](math::Vector3 target_pos, math::Vector3 our_pos)
{
float dist = math::sqrtf((our_pos.x - target_pos.x) * (our_pos.x - target_pos.x)
+ (our_pos.y - target_pos.y) * (our_pos.y - target_pos.y)
+ (our_pos.z - target_pos.z) * (our_pos.z - target_pos.z));
return dist * 0.01905f;
};
auto velocity = find_ctx.target_info.velocity;
if (velocity.Length2d() > 0.f)
{
auto world_gravity = 750.f;
auto distance = get_distance(hit_pos, my_shoot_pos) / 0.01905f;
auto bullet_speed = my_wpn->projectile_speed();
auto bullet_gravity = my_wpn->projectile_gravity();
auto travel_time = (distance / bullet_speed);
auto prediction_scale = max(cfg::aim_bullet_prediction_scale, bullet_gravity);
hit_pos.x += (velocity.x * travel_time) * prediction_scale;
hit_pos.y += (velocity.y * travel_time) * prediction_scale;
hit_pos.z += (world_gravity * travel_time * travel_time) * prediction_scale;
}
}
math::VectorAngles((hit_pos - my_shoot_pos), aim_ang);
auto my_angle = me->eye_angles();
auto my_angle_dyn = (!cfg::no_sway ? me->dyn_angles() : g::p::sway_angles);
if (cfg::aim_no_recoil > 0)
{
auto delta = (my_angle_dyn - my_angle);
auto length = delta.Length2d();
if (cfg::aim_no_recoil == 1)
{
delta.x = (delta.x / 2.f);
delta.y = (delta.y / 2.f);
}
if (length > 0.f)
{
aim_ang.x -= delta.x;
aim_ang.y -= delta.y;
}
}
if (cfg::aim_smooth_out && cfg::aim_smooth > 0.f)
{
auto vCurrentAngle = my_angle;
auto vAimDelta = (aim_ang - vCurrentAngle);
math::NormalizeAngle(vCurrentAngle);
math::NormalizeAngle(vAimDelta);
const auto flMultiplier = cfg::aim_smooth;
const auto vActualAimAngle = aim_ang; // back it up so we can compare it later.
if (vAimDelta.x >= +89.f || vAimDelta.x <= -89.f)
vAimDelta.x = 0.f;
if (flMultiplier >= 0.01f)
{
aim_ang.x = vCurrentAngle.x + ((vAimDelta.x + FLT_EPSILON) / flMultiplier);
aim_ang.y = vCurrentAngle.y + ((vAimDelta.y + FLT_EPSILON) / flMultiplier);
aim_ang.z = 0.f;
}
}
bool should_aim = false;
if (cfg::aim_ignore_key)
should_aim = true;
else if (cfg::aim_auto_fire && g::p::input_mgr.is_button_down(VK_SHIFT))
should_aim = true;
else if (cmd->buttons & IN_ATTACK)
should_aim = true;
if (cfg::aim_rapid_fire)
{
if (cmd->buttons & IN_ATTACK && my_wpn->can_fire(me))
cvar::time_scale->m_value_float = cfg::aim_rapid_fire_boost;
else
cvar::time_scale->m_value_float = 1.f;
}
if (should_aim)
{
is_aiming = true;
target_pos_ = hit_pos;
wish_angle = aim_ang;
switch (cfg::aim_silent)
{
case 0: // plain
cmd->viewangles = aim_ang;
me->eye_angles() = aim_ang;
break;
case 1: // silent (1)
case 2: // silent (2)
cmd->viewangles = aim_ang;
break;
default:
break;
}
if (cfg::aim_auto_fire)
cmd->buttons |= IN_ATTACK;
}
else
{
is_aiming = false;
writecmd_silent = false;
wish_angle = { };
}
}
void c_aim::cl_move(respawn::c_player* me)
{
//
// ...
//
}
void c_aim::paint()
{
if (!respawn::is_playing())
return;
if (!cfg::aim_enabled)
return;
if(cfg::aim_visualize_range)
draw_range();
if (is_aiming)
{
math::Vector3 target_scr{ };
if (respawn::world_to_screen(target_pos_, target_scr))
{
const float x_center = target_scr.x;
const float y_center = target_scr.y;
const float width = 5.0f;
g::p::render.draw_rect_filled(respawn::colors::red, x_center - width, y_center - 1.0f, x_center + width, y_center + 1.0f);
g::p::render.draw_rect_filled(respawn::colors::red, x_center - 1.0f, y_center - width, x_center + 1.0f, y_center + width);
g::p::render.draw_rect(respawn::colors::red, x_center - width, y_center - 1.0f, x_center + width, y_center + 1.0f);
g::p::render.draw_rect(respawn::colors::red, x_center - 1.0f, y_center - width, x_center + 1.0f, y_center + width);
}
}
}
void c_aim::draw_range()
{
auto screen = g::p::screen;
float local_fov = 110.f;
float valid_fov = effective_max_fov_ / local_fov;
float local_range = (local_fov * static_cast<float>(M_PI) / 180.f);
float valid_range = (valid_fov * static_cast<float>(M_PI) / 180.f);
float radius = (math::tanf((valid_fov / 2.f)) / math::tanf((local_fov / 2.f)) * screen.w * 25.f);
float scenter_x = (screen.w / 2);
float scenter_y = (screen.h / 2);
g::p::render.draw_circle(respawn::colors::white, scenter_x, scenter_y, radius, 100, 125);
}
+43
View File
@@ -0,0 +1,43 @@
#include <include.h>
using bone_id = respawn::bone_id;
static bone_id bone_array[] = { bone_id::head, bone_id::neck, bone_id::spine, bone_id::torso_center, bone_id::torso_lower, bone_id::torso_upper };
respawn::bone_id aim::get_optimal_bone_id(const cache::player_t& player)
{
const auto& lp_data = g::p::cache.local_player;
if (cfg::aim_random_hitbox)
return bone_id::torso_upper;
if (cfg::aim_dynamic_hitbox)
{
auto closest_bone = bone_id{ };
auto maximum_fov = FLT_MAX;
auto closest_fov = maximum_fov;
const auto& shoot_position = lp_data.shoot_pos;
for (auto i = 0; i < ARRAYSIZE(bone_array); i++)
{
auto id = bone_array[i];
auto bone_position = player.m_bones[ static_cast<int>(id) ];
auto fov = math::SE::get_fov_difference(lp_data.eye_angle, shoot_position, bone_position);
if (fov > maximum_fov)
continue;
if (fov < closest_fov)
{
closest_bone = static_cast<bone_id>(id);
closest_fov = fov;
continue;
}
}
return closest_bone;
}
return bone_id::head;
}
+28
View File
@@ -0,0 +1,28 @@
#include <include.h>
void aim::psilent(respawn::c_player* me, respawn::c_weapon* weapon)
{
const auto net_chan = respawn::net_chan();
if (net_chan == nullptr)
return;
if (!ix::engine_client->is_in_game())
return;
const auto choked_packets = net_chan->num_choked_packets();
const auto last_out_cmd_nr = respawn::last_out_cmd_nr();
if (f::aim.is_aiming)
{
g::choke_this_tick = (choked_packets <= cfg::aim_choke_cap);
auto* const silent_cmd = ix::input->get_user_cmd(last_out_cmd_nr - 1);
if (silent_cmd && silent_cmd->command_number)
{
silent_cmd->buttons |= IN_ATTACK;
silent_cmd->viewangles = f::aim.wish_angle;
}
}
}
+110
View File
@@ -0,0 +1,110 @@
#include <include.h>
bool aim::is_target_viable(cache::entry_t& entity, aim::find_context_t& ctx)
{
auto& info = ctx.target_info;
switch (entity.type)
{
case cache::types::dummie:
case cache::types::player:
{
if (cfg::aim_players)
{
auto& player = entity.type_specific.plr;
if (player.m_teammate && !cfg::aim_friendly_fire)
return false;
if (player.m_life_state != LIFE_ALIVE)
return false;
if (!player.m_visible)
return false;
ctx.aim_pos = player.m_bones[static_cast<int>(get_optimal_bone_id(player))];
info.velocity = player.m_velocity;
}
break;
}
case cache::types::npc:
{
switch (entity.entity_type)
{
case respawn::entity_types::PROWLER:
if (cfg::aim_prowler)
{
auto& npc = entity.type_specific.npc;
if (npc.m_life_state != LIFE_ALIVE)
return false;
ctx.aim_pos = npc.m_center;
info.velocity = { };
break;
}
}
break;
}
case cache::types::dynamic_prop:
case cache::types::script_prop:
{
const auto& prop = entity.type_specific.prop_dynamic;
using prop_type = cache::prop_dynamic_types;
switch (prop.m_type)
{
case prop_type::shooting_range_target:
if (cfg::aim_firing_range_targets)
{
ctx.aim_pos = prop.m_center;
info.velocity = { };
}
break;
}
break;
}
default:
return false;
}
//
// At this point the current target has been classified as viable.
// Calculate aim angles and such, and then perform some checks.
//
auto entity_pos = ctx.aim_pos;
auto arbitrary_aim_angle = math::Angle3{};
math::VectorAngles((entity_pos - ctx.my_position), arbitrary_aim_angle);
auto distance = entity_pos.DistanceTo(ctx.my_position) / 4096.f;
auto fov = math::SE::get_fov_difference(ctx.my_angle, ctx.my_view, entity_pos);
if (distance > ctx.maximum_distance)
return false;
if (fov > ctx.maximum_fov)
return false;
if (fov < ctx.closest_fov)
{
ctx.closest_fov = fov;
++ctx.viable_targets;
return true;
}
return false;
}
+477
View File
@@ -0,0 +1,477 @@
#include <include.h>
using namespace features;
void c_esp::draw_bar(respawn::color_t color, FLOAT flX, FLOAT flY, FLOAT flW, FLOAT flH, int current, const int max)
{
if (current < 0)
current = 0;
if (current > max)
current = max;
flY -= flH;
const float base = flH / static_cast<float>(max) * static_cast<float>(current);
const float delta = (flH - base);
const float bar_x = flX;
g::p::render.draw_rect_filled({ 5, 5, 5 }, bar_x, flY, bar_x + 5.0f, flY + flH, 175);
g::p::render.draw_rect_filled(color, bar_x, flY + delta, bar_x + 5.0f, flY + flH);
g::p::render.draw_rect({ 5, 5, 5 }, bar_x, flY, bar_x + 5.0f, flY + flH);
}
void c_esp::draw_outline(respawn::color_t color, int opacity, math::Vector3 scr_origin, float bw, float bh)
{
g::p::render.draw_rect_bordered(color, scr_origin.x - bw, scr_origin.y - bh, scr_origin.x + bw, scr_origin.y + 5.f, opacity);
}
void c_esp::show_debug_ents()
{
const auto& local_player_data = g::p::cache.local_player;
const auto my_origin = local_player_data.origin;
math::Vector3 screen{};
for (auto i = 0; i < ix::entity_list->get_highest_entity_index(); i++)
{
auto* const entity = ix::entity_list->get_client_entity<respawn::c_entity>(i);
if (entity == nullptr)
continue;
if (!respawn::world_to_screen(entity->origin(), screen))
continue;
if (!entity->identifier())
continue;
const auto distance = entity->origin().DistanceTo(my_origin) / 4096.f;
if (distance > 512.f)
continue;
g::p::render.draw_text_ex(
respawn::colors::white, 2, 12, screen.x,
screen.y, _XS("[%s]\n[%s]"),
entity->identifier(),
entity->model_name()
);
}
}
void c_esp::process_player(int index, const cache::entry_t& entry, const cache::player_t& player)
{
const auto& local_player_data = g::p::cache.local_player;
if (!player.m_valid)
return;
if (index == g::p::cache.local_player.index)
{
if (!cfg::esp_show_local_player)
return;
if (cvar::third_person->m_value_numeric != 1)
return;
}
else
{
if (player.m_teammate && !cfg::esp_show_team_mates)
return;
}
const auto is_ally = (player.m_team_number == local_player_data.team_number);
const auto is_knocked = (player.m_bleedout_state != 0);
math::Vector3 pos_head, pos_origin = player.m_origin;
math::Vector3 scr_head, scr_origin;
if (player.m_life_state != 0)
return;
pos_head = player.m_bones[7];
if (!respawn::world_to_screen(pos_head, scr_head) ||
!respawn::world_to_screen(pos_origin, scr_origin))
return;
const auto bounds_height = math::fabsf(scr_head.y - scr_origin.y) * 1.5f;
const auto bounds_width = (bounds_height / 2.5f);
const auto distance = pos_origin.DistanceTo(local_player_data.origin) / 4096.f;
if (distance > cfg::esp_object_render_dist)
return;
const auto render_text = (distance < cfg::esp_text_render_dist);
const auto opacity = player.m_visible ? 255 : 125;
const auto draw_pos_top_x = scr_origin.x + (bounds_width / 2.f);
const auto draw_pos_top_y = scr_origin.y - (bounds_height + 20.f);
float draw_pos_top_push = 0.f;
if (render_text)
{
if (cfg::esp_players_name)
{
g::p::render.draw_text_centered(
respawn::colors::white, 2, 14,
draw_pos_top_x, draw_pos_top_y - draw_pos_top_push,
player.m_name
);
draw_pos_top_push += 15.f;
}
if (cfg::esp_players_health > 0 && player.m_health > 0)
{
if (cfg::esp_players_health == 1)
{
g::p::render.draw_text_centered(
respawn::colors::green, 2, 14,
draw_pos_top_x, draw_pos_top_y - draw_pos_top_push,
_XS("%i HP"), player.m_health
);
}
else if (cfg::esp_players_health == 2)
{
g::p::render.draw_text_centered(
respawn::colors::green, 2, 14,
draw_pos_top_x, draw_pos_top_y - draw_pos_top_push,
_XS("%i/%i HP"), player.m_health, player.m_health_max
);
}
draw_pos_top_push += 15.f;
}
if (cfg::esp_players_armor > 0 && player.m_armor > 0)
{
if (cfg::esp_players_armor == 1)
{
g::p::render.draw_text_centered(
respawn::colors::blue, 2, 14,
draw_pos_top_x, draw_pos_top_y - draw_pos_top_push,
_XS("%i AR"), player.m_armor
);
}
else if (cfg::esp_players_armor == 2)
{
g::p::render.draw_text_centered(
respawn::colors::blue, 2, 14,
draw_pos_top_x, draw_pos_top_y - draw_pos_top_push,
_XS("%i/%i AR"), player.m_armor, player.m_armor_max
);
}
}
}
if(cfg::esp_players_outline)
draw_outline(player.m_color, opacity, scr_origin, bounds_width, bounds_height);
if(cfg::esp_players_health_bar && player.m_health_max > 0)
draw_bar({ 65, 255, 65 }, scr_origin.x - bounds_width - 6.f, scr_origin.y, bounds_width, bounds_height, player.m_health, player.m_health_max);
if(cfg::esp_players_armor_bar && player.m_armor_max > 0)
draw_bar({ 65, 65, 255 }, scr_origin.x + bounds_width + 2.f, scr_origin.y, bounds_width, bounds_height, player.m_armor, player.m_armor_max);
if (cfg::esp_player_bone_ids)
draw_bone_identifiers(player);
}
void c_esp::process_prowler(int index, const cache::entry_t& entry, const cache::npc_t& npc)
{
const auto& local_player_data = g::p::cache.local_player;
if (!npc.m_valid)
return;
math::Vector3 scr_origin, pos_origin = npc.m_origin;
if (!respawn::world_to_screen(pos_origin, scr_origin))
return;
const auto distance = pos_origin.DistanceTo(local_player_data.origin) / 4096.f;
if (distance > 4096.f)
return;
g::p::render.draw_text(respawn::colors::yellow, 2, 20, scr_origin.x, scr_origin.y, _XS("PROWLER"));
g::p::render.draw_text_ex(
respawn::colors::white, 2, 20,
scr_origin.x, scr_origin.y + 22,
_XS("%i HP"),
npc.m_health
);
}
void c_esp::process_loot(int index, const cache::entry_t& entry, const cache::loot_t& loot)
{
const auto& local_player_data = g::p::cache.local_player;
if (!loot.m_valid)
return;
math::Vector3 scr_origin, pos_origin = loot.m_origin;
if (!respawn::world_to_screen(pos_origin, scr_origin))
return;
const auto distance = pos_origin.DistanceTo(local_player_data.origin) / 4096.f;
if (distance > 1024.f)
return;
using lid = respawn::loot_ids;
bool found = true;
std::pair<const char*, respawn::color_t> ldef;
switch ( static_cast<lid>(loot.m_script_id) )
{
/*case lid::SHIELD_BLUE: ldef = std::make_pair(_XS("SH"), respawn::colors::blue); break;
case lid::SHIELD_PURP: ldef = std::make_pair(_XS("SH"), respawn::colors::purple); break;
case lid::SHIELD_GOLD: ldef = std::make_pair(_XS("SH"), respawn::colors::yellow); break;
case lid::BACKPACK_BLUE: ldef = std::make_pair(_XS("BP"), respawn::colors::blue); break;
case lid::BACKPACK_PURP: ldef = std::make_pair(_XS("BP"), respawn::colors::purple); break;
case lid::BACKPACK_GOLD: ldef = std::make_pair(_XS("BP"), respawn::colors::yellow); break;
case lid::HELMET_BLUE: ldef = std::make_pair(_XS("H"), respawn::colors::blue); break;
case lid::HELMET_PURP: ldef = std::make_pair(_XS("H"), respawn::colors::purple); break;
case lid::HELMET_GOLD: ldef = std::make_pair(_XS("H"), respawn::colors::yellow); break;*/
case lid::WEAPON_CHARGE_RIFLE: ldef = std::make_pair(_XS("CR"), respawn::colors::blue); break;
default:
found = false;
break;
}
if (found)
{
g::p::render.draw_text(ldef.second, 2, 14, scr_origin.x, scr_origin.y, ldef.first);
}
else if (cfg::esp_loot_unknown)
{
g::p::render.draw_text_ex(
respawn::colors::yellow, 2, 14,
scr_origin.x, scr_origin.y, _XS("ID: %i"),
loot.m_script_id
);
}
}
void process_generic(const math::Vector3& origin, const char* name, const respawn::color_t color)
{
const auto& local_player_data = g::p::cache.local_player;
math::Vector3 scr_origin, pos_origin = origin;
if (!respawn::world_to_screen(pos_origin, scr_origin))
return;
const auto distance = pos_origin.DistanceTo(local_player_data.origin) / 4096.f;
if (distance > 4096.f)
return;
g::p::render.draw_text(color, 2, 20, scr_origin.x, scr_origin.y, name);
}
void c_esp::overlay_hud()
{
float push = 0.f;
constexpr float start_x = 150.f, start_y = 5.f;
//
//
//
if (cfg::other_debug_overlay)
{
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS("is_ingame= %i"), g::is_in_game);
push += 15.f;
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS("engine time= %i"), (int)*gv::engine_time);
push += 15.f;
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS("current time= %i"), (int)ix::global_vars->Curtime);
push += 15.f;
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS("sway angles= (%i, %i, %i)"),
(int)g::p::sway_angles.x, (int)g::p::sway_angles.y, (int)g::p::sway_angles.z);
push += 15.f;
if (g::is_in_game)
{
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS("local_player= %p"), g::p::cache.local_player.address);
push += 15.f;
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS("local_weapon= %p"), g::p::cache.local_weapon.address);
push += 15.f;
if (g::p::cache.local_weapon.address)
{
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS(" reloading= %i"), g::p::cache.local_weapon.reloading);
push += 15.f;
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS(" next_primary_attack= %i"), (int)g::p::cache.local_weapon.next_primary_attack);
push += 15.f;
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS(" next_ready_time= %i"), (int)g::p::cache.local_weapon.next_ready_time);
push += 15.f;
g::p::render.draw_text_ex(respawn::colors::white, 2, 14, start_x, start_y + push, _XS(" can_fire= %i"), (int)g::p::cache.local_weapon.can_fire);
push += 15.f;
}
}
}
if (g::unprotected_game)
{
g::p::render.draw_text(respawn::colors::red, 2, 14, start_x, start_y + push, _XS("*UNPROTECTED GAME*"));
push += 15.f;
}
if (cfg::aim_enabled)
{
if (cfg::aim_silent == 0 || cfg::aim_silent == 1)
{
g::p::render.draw_text(respawn::colors::red, 2, 14, start_x, start_y + push, _XS("*UNSAFE AIM*"));
push += 15.f;
}
}
if (cfg::custom_crosshair_enabled)
{
if (respawn::is_playing())
{
const auto screen_size = g::p::screen;
const float x_center = static_cast<float>(screen_size.w) / 2.0f;
const float y_center = static_cast<float>(screen_size.h) / 2.0f;
const float width = cfg::custom_crosshair_size;
g::p::render.draw_rect_filled(respawn::colors::white, x_center - width, y_center - 1.0f, x_center + width, y_center + 1.0f);
g::p::render.draw_rect_filled(respawn::colors::white, x_center - 1.0f, y_center - width, x_center + 1.0f, y_center + width);
if (cfg::custom_crosshair_outline)
{
g::p::render.draw_rect(respawn::colors::black, x_center - width, y_center - 1.0f, x_center + width, y_center + 1.0f);
g::p::render.draw_rect(respawn::colors::black, x_center - 1.0f, y_center - width, x_center + 1.0f, y_center + width);
}
}
}
}
void c_esp::info_panel()
{
}
void c_esp::draw_bone_identifiers(const cache::player_t& player)
{
math::Vector3 pos, screen;
for (auto i = 0ull; i < 20; i++)
{
pos = player.m_bones[i];
if (!respawn::world_to_screen(pos, screen))
continue;
char text[64];
util::format_string(text, sizeof(text), _XS("%i"), i);
g::p::render.draw_text({ 65, 255, 65 }, 2, 15, screen.x, screen.y, text);
}
}
void c_esp::paint()
{
if (!cfg::esp_enabled)
return;
if (cfg::esp_show_debug_ents)
{
show_debug_ents();
return;
}
if (respawn::is_playing())
{
for (auto i = 0ull; i < g::p::ent_cache.count(); i++)
{
auto data = g::p::ent_cache.get_neutral(i);
if (!data.valid)
continue;
switch (data.type)
{
case cache::types::player:
case cache::types::dummie:
{
if (cfg::esp_players)
process_player(i, data, data.type_specific.plr);
break;
}
case cache::types::npc:
{
using ent_type = respawn::entity_types;
switch (data.entity_type)
{
case ent_type::PROWLER:
if(cfg::esp_prowler)
process_prowler(i, data, data.type_specific.npc);
break;
}
break;
}
case cache::types::loot:
{
if (cfg::esp_loot)
process_loot(i, data, data.type_specific.loot);
break;
}
case cache::types::dynamic_prop:
case cache::types::script_prop:
{
using pd_types = cache::prop_dynamic_types;
switch (data.type_specific.prop_dynamic.m_type)
{
case pd_types::shooting_range_target:
if(cfg::esp_firing_range_targets)
process_generic(data.type_specific.prop_dynamic.m_center, _XS("X"), respawn::colors::red);
break;
case pd_types::trap_gas:
if(cfg::esp_traps)
process_generic(data.type_specific.prop_dynamic.m_center, _XS("GAS-T"), respawn::colors::yellow);
break;
}
break;
}
default:
break;
}
}
}
overlay_hud();
info_panel();
}
+108
View File
@@ -0,0 +1,108 @@
#include <include.h>
using namespace features;
respawn::color_t c_glow::get_color(const cache::player_t& player)
{
auto result = respawn::color_t{};
const int current_shield = player.m_armor;
const int current_health = player.m_health;
const int max_shield = player.m_armor_max;
const int max_health = player.m_health_max;
const int total_health = (current_health + current_shield);
const int split_count = 3;
const auto frac_shield = ((max_shield + 1) / 3);
const auto frac_health = ((max_health + 1) / 3);
if (player.m_bleedout_state == 0)
{
if (frac_shield && frac_health)
{
const auto shield_state = ((current_shield + 1) / frac_shield);
const auto health_state = ((current_health + 1) / frac_health);
const auto total_state = (shield_state + health_state);
switch (total_state)
{
case 0:
case 1:
result = respawn::glow_colors::red;
break;
case 2:
case 3:
result = respawn::glow_colors::yellow;
break;
case 4:
case 5:
case 6:
result = respawn::glow_colors::green;
break;
default:
break;
}
}
else
result = respawn::glow_colors::green;
}
else
result = respawn::glow_colors::white;
return result;
}
void c_glow::create_move(respawn::c_player* me, respawn::user_cmd_t* cmd)
{
const auto& local_player_data = g::p::cache.local_player;
for (auto i = 0ull; i < g::p::ent_cache.count(); i++)
{
auto entry = g::p::ent_cache.get_neutral(i);
if (!entry.valid)
continue;
switch (entry.type)
{
case cache::types::player:
case cache::types::dummie:
break;
default:
continue;
}
auto data = entry.type_specific.plr;
if (entry.index == g::p::cache.local_player.index)
{
continue;
}
else
{
if (data.m_teammate && !cfg::esp_show_team_mates)
continue;
}
auto* const pointer = g::p::ent_cache.get_pointer<respawn::c_player*>(i);
if (pointer)
{
if (cfg::esp_enabled && cfg::esp_players && cfg::esp_players_glow)
{
pointer->glow_enabled() = true;
pointer->glow_type() = 0x2;
pointer->glow_config() = { 101, 102, 46, 96 };
pointer->glow_color() = get_color(data);
}
else
{
if (pointer->glow_enabled())
pointer->glow_enabled() = false;
}
}
}
}
+69
View File
@@ -0,0 +1,69 @@
#include <include.h>
using namespace features;
void c_logger::paint()
{
draw_messages();
}
void c_logger::draw_messages()
{
float push_y = 0.0f;
float start_x = 2.0f, start_y = 2.0f;
for (auto i = 0ul; i < m_fields.count(); i++)
{
field_t* entry = m_fields[i];
if (entry == nullptr)
continue;
bool requires_removal = (entry->m_time_registered && math::fabsf(entry->m_time_registered - *gv::engine_time) > entry->m_duration);
size_t text_height = 14;
size_t text_width = g::p::render.get_text_width(entry->m_text, text_height);
g::p::render.draw_rect_filled(
respawn::color_t{25, 25, 25}, start_x, start_y + push_y,
start_x + 1 + text_width,
start_y + push_y + text_height + 1.0f
);
g::p::render.draw_text(entry->m_color, 2, static_cast<int>(text_height), start_x + 1, start_y + push_y, entry->m_text);
if (requires_removal)
{
m_fields.remove(*entry);
break;
}
push_y += text_height;
}
}
void c_logger::add_message(float duration, respawn::color_t color, const char* fmt, ...)
{
stl::my_lock_guard _(&m_lock);
if (!duration || !fmt)
return;
va_list list{ };
field_t entry{ };
memset(&entry, 0, sizeof(entry));
if( stl::strlen(fmt) >= (sizeof(entry.m_text) - 1) )
return;
entry.m_duration = duration;
entry.m_color = color;
entry.m_time_registered = *gv::engine_time;
va_start(list, fmt);
LI_FN(wvsprintfA).cached()(entry.m_text, fmt, list);
va_end(list);
m_fields.insert(entry);
}
+193
View File
@@ -0,0 +1,193 @@
#include <include.h>
using namespace features;
void bunnyhop(bool& hopping, respawn::c_player* me, respawn::user_cmd_t* cmd)
{
if (!cfg::movement_bunny_hop)
return;
if (hopping)
{
if (!(cmd->buttons & IN_JUMP))
{
hopping = false;
return;
}
if (!(me->flags() & FL_ONGROUND))
cmd->buttons &= ~IN_JUMP;
}
else
{
if (cmd->buttons & IN_DUCK)
hopping = true;
}
}
void freecam(respawn::c_player* me)
{
static bool is_toggled{ };
g::in_freecam = cfg::movement_freecam && is_toggled;
if (si::create_move.was_button_down(VK_NUMPAD7))
is_toggled = !is_toggled;
me->observer_mode() = g::in_freecam ? 7 : 0;
}
void thirdperson()
{
static bool previous_enabled{ };
static bool is_toggled{ };
static int initial_value{ };
if (!initial_value)
initial_value = cvar::third_person->m_value_numeric;
const auto maintain_value = []()
{
if (cfg::movement_thirdperson && is_toggled)
cvar::third_person->m_value_numeric = 1;
else
cvar::third_person->m_value_numeric = initial_value;
};
if (previous_enabled != cfg::movement_thirdperson)
{
maintain_value();
previous_enabled = cfg::movement_thirdperson;
}
if (si::create_move.was_button_down(VK_XBUTTON1))
{
is_toggled = !is_toggled;
maintain_value();
}
}
void airstuck()
{
static bool is_toggled{ };
static int initial_value{ };
if (!initial_value)
initial_value = cvar::move_use_dt->m_value_numeric;
const auto maintain_value = []()
{
if (is_toggled)
cvar::move_use_dt->m_value_numeric = 0;
else
cvar::move_use_dt->m_value_numeric = initial_value;
};
if (si::create_move.was_button_down(VK_NUMPAD4))
{
is_toggled = !is_toggled;
maintain_value();
}
}
void fakelag(respawn::c_player* me)
{
static bool is_toggled{ };
if (!cfg::fake_lag)
return;
const auto my_index = g::p::cache.local_player.index;
const auto my_team_number = g::p::cache.local_player.team_number;
const auto choked_packets = g::p::cache.net_chan.num_choked_packets;
if (cfg::fake_lag == 1)
{
//
// adaptive, based on enemy sight.
//
size_t num_visible_opponents{};
for (auto i = 0ull; i < ix::global_vars->MaxClients; i++)
{
if (i == my_index)
continue;
auto player_data = g::p::ent_cache.get_player(i);
if (!player_data.m_valid)
continue;
if (player_data.m_team_number == my_team_number)
continue;
if (!player_data.is_alive() || !player_data.m_visible)
continue;
++num_visible_opponents;
}
if (num_visible_opponents > 0)
g::choke_this_tick = (choked_packets < cfg::fake_lag_choke_cap);
}
else if (cfg::fake_lag == 2)
{
//
// full pulled, all time.
// TODO: once we figure out xbutton keys for input handler,
// make an option like on aimbot called ignore key
// and make the default one require a key like on the external.
//
if ( (!cfg::fake_lag_ignore_key && g::p::input_mgr.is_button_down(VK_XBUTTON2)) || cfg::fake_lag_ignore_key)
{
g::choke_this_tick = (choked_packets < cfg::fake_lag_choke_cap);
}
}
}
void charge_rifle(respawn::c_player* me)
{
if (!cfg::other_infinite_charge_rifle)
return;
static bool toggled = false;
if (si::create_move.was_button_down(VK_F12))
{
toggled = !toggled;
if (!toggled)
{
cvar::time_scale->m_value_float = 1.f;
}
}
auto my_wpn = me->get_active_weapon();
if (my_wpn)
{
if (my_wpn->projectile_speed() == 1.f)
{
if (toggled)
{
cvar::time_scale->m_value_float = 0.000000000000000000000000000000001f;
}
}
}
}
void c_movement::create_move(respawn::c_player* me, respawn::user_cmd_t* cmd)
{
if (respawn::is_playing())
{
bunnyhop(m_hopping, me, cmd);
charge_rifle(me);
}
freecam(me);
fakelag(me);
thirdperson();
airstuck();
}
+165
View File
@@ -0,0 +1,165 @@
#include <include.h>
using namespace features;
void force_heirloom(respawn::c_entity* vm, int model_index)
{
if (!vm || !model_index)
return;
vm->set_model_index(model_index);
}
bool is_valid_sequence(int heirloom_idx, int sequence_nr)
{
int blacklisted_sequence_nr = 0;
switch (heirloom_idx)
{
case HEIRLOOM_IDX_WRAITH:
case HEIRLOOM_IDX_BLOODHOUND:
blacklisted_sequence_nr = 60;
break;
case HEIRLOOM_IDX_LIFELINE:
blacklisted_sequence_nr = 65;
break;
case HEIRLOOM_IDX_PATHFINDER_GLOVES:
blacklisted_sequence_nr = 64;
break;
case HEIRLOOM_IDX_OCTANE_KNIFE:
blacklisted_sequence_nr = 57;
break;
case HEIRLOOM_IDX_MIRAGE:
blacklisted_sequence_nr = 53;
break;
case HEIRLOOM_IDX_GIBRALTAR:
blacklisted_sequence_nr = 71;
break;
case HEIRLOOM_IDX_BANGALORE:
blacklisted_sequence_nr = 79;
break;
default:
//
// No validation for this specific heirloom.
//
break;
}
return (sequence_nr != blacklisted_sequence_nr);
}
void reset_sequence(int heirloom_idx, uint32_t* sequence_nr)
{
uint32_t default_sequence = 0;
switch (heirloom_idx)
{
case HEIRLOOM_IDX_WRAITH:
case HEIRLOOM_IDX_BLOODHOUND:
default_sequence = 46;
break;
case HEIRLOOM_IDX_LIFELINE:
default_sequence = 48;
break;
case HEIRLOOM_IDX_PATHFINDER_GLOVES:
default_sequence = 51;
break;
case HEIRLOOM_IDX_OCTANE_KNIFE:
default_sequence = 42;
break;
case HEIRLOOM_IDX_MIRAGE:
default_sequence = 43;
break;
case HEIRLOOM_IDX_GIBRALTAR:
default_sequence = 57;
break;
case HEIRLOOM_IDX_BANGALORE:
default_sequence = 59;
break;
default:
//
// No rule for this specific heirloom.
//
break;
}
if (default_sequence != 0)
*sequence_nr = default_sequence;
}
void c_skin_changer::create_move(respawn::c_player* me, respawn::user_cmd_t* cmd)
{
}
bool is_hands(respawn::c_entity* entity)
{
auto model_name = entity->model_name();
if (model_name)
{
if (stl::strlen(model_name) == 45)
{
if (model_name[12] == 'e' && model_name[15] == 't' && model_name[18] == 'h')
return true;
}
}
return false;
}
void c_skin_changer::frame_stage_notify(int stage, respawn::c_player* me)
{
if (!cfg::other_heirloom_changer_active || !respawn::is_playing())
return;
if (me == nullptr)
return;
switch (stage)
{
case respawn::frame_render_start:
{
if (!respawn::is_alive(me) || respawn::is_knocked(me))
return;
auto my_wpn = me->get_active_weapon();
auto my_vm = me->get_view_model();
if (my_wpn == nullptr || my_vm == nullptr)
return;
auto name_idx = my_wpn->name_index();
if (name_idx != respawn::weapon_name_indexes::hands)
return;
if (!is_hands(my_vm))
return;
auto heirloom_idx = ix::model_info->get_model_index(respawn::_heirloom_table.get(cfg::other_heirloom_index));
if (!heirloom_idx || heirloom_idx == -1)
return;
const auto cur_sequence = my_vm->anim_sequence();
const auto cur_activity = my_vm->get_sequence_activity(cur_sequence);
force_heirloom(my_vm, heirloom_idx);
auto new_sequence = my_vm->get_activity_sequence(cur_activity);
if (new_sequence != UINT32_MAX)
{
if (!is_valid_sequence(cfg::other_heirloom_index, new_sequence))
reset_sequence(cfg::other_heirloom_index, &new_sequence);
my_vm->anim_sequence() = new_sequence;
}
break;
}
default:
break;
}
}