src/common.h

/*
Copyright (C) 1997-2001 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/

// qcommon.h -- definitions common between client and server, but not game.dll

#include <config.h>
#include "q_shared.h"
#include <errno.h>
#include "error.h"

#define PRODUCT         "Q2PRO"

#if USE_CLIENT
#define APPLICATION     "q2pro"
#else
#define APPLICATION     "q2proded"
#endif

/*
==============================================================

CMD

Command text buffering and command execution

==============================================================
*/

#define CMD_BUFFER_SIZE     (1 << 16) // bumped max config size up to 64K

#define ALIAS_LOOP_COUNT    16

// where did current command come from?
typedef enum {
    FROM_STUFFTEXT,
    FROM_RCON,
    FROM_MENU,
    FROM_CONSOLE,
    FROM_CMDLINE,
    FROM_CODE
} from_t;

typedef struct cmdbuf_s {
    from_t      from;
    char        *text; // may not be NULL terminated
    size_t      cursize;
    size_t      maxsize;
    int         waitCount;
    int         aliasCount; // for detecting runaway loops
    void        (*exec)(struct cmdbuf_s *, const char *);
} cmdbuf_t;

// generic console buffer
extern char         cmd_buffer_text[CMD_BUFFER_SIZE];
extern cmdbuf_t     cmd_buffer;

extern cmdbuf_t     *cmd_current;

/*

Any number of commands can be added in a frame, from several different sources.
Most commands come from either keybindings or console line input, but remote
servers can also send across commands and entire text files can be execed.

The + command line options are also added to the command buffer.

The game starts with a Cbuf_AddText ("exec quake.rc\n"); Cbuf_Execute ();

*/

void Cbuf_Init(void);
// allocates an initial text buffer that will grow as needed

void Cbuf_AddText(cmdbuf_t *buf, const char *text);
// as new commands are generated from the console or keybindings,
// the text is added to the end of the command buffer.

void Cbuf_InsertText(cmdbuf_t *buf, const char *text);
// when a command wants to issue other commands immediately, the text is
// inserted at the beginning of the buffer, before any remaining unexecuted
// commands.

void Cbuf_Execute(cmdbuf_t *buf);
// Pulls off \n terminated lines of text from the command buffer and sends
// them through Cmd_ExecuteString.  Stops when the buffer is empty.
// Normally called once per frame, but may be explicitly invoked.
// Do not call inside a command function!

char *Cbuf_Alloc(cmdbuf_t *buf, size_t len);

//===========================================================================

/*

Command execution takes a null terminated string, breaks it into tokens,
then searches for a command or variable that matches the first token.

*/

typedef struct genctx_s {
    const char  *partial;
    size_t length;
    int argnum;
    char **matches;
    int count, size;
    void *data;
    qboolean ignorecase;
    qboolean ignoredups;
} genctx_t;

typedef void (*xcommand_t)(void);
typedef void (*xcommandex_t)(cmdbuf_t *);
typedef size_t (*xmacro_t)(char *, size_t);
typedef void (*xcompleter_t)(struct genctx_s *, int);

typedef struct cmd_macro_s {
    struct cmd_macro_s  *next, *hashNext;
    const char          *name;
    xmacro_t            function;
} cmd_macro_t;

typedef struct {
    const char *sh, *lo, *help;
} cmd_option_t;

typedef struct cmdreg_s {
    const char      *name;
    xcommand_t      function;
    xcompleter_t    completer;
} cmdreg_t;

void Cmd_Init(void);

qboolean Cmd_Exists(const char *cmd_name);
// used by the cvar code to check for cvar / command name overlap

void Cmd_ExecTrigger(const char *string);

xcommand_t Cmd_FindFunction(const char *name);
cmd_macro_t *Cmd_FindMacro(const char *name);
xcompleter_t Cmd_FindCompleter(const char *name);

char *Cmd_AliasCommand(const char *name);
void Cmd_AliasSet(const char *name, const char *cmd);

void Cmd_Command_g(genctx_t *ctx);
void Cmd_Alias_g(genctx_t *ctx);
void Cmd_Macro_g(genctx_t *ctx);
void Cmd_Config_g(genctx_t *ctx);
void Cmd_Option_c(const cmd_option_t *opt, xgenerator_t g, genctx_t *ctx, int argnum);
// attempts to match a partial command for automatic command line completion
// returns NULL if nothing fits

