|
Вопрос how fix lw not shoot
- Автор темы Semxzz
- Дата начала
-
- Теги
- #legendwarev3 help lw3
EXCLUSIVE
- Статус
- Оффлайн
- Регистрация
- 26 Янв 2021
- Сообщения
- 1,845
- Реакции
- 601
Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 21 Июл 2021
- Сообщения
- 124
- Реакции
- 6
Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 5 Апр 2021
- Сообщения
- 60
- Реакции
- 3
нет, чекни aim::scan вроде
Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 21 Июл 2021
- Сообщения
- 124
- Реакции
- 6
не помогло
Пользователь
Пользователь
- Статус
- Оффлайн
- Регистрация
- 6 Дек 2021
- Сообщения
- 194
- Реакции
- 33
А что должно было помочь?
Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 21 Июл 2021
- Сообщения
- 124
- Реакции
- 6
не знаю
automatic wall
Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 21 Июл 2021
- Сообщения
- 124
- Реакции
- 6
EXCLUSIVE
- Статус
- Оффлайн
- Регистрация
- 26 Янв 2021
- Сообщения
- 1,845
- Реакции
- 601
иди значит учи минимальные основы с++ ты чето делаешь неправильно
Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 21 Июл 2021
- Сообщения
- 124
- Реакции
- 6
give link pls
Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 5 Июн 2021
- Сообщения
- 100
- Реакции
- 6
Can you at least give us your aim.cpp?
Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 21 Июл 2021
- Сообщения
- 124
- Реакции
- 6
aim.cpp:
// This is an independent project of an individual developer. Dear PVS-Studio, please check it.
// PVS-Studio Static Code Analyzer for C, C++, C#, and Java: http://www.viva64.com
#include "aim.h"
#include "..\misc\misc.h"
#include "..\misc\logs.h"
#include "..\autowall\autowall.h"
#include "..\misc\prediction_system.h"
#include "..\fakewalk\slowwalk.h"
#include "..\lagcompensation\local_animations.h"
void aim::run(CUserCmd* cmd)
{
backup.clear();
targets.clear();
scanned_targets.clear();
final_target.reset();
should_stop = false;
if (!g_cfg.ragebot.enable)
return;
automatic_revolver(cmd);
prepare_targets();
if (g_ctx.globals.weapon->is_non_aim())
return;
if (g_ctx.globals.current_weapon == -1)
return;
scan_targets();
if (!should_stop && g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].autostop_modifiers[AUTOSTOP_PREDICTIVE])
{
auto max_speed = 260.0f;
auto weapon_info = g_ctx.globals.weapon->get_csweapon_info();
if (weapon_info)
max_speed = g_ctx.globals.scoped ? weapon_info->flMaxPlayerSpeedAlt : weapon_info->flMaxPlayerSpeed;
auto ticks_to_stop = math::clamp(engineprediction::get().backup_data.velocity.Length2D() / max_speed * 3.0f, 0.0f, 4.0f);
auto predicted_eye_pos = g_ctx.globals.eye_pos + engineprediction::get().backup_data.velocity * m_globals()->m_intervalpertick * ticks_to_stop;
for (auto& target : targets)
{
if (!target.last_record->valid())
continue;
scan_data last_data;
target.last_record->adjust_player();
scan(target.last_record, last_data, predicted_eye_pos, true);
if (!last_data.valid())
continue;
should_stop = true;
break;
}
}
if (!automatic_stop(cmd))
return;
if (scanned_targets.empty())
return;
find_best_target();
if (!final_target.data.valid())
return;
fire(cmd);
}
void aim::automatic_revolver(CUserCmd* cmd)
{
if (!m_engine()->IsActiveApp())
return;
if (g_ctx.globals.weapon->m_iItemDefinitionIndex() != WEAPON_REVOLVER)
return;
if (cmd->m_buttons & IN_ATTACK)
return;
cmd->m_buttons &= ~IN_ATTACK2;
static auto r8cock_time = 0.0f;
auto server_time = TICKS_TO_TIME(g_ctx.globals.backup_tickbase);
if (g_ctx.globals.weapon->can_fire(false))
{
if (r8cock_time <= server_time) //-V807
{
if (g_ctx.globals.weapon->m_flNextSecondaryAttack() <= server_time)
r8cock_time = server_time + 0.234375f;
else
cmd->m_buttons |= IN_ATTACK2;
}
else
cmd->m_buttons |= IN_ATTACK;
}
else
{
r8cock_time = server_time + 0.234375f;
cmd->m_buttons &= ~IN_ATTACK;
}
g_ctx.globals.revolver_working = true;
}
void aim::prepare_targets()
{
for (auto i = 1; i < m_globals()->m_maxclients; i++)
{
if (g_cfg.player_list.white_list[i])
continue;
auto e = (player_t*)m_entitylist()->GetClientEntity(i);
if (!e->valid(true, false))
continue;
auto records = &player_records[i]; //-V826
if (records->empty())
continue;
targets.emplace_back(target(e, get_record(records, false), get_record(records, true)));
}
if (targets.size() >= 4)
{
auto first = rand() % targets.size();
auto second = rand() % targets.size();
auto third = rand() % targets.size();
for (auto i = 0; i < targets.size(); ++i)
{
if (i == first || i == second || i == third)
continue;
targets.erase(targets.begin() + i);
if (i > 0)
--i;
}
}
for (auto& target : targets)
backup.emplace_back(adjust_data(target.e));
}
static bool compare_records(const optimized_adjust_data& first, const optimized_adjust_data& second)
{
auto first_pitch = math::normalize_pitch(first.angles.x);
auto second_pitch = math::normalize_pitch(second.angles.x);
if (fabs(first_pitch - second_pitch) > 15.0f)
return fabs(first_pitch) < fabs(second_pitch);
else if (first.duck_amount != second.duck_amount) //-V550
return first.duck_amount < second.duck_amount;
else if (first.origin != second.origin)
return first.origin.DistTo(g_ctx.local()->GetAbsOrigin()) < second.origin.DistTo(g_ctx.local()->GetAbsOrigin());
return first.simulation_time > second.simulation_time;
}
adjust_data* aim::get_record(std::deque <adjust_data>* records, bool history)
{
if (history)
{
std::deque <optimized_adjust_data> optimized_records; //-V826
for (auto i = 0; i < records->size(); ++i)
{
auto record = &records->at(i);
optimized_adjust_data optimized_record;
optimized_record.i = i;
optimized_record.player = record->player;
optimized_record.simulation_time = record->simulation_time;
optimized_record.duck_amount = record->duck_amount;
optimized_record.angles = record->angles;
optimized_record.origin = record->origin;
optimized_records.emplace_back(optimized_record);
}
if (optimized_records.size() < 2)
return nullptr;
std::sort(optimized_records.begin(), optimized_records.end(), compare_records);
for (auto& optimized_record : optimized_records)
{
auto record = &records->at(optimized_record.i);
if (!record->valid())
continue;
return record;
}
}
else
{
for (auto i = 0; i < records->size(); ++i)
{
auto record = &records->at(i);
if (!record->valid())
continue;
return record;
}
}
return nullptr;
}
int aim::get_minimum_damage(bool visible, int health)
{
auto minimum_damage = 1;
if (visible)
{
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].minimum_visible_damage > 100)
minimum_damage = health + g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].minimum_visible_damage - 100;
else
minimum_damage = math::clamp(g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].minimum_visible_damage, 1, health);
}
else
{
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].minimum_damage > 100)
minimum_damage = health + g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].minimum_damage - 100;
else
minimum_damage = math::clamp(g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].minimum_damage, 1, health);
}
if (key_binds::get().get_key_bind_state(4 + g_ctx.globals.current_weapon))
{
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].minimum_override_damage > 100)
minimum_damage = health + g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].minimum_override_damage - 100;
else
minimum_damage = math::clamp(g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].minimum_override_damage, 1, health);
}
return minimum_damage;
}
void aim::scan_targets()
{
if (targets.empty())
return;
for (auto& target : targets)
{
if (target.history_record->valid())
{
scan_data last_data;
if (target.last_record->valid())
{
target.last_record->adjust_player();
scan(target.last_record, last_data);
}
scan_data history_data;
target.history_record->adjust_player();
scan(target.history_record, history_data);
if (last_data.valid() && last_data.damage > history_data.damage)
scanned_targets.emplace_back(scanned_target(target.last_record, last_data));
else if (history_data.valid())
scanned_targets.emplace_back(scanned_target(target.history_record, history_data));
}
else
{
if (!target.last_record->valid())
continue;
scan_data last_data;
target.last_record->adjust_player();
scan(target.last_record, last_data);
if (!last_data.valid())
continue;
scanned_targets.emplace_back(scanned_target(target.last_record, last_data));
}
}
}
bool aim::automatic_stop(CUserCmd* cmd)
{
if (!should_stop)
return true;
if (!g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].autostop)
return true;
if (g_ctx.globals.slowwalking)
return true;
if (!(g_ctx.local()->m_fFlags() & FL_ONGROUND && engineprediction::get().backup_data.flags & FL_ONGROUND)) //-V807
return true;
if (g_ctx.globals.weapon->is_empty())
return true;
if (!g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].autostop_modifiers[AUTOSTOP_BETWEEN_SHOTS] && !g_ctx.globals.weapon->can_fire(false))
return true;
auto animlayer = g_ctx.local()->get_animlayers()[1];
if (animlayer.m_nSequence)
{
auto activity = g_ctx.local()->sequence_activity(animlayer.m_nSequence);
if (activity == ACT_CSGO_RELOAD && animlayer.m_flWeight > 0.0f)
return true;
}
auto weapon_info = g_ctx.globals.weapon->get_csweapon_info();
if (!weapon_info)
return true;
auto max_speed = 0.33f * (g_ctx.globals.scoped ? weapon_info->flMaxPlayerSpeedAlt : weapon_info->flMaxPlayerSpeed);
if (engineprediction::get().backup_data.velocity.Length2D() < max_speed)
slowwalk::get().create_move(cmd);
else
{
Vector direction;
Vector real_view;
math::vector_angles(engineprediction::get().backup_data.velocity, direction);
m_engine()->GetViewAngles(real_view);
direction.y = real_view.y - direction.y;
Vector forward;
math::angle_vectors(direction, forward);
static auto cl_forwardspeed = m_cvar()->FindVar(crypt_str("cl_forwardspeed"));
static auto cl_sidespeed = m_cvar()->FindVar(crypt_str("cl_sidespeed"));
auto negative_forward_speed = -cl_forwardspeed->GetFloat();
auto negative_side_speed = -cl_sidespeed->GetFloat();
auto negative_forward_direction = forward * negative_forward_speed;
auto negative_side_direction = forward * negative_side_speed;
cmd->m_forwardmove = negative_forward_direction.x;
cmd->m_sidemove = negative_side_direction.y;
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].autostop_modifiers[AUTOSTOP_FORCE_ACCURACY])
return false;
}
return true;
}
static bool compare_points(const scan_point& first, const scan_point& second)
{
return !first.center && first.hitbox == second.hitbox;
}
void aim::scan(adjust_data* record, scan_data& data, const Vector& shoot_position, bool optimized)
{
auto weapon = optimized ? g_ctx.local()->m_hActiveWeapon().Get() : g_ctx.globals.weapon;
if (!weapon)
return;
auto weapon_info = weapon->get_csweapon_info();
if (!weapon_info)
return;
auto hitboxes = get_hitboxes(record, optimized);
if (hitboxes.empty())
return;
auto force_safe_points = record->player->m_iHealth() <= weapon_info->iDamage || key_binds::get().get_key_bind_state(3) || g_cfg.player_list.force_safe_points[record->i] || g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].max_misses && g_ctx.globals.missed_shots[record->i] >= g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].max_misses_amount; //-V648
auto best_damage = 0;
auto minimum_damage = get_minimum_damage(false, record->player->m_iHealth());
auto minimum_visible_damage = get_minimum_damage(true, record->player->m_iHealth());
auto get_hitgroup = [](const int& hitbox)
{
if (hitbox == HITBOX_HEAD)
return 0;
else if (hitbox == HITBOX_PELVIS)
return 1;
else if (hitbox == HITBOX_STOMACH)
return 2;
else if (hitbox >= HITBOX_LOWER_CHEST && hitbox <= HITBOX_UPPER_CHEST)
return 3;
else if (hitbox >= HITBOX_RIGHT_THIGH && hitbox <= HITBOX_LEFT_FOOT)
return 4;
else if (hitbox >= HITBOX_RIGHT_HAND && hitbox <= HITBOX_LEFT_FOREARM)
return 5;
return -1;
};
std::vector <scan_point> points; //-V826
for (auto& hitbox : hitboxes)
{
if (optimized)
{
points.emplace_back(scan_point(record->player->hitbox_position_matrix(hitbox, record->matrixes_data.main), hitbox, true));
continue;
}
auto current_points = get_points(record, hitbox);
for (auto& point : current_points)
{
if (!record->bot)
{
auto safe = 0.0f;
if (record->matrixes_data.zero[0].GetOrigin() == record->matrixes_data.first[0].GetOrigin() || record->matrixes_data.zero[0].GetOrigin() == record->matrixes_data.second[0].GetOrigin() || record->matrixes_data.first[0].GetOrigin() == record->matrixes_data.second[0].GetOrigin())
safe = 0.0f;
else if (!hitbox_intersection(record->player, record->matrixes_data.zero, hitbox, shoot_position, point.point, &safe))
safe = 0.0f;
else if (!hitbox_intersection(record->player, record->matrixes_data.first, hitbox, shoot_position, point.point, &safe))
safe = 0.0f;
else if (!hitbox_intersection(record->player, record->matrixes_data.second, hitbox, shoot_position, point.point, &safe))
safe = 0.0f;
point.safe = safe;
}
else
point.safe = 1.0f;
if (!force_safe_points || point.safe)
points.emplace_back(point);
}
}
if (!optimized)
{
for (auto& point : points)
{
if (points.empty())
return;
if (point.hitbox == HITBOX_HEAD)
continue;
for (auto it = points.begin(); it != points.end(); ++it)
{
if (point.point == it->point)
continue;
auto first_angle = math::calculate_angle(shoot_position, point.point);
auto second_angle = math::calculate_angle(shoot_position, it->point);
auto distance = shoot_position.DistTo(point.point);
auto fov = math::fast_sin(DEG2RAD(math::get_fov(first_angle, second_angle))) * distance;
if (fov < 5.0f)
{
points.erase(it);
break;
}
}
}
}
if (points.empty())
return;
if (!optimized)
std::sort(points.begin(), points.end(), compare_points);
auto body_hitboxes = true;
for (auto& point : points)
{
if (!optimized && body_hitboxes && (point.hitbox < HITBOX_PELVIS || point.hitbox > HITBOX_UPPER_CHEST))
{
body_hitboxes = false;
if (g_cfg.player_list.force_body_aim[record->i])
break;
if (key_binds::get().get_key_bind_state(22))
break;
if (best_damage >= record->player->m_iHealth())
break;
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].prefer_body_aim && best_damage >= 1)
break;
}
if (!optimized && (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].prefer_safe_points || force_safe_points) && data.point.safe && data.point.safe < point.safe)
continue;
auto fire_data = autowall::get().wall_penetration(shoot_position, point.point, record->player);
if (!fire_data.valid)
continue;
if (fire_data.damage < 1)
continue;
if (!fire_data.visible && !g_cfg.ragebot.autowall)
continue;
if (!optimized && get_hitgroup(fire_data.hitbox) != get_hitgroup(point.hitbox))
continue;
auto current_minimum_damage = fire_data.visible ? minimum_visible_damage : minimum_damage;
if (fire_data.damage >= current_minimum_damage && fire_data.damage >= best_damage)
{
if (!optimized && !should_stop)
{
should_stop = true;
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].autostop_modifiers[AUTOSTOP_LETHAL] && fire_data.damage < record->player->m_iHealth())
should_stop = false;
else if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].autostop_modifiers[AUTOSTOP_VISIBLE] && !fire_data.visible)
should_stop = false;
else if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].autostop_modifiers[AUTOSTOP_CENTER] && !point.center)
should_stop = false;
}
if (!optimized && force_safe_points && !point.safe)
continue;
best_damage = fire_data.damage;
data.point = point;
data.visible = fire_data.visible;
data.damage = fire_data.damage;
data.hitbox = fire_data.hitbox;
if (optimized)
return;
}
}
}
std::vector <int> aim::get_hitboxes(adjust_data* record, bool optimized)
{
std::vector <int> hitboxes; //-V827
if (optimized)
{
hitboxes.emplace_back(HITBOX_HEAD);
hitboxes.emplace_back(HITBOX_CHEST);
hitboxes.emplace_back(HITBOX_STOMACH);
hitboxes.emplace_back(HITBOX_PELVIS);
return hitboxes;
}
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitboxes.at(1))
hitboxes.emplace_back(HITBOX_UPPER_CHEST);
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitboxes.at(2))
hitboxes.emplace_back(HITBOX_CHEST);
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitboxes.at(3))
hitboxes.emplace_back(HITBOX_LOWER_CHEST);
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitboxes.at(4))
hitboxes.emplace_back(HITBOX_STOMACH);
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitboxes.at(5))
hitboxes.emplace_back(HITBOX_PELVIS);
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitboxes.at(0))
hitboxes.emplace_back(HITBOX_HEAD);
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitboxes.at(6))
{
hitboxes.emplace_back(HITBOX_RIGHT_UPPER_ARM);
hitboxes.emplace_back(HITBOX_LEFT_UPPER_ARM);
}
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitboxes.at(7))
{
hitboxes.emplace_back(HITBOX_RIGHT_THIGH);
hitboxes.emplace_back(HITBOX_LEFT_THIGH);
hitboxes.emplace_back(HITBOX_RIGHT_CALF);
hitboxes.emplace_back(HITBOX_LEFT_CALF);
}
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitboxes.at(8))
{
hitboxes.emplace_back(HITBOX_RIGHT_FOOT);
hitboxes.emplace_back(HITBOX_LEFT_FOOT);
}
return hitboxes;
}
std::vector <scan_point> aim::get_points(adjust_data* record, int hitbox, bool from_aim)
{
std::vector <scan_point> points; //-V827
auto model = record->player->GetModel();
if (!model)
return points;
auto hdr = m_modelinfo()->GetStudioModel(model);
if (!hdr)
return points;
auto set = hdr->pHitboxSet(record->player->m_nHitboxSet());
if (!set)
return points;
auto bbox = set->pHitbox(hitbox);
if (!bbox)
return points;
auto center = (bbox->bbmin + bbox->bbmax) * 0.5f;
if (bbox->radius <= 0.0f)
{
auto rotation_matrix = math::angle_matrix(bbox->rotation);
matrix3x4_t matrix;
math::concat_transforms(record->matrixes_data.main[bbox->bone], rotation_matrix, matrix);
auto origin = matrix.GetOrigin();
if (hitbox == HITBOX_RIGHT_FOOT || hitbox == HITBOX_LEFT_FOOT)
{
auto side = (bbox->bbmin.z - center.z) * 0.875f;
if (hitbox == HITBOX_LEFT_FOOT)
side = -side;
points.emplace_back(scan_point(Vector(center.x, center.y, center.z + side), hitbox, true));
auto min = (bbox->bbmin.x - center.x) * 0.875f;
auto max = (bbox->bbmax.x - center.x) * 0.875f;
points.emplace_back(scan_point(Vector(center.x + min, center.y, center.z), hitbox, false));
points.emplace_back(scan_point(Vector(center.x + max, center.y, center.z), hitbox, false));
}
}
else
{
auto scale = 0.0f;
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].static_point_scale)
{
if (hitbox == HITBOX_HEAD)
scale = g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].head_scale;
else
scale = g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].body_scale;
}
else
{
auto transformed_center = center;
math::vector_transform(transformed_center, record->matrixes_data.main[bbox->bone], transformed_center);
auto spread = g_ctx.globals.spread + g_ctx.globals.inaccuracy;
auto distance = transformed_center.DistTo(g_ctx.globals.eye_pos);
distance /= math::fast_sin(DEG2RAD(90.0f - RAD2DEG(spread)));
spread = math::fast_sin(spread);
auto radius = max(bbox->radius - distance * spread, 0.0f);
scale = math::clamp(radius / bbox->radius, 0.0f, 1.0f);
}
if (scale <= 0.0f) //-V648
{
math::vector_transform(center, record->matrixes_data.main[bbox->bone], center);
points.emplace_back(scan_point(center, hitbox, true));
return points;
}
auto final_radius = bbox->radius * scale;
if (hitbox == HITBOX_HEAD)
{
auto pitch_down = math::normalize_pitch(record->angles.x) > 85.0f;
auto backward = fabs(math::normalize_yaw(record->angles.y - math::calculate_angle(record->player->get_shoot_position(), g_ctx.local()->GetAbsOrigin()).y)) > 120.0f;
points.emplace_back(scan_point(center, hitbox, !pitch_down || !backward));
points.emplace_back(scan_point(Vector(bbox->bbmax.x + 0.70710678f * final_radius, bbox->bbmax.y - 0.70710678f * final_radius, bbox->bbmax.z), hitbox, false));
points.emplace_back(scan_point(Vector(bbox->bbmax.x, bbox->bbmax.y, bbox->bbmax.z + final_radius), hitbox, false));
points.emplace_back(scan_point(Vector(bbox->bbmax.x, bbox->bbmax.y, bbox->bbmax.z - final_radius), hitbox, false));
points.emplace_back(scan_point(Vector(bbox->bbmax.x, bbox->bbmax.y - final_radius, bbox->bbmax.z), hitbox, false));
if (pitch_down && backward)
points.emplace_back(scan_point(Vector(bbox->bbmax.x - final_radius, bbox->bbmax.y, bbox->bbmax.z), hitbox, false));
}
else if (hitbox >= HITBOX_PELVIS && hitbox <= HITBOX_UPPER_CHEST)
{
points.emplace_back(scan_point(center, hitbox, true));
points.emplace_back(scan_point(Vector(bbox->bbmax.x, bbox->bbmax.y, bbox->bbmax.z + final_radius), hitbox, false));
points.emplace_back(scan_point(Vector(bbox->bbmax.x, bbox->bbmax.y, bbox->bbmax.z - final_radius), hitbox, false));
points.emplace_back(scan_point(Vector(center.x, bbox->bbmax.y - final_radius, center.z), hitbox, true));
}
else if (hitbox == HITBOX_RIGHT_CALF || hitbox == HITBOX_LEFT_CALF)
{
points.emplace_back(scan_point(center, hitbox, true));
points.emplace_back(scan_point(Vector(bbox->bbmax.x - final_radius, bbox->bbmax.y, bbox->bbmax.z), hitbox, false));
}
else if (hitbox == HITBOX_RIGHT_THIGH || hitbox == HITBOX_LEFT_THIGH)
points.emplace_back(scan_point(center, hitbox, true));
else if (hitbox == HITBOX_RIGHT_UPPER_ARM || hitbox == HITBOX_LEFT_UPPER_ARM)
{
points.emplace_back(scan_point(center, hitbox, true));
points.emplace_back(scan_point(Vector(bbox->bbmax.x + final_radius, center.y, center.z), hitbox, false));
}
}
for (auto& point : points)
math::vector_transform(point.point, record->matrixes_data.main[bbox->bone], point.point);
return points;
}
static bool compare_targets(const scanned_target& first, const scanned_target& second)
{
if (g_cfg.player_list.high_priority[first.record->i] != g_cfg.player_list.high_priority[second.record->i])
return g_cfg.player_list.high_priority[first.record->i];
switch (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].selection_type)
{
case 1:
return first.fov < second.fov;
case 2:
return first.distance < second.distance;
case 3:
return first.health < second.health;
case 4:
return first.data.damage > second.data.damage;
}
return false;
}
void aim::find_best_target()
{
if (g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].selection_type)
std::sort(scanned_targets.begin(), scanned_targets.end(), compare_targets);
for (auto& target : scanned_targets)
{
if (target.fov > (float)g_cfg.ragebot.field_of_view)
continue;
final_target = target;
final_target.record->adjust_player();
break;
}
}
void aim::fire(CUserCmd* cmd)
{
if (!g_ctx.globals.weapon->can_fire(true))
return;
auto aim_angle = math::calculate_angle(g_ctx.globals.eye_pos, final_target.data.point.point).Clamp();
if (!g_cfg.ragebot.silent_aim)
m_engine()->SetViewAngles(aim_angle);
if (!g_cfg.ragebot.autoshoot && !(cmd->m_buttons & IN_ATTACK))
return;
auto final_hitchance = 0;
auto hitchance_amount = 0;
if (g_ctx.globals.double_tap_aim && g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].double_tap_hitchance)
hitchance_amount = g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].double_tap_hitchance_amount;
else if (!g_ctx.globals.double_tap_aim && g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitchance)
hitchance_amount = g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitchance_amount;
if (hitchance_amount)
{
if (g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_SSG08 && !(g_ctx.local()->m_fFlags() & FL_ONGROUND) && !(engineprediction::get().backup_data.flags & FL_ONGROUND) && fabs(engineprediction::get().backup_data.velocity.z) < 5.0f && engineprediction::get().backup_data.velocity.Length2D() < 5.0f) //-V807
final_hitchance = 101;
else
final_hitchance = hitchance(aim_angle);
if (final_hitchance < hitchance_amount)
{
auto is_zoomable_weapon = g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_SCAR20 || g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_G3SG1 || g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_SSG08 || g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_AWP || g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_AUG || g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_SG553;
if (g_cfg.ragebot.autoscope && is_zoomable_weapon && !g_ctx.globals.weapon->m_zoomLevel())
cmd->m_buttons |= IN_ATTACK2;
return;
}
}
auto backtrack_ticks = 0;
auto net_channel_info = m_engine()->GetNetChannelInfo();
if (net_channel_info)
{
auto original_tickbase = g_ctx.globals.backup_tickbase;
if (misc::get().double_tap_enabled && misc::get().double_tap_key)
original_tickbase = g_ctx.globals.backup_tickbase + g_ctx.globals.weapon->get_max_tickbase_shift();
static auto sv_maxunlag = m_cvar()->FindVar(crypt_str("sv_maxunlag"));
auto correct = math::clamp(net_channel_info->GetLatency(FLOW_OUTGOING) + net_channel_info->GetLatency(FLOW_INCOMING) + util::get_interpolation(), 0.0f, sv_maxunlag->GetFloat());
auto delta_time = correct - (TICKS_TO_TIME(original_tickbase) - final_target.record->simulation_time);
backtrack_ticks = TIME_TO_TICKS(fabs(delta_time));
}
static auto get_hitbox_name = [](int hitbox, bool shot_info = false) -> std::string
{
switch (hitbox)
{
case HITBOX_HEAD:
return shot_info ? crypt_str("Head") : crypt_str("head");
case HITBOX_LOWER_CHEST:
return shot_info ? crypt_str("Lower chest") : crypt_str("lower chest");
case HITBOX_CHEST:
return shot_info ? crypt_str("Chest") : crypt_str("chest");
case HITBOX_UPPER_CHEST:
return shot_info ? crypt_str("Upper chest") : crypt_str("upper chest");
case HITBOX_STOMACH:
return shot_info ? crypt_str("Stomach") : crypt_str("stomach");
case HITBOX_PELVIS:
return shot_info ? crypt_str("Pelvis") : crypt_str("pelvis");
case HITBOX_RIGHT_UPPER_ARM:
case HITBOX_RIGHT_FOREARM:
case HITBOX_RIGHT_HAND:
return shot_info ? crypt_str("Left arm") : crypt_str("left arm");
case HITBOX_LEFT_UPPER_ARM:
case HITBOX_LEFT_FOREARM:
case HITBOX_LEFT_HAND:
return shot_info ? crypt_str("Right arm") : crypt_str("right arm");
case HITBOX_RIGHT_THIGH:
case HITBOX_RIGHT_CALF:
return shot_info ? crypt_str("Left leg") : crypt_str("left leg");
case HITBOX_LEFT_THIGH:
case HITBOX_LEFT_CALF:
return shot_info ? crypt_str("Right leg") : crypt_str("right leg");
case HITBOX_RIGHT_FOOT:
return shot_info ? crypt_str("Left foot") : crypt_str("left foot");
case HITBOX_LEFT_FOOT:
return shot_info ? crypt_str("Right foot") : crypt_str("right foot");
}
};
static auto get_resolver_type = [](resolver_type type) -> std::string
{
switch (type)
{
case ORIGINAL:
return crypt_str("original ");
case BRUTEFORCE:
return crypt_str("bruteforce ");
case LBY:
return crypt_str("lby ");
case TRACE:
return crypt_str("trace ");
case DIRECTIONAL:
return crypt_str("directional ");
}
};
player_info_t player_info;
m_engine()->GetPlayerInfo(final_target.record->i, &player_info);
#if BETA
std::stringstream log;
log << crypt_str("Fired shot at ") + (std::string)player_info.szName + crypt_str(": ");
log << crypt_str("hitchance: ") + (final_hitchance == 101 ? crypt_str("MA") : std::to_string(final_hitchance)) + crypt_str(", ");
log << crypt_str("hitbox: ") + get_hitbox_name(final_target.data.hitbox) + crypt_str(", ");
log << crypt_str("damage: ") + std::to_string(final_target.data.damage) + crypt_str(", ");
log << crypt_str("safe: ") + std::to_string((bool)final_target.data.point.safe) + crypt_str(", ");
log << crypt_str("backtrack: ") + std::to_string(backtrack_ticks) + crypt_str(", ");
log << crypt_str("resolver type: ") + get_resolver_type(final_target.record->type) + std::to_string(final_target.record->side);
if (g_cfg.misc.events_to_log[EVENTLOG_HIT])
eventlogs::get().add(log.str());
#endif
cmd->m_viewangles = aim_angle;
cmd->m_buttons |= IN_ATTACK;
cmd->m_tickcount = TIME_TO_TICKS(final_target.record->simulation_time + util::get_interpolation());
last_target_index = final_target.record->i;
last_shoot_position = g_ctx.globals.eye_pos;
last_target[last_target_index] = Last_target
{
*final_target.record, final_target.data, final_target.distance
};
auto shot = &g_ctx.shots.emplace_back();
shot->last_target = last_target_index;
shot->side = final_target.record->side;
shot->fire_tick = m_globals()->m_tickcount;
shot->shot_info.target_name = player_info.szName;
shot->shot_info.client_hitbox = get_hitbox_name(final_target.data.hitbox, true);
shot->shot_info.client_damage = final_target.data.damage;
shot->shot_info.hitchance = final_hitchance;
shot->shot_info.backtrack_ticks = backtrack_ticks;
shot->shot_info.aim_point = final_target.data.point.point;
g_ctx.globals.aimbot_working = true;
g_ctx.globals.revolver_working = false;
g_ctx.globals.last_aimbot_shot = m_globals()->m_tickcount;
}
int aim::hitchance(const Vector& aim_angle)
{
auto final_hitchance = 0;
auto weapon_info = g_ctx.globals.weapon->get_csweapon_info();
if (!weapon_info)
return final_hitchance;
if ((g_ctx.globals.eye_pos - final_target.data.point.point).Length() > weapon_info->flRange)
return final_hitchance;
auto forward = ZERO;
auto right = ZERO;
auto up = ZERO;
math::angle_vectors(aim_angle, &forward, &right, &up);
math::fast_vec_normalize(forward);
math::fast_vec_normalize(right);
math::fast_vec_normalize(up);
auto is_special_weapon = g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_AWP || g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_G3SG1 || g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_SCAR20 || g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_SSG08;
auto inaccuracy = weapon_info->flInaccuracyStand;
if (g_ctx.local()->m_fFlags() & FL_DUCKING)
{
if (is_special_weapon)
inaccuracy = weapon_info->flInaccuracyCrouchAlt;
else
inaccuracy = weapon_info->flInaccuracyCrouch;
}
else if (is_special_weapon)
inaccuracy = weapon_info->flInaccuracyStandAlt;
if (g_ctx.globals.inaccuracy - 0.000001f < inaccuracy)
final_hitchance = 101;
else
{
static auto setup_spread_values = true;
static float spread_values[256][6];
if (setup_spread_values)
{
setup_spread_values = false;
for (auto i = 0; i < 256; ++i)
{
math::random_seed(i + 1);
auto a = math::random_float(0.0f, 1.0f);
auto b = math::random_float(0.0f, DirectX::XM_2PI);
auto c = math::random_float(0.0f, 1.0f);
auto d = math::random_float(0.0f, DirectX::XM_2PI);
spread_values[i][0] = a;
spread_values[i][1] = c;
auto sin_b = 0.0f, cos_b = 0.0f;
DirectX::XMScalarSinCos(&sin_b, &cos_b, b);
auto sin_d = 0.0f, cos_d = 0.0f;
DirectX::XMScalarSinCos(&sin_d, &cos_d, d);
spread_values[i][2] = sin_b;
spread_values[i][3] = cos_b;
spread_values[i][4] = sin_d;
spread_values[i][5] = cos_d;
}
}
auto hits = 0;
for (auto i = 0; i < 256; ++i)
{
auto inaccuracy = spread_values[i][0] * g_ctx.globals.inaccuracy;
auto spread = spread_values[i][1] * g_ctx.globals.spread;
auto spread_x = spread_values[i][3] * inaccuracy + spread_values[i][5] * spread;
auto spread_y = spread_values[i][2] * inaccuracy + spread_values[i][4] * spread;
auto direction = ZERO;
direction.x = forward.x + right.x * spread_x + up.x * spread_y;
direction.y = forward.y + right.y * spread_x + up.y * spread_y;
direction.z = forward.z + right.z * spread_x + up.z * spread_y; //-V778
auto end = g_ctx.globals.eye_pos + direction * weapon_info->flRange;
if (hitbox_intersection(final_target.record->player, final_target.record->matrixes_data.main, final_target.data.hitbox, g_ctx.globals.eye_pos, end))
++hits;
}
final_hitchance = (int)((float)hits / 2.56f);
}
if (g_ctx.globals.double_tap_aim)
return final_hitchance;
auto damage = 0;
auto high_accuracy_weapon = g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_AWP || g_ctx.globals.weapon->m_iItemDefinitionIndex() == WEAPON_SSG08;
auto spread = g_ctx.globals.spread + g_ctx.globals.inaccuracy;
for (auto i = 1; i <= 6; ++i)
{
for (auto j = 0; j < 8; ++j)
{
auto current_spread = spread * ((float)i / 6.0f);
auto direction_cos = 0.0f;
auto direction_sin = 0.0f;
DirectX::XMScalarSinCos(&direction_cos, &direction_sin, (float)j / 8.0f * DirectX::XM_2PI);
auto spread_x = direction_cos * current_spread;
auto spread_y = direction_sin * current_spread;
auto direction = ZERO;
direction.x = forward.x + spread_x * right.x + spread_y * up.x;
direction.y = forward.y + spread_x * right.y + spread_y * up.y;
direction.z = forward.z + spread_x * right.z + spread_y * up.z;
auto end = g_ctx.globals.eye_pos + direction * weapon_info->flRange;
if (hitbox_intersection(final_target.record->player, final_target.record->matrixes_data.main, final_target.data.hitbox, g_ctx.globals.eye_pos, end))
{
auto fire_data = autowall::get().wall_penetration(g_ctx.globals.eye_pos, end, final_target.record->player);
auto valid_hitbox = true;
if (final_target.data.hitbox == HITBOX_HEAD && fire_data.hitbox != HITBOX_HEAD)
valid_hitbox = false;
if (fire_data.valid && fire_data.damage >= 1 && valid_hitbox)
damage += high_accuracy_weapon ? fire_data.damage : 1;
}
}
}
if (high_accuracy_weapon)
return (float)damage / 48.0f >= get_minimum_damage(final_target.data.visible, final_target.health) ? final_hitchance : 0;
return (float)damage / 48.0f >= (float)g_cfg.ragebot.weapon[g_ctx.globals.current_weapon].hitchance_amount * 0.01f ? final_hitchance : 0;
}
static int clip_ray_to_hitbox(const Ray_t& ray, mstudiobbox_t* hitbox, matrix3x4_t& matrix, trace_t& trace)
{
static auto fn = util::FindSignature(crypt_str("client.dll"), crypt_str("55 8B EC 83 E4 F8 F3 0F 10 42"));
trace.fraction = 1.0f;
trace.startsolid = false;
return reinterpret_cast <int(__fastcall*)(const Ray_t&, mstudiobbox_t*, matrix3x4_t&, trace_t&)> (fn)(ray, hitbox, matrix, trace);
}
bool aim::hitbox_intersection(player_t* e, matrix3x4_t* matrix, int hitbox, const Vector& start, const Vector& end, float* safe)
{
auto model = e->GetModel();
if (!model)
return false;
auto studio_model = m_modelinfo()->GetStudioModel(model);
if (!studio_model)
return false;
auto studio_set = studio_model->pHitboxSet(e->m_nHitboxSet());
if (!studio_set)
return false;
auto studio_hitbox = studio_set->pHitbox(hitbox);
if (!studio_hitbox)
return false;
trace_t trace;
Ray_t ray;
ray.Init(start, end);
auto intersected = clip_ray_to_hitbox(ray, studio_hitbox, matrix[studio_hitbox->bone], trace) >= 0;
if (!safe)
return intersected;
Vector min, max;
math::vector_transform(studio_hitbox->bbmin, matrix[studio_hitbox->bone], min);
math::vector_transform(studio_hitbox->bbmax, matrix[studio_hitbox->bone], max);
auto center = (min + max) * 0.5f;
auto distance = center.DistTo(end);
if (distance > *safe)
*safe = distance;
return intersected;
}
Пользователь
- Статус
- Оффлайн
- Регистрация
- 13 Май 2022
- Сообщения
- 160
- Реакции
- 32
structs.hpp:
#pragma once
//fixed by shonax
#include "..\includes.hpp"
#include "interfaces\IClientEntity.hpp"
#include "misc\EHandle.hpp"
#include "misc\UtlVector.hpp"
#include "math\QAngle.hpp"
#include "..\utils\netmanager.hpp"
#include "misc\CBoneAccessor.hpp"
#include "..\cheats\misc\fakelag.h"
#include "..\sdk\misc\Recv.hpp"
#define min(a, b) (((a) < (b)) ? (a) : (b))
#define max(a, b) (((a) > (b)) ? (a) : (b))
#define TIME_TO_TICKS(t) ((int)(0.5f + (float)(t) / m_globals()->m_intervalpertick))
#define TICKS_TO_TIME(t) (m_globals()->m_intervalpertick * (t))
#define NETVAR(type, name, table, netvar) \
type& name##() const { \
static int _##name = netvars::get().get_offset(table, netvar); \
return *(type*)((uintptr_t)this + _##name); \
}
#define PNETVAR(type, name, table, netvar) \
type* name##() const { \
static int _##name = netvars::get().get_offset(table, netvar); \
return (type*)((uintptr_t)this + _##name); \
}
#define OFFSET(type, name, offset)\
type &name##() const\
{\
return *(type*)(uintptr_t(this) + offset);\
}
class player_t;
struct datamap_t;
enum CSWeaponType
{
WEAPONTYPE_KNIFE = 0,
WEAPONTYPE_PISTOL,
WEAPONTYPE_SUBMACHINEGUN,
WEAPONTYPE_RIFLE,
WEAPONTYPE_SHOTGUN,
WEAPONTYPE_SNIPER_RIFLE,
WEAPONTYPE_MACHINEGUN,
WEAPONTYPE_C4,
WEAPONTYPE_PLACEHOLDER,
WEAPONTYPE_GRENADE,
WEAPONTYPE_UNKNOWN
};
class VarMapEntry_t
{
public:
unsigned short type;
unsigned short m_bNeedsToInterpolate;
void* data;
void* watcher;
};
struct VarMapping_t
{
VarMapping_t()
{
m_Entries = nullptr;
m_nInterpolatedEntries = 0;
m_lastInterpolationTime = 0.0f;
}
VarMapEntry_t* m_Entries;
int m_nInterpolatedEntries;
float m_lastInterpolationTime;
};
struct client_hit_verify_t
{
Vector position;
float time;
float expires;
};
class AnimationLayer;
class c_baseplayeranimationstate;
class entity_t;
class clientanimating_t;
class weapon_info_t
{
public:
char pad_0000[4]; //0x0000
char* ConsoleName; //0x0004
char pad_0008[12]; //0x0008
int iMaxClip1; //0x0014
char pad_0018[12]; //0x0018
int iMaxClip2; //0x0024
char pad_0028[4]; //0x0028
char* szWorldModel; //0x002C
char* szViewModel; //0x0030
char* szDropedModel; //0x0034
char pad_0038[4]; //0x0038
char* N00000984; //0x003C
char pad_0040[56]; //0x0040
char* szEmptySound; //0x0078
char pad_007C[4]; //0x007C
char* szBulletType; //0x0080
char pad_0084[4]; //0x0084
char* szHudName; //0x0088
char* szWeaponName; //0x008C
char pad_0090[60]; //0x0090
int WeaponType; //0x00CC
int iWeaponPrice; //0x00D0
int iKillAward; //0x00D4
char* szAnimationPrefex; //0x00D8
float flCycleTime; //0x00DC
float flCycleTimeAlt; //0x00E0
float flTimeToIdle; //0x00E4
float flIdleInterval; //0x00E8
bool bFullAuto; //0x00EC
char pad_00ED[3]; //0x00ED
int iDamage; //0x00F0
float headshotmultiplyier;
float flArmorRatio; //0x00F4
int iBullets; //0x00F8
float flPenetration; //0x00FC
float flFlinchVelocityModifierLarge; //0x0100
float flFlinchVelocityModifierSmall; //0x0104
float flRange; //0x0108
float flRangeModifier; //0x010C
char pad_0110[28]; //0x0110
int iCrosshairMinDistance; //0x012C
float flMaxPlayerSpeed; //0x0130
float flMaxPlayerSpeedAlt; //0x0134
char pad_0138[4]; //0x0138
float flSpread; //0x013C
float flSpreadAlt; //0x0140
float flInaccuracyCrouch; //0x0144
float flInaccuracyCrouchAlt; //0x0148
float flInaccuracyStand; //0x014C
float flInaccuracyStandAlt; //0x0150
float flInaccuracyJumpIntial; //0x0154
float flInaccaurcyJumpApex;
float flInaccuracyJump; //0x0158
float flInaccuracyJumpAlt; //0x015C
float flInaccuracyLand; //0x0160
float flInaccuracyLandAlt; //0x0164
float flInaccuracyLadder; //0x0168
float flInaccuracyLadderAlt; //0x016C
float flInaccuracyFire; //0x0170
float flInaccuracyFireAlt; //0x0174
float flInaccuracyMove; //0x0178
float flInaccuracyMoveAlt; //0x017C
float flInaccuracyReload; //0x0180
int iRecoilSeed; //0x0184
float flRecoilAngle; //0x0188
float flRecoilAngleAlt; //0x018C
float flRecoilVariance; //0x0190
float flRecoilAngleVarianceAlt; //0x0194
float flRecoilMagnitude; //0x0198
float flRecoilMagnitudeAlt; //0x019C
float flRecoilMagnatiudeVeriance; //0x01A0
float flRecoilMagnatiudeVerianceAlt; //0x01A4
float flRecoveryTimeCrouch; //0x01A8
float flRecoveryTimeStand; //0x01AC
float flRecoveryTimeCrouchFinal; //0x01B0
float flRecoveryTimeStandFinal; //0x01B4
int iRecoveryTransititionStartBullet; //0x01B8
int iRecoveryTransititionEndBullet; //0x01BC
bool bUnzoomAfterShot; //0x01C0
char pad_01C1[31]; //0x01C1
char* szWeaponClass; //0x01E0
char pad_01E4[56]; //0x01E4
float flInaccuracyPitchShift; //0x021C
float flInaccuracySoundThreshold; //0x0220
float flBotAudibleRange; //0x0224
char pad_0228[12]; //0x0228
bool bHasBurstMode; //0x0234
};
struct NoticeText_t
{
wchar_t text[512];
int unk0; // 0x400
float unk1; // 0x404
float unk2; // 0x408
int unk3; // 0x40C
float time; // 0x410
int unk4; // 0x414
float fade; // 0x418
int unk5; // 0x41C
};
struct KillFeed_t
{
char pad[0x7C];
CUtlVector <NoticeText_t> notices;
};
class entity_t : public IClientEntity
{
public:
NETVAR(int, body, crypt_str("CBaseAnimating"), crypt_str("m_nBody"));
NETVAR(int, m_nModelIndex, crypt_str("CBaseEntity"), crypt_str("m_nModelIndex"));
NETVAR(int, m_iTeamNum, crypt_str("CBaseEntity"), crypt_str("m_iTeamNum"));
NETVAR(Vector, m_vecOrigin, crypt_str("CBaseEntity"), crypt_str("m_vecOrigin"));
NETVAR(CHandle <player_t>, m_hOwnerEntity, crypt_str("CBaseEntity"), crypt_str("m_hOwnerEntity"));
NETVAR(int, m_CollisionGroup, crypt_str("CBaseEntity"), crypt_str("m_CollisionGroup"));
NETVAR(int, m_nSequence, crypt_str("CBaseAnimating"), crypt_str("m_nSequence"));
void set_m_bUseCustomBloomScale(byte value)
{
*reinterpret_cast<byte*>(uintptr_t(this) + (int)netvars::get().get_offset(crypt_str("CEnvTonemapController"), crypt_str("m_bUseCustomBloomScale"))) = value;
}
void set_m_flCustomBloomScale(float value)
{
*reinterpret_cast<float*>(uintptr_t(this) + (int)netvars::get().get_offset(crypt_str("CEnvTonemapController"), crypt_str("m_flCustomBloomScale"))) = value;
}
void set_m_bUseCustomAutoExposureMin(byte value)
{
*reinterpret_cast<byte*>(uintptr_t(this) + (int)netvars::get().get_offset(crypt_str("CEnvTonemapController"), crypt_str("m_bUseCustomAutoExposureMin"))) = value;
}
void set_m_flCustomAutoExposureMin(float value)
{
*reinterpret_cast<float*>(uintptr_t(this) + (int)netvars::get().get_offset(crypt_str("CEnvTonemapController"), crypt_str("m_flCustomAutoExposureMin"))) = value;
}
void set_m_bUseCustomAutoExposureMax(byte value)
{
*reinterpret_cast<byte*>(uintptr_t(this) + (int)netvars::get().get_offset(crypt_str("CEnvTonemapController"), crypt_str("m_bUseCustomAutoExposureMax"))) = value;
}
void set_m_flCustomAutoExposureMax(float value)
{
*reinterpret_cast<float*>(uintptr_t(this) + (int)netvars::get().get_offset(crypt_str("CEnvTonemapController"), crypt_str("m_flCustomAutoExposureMax"))) = value;
}
const matrix3x4_t& m_rgflCoordinateFrame()
{
static auto _m_rgflCoordinateFrame = netvars::get().get_offset(crypt_str("CBaseEntity"), crypt_str("m_CollisionGroup")) - 0x30;
return *(matrix3x4_t*)((uintptr_t)this + _m_rgflCoordinateFrame);
}
int GetPropInt(std::string& table, std::string& var)
{
static auto offset = netvars::get().get_offset(table.c_str(), var.c_str());
int val = *(int*)(uintptr_t(this) + (int)offset);
return val;
}
float GetPropFloat(std::string& table, std::string& var)
{
static auto offset = netvars::get().get_offset(table.c_str(), var.c_str());
float val = *(float*)(uintptr_t(this) + (int)offset);
return val;
}
bool GetPropBool(std::string& table, std::string& var)
{
static auto offset = netvars::get().get_offset(table.c_str(), var.c_str());
bool val = *(bool*)(uintptr_t(this) + (int)offset);
return val;
}
std::string GetPropString(std::string& table, std::string& var)
{
static auto offset = netvars::get().get_offset(table.c_str(), var.c_str());
char* val = (char*)(uintptr_t(this) + (int)offset);
return std::string(val);
}
void SetPropInt(std::string& table, std::string& var, int val)
{
*reinterpret_cast<int*>(uintptr_t(this) + (int)netvars::get().get_offset(table.c_str(), var.c_str())) = val;
}
void SetPropFloat(std::string& table, std::string& var, float val)
{
*reinterpret_cast<float*>(uintptr_t(this) + (int)netvars::get().get_offset(table.c_str(), var.c_str())) = val;
}
void SetPropBool(std::string& table, std::string& var, bool val)
{
*reinterpret_cast<float*>(uintptr_t(this) + (int)netvars::get().get_offset(table.c_str(), var.c_str())) = val;
}
datamap_t* GetPredDescMap();
std::array <float, 24>& m_flPoseParameter();
bool is_player();
void set_model_index(int index);
void set_abs_angles(const Vector& angle);
void set_abs_origin(const Vector& origin);
int getMuzzleAttachmentIndex1stPerson(entity_t* viewModel);
int getMuzzleAttachmentIndex3rdPerson();
};
class attributableitem_t : public entity_t
{
public:
NETVAR(int, m_iItemDefinitionIndex, crypt_str("CBaseAttributableItem"), crypt_str("m_iItemDefinitionIndex"));
NETVAR(int, m_nFallbackStatTrak, crypt_str("CBaseAttributableItem"), crypt_str("m_nFallbackStatTrak"));
NETVAR(int, m_nFallbackPaintKit, crypt_str("CBaseAttributableItem"), crypt_str("m_nFallbackPaintKit"));
NETVAR(int, m_nFallbackSeed, crypt_str("CBaseAttributableItem"), crypt_str("m_nFallbackSeed"));
NETVAR(float, m_flFallbackWear, crypt_str("CBaseAttributableItem"), crypt_str("m_flFallbackWear"));
NETVAR(int, m_iAccountID, crypt_str("CBaseAttributableItem"), crypt_str("m_iAccountID"));
NETVAR(int, m_iItemIDHigh, crypt_str("CBaseAttributableItem"), crypt_str("m_iItemIDHigh"));
PNETVAR(char, m_szCustomName, crypt_str("CBaseAttributableItem"), crypt_str("m_szCustomName"));
NETVAR(int, m_OriginalOwnerXuidLow, crypt_str("CBaseAttributableItem"), crypt_str("m_OriginalOwnerXuidLow"));
NETVAR(int, m_OriginalOwnerXuidHigh, crypt_str("CBaseAttributableItem"), crypt_str("m_OriginalOwnerXuidHigh"));
NETVAR(int, m_iEntityQuality, crypt_str("CBaseAttributableItem"), crypt_str("m_iEntityQuality"));
};
class weapon_t : public attributableitem_t
{
public:
NETVAR(float, m_flNextPrimaryAttack, crypt_str("CBaseCombatWeapon"), crypt_str("m_flNextPrimaryAttack"));
NETVAR(float, m_flNextSecondaryAttack, crypt_str("CBaseCombatWeapon"), crypt_str("m_flNextSecondaryAttack"));
NETVAR(bool, initialized, crypt_str("CBaseAttributableItem"), crypt_str("m_bInitialized"));
NETVAR(int, weapon, crypt_str("CBaseViewModel"), crypt_str("m_hWeapon"));
NETVAR(short, m_iItemDefinitionIndex, crypt_str("CBaseCombatWeapon"), crypt_str("m_iItemDefinitionIndex"));
NETVAR(int, m_iClip1, crypt_str("CBaseCombatWeapon"), crypt_str("m_iClip1"));
NETVAR(int, m_iViewModelIndex, crypt_str("CBaseCombatWeapon"), crypt_str("m_iViewModelIndex"));
NETVAR(int, m_iWorldModelIndex, crypt_str("CBaseCombatWeapon"), crypt_str("m_iWorldModelIndex"));
NETVAR(float, m_fAccuracyPenalty, crypt_str("CWeaponCSBase"), crypt_str("m_fAccuracyPenalty"));
NETVAR(int, m_zoomLevel, crypt_str("CWeaponCSBaseGun"), crypt_str("m_zoomLevel"));
NETVAR(bool, m_bPinPulled, crypt_str("CBaseCSGrenade"), crypt_str("m_bPinPulled"));
NETVAR(float, m_fThrowTime, crypt_str("CBaseCSGrenade"), crypt_str("m_fThrowTime"));
NETVAR(float, m_flPostponeFireReadyTime, crypt_str("CWeaponCSBase"), crypt_str("m_flPostponeFireReadyTime"));
NETVAR(float, m_fLastShotTime, crypt_str("CWeaponCSBase"), crypt_str("m_fLastShotTime"));
NETVAR(float, m_flRecoilSeed, crypt_str("CWeaponCSBase"), crypt_str("m_flRecoilIndex"));
NETVAR(int, m_weaponMode, crypt_str("CWeaponCSBase"), crypt_str("m_weaponMode"));
NETVAR(CHandle <weapon_t>, m_hWeaponWorldModel, crypt_str("CBaseCombatWeapon"), crypt_str("m_hWeaponWorldModel"));
bool can_shift_tickbase(int tickbase_shift);
weapon_info_t* get_csweapon_info();
bool is_empty();
bool can_fire(bool check_revolver);
int get_weapon_group(bool rage);
bool is_rifle();
bool is_smg();
bool is_shotgun();
bool is_pistol();
bool is_sniper();
bool is_grenade();
bool is_knife();
bool is_non_aim();
bool can_double_tap();
int get_max_tickbase_shift();
float get_inaccuracy();
float get_spread();
void update_accuracy_penality();
char* get_icon();
std::string get_name();
};
class viewmodel_t;
class projectile_t : public entity_t
{
public:
NETVAR(Vector, m_vInitialVelocity, crypt_str("CBaseCSGrenadeProjectile"), crypt_str("m_vInitialVelocity"));
NETVAR(int, m_flAnimTime, crypt_str("CBaseCSGrenadeProjectile"), crypt_str("m_flAnimTime"));
NETVAR(int, m_nExplodeEffectTickBegin, crypt_str("CBaseCSGrenadeProjectile"), crypt_str("m_nExplodeEffectTickBegin"));
NETVAR(int, m_nBody, crypt_str("CBaseCSGrenadeProjectile"), crypt_str("m_nBody"));
NETVAR(int, m_nForceBone, crypt_str("CBaseCSGrenadeProjectile"), crypt_str("m_nForceBone"));
NETVAR(Vector, m_vecVelocity, crypt_str("CBaseGrenade"), crypt_str("m_vecVelocity"));
NETVAR(CHandle<player_t>, m_hThrower, "CBaseGrenade", "m_hThrower");
NETVAR(Vector, m_vecOrigin, crypt_str("CBaseCSGrenadeProjectile"), crypt_str("m_vecOrigin"));
OFFSET(float, m_flSpawnTime, netvars::get().get_offset(crypt_str("CBaseCSGrenadeProjectile"), crypt_str("m_vecExplodeEffectOrigin")) + 0xC);
};
class player_t : public entity_t
{
public:
// helper methods.
template< typename t >
inline t& get(size_t offset) { return *reinterpret_cast<t*>(reinterpret_cast<std::size_t>(this) + offset); }
enum indices : size_t {
GETREFEHANDLE = 2,
GETABSORIGIN = 10,
GETABSANGLES = 11,
TESTHITBOXES = 52,
SET_MODEL_INDEX = 75,
GETATTACHMENT = 84,
THINK = 139, // from that place and more +1 to idx for last upd
EYEANGLESPOSITION = 169,
ISFOLLOWINGENTITY = 178,
BUILDTRANSFORMATIONS = 190,
UPDATE_IK_LOCKS = 192,
CALCULATE_IK_LOCKS = 193,
DOEXTRABONEPROCESSING = 198,
STANDARDBLENDINGRULES = 206,
ACCUMULATELAYERS = 209,
SETSEQUENCY = 219,
STUDIOFRAMEADVANCE = 220,
GETLAYERSEQUENCYCICLERATE = 223,
UPDATECLIENTSIDEANIMATION = 224, // 55 8B EC 51 56 8B F1 80 BE ? ? ? ? ? 74 36
UPDATE_DISPATCH_LAYER = 247,
GETACTIVEWEAPON = 268,
WEAPONSHOOTPOSITION = 285,
CALCVIEW = 277,
PRETHINK = 318,
POSTTHINK = 319,
RUNPOSTTHINK = 320,
GETFOV = 327,
SELECT_ITEM = 330,
UPDATECOLLISIONBOUNDS = 340, // 56 57 8B F9 8B 0D ? ? ? ? F6 87 ? ? ? ? ?
GETAIMPUNCHANG = 346,
GETEYEPOSITION = 348,
GETAIMPUNCH = 409
};
CUserCmd*& m_pCurrentCommand();
NETVAR(bool, m_bClientSideAnimation, crypt_str("CBaseAnimating"), crypt_str("m_bClientSideAnimation"));
NETVAR(bool, m_bHasDefuser, crypt_str("CCSPlayer"), crypt_str("m_bHasDefuser"));
NETVAR(bool, m_bGunGameImmunity, crypt_str("CCSPlayer"), crypt_str("m_bGunGameImmunity"));
NETVAR(int, m_iShotsFired, crypt_str("CCSPlayer"), crypt_str("m_iShotsFired"));
NETVAR(Vector, m_angEyeAngles, crypt_str("CCSPlayer"), crypt_str("m_angEyeAngles[0]"));
NETVAR(Vector, m_angRotation, crypt_str("CBaseEntity"), crypt_str("m_angRotation"));
NETVAR(int, m_ArmorValue, crypt_str("CCSPlayer"), crypt_str("m_ArmorValue"));
NETVAR(int, m_iAccount, crypt_str("CCSPlayer"), crypt_str("m_iAccount"));
NETVAR(bool, m_bHasHelmet, crypt_str("CCSPlayer"), crypt_str("m_bHasHelmet"));
NETVAR(bool, m_bHasHeavyArmor, crypt_str("CCSPlayer"), crypt_str("m_bHasHeavyArmor"));
NETVAR(bool, m_bIsScoped, crypt_str("CCSPlayer"), crypt_str("m_bIsScoped"));
NETVAR(float, m_flLowerBodyYawTarget, crypt_str("CCSPlayer"), crypt_str("m_flLowerBodyYawTarget"));
NETVAR(float, m_flFlashDuration, crypt_str("CCSPlayer"), crypt_str("m_flFlashDuration"));
NETVAR(CBaseHandle, m_hVehicle, crypt_str("CBasePlayer"), crypt_str("m_hVehicle"));
NETVAR(int, m_iHealth, crypt_str("CBasePlayer"), crypt_str("m_iHealth"));
NETVAR(int, m_lifeState, crypt_str("CBasePlayer"), crypt_str("m_lifeState"));
NETVAR(int, m_fFlags, crypt_str("CBasePlayer"), crypt_str("m_fFlags"));
NETVAR(int, m_nHitboxSet, crypt_str("CBasePlayer"), crypt_str("m_nHitboxSet"));
NETVAR(int, m_nTickBase, crypt_str("CBasePlayer"), crypt_str("m_nTickBase"));
NETVAR(Vector, m_vecViewOffset, crypt_str("CBasePlayer"), crypt_str("m_vecViewOffset[0]"));
NETVAR(Vector, m_viewPunchAngle, crypt_str("CBasePlayer"), crypt_str("m_viewPunchAngle"));
NETVAR(Vector, m_aimPunchAngle, crypt_str("CBasePlayer"), crypt_str("m_aimPunchAngle"));
NETVAR(Vector, m_aimPunchAngleVel, crypt_str("CBasePlayer"), crypt_str("m_aimPunchAngleVel"));
NETVAR(CHandle <viewmodel_t>, m_hViewModel, crypt_str("CBasePlayer"), crypt_str("m_hViewModel[0]"));
NETVAR(Vector, m_vecVelocity, crypt_str("CBasePlayer"), crypt_str("m_vecVelocity[0]"));
NETVAR(Vector, m_vecMins, crypt_str("CBaseEntity"), crypt_str("m_vecMins"));
NETVAR(Vector, m_vecMaxs, crypt_str("CBaseEntity"), crypt_str("m_vecMaxs"));
NETVAR(float, m_flVelocityModifier, crypt_str("CCSPlayer"), crypt_str("m_flVelocityModifier"));
NETVAR(float, m_flSimulationTime, crypt_str("CBaseEntity"), crypt_str("m_flSimulationTime"));
OFFSET(float, m_flOldSimulationTime, netvars::get().get_offset(crypt_str("CBaseEntity"), crypt_str("m_flSimulationTime")) + 0x4);
NETVAR(float, m_flDuckSpeed, crypt_str("CCSPlayer"), crypt_str("m_flDuckSpeed"));
NETVAR(float, m_flDuckAmount, crypt_str("CCSPlayer"), crypt_str("m_flDuckAmount"));
NETVAR(bool, m_bDucked, crypt_str("CCSPlayer"), crypt_str("m_bDucked"));
NETVAR(bool, m_bDucking, crypt_str("CCSPlayer"), crypt_str("m_bDucking"));
NETVAR(float, m_flHealthShotBoostExpirationTime, crypt_str("CCSPlayer"), crypt_str("m_flHealthShotBoostExpirationTime"));
NETVAR(int, m_bInBombZone, crypt_str("CCSPlayer"), crypt_str("m_bInBombZone"));
NETVAR(float, m_flFallVelocity, crypt_str("CBasePlayer"), crypt_str("m_flFallVelocity"));
NETVAR(float, m_flStepSize, crypt_str("CBaseEntity"), crypt_str("m_flStepSize"));
NETVAR(float, m_flNextAttack, crypt_str("CBaseCombatCharacter"), crypt_str("m_flNextAttack"));
PNETVAR(CBaseHandle, m_hMyWearables, crypt_str("CBaseCombatCharacter"), crypt_str("m_hMyWearables"));
NETVAR(int, m_iObserverMode, crypt_str("CBasePlayer"), crypt_str("m_iObserverMode"));
NETVAR(CHandle <player_t>, m_hObserverTarget, crypt_str("CBasePlayer"), crypt_str("m_hObserverTarget"));
NETVAR(CHandle <weapon_t>, m_hActiveWeapon, crypt_str("CBaseCombatCharacter"), crypt_str("m_hActiveWeapon"));
NETVAR(CHandle <attributableitem_t>, m_hWeaponWorldModel, crypt_str("CBaseCombatWeapon"), crypt_str("m_hWeaponWorldModel"));
NETVAR(CHandle <entity_t>, m_hGroundEntity, crypt_str("CBasePlayer"), crypt_str("m_hGroundEntity"));
NETVAR(bool, m_bSpotted, crypt_str("CBaseEntity"), crypt_str("m_bSpotted"));
NETVAR(int, m_vphysicsCollisionState, crypt_str("CBasePlayer"), crypt_str("m_vphysicsCollisionState"));
NETVAR(bool, m_bIsWalking, crypt_str("CCSPlayer"), crypt_str("m_bIsWalking"));
NETVAR(bool, m_bIsDefusing, crypt_str("CCSPlayer"), crypt_str("m_bIsDefusing"));
VIRTUAL(think(void), 138, void(__thiscall*)(void*));
VIRTUAL(pre_think(void), 317, void(__thiscall*)(void*));
VIRTUAL(post_think(void), 318, void(__thiscall*)(void*));
VIRTUAL(set_local_view_angles(Vector& angle), 372, void(__thiscall*)(void*, Vector&), angle);
NETVAR(int, get_next_think_tick, crypt_str("CBasePlayer"), crypt_str("m_nNextThinkTick"));
NETVAR(float, m_flThirdpersonRecoil, crypt_str("CCSPlayer"), crypt_str("m_flThirdpersonRecoil"));
CBaseHandle* m_hMyWeapons()
{
return (CBaseHandle*)((uintptr_t)this + 0x2E08); //fixed
}
float GetMaxPlayerSpeed();
float& m_flSpawnTime()
{
return *(float*)((uintptr_t)this + 0x103C0); //fixed
}
Vector get_eye_pos()
{
return m_vecOrigin() + m_vecViewOffset();
}
uint32_t& m_iMostRecentModelBoneCounter();
float& m_flLastBoneSetupTime();
void select_item(const char* string, int sub_type);
bool using_standard_weapons_in_vechile();
bool physics_run_think(int index);
VarMapping_t* var_mapping();
c_baseplayeranimationstate* get_animation_state();
CStudioHdr* m_pStudioHdr();
bool setup_bones_fixed(matrix3x4_t* matrix, int mask);
bool CanSeePlayer(player_t* player, const Vector& pos);
Vector get_shoot_position();
void modify_eye_position(Vector& eye_position);
uint32_t& m_fEffects();
uint32_t& m_iEFlags();
float& m_surfaceFriction();
Vector& m_vecAbsVelocity();
int get_hitbox_bone_id(int hitbox_id);
Vector hitbox_position(int hitbox_id);
Vector hitbox_position_matrix(int hitbox_id, matrix3x4_t matrix[MAXSTUDIOBONES]);
AnimationLayer* get_animlayers();
CUtlVector <matrix3x4_t>& m_CachedBoneData();
CBoneAccessor& m_BoneAccessor();
void invalidate_bone_cache();
void set_abs_velocity(const Vector& velocity);
Vector get_render_angles();
void set_render_angles(const Vector& angles);
void update_clientside_animation();
bool is_alive();
bool valid(bool check_team, bool check_dormant = true);
int get_move_type();
int animlayer_count();
int sequence_activity(int sequence);
float get_max_desync_delta();
void invalidate_physics_recursive(int change_flags);
CUserCmd*& m_PlayerCommand() {
return *(CUserCmd**)(std::uintptr_t(this) + 0x3288);
}
__forceinline void RunPostThink() {
return call_virtual< void(__thiscall*)(decltype(this)) >(this, RUNPOSTTHINK)(this);
}
//Purpose: Called before player thinks
void RunPreThink();
__forceinline void PreThink() {
return call_virtual< void(__thiscall*)(decltype(this)) >(this, PRETHINK)(this);
}
__forceinline void Think() {
return call_virtual< void(__thiscall*)(decltype(this)) >(this, THINK)(this);
}
int& m_nNextThinkTick() {
static auto next_think = netvars::get().get_offset(crypt_str("CCSPlayer"), crypt_str("m_nNextThinkTick"));
return get <int>(next_think);
}
int& m_nFinalPredictedTick() {
static int fpt = (netvars::get().get_offset(crypt_str("CCSPlayer"), crypt_str("m_nTickBase")) + 0x4);
return get< int >(fpt);
}
//-----------------------------------------------------------------------------
// Purpose: Runs the PLAYER's thinking code if time. There is some play in the exact time the think
// function will be called, because it is called before any movement is done
// in a frame. Not used for pushmove objects, because they must be exact.
// Returns false if the entity removed itself.
void RunThink();
};
class C_BaseViewModel : public entity_t
{
public:
CBaseHandle get_viewmodel_weapon()
{
static auto offset = netvars::get().get_offset(crypt_str("CBaseViewModel"), crypt_str("m_hWeapon"));
return *(CBaseHandle*)(uintptr_t(this) + offset);
}
int m_nViewModelIndex()
{
static auto offset = netvars::get().get_offset(crypt_str("CBaseViewModel"), crypt_str("m_nViewModelIndex"));
return *(int*)(uintptr_t(this) + offset);
}
float& m_flCycle()
{
//static auto m_flCycle = utils::find_in_data_map(GetPredDescMap(), "m_flCycle");
static auto offset = netvars::get().get_offset(crypt_str("CCSPlayer"), crypt_str("m_flCycle"));
return *(float*)(uintptr_t(this) + offset);
}
float& m_flModelAnimTime()
{
//static auto offset = utils::find_in_data_map(GetPredDescMap(), "m_flAnimTime");
static auto offset = netvars::get().get_offset(crypt_str("CCSPlayer"), crypt_str("m_flAnimTime"));
return *(float*)(uintptr_t(this) + offset);
}
int& m_nAnimationParity()
{
static auto offset = netvars::get().get_offset(crypt_str("CBaseViewModel"), crypt_str("m_nAnimationParity"));
return *(int*)(uintptr_t(this) + offset);
}
CBaseHandle& m_hNetworkMoveParent()
{
static auto offset = netvars::get().get_offset(crypt_str("CBasePlayer"), crypt_str("m_hOwnerEntity"));
return *(CBaseHandle*)(uintptr_t(this) + offset - sizeof(CBaseHandle));
}
int& m_nSequence()
{
//static auto m_nSequence = utils::find_in_data_map(GetPredDescMap(), "m_nSequence");
static auto m_nSequence = netvars::get().get_offset(crypt_str("CPredictedViewModel"), crypt_str("m_nSequence"));
return *(int*)(uintptr_t(this) + m_nSequence);
}
void send_matching_seq(int seq)
{
return call_virtual<void(__thiscall*)(C_BaseViewModel*, int)>(this, 245)(this, seq);
}
};
class viewmodel_t : public entity_t
{
public:
NETVAR(int, m_nModelIndex, crypt_str("CBaseViewModel"), crypt_str("m_nModelIndex"));
NETVAR(int, m_nViewModelIndex, crypt_str("CBaseViewModel"), crypt_str("m_nViewModelIndex"));
NETVAR(CHandle <weapon_t>, m_hWeapon, crypt_str("CBaseViewModel"), crypt_str("m_hWeapon"));
NETVAR(CHandle <player_t>, m_hOwner, crypt_str("CBaseViewModel"), crypt_str("m_hOwner"));
NETVAR(int, m_nAnimationParity, crypt_str("CBaseViewModel"), crypt_str("m_nAnimationParity"));
float& m_flCycle();
float& m_flAnimTime();
void SendViewModelMatchingSequence(int sequence);
};
class CCSBomb : public entity_t
{
public:
NETVAR(float, m_flDefuseCountDown, crypt_str("CPlantedC4"), crypt_str("m_flDefuseCountDown"));
NETVAR(int, m_hBombDefuser, crypt_str("CPlantedC4"), crypt_str("m_hBombDefuser"));
NETVAR(float, m_flC4Blow, crypt_str("CPlantedC4"), crypt_str("m_flC4Blow"));
NETVAR(bool, m_bBombDefused, crypt_str("CPlantedC4"), crypt_str("m_bBombDefused"));
};
class ragdoll_t : public entity_t
{
public:
NETVAR(Vector, m_vecForce, crypt_str("CCSRagdoll"), crypt_str("m_vecForce"));
NETVAR(Vector, m_vecRagdollVelocity, crypt_str("CCSRagdoll"), crypt_str("m_vecRagdollVelocity"));
};
struct inferno_t : public entity_t
{
OFFSET(float, get_spawn_time, 0x20);
static float get_expiry_time()
{
return 7.03125f;
}
};
struct smoke_t : public entity_t
{
NETVAR(int, m_nSmokeEffectTickBegin, crypt_str("CSmokeGrenadeProjectile"), crypt_str("m_nSmokeEffectTickBegin"));
NETVAR(bool, m_bDidSmokeEffect, crypt_str("CSmokeGrenadeProjectile"), crypt_str("m_bDidSmokeEffect"));
static float get_expiry_time()
{
return 19.0f;
}
};
class CHudChat
{
public:
char pad_0x0000[0x4C];
int m_timesOpened;
char pad_0x0050[0x8];
bool m_isOpen;
char pad_0x0059[0x427];
void chat_print(const char* fmt, ...);
};
class AnimationLayer
{
public:
bool m_bClientBlend; //0x0000
float m_flBlendIn; //0x0004
void* m_pStudioHdr; //0x0008
int m_nDispatchSequence; //0x000C
int m_nDispatchSequence_2; //0x0010
uint32_t m_nOrder; //0x0014
uint32_t m_nSequence; //0x0018
float_t m_flPrevCycle; //0x001C
float_t m_flWeight; //0x0020
float_t m_flWeightDeltaRate; //0x0024
float_t m_flPlaybackRate; //0x0028
float_t m_flCycle; //0x002C
void* m_pOwner; //0x0030
char pad_0038[4]; //0x0034
};
class c_baseplayeranimationstate
{
public:
char pad[3];
char bUnknown; //0x4
char pad2[87];
weapon_t* m_pLastBoneSetupWeapon; //0x5C
player_t* m_pBaseEntity; //0x60
weapon_t* m_pActiveWeapon; //0x64
weapon_t* m_pLastActiveWeapon; //0x68
float m_flLastClientSideAnimationUpdateTime; //0x6C
int m_iLastClientSideAnimationUpdateFramecount; //0x70
float m_flUpdateTimeDelta; //0x74
float m_flEyeYaw; //0x78
float m_flPitch; //0x7C
float m_flGoalFeetYaw; //0x80
float m_flCurrentFeetYaw; //0x84
float m_flCurrentTorsoYaw; //0x88
float m_flUnknownVelocityLean; //0x8C //changes when moving/jumping/hitting ground
float m_flLeanAmount; //0x90
char pad4[4]; //NaN
float m_flFeetCycle; //0x98 0 to 1
float m_flFeetYawRate; //0x9C 0 to 1
float m_fUnknown2;
float m_fDuckAmount; //0xA4
float m_fLandingDuckAdditiveSomething; //0xA8
float m_fUnknown3; //0xAC
Vector m_vOrigin; //0xB0, 0xB4, 0xB8
Vector m_vLastOrigin; //0xBC, 0xC0, 0xC4
float m_vVelocityX; //0xC8
float m_vVelocityY; //0xCC
char pad5[4];
float m_flUnknownFloat1; //0xD4 Affected by movement and direction
char pad6[8];
float m_flUnknownFloat2; //0xE0 //from -1 to 1 when moving and affected by direction
float m_flUnknownFloat3; //0xE4 //from -1 to 1 when moving and affected by direction
float m_unknown; //0xE8
float m_velocity; //0xEC
float flUpVelocity; //0xF0
float m_flSpeedNormalized; //0xF4 //from 0 to 1
float m_flFeetSpeedForwardsOrSideWays; //0xF8 //from 0 to 2. something is 1 when walking, 2.something when running, 0.653 when crouch walking
float m_flFeetSpeedUnknownForwardOrSideways; //0xFC //from 0 to 3. something
float m_flTimeSinceStartedMoving; //0x100
float m_flTimeSinceStoppedMoving; //0x104
bool m_bOnGround; //0x108
bool m_bInHitGroundAnimation; //0x109
char pad7[10];
float m_flLastOriginZ; //0x114
float m_flHeadHeightOrOffsetFromHittingGroundAnimation; //0x118 from 0 to 1, is 1 when standing
float m_flStopToFullRunningFraction; //0x11C from 0 to 1, doesnt change when walking or crouching, only running
char pad8[4]; //NaN
float m_flMovingFraction; //0x124 affected while jumping and running, or when just jumping, 0 to 1
char pad9[4]; //NaN
float m_flUnknown3;
char pad10[528];
float& time_since_in_air()
{
return *(float*)((uintptr_t)this + 0x110);
}
float& yaw_desync_adjustment()
{
return *(float*)((uintptr_t)this + 0x334 + 0x4); //fixed shonax
}
};
enum Activity
{
ACT_RESET,
ACT_IDLE,
ACT_TRANSITION,
ACT_COVER,
ACT_COVER_MED,
ACT_COVER_LOW,
ACT_WALK,
ACT_WALK_AIM,
ACT_WALK_CROUCH,
ACT_WALK_CROUCH_AIM,
ACT_RUN,
ACT_RUN_AIM,
ACT_RUN_CROUCH,
ACT_RUN_CROUCH_AIM,
ACT_RUN_PROTECTED,
ACT_SCRIPT_CUSTOM_MOVE,
ACT_RANGE_ATTACK1,
ACT_RANGE_ATTACK2,
ACT_RANGE_ATTACK1_LOW,
ACT_RANGE_ATTACK2_LOW,
ACT_DIESIMPLE,
ACT_DIEBACKWARD,
ACT_DIEFORWARD,
ACT_DIEVIOLENT,
ACT_DIERAGDOLL,
ACT_FLY,
ACT_HOVER,
ACT_GLIDE,
ACT_SWIM,
ACT_JUMP,
ACT_HOP,
ACT_LEAP,
ACT_LAND,
ACT_CLIMB_UP,
ACT_CLIMB_DOWN,
ACT_CLIMB_DISMOUNT,
ACT_SHIPLADDER_UP,
ACT_SHIPLADDER_DOWN,
ACT_STRAFE_LEFT,
ACT_STRAFE_RIGHT,
ACT_ROLL_LEFT,
ACT_ROLL_RIGHT,
ACT_TURN_LEFT,
ACT_TURN_RIGHT,
ACT_CROUCH,
ACT_CROUCHIDLE,
ACT_STAND,
ACT_USE,
ACT_ALIEN_BURROW_IDLE,
ACT_ALIEN_BURROW_OUT,
ACT_SIGNAL1,
ACT_SIGNAL2,
ACT_SIGNAL3,
ACT_SIGNAL_ADVANCE,
ACT_SIGNAL_FORWARD,
ACT_SIGNAL_GROUP,
ACT_SIGNAL_HALT,
ACT_SIGNAL_LEFT,
ACT_SIGNAL_RIGHT,
ACT_SIGNAL_TAKECOVER,
ACT_LOOKBACK_RIGHT,
ACT_LOOKBACK_LEFT,
ACT_COWER,
ACT_SMALL_FLINCH,
ACT_BIG_FLINCH,
ACT_MELEE_ATTACK1,
ACT_MELEE_ATTACK2,
ACT_RELOAD,
ACT_RELOAD_START,
ACT_RELOAD_FINISH,
ACT_RELOAD_LOW,
ACT_ARM,
ACT_DISARM,
ACT_DROP_WEAPON,
ACT_DROP_WEAPON_SHOTGUN,
ACT_PICKUP_GROUND,
ACT_PICKUP_RACK,
ACT_IDLE_ANGRY,
ACT_IDLE_RELAXED,
ACT_IDLE_STIMULATED,
ACT_IDLE_AGITATED,
ACT_IDLE_STEALTH,
ACT_IDLE_HURT,
ACT_WALK_RELAXED,
ACT_WALK_STIMULATED,
ACT_WALK_AGITATED,
ACT_WALK_STEALTH,
ACT_RUN_RELAXED,
ACT_RUN_STIMULATED,
ACT_RUN_AGITATED,
ACT_RUN_STEALTH,
ACT_IDLE_AIM_RELAXED,
ACT_IDLE_AIM_STIMULATED,
ACT_IDLE_AIM_AGITATED,
ACT_IDLE_AIM_STEALTH,
ACT_WALK_AIM_RELAXED,
ACT_WALK_AIM_STIMULATED,
ACT_WALK_AIM_AGITATED,
ACT_WALK_AIM_STEALTH,
ACT_RUN_AIM_RELAXED,
ACT_RUN_AIM_STIMULATED,
ACT_RUN_AIM_AGITATED,
ACT_RUN_AIM_STEALTH,
ACT_CROUCHIDLE_STIMULATED,
ACT_CROUCHIDLE_AIM_STIMULATED,
ACT_CROUCHIDLE_AGITATED,
ACT_WALK_HURT,
ACT_RUN_HURT,
ACT_SPECIAL_ATTACK1,
ACT_SPECIAL_ATTACK2,
ACT_COMBAT_IDLE,
ACT_WALK_SCARED,
ACT_RUN_SCARED,
ACT_VICTORY_DANCE,
ACT_DIE_HEADSHOT,
ACT_DIE_CHESTSHOT,
ACT_DIE_GUTSHOT,
ACT_DIE_BACKSHOT,
ACT_FLINCH_HEAD,
ACT_FLINCH_CHEST,
ACT_FLINCH_STOMACH,
ACT_FLINCH_LEFTARM,
ACT_FLINCH_RIGHTARM,
ACT_FLINCH_LEFTLEG,
ACT_FLINCH_RIGHTLEG,
ACT_FLINCH_PHYSICS,
ACT_FLINCH_HEAD_BACK,
ACT_FLINCH_HEAD_LEFT,
ACT_FLINCH_HEAD_RIGHT,
ACT_FLINCH_CHEST_BACK,
ACT_FLINCH_STOMACH_BACK,
ACT_FLINCH_CROUCH_FRONT,
ACT_FLINCH_CROUCH_BACK,
ACT_FLINCH_CROUCH_LEFT,
ACT_FLINCH_CROUCH_RIGHT,
ACT_IDLE_ON_FIRE,
ACT_WALK_ON_FIRE,
ACT_RUN_ON_FIRE,
ACT_RAPPEL_LOOP,
ACT_180_LEFT,
ACT_180_RIGHT,
ACT_90_LEFT,
ACT_90_RIGHT,
ACT_STEP_LEFT,
ACT_STEP_RIGHT,
ACT_STEP_BACK,
ACT_STEP_FORE,
ACT_GESTURE_RANGE_ATTACK1,
ACT_GESTURE_RANGE_ATTACK2,
ACT_GESTURE_MELEE_ATTACK1,
ACT_GESTURE_MELEE_ATTACK2,
ACT_GESTURE_RANGE_ATTACK1_LOW,
ACT_GESTURE_RANGE_ATTACK2_LOW,
ACT_MELEE_ATTACK_SWING_GESTURE,
ACT_GESTURE_SMALL_FLINCH,
ACT_GESTURE_BIG_FLINCH,
ACT_GESTURE_FLINCH_BLAST,
ACT_GESTURE_FLINCH_BLAST_SHOTGUN,
ACT_GESTURE_FLINCH_BLAST_DAMAGED,
ACT_GESTURE_FLINCH_BLAST_DAMAGED_SHOTGUN,
ACT_GESTURE_FLINCH_HEAD,
ACT_GESTURE_FLINCH_CHEST,
ACT_GESTURE_FLINCH_STOMACH,
ACT_GESTURE_FLINCH_LEFTARM,
ACT_GESTURE_FLINCH_RIGHTARM,
ACT_GESTURE_FLINCH_LEFTLEG,
ACT_GESTURE_FLINCH_RIGHTLEG,
ACT_GESTURE_TURN_LEFT,
ACT_GESTURE_TURN_RIGHT,
ACT_GESTURE_TURN_LEFT45,
ACT_GESTURE_TURN_RIGHT45,
ACT_GESTURE_TURN_LEFT90,
ACT_GESTURE_TURN_RIGHT90,
ACT_GESTURE_TURN_LEFT45_FLAT,
ACT_GESTURE_TURN_RIGHT45_FLAT,
ACT_GESTURE_TURN_LEFT90_FLAT,
ACT_GESTURE_TURN_RIGHT90_FLAT,
ACT_BARNACLE_HIT,
ACT_BARNACLE_PULL,
ACT_BARNACLE_CHOMP,
ACT_BARNACLE_CHEW,
ACT_DO_NOT_DISTURB,
ACT_SPECIFIC_SEQUENCE,
ACT_VM_DRAW,
ACT_VM_HOLSTER,
ACT_VM_IDLE,
ACT_VM_FIDGET,
ACT_VM_PULLBACK,
ACT_VM_PULLBACK_HIGH,
ACT_VM_PULLBACK_LOW,
ACT_VM_THROW,
ACT_VM_PULLPIN,
ACT_VM_PRIMARYATTACK,
ACT_VM_SECONDARYATTACK,
ACT_VM_RELOAD,
ACT_VM_DRYFIRE,
ACT_VM_HITLEFT,
ACT_VM_HITLEFT2,
ACT_VM_HITRIGHT,
ACT_VM_HITRIGHT2,
ACT_VM_HITCENTER,
ACT_VM_HITCENTER2,
ACT_VM_MISSLEFT,
ACT_VM_MISSLEFT2,
ACT_VM_MISSRIGHT,
ACT_VM_MISSRIGHT2,
ACT_VM_MISSCENTER,
ACT_VM_MISSCENTER2,
ACT_VM_HAULBACK,
ACT_VM_SWINGHARD,
ACT_VM_SWINGMISS,
ACT_VM_SWINGHIT,
ACT_VM_IDLE_TO_LOWERED,
ACT_VM_IDLE_LOWERED,
ACT_VM_LOWERED_TO_IDLE,
ACT_VM_RECOIL1,
ACT_VM_RECOIL2,
ACT_VM_RECOIL3,
ACT_VM_PICKUP,
ACT_VM_RELEASE,
ACT_VM_ATTACH_SILENCER,
ACT_VM_DETACH_SILENCER,
ACT_VM_EMPTY_FIRE,
ACT_VM_EMPTY_RELOAD,
ACT_VM_EMPTY_DRAW,
ACT_VM_EMPTY_IDLE,
ACT_SLAM_STICKWALL_IDLE,
ACT_SLAM_STICKWALL_ND_IDLE,
ACT_SLAM_STICKWALL_ATTACH,
ACT_SLAM_STICKWALL_ATTACH2,
ACT_SLAM_STICKWALL_ND_ATTACH,
ACT_SLAM_STICKWALL_ND_ATTACH2,
ACT_SLAM_STICKWALL_DETONATE,
ACT_SLAM_STICKWALL_DETONATOR_HOLSTER,
ACT_SLAM_STICKWALL_DRAW,
ACT_SLAM_STICKWALL_ND_DRAW,
ACT_SLAM_STICKWALL_TO_THROW,
ACT_SLAM_STICKWALL_TO_THROW_ND,
ACT_SLAM_STICKWALL_TO_TRIPMINE_ND,
ACT_SLAM_THROW_IDLE,
ACT_SLAM_THROW_ND_IDLE,
ACT_SLAM_THROW_THROW,
ACT_SLAM_THROW_THROW2,
ACT_SLAM_THROW_THROW_ND,
ACT_SLAM_THROW_THROW_ND2,
ACT_SLAM_THROW_DRAW,
ACT_SLAM_THROW_ND_DRAW,
ACT_SLAM_THROW_TO_STICKWALL,
ACT_SLAM_THROW_TO_STICKWALL_ND,
ACT_SLAM_THROW_DETONATE,
ACT_SLAM_THROW_DETONATOR_HOLSTER,
ACT_SLAM_THROW_TO_TRIPMINE_ND,
ACT_SLAM_TRIPMINE_IDLE,
ACT_SLAM_TRIPMINE_DRAW,
ACT_SLAM_TRIPMINE_ATTACH,
ACT_SLAM_TRIPMINE_ATTACH2,
ACT_SLAM_TRIPMINE_TO_STICKWALL_ND,
ACT_SLAM_TRIPMINE_TO_THROW_ND,
ACT_SLAM_DETONATOR_IDLE,
ACT_SLAM_DETONATOR_DRAW,
ACT_SLAM_DETONATOR_DETONATE,
ACT_SLAM_DETONATOR_HOLSTER,
ACT_SLAM_DETONATOR_STICKWALL_DRAW,
ACT_SLAM_DETONATOR_THROW_DRAW,
ACT_SHOTGUN_RELOAD_START,
ACT_SHOTGUN_RELOAD_FINISH,
ACT_SHOTGUN_PUMP,
ACT_SMG2_IDLE2,
ACT_SMG2_FIRE2,
ACT_SMG2_DRAW2,
ACT_SMG2_RELOAD2,
ACT_SMG2_DRYFIRE2,
ACT_SMG2_TOAUTO,
ACT_SMG2_TOBURST,
ACT_PHYSCANNON_UPGRADE,
ACT_RANGE_ATTACK_AR1,
ACT_RANGE_ATTACK_AR2,
ACT_RANGE_ATTACK_AR2_LOW,
ACT_RANGE_ATTACK_AR2_GRENADE,
ACT_RANGE_ATTACK_HMG1,
ACT_RANGE_ATTACK_ML,
ACT_RANGE_ATTACK_SMG1,
ACT_RANGE_ATTACK_SMG1_LOW,
ACT_RANGE_ATTACK_SMG2,
ACT_RANGE_ATTACK_SHOTGUN,
ACT_RANGE_ATTACK_SHOTGUN_LOW,
ACT_RANGE_ATTACK_PISTOL,
ACT_RANGE_ATTACK_PISTOL_LOW,
ACT_RANGE_ATTACK_SLAM,
ACT_RANGE_ATTACK_TRIPWIRE,
ACT_RANGE_ATTACK_THROW,
ACT_RANGE_ATTACK_SNIPER_RIFLE,
ACT_RANGE_ATTACK_RPG,
ACT_MELEE_ATTACK_SWING,
ACT_RANGE_AIM_LOW,
ACT_RANGE_AIM_SMG1_LOW,
ACT_RANGE_AIM_PISTOL_LOW,
ACT_RANGE_AIM_AR2_LOW,
ACT_COVER_PISTOL_LOW,
ACT_COVER_SMG1_LOW,
ACT_GESTURE_RANGE_ATTACK_AR1,
ACT_GESTURE_RANGE_ATTACK_AR2,
ACT_GESTURE_RANGE_ATTACK_AR2_GRENADE,
ACT_GESTURE_RANGE_ATTACK_HMG1,
ACT_GESTURE_RANGE_ATTACK_ML,
ACT_GESTURE_RANGE_ATTACK_SMG1,
ACT_GESTURE_RANGE_ATTACK_SMG1_LOW,
ACT_GESTURE_RANGE_ATTACK_SMG2,
ACT_GESTURE_RANGE_ATTACK_SHOTGUN,
ACT_GESTURE_RANGE_ATTACK_PISTOL,
ACT_GESTURE_RANGE_ATTACK_PISTOL_LOW,
ACT_GESTURE_RANGE_ATTACK_SLAM,
ACT_GESTURE_RANGE_ATTACK_TRIPWIRE,
ACT_GESTURE_RANGE_ATTACK_THROW,
ACT_GESTURE_RANGE_ATTACK_SNIPER_RIFLE,
ACT_GESTURE_MELEE_ATTACK_SWING,
ACT_IDLE_RIFLE,
ACT_IDLE_SMG1,
ACT_IDLE_ANGRY_SMG1,
ACT_IDLE_PISTOL,
ACT_IDLE_ANGRY_PISTOL,
ACT_IDLE_ANGRY_SHOTGUN,
ACT_IDLE_STEALTH_PISTOL,
ACT_IDLE_PACKAGE,
ACT_WALK_PACKAGE,
ACT_IDLE_SUITCASE,
ACT_WALK_SUITCASE,
ACT_IDLE_SMG1_RELAXED,
ACT_IDLE_SMG1_STIMULATED,
ACT_WALK_RIFLE_RELAXED,
ACT_RUN_RIFLE_RELAXED,
ACT_WALK_RIFLE_STIMULATED,
ACT_RUN_RIFLE_STIMULATED,
ACT_IDLE_AIM_RIFLE_STIMULATED,
ACT_WALK_AIM_RIFLE_STIMULATED,
ACT_RUN_AIM_RIFLE_STIMULATED,
ACT_IDLE_SHOTGUN_RELAXED,
ACT_IDLE_SHOTGUN_STIMULATED,
ACT_IDLE_SHOTGUN_AGITATED,
ACT_WALK_ANGRY,
ACT_POLICE_HARASS1,
ACT_POLICE_HARASS2,
ACT_IDLE_MANNEDGUN,
ACT_IDLE_MELEE,
ACT_IDLE_ANGRY_MELEE,
ACT_IDLE_RPG_RELAXED,
ACT_IDLE_RPG,
ACT_IDLE_ANGRY_RPG,
ACT_COVER_LOW_RPG,
ACT_WALK_RPG,
ACT_RUN_RPG,
ACT_WALK_CROUCH_RPG,
ACT_RUN_CROUCH_RPG,
ACT_WALK_RPG_RELAXED,
ACT_RUN_RPG_RELAXED,
ACT_WALK_RIFLE,
ACT_WALK_AIM_RIFLE,
ACT_WALK_CROUCH_RIFLE,
ACT_WALK_CROUCH_AIM_RIFLE,
ACT_RUN_RIFLE,
ACT_RUN_AIM_RIFLE,
ACT_RUN_CROUCH_RIFLE,
ACT_RUN_CROUCH_AIM_RIFLE,
ACT_RUN_STEALTH_PISTOL,
ACT_WALK_AIM_SHOTGUN,
ACT_RUN_AIM_SHOTGUN,
ACT_WALK_PISTOL,
ACT_RUN_PISTOL,
ACT_WALK_AIM_PISTOL,
ACT_RUN_AIM_PISTOL,
ACT_WALK_STEALTH_PISTOL,
ACT_WALK_AIM_STEALTH_PISTOL,
ACT_RUN_AIM_STEALTH_PISTOL,
ACT_RELOAD_PISTOL,
ACT_RELOAD_PISTOL_LOW,
ACT_RELOAD_SMG1,
ACT_RELOAD_SMG1_LOW,
ACT_RELOAD_SHOTGUN,
ACT_RELOAD_SHOTGUN_LOW,
ACT_GESTURE_RELOAD,
ACT_GESTURE_RELOAD_PISTOL,
ACT_GESTURE_RELOAD_SMG1,
ACT_GESTURE_RELOAD_SHOTGUN,
ACT_BUSY_LEAN_LEFT,
ACT_BUSY_LEAN_LEFT_ENTRY,
ACT_BUSY_LEAN_LEFT_EXIT,
ACT_BUSY_LEAN_BACK,
ACT_BUSY_LEAN_BACK_ENTRY,
ACT_BUSY_LEAN_BACK_EXIT,
ACT_BUSY_SIT_GROUND,
ACT_BUSY_SIT_GROUND_ENTRY,
ACT_BUSY_SIT_GROUND_EXIT,
ACT_BUSY_SIT_CHAIR,
ACT_BUSY_SIT_CHAIR_ENTRY,
ACT_BUSY_SIT_CHAIR_EXIT,
ACT_BUSY_STAND,
ACT_BUSY_QUEUE,
ACT_DUCK_DODGE,
ACT_DIE_BARNACLE_SWALLOW,
ACT_GESTURE_BARNACLE_STRANGLE,
ACT_PHYSCANNON_DETACH,
ACT_PHYSCANNON_ANIMATE,
ACT_PHYSCANNON_ANIMATE_PRE,
ACT_PHYSCANNON_ANIMATE_POST,
ACT_DIE_FRONTSIDE,
ACT_DIE_RIGHTSIDE,
ACT_DIE_BACKSIDE,
ACT_DIE_LEFTSIDE,
ACT_DIE_CROUCH_FRONTSIDE,
ACT_DIE_CROUCH_RIGHTSIDE,
ACT_DIE_CROUCH_BACKSIDE,
ACT_DIE_CROUCH_LEFTSIDE,
ACT_OPEN_DOOR,
ACT_DI_ALYX_ZOMBIE_MELEE,
ACT_DI_ALYX_ZOMBIE_TORSO_MELEE,
ACT_DI_ALYX_HEADCRAB_MELEE,
ACT_DI_ALYX_ANTLION,
ACT_DI_ALYX_ZOMBIE_SHOTGUN64,
ACT_DI_ALYX_ZOMBIE_SHOTGUN26,
ACT_READINESS_RELAXED_TO_STIMULATED,
ACT_READINESS_RELAXED_TO_STIMULATED_WALK,
ACT_READINESS_AGITATED_TO_STIMULATED,
ACT_READINESS_STIMULATED_TO_RELAXED,
ACT_READINESS_PISTOL_RELAXED_TO_STIMULATED,
ACT_READINESS_PISTOL_RELAXED_TO_STIMULATED_WALK,
ACT_READINESS_PISTOL_AGITATED_TO_STIMULATED,
ACT_READINESS_PISTOL_STIMULATED_TO_RELAXED,
ACT_IDLE_CARRY,
ACT_WALK_CARRY,
ACT_STARTDYING,
ACT_DYINGLOOP,
ACT_DYINGTODEAD,
ACT_RIDE_MANNED_GUN,
ACT_VM_SPRINT_ENTER,
ACT_VM_SPRINT_IDLE,
ACT_VM_SPRINT_LEAVE,
ACT_FIRE_START,
ACT_FIRE_LOOP,
ACT_FIRE_END,
ACT_CROUCHING_GRENADEIDLE,
ACT_CROUCHING_GRENADEREADY,
ACT_CROUCHING_PRIMARYATTACK,
ACT_OVERLAY_GRENADEIDLE,
ACT_OVERLAY_GRENADEREADY,
ACT_OVERLAY_PRIMARYATTACK,
ACT_OVERLAY_SHIELD_UP,
ACT_OVERLAY_SHIELD_DOWN,
ACT_OVERLAY_SHIELD_UP_IDLE,
ACT_OVERLAY_SHIELD_ATTACK,
ACT_OVERLAY_SHIELD_KNOCKBACK,
ACT_SHIELD_UP,
ACT_SHIELD_DOWN,
ACT_SHIELD_UP_IDLE,
ACT_SHIELD_ATTACK,
ACT_SHIELD_KNOCKBACK,
ACT_CROUCHING_SHIELD_UP,
ACT_CROUCHING_SHIELD_DOWN,
ACT_CROUCHING_SHIELD_UP_IDLE,
ACT_CROUCHING_SHIELD_ATTACK,
ACT_CROUCHING_SHIELD_KNOCKBACK,
ACT_TURNRIGHT45,
ACT_TURNLEFT45,
ACT_TURN,
ACT_OBJ_ASSEMBLING,
ACT_OBJ_DISMANTLING,
ACT_OBJ_STARTUP,
ACT_OBJ_RUNNING,
ACT_OBJ_IDLE,
ACT_OBJ_PLACING,
ACT_OBJ_DETERIORATING,
ACT_OBJ_UPGRADING,
ACT_DEPLOY,
ACT_DEPLOY_IDLE,
ACT_UNDEPLOY,
ACT_CROSSBOW_DRAW_UNLOADED,
ACT_GAUSS_SPINUP,
ACT_GAUSS_SPINCYCLE,
ACT_VM_PRIMARYATTACK_SILENCED,
ACT_VM_RELOAD_SILENCED,
ACT_VM_DRYFIRE_SILENCED,
ACT_VM_IDLE_SILENCED,
ACT_VM_DRAW_SILENCED,
ACT_VM_IDLE_EMPTY_LEFT,
ACT_VM_DRYFIRE_LEFT,
ACT_VM_IS_DRAW,
ACT_VM_IS_HOLSTER,
ACT_VM_IS_IDLE,
ACT_VM_IS_PRIMARYATTACK,
ACT_PLAYER_IDLE_FIRE,
ACT_PLAYER_CROUCH_FIRE,
ACT_PLAYER_CROUCH_WALK_FIRE,
ACT_PLAYER_WALK_FIRE,
ACT_PLAYER_RUN_FIRE,
ACT_IDLETORUN,
ACT_RUNTOIDLE,
ACT_VM_DRAW_DEPLOYED,
ACT_HL2MP_IDLE_MELEE,
ACT_HL2MP_RUN_MELEE,
ACT_HL2MP_IDLE_CROUCH_MELEE,
ACT_HL2MP_WALK_CROUCH_MELEE,
ACT_HL2MP_GESTURE_RANGE_ATTACK_MELEE,
ACT_HL2MP_GESTURE_RELOAD_MELEE,
ACT_HL2MP_JUMP_MELEE,
ACT_VM_FIZZLE,
ACT_MP_STAND_IDLE,
ACT_MP_CROUCH_IDLE,
ACT_MP_CROUCH_DEPLOYED_IDLE,
ACT_MP_CROUCH_DEPLOYED,
ACT_MP_DEPLOYED_IDLE,
ACT_MP_RUN,
ACT_MP_WALK,
ACT_MP_AIRWALK,
ACT_MP_CROUCHWALK,
ACT_MP_SPRINT,
ACT_MP_JUMP,
ACT_MP_JUMP_START,
ACT_MP_JUMP_FLOAT,
ACT_MP_JUMP_LAND,
ACT_MP_JUMP_IMPACT_N,
ACT_MP_JUMP_IMPACT_E,
ACT_MP_JUMP_IMPACT_W,
ACT_MP_JUMP_IMPACT_S,
ACT_MP_JUMP_IMPACT_TOP,
ACT_MP_DOUBLEJUMP,
ACT_MP_SWIM,
ACT_MP_DEPLOYED,
ACT_MP_SWIM_DEPLOYED,
ACT_MP_VCD,
ACT_MP_ATTACK_STAND_PRIMARYFIRE,
ACT_MP_ATTACK_STAND_PRIMARYFIRE_DEPLOYED,
ACT_MP_ATTACK_STAND_SECONDARYFIRE,
ACT_MP_ATTACK_STAND_GRENADE,
ACT_MP_ATTACK_CROUCH_PRIMARYFIRE,
ACT_MP_ATTACK_CROUCH_PRIMARYFIRE_DEPLOYED,
ACT_MP_ATTACK_CROUCH_SECONDARYFIRE,
ACT_MP_ATTACK_CROUCH_GRENADE,
ACT_MP_ATTACK_SWIM_PRIMARYFIRE,
ACT_MP_ATTACK_SWIM_SECONDARYFIRE,
ACT_MP_ATTACK_SWIM_GRENADE,
ACT_MP_ATTACK_AIRWALK_PRIMARYFIRE,
ACT_MP_ATTACK_AIRWALK_SECONDARYFIRE,
ACT_MP_ATTACK_AIRWALK_GRENADE,
ACT_MP_RELOAD_STAND,
ACT_MP_RELOAD_STAND_LOOP,
ACT_MP_RELOAD_STAND_END,
ACT_MP_RELOAD_CROUCH,
ACT_MP_RELOAD_CROUCH_LOOP,
ACT_MP_RELOAD_CROUCH_END,
ACT_MP_RELOAD_SWIM,
ACT_MP_RELOAD_SWIM_LOOP,
ACT_MP_RELOAD_SWIM_END,
ACT_MP_RELOAD_AIRWALK,
ACT_MP_RELOAD_AIRWALK_LOOP,
ACT_MP_RELOAD_AIRWALK_END,
ACT_MP_ATTACK_STAND_PREFIRE,
ACT_MP_ATTACK_STAND_POSTFIRE,
ACT_MP_ATTACK_STAND_STARTFIRE,
ACT_MP_ATTACK_CROUCH_PREFIRE,
ACT_MP_ATTACK_CROUCH_POSTFIRE,
ACT_MP_ATTACK_SWIM_PREFIRE,
ACT_MP_ATTACK_SWIM_POSTFIRE,
ACT_MP_STAND_PRIMARY,
ACT_MP_CROUCH_PRIMARY,
ACT_MP_RUN_PRIMARY,
ACT_MP_WALK_PRIMARY,
ACT_MP_AIRWALK_PRIMARY,
ACT_MP_CROUCHWALK_PRIMARY,
ACT_MP_JUMP_PRIMARY,
ACT_MP_JUMP_START_PRIMARY,
ACT_MP_JUMP_FLOAT_PRIMARY,
ACT_MP_JUMP_LAND_PRIMARY,
ACT_MP_SWIM_PRIMARY,
ACT_MP_DEPLOYED_PRIMARY,
ACT_MP_SWIM_DEPLOYED_PRIMARY,
ACT_MP_ATTACK_STAND_PRIMARY,
ACT_MP_ATTACK_STAND_PRIMARY_DEPLOYED,
ACT_MP_ATTACK_CROUCH_PRIMARY,
ACT_MP_ATTACK_CROUCH_PRIMARY_DEPLOYED,
ACT_MP_ATTACK_SWIM_PRIMARY,
ACT_MP_ATTACK_AIRWALK_PRIMARY,
ACT_MP_RELOAD_STAND_PRIMARY,
ACT_MP_RELOAD_STAND_PRIMARY_LOOP,
ACT_MP_RELOAD_STAND_PRIMARY_END,
ACT_MP_RELOAD_CROUCH_PRIMARY,
ACT_MP_RELOAD_CROUCH_PRIMARY_LOOP,
ACT_MP_RELOAD_CROUCH_PRIMARY_END,
ACT_MP_RELOAD_SWIM_PRIMARY,
ACT_MP_RELOAD_SWIM_PRIMARY_LOOP,
ACT_MP_RELOAD_SWIM_PRIMARY_END,
ACT_MP_RELOAD_AIRWALK_PRIMARY,
ACT_MP_RELOAD_AIRWALK_PRIMARY_LOOP,
ACT_MP_RELOAD_AIRWALK_PRIMARY_END,
ACT_MP_ATTACK_STAND_GRENADE_PRIMARY,
ACT_MP_ATTACK_CROUCH_GRENADE_PRIMARY,
ACT_MP_ATTACK_SWIM_GRENADE_PRIMARY,
ACT_MP_ATTACK_AIRWALK_GRENADE_PRIMARY,
ACT_MP_STAND_SECONDARY,
ACT_MP_CROUCH_SECONDARY,
ACT_MP_RUN_SECONDARY,
ACT_MP_WALK_SECONDARY,
ACT_MP_AIRWALK_SECONDARY,
ACT_MP_CROUCHWALK_SECONDARY,
ACT_MP_JUMP_SECONDARY,
ACT_MP_JUMP_START_SECONDARY,
ACT_MP_JUMP_FLOAT_SECONDARY,
ACT_MP_JUMP_LAND_SECONDARY,
ACT_MP_SWIM_SECONDARY,
ACT_MP_ATTACK_STAND_SECONDARY,
ACT_MP_ATTACK_CROUCH_SECONDARY,
ACT_MP_ATTACK_SWIM_SECONDARY,
ACT_MP_ATTACK_AIRWALK_SECONDARY,
ACT_MP_RELOAD_STAND_SECONDARY,
ACT_MP_RELOAD_STAND_SECONDARY_LOOP,
ACT_MP_RELOAD_STAND_SECONDARY_END,
ACT_MP_RELOAD_CROUCH_SECONDARY,
ACT_MP_RELOAD_CROUCH_SECONDARY_LOOP,
ACT_MP_RELOAD_CROUCH_SECONDARY_END,
ACT_MP_RELOAD_SWIM_SECONDARY,
ACT_MP_RELOAD_SWIM_SECONDARY_LOOP,
ACT_MP_RELOAD_SWIM_SECONDARY_END,
ACT_MP_RELOAD_AIRWALK_SECONDARY,
ACT_MP_RELOAD_AIRWALK_SECONDARY_LOOP,
ACT_MP_RELOAD_AIRWALK_SECONDARY_END,
ACT_MP_ATTACK_STAND_GRENADE_SECONDARY,
ACT_MP_ATTACK_CROUCH_GRENADE_SECONDARY,
ACT_MP_ATTACK_SWIM_GRENADE_SECONDARY,
ACT_MP_ATTACK_AIRWALK_GRENADE_SECONDARY,
ACT_MP_STAND_MELEE,
ACT_MP_CROUCH_MELEE,
ACT_MP_RUN_MELEE,
ACT_MP_WALK_MELEE,
ACT_MP_AIRWALK_MELEE,
ACT_MP_CROUCHWALK_MELEE,
ACT_MP_JUMP_MELEE,
ACT_MP_JUMP_START_MELEE,
ACT_MP_JUMP_FLOAT_MELEE,
ACT_MP_JUMP_LAND_MELEE,
ACT_MP_SWIM_MELEE,
ACT_MP_ATTACK_STAND_MELEE,
ACT_MP_ATTACK_STAND_MELEE_SECONDARY,
ACT_MP_ATTACK_CROUCH_MELEE,
ACT_MP_ATTACK_CROUCH_MELEE_SECONDARY,
ACT_MP_ATTACK_SWIM_MELEE,
ACT_MP_ATTACK_AIRWALK_MELEE,
ACT_MP_ATTACK_STAND_GRENADE_MELEE,
ACT_MP_ATTACK_CROUCH_GRENADE_MELEE,
ACT_MP_ATTACK_SWIM_GRENADE_MELEE,
ACT_MP_ATTACK_AIRWALK_GRENADE_MELEE,
ACT_MP_STAND_ITEM1,
ACT_MP_CROUCH_ITEM1,
ACT_MP_RUN_ITEM1,
ACT_MP_WALK_ITEM1,
ACT_MP_AIRWALK_ITEM1,
ACT_MP_CROUCHWALK_ITEM1,
ACT_MP_JUMP_ITEM1,
ACT_MP_JUMP_START_ITEM1,
ACT_MP_JUMP_FLOAT_ITEM1,
ACT_MP_JUMP_LAND_ITEM1,
ACT_MP_SWIM_ITEM1,
ACT_MP_ATTACK_STAND_ITEM1,
ACT_MP_ATTACK_STAND_ITEM1_SECONDARY,
ACT_MP_ATTACK_CROUCH_ITEM1,
ACT_MP_ATTACK_CROUCH_ITEM1_SECONDARY,
ACT_MP_ATTACK_SWIM_ITEM1,
ACT_MP_ATTACK_AIRWALK_ITEM1,
ACT_MP_STAND_ITEM2,
ACT_MP_CROUCH_ITEM2,
ACT_MP_RUN_ITEM2,
ACT_MP_WALK_ITEM2,
ACT_MP_AIRWALK_ITEM2,
ACT_MP_CROUCHWALK_ITEM2,
ACT_MP_JUMP_ITEM2,
ACT_MP_JUMP_START_ITEM2,
ACT_MP_JUMP_FLOAT_ITEM2,
ACT_MP_JUMP_LAND_ITEM2,
ACT_MP_SWIM_ITEM2,
ACT_MP_ATTACK_STAND_ITEM2,
ACT_MP_ATTACK_STAND_ITEM2_SECONDARY,
ACT_MP_ATTACK_CROUCH_ITEM2,
ACT_MP_ATTACK_CROUCH_ITEM2_SECONDARY,
ACT_MP_ATTACK_SWIM_ITEM2,
ACT_MP_ATTACK_AIRWALK_ITEM2,
ACT_MP_GESTURE_FLINCH,
ACT_MP_GESTURE_FLINCH_PRIMARY,
ACT_MP_GESTURE_FLINCH_SECONDARY,
ACT_MP_GESTURE_FLINCH_MELEE,
ACT_MP_GESTURE_FLINCH_ITEM1,
ACT_MP_GESTURE_FLINCH_ITEM2,
ACT_MP_GESTURE_FLINCH_HEAD,
ACT_MP_GESTURE_FLINCH_CHEST,
ACT_MP_GESTURE_FLINCH_STOMACH,
ACT_MP_GESTURE_FLINCH_LEFTARM,
ACT_MP_GESTURE_FLINCH_RIGHTARM,
ACT_MP_GESTURE_FLINCH_LEFTLEG,
ACT_MP_GESTURE_FLINCH_RIGHTLEG,
ACT_MP_GRENADE1_DRAW,
ACT_MP_GRENADE1_IDLE,
ACT_MP_GRENADE1_ATTACK,
ACT_MP_GRENADE2_DRAW,
ACT_MP_GRENADE2_IDLE,
ACT_MP_GRENADE2_ATTACK,
ACT_MP_PRIMARY_GRENADE1_DRAW,
ACT_MP_PRIMARY_GRENADE1_IDLE,
ACT_MP_PRIMARY_GRENADE1_ATTACK,
ACT_MP_PRIMARY_GRENADE2_DRAW,
ACT_MP_PRIMARY_GRENADE2_IDLE,
ACT_MP_PRIMARY_GRENADE2_ATTACK,
ACT_MP_SECONDARY_GRENADE1_DRAW,
ACT_MP_SECONDARY_GRENADE1_IDLE,
ACT_MP_SECONDARY_GRENADE1_ATTACK,
ACT_MP_SECONDARY_GRENADE2_DRAW,
ACT_MP_SECONDARY_GRENADE2_IDLE,
ACT_MP_SECONDARY_GRENADE2_ATTACK,
ACT_MP_MELEE_GRENADE1_DRAW,
ACT_MP_MELEE_GRENADE1_IDLE,
ACT_MP_MELEE_GRENADE1_ATTACK,
ACT_MP_MELEE_GRENADE2_DRAW,
ACT_MP_MELEE_GRENADE2_IDLE,
ACT_MP_MELEE_GRENADE2_ATTACK,
ACT_MP_ITEM1_GRENADE1_DRAW,
ACT_MP_ITEM1_GRENADE1_IDLE,
ACT_MP_ITEM1_GRENADE1_ATTACK,
ACT_MP_ITEM1_GRENADE2_DRAW,
ACT_MP_ITEM1_GRENADE2_IDLE,
ACT_MP_ITEM1_GRENADE2_ATTACK,
ACT_MP_ITEM2_GRENADE1_DRAW,
ACT_MP_ITEM2_GRENADE1_IDLE,
ACT_MP_ITEM2_GRENADE1_ATTACK,
ACT_MP_ITEM2_GRENADE2_DRAW,
ACT_MP_ITEM2_GRENADE2_IDLE,
ACT_MP_ITEM2_GRENADE2_ATTACK,
ACT_MP_STAND_BUILDING,
ACT_MP_CROUCH_BUILDING,
ACT_MP_RUN_BUILDING,
ACT_MP_WALK_BUILDING,
ACT_MP_AIRWALK_BUILDING,
ACT_MP_CROUCHWALK_BUILDING,
ACT_MP_JUMP_BUILDING,
ACT_MP_JUMP_START_BUILDING,
ACT_MP_JUMP_FLOAT_BUILDING,
ACT_MP_JUMP_LAND_BUILDING,
ACT_MP_SWIM_BUILDING,
ACT_MP_ATTACK_STAND_BUILDING,
ACT_MP_ATTACK_CROUCH_BUILDING,
ACT_MP_ATTACK_SWIM_BUILDING,
ACT_MP_ATTACK_AIRWALK_BUILDING,
ACT_MP_ATTACK_STAND_GRENADE_BUILDING,
ACT_MP_ATTACK_CROUCH_GRENADE_BUILDING,
ACT_MP_ATTACK_SWIM_GRENADE_BUILDING,
ACT_MP_ATTACK_AIRWALK_GRENADE_BUILDING,
ACT_MP_STAND_PDA,
ACT_MP_CROUCH_PDA,
ACT_MP_RUN_PDA,
ACT_MP_WALK_PDA,
ACT_MP_AIRWALK_PDA,
ACT_MP_CROUCHWALK_PDA,
ACT_MP_JUMP_PDA,
ACT_MP_JUMP_START_PDA,
ACT_MP_JUMP_FLOAT_PDA,
ACT_MP_JUMP_LAND_PDA,
ACT_MP_SWIM_PDA,
ACT_MP_ATTACK_STAND_PDA,
ACT_MP_ATTACK_SWIM_PDA,
ACT_MP_GESTURE_VC_HANDMOUTH,
ACT_MP_GESTURE_VC_FINGERPOINT,
ACT_MP_GESTURE_VC_FISTPUMP,
ACT_MP_GESTURE_VC_THUMBSUP,
ACT_MP_GESTURE_VC_NODYES,
ACT_MP_GESTURE_VC_NODNO,
ACT_MP_GESTURE_VC_HANDMOUTH_PRIMARY,
ACT_MP_GESTURE_VC_FINGERPOINT_PRIMARY,
ACT_MP_GESTURE_VC_FISTPUMP_PRIMARY,
ACT_MP_GESTURE_VC_THUMBSUP_PRIMARY,
ACT_MP_GESTURE_VC_NODYES_PRIMARY,
ACT_MP_GESTURE_VC_NODNO_PRIMARY,
ACT_MP_GESTURE_VC_HANDMOUTH_SECONDARY,
ACT_MP_GESTURE_VC_FINGERPOINT_SECONDARY,
ACT_MP_GESTURE_VC_FISTPUMP_SECONDARY,
ACT_MP_GESTURE_VC_THUMBSUP_SECONDARY,
ACT_MP_GESTURE_VC_NODYES_SECONDARY,
ACT_MP_GESTURE_VC_NODNO_SECONDARY,
ACT_MP_GESTURE_VC_HANDMOUTH_MELEE,
ACT_MP_GESTURE_VC_FINGERPOINT_MELEE,
ACT_MP_GESTURE_VC_FISTPUMP_MELEE,
ACT_MP_GESTURE_VC_THUMBSUP_MELEE,
ACT_MP_GESTURE_VC_NODYES_MELEE,
ACT_MP_GESTURE_VC_NODNO_MELEE,
ACT_MP_GESTURE_VC_HANDMOUTH_ITEM1,
ACT_MP_GESTURE_VC_FINGERPOINT_ITEM1,
ACT_MP_GESTURE_VC_FISTPUMP_ITEM1,
ACT_MP_GESTURE_VC_THUMBSUP_ITEM1,
ACT_MP_GESTURE_VC_NODYES_ITEM1,
ACT_MP_GESTURE_VC_NODNO_ITEM1,
ACT_MP_GESTURE_VC_HANDMOUTH_ITEM2,
ACT_MP_GESTURE_VC_FINGERPOINT_ITEM2,
ACT_MP_GESTURE_VC_FISTPUMP_ITEM2,
ACT_MP_GESTURE_VC_THUMBSUP_ITEM2,
ACT_MP_GESTURE_VC_NODYES_ITEM2,
ACT_MP_GESTURE_VC_NODNO_ITEM2,
ACT_MP_GESTURE_VC_HANDMOUTH_BUILDING,
ACT_MP_GESTURE_VC_FINGERPOINT_BUILDING,
ACT_MP_GESTURE_VC_FISTPUMP_BUILDING,
ACT_MP_GESTURE_VC_THUMBSUP_BUILDING,
ACT_MP_GESTURE_VC_NODYES_BUILDING,
ACT_MP_GESTURE_VC_NODNO_BUILDING,
ACT_MP_GESTURE_VC_HANDMOUTH_PDA,
ACT_MP_GESTURE_VC_FINGERPOINT_PDA,
ACT_MP_GESTURE_VC_FISTPUMP_PDA,
ACT_MP_GESTURE_VC_THUMBSUP_PDA,
ACT_MP_GESTURE_VC_NODYES_PDA,
ACT_MP_GESTURE_VC_NODNO_PDA,
ACT_VM_UNUSABLE,
ACT_VM_UNUSABLE_TO_USABLE,
ACT_VM_USABLE_TO_UNUSABLE,
ACT_PRIMARY_VM_DRAW,
ACT_PRIMARY_VM_HOLSTER,
ACT_PRIMARY_VM_IDLE,
ACT_PRIMARY_VM_PULLBACK,
ACT_PRIMARY_VM_PRIMARYATTACK,
ACT_PRIMARY_VM_SECONDARYATTACK,
ACT_PRIMARY_VM_RELOAD,
ACT_PRIMARY_VM_DRYFIRE,
ACT_PRIMARY_VM_IDLE_TO_LOWERED,
ACT_PRIMARY_VM_IDLE_LOWERED,
ACT_PRIMARY_VM_LOWERED_TO_IDLE,
ACT_SECONDARY_VM_DRAW,
ACT_SECONDARY_VM_HOLSTER,
ACT_SECONDARY_VM_IDLE,
ACT_SECONDARY_VM_PULLBACK,
ACT_SECONDARY_VM_PRIMARYATTACK,
ACT_SECONDARY_VM_SECONDARYATTACK,
ACT_SECONDARY_VM_RELOAD,
ACT_SECONDARY_VM_DRYFIRE,
ACT_SECONDARY_VM_IDLE_TO_LOWERED,
ACT_SECONDARY_VM_IDLE_LOWERED,
ACT_SECONDARY_VM_LOWERED_TO_IDLE,
ACT_MELEE_VM_DRAW,
ACT_MELEE_VM_HOLSTER,
ACT_MELEE_VM_IDLE,
ACT_MELEE_VM_PULLBACK,
ACT_MELEE_VM_PRIMARYATTACK,
ACT_MELEE_VM_SECONDARYATTACK,
ACT_MELEE_VM_RELOAD,
ACT_MELEE_VM_DRYFIRE,
ACT_MELEE_VM_IDLE_TO_LOWERED,
ACT_MELEE_VM_IDLE_LOWERED,
ACT_MELEE_VM_LOWERED_TO_IDLE,
ACT_PDA_VM_DRAW,
ACT_PDA_VM_HOLSTER,
ACT_PDA_VM_IDLE,
ACT_PDA_VM_PULLBACK,
ACT_PDA_VM_PRIMARYATTACK,
ACT_PDA_VM_SECONDARYATTACK,
ACT_PDA_VM_RELOAD,
ACT_PDA_VM_DRYFIRE,
ACT_PDA_VM_IDLE_TO_LOWERED,
ACT_PDA_VM_IDLE_LOWERED,
ACT_PDA_VM_LOWERED_TO_IDLE,
ACT_ITEM1_VM_DRAW,
ACT_ITEM1_VM_HOLSTER,
ACT_ITEM1_VM_IDLE,
ACT_ITEM1_VM_PULLBACK,
ACT_ITEM1_VM_PRIMARYATTACK,
ACT_ITEM1_VM_SECONDARYATTACK,
ACT_ITEM1_VM_RELOAD,
ACT_ITEM1_VM_DRYFIRE,
ACT_ITEM1_VM_IDLE_TO_LOWERED,
ACT_ITEM1_VM_IDLE_LOWERED,
ACT_ITEM1_VM_LOWERED_TO_IDLE,
ACT_ITEM2_VM_DRAW,
ACT_ITEM2_VM_HOLSTER,
ACT_ITEM2_VM_IDLE,
ACT_ITEM2_VM_PULLBACK,
ACT_ITEM2_VM_PRIMARYATTACK,
ACT_ITEM2_VM_SECONDARYATTACK,
ACT_ITEM2_VM_RELOAD,
ACT_ITEM2_VM_DRYFIRE,
ACT_ITEM2_VM_IDLE_TO_LOWERED,
ACT_ITEM2_VM_IDLE_LOWERED,
ACT_ITEM2_VM_LOWERED_TO_IDLE,
ACT_RELOAD_SUCCEED,
ACT_RELOAD_FAIL,
ACT_WALK_AIM_AUTOGUN,
ACT_RUN_AIM_AUTOGUN,
ACT_IDLE_AUTOGUN,
ACT_IDLE_AIM_AUTOGUN,
ACT_RELOAD_AUTOGUN,
ACT_CROUCH_IDLE_AUTOGUN,
ACT_RANGE_ATTACK_AUTOGUN,
ACT_JUMP_AUTOGUN,
ACT_IDLE_AIM_PISTOL,
ACT_WALK_AIM_DUAL,
ACT_RUN_AIM_DUAL,
ACT_IDLE_DUAL,
ACT_IDLE_AIM_DUAL,
ACT_RELOAD_DUAL,
ACT_CROUCH_IDLE_DUAL,
ACT_RANGE_ATTACK_DUAL,
ACT_JUMP_DUAL,
ACT_IDLE_SHOTGUN,
ACT_IDLE_AIM_SHOTGUN,
ACT_CROUCH_IDLE_SHOTGUN,
ACT_JUMP_SHOTGUN,
ACT_IDLE_AIM_RIFLE,
ACT_RELOAD_RIFLE,
ACT_CROUCH_IDLE_RIFLE,
ACT_RANGE_ATTACK_RIFLE,
ACT_JUMP_RIFLE,
ACT_SLEEP,
ACT_WAKE,
ACT_FLICK_LEFT,
ACT_FLICK_LEFT_MIDDLE,
ACT_FLICK_RIGHT_MIDDLE,
ACT_FLICK_RIGHT,
ACT_SPINAROUND,
ACT_PREP_TO_FIRE,
ACT_FIRE,
ACT_FIRE_RECOVER,
ACT_SPRAY,
ACT_PREP_EXPLODE,
ACT_EXPLODE,
ACT_DOTA_IDLE,
ACT_DOTA_RUN,
ACT_DOTA_ATTACK,
ACT_DOTA_ATTACK_EVENT,
ACT_DOTA_DIE,
ACT_DOTA_FLINCH,
ACT_DOTA_DISABLED,
ACT_DOTA_CAST_ABILITY_1,
ACT_DOTA_CAST_ABILITY_2,
ACT_DOTA_CAST_ABILITY_3,
ACT_DOTA_CAST_ABILITY_4,
ACT_DOTA_OVERRIDE_ABILITY_1,
ACT_DOTA_OVERRIDE_ABILITY_2,
ACT_DOTA_OVERRIDE_ABILITY_3,
ACT_DOTA_OVERRIDE_ABILITY_4,
ACT_DOTA_CHANNEL_ABILITY_1,
ACT_DOTA_CHANNEL_ABILITY_2,
ACT_DOTA_CHANNEL_ABILITY_3,
ACT_DOTA_CHANNEL_ABILITY_4,
ACT_DOTA_CHANNEL_END_ABILITY_1,
ACT_DOTA_CHANNEL_END_ABILITY_2,
ACT_DOTA_CHANNEL_END_ABILITY_3,
ACT_DOTA_CHANNEL_END_ABILITY_4,
ACT_MP_RUN_SPEEDPAINT,
ACT_MP_LONG_FALL,
ACT_MP_TRACTORBEAM_FLOAT,
ACT_MP_DEATH_CRUSH,
ACT_MP_RUN_SPEEDPAINT_PRIMARY,
ACT_MP_DROWNING_PRIMARY,
ACT_MP_LONG_FALL_PRIMARY,
ACT_MP_TRACTORBEAM_FLOAT_PRIMARY,
ACT_MP_DEATH_CRUSH_PRIMARY,
ACT_DIE_STAND,
ACT_DIE_STAND_HEADSHOT,
ACT_DIE_CROUCH,
ACT_DIE_CROUCH_HEADSHOT,
ACT_CSGO_NULL,
ACT_CSGO_DEFUSE,
ACT_CSGO_DEFUSE_WITH_KIT,
ACT_CSGO_FLASHBANG_REACTION,
ACT_CSGO_FIRE_PRIMARY,
ACT_CSGO_FIRE_PRIMARY_OPT_1,
ACT_CSGO_FIRE_PRIMARY_OPT_2,
ACT_CSGO_FIRE_SECONDARY,
ACT_CSGO_FIRE_SECONDARY_OPT_1,
ACT_CSGO_FIRE_SECONDARY_OPT_2,
ACT_CSGO_RELOAD,
ACT_CSGO_RELOAD_START,
ACT_CSGO_RELOAD_LOOP,
ACT_CSGO_RELOAD_END,
ACT_CSGO_OPERATE,
ACT_CSGO_DEPLOY,
ACT_CSGO_CATCH,
ACT_CSGO_SILENCER_DETACH,
ACT_CSGO_SILENCER_ATTACH,
ACT_CSGO_TWITCH,
ACT_CSGO_TWITCH_BUYZONE,
ACT_CSGO_PLANT_BOMB,
ACT_CSGO_IDLE_TURN_BALANCEADJUST,
ACT_CSGO_IDLE_ADJUST_STOPPEDMOVING,
ACT_CSGO_ALIVE_LOOP,
ACT_CSGO_FLINCH,
ACT_CSGO_FLINCH_HEAD,
ACT_CSGO_FLINCH_MOLOTOV,
ACT_CSGO_JUMP,
ACT_CSGO_FALL,
ACT_CSGO_CLIMB_LADDER,
ACT_CSGO_LAND_LIGHT,
ACT_CSGO_LAND_HEAVY,
ACT_CSGO_EXIT_LADDER_TOP,
ACT_CSGO_EXIT_LADDER_BOTTOM,
};
class INetworkStringTable
{
public:
virtual ~INetworkStringTable(void) {};
Table Info
virtual const char* GetTableName(void) const = 0;
virtual int GetTableId(void) const = 0;
virtual int GetNumStrings(void) const = 0;
virtual int GetMaxStrings(void) const = 0;
virtual int GetEntryBits(void) const = 0;
Networking
virtual void SetTick(int tick) = 0;
virtual bool ChangedSinceTick(int tick) const = 0;
Accessors (length -1 means don't change user data if string already exits)
virtual int AddString(bool bIsServer, const char* value, int length = -1, const void* userdata = 0) = 0;
virtual const char* GetString(int stringNumber) = 0;
virtual void SetStringUserData(int stringNumber, int length, const void* userdata) = 0;
virtual const void* GetStringUserData(int stringNumber, int* length) = 0;
virtual int FindStringIndex(char const* string) = 0; returns INVALID_STRING_INDEX if not found
Callbacks
virtual void SetStringChangedCallback(void* object, void* changeFunc) = 0;
};
class CNetworkStringTableContainer
{
template <typename T, typename ... args_t>
constexpr T CallVFunc(void* thisptr, std::size_t nIndex, args_t... argList)
{
using VirtualFnz = T(__thiscall*)(void*, decltype(argList)...);
return (*static_cast<VirtualFnz**>(thisptr))[nIndex](thisptr, argList...);
}
public:
INetworkStringTable* FindTable(const char* tableName)
{
typedef INetworkStringTable* (__thiscall* oFindTable)(PVOID, const char*);
return CallVFunc< oFindTable >(this, 3)(this, tableName);
}
};
inline CNetworkStringTableContainer* ClientStringTableContainer = new CNetworkStringTableContainer();next time use
Пожалуйста, авторизуйтесь для просмотра ссылки.
Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 5 Июн 2021
- Сообщения
- 100
- Реакции
- 6
1)Fucked resolver/lagcompensation
2)Fucked weapon_t
That's what comes on my mind and your aim.cpp is very bad. Maybe check if aim locks on another target. Example if it locks on target thats behind the wall you and you want to shoot one that isnt behind the wall it would probably stuck.
