qcommon.h

Go to the documentation of this file.

/*
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 "../game/q_shared.h"
 
 
#define VERSION     3.21
 
#define BASEDIRNAME "baseq2"
 
#ifdef WIN32
 
#ifdef NDEBUG
#define BUILDSTRING "Win32"
#else
#define BUILDSTRING "Win32 DEBUG"
#endif
 
#ifdef _M_IX86
#define CPUSTRING   "x86"
#elif defined _M_X64
#define CPUSTRING   "x64"
#elif defined _M_ALPHA
#define CPUSTRING   "AXP"
#endif
 
#elif defined __linux__
 
#ifdef NDEBUG
#define BUILDSTRING "Linux"
#else
#define BUILDSTRING "Linux DEBUG"
#endif
 
#ifdef __i386__
#define CPUSTRING "i386"
#elif defined __LP64__
#define CPUSTRING   "x64"
#elif defined __alpha__
#define CPUSTRING "axp"
#else
#define CPUSTRING "Unknown"
#endif
 
#elif defined __APPLE__
 
#ifdef NDEBUG
#define BUILDSTRING "MacOS"
#else
#define BUILDSTRING "MacOS DEBUG"
#endif
#define CPUSTRING "x64"
 
#elif defined __sun__
 
#define BUILDSTRING "Solaris"
 
#ifdef __i386__
#define CPUSTRING "i386"
#else
#define CPUSTRING "sparc"
#endif
 
#else   // !WIN32
 
#define BUILDSTRING "NON-WIN32"
#define CPUSTRING   "NON-WIN32"
 
#endif
 
//============================================================================
 
typedef struct sizebuf_s
{
    qboolean    allowoverflow;  // if false, do a Com_Error
    qboolean    overflowed;     // set to true if the buffer size failed
    byte    *data;
    int     maxsize;
    int     cursize;
    int     readcount;
} sizebuf_t;
 
void SZ_Init (sizebuf_t *buf, byte *data, int length);
void SZ_Clear (sizebuf_t *buf);
void *SZ_GetSpace (sizebuf_t *buf, int length);
void SZ_Write (sizebuf_t *buf, void *data, int length);
void SZ_Print (sizebuf_t *buf, char *data); // strcats onto the sizebuf
 
//============================================================================
 
struct usercmd_s;
struct entity_state_s;
 
void MSG_WriteChar (sizebuf_t *sb, int c);
void MSG_WriteByte (sizebuf_t *sb, int c);
void MSG_WriteShort (sizebuf_t *sb, int c);
void MSG_WriteLong (sizebuf_t *sb, int c);
void MSG_WriteFloat (sizebuf_t *sb, float f);
void MSG_WriteString (sizebuf_t *sb, char *s);
void MSG_WriteCoord (sizebuf_t *sb, float f);
void MSG_WritePos (sizebuf_t *sb, vec3_t pos);
void MSG_WriteAngle (sizebuf_t *sb, float f);
void MSG_WriteAngle16 (sizebuf_t *sb, float f);
void MSG_WriteDeltaUsercmd (sizebuf_t *sb, struct usercmd_s *from, struct usercmd_s *cmd);
void MSG_WriteDeltaEntity (struct entity_state_s *from, struct entity_state_s *to, sizebuf_t *msg, qboolean force, qboolean newentity);
void MSG_WriteDir (sizebuf_t *sb, vec3_t vector);
 
 
void    MSG_BeginReading (sizebuf_t *sb);
 
int     MSG_ReadChar (sizebuf_t *sb);
int     MSG_ReadByte (sizebuf_t *sb);
int     MSG_ReadShort (sizebuf_t *sb);
int     MSG_ReadLong (sizebuf_t *sb);
float   MSG_ReadFloat (sizebuf_t *sb);
char    *MSG_ReadString (sizebuf_t *sb);
char    *MSG_ReadStringLine (sizebuf_t *sb);
 
float   MSG_ReadCoord (sizebuf_t *sb);
void    MSG_ReadPos (sizebuf_t *sb, vec3_t pos);
float   MSG_ReadAngle (sizebuf_t *sb);
float   MSG_ReadAngle16 (sizebuf_t *sb);
void    MSG_ReadDeltaUsercmd (sizebuf_t *sb, struct usercmd_s *from, struct usercmd_s *cmd);
 
void    MSG_ReadDir (sizebuf_t *sb, vec3_t vector);
 
void    MSG_ReadData (sizebuf_t *sb, void *buffer, int size);
 
//============================================================================
 
extern  qboolean        bigendien;
 
extern  short   BigShort (short l);
extern  short   LittleShort (short l);
extern  int     BigLong (int l);
extern  int     LittleLong (int l);
extern  float   BigFloat (float l);
extern  float   LittleFloat (float l);
 
//============================================================================
 
 
int COM_Argc (void);
char *COM_Argv (int arg);   // range and null checked
void COM_ClearArgv (int arg);
int COM_CheckParm (char *parm);
void COM_AddParm (char *parm);
 
void COM_Init (void);
void COM_InitArgv (int argc, char **argv);
 
char *CopyString (char *in);
 
//============================================================================
 
void Info_Print (char *s);
 
 
/* crc.h */
 
