path: root/src/hl2h.h

#ifndef HL2H_H
#define HL2H_H

#include <cstdint>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>

#include <dlfcn.h>
#include <pthread.h>
#include <unistd.h>

// Shared float-precision constant. More digits than a float can hold are
// rounded at compile time and have no runtime cost; a coarse value would only
// hurt angular accuracy, never performance.
constexpr float PI_F = 3.14159265f;

// ---------------------------------------------------------------------------
// logging
// ---------------------------------------------------------------------------

void logf(const char *fmt, ...);

// ---------------------------------------------------------------------------
// module discovery
// ---------------------------------------------------------------------------

struct Module {
  struct Range {
    uintptr_t lo, hi;
    bool file;
  };
  std::vector<Range> ranges;
  std::string path;
  bool valid() const { return !ranges.empty(); }
  bool contains(uintptr_t p) const {
    for (auto &r : ranges)
      if (p >= r.lo && p < r.hi)
        return true;
    return false;
  }
};
extern Module g_client, g_engine, g_server;

// ---------------------------------------------------------------------------
// game interfaces
// ---------------------------------------------------------------------------

using CreateInterfaceFn = void *(*)(const char *, int *);

struct GameInterfaces {
  void *client = nullptr;
  void *entitylist = nullptr;
  void *engine = nullptr;
  void *modelinfo = nullptr;    // IVModelInfoClient006 (model index -> model name)
  void *engineserver = nullptr; // IVEngineServer021 (edict access, incl. server entities)
  void *debugoverlay = nullptr; // IVDebugOverlay003 (engine-accurate world->screen)
  void *enginetrace = nullptr;  // EngineTraceClient003 (world vischeck)
};
extern GameInterfaces g_iface;

#define VTABLE(obj) (*(void ***)(obj))
template <typename Fn> inline Fn vfunc(void *obj, size_t idx) {
  return reinterpret_cast<Fn>(VTABLE(obj)[idx]);
}

// ---------------------------------------------------------------------------
// netvars
// ---------------------------------------------------------------------------
struct NetVars {
  int flags = -1;
  int velocity = -1;
  int movetype = -1;
  int health = -1;
  int maxhealth = -1;
  int teamnum = -1;
  int origin = -1;
  int viewoffset = -1;
  int mins = -1;
  int maxs = -1;
  int lifestate = -1;
  int modelindex = -1;
  int absvelocity = -1; // client C_BaseEntity::m_vecAbsVelocity (prediction)
  int activeweapon = -1; // client m_hActiveWeapon handle
  // ponytail: mins/maxs may be absent from some HL2 netvar tables; esp.cpp falls back to h=72
  bool ok() const { return flags >= 0 && velocity >= 0 && movetype >= 0; }
  // ponytail: m_iMaxHealth isn't a netvar in HL2 SP; esp.cpp falls back to 100.
  // m_iHealth only ever updates for players — NPCs are detected via m_lifeState.
  bool esp_ok() const { return ok() && health >= 0 && teamnum >= 0 && origin >= 0 && viewoffset >= 0; }
};
extern NetVars g_net;

// ---------------------------------------------------------------------------
// CInput
// ---------------------------------------------------------------------------

extern uintptr_t g_input;

// ---------------------------------------------------------------------------
// console output
// ---------------------------------------------------------------------------

extern void (*g_conmsg)(const char *, ...);

// ---------------------------------------------------------------------------
// CUserCmd
// ---------------------------------------------------------------------------

struct CUserCmd {
  void *vtable;
  int command_number;
  int tick_count;
  float viewangles[3];
  float forwardmove;
  float sidemove;
  float upmove;
  int buttons;
  uint8_t impulse;
  int weaponselect;
  int weaponsubtype;
  int random_seed;
  short mousedx;
  short mousedy;
  bool hasbeenpredicted;
};

// ---------------------------------------------------------------------------
// engine constants
// ---------------------------------------------------------------------------

enum { IN_ATTACK = 1 << 0, IN_JUMP = 1 << 1, IN_DUCK = 1 << 2, IN_USE = 1 << 5, IN_ATTACK2 = 1 << 11 };
enum { FL_ONGROUND = 1 << 0, FL_DUCKING = 1 << 1, FL_INWATER = 1 << 9 };
enum { MOVETYPE_WALK = 2, MOVETYPE_NOCLIP = 8, MOVETYPE_LADDER = 9 };