void Cmd_TokenizeString(const char *text, qboolean macroExpand);
// Takes a null terminated string.  Does not need to be /n terminated.
// breaks the string up into arg tokens.

void Cmd_ExecuteCommand(cmdbuf_t *buf);
// execute already tokenized string

void Cmd_ExecuteString(cmdbuf_t *buf, const char *text);
// Parses a single line of text into arguments and tries to execute it
// as if it was typed at the console

qerror_t Cmd_ExecuteFile(const char *path, unsigned flags);
// execute a config file

char *Cmd_MacroExpandString(const char *text, qboolean aliasHack);

void Cmd_Register(const cmdreg_t *reg);
void Cmd_AddCommand(const char *cmd_name, xcommand_t function);
// called by the init functions of other parts of the program to
// register commands and functions to call for them.
// The cmd_name is referenced later, so it should not be in temp memory
// if function is NULL, the command will be forwarded to the server
// as a clc_stringcmd instead of executed locally
void Cmd_Deregister(const cmdreg_t *reg);
void Cmd_RemoveCommand(const char *cmd_name);

void Cmd_AddMacro(const char *name, xmacro_t function);

from_t  Cmd_From(void);
int     Cmd_Argc(void);
char    *Cmd_Argv(int arg);
char    *Cmd_Args(void);
char    *Cmd_RawArgs(void);
char    *Cmd_ArgsFrom(int from);
char    *Cmd_RawArgsFrom(int from);
size_t  Cmd_ArgsBuffer(char *buffer, size_t size);
size_t  Cmd_ArgvBuffer(int arg, char *buffer, size_t size);
size_t  Cmd_ArgOffset(int arg);
int     Cmd_FindArgForOffset(size_t offset);
size_t  Cmd_WhiteSpaceTail(void);
char    *Cmd_RawString(void);
void    Cmd_Shift(void);
// The functions that execute commands get their parameters with these
// functions. Cmd_Argv () will return an empty string, not a NULL
// if arg > argc, so string operations are always safe.

void Cmd_Alias_f(void);

void Cmd_WriteAliases(qhandle_t f);

#define EXEC_TRIGGER(var) \
    do { \
        if ((var)->string[0]) { \
            Cbuf_AddText(&cmd_buffer, (var)->string); \
        } \
    } while(0)

extern int cmd_optind;
extern char *cmd_optarg;
extern char *cmd_optopt;

int Cmd_ParseOptions(const cmd_option_t *opt);
void Cmd_PrintHelp(const cmd_option_t *opt);
void Cmd_PrintUsage(const cmd_option_t *opt, const char *suffix);
void Cmd_PrintHint(void);

const char *Cmd_Completer(const cmd_option_t *opt, const char *partial,
                          int argnum, int state, xgenerator_t generator);

/*
==============================================================

CVAR

==============================================================
*/

/*

cvar_t variables are used to hold scalar or string variables that can be changed or displayed at the console or prog code as well as accessed directly
in C code.

The user can access cvars from the console in three ways:
r_draworder            prints the current value
r_draworder 0        sets the current value to 0
set r_draworder 0    as above, but creates the cvar if not present
Cvars are restricted from having the same names as commands to keep this
interface from being ambiguous.
*/

#define CVAR_CHEAT          (1 << 5)  // can't be changed when connected
#define CVAR_PRIVATE        (1 << 6)  // never macro expanded or saved to config
#define CVAR_ROM            (1 << 7)  // can't be changed even from cmdline
#define CVAR_MODIFIED       (1 << 8)  // modified by user
#define CVAR_CUSTOM         (1 << 9)  // created by user
#define CVAR_WEAK           (1 << 10) // doesn't have value
#define CVAR_GAME           (1 << 11) // created by game library
#define CVAR_FILES          (1 << 13) // r_reload when changed
#define CVAR_REFRESH        (1 << 14) // vid_restart when changed
#define CVAR_SOUND          (1 << 15) // snd_restart when changed