void CRC_Init(unsigned short *crcvalue);
void CRC_ProcessByte(unsigned short *crcvalue, byte data);
unsigned short CRC_Value(unsigned short crcvalue);
unsigned short CRC_Block (byte *start, int count);
 
 
 
/*
==============================================================
 
PROTOCOL
 
==============================================================
*/
 
// protocol.h -- communications protocols
 
#define PROTOCOL_VERSION    34
 
//=========================================
 
#define PORT_MASTER 27900
#define PORT_CLIENT 27901
#define PORT_SERVER 27910
 
//=========================================
 
#define UPDATE_BACKUP   16  // copies of entity_state_t to keep buffered
                            // must be power of two
#define UPDATE_MASK     (UPDATE_BACKUP-1)
 
 
 
//==================
// the svc_strings[] array in cl_parse.c should mirror this
//==================
 
//
// server to client
//
enum svc_ops_e
{
    svc_bad,
 
    // these ops are known to the game dll
    svc_muzzleflash,
    svc_muzzleflash2,
    svc_temp_entity,
    svc_layout,
    svc_inventory,
 
    // the rest are private to the client and server
    svc_nop,
    svc_disconnect,
    svc_reconnect,
    svc_sound,                  // <see code>
    svc_print,                  // [byte] id [string] null terminated string
    svc_stufftext,              // [string] stuffed into client's console buffer, should be \n terminated
    svc_serverdata,             // [long] protocol ...
    svc_configstring,           // [short] [string]
    svc_spawnbaseline,      
    svc_centerprint,            // [string] to put in center of the screen
    svc_download,               // [short] size [size bytes]
    svc_playerinfo,             // variable
    svc_packetentities,         // [...]
    svc_deltapacketentities,    // [...]
    svc_frame
};
 
//==============================================
 
//
// client to server
//
enum clc_ops_e
{
    clc_bad,
    clc_nop,        
    clc_move,               // [[usercmd_t]
    clc_userinfo,           // [[userinfo string]
    clc_stringcmd           // [string] message
};
 
//==============================================
 
// plyer_state_t communication
 
#define PS_M_TYPE           (1<<0)
#define PS_M_ORIGIN         (1<<1)
#define PS_M_VELOCITY       (1<<2)
#define PS_M_TIME           (1<<3)
#define PS_M_FLAGS          (1<<4)
#define PS_M_GRAVITY        (1<<5)
#define PS_M_DELTA_ANGLES   (1<<6)
 
#define PS_VIEWOFFSET       (1<<7)
#define PS_VIEWANGLES       (1<<8)
#define PS_KICKANGLES       (1<<9)
#define PS_BLEND            (1<<10)
#define PS_FOV              (1<<11)
#define PS_WEAPONINDEX      (1<<12)
#define PS_WEAPONFRAME      (1<<13)
#define PS_RDFLAGS          (1<<14)
 
//==============================================
 
// user_cmd_t communication
 