// ---------------------------------------------------------------------------
// vector math
// ---------------------------------------------------------------------------

struct Vector { float x, y, z; };
struct QAngle { float x, y, z; };
// camera state captured each CreateMove (used by ESP / future aimbot)
extern Vector g_cam_eye;
extern Vector g_cam_view;
QAngle vector_angles(const Vector &forward);
Vector angle_forward_vector(const QAngle &angles);
float getfov(const QAngle &my_view, const QAngle &aim_ang);
bool aimbot_apply(CUserCmd *cmd);
bool triggerbot_apply(CUserCmd *cmd);
bool silent_aim_apply(CUserCmd *cmd);
bool melee_weapon_active(void *local_ent);
bool melee_aimbot_apply(CUserCmd *cmd);
bool spread_control_apply(CUserCmd *cmd, void *local_ent);
int spread_best_seed(int pellets);
extern int g_spread_pellets;
enum FeatureId {
  FEAT_BHOP = 0,
  FEAT_ABH = 1,
  FEAT_ESP = 2,
  FEAT_AIMBOT = 3,
  FEAT_TRIGGERBOT = 4,
  FEAT_SILENTAIM = 5,
  FEAT_JUMPBUG = 6,
  FEAT_MELEE = 7,
  FEAT_SPREAD = 8
};
enum EspOption {
  ESP_OPT_SHOW_NEUTRAL = 0,
  ESP_OPT_SHOW_HEALTHBAR = 1,
  ESP_OPT_SHOW_HEALTHNUM = 2,
  ESP_OPT_SHOW_NAME = 3,
  ESP_OPT_SHOW_SKELETON = 4,
  ESP_OPT_SHOW_BOX = 5,
  ESP_OPT_SHOW_SPEEDGRAPH = 6,
  ESP_OPT_COUNT = 7
};

// ---------------------------------------------------------------------------
// cross-file declarations
// ---------------------------------------------------------------------------
void note_modified(const CUserCmd *cmd, int flags, const float *vel);
CUserCmd *get_usercmd(int seq);
void fix_verified_crc(int seq, uint32_t crc);
uint32_t usercmd_checksum(const CUserCmd *c);
bool find_input_global();
void resolve_netvars();
bool resolve_server_netvars();
int server_entity_health(int idx, int *maxhealth, int *lifestate, void **base_out);
bool server_set_velocity_z(int idx, float vz);
int server_active_weapon(int idx);
int server_model_index(void *base);
void find_modules();
void init_conmsg();
bool feature_active(int feature);
bool feature_has_bind(int feature);
bool feature_bind_held(int feature);
bool esp_option(int opt);
bool bhop_autostrafe_enabled();
bool jumpbug_assist_enabled();
bool spread_no_spread_enabled();
unsigned aimbot_bone_mask();
int aimbot_smooth_step();
bool aimbot_vischeck_enabled();
int aimbot_fov();
int silentaim_fov();
bool aimbot_fov_circle();
void aimbot_reset_lock();
void silentaim_reset_lock();
void *entitylist_get(int idx);
int engine_get_local_player();
void draw_text_col(int x, int y, const char *s, int r, int g, int b);
void esp_draw();
bool world_to_screen(const Vector &w, float &sx, float &sy);
void set_silent_restore(const QAngle &angles);
bool is_visible(const Vector &eye, const Vector &point);
void *trace_entity(const Vector &start, const Vector &end, void *ignore);
float ground_distance(const Vector &origin, void *ignore, float max_dist);

// bones.cpp — client-side animated skeleton / hitbox access (see there)
bool bones_update(int idx, void *ent);
int bones_count(int idx);
int bone_find(int idx, const char *name);
int bone_parent(int idx, int bone);
bool bone_pos(int idx, int bone, Vector &out);
bool bone_is_skeleton_core(int idx, int bone);
int bone_nearest_core_parent(int idx, int bone);
bool bones_is_humanoid(int idx);
bool hitbox_center(int idx, const char *hitbox_name, Vector &out);
bool head_position(int idx, Vector &out);
int aim_points(int idx, unsigned group_mask, Vector *out, int max);

void outer_draw();
// ISurface pointer (defined in menu.cpp, used for drawing tests)
struct ISurface;
extern ISurface *g_surface;
#endif