#define CVAR_INFOMASK       (CVAR_USERINFO | CVAR_SERVERINFO)
#define CVAR_MODIFYMASK     (CVAR_INFOMASK | CVAR_FILES | CVAR_REFRESH | CVAR_SOUND)
#define CVAR_NOARCHIVEMASK  (CVAR_NOSET | CVAR_CHEAT | CVAR_PRIVATE | CVAR_ROM)
#define CVAR_EXTENDED_MASK  (~31)

extern cvar_t   *cvar_vars;
extern int      cvar_modified;

void Cvar_Init(void);

void Cvar_Variable_g(genctx_t *ctx);
void Cvar_Default_g(genctx_t *ctx);
// attempts to match a partial variable name for command line completion
// returns NULL if nothing fits

int Cvar_CountLatchedVars(void);
void Cvar_GetLatchedVars(void);
// any CVAR_LATCHED variables that have been set will now take effect

void Cvar_FixCheats(void);
// resets all cheating cvars to default

void Cvar_Command(cvar_t *v);
// called by Cmd_ExecuteString when Cmd_Argv(0) doesn't match a known
// command.  Returns qtrue if the command was a variable reference that
// was handled. (print or change)

void Cvar_WriteVariables(qhandle_t f, int mask, qboolean modified);
// appends lines containing "set variable value" for all variables
// with matching flags

size_t Cvar_BitInfo(char *info, int bit);

cvar_t *Cvar_FindVar(const char *var_name);
xgenerator_t Cvar_FindGenerator(const char *var_name);
qboolean Cvar_Exists(const char *name, qboolean weak);

cvar_t *Cvar_Get(const char *var_name, const char *value, int flags);
// creates the variable if it doesn't exist, or returns the existing one
// if it exists, the value will not be changed, but flags will be ORed in
// that allows variables to be unarchived without needing bitflags

cvar_t *Cvar_WeakGet(const char *var_name);
// creates weak variable without value

void Cvar_SetByVar(cvar_t *var, const char *value, from_t from);
// set by cvar pointer

cvar_t *Cvar_SetEx(const char *var_name, const char *value, from_t from);
// will create the variable if it doesn't exist
cvar_t *Cvar_Set(const char *var_name, const char *value);
// will set the variable even if NOSET or LATCH
cvar_t *Cvar_UserSet(const char *var_name, const char *value);
cvar_t *Cvar_FullSet(const char *var_name, const char *value,
                     int flags, from_t from);

#define Cvar_Reset(x) \
    Cvar_SetByVar(x, (x)->default_string, FROM_CODE)

void Cvar_SetValue(cvar_t *var, float value, from_t from);
void Cvar_SetInteger(cvar_t *var, int value, from_t from);
//void Cvar_SetHex(cvar_t *var, int value, from_t from);
// expands value to a string and calls Cvar_Set

int Cvar_ClampInteger(cvar_t *var, int min, int max);
float Cvar_ClampValue(cvar_t *var, float min, float max);

float Cvar_VariableValue(const char *var_name);
int Cvar_VariableInteger(const char *var_name);
// returns 0 if not defined or non numeric

char *Cvar_VariableString(const char *var_name);
// returns an empty string if not defined

#define Cvar_VariableStringBuffer(name, buffer, size) \
    Q_strlcpy(buffer, Cvar_VariableString(name), size)

void Cvar_Set_f(void);

/*
==============================================================

ZONE

==============================================================
*/

#define Z_Malloc(size)          Z_TagMalloc(size, TAG_GENERAL)
#define Z_Mallocz(size)         Z_TagMallocz(size, TAG_GENERAL)
#define Z_Reserve(size)         Z_TagReserve(size, TAG_GENERAL)
#define Z_CopyString(string)    Z_TagCopyString(string, TAG_GENERAL)

// memory tags to allow dynamic memory to be cleaned up
// game DLL has separate tag namespace starting at TAG_MAX
typedef enum memtag_e {
    TAG_FREE,       // should have never been set
    TAG_STATIC,

    TAG_GENERAL,
    TAG_CMD,
    TAG_CVAR,
    TAG_FILESYSTEM,
    TAG_RENDERER,
    TAG_UI,
    TAG_SERVER,
    TAG_MVD,
    TAG_SOUND,
    TAG_CMODEL,

    TAG_MAX
} memtag_t;