// ms and light always sent, the others are optional
#define CM_ANGLE1   (1<<0)
#define CM_ANGLE2   (1<<1)
#define CM_ANGLE3   (1<<2)
#define CM_FORWARD  (1<<3)
#define CM_SIDE     (1<<4)
#define CM_UP       (1<<5)
#define CM_BUTTONS  (1<<6)
#define CM_IMPULSE  (1<<7)
 
//==============================================
 
// a sound without an ent or pos will be a local only sound
#define SND_VOLUME      (1<<0)      // a byte
#define SND_ATTENUATION (1<<1)      // a byte
#define SND_POS         (1<<2)      // three coordinates
#define SND_ENT         (1<<3)      // a short 0-2: channel, 3-12: entity
#define SND_OFFSET      (1<<4)      // a byte, msec offset from frame start
 
#define DEFAULT_SOUND_PACKET_VOLUME 1.0
#define DEFAULT_SOUND_PACKET_ATTENUATION 1.0
 
//==============================================
 
// entity_state_t communication
 
// try to pack the common update flags into the first byte
#define U_ORIGIN1   (1<<0)
#define U_ORIGIN2   (1<<1)
#define U_ANGLE2    (1<<2)
#define U_ANGLE3    (1<<3)
#define U_FRAME8    (1<<4)      // frame is a byte
#define U_EVENT     (1<<5)
#define U_REMOVE    (1<<6)      // REMOVE this entity, don't add it
#define U_MOREBITS1 (1<<7)      // read one additional byte
 
// second byte
#define U_NUMBER16  (1<<8)      // NUMBER8 is implicit if not set
#define U_ORIGIN3   (1<<9)
#define U_ANGLE1    (1<<10)
#define U_MODEL     (1<<11)
#define U_RENDERFX8 (1<<12)     // fullbright, etc
#define U_EFFECTS8  (1<<14)     // autorotate, trails, etc
#define U_MOREBITS2 (1<<15)     // read one additional byte
 
// third byte
#define U_SKIN8     (1<<16)
#define U_FRAME16   (1<<17)     // frame is a short
#define U_RENDERFX16 (1<<18)    // 8 + 16 = 32
#define U_EFFECTS16 (1<<19)     // 8 + 16 = 32
#define U_MODEL2    (1<<20)     // weapons, flags, etc
#define U_MODEL3    (1<<21)
#define U_MODEL4    (1<<22)
#define U_MOREBITS3 (1<<23)     // read one additional byte
 
// fourth byte
#define U_OLDORIGIN (1<<24)     // FIXME: get rid of this
#define U_SKIN16    (1<<25)
#define U_SOUND     (1<<26)
#define U_SOLID     (1<<27)
 
 
/*
==============================================================
 
CMD
 
Command text buffering and command execution
 
==============================================================
*/
 
/*
 
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 ();
 
*/
 
#define EXEC_NOW    0       // don't return until completed
#define EXEC_INSERT 1       // insert at current position, but don't run yet
#define EXEC_APPEND 2       // add to end of the command buffer
 
void Cbuf_Init (void);
// allocates an initial text buffer that will grow as needed
 
