хелпаните как в аимботе visiblity check сделать а то он чё то не работает (не наводится крч)
мега вайбкод:
мега вайбкод:
aimbot.cpp:
#include <astrum.h>
vec3_t aimbot::calculate_angle(const vec3_t& source, const vec3_t& destination) {
vec3_t delta = destination - source;
float length = std::sqrtf(delta.x * delta.x + delta.y * delta.y + delta.z * delta.z);
if (length < 0.1f || !std::isfinite(length))
return vec3_t(0, 0, 0);
constexpr float RAD2DEG = 180.0f / 3.14159265358979323846f;
float pitch = -std::asin(delta.z / length) * RAD2DEG;
float yaw = std::atan2(delta.y, delta.x) * RAD2DEG;
if (!std::isfinite(pitch) || !std::isfinite(yaw))
return vec3_t(0, 0, 0);
return vec3_t(pitch, yaw, 0.0f);
}
vec3_t aimbot::get_hitbox_position(c_cs_player_pawn* pawn, hitbox_t hitbox) {
if (!pawn)
return vec3_t(0, 0, 0);
auto scene_node = pawn->m_scene_node();
if (!scene_node)
return vec3_t(0, 0, 0);
auto& origin = scene_node->m_abs_origin();
auto collision = pawn->m_collision();
if (!collision)
return origin;
vec3_t mins = collision->m_mins();
vec3_t maxs = collision->m_maxs();
float height = maxs.z - mins.z;
vec3_t position = origin;
switch (hitbox) {
case hitbox_t::HEAD:
position.z += height * 0.9f;
break;
case hitbox_t::NECK:
position.z += height * 0.8f;
break;
case hitbox_t::STOMACH:
position.z += height * 0.5f;
break;
case hitbox_t::HANDS:
position.z += height * 0.6f;
break;
case hitbox_t::LEGS:
position.z += height * 0.2f;
break;
case hitbox_t::NEAREST:
position.z += height * 0.9f;
break;
}
return position;
}
bool aimbot::is_visible(c_cs_player_pawn* pawn) {
if (!pawn || !ctx::local_pawn)
return false;
auto local_scene = ctx::local_pawn->m_scene_node();
auto enemy_scene = pawn->m_scene_node();
if (!local_scene || !enemy_scene)
return false;
vec3_t local_origin = local_scene->m_abs_origin();
vec3_t enemy_origin = enemy_scene->m_abs_origin();
// Добавляем eye offset
auto local_collision = ctx::local_pawn->m_collision();
if (local_collision) {
local_origin.z += local_collision->m_maxs().z * 0.9f;
}
auto enemy_collision = pawn->m_collision();
if (enemy_collision) {
enemy_origin.z += enemy_collision->m_maxs().z * 0.5f; // Center mass
}
// Используем autowall для проверки видимости
return autowall::is_visible(local_origin, enemy_origin, pawn, -1);
}
void aimbot::draw_fov_circle() {
if (!draw_fov || !ctx::local_pawn)
return;
ImGui::GetBackgroundDrawList()->AddCircle(
ImVec2(ImGui::GetIO().DisplaySize.x * 0.5f, ImGui::GetIO().DisplaySize.y * 0.5f),
fov * (ImGui::GetIO().DisplaySize.y / 90.0f),
ImGui::ColorConvertFloat4ToU32(fov_color),
64,
2.0f
);
}
c_cs_player_pawn* aimbot::get_best_target() {
if (!ctx::local_pawn || !interfaces::entity_system)
return nullptr;
auto local_scene = ctx::local_pawn->m_scene_node();
if (!local_scene)
return nullptr;
vec3_t local_origin = local_scene->m_abs_origin();
// Используем collision для безопасного получения eye position
auto local_collision = ctx::local_pawn->m_collision();
if (local_collision) {
local_origin.z += local_collision->m_maxs().z * 0.9f;
}
auto local_team = ctx::local_pawn->m_team_num();
c_cs_player_pawn* best_target = nullptr;
float best_fov_value = fov;
float best_distance = FLT_MAX;
auto view_angles = interfaces::input->get_view_angles();
auto highest_index = interfaces::entity_system->get_highest_entity_index();
// Сначала находим local_index
int local_index = -1;
for (int i = 0; i <= highest_index; ++i) {
auto entity = interfaces::entity_system->get(i);
if (!entity || !entity->is_player_controller())
continue;
auto controller = reinterpret_cast<c_cs_player_controller*>(entity);
auto pawn = reinterpret_cast<c_cs_player_pawn*>(interfaces::entity_system->get(controller->m_player_pawn()));
if (pawn == ctx::local_pawn) {
local_index = i;
break;
}
}
for (int i = 0; i <= highest_index; ++i) {
auto entity = interfaces::entity_system->get(i);
if (!entity || !entity->is_player_controller())
continue;
auto controller = reinterpret_cast<c_cs_player_controller*>(entity);
auto pawn = reinterpret_cast<c_cs_player_pawn*>(interfaces::entity_system->get(controller->m_player_pawn()));
if (!pawn || pawn == ctx::local_pawn || pawn->m_health() <= 0)
continue;
// ВАЖНО: Не целимся в тиммейтов!
if (pawn->m_team_num() == local_team)
continue;
vec3_t target_pos = get_hitbox_position(pawn, static_cast<hitbox_t>(hitbox));
if (visible_only && !is_visible(pawn))
continue;
vec3_t angle_to_target = calculate_angle(local_origin, target_pos);
if (!std::isfinite(angle_to_target.x) || !std::isfinite(angle_to_target.y))
continue;
vec3_t delta;
delta.x = view_angles.x - angle_to_target.x;
delta.y = view_angles.y - angle_to_target.y;
while (delta.y > 180.0f) delta.y -= 360.0f;
while (delta.y < -180.0f) delta.y += 360.0f;
float current_fov_value = std::hypot(delta.x, delta.y);
if (!std::isfinite(current_fov_value) || current_fov_value > fov)
continue;
float distance = local_origin.distance_to(target_pos);
if (hitbox == static_cast<int>(hitbox_t::NEAREST)) {
if (distance < best_distance && current_fov_value < best_fov_value) {
best_distance = distance;
best_target = pawn;
}
}
else {
if (current_fov_value < best_fov_value) {
best_fov_value = current_fov_value;
best_target = pawn;
}
}
}
return best_target;
}
void aimbot::run(c_user_cmd* cmd) {
if (!enabled || !cmd || !ctx::local_pawn || !interfaces::input)
return;
bool should_aim = false;
if (aimlock_mode == static_cast<int>(aimlock_mode_t::ALWAYS)) {
should_aim = true;
}
else if (aimlock_mode == static_cast<int>(aimlock_mode_t::ON_KEY)) {
should_aim = GetAsyncKeyState(aimlock_key) & 0x8000;
}
else {
should_aim = (cmd->button_states.m_button_state & (1ULL << 0));
}
if (!should_aim)
return;
auto target = get_best_target();
if (!target)
return;
auto local_scene = ctx::local_pawn->m_scene_node();
if (!local_scene)
return;
vec3_t local_origin = local_scene->m_abs_origin();
// Используем collision для безопасного получения eye position
auto local_collision = ctx::local_pawn->m_collision();
if (local_collision) {
local_origin.z += local_collision->m_maxs().z * 0.9f;
}
vec3_t target_pos = get_hitbox_position(target, static_cast<hitbox_t>(hitbox));
vec3_t aim_angle = calculate_angle(local_origin, target_pos);
if (!std::isfinite(aim_angle.x) || !std::isfinite(aim_angle.y))
return;
if (silent) {
if (cmd->user_cmd.has_base()) {
auto base = cmd->user_cmd.mutable_base();
if (base && base->has_viewangles()) {
auto angles = base->mutable_viewangles();
if (angles) {
angles->set_x(aim_angle.x);
angles->set_y(aim_angle.y);
}
}
}
}
else {
auto current_angles = interfaces::input->get_view_angles();
vec3_t delta;
delta.x = aim_angle.x - current_angles.x;
delta.y = aim_angle.y - current_angles.y;
delta.z = 0.0f;
while (delta.y > 180.0f) delta.y -= 360.0f;
while (delta.y < -180.0f) delta.y += 360.0f;
if (!std::isfinite(delta.x) || !std::isfinite(delta.y))
return;
if (smoothness > 0.0f) {
delta.x /= smoothness;
delta.y /= smoothness;
}
vec3_t new_angles;
new_angles.x = current_angles.x + delta.x;
new_angles.y = current_angles.y + delta.y;
new_angles.z = 0.0f;
new_angles.x = std::clamp(new_angles.x, -89.0f, 89.0f);
new_angles.y = std::fmod(new_angles.y + 180.0f, 360.0f) - 180.0f;
if (!std::isfinite(new_angles.x) || !std::isfinite(new_angles.y))
return;
interfaces::input->set_view_angles(new_angles);
}
}