// may return pointer to static memory
char    *Cvar_CopyString(const char *in);

void    Z_Free(void *ptr);
void    *Z_TagMalloc(size_t size, memtag_t tag) q_malloc;
void    *Z_TagMallocz(size_t size, memtag_t tag) q_malloc;
char    *Z_TagCopyString(const char *in, memtag_t tag) q_malloc;
void    Z_FreeTags(memtag_t tag);
void    Z_LeakTest(memtag_t tag);
void    Z_Check(void);

void    Z_TagReserve(size_t size, memtag_t tag);
void    *Z_ReservedAlloc(size_t size) q_malloc;
void    *Z_ReservedAllocz(size_t size) q_malloc;
char    *Z_ReservedCopyString(const char *in) q_malloc;

/*
==============================================================

MATH

==============================================================
*/

#define NUMVERTEXNORMALS    162

extern const vec3_t bytedirs[NUMVERTEXNORMALS];

int DirToByte(const vec3_t dir);
//void ByteToDir(int index, vec3_t dir);

void SetPlaneType(cplane_t *plane);
void SetPlaneSignbits(cplane_t *plane);

#define BOX_INFRONT     1
#define BOX_BEHIND      2
#define BOX_INTERSECTS  3

int BoxOnPlaneSide(vec3_t emins, vec3_t emaxs, cplane_t *p);

static inline int BoxOnPlaneSideFast(vec3_t emins, vec3_t emaxs, cplane_t *p)
{
    // fast axial cases
    if (p->type < 3) {
        if (p->dist <= emins[p->type])
            return BOX_INFRONT;
        if (p->dist >= emaxs[p->type])
            return BOX_BEHIND;
        return BOX_INTERSECTS;
    }

    // slow generic case
    return BoxOnPlaneSide(emins, emaxs, p);
}

static inline vec_t PlaneDiffFast(vec3_t v, cplane_t *p)
{
    // fast axial cases
    if (p->type < 3) {
        return v[p->type] - p->dist;
    }

    // slow generic case
    return PlaneDiff(v, p);
}

/*
==============================================================

MISC

==============================================================
*/

#define MAXPRINTMSG     4096
#define MAXERRORMSG     1024

#define CONST_STR_LEN(x) x, x ? sizeof(x) - 1 : 0

typedef enum {
    COLOR_BLACK,
    COLOR_RED,
    COLOR_GREEN,
    COLOR_YELLOW,
    COLOR_BLUE,
    COLOR_CYAN,
    COLOR_MAGENTA,
    COLOR_WHITE,

    COLOR_ALT,
    COLOR_NONE
} color_index_t;

typedef struct {
    const char *name;
    void (* const func)(void);
} ucmd_t;

static inline const ucmd_t *Com_Find(const ucmd_t *u, const char *c)
{
    for (; u->name; u++) {
        if (!strcmp(c, u->name)) {
            return u;
        }
    }
    return NULL;
}

typedef struct string_entry_s {
    struct string_entry_s *next;
    char string[1];
} string_entry_t;

typedef void (*rdflush_t)(int target, char *buffer, size_t len);

void        Com_BeginRedirect(int target, char *buffer, size_t buffersize, rdflush_t flush);
void        Com_EndRedirect(void);

#ifdef _WIN32
void        Com_AbortFrame(void);
#endif

char        *Com_GetLastError(void);
void        Com_SetLastError(const char *msg);

void        Com_Quit(const char *reason, error_type_t type) q_noreturn;

void        Com_SetColor(color_index_t color);

byte        COM_BlockSequenceCRCByte(byte *base, size_t length, int sequence);

void        Com_Address_g(genctx_t *ctx);
void        Com_Generic_c(genctx_t *ctx, int argnum);
#if USE_CLIENT
void        Com_Color_g(genctx_t *ctx);
#endif
void        Com_PlayerToEntityState(const player_state_t *ps, entity_state_t *es);

#if USE_CLIENT || USE_MVD_CLIENT
qboolean    Com_ParseTimespec(const char *s, int *frames);
#endif