void Cbuf_AddText (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 (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_ExecuteText (int exec_when, char *text);
// this can be used in place of either Cbuf_AddText or Cbuf_InsertText
 
void Cbuf_AddEarlyCommands (qboolean clear);
// adds all the +set commands from the command line
 
qboolean Cbuf_AddLateCommands (void);
// adds all the remaining + commands from the command line
// Returns true if any late commands were added, which
// will keep the demoloop from immediately starting
 
void Cbuf_Execute (void);
// 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!
 
void Cbuf_CopyToDefer (void);
void Cbuf_InsertFromDefer (void);
// These two functions are used to defer any pending commands while a map
// is being loaded
 
//===========================================================================
 
/*
 
Command execution takes a null terminated string, breaks it into tokens,
then searches for a command or variable that matches the first token.
 
*/
 
typedef void (*xcommand_t) (void);
 
void    Cmd_Init (void);
 
void    Cmd_AddCommand (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_RemoveCommand (char *cmd_name);
 
qboolean Cmd_Exists (char *cmd_name);
// used by the cvar code to check for cvar / command name overlap
 
char    *Cmd_CompleteCommand (char *partial);
// attempts to match a partial command for automatic command line completion
// returns NULL if nothing fits
 
int     Cmd_Argc (void);
char    *Cmd_Argv (int arg);
char    *Cmd_Args (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_TokenizeString (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_ExecuteString (char *text);
// Parses a single line of text into arguments and tries to execute it
// as if it was typed at the console
 
void    Cmd_ForwardToServer (void);
// adds the current command line as a clc_stringcmd to the client message.
// things like godmode, noclip, etc, are commands directed to the server,
// so when they are typed in at the console, they will need to be forwarded.
 
 
/*
==============================================================
 
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.
*/
 
extern  cvar_t  *cvar_vars;
 
cvar_t *Cvar_Get (char *var_name, 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_Set (char *var_name, char *value);
// will create the variable if it doesn't exist
 
cvar_t *Cvar_ForceSet (char *var_name, char *value);
// will set the variable even if NOSET or LATCH
 
cvar_t  *Cvar_FullSet (char *var_name, char *value, int flags);
 
void    Cvar_SetValue (char *var_name, float value);
// expands value to a string and calls Cvar_Set
 
float   Cvar_VariableValue (char *var_name);
// returns 0 if not defined or non numeric
 
char    *Cvar_VariableString (char *var_name);
// returns an empty string if not defined
 
char    *Cvar_CompleteVariable (char *partial);
// attempts to match a partial variable name for command line completion
// returns NULL if nothing fits
 
void    Cvar_GetLatchedVars (void);
// any CVAR_LATCHED variables that have been set will now take effect
 
qboolean Cvar_Command (void);
// called by Cmd_ExecuteString when Cmd_Argv(0) doesn't match a known
// command.  Returns true if the command was a variable reference that
// was handled. (print or change)
 
void    Cvar_WriteVariables (char *path);
// appends lines containing "set variable value" for all variables
// with the archive flag set to true.
 
void    Cvar_Init (void);
 
char    *Cvar_Userinfo (void);
// returns an info string containing all the CVAR_USERINFO cvars
 
char    *Cvar_Serverinfo (void);
// returns an info string containing all the CVAR_SERVERINFO cvars
 
extern  qboolean    userinfo_modified;
// this is set each time a CVAR_USERINFO variable is changed
// so that the client knows to send it to the server
 
/*
==============================================================
 
NET
 
==============================================================
*/
 
// net.h -- quake's interface to the networking layer
 
#define PORT_ANY    -1
 
#define MAX_MSGLEN      1400        // max length of a message
#define PACKET_HEADER   10          // two ints and a short
 
typedef enum {NA_LOOPBACK, NA_BROADCAST, NA_IP, NA_IPX, NA_BROADCAST_IPX} netadrtype_t;
 
typedef enum {NS_CLIENT, NS_SERVER} netsrc_t;
 
typedef struct
{
    netadrtype_t    type;
 
    byte    ip[4];
    byte    ipx[10];
 
    unsigned short  port;
} netadr_t;
 
void        NET_Init (void);
void        NET_Shutdown (void);
 
void        NET_Config (qboolean multiplayer);
 
qboolean    NET_GetPacket (netsrc_t sock, netadr_t *net_from, sizebuf_t *net_message);
void        NET_SendPacket (netsrc_t sock, int length, void *data, netadr_t to);
 
qboolean    NET_CompareAdr (netadr_t a, netadr_t b);
qboolean    NET_CompareBaseAdr (netadr_t a, netadr_t b);
qboolean    NET_IsLocalAddress (netadr_t adr);
char        *NET_AdrToString (netadr_t a);
qboolean    NET_StringToAdr (char *s, netadr_t *a);
void        NET_Sleep(int msec);
 
//============================================================================
 
#define OLD_AVG     0.99        // total = oldtotal*OLD_AVG + new*(1-OLD_AVG)
 
#define MAX_LATENT  32
 
typedef struct
{
    qboolean    fatal_error;
 
    netsrc_t    sock;
 
    int         dropped;            // between last packet and previous
 
    int         last_received;      // for timeouts
    int         last_sent;          // for retransmits
 
    netadr_t    remote_address;
    int         qport;              // qport value to write when transmitting
 
// sequencing variables
    int         incoming_sequence;
    int         incoming_acknowledged;
    int         incoming_reliable_acknowledged; // single bit
 
    int         incoming_reliable_sequence;     // single bit, maintained local
 
    int         outgoing_sequence;
    int         reliable_sequence;          // single bit
    int         last_reliable_sequence;     // sequence number of last send
 
// reliable staging and holding areas
    sizebuf_t   message;        // writing buffer to send to server
    byte        message_buf[MAX_MSGLEN-16];     // leave space for header
 
// message is copied to this buffer when it is first transfered
    int         reliable_length;
    byte        reliable_buf[MAX_MSGLEN-16];    // unacked reliable message
} netchan_t;
 
extern  netadr_t    net_from;
extern  sizebuf_t   net_message;
extern  byte        net_message_buffer[MAX_MSGLEN];
 
 
void Netchan_Init (void);
void Netchan_Setup (netsrc_t sock, netchan_t *chan, netadr_t adr, int qport);
 
qboolean Netchan_NeedReliable (netchan_t *chan);
void Netchan_Transmit (netchan_t *chan, int length, byte *data);
void Netchan_OutOfBand (int net_socket, netadr_t adr, int length, byte *data);
void Netchan_OutOfBandPrint (int net_socket, netadr_t adr, char *format, ...);
qboolean Netchan_Process (netchan_t *chan, sizebuf_t *msg);
 
qboolean Netchan_CanReliable (netchan_t *chan);
 
 
/*
==============================================================
 
CMODEL
 
==============================================================
*/
 
 
#include "../qcommon/qfiles.h"
 
cmodel_t    *CM_LoadMap (char *name, qboolean clientload, unsigned *checksum);
cmodel_t    *CM_InlineModel (char *name);   // *1, *2, etc
 
int         CM_NumClusters (void);
int         CM_NumInlineModels (void);
char        *CM_EntityString (void);
 
// creates a clipping hull for an arbitrary box
int         CM_HeadnodeForBox (vec3_t mins, vec3_t maxs);
 
 
// returns an ORed contents mask
int         CM_PointContents (vec3_t p, int headnode);
int         CM_TransformedPointContents (vec3_t p, int headnode, vec3_t origin, vec3_t angles);
 
trace_t     CM_BoxTrace (vec3_t start, vec3_t end,
                          vec3_t mins, vec3_t maxs,
                          int headnode, int brushmask);
trace_t     CM_TransformedBoxTrace (vec3_t start, vec3_t end,
                          vec3_t mins, vec3_t maxs,
                          int headnode, int brushmask,
                          vec3_t origin, vec3_t angles);
 
byte        *CM_ClusterPVS (int cluster);
byte        *CM_ClusterPHS (int cluster);
 
int         CM_PointLeafnum (vec3_t p);
 
// call with topnode set to the headnode, returns with topnode
// set to the first node that splits the box
int         CM_BoxLeafnums (vec3_t mins, vec3_t maxs, int *list,
                            int listsize, int *topnode);
 
int         CM_LeafContents (int leafnum);
int         CM_LeafCluster (int leafnum);
int         CM_LeafArea (int leafnum);
 
void        CM_SetAreaPortalState (int portalnum, qboolean open);
qboolean    CM_AreasConnected (int area1, int area2);
 
int         CM_WriteAreaBits (byte *buffer, int area);
qboolean    CM_HeadnodeVisible (int headnode, byte *visbits);
 
void        CM_WritePortalState (FILE *f);
void        CM_ReadPortalState (FILE *f);
 
/*
==============================================================
 
PLAYER MOVEMENT CODE
 
Common between server and client so prediction matches
 
==============================================================
*/
 
extern float pm_airaccelerate;
 
void Pmove (pmove_t *pmove);
 
/*
==============================================================
 
FILESYSTEM
 
==============================================================
*/
 
void    FS_InitFilesystem (void);
void    FS_SetGamedir (char *dir);
char    *FS_Gamedir (void);
char    *FS_NextPath (char *prevpath);
void    FS_ExecAutoexec (void);
 
int     FS_FOpenFile (char *filename, FILE **file);
void    FS_FCloseFile (FILE *f);
// note: this can't be called from another DLL, due to MS libc issues
 
int     FS_LoadFile (char *path, void **buffer);
// a null buffer will just return the file length without loading
// a -1 length is not present
 
void    FS_Read (void *buffer, int len, FILE *f);
// properly handles partial reads
 
void    FS_FreeFile (void *buffer);
 
void    FS_CreatePath (char *path);
 
 
/*
==============================================================
 
MISC
 
==============================================================
*/
 
 
#define ERR_FATAL   0       // exit the entire game with a popup window
#define ERR_DROP    1       // print to console and disconnect from game
#define ERR_QUIT    2       // not an error, just a normal exit
 
#define EXEC_NOW    0       // don't return until completed
#define EXEC_INSERT 1       // insert at current position, but don't run yet
#define EXEC_APPEND 2       // add to end of the command buffer
 
#define PRINT_ALL       0
#define PRINT_DEVELOPER 1   // only print when "developer 1"
 
void        Com_BeginRedirect (int target, char *buffer, int buffersize, void (*flush));
void        Com_EndRedirect (void);
void        Com_Printf (char *fmt, ...);
void        Com_DPrintf (char *fmt, ...);
void        Com_Error (int code, char *fmt, ...);
void        Com_Quit (void);
 
int         Com_ServerState (void);     // this should have just been a cvar...
void        Com_SetServerState (int state);
 
unsigned    Com_BlockChecksum (void *buffer, int length);
byte        COM_BlockSequenceCRCByte (byte *base, int length, int sequence);
 
float   frand(void);    // 0 ti 1
float   crand(void);    // -1 to 1
 
extern  cvar_t  *developer;
extern  cvar_t  *dedicated;
extern  cvar_t  *host_speeds;
extern  cvar_t  *log_stats;
 
extern  FILE *log_stats_file;
 
// host_speeds times
extern  int     time_before_game;
extern  int     time_after_game;
extern  int     time_before_ref;
extern  int     time_after_ref;
 
void Z_Free (void *ptr);
void *Z_Malloc (int size);          // returns 0 filled memory
void *Z_TagMalloc (int size, int tag);
void Z_FreeTags (int tag);
 
void Qcommon_Init (int argc, char **argv);
void Qcommon_Frame (int msec);
void Qcommon_Shutdown (void);
 
#define NUMVERTEXNORMALS    162
extern  vec3_t  bytedirs[NUMVERTEXNORMALS];
 
// this is in the client code, but can be used for debugging from server
void SCR_DebugGraph (float value, int color);
 
 
/*
==============================================================
 
NON-PORTABLE SYSTEM SERVICES
 
==============================================================
*/
 
void    Sys_Init (void);
 
void    Sys_AppActivate (void);
 
void    Sys_UnloadGame (void);
void    *Sys_GetGameAPI (void *parms);
// loads the game dll and calls the api init function
 
char    *Sys_ConsoleInput (void);
void    Sys_ConsoleOutput (char *string);
void    Sys_SendKeyEvents (void);
void    Sys_Error (char *error, ...);
void    Sys_Quit (void);
char    *Sys_GetClipboardData( void );
void    Sys_CopyProtect (void);
 
/*
==============================================================
 
CLIENT / SERVER SYSTEMS
 
==============================================================
*/
 
void CL_Init (void);
void CL_Drop (void);
void CL_Shutdown (void);
void CL_Frame (int msec);
void Con_Print (char *text);
void SCR_BeginLoadingPlaque (void);
 
void SV_Init (void);
void SV_Shutdown (char *finalmsg, qboolean reconnect);
void SV_Frame (int msec);