Initial commit
This commit is contained in:
@@ -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);
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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
@@ -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
@@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -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);
|
||||
}
|
||||
@@ -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();
|
||||
}
|
||||
@@ -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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user