qboolean    Com_WildCmpEx(const char *filter, const char *string, int term, qboolean ignorecase);
#define Com_WildCmp(filter, string)  Com_WildCmpEx(filter, string, 0, qfalse)

unsigned    Com_HashString(const char *s, unsigned size);
unsigned    Com_HashStringLen(const char *s, size_t len, unsigned size);

qboolean    Prompt_AddMatch(genctx_t *ctx, const char *s);

size_t      Com_FormatTime(char *buffer, size_t size, time_t t);
size_t      Com_FormatTimeLong(char *buffer, size_t size, time_t t);
size_t      Com_TimeDiff(char *buffer, size_t size,
                         time_t *p, time_t now);
size_t      Com_TimeDiffLong(char *buffer, size_t size,
                             time_t *p, time_t now);

size_t      Com_Time_m(char *buffer, size_t size);
size_t      Com_Uptime_m(char *buffer, size_t size);
size_t      Com_UptimeLong_m(char *buffer, size_t size);

size_t      Com_FormatSize(char *dest, size_t destsize, off_t bytes);
size_t      Com_FormatSizeLong(char *dest, size_t destsize, off_t bytes);

uint32_t    Com_BlockChecksum(void *buffer, size_t len);

void        Com_PageInMemory(void *buffer, size_t size);

color_index_t Com_ParseColor(const char *s, color_index_t last);

#if USE_REF == REF_GL
unsigned    Com_ParseExtensionString(const char *s, const char *const extnames[]);
#endif

#ifndef _WIN32
void        Com_FlushLogs(void);
#endif

#if USE_CLIENT
#define Com_IsDedicated() (dedicated->integer != 0)
#else
#define Com_IsDedicated() 1
#endif

#ifdef _DEBUG
#define Com_DPrintf(...) \
    if (developer && developer->integer > 0) \
        Com_LPrintf(PRINT_DEVELOPER, __VA_ARGS__)
#define Com_DDPrintf(...) \
    if (developer && developer->integer > 1) \
        Com_LPrintf(PRINT_DEVELOPER, __VA_ARGS__)
#define Com_DDDPrintf(...) \
    if (developer && developer->integer > 2) \
        Com_LPrintf(PRINT_DEVELOPER, __VA_ARGS__)
#define Com_DDDDPrintf(...) \
    if (developer && developer->integer > 3) \
        Com_LPrintf(PRINT_DEVELOPER, __VA_ARGS__)
#else
#define Com_DPrintf(...)
#define Com_DDPrintf(...)
#define Com_DDDPrintf(...)
#define Com_DDDDPrintf(...)
#endif

#if USE_TESTS
void    Com_InitTests(void);
#endif

#ifdef _DEBUG
extern cvar_t   *developer;
#endif
extern cvar_t   *dedicated;
#if USE_CLIENT
extern cvar_t   *host_speeds;
#endif
extern cvar_t   *com_version;

#if USE_CLIENT
extern cvar_t   *cl_running;
extern cvar_t   *cl_paused;
#endif
extern cvar_t   *sv_running;
extern cvar_t   *sv_paused;
extern cvar_t   *com_timedemo;
extern cvar_t   *com_sleep;

extern cvar_t   *allow_download;
extern cvar_t   *allow_download_players;
extern cvar_t   *allow_download_models;
extern cvar_t   *allow_download_sounds;
extern cvar_t   *allow_download_maps;
extern cvar_t   *allow_download_textures;
extern cvar_t   *allow_download_pics;
extern cvar_t   *allow_download_others;

extern cvar_t   *rcon_password;

#if USE_CLIENT
// host_speeds times
extern unsigned     time_before_game;
extern unsigned     time_after_game;
extern unsigned     time_before_ref;
extern unsigned     time_after_ref;
#endif

extern const char   com_version_string[];

extern unsigned     com_eventTime; // system time of the last event
extern unsigned     com_localTime; // milliseconds since Q2 startup
extern unsigned     com_framenum;
extern qboolean     com_initialized;
extern time_t       com_startTime;

extern qhandle_t    com_logFile;

extern const char *const colorNames[10];

void Qcommon_Init(int argc, char **argv);
void Qcommon_Frame(void);
void Qcommon_Shutdown(void);