Headers: split the shared header by declaration group

hl2h.h becomes an umbrella over core.h (logging, init stage, module snapshots,
interfaces, netvars, CUserCmd, engine constants, vector math), settings.h
(feature ids, feature state, user settings) and features.h (cross-module
declarations). Translation units keep including hl2h.h, so this only moves
declarations.

1 files changed, 205 insertions, 0 deletions

diff --git a/src/core.h b/src/core.h
new file mode 100644
index 0000000..320b62b
--- /dev/null
+++ b/src/core.h
@@ -0,0 +1,205 @@
+#ifndef HL2H_CORE_H
+#define HL2H_CORE_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, ...);
+void logd(const char *fmt, ...); // debug-only (HL2H_DEBUG=1)
+
+// ---------------------------------------------------------------------------
+// init readiness
+// ---------------------------------------------------------------------------
+//
+// setup_thread runs detached while the game threads are already live, and some
+// hooks are installed lazily from the game thread. Hooks therefore always stay
+// installed but pass straight through to the original until setup reaches
+// INIT_LIVE, so the game can never observe half-initialised state. INIT_FAILED
+// is terminal: the cheat stays inert instead of half-working.
+enum {
+  INIT_FAILED = -1,
+  INIT_NONE = 0,
+  INIT_INTERFACES = 1, // modules + interfaces + netvars resolved
+  INIT_READY = 2,      // config loaded, ISurface/fonts resolved
+  INIT_LIVE = 3        // hooks may run their bodies
+};
+void init_set_stage(int stage);
+int init_stage(); // acquire load
+inline bool init_live() { return init_stage() == INIT_LIVE; }
+
+// Clone a vtable into a new array, preserving the Itanium ABI header at
+// [-2]/[-1] (offset-to-top and typeinfo) so RTTI on the hooked object still
+// works. Returns the slot-0 pointer to install (i.e. the clone + 2).
+void **vtable_clone(void *iface, size_t slots);
+
+// ---------------------------------------------------------------------------
+// on-screen toasts
+// ---------------------------------------------------------------------------
+
+enum ToastLevel { TOAST_INFO = 0, TOAST_WARN, TOAST_ERROR };
+void toastf(int level, const char *fmt, ...);
+bool gui_toasts_active();
+void gui_draw_toasts();
+
+// ---------------------------------------------------------------------------
+// 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;
+  }
+};
+// Immutable module snapshots. A reader gets a reference that stays valid for
+// the whole process: find_modules() publishes a new snapshot instead of
+// mutating the old one, and retired snapshots are intentionally never freed, so
+// a concurrent refresh can never invalidate a reference already in use.
+const Module &mod_client();
+const Module &mod_engine();
+const Module &mod_server();
+
+// True only when the whole byte range [p, p+n) lies inside one known module
+// range. Use before dereferencing pointers read out of engine memory.
+bool module_range(uintptr_t p, size_t n);
+
+// ---------------------------------------------------------------------------
+// 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)
+  void *cvar = nullptr;         // VEngineCvar004 (mat_fullbright etc.)
+  void *modelrender = nullptr;  // VEngineModel016 (chams)
+  void *renderview = nullptr;   // VEngineRenderView014 (alpha/color modulation)
+};
+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
+  int owner = -1;        // client m_hOwnerEntity handle
+  int weapon_owner = -1; // client m_hOwner handle (C_BaseCombatWeapon)
+  int clr_render = -1;   // client m_clrRender (entity render colour)
+  int punch = -1;        // client m_vecPunchAngle (aim punch)
+  int default_fov = -1;  // client m_iDefaultFOV (camera fov)
+  int dmg_radius = -1;   // client C_BaseGrenade::m_DmgRadius
+  int my_weapons = -1;   // client m_hMyWeapons[48] array base
+  int ammo = -1;         // client m_iAmmo[] array base
+  // 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, IN_SPEED = 1 << 17 };
+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);
+
+#endif