1859 lines
35 KiB
C++
1859 lines
35 KiB
C++
#pragma once
|
|
|
|
#pragma warning(push)
|
|
#pragma warning(disable : 4324)
|
|
|
|
namespace game {
|
|
typedef float vec_t;
|
|
typedef vec_t vec2_t[2];
|
|
typedef vec_t vec3_t[3];
|
|
typedef vec_t vec4_t[4];
|
|
|
|
enum LocalClientNum_t {
|
|
LOCAL_CLIENT_0 = 0,
|
|
LOCAL_CLIENT_LAST = 1,
|
|
LOCAL_CLIENT_COUNT = 1,
|
|
};
|
|
|
|
enum ControllerIndex_t {
|
|
INVALID_CONTROLLER_PORT = -1,
|
|
CONTROLLER_INDEX_0 = 0x0,
|
|
CONTROLLER_INDEX_FIRST = 0x0,
|
|
CONTROLLER_INDEX_COUNT = 0x1,
|
|
};
|
|
|
|
struct scr_entref_t {
|
|
unsigned __int16 entnum;
|
|
unsigned __int16 classnum;
|
|
};
|
|
|
|
typedef void (*BuiltinMethod)(scr_entref_t);
|
|
|
|
typedef void (*BuiltinFunction)();
|
|
|
|
struct BuiltinMethodDef {
|
|
const char* actionString;
|
|
void (*actionFunc)(scr_entref_t);
|
|
int type;
|
|
};
|
|
|
|
struct BuiltinFunctionDef {
|
|
const char* actionString;
|
|
void (*actionFunc)();
|
|
int type;
|
|
};
|
|
|
|
struct OpcodeLookup {
|
|
const char* codePos;
|
|
unsigned int sourcePosIndex;
|
|
unsigned __int16 sourcePosCount;
|
|
unsigned __int16 cumulOffset;
|
|
unsigned __int16* localVars;
|
|
int profileTime;
|
|
int profileBuiltInTime;
|
|
int profileUsage;
|
|
};
|
|
|
|
static_assert(sizeof(OpcodeLookup) == 0x1C);
|
|
|
|
struct SourceLookup {
|
|
unsigned int sourcePos;
|
|
int type;
|
|
};
|
|
|
|
struct SaveSourceBufferInfo {
|
|
char* buf;
|
|
char* sourceBuf;
|
|
int len;
|
|
};
|
|
|
|
struct scrParserGlob_t {
|
|
OpcodeLookup* opcodeLookup;
|
|
unsigned int opcodeLookupMaxSize;
|
|
unsigned int opcodeLookupLen;
|
|
SourceLookup* sourcePosLookup;
|
|
unsigned int sourcePosLookupMaxSize;
|
|
unsigned int sourcePosLookupLen;
|
|
unsigned int sourceBufferLookupMaxSize;
|
|
const char* currentCodePos;
|
|
unsigned int currentSourcePosCount;
|
|
SaveSourceBufferInfo* saveSourceBufferLookup;
|
|
unsigned int saveSourceBufferLookupLen;
|
|
int delayedSourceIndex;
|
|
int threadStartSourceIndex;
|
|
};
|
|
|
|
static_assert(sizeof(scrParserGlob_t) == 0x34);
|
|
|
|
struct SourceBufferInfo {
|
|
const char* codePos;
|
|
char* buf;
|
|
const char* sourceBuf;
|
|
int len;
|
|
int sortedIndex;
|
|
bool archive;
|
|
int time;
|
|
int avgTime;
|
|
int maxTime;
|
|
float totalTime;
|
|
float totalBuiltIn;
|
|
};
|
|
|
|
struct CodeOffsetMap {
|
|
int type;
|
|
unsigned int cumulOffset;
|
|
int codeOffset;
|
|
int sourcePos;
|
|
int newCodeOffest;
|
|
};
|
|
|
|
struct scrParserPub_t {
|
|
SourceBufferInfo* sourceBufferLookup;
|
|
unsigned int sourceBufferLookupLen;
|
|
const char* scriptfilename;
|
|
const char* sourceBuf;
|
|
CodeOffsetMap* codeOffsetMap;
|
|
unsigned int codeOffsetMapLen;
|
|
int useCodeOffsetMap;
|
|
};
|
|
|
|
static_assert(sizeof(scrParserPub_t) == 0x1C);
|
|
|
|
struct VariableStackBuffer {
|
|
const char* pos;
|
|
unsigned __int16 size;
|
|
unsigned __int16 bufLen;
|
|
unsigned __int16 localId;
|
|
unsigned __int8 time;
|
|
char buf[1];
|
|
};
|
|
|
|
union VariableUnion {
|
|
int intValue;
|
|
float floatValue;
|
|
unsigned int stringValue;
|
|
const float* vectorValue;
|
|
const char* codePosValue;
|
|
unsigned int pointerValue;
|
|
VariableStackBuffer* stackValue;
|
|
unsigned int entityOffset;
|
|
};
|
|
|
|
struct VariableValue {
|
|
VariableUnion u;
|
|
int type;
|
|
};
|
|
|
|
struct function_stack_t {
|
|
const char* pos;
|
|
unsigned int localId;
|
|
unsigned int localVarCount;
|
|
VariableValue* top;
|
|
VariableValue* startTop;
|
|
};
|
|
|
|
struct function_frame_t {
|
|
function_stack_t fs;
|
|
int topType;
|
|
};
|
|
|
|
struct scrVmPub_t {
|
|
unsigned int* localVars;
|
|
VariableValue* maxstack;
|
|
int function_count;
|
|
function_frame_t* function_frame;
|
|
VariableValue* top;
|
|
bool debugCode;
|
|
bool abort_on_error;
|
|
bool terminal_error;
|
|
unsigned int inparamcount;
|
|
unsigned int outparamcount;
|
|
function_frame_t function_frame_start[32];
|
|
VariableValue stack[2048];
|
|
};
|
|
|
|
struct HunkUser {
|
|
HunkUser* current;
|
|
HunkUser* next;
|
|
int maxSize;
|
|
int end;
|
|
int pos;
|
|
const char* name;
|
|
bool fixed;
|
|
int type;
|
|
unsigned __int8 buf[1];
|
|
};
|
|
|
|
static_assert(sizeof(HunkUser) == 0x24);
|
|
|
|
struct scrVarPub_t {
|
|
const char* fieldBuffer;
|
|
unsigned __int16 canonicalStrCount;
|
|
bool developer_script;
|
|
bool evaluate;
|
|
const char* error_message;
|
|
int error_index;
|
|
unsigned int time;
|
|
unsigned int timeArrayId;
|
|
unsigned int pauseArrayId;
|
|
unsigned int notifyArrayId;
|
|
unsigned int objectStackId;
|
|
unsigned int levelId;
|
|
unsigned int gameId;
|
|
unsigned int animId;
|
|
unsigned int freeEntList;
|
|
unsigned int tempVariable;
|
|
unsigned int numScriptValues[2];
|
|
bool bInited;
|
|
unsigned __int16 savecount;
|
|
unsigned __int16 savecountMark;
|
|
unsigned int checksum;
|
|
unsigned int entId;
|
|
unsigned int entFieldName;
|
|
HunkUser* programHunkUser;
|
|
const char* programBuffer;
|
|
const char* endScriptBuffer;
|
|
unsigned __int16 saveIdMap[36864];
|
|
unsigned __int16 saveIdMapRev[36864];
|
|
bool bScriptProfile;
|
|
float scriptProfileMinTime;
|
|
bool bScriptProfileBuiltin;
|
|
float scriptProfileBuiltinMinTime;
|
|
unsigned int numScriptThreads;
|
|
unsigned int numScriptObjects;
|
|
const char* varUsagePos;
|
|
int ext_threadcount;
|
|
int totalObjectRefCount;
|
|
volatile int totalVectorRefCount;
|
|
unsigned int removeId;
|
|
};
|
|
|
|
static_assert(sizeof(scrVarPub_t) == 0x2408C);
|
|
|
|
struct scr_localVar_t {
|
|
unsigned int name;
|
|
unsigned int sourcePos;
|
|
};
|
|
|
|
struct scr_block_t {
|
|
int abortLevel;
|
|
int localVarsCreateCount;
|
|
int localVarsPublicCount;
|
|
int localVarsCount;
|
|
unsigned __int8 localVarsInitBits[8];
|
|
scr_localVar_t localVars[64];
|
|
};
|
|
|
|
struct scrCompilePub_t {
|
|
int value_count;
|
|
int far_function_count;
|
|
unsigned int loadedscripts;
|
|
unsigned int scriptsPos;
|
|
unsigned int scriptsCount;
|
|
unsigned int scriptsDefine;
|
|
unsigned int builtinFunc;
|
|
unsigned int builtinMeth;
|
|
unsigned __int16 canonicalStrings[65536];
|
|
const char* in_ptr;
|
|
bool in_ptr_valid;
|
|
const char* parseBuf;
|
|
bool script_loading;
|
|
bool allowedBreakpoint;
|
|
int developer_statement;
|
|
char* opcodePos;
|
|
unsigned int programLen;
|
|
int func_table_size;
|
|
int func_table[1024];
|
|
scr_block_t* pauseBlock;
|
|
};
|
|
|
|
struct CaseStatementInfo {
|
|
unsigned int name;
|
|
const char* codePos;
|
|
unsigned int sourcePos;
|
|
CaseStatementInfo* next;
|
|
};
|
|
|
|
struct BreakStatementInfo {
|
|
const char* codePos;
|
|
const char* nextCodePos;
|
|
BreakStatementInfo* next;
|
|
};
|
|
|
|
struct ContinueStatementInfo {
|
|
const char* codePos;
|
|
const char* nextCodePos;
|
|
ContinueStatementInfo* next;
|
|
};
|
|
|
|
struct PrecacheEntry {
|
|
unsigned __int16 filename;
|
|
bool include;
|
|
unsigned int sourcePos;
|
|
};
|
|
|
|
union sval_u {
|
|
int type;
|
|
unsigned int stringValue;
|
|
unsigned int idValue;
|
|
float floatValue;
|
|
int intValue;
|
|
sval_u* node;
|
|
unsigned int sourcePosValue;
|
|
const char* codePosValue;
|
|
const char* debugString;
|
|
scr_block_t* block;
|
|
};
|
|
|
|
struct VariableCompileValue {
|
|
VariableValue value;
|
|
sval_u sourcePos;
|
|
};
|
|
|
|
struct scrCompileGlob_t {
|
|
unsigned char* codePos;
|
|
unsigned char* prevOpcodePos;
|
|
unsigned int filePosId;
|
|
unsigned int fileCountId;
|
|
int cumulOffset;
|
|
int prevCumulOffset;
|
|
int maxOffset;
|
|
int maxCallOffset;
|
|
bool bConstRefCount;
|
|
bool in_developer_thread;
|
|
unsigned int developer_thread_sourcePos;
|
|
bool firstThread[2];
|
|
CaseStatementInfo* currentCaseStatement;
|
|
bool bCanBreak;
|
|
BreakStatementInfo* currentBreakStatement;
|
|
bool bCanContinue;
|
|
ContinueStatementInfo* currentContinueStatement;
|
|
scr_block_t** breakChildBlocks;
|
|
int* breakChildCount;
|
|
scr_block_t* breakBlock;
|
|
scr_block_t** continueChildBlocks;
|
|
int* continueChildCount;
|
|
bool forceNotCreate;
|
|
PrecacheEntry* precachescriptList;
|
|
VariableCompileValue value_start[32];
|
|
};
|
|
|
|
struct scr_animtree_t {
|
|
void* anims;
|
|
};
|
|
|
|
struct scrAnimPub_t {
|
|
unsigned int animtrees;
|
|
unsigned int animtree_node;
|
|
unsigned int animTreeNames;
|
|
scr_animtree_t xanim_lookup[2][128];
|
|
unsigned int xanim_num[2];
|
|
unsigned int animTreeIndex;
|
|
bool animtree_loading;
|
|
};
|
|
|
|
enum {
|
|
SOURCE_TYPE_BREAKPOINT = 0x1,
|
|
SOURCE_TYPE_CALL = 0x2,
|
|
SOURCE_TYPE_CALL_POINTER = 0x4,
|
|
SOURCE_TYPE_THREAD_START = 0x8,
|
|
SOURCE_TYPE_BUILTIN_CALL = 0x10,
|
|
SOURCE_TYPE_NOTIFY = 0x20,
|
|
SOURCE_TYPE_GETFUNCTION = 0x40,
|
|
SOURCE_TYPE_WAIT = 0x80,
|
|
};
|
|
|
|
enum {
|
|
VAR_STRING = 0x2,
|
|
VAR_FLOAT = 0x5,
|
|
VAR_INTEGER = 0x6,
|
|
};
|
|
|
|
enum msgLocErrType_t {
|
|
LOCMSG_SAFE = 0x0,
|
|
LOCMSG_NOERR = 0x1,
|
|
};
|
|
|
|
enum {
|
|
CON_CHANNEL_DONT_FILTER = 0x0,
|
|
CON_CHANNEL_ERROR = 0x1,
|
|
CON_CHANNEL_GAMENOTIFY = 0x2,
|
|
CON_CHANNEL_BOLDGAME = 0x3,
|
|
CON_CHANNEL_SUBTITLE = 0x4,
|
|
CON_CHANNEL_OBITUARY = 0x5,
|
|
CON_CHANNEL_LOGFILEONLY = 0x6,
|
|
CON_CHANNEL_CONSOLEONLY = 0x7,
|
|
CON_CHANNEL_GFX = 0x8,
|
|
CON_CHANNEL_SOUND = 0x9,
|
|
CON_CHANNEL_FILES = 0xA,
|
|
CON_CHANNEL_DEVGUI = 0xB,
|
|
CON_CHANNEL_PROFILE = 0xC,
|
|
CON_CHANNEL_UI = 0xD,
|
|
CON_CHANNEL_CLIENT = 0xE,
|
|
CON_CHANNEL_SERVER = 0xF,
|
|
CON_CHANNEL_SYSTEM = 0x10,
|
|
CON_CHANNEL_PLAYERWEAP = 0x11,
|
|
CON_CHANNEL_AI = 0x12,
|
|
CON_CHANNEL_ANIM = 0x13,
|
|
CON_CHANNEL_PHYS = 0x14,
|
|
CON_CHANNEL_FX = 0x15,
|
|
CON_CHANNEL_LEADERBOARDS = 0x16,
|
|
CON_CHANNEL_PARSERSCRIPT = 0x17,
|
|
CON_CHANNEL_SCRIPT = 0x18,
|
|
CON_CHANNEL_NETWORK = 0x19,
|
|
|
|
CON_BUILTIN_CHANNEL_COUNT = 0x1A,
|
|
};
|
|
|
|
enum XAssetType {
|
|
ASSET_TYPE_PHYSPRESET = 0,
|
|
ASSET_TYPE_PHYSCOLLMAP = 1,
|
|
ASSET_TYPE_XANIMPARTS = 2,
|
|
ASSET_TYPE_XMODEL_SURFS = 3,
|
|
ASSET_TYPE_XMODEL = 4,
|
|
ASSET_TYPE_MATERIAL = 5,
|
|
ASSET_TYPE_PIXELSHADER = 6,
|
|
ASSET_TYPE_VERTEXSHADER = 7,
|
|
ASSET_TYPE_VERTEXDECL = 8,
|
|
ASSET_TYPE_TECHNIQUE_SET = 9,
|
|
ASSET_TYPE_IMAGE = 10,
|
|
ASSET_TYPE_SOUND = 11,
|
|
ASSET_TYPE_SOUND_CURVE = 12,
|
|
ASSET_TYPE_LOADED_SOUND = 13,
|
|
ASSET_TYPE_CLIPMAP_SP = 14,
|
|
ASSET_TYPE_CLIPMAP_MP = 15,
|
|
ASSET_TYPE_COMWORLD = 16,
|
|
ASSET_TYPE_GAMEWORLD_SP = 17,
|
|
ASSET_TYPE_GAMEWORLD_MP = 18,
|
|
ASSET_TYPE_MAP_ENTS = 19,
|
|
ASSET_TYPE_FXWORLD = 20,
|
|
ASSET_TYPE_GFXWORLD = 21,
|
|
ASSET_TYPE_LIGHT_DEF = 22,
|
|
ASSET_TYPE_UI_MAP = 23,
|
|
ASSET_TYPE_FONT = 24,
|
|
ASSET_TYPE_MENULIST = 25,
|
|
ASSET_TYPE_MENU = 26,
|
|
ASSET_TYPE_LOCALIZE_ENTRY = 27,
|
|
ASSET_TYPE_WEAPON = 28,
|
|
ASSET_TYPE_SNDDRIVER_GLOBALS = 29,
|
|
ASSET_TYPE_FX = 30,
|
|
ASSET_TYPE_IMPACT_FX = 31,
|
|
ASSET_TYPE_AITYPE = 32,
|
|
ASSET_TYPE_MPTYPE = 33,
|
|
ASSET_TYPE_CHARACTER = 34,
|
|
ASSET_TYPE_XMODELALIAS = 35,
|
|
ASSET_TYPE_RAWFILE = 36,
|
|
ASSET_TYPE_STRINGTABLE = 37,
|
|
ASSET_TYPE_LEADERBOARD = 38,
|
|
ASSET_TYPE_STRUCTURED_DATA_DEF = 39,
|
|
ASSET_TYPE_TRACER = 40,
|
|
ASSET_TYPE_VEHICLE = 41,
|
|
ASSET_TYPE_ADDON_MAP_ENTS = 42,
|
|
|
|
ASSET_TYPE_COUNT = 43,
|
|
};
|
|
|
|
enum FsThread {
|
|
FS_THREAD_MAIN = 0x0,
|
|
FS_THREAD_STREAM = 0x1,
|
|
FS_THREAD_DATABASE = 0x2,
|
|
FS_THREAD_BACKEND = 0x3,
|
|
FS_THREAD_SERVER = 0x4,
|
|
FS_THREAD_COUNT = 0x5,
|
|
FS_THREAD_INVALID = 0x6,
|
|
};
|
|
|
|
enum FsListBehavior_e {
|
|
FS_LIST_PURE_ONLY = 0x0,
|
|
FS_LIST_ALL = 0x1,
|
|
};
|
|
|
|
enum fsMode_t {
|
|
FS_READ = 0x0,
|
|
FS_WRITE = 0x1,
|
|
FS_APPEND = 0x2,
|
|
FS_APPEND_SYNC = 0x3,
|
|
};
|
|
|
|
struct token_s {
|
|
char string[1024];
|
|
int type;
|
|
int subtype;
|
|
unsigned int intvalue;
|
|
long double floatvalue;
|
|
char* whitespace_p;
|
|
char* endwhitespace_p;
|
|
int line;
|
|
int linescrossed;
|
|
token_s* next;
|
|
};
|
|
|
|
static_assert(sizeof(token_s) == 0x430);
|
|
|
|
struct define_s {
|
|
char* name;
|
|
int flags;
|
|
int builtin;
|
|
int numparms;
|
|
token_s* parms;
|
|
token_s* tokens;
|
|
define_s* next;
|
|
define_s* hashnext;
|
|
};
|
|
|
|
struct punctuation_s {
|
|
const char* p;
|
|
int n;
|
|
punctuation_s* next;
|
|
};
|
|
|
|
struct script_s {
|
|
char filename[64];
|
|
char* buffer;
|
|
char* script_p;
|
|
char* end_p;
|
|
char* lastscript_p;
|
|
char* whitespace_p;
|
|
char* endwhitespace_p;
|
|
int length;
|
|
int line;
|
|
int lastline;
|
|
int tokenavailable;
|
|
int flags;
|
|
punctuation_s* punctuations;
|
|
punctuation_s** punctuationtable;
|
|
token_s token;
|
|
script_s* next;
|
|
};
|
|
|
|
enum parseSkip_t {
|
|
SKIP_NO = 0x0,
|
|
SKIP_YES = 0x1,
|
|
SKIP_ALL_ELIFS = 0x2,
|
|
};
|
|
|
|
struct indent_s {
|
|
int type;
|
|
parseSkip_t skip;
|
|
script_s* script;
|
|
indent_s* next;
|
|
};
|
|
|
|
struct source_s {
|
|
char filename[64];
|
|
char includepath[64];
|
|
punctuation_s* punctuations;
|
|
script_s* scriptstack;
|
|
token_s* tokens;
|
|
define_s* defines;
|
|
define_s** definehash;
|
|
indent_s* indentstack;
|
|
int skip;
|
|
token_s token;
|
|
};
|
|
|
|
struct pc_token_s {
|
|
int type;
|
|
int subtype;
|
|
int intvalue;
|
|
float floatvalue;
|
|
char string[1024];
|
|
};
|
|
|
|
struct cmd_function_s {
|
|
cmd_function_s* next;
|
|
const char* name;
|
|
const char* autoCompleteDir;
|
|
const char* autoCompleteExt;
|
|
void(__cdecl* function)();
|
|
int flags;
|
|
};
|
|
|
|
struct CmdArgs {
|
|
int nesting;
|
|
int localClientNum[8];
|
|
int controllerIndex[8];
|
|
int argc[8];
|
|
const char** argv[8];
|
|
};
|
|
|
|
struct msg_t {
|
|
int overflowed;
|
|
int readOnly;
|
|
unsigned char* data;
|
|
unsigned char* splitData;
|
|
int maxsize;
|
|
int cursize;
|
|
int splitSize;
|
|
int readcount;
|
|
int bit;
|
|
int lastEntityRef;
|
|
};
|
|
|
|
static_assert(sizeof(msg_t) == 0x28);
|
|
|
|
typedef enum {
|
|
ERR_FATAL = 0x0,
|
|
ERR_DROP = 0x1,
|
|
ERR_SERVERDISCONNECT = 0x2,
|
|
ERR_DISCONNECT = 0x3,
|
|
ERR_SCRIPT = 0x4,
|
|
ERR_SCRIPT_DROP = 0x5,
|
|
ERR_LOCALIZATION = 0x6,
|
|
ERR_MAPLOADERRORSUMMARY = 0x7,
|
|
} errorParm_t;
|
|
|
|
enum DvarFlags : std::uint16_t {
|
|
DVAR_NONE = 0,
|
|
DVAR_ARCHIVE = 1 << 0,
|
|
DVAR_LATCH = 1 << 1,
|
|
DVAR_CHEAT = 1 << 2,
|
|
DVAR_CODINFO = 1 << 3,
|
|
DVAR_SCRIPTINFO = 1 << 4,
|
|
DVAR_TEMP = 1 << 5,
|
|
DVAR_SAVED = 1 << 6,
|
|
DVAR_INTERNAL = 1 << 7,
|
|
DVAR_EXTERNAL = 1 << 8,
|
|
DVAR_USERINFO = 1 << 9,
|
|
DVAR_SERVERINFO = 1 << 10,
|
|
DVAR_INIT = 1 << 11,
|
|
DVAR_SYSTEMINFO = 1 << 12,
|
|
DVAR_ROM = 1 << 13,
|
|
DVAR_CHANGEABLE_RESET = 1 << 14,
|
|
DVAR_AUTOEXEC = 1 << 15,
|
|
};
|
|
|
|
enum : std::int8_t {
|
|
DVAR_TYPE_BOOL = 0x0,
|
|
DVAR_TYPE_FLOAT = 0x1,
|
|
DVAR_TYPE_FLOAT_2 = 0x2,
|
|
DVAR_TYPE_FLOAT_3 = 0x3,
|
|
DVAR_TYPE_FLOAT_4 = 0x4,
|
|
DVAR_TYPE_INT = 0x5,
|
|
DVAR_TYPE_ENUM = 0x6,
|
|
DVAR_TYPE_STRING = 0x7,
|
|
DVAR_TYPE_COLOR = 0x8,
|
|
DVAR_TYPE_FLOAT_3_COLOR = 0x9,
|
|
};
|
|
|
|
enum DvarSetSource {
|
|
DVAR_SOURCE_INTERNAL,
|
|
DVAR_SOURCE_EXTERNAL,
|
|
DVAR_SOURCE_SCRIPT,
|
|
DVAR_SOURCE_DEVGUI,
|
|
};
|
|
|
|
union DvarValue {
|
|
bool enabled;
|
|
int integer;
|
|
unsigned int unsignedInt;
|
|
float value;
|
|
float vector[4];
|
|
const char* string;
|
|
unsigned char color[4];
|
|
};
|
|
|
|
struct enum_limit {
|
|
int stringCount;
|
|
const char** strings;
|
|
};
|
|
|
|
struct int_limit {
|
|
int min;
|
|
int max;
|
|
};
|
|
|
|
struct float_limit {
|
|
float min;
|
|
float max;
|
|
};
|
|
|
|
union DvarLimits {
|
|
enum_limit enumeration;
|
|
int_limit integer;
|
|
float_limit value;
|
|
float_limit vector;
|
|
};
|
|
|
|
struct dvar_t {
|
|
const char* name;
|
|
const char* description;
|
|
unsigned int flags;
|
|
char type;
|
|
bool modified;
|
|
DvarValue current;
|
|
DvarValue latched;
|
|
DvarValue reset;
|
|
DvarLimits domain;
|
|
bool(__cdecl* domainFunc)(dvar_t*, DvarValue);
|
|
dvar_t* hashNext;
|
|
};
|
|
|
|
enum netsrc_t {
|
|
NS_CLIENT1 = 0x0,
|
|
NS_SERVER = 0x1,
|
|
NS_MAXCLIENTS = 0x1,
|
|
NS_PACKET = 0x2,
|
|
};
|
|
|
|
enum netadrtype_t {
|
|
NA_BOT = 0x0,
|
|
NA_BAD = 0x1,
|
|
NA_LOOPBACK = 0x2,
|
|
NA_BROADCAST = 0x3,
|
|
NA_IP = 0x4,
|
|
NA_IPX = 0x5,
|
|
NA_BROADCAST_IPX = 0x6,
|
|
};
|
|
|
|
struct netadr_t {
|
|
netadrtype_t type;
|
|
unsigned char ip[4];
|
|
unsigned __int16 port;
|
|
char ipx[10];
|
|
};
|
|
|
|
static_assert(sizeof(netadr_t) == 0x14);
|
|
|
|
struct Bounds {
|
|
float midPoint[3];
|
|
float halfSize[3];
|
|
};
|
|
|
|
struct TriggerModel {
|
|
int contents;
|
|
unsigned __int16 hullCount;
|
|
unsigned __int16 firstHull;
|
|
};
|
|
|
|
struct TriggerHull {
|
|
Bounds bounds;
|
|
int contents;
|
|
unsigned __int16 slabCount;
|
|
unsigned __int16 firstSlab;
|
|
};
|
|
|
|
struct TriggerSlab {
|
|
float dir[3];
|
|
float midPoint;
|
|
float halfSize;
|
|
};
|
|
|
|
struct MapTriggers {
|
|
unsigned int count;
|
|
TriggerModel* models;
|
|
unsigned int hullCount;
|
|
TriggerHull* hulls;
|
|
unsigned int slabCount;
|
|
TriggerSlab* slabs;
|
|
};
|
|
|
|
struct Stage {
|
|
const char* name;
|
|
float origin[3];
|
|
unsigned __int16 triggerIndex;
|
|
char sunPrimaryLightIndex;
|
|
};
|
|
|
|
struct MapEnts {
|
|
const char* name;
|
|
char* entityString;
|
|
int numEntityChars;
|
|
MapTriggers trigger;
|
|
Stage* stages;
|
|
char stageCount;
|
|
};
|
|
|
|
struct WeaponCompleteDef {
|
|
const char* szInternalName;
|
|
}; // Incomplete
|
|
|
|
struct Font_s {
|
|
const char* fontName;
|
|
int pixelHeight;
|
|
int glyphCount;
|
|
void* material;
|
|
void* glowMaterial;
|
|
void* glyphs;
|
|
};
|
|
|
|
struct RawFile {
|
|
const char* name;
|
|
int compressedLen;
|
|
int len;
|
|
const char* buffer;
|
|
};
|
|
|
|
struct G_GlassPiece {
|
|
unsigned __int16 damageTaken;
|
|
unsigned __int16 collapseTime;
|
|
int lastStateChangeTime;
|
|
char impactDir;
|
|
char impactPos[2];
|
|
};
|
|
|
|
static_assert(sizeof(G_GlassPiece) == 0xC);
|
|
|
|
struct G_GlassName {
|
|
char* nameStr;
|
|
unsigned __int16 name;
|
|
unsigned __int16 pieceCount;
|
|
unsigned __int16* pieceIndices;
|
|
};
|
|
|
|
static_assert(sizeof(G_GlassName) == 0xC);
|
|
|
|
struct G_GlassData {
|
|
G_GlassPiece* glassPieces;
|
|
unsigned int pieceCount;
|
|
unsigned __int16 damageToWeaken;
|
|
unsigned __int16 damageToDestroy;
|
|
unsigned int glassNameCount;
|
|
G_GlassName* glassNames;
|
|
unsigned __int8 pad[108];
|
|
};
|
|
|
|
static_assert(sizeof(G_GlassData) == 0x80);
|
|
|
|
struct GameWorldMp {
|
|
const char* name;
|
|
G_GlassData* g_glassData;
|
|
};
|
|
|
|
struct GameWorldSp {
|
|
const char* name;
|
|
unsigned char __pad0[0x30];
|
|
G_GlassData* g_glassData;
|
|
};
|
|
|
|
static_assert(sizeof(GameWorldSp) == 0x38);
|
|
|
|
struct StringTableCell {
|
|
const char* string;
|
|
int hash;
|
|
};
|
|
|
|
struct StringTable {
|
|
const char* name;
|
|
int columnCount;
|
|
int rowCount;
|
|
StringTableCell* values;
|
|
};
|
|
|
|
#define MAX_UISTRINGS 0x800
|
|
|
|
struct rectDef_s {
|
|
float x;
|
|
float y;
|
|
float w;
|
|
float h;
|
|
char horzAlign;
|
|
char vertAlign;
|
|
};
|
|
|
|
struct windowDef_t {
|
|
const char* name;
|
|
rectDef_s rect;
|
|
rectDef_s rectClient;
|
|
const char* group;
|
|
int style;
|
|
int border;
|
|
int ownerDraw;
|
|
int ownerDrawFlags;
|
|
float borderSize;
|
|
int staticFlags;
|
|
int dynamicFlags[1];
|
|
int nextTime;
|
|
float foreColor[4];
|
|
float backColor[4];
|
|
float borderColor[4];
|
|
float outlineColor[4];
|
|
float disableColor[4];
|
|
void* background;
|
|
};
|
|
|
|
static_assert(sizeof(windowDef_t) == 0xA4);
|
|
|
|
enum expDataType {
|
|
VAL_INT = 0x0,
|
|
VAL_FLOAT = 0x1,
|
|
VAL_STRING = 0x2,
|
|
NUM_INTERNAL_DATATYPES = 0x3,
|
|
VAL_FUNCTION = 0x3,
|
|
NUM_DATATYPES = 0x4,
|
|
};
|
|
|
|
struct Operand {
|
|
expDataType dataType;
|
|
char internals[4];
|
|
};
|
|
|
|
union entryInternalData {
|
|
int op;
|
|
Operand operand;
|
|
};
|
|
|
|
struct expressionEntry {
|
|
int type;
|
|
entryInternalData data;
|
|
};
|
|
|
|
struct menuTransition {
|
|
int transitionType;
|
|
int targetField;
|
|
int startTime;
|
|
float startVal;
|
|
float endVal;
|
|
float time;
|
|
int endTriggerType;
|
|
};
|
|
|
|
struct StaticDvar {
|
|
dvar_t* dvar;
|
|
char* dvarName;
|
|
};
|
|
|
|
struct StaticDvarList {
|
|
int numStaticDvars;
|
|
StaticDvar** staticDvars;
|
|
};
|
|
|
|
struct StringList {
|
|
int totalStrings;
|
|
const char** strings;
|
|
};
|
|
|
|
struct ExpressionSupportingData; // required against my will
|
|
|
|
struct Statement_s {
|
|
int numEntries;
|
|
expressionEntry* entries;
|
|
ExpressionSupportingData* supportingData;
|
|
int lastExecuteTime;
|
|
Operand lastResult;
|
|
};
|
|
|
|
struct UIFunctionList {
|
|
int totalFunctions;
|
|
Statement_s** functions;
|
|
};
|
|
|
|
struct ExpressionSupportingData {
|
|
UIFunctionList uifunctions;
|
|
StaticDvarList staticDvarList;
|
|
StringList uiStrings;
|
|
};
|
|
|
|
static_assert(sizeof(Statement_s) == 0x18);
|
|
|
|
struct ItemFloatExpression {
|
|
int target;
|
|
Statement_s* expression;
|
|
};
|
|
|
|
struct MenuEventHandlerSet; // required against my will
|
|
|
|
struct ConditionalScript {
|
|
MenuEventHandlerSet* eventHandlerSet;
|
|
Statement_s* eventExpression;
|
|
};
|
|
|
|
static_assert(sizeof(ConditionalScript) == 0x8);
|
|
|
|
struct SetLocalVarData {
|
|
const char* localVarName;
|
|
Statement_s* expression;
|
|
};
|
|
|
|
union EventData {
|
|
const char* unconditionalScript;
|
|
ConditionalScript* conditionalScript;
|
|
MenuEventHandlerSet* elseScript;
|
|
SetLocalVarData* setLocalVarData;
|
|
};
|
|
|
|
#define MAX_EVENT_HANDLERS_PER_EVENT 200
|
|
|
|
enum EventType {
|
|
EVENT_UNCONDITIONAL = 0x0,
|
|
EVENT_IF = 0x1,
|
|
EVENT_ELSE = 0x2,
|
|
EVENT_SET_LOCAL_VAR_BOOL = 0x3,
|
|
EVENT_SET_LOCAL_VAR_INT = 0x4,
|
|
EVENT_SET_LOCAL_VAR_FLOAT = 0x5,
|
|
EVENT_SET_LOCAL_VAR_STRING = 0x6,
|
|
EVENT_COUNT = 0x7,
|
|
};
|
|
|
|
struct MenuEventHandler {
|
|
EventData eventData;
|
|
char eventType;
|
|
};
|
|
|
|
static_assert(sizeof(MenuEventHandler) == 0x8);
|
|
|
|
struct MenuEventHandlerSet {
|
|
int eventHandlerCount;
|
|
MenuEventHandler** eventHandlers;
|
|
};
|
|
|
|
struct ItemKeyHandler {
|
|
int key;
|
|
MenuEventHandlerSet* action;
|
|
ItemKeyHandler* next;
|
|
};
|
|
|
|
struct columnInfo_s {
|
|
int pos;
|
|
int width;
|
|
int maxChars;
|
|
int alignment;
|
|
};
|
|
|
|
struct listBoxDef_s {
|
|
int mousePos;
|
|
int startPos[1];
|
|
int endPos[1];
|
|
int drawPadding;
|
|
float elementWidth;
|
|
float elementHeight;
|
|
int elementStyle;
|
|
int numColumns;
|
|
columnInfo_s columnInfo[16];
|
|
MenuEventHandlerSet* onDoubleClick;
|
|
int notselectable;
|
|
int noScrollBars;
|
|
int usePaging;
|
|
float selectBorder[4];
|
|
void* selectIcon;
|
|
};
|
|
|
|
static_assert(sizeof(listBoxDef_s) == 0x144);
|
|
|
|
struct editFieldDef_s {
|
|
float minVal;
|
|
float maxVal;
|
|
float defVal;
|
|
float range;
|
|
int maxChars;
|
|
int maxCharsGotoNext;
|
|
int maxPaintChars;
|
|
int paintOffset;
|
|
};
|
|
|
|
static_assert(sizeof(editFieldDef_s) == 0x20);
|
|
|
|
#define MAX_MULTI_DVARS 32
|
|
|
|
struct multiDef_s {
|
|
const char* dvarList[MAX_MULTI_DVARS];
|
|
const char* dvarStr[MAX_MULTI_DVARS];
|
|
float dvarValue[MAX_MULTI_DVARS];
|
|
int count;
|
|
int strDef;
|
|
};
|
|
|
|
static_assert(sizeof(multiDef_s) == 0x188);
|
|
|
|
struct newsTickerDef_s {
|
|
int feedId;
|
|
int speed;
|
|
int spacing;
|
|
int lastTime;
|
|
int start;
|
|
int end;
|
|
float x;
|
|
};
|
|
|
|
static_assert(sizeof(newsTickerDef_s) == 0x1C);
|
|
|
|
struct textScrollDef_s {
|
|
int startTime;
|
|
};
|
|
|
|
union itemDefData_t {
|
|
listBoxDef_s* listBox;
|
|
editFieldDef_s* editField;
|
|
multiDef_s* multi;
|
|
const char* enumDvarName;
|
|
newsTickerDef_s* ticker;
|
|
textScrollDef_s* scroll;
|
|
void* data;
|
|
};
|
|
|
|
struct menuDef_t; // required against my will
|
|
|
|
struct itemDef_s {
|
|
windowDef_t window;
|
|
rectDef_s textRect[1];
|
|
int type;
|
|
int dataType;
|
|
int alignment;
|
|
int fontEnum;
|
|
int textAlignMode;
|
|
float textalignx;
|
|
float textaligny;
|
|
float textscale;
|
|
int textStyle;
|
|
int gameMsgWindowIndex;
|
|
int gameMsgWindowMode;
|
|
const char* text;
|
|
int itemFlags;
|
|
menuDef_t* parent;
|
|
MenuEventHandlerSet* mouseEnterText;
|
|
MenuEventHandlerSet* mouseExitText;
|
|
MenuEventHandlerSet* mouseEnter;
|
|
MenuEventHandlerSet* mouseExit;
|
|
MenuEventHandlerSet* action;
|
|
MenuEventHandlerSet* accept;
|
|
MenuEventHandlerSet* onFocus;
|
|
MenuEventHandlerSet* leaveFocus;
|
|
const char* dvar;
|
|
const char* dvarTest;
|
|
ItemKeyHandler* onKey;
|
|
const char* enableDvar;
|
|
const char* localVar;
|
|
int dvarFlags;
|
|
void* focusSound;
|
|
float special;
|
|
int cursorPos[1];
|
|
itemDefData_t typeData;
|
|
int imageTrack;
|
|
int floatExpressionCount;
|
|
ItemFloatExpression* floatExpressions;
|
|
Statement_s* visibleExp;
|
|
Statement_s* disabledExp;
|
|
Statement_s* textExp;
|
|
Statement_s* materialExp;
|
|
float glowColor[4];
|
|
bool decayActive;
|
|
int fxBirthTime;
|
|
int fxLetterTime;
|
|
int fxDecayStartTime;
|
|
int fxDecayDuration;
|
|
int lastSoundPlayedTime;
|
|
};
|
|
|
|
static_assert(sizeof(itemDef_s) == 0x17C);
|
|
|
|
struct menuDef_t {
|
|
windowDef_t window;
|
|
const char* font;
|
|
int fullScreen;
|
|
int itemCount;
|
|
int fontIndex;
|
|
int cursorItem[1];
|
|
int fadeCycle;
|
|
float fadeClamp;
|
|
float fadeAmount;
|
|
float fadeInAmount;
|
|
float blurRadius;
|
|
MenuEventHandlerSet* onOpen;
|
|
MenuEventHandlerSet* onCloseRequest;
|
|
MenuEventHandlerSet* onClose;
|
|
MenuEventHandlerSet* onESC;
|
|
ItemKeyHandler* onKey;
|
|
Statement_s* visibleExp;
|
|
const char* allowedBinding;
|
|
const char* soundName;
|
|
int imageTrack;
|
|
float focusColor[4];
|
|
Statement_s* rectXExp;
|
|
Statement_s* rectYExp;
|
|
Statement_s* rectWExp;
|
|
Statement_s* rectHExp;
|
|
Statement_s* openSoundExp;
|
|
Statement_s* closeSoundExp;
|
|
itemDef_s** items;
|
|
menuTransition scaleTransition[1];
|
|
menuTransition alphaTransition[1];
|
|
menuTransition xTransition[1];
|
|
menuTransition yTransition[1];
|
|
ExpressionSupportingData* expressionData;
|
|
};
|
|
|
|
static_assert(sizeof(menuDef_t) == 0x190);
|
|
|
|
struct loadAssets_t {
|
|
float fadeClamp;
|
|
int fadeCycle;
|
|
float fadeAmount;
|
|
float fadeInAmount;
|
|
};
|
|
|
|
enum UILocalVarType {
|
|
UILOCALVAR_INT = 0x0,
|
|
UILOCALVAR_FLOAT = 0x1,
|
|
UILOCALVAR_STRING = 0x2,
|
|
};
|
|
|
|
struct UILocalVar {
|
|
UILocalVarType type;
|
|
const char* name;
|
|
union {
|
|
int integer;
|
|
float value;
|
|
const char* string;
|
|
} u;
|
|
};
|
|
|
|
struct UILocalVarContext {
|
|
UILocalVar table[256];
|
|
};
|
|
|
|
struct UiContext {
|
|
int localClientNum;
|
|
float bias;
|
|
int realTime;
|
|
int frameTime;
|
|
struct {
|
|
float x;
|
|
float y;
|
|
int lastMoveTime;
|
|
} cursor;
|
|
int isCursorVisible;
|
|
int paintFull;
|
|
int screenWidth;
|
|
int screenHeight;
|
|
float screenAspect;
|
|
float FPS;
|
|
float blurRadiusOut;
|
|
menuDef_t* Menus[640];
|
|
int menuCount;
|
|
menuDef_t* menuStack[16];
|
|
int openMenuCount;
|
|
UILocalVarContext localVars;
|
|
const StringTable* cinematicSubtitles;
|
|
};
|
|
|
|
struct MenuList {
|
|
const char* name;
|
|
int menuCount;
|
|
menuDef_t** menus;
|
|
};
|
|
|
|
struct savegameStatus_s {
|
|
int sortKey;
|
|
int sortDir;
|
|
int displaySavegames[256];
|
|
};
|
|
|
|
struct qtime_s {
|
|
int tm_sec;
|
|
int tm_min;
|
|
int tm_hour;
|
|
int tm_mday;
|
|
int tm_mon;
|
|
int tm_year;
|
|
int tm_wday;
|
|
int tm_yday;
|
|
int tm_isdst;
|
|
};
|
|
|
|
struct SavegameInfo {
|
|
const char* savegameFile;
|
|
const char* savegameName;
|
|
const char* imageName;
|
|
const char* mapName;
|
|
const char* savegameInfoText;
|
|
const char* time;
|
|
const char* date;
|
|
qtime_s tm;
|
|
};
|
|
|
|
struct uiInfo_s {
|
|
UiContext uiDC;
|
|
SavegameInfo savegameList[512];
|
|
int savegameCount;
|
|
savegameStatus_s savegameStatus;
|
|
int timeIndex;
|
|
int previousTimes[4];
|
|
bool allowScriptMenuResponse;
|
|
char savegameName[64];
|
|
char savegameInfo[256];
|
|
void* sshotImage;
|
|
char sshotImageName[64];
|
|
};
|
|
|
|
static_assert(sizeof(uiInfo_s) == 0x9C2C);
|
|
|
|
struct LocalizeEntry {
|
|
const char* value;
|
|
const char* name;
|
|
};
|
|
|
|
union XAssetHeader {
|
|
GameWorldSp* gameWorldSp;
|
|
GameWorldMp* gameWorldMp;
|
|
MapEnts* mapEnts;
|
|
Font_s* font;
|
|
MenuList* menuList;
|
|
LocalizeEntry* localize;
|
|
WeaponCompleteDef* weapon;
|
|
RawFile* rawfile;
|
|
StringTable* stringTable;
|
|
void* data;
|
|
};
|
|
|
|
struct XAsset {
|
|
XAssetType type;
|
|
XAssetHeader header;
|
|
};
|
|
|
|
struct XAssetEntry {
|
|
XAsset asset;
|
|
unsigned char zoneIndex;
|
|
volatile unsigned char inuseMask;
|
|
bool printedMissingAsset;
|
|
unsigned __int16 nextHash;
|
|
unsigned __int16 nextOverride;
|
|
};
|
|
|
|
static_assert(sizeof(XAssetEntry) == 0x10);
|
|
|
|
struct GfxConfiguration {
|
|
bool inited;
|
|
unsigned int maxClientViews;
|
|
unsigned int maxClientRenderViews;
|
|
unsigned int entCount;
|
|
unsigned int entnumNone;
|
|
unsigned int entnumOrdinaryEnd;
|
|
int threadContextCount;
|
|
int critSectCount;
|
|
const char* codeFastFileName;
|
|
const char* localizedCodeFastFileName;
|
|
const char* uiFastFileName;
|
|
const char* localizedUiFastFileName;
|
|
const char* commonFastFileName;
|
|
const char* localizedCommonFastFileName;
|
|
const char* patchFastFileName;
|
|
bool defaultFullscreen;
|
|
unsigned __int16 defaultFullscreenFlags;
|
|
int defaultMode;
|
|
unsigned int textureMinVRamTier1;
|
|
unsigned int textureMinVRamTier2;
|
|
};
|
|
|
|
enum FF_DIR {
|
|
FFD_DEFAULT = 0x0,
|
|
FFD_MOD_DIR = 0x1,
|
|
FFD_USER_MAP = 0x2,
|
|
};
|
|
|
|
enum {
|
|
DB_ZONE_COMMON = 0x1,
|
|
DB_ZONE_UI = 0x2,
|
|
DB_ZONE_GAME = 0x4,
|
|
DB_ZONE_LOAD = 0x8,
|
|
DB_ZONE_DEV = 0x10,
|
|
DB_ZONE_TRANSIENT = 0x20,
|
|
};
|
|
|
|
struct XZoneInfo {
|
|
const char* name;
|
|
int allocFlags;
|
|
int freeFlags;
|
|
};
|
|
|
|
struct playerState_s {
|
|
int commandTime;
|
|
int pm_type;
|
|
int pm_time;
|
|
int pm_flags;
|
|
int otherFlags;
|
|
int linkFlags;
|
|
int bobCycle;
|
|
float origin[3];
|
|
float velocity[3];
|
|
unsigned char __pad0[0xAC70];
|
|
};
|
|
|
|
static_assert(sizeof(playerState_s) == 0xACA4);
|
|
|
|
struct gclient_s {
|
|
playerState_s ps;
|
|
unsigned char __pad0[0xB0];
|
|
int flags; // 0xAD54
|
|
unsigned char __pad1[0x27C];
|
|
};
|
|
|
|
static_assert(sizeof(gclient_s) == 0xAFD4);
|
|
|
|
struct entityState_s {
|
|
unsigned char eType; // 0
|
|
unsigned char __pad0[0x7D];
|
|
unsigned __int16 number; // 0x7E
|
|
unsigned char __pad1[0x2C];
|
|
};
|
|
|
|
static_assert(sizeof(entityState_s) == 0xAC);
|
|
|
|
struct entityShared_t {
|
|
unsigned char __pad0[0x5C];
|
|
};
|
|
|
|
static_assert(sizeof(entityShared_t) == 0x5C);
|
|
|
|
struct gentity_s {
|
|
entityState_s s;
|
|
entityShared_t r;
|
|
gclient_s* client;
|
|
unsigned char __pad0[0x164];
|
|
};
|
|
|
|
static_assert(sizeof(gentity_s) == 0x270);
|
|
|
|
struct client_t {
|
|
unsigned char __pad0[0x1674];
|
|
};
|
|
|
|
static_assert(sizeof(client_t) == 0x1674);
|
|
|
|
struct level_locals_t {
|
|
unsigned char __pad0[0x34];
|
|
int time;
|
|
unsigned char __pad1[0x4748];
|
|
};
|
|
|
|
static_assert(sizeof(level_locals_t) == 0x4780);
|
|
|
|
struct field_t {
|
|
int cursor;
|
|
int scroll;
|
|
int drawWidth;
|
|
int widthInPixels;
|
|
float charHeight;
|
|
int fixedSize;
|
|
char buffer[256];
|
|
};
|
|
|
|
struct ConDrawInputGlob {
|
|
char autoCompleteChoice[64];
|
|
int matchIndex;
|
|
int matchCount;
|
|
const char* inputText;
|
|
int inputTextLen;
|
|
bool hasExactMatch;
|
|
bool mayAutoComplete;
|
|
float x;
|
|
float y;
|
|
float leftX;
|
|
float fontHeight;
|
|
};
|
|
|
|
struct MessageLine {
|
|
int messageIndex;
|
|
int textBufPos;
|
|
int textBufSize;
|
|
int typingStartTime;
|
|
int lastTypingSoundTime;
|
|
int flags;
|
|
};
|
|
|
|
struct Message {
|
|
int startTime;
|
|
int endTime;
|
|
};
|
|
|
|
struct MessageWindow {
|
|
MessageLine* lines;
|
|
Message* messages;
|
|
char* circularTextBuffer;
|
|
int textBufSize;
|
|
int lineCount;
|
|
int padding;
|
|
int scrollTime;
|
|
int fadeIn;
|
|
int fadeOut;
|
|
int textBufPos;
|
|
int firstLineIndex;
|
|
int activeLineCount;
|
|
int messageIndex;
|
|
};
|
|
|
|
struct MessageBuffer {
|
|
char gamemsgText[4][2048];
|
|
MessageWindow gamemsgWindows[4];
|
|
MessageLine gamemsgLines[4][12];
|
|
Message gamemsgMessages[4][12];
|
|
char miniconText[4096];
|
|
MessageWindow miniconWindow;
|
|
MessageLine miniconLines[100];
|
|
Message miniconMessages[100];
|
|
char errorText[1024];
|
|
MessageWindow errorWindow;
|
|
MessageLine errorLines[5];
|
|
Message errorMessages[5];
|
|
};
|
|
|
|
struct Console {
|
|
MessageWindow consoleWindow;
|
|
MessageLine consoleLines[1024];
|
|
Message consoleMessages[1024];
|
|
char consoleText[65536];
|
|
char textTempLine[512];
|
|
unsigned int lineOffset;
|
|
int displayLineOffset;
|
|
int prevChannel;
|
|
bool outputVisible;
|
|
int fontHeight;
|
|
int visibleLineCount;
|
|
int visiblePixelWidth;
|
|
float screenMin[2];
|
|
float screenMax[2];
|
|
MessageBuffer messageBuffer[1];
|
|
float color[4];
|
|
};
|
|
|
|
enum {
|
|
KEYCATCH_CONSOLE = 0x1,
|
|
};
|
|
|
|
enum ScreenPlacementMode {
|
|
SCRMODE_FULL = 0x0,
|
|
SCRMODE_DISPLAY = 0x1,
|
|
SCRMODE_INVALID = 0x2,
|
|
SCRMODE_COUNT = 0x3,
|
|
};
|
|
|
|
struct ScreenPlacement {
|
|
float scaleVirtualToReal[2];
|
|
float scaleVirtualToFull[2];
|
|
float scaleRealToVirtual[2];
|
|
float realViewportPosition[2];
|
|
float realViewportSize[2];
|
|
float virtualViewableMin[2];
|
|
float virtualViewableMax[2];
|
|
float realViewableMin[2];
|
|
float realViewableMax[2];
|
|
float virtualAdjustableMin[2];
|
|
float virtualAdjustableMax[2];
|
|
float realAdjustableMin[2];
|
|
float realAdjustableMax[2];
|
|
float subScreenLeft;
|
|
};
|
|
|
|
enum usercmdButtonBits {
|
|
CMD_BUTTON_LEAN_LEFT = 0x40,
|
|
CMD_BUTTON_LEAN_RIGHT = 0x80,
|
|
};
|
|
|
|
struct kbutton_t {
|
|
int down[2];
|
|
unsigned int downtime;
|
|
unsigned int msec;
|
|
bool active;
|
|
bool wasPressed;
|
|
};
|
|
|
|
struct usercmd_s {
|
|
int serverTime;
|
|
int buttons;
|
|
int angles[3];
|
|
unsigned __int16 weapon;
|
|
unsigned __int16 primaryWeaponForAltMode;
|
|
unsigned __int16 offHandIndex;
|
|
char forwardmove;
|
|
char rightmove;
|
|
unsigned char upmove;
|
|
unsigned char downmove;
|
|
char pitchmove;
|
|
char yawmove;
|
|
float gunPitch;
|
|
float gunYaw;
|
|
float gunXOfs;
|
|
float gunYOfs;
|
|
float gunZOfs;
|
|
float meleeChargeYaw;
|
|
unsigned char meleeChargeDist;
|
|
char selectedLoc[2];
|
|
unsigned char selectedLocAngle;
|
|
char remoteControlAngles[2];
|
|
};
|
|
|
|
struct weaponParms {
|
|
float forward[3];
|
|
float right[3];
|
|
float up[3];
|
|
float muzzleTrace[3];
|
|
float gunForward[3];
|
|
unsigned int weaponIndex;
|
|
const void* weapDef;
|
|
const void* weapCompleteDef;
|
|
};
|
|
|
|
struct lockonFireParms {
|
|
bool lockon;
|
|
gentity_s* target;
|
|
float targetPosOrOffset[3];
|
|
bool topFire;
|
|
};
|
|
|
|
enum TraceHitType {
|
|
TRACE_HITTYPE_NONE = 0x0,
|
|
TRACE_HITTYPE_ENTITY = 0x1,
|
|
TRACE_HITTYPE_DYNENT_MODEL = 0x2,
|
|
TRACE_HITTYPE_DYNENT_BRUSH = 0x3,
|
|
TRACE_HITTYPE_GLASS = 0x4,
|
|
};
|
|
|
|
struct trace_t {
|
|
float fraction;
|
|
float normal[3];
|
|
int surfaceFlags;
|
|
int contents;
|
|
const char* material;
|
|
TraceHitType hitType;
|
|
unsigned __int16 hitId;
|
|
unsigned __int16 modelIndex;
|
|
unsigned __int16 partName;
|
|
unsigned __int16 partGroup;
|
|
bool allsolid;
|
|
bool startsolid;
|
|
bool walkable;
|
|
};
|
|
|
|
static_assert(sizeof(trace_t) == 0x2C);
|
|
|
|
struct pml_t {
|
|
float forward[3];
|
|
float right[3];
|
|
float up[3];
|
|
float frametime;
|
|
int msec;
|
|
int walking;
|
|
int groundPlane;
|
|
trace_t groundTrace;
|
|
float impactSpeed;
|
|
float previous_origin[3];
|
|
float previous_velocity[3];
|
|
unsigned int holdrand;
|
|
};
|
|
|
|
static_assert(sizeof(pml_t) == 0x80);
|
|
|
|
struct pmove_t {
|
|
playerState_s* ps;
|
|
usercmd_s cmd;
|
|
usercmd_s oldcmd;
|
|
int tracemask;
|
|
int numtouch;
|
|
int touchents[32];
|
|
Bounds bounds;
|
|
float xyspeed;
|
|
int proneChange;
|
|
int viewChangeTime;
|
|
float viewChange;
|
|
float fTorsoPitch;
|
|
float fWaistPitch;
|
|
unsigned char handler;
|
|
};
|
|
|
|
static_assert(sizeof(pmove_t) == 0x140);
|
|
|
|
enum ScopedCriticalSectionType {
|
|
SCOPED_CRITSECT_NORMAL = 0x0,
|
|
SCOPED_CRITSECT_DISABLED = 0x1,
|
|
SCOPED_CRITSECT_RELEASE = 0x2,
|
|
SCOPED_CRITSECT_TRY = 0x3,
|
|
};
|
|
|
|
enum CriticalSection {
|
|
CRITSECT_CONSOLE = 0x0,
|
|
CRITSECT_LSP = 0x1A,
|
|
CRITSECT_CBUF = 0x21,
|
|
CRITSECT_COUNT = 0x28,
|
|
};
|
|
|
|
enum {
|
|
THREAD_VALUE_PROF_STACK = 0x0,
|
|
THREAD_VALUE_VA = 0x1,
|
|
THREAD_VALUE_COM_ERROR = 0x2,
|
|
THREAD_VALUE_TRACE = 0x3,
|
|
THREAD_VALUE_COUNT = 0x4,
|
|
};
|
|
|
|
struct TempPriority {
|
|
void* threadHandle;
|
|
int oldPriority;
|
|
};
|
|
|
|
struct FastCriticalSection {
|
|
volatile long readCount;
|
|
volatile long writeCount;
|
|
TempPriority tempPriority;
|
|
};
|
|
|
|
struct ProfileAtom {
|
|
unsigned int value[1];
|
|
};
|
|
|
|
volatile struct ProfileReadable {
|
|
unsigned int hits;
|
|
ProfileAtom total;
|
|
ProfileAtom self;
|
|
};
|
|
|
|
struct ProfileWritable {
|
|
int nesting;
|
|
unsigned int hits;
|
|
ProfileAtom start[3];
|
|
ProfileAtom total;
|
|
ProfileAtom child;
|
|
};
|
|
|
|
struct profile_t {
|
|
ProfileWritable write;
|
|
ProfileReadable read;
|
|
};
|
|
|
|
struct profile_guard_t {
|
|
int id;
|
|
profile_t** ppStack;
|
|
};
|
|
|
|
struct ProfileStack {
|
|
profile_t prof_root;
|
|
profile_t* prof_pStack[16384];
|
|
profile_t** prof_ppStack;
|
|
profile_t prof_array[443];
|
|
ProfileAtom prof_overhead_internal;
|
|
ProfileAtom prof_overhead_external;
|
|
profile_guard_t prof_guardstack[32];
|
|
int prof_guardpos;
|
|
float prof_timescale;
|
|
};
|
|
|
|
struct va_info_t {
|
|
char va_string[2][1024];
|
|
int index;
|
|
};
|
|
|
|
static_assert(sizeof(va_info_t) == 0x804);
|
|
|
|
struct TraceCheckCount {
|
|
int global;
|
|
int* partitions;
|
|
};
|
|
|
|
struct TraceThreadInfo {
|
|
TraceCheckCount checkcount;
|
|
};
|
|
|
|
static_assert(sizeof(TraceThreadInfo) == 0x8);
|
|
|
|
struct localization_t {
|
|
char* language;
|
|
char* strings;
|
|
};
|
|
|
|
struct Sys_File {
|
|
HANDLE handle;
|
|
};
|
|
|
|
enum ShockViewTypes {
|
|
SHELLSHOCK_VIEWTYPE_BLURRED = 0x0,
|
|
SHELLSHOCK_VIEWTYPE_FLASHED = 0x1,
|
|
SHELLSHOCK_VIEWTYPE_NONE = 0x2,
|
|
};
|
|
|
|
struct shellshock_parms_t {
|
|
struct {
|
|
int blurredFadeTime;
|
|
int blurredEffectTime;
|
|
int flashWhiteFadeTime;
|
|
int flashShotFadeTime;
|
|
ShockViewTypes type;
|
|
} screenBlend;
|
|
struct {
|
|
int fadeTime;
|
|
float kickRate;
|
|
float kickRadius;
|
|
} view;
|
|
struct {
|
|
bool affect;
|
|
char loop[64];
|
|
char loopSilent[64];
|
|
char end[64];
|
|
char endAbort[64];
|
|
int fadeInTime;
|
|
int fadeOutTime;
|
|
float drylevel;
|
|
float wetlevel;
|
|
char roomtype[16];
|
|
float channelvolume[64];
|
|
int modEndDelay;
|
|
int loopFadeTime;
|
|
int loopEndDelay;
|
|
} sound;
|
|
struct {
|
|
bool affect;
|
|
int fadeTime;
|
|
float mouseSensitivity;
|
|
float maxPitchSpeed;
|
|
float maxYawSpeed;
|
|
} lookControl;
|
|
struct {
|
|
bool affect;
|
|
} movement;
|
|
};
|
|
|
|
struct cgs_t {
|
|
int viewX;
|
|
int viewY;
|
|
int viewWidth;
|
|
int viewHeight;
|
|
float viewAspect;
|
|
bool started;
|
|
shellshock_parms_t holdBreathParams;
|
|
};
|
|
|
|
static_assert(sizeof(cgs_t) == 0x280);
|
|
|
|
struct cpose_t {
|
|
unsigned char __pad0[0x64];
|
|
};
|
|
|
|
static_assert(sizeof(cpose_t) == 0x64);
|
|
|
|
enum CubemapShot {
|
|
CUBEMAPSHOT_NONE = 0x0,
|
|
CUBEMAPSHOT_RIGHT = 0x1,
|
|
CUBEMAPSHOT_LEFT = 0x2,
|
|
CUBEMAPSHOT_BACK = 0x3,
|
|
CUBEMAPSHOT_FRONT = 0x4,
|
|
CUBEMAPSHOT_UP = 0x5,
|
|
CUBEMAPSHOT_DOWN = 0x6,
|
|
CUBEMAPSHOT_COUNT = 0x7,
|
|
};
|
|
|
|
struct snapshot_s {
|
|
int snapFlags;
|
|
int serverTime;
|
|
int numEntities;
|
|
unsigned __int16 entityNums[2048];
|
|
int numFxEntities;
|
|
unsigned __int16 fxEntityNums[768];
|
|
};
|
|
|
|
struct cg_s {
|
|
int clientNum;
|
|
int localClientNum;
|
|
CubemapShot cubemapShot;
|
|
int cubemapSize;
|
|
int serverCommandSequence;
|
|
int serverLatestCommandSequence;
|
|
int loaded;
|
|
snapshot_s* snap;
|
|
snapshot_s* nextSnap;
|
|
playerState_s* ps;
|
|
playerState_s* nextPs;
|
|
}; // Incomplete
|
|
|
|
static_assert(offsetof(cg_s, snap) == 0x1C);
|
|
static_assert(offsetof(cg_s, nextSnap) == 0x20);
|
|
static_assert(offsetof(cg_s, nextPs) == 0x28);
|
|
} // namespace game
|
|
|
|
#pragma warning(pop)
|