Wizzard/goldsrc-cheat
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
0b9c7484441d01682ec3b3c364c9514ba3c97423
goldsrc-cheat/src/features/anti_aim.c

309 lines
9.0 KiB
C
Raw Blame History

#include <math.h>
#include <stdlib.h>
#include <time.h>
#include <X11/Xlib.h>
#include <X11/keysym.h>
#include "features.h"
#include "../include/sdk.h"
#include "../include/settings.h"
#include "../include/util.h"
#include "../include/globals.h"
#define AA_PITCH_NONE 0
#define AA_PITCH_DOWN 1
#define AA_PITCH_UP 2
#define AA_PITCH_ZERO 3
#define AA_PITCH_JITTER 4
#define AA_PITCH_CUSTOM 5
#define AA_YAW_NONE 0
#define AA_YAW_BACKWARD 1
#define AA_YAW_SPIN 2
#define AA_YAW_JITTER 3
#define AA_YAW_SIDEWAYS 4
#define AA_YAW_CUSTOM 5
static float spin_angle = 0.0f;
static float last_update_time = 0.0f;
static float jitter_next_update = 0.0f;
float random_float(float min, float max) {
return (max - min) * ((float)rand() / (float)RAND_MAX) + min;
}
bool isSpacebarPressed() {
Display* display = XOpenDisplay(NULL);
if (!display) {
return false;
}
char keys_return[32];
XQueryKeymap(display, keys_return);
KeyCode kc = XKeysymToKeycode(display, XK_space);
bool pressed = (keys_return[kc >> 3] & (1 << (kc & 7))) != 0;
XCloseDisplay(display);
return pressed;
}
bool is_key_pressed(int key_code) {
if (key_code <= 0) {
return false;
}
Display* display = XOpenDisplay(NULL);
if (!display) {
return false;
}
char keys_return[32];
XQueryKeymap(display, keys_return);
KeyCode kc;
if (key_code >= 'A' && key_code <= 'Z') {
kc = XKeysymToKeycode(display, XK_a + (key_code - 'A'));
} else if (key_code >= 'a' && key_code <= 'z') {
kc = XKeysymToKeycode(display, XK_a + (key_code - 'a'));
} else {
switch (key_code) {
case K_SPACE: kc = XKeysymToKeycode(display, XK_space); break;
case K_CTRL: kc = XKeysymToKeycode(display, XK_Control_L); break;
case K_SHIFT: kc = XKeysymToKeycode(display, XK_Shift_L); break;
case K_ALT: kc = XKeysymToKeycode(display, XK_Alt_L); break;
case K_TAB: kc = XKeysymToKeycode(display, XK_Tab); break;
default: kc = XKeysymToKeycode(display, key_code);
}
}
bool pressed = (keys_return[kc >> 3] & (1 << (kc & 7))) != 0;
XCloseDisplay(display);
return pressed;
}
void apply_pitch_anti_aim(vec3_t* view_angles, int pitch_mode, float custom_pitch) {
switch (pitch_mode) {
case AA_PITCH_DOWN:
view_angles->x = 89.0f;
break;
case AA_PITCH_UP:
view_angles->x = -89.0f;
break;
case AA_PITCH_ZERO:
view_angles->x = 0.0f;
break;
case AA_PITCH_JITTER: {
static bool flip_pitch = false;
if (flip_pitch) {
view_angles->x = 89.0f;
} else {
view_angles->x = -89.0f;
}
if (g_flCurrentTime > jitter_next_update) {
flip_pitch = !flip_pitch;
jitter_next_update = g_flCurrentTime + random_float(0.1f, 0.3f);
}
break;
}
case AA_PITCH_CUSTOM:
view_angles->x = CLAMP(custom_pitch, -89.0f, 89.0f);
break;
default:
break;
}
}
void apply_yaw_anti_aim(vec3_t* view_angles, int yaw_mode, float custom_yaw, float speed, float jitter_range) {
float time_now;
float time_delta;
static bool is_left = true;
switch (yaw_mode) {
case AA_YAW_BACKWARD:
view_angles->y += 180.0f;
break;
case AA_YAW_SPIN:
time_now = g_flCurrentTime;
time_delta = time_now - last_update_time;
spin_angle += time_delta * speed;
if (spin_angle > 360.0f) {
spin_angle -= 360.0f;
}
view_angles->y = spin_angle;
last_update_time = time_now;
break;
case AA_YAW_JITTER:
if (g_flCurrentTime > jitter_next_update) {
view_angles->y += random_float(-jitter_range, jitter_range);
jitter_next_update = g_flCurrentTime + random_float(0.1f, 0.3f);
}
break;
case AA_YAW_SIDEWAYS:
if (g_flCurrentTime > jitter_next_update) {
is_left = !is_left;
jitter_next_update = g_flCurrentTime + random_float(0.5f, 1.5f);
}
if (is_left) {
view_angles->y += 90.0f;
} else {
view_angles->y -= 90.0f;
}
break;
case AA_YAW_CUSTOM:
view_angles->y = custom_yaw;
break;
default:
break;
}
}
void apply_lby_breaker(vec3_t* view_angles, bool enable_breaker) {
if (!enable_breaker)
return;
static bool lby_update = false;
static float next_lby_update = 0.0f;
if (g_flCurrentTime > next_lby_update) {
lby_update = !lby_update;
next_lby_update = g_flCurrentTime + 1.1f;
if (lby_update) {
view_angles->y += 120.0f;
}
}
}
void apply_fake_duck(usercmd_t* cmd, bool enable_duck) {
if (!enable_duck)
return;
static int duck_state = 0;
static float next_duck_time = 0.0f;
if (g_flCurrentTime > next_duck_time) {
duck_state = (duck_state + 1) % 4;
next_duck_time = g_flCurrentTime + 0.05f;
}
if (duck_state < 2) {
cmd->buttons |= IN_DUCK;
} else {
cmd->buttons &= ~IN_DUCK;
}
}
void anti_aim(usercmd_t* cmd) {
if (!g_settings.antiaim_enabled) {
return;
}
if (!is_alive(localplayer)) {
return;
}
if ((cmd->buttons & IN_ATTACK) && !g_settings.antiaim_on_attack) {
return;
}
if (cmd->buttons & IN_USE) {
return;
}
vec3_t view_angles;
i_engine->GetViewAngles(view_angles);
if (g_settings.antiaim_pitch_enabled) {
if (g_settings.antiaim_pitch_mode == 0) {
view_angles.x = g_settings.antiaim_pitch;
view_angles.x = CLAMP(view_angles.x, -89.0f, 89.0f);
} else {
apply_pitch_anti_aim(&view_angles, g_settings.antiaim_pitch_mode, g_settings.antiaim_custom_pitch);
}
static float last_debug_time = 0.0f;
if (g_flCurrentTime > last_debug_time + 5.0f) {
i_engine->Con_Printf("Anti-Aim: Applied pitch angle %.1f (mode %d)\n",
view_angles.x, g_settings.antiaim_pitch_mode);
last_debug_time = g_flCurrentTime;
}
}
if (g_settings.antiaim_yaw_enabled) {
if (g_settings.antiaim_yaw_mode == 0) {
if (g_settings.antiaim_legit) {
float legit_yaw_max = 35.0f;
view_angles.y += CLAMP(g_settings.antiaim_yaw, -legit_yaw_max, legit_yaw_max);
} else {
view_angles.y += g_settings.antiaim_yaw;
}
} else {
apply_yaw_anti_aim(&view_angles, g_settings.antiaim_yaw_mode, g_settings.antiaim_custom_yaw,
g_settings.antiaim_spin_speed, g_settings.antiaim_jitter_range);
}
if (view_angles.y > 180.0f) view_angles.y -= 360.0f;
if (view_angles.y < -180.0f) view_angles.y += 360.0f;
}
apply_lby_breaker(&view_angles, g_settings.antiaim_lby_breaker);
if (g_settings.antiaim_desync) {
static bool switch_side = false;
static float next_switch = 0.0f;
if (g_flCurrentTime > next_switch) {
switch_side = !switch_side;
next_switch = g_flCurrentTime + random_float(0.4f, 0.8f);
}
float desync_amount = switch_side ? 58.0f : -58.0f;
static vec3_t real_angles;
vec_copy(real_angles, view_angles);
view_angles.y += desync_amount;
if (view_angles.y > 180.0f) view_angles.y -= 360.0f;
if (view_angles.y < -180.0f) view_angles.y += 360.0f;
if (!g_settings.antiaim_view) {
vec_copy(cmd->viewangles, view_angles);
i_engine->SetViewAngles(real_angles);
return;
}
}
bool should_fake_duck = false;
if (g_settings.antiaim_fakeduck_key > 0) {
should_fake_duck = g_settings.antiaim_fakeduck && is_key_pressed(g_settings.antiaim_fakeduck_key);
} else {
should_fake_duck = g_settings.antiaim_fakeduck;
}
if (should_fake_duck) {
apply_fake_duck(cmd, true);
}
if (g_settings.antiaim_view) {
i_engine->SetViewAngles(view_angles);
} else {
vec_copy(cmd->viewangles, view_angles);
}
static float last_log_time = 0.0f;
if (g_flCurrentTime > last_log_time + 5.0f) {
i_engine->Con_Printf("Anti-Aim active: Pitch=%.1f, Yaw=%.1f, Mode=%d/%d\n",
view_angles.x, view_angles.y,
g_settings.antiaim_pitch_mode, g_settings.antiaim_yaw_mode);
last_log_time = g_flCurrentTime;
}
}
Reference in New Issue View Git Blame Copy Permalink