yquake2/yquake2remaster
0
0
Fork 0
mirror of https://github.com/yquake2/yquake2remaster.git synced 2025-03-31 23:41:25 +00:00
Code Issues Projects Releases Packages Wiki Activity

Cleanup and reformat.

Browse source
This commit is contained in:
Yamagi Burmeister 2012-06-07 15:40:58 +02:00
parent ac6748e7d2
commit 9ad40b2a17
10 changed files with 1764 additions and 1210 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

90
src/common/crc.c
View file

@ -28,68 +28,74 @@
#include "header/common.h"
#define CRC_INIT_VALUE 0xffff
#define CRC_XOR_VALUE 0x0000
#define CRC_INIT_VALUE 0xffff
#define CRC_XOR_VALUE 0x0000
static unsigned short crctable[256] =
{
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
static unsigned short crctable[256] = {
0x0000, 0x1021, 0x2042, 0x3063, 0x4084, 0x50a5, 0x60c6, 0x70e7,
0x8108, 0x9129, 0xa14a, 0xb16b, 0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
0x1231, 0x0210, 0x3273, 0x2252, 0x52b5, 0x4294, 0x72f7, 0x62d6,
0x9339, 0x8318, 0xb37b, 0xa35a, 0xd3bd, 0xc39c, 0xf3ff, 0xe3de,
0x2462, 0x3443, 0x0420, 0x1401, 0x64e6, 0x74c7, 0x44a4, 0x5485,
0xa56a, 0xb54b, 0x8528, 0x9509, 0xe5ee, 0xf5cf, 0xc5ac, 0xd58d,
0x3653, 0x2672, 0x1611, 0x0630, 0x76d7, 0x66f6, 0x5695, 0x46b4,
0xb75b, 0xa77a, 0x9719, 0x8738, 0xf7df, 0xe7fe, 0xd79d, 0xc7bc,
0x48c4, 0x58e5, 0x6886, 0x78a7, 0x0840, 0x1861, 0x2802, 0x3823,
0xc9cc, 0xd9ed, 0xe98e, 0xf9af, 0x8948, 0x9969, 0xa90a, 0xb92b,
0x5af5, 0x4ad4, 0x7ab7, 0x6a96, 0x1a71, 0x0a50, 0x3a33, 0x2a12,
0xdbfd, 0xcbdc, 0xfbbf, 0xeb9e, 0x9b79, 0x8b58, 0xbb3b, 0xab1a,
0x6ca6, 0x7c87, 0x4ce4, 0x5cc5, 0x2c22, 0x3c03, 0x0c60, 0x1c41,
0xedae, 0xfd8f, 0xcdec, 0xddcd, 0xad2a, 0xbd0b, 0x8d68, 0x9d49,
0x7e97, 0x6eb6, 0x5ed5, 0x4ef4, 0x3e13, 0x2e32, 0x1e51, 0x0e70,
0xff9f, 0xefbe, 0xdfdd, 0xcffc, 0xbf1b, 0xaf3a, 0x9f59, 0x8f78,
0x9188, 0x81a9, 0xb1ca, 0xa1eb, 0xd10c, 0xc12d, 0xf14e, 0xe16f,
0x1080, 0x00a1, 0x30c2, 0x20e3, 0x5004, 0x4025, 0x7046, 0x6067,
0x83b9, 0x9398, 0xa3fb, 0xb3da, 0xc33d, 0xd31c, 0xe37f, 0xf35e,
0x02b1, 0x1290, 0x22f3, 0x32d2, 0x4235, 0x5214, 0x6277, 0x7256,
0xb5ea, 0xa5cb, 0x95a8, 0x8589, 0xf56e, 0xe54f, 0xd52c, 0xc50d,
0x34e2, 0x24c3, 0x14a0, 0x0481, 0x7466, 0x6447, 0x5424, 0x4405,
0xa7db, 0xb7fa, 0x8799, 0x97b8, 0xe75f, 0xf77e, 0xc71d, 0xd73c,
0x26d3, 0x36f2, 0x0691, 0x16b0, 0x6657, 0x7676, 0x4615, 0x5634,
0xd94c, 0xc96d, 0xf90e, 0xe92f, 0x99c8, 0x89e9, 0xb98a, 0xa9ab,
0x5844, 0x4865, 0x7806, 0x6827, 0x18c0, 0x08e1, 0x3882, 0x28a3,
0xcb7d, 0xdb5c, 0xeb3f, 0xfb1e, 0x8bf9, 0x9bd8, 0xabbb, 0xbb9a,
0x4a75, 0x5a54, 0x6a37, 0x7a16, 0x0af1, 0x1ad0, 0x2ab3, 0x3a92,
0xfd2e, 0xed0f, 0xdd6c, 0xcd4d, 0xbdaa, 0xad8b, 0x9de8, 0x8dc9,
0x7c26, 0x6c07, 0x5c64, 0x4c45, 0x3ca2, 0x2c83, 0x1ce0, 0x0cc1,
0xef1f, 0xff3e, 0xcf5d, 0xdf7c, 0xaf9b, 0xbfba, 0x8fd9, 0x9ff8,
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};
void CRC_Init(unsigned short *crcvalue)
void
CRC_Init(unsigned short *crcvalue)
{
*crcvalue = CRC_INIT_VALUE;
}
void CRC_ProcessByte(unsigned short *crcvalue, byte data)
void
CRC_ProcessByte(unsigned short *crcvalue, byte data)
{
*crcvalue = (*crcvalue << 8) ^ crctable[(*crcvalue >> 8) ^ data];
}
unsigned short CRC_Value(unsigned short crcvalue)
unsigned short
CRC_Value(unsigned short crcvalue)
{
return crcvalue ^ CRC_XOR_VALUE;
}
unsigned short CRC_Block (byte *start, int count)
unsigned short
CRC_Block(byte *start, int count)
{
unsigned short crc;
unsigned short crc;
CRC_Init (&crc);
CRC_Init(&crc);
while (count--)
{
crc = (crc << 8) ^ crctable[(crc >> 8) ^ *start++];
}
return crc;
}

315
src/common/cvar.c
View file

@ -19,83 +19,112 @@
*
* =======================================================================
*
* The Quake II CVAR subsystem. Implements dynamic variable tracking.
* The Quake II CVAR subsystem. Implements dynamic variable handling.
*
* =======================================================================
*/
#include "header/common.h"
cvar_t *cvar_vars;
cvar_t *cvar_vars;
static qboolean Cvar_InfoValidate (char *s)
static qboolean
Cvar_InfoValidate(char *s)
{
if (strstr (s, "\\"))
if (strstr(s, "\\"))
{
return false;
}
if (strstr (s, "\""))
if (strstr(s, "\""))
{
return false;
}
if (strstr (s, ";"))
if (strstr(s, ";"))
{
return false;
}
return true;
}
static cvar_t *Cvar_FindVar (const char *var_name)
static cvar_t *
Cvar_FindVar(const char *var_name)
{
cvar_t *var;
cvar_t *var;
for (var=cvar_vars ; var ; var=var->next)
if (!strcmp (var_name, var->name))
for (var = cvar_vars; var; var = var->next)
{
if (!strcmp(var_name, var->name))
{
return var;
}
}
return NULL;
}
float Cvar_VariableValue (char *var_name)
float
Cvar_VariableValue(char *var_name)
{
cvar_t *var;
cvar_t *var;
var = Cvar_FindVar (var_name);
var = Cvar_FindVar(var_name);
if (!var)
{
return 0;
}
return strtod(var->string, (char **)NULL);
}
const char *Cvar_VariableString (const char *var_name)
const char *
Cvar_VariableString(const char *var_name)
{
cvar_t *var;
var = Cvar_FindVar (var_name);
var = Cvar_FindVar(var_name);
if (!var)
{
return "";
}
return var->string;
}
char *Cvar_CompleteVariable (char *partial)
char *
Cvar_CompleteVariable(char *partial)
{
cvar_t *cvar;
int len;
cvar_t *cvar;
int len;
len = (int)strlen(partial);
if (!len)
{
return NULL;
}
/* check exact match */
for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
if (!strcmp (partial,cvar->name))
for (cvar = cvar_vars; cvar; cvar = cvar->next)
{
if (!strcmp(partial, cvar->name))
{
return cvar->name;
}
}
/* check partial match */
for (cvar=cvar_vars ; cvar ; cvar=cvar->next)
if (!strncmp (partial,cvar->name, len))
for (cvar = cvar_vars; cvar; cvar = cvar->next)
{
if (!strncmp(partial, cvar->name, len))
{
return cvar->name;
}
}
return NULL;
}
@ -104,20 +133,21 @@ char *Cvar_CompleteVariable (char *partial)
* If the variable already exists, the value will not be set
* The flags will be or'ed in if the variable exists.
*/
cvar_t *Cvar_Get (char *var_name, char *var_value, int flags)
cvar_t *
Cvar_Get(char *var_name, char *var_value, int flags)
{
cvar_t *var;
cvar_t *var;
if (flags & (CVAR_USERINFO | CVAR_SERVERINFO))
{
if (!Cvar_InfoValidate (var_name))
if (!Cvar_InfoValidate(var_name))
{
Com_Printf("invalid info cvar name\n");
return NULL;
}
}
var = Cvar_FindVar (var_name);
var = Cvar_FindVar(var_name);
if (var)
{
@ -126,20 +156,22 @@ cvar_t *Cvar_Get (char *var_name, char *var_value, int flags)
}
if (!var_value)
{
return NULL;
}
if (flags & (CVAR_USERINFO | CVAR_SERVERINFO))
{
if (!Cvar_InfoValidate (var_value))
if (!Cvar_InfoValidate(var_value))
{
Com_Printf("invalid info cvar value\n");
return NULL;
}
}
var = Z_Malloc (sizeof(*var));
var->name = CopyString (var_name);
var->string = CopyString (var_value);
var = Z_Malloc(sizeof(*var));
var->name = CopyString(var_name);
var->string = CopyString(var_value);
var->modified = true;
var->value = strtod(var->string, (char **)NULL);
@ -152,20 +184,21 @@ cvar_t *Cvar_Get (char *var_name, char *var_value, int flags)
return var;
}
cvar_t *Cvar_Set2 (char *var_name, char *value, qboolean force)
cvar_t *
Cvar_Set2(char *var_name, char *value, qboolean force)
{
cvar_t *var;
cvar_t *var;
var = Cvar_FindVar (var_name);
var = Cvar_FindVar(var_name);
if (!var)
{
return Cvar_Get (var_name, value, 0);
return Cvar_Get(var_name, value, 0);
}
if (var->flags & (CVAR_USERINFO | CVAR_SERVERINFO))
{
if (!Cvar_InfoValidate (value))
if (!Cvar_InfoValidate(value))
{
Com_Printf("invalid info cvar value\n");
return var;
@ -176,7 +209,7 @@ cvar_t *Cvar_Set2 (char *var_name, char *value, qboolean force)
{
if (var->flags & CVAR_NOSET)
{
Com_Printf ("%s is write protected.\n", var_name);
Com_Printf("%s is write protected.\n", var_name);
return var;
}
@ -185,20 +218,24 @@ cvar_t *Cvar_Set2 (char *var_name, char *value, qboolean force)
if (var->latched_string)
{
if (strcmp(value, var->latched_string) == 0)
{
return var;
}
Z_Free (var->latched_string);
Z_Free(var->latched_string);
}
else
{
if (strcmp(value, var->string) == 0)
{
return var;
}
}
if (Com_ServerState())
{
Com_Printf ("%s will be changed for next game.\n", var_name);
Com_Printf("%s will be changed for next game.\n", var_name);
var->latched_string = CopyString(value);
}
@ -209,8 +246,8 @@ cvar_t *Cvar_Set2 (char *var_name, char *value, qboolean force)
if (!strcmp(var->name, "game"))
{
FS_SetGamedir (var->string);
FS_ExecAutoexec ();
FS_SetGamedir(var->string);
FS_ExecAutoexec();
}
}
@ -222,20 +259,24 @@ cvar_t *Cvar_Set2 (char *var_name, char *value, qboolean force)
{
if (var->latched_string)
{
Z_Free (var->latched_string);
Z_Free(var->latched_string);
var->latched_string = NULL;
}
}
if (!strcmp(value, var->string))
{
return var;
}
var->modified = true;
if (var->flags & CVAR_USERINFO)
{
userinfo_modified = true;
}
Z_Free (var->string);
Z_Free(var->string);
var->string = CopyString(value);
var->value = strtod(var->string, (char **)NULL);
@ -243,33 +284,38 @@ cvar_t *Cvar_Set2 (char *var_name, char *value, qboolean force)
return var;
}
cvar_t *Cvar_ForceSet (char *var_name, char *value)
cvar_t *
Cvar_ForceSet(char *var_name, char *value)
{
return Cvar_Set2 (var_name, value, true);
return Cvar_Set2(var_name, value, true);
}
cvar_t *Cvar_Set (char *var_name, char *value)
cvar_t *
Cvar_Set(char *var_name, char *value)
{
return Cvar_Set2 (var_name, value, false);
return Cvar_Set2(var_name, value, false);
}
cvar_t *Cvar_FullSet (char *var_name, char *value, int flags)
cvar_t *
Cvar_FullSet(char *var_name, char *value, int flags)
{
cvar_t *var;
cvar_t *var;
var = Cvar_FindVar (var_name);
var = Cvar_FindVar(var_name);
if (!var)
{
return Cvar_Get (var_name, value, flags);
return Cvar_Get(var_name, value, flags);
}
var->modified = true;
if (var->flags & CVAR_USERINFO)
{
userinfo_modified = true;
}
Z_Free (var->string);
Z_Free(var->string);
var->string = CopyString(value);
var->value = (float)strtod(var->string, (char **)NULL);
@ -279,40 +325,48 @@ cvar_t *Cvar_FullSet (char *var_name, char *value, int flags)
return var;
}
void Cvar_SetValue (char *var_name, float value)
void
Cvar_SetValue(char *var_name, float value)
{
char val[32];
char val[32];
if (value == (int)value)
Com_sprintf (val, sizeof(val), "%i",(int)value);
{
Com_sprintf(val, sizeof(val), "%i", (int)value);
}
else
Com_sprintf (val, sizeof(val), "%f",value);
{
Com_sprintf(val, sizeof(val), "%f", value);
}
Cvar_Set (var_name, val);
Cvar_Set(var_name, val);
}
/*
* Any variables with latched values will now be updated
*/
void Cvar_GetLatchedVars (void)
void
Cvar_GetLatchedVars(void)
{
cvar_t *var;
cvar_t *var;
for (var = cvar_vars ; var ; var = var->next)
for (var = cvar_vars; var; var = var->next)
{
if (!var->latched_string)
{
continue;
}
Z_Free (var->string);
Z_Free(var->string);
var->string = var->latched_string;
var->latched_string = NULL;
var->value = strtod(var->string, (char **)NULL);
if (!strcmp(var->name, "game"))
{
FS_SetGamedir (var->string);
FS_ExecAutoexec ();
FS_SetGamedir(var->string);
FS_ExecAutoexec();
}
}
}
@ -320,143 +374,177 @@ void Cvar_GetLatchedVars (void)
/*
* Handles variable inspection and changing from the console
*/
qboolean Cvar_Command (void)
qboolean
Cvar_Command(void)
{
cvar_t *v;
cvar_t *v;
/* check variables */
v = Cvar_FindVar (Cmd_Argv(0));
v = Cvar_FindVar(Cmd_Argv(0));
if (!v)
{
return false;
}
/* perform a variable print or set */
if (Cmd_Argc() == 1)
{
Com_Printf ("\"%s\" is \"%s\"\n", v->name, v->string);
Com_Printf("\"%s\" is \"%s\"\n", v->name, v->string);
return true;
}
Cvar_Set (v->name, Cmd_Argv(1));
Cvar_Set(v->name, Cmd_Argv(1));
return true;
}
/*
* Allows setting and defining of arbitrary cvars from console
*/
void Cvar_Set_f (void)
void
Cvar_Set_f(void)
{
int c;
int flags;
int c;
int flags;
c = Cmd_Argc();
if (c != 3 && c != 4)
if ((c != 3) && (c != 4))
{
Com_Printf ("usage: set <variable> <value> [u / s]\n");
Com_Printf("usage: set <variable> <value> [u / s]\n");
return;
}
if (c == 4)
{
if (!strcmp(Cmd_Argv(3), "u"))
{
flags = CVAR_USERINFO;
}
else if (!strcmp(Cmd_Argv(3), "s"))
{
flags = CVAR_SERVERINFO;
}
else
{
Com_Printf ("flags can only be 'u' or 's'\n");
Com_Printf("flags can only be 'u' or 's'\n");
return;
}
Cvar_FullSet (Cmd_Argv(1), Cmd_Argv(2), flags);
Cvar_FullSet(Cmd_Argv(1), Cmd_Argv(2), flags);
}
else
Cvar_Set (Cmd_Argv(1), Cmd_Argv(2));
{
Cvar_Set(Cmd_Argv(1), Cmd_Argv(2));
}
}
/*
* Appends lines containing "set variable value" for all variables
* with the archive flag set to true.
*/
void Cvar_WriteVariables (char *path)
void
Cvar_WriteVariables(char *path)
{
cvar_t *var;
char buffer[1024];
FILE *f;
cvar_t *var;
char buffer[1024];
FILE *f;
f = fopen (path, "a");
f = fopen(path, "a");
for (var = cvar_vars ; var ; var = var->next)
for (var = cvar_vars; var; var = var->next)
{
if (var->flags & CVAR_ARCHIVE)
{
Com_sprintf (buffer, sizeof(buffer), "set %s \"%s\"\n", var->name, var->string);
fprintf (f, "%s", buffer);
Com_sprintf(buffer, sizeof(buffer), "set %s \"%s\"\n",
var->name, var->string);
fprintf(f, "%s", buffer);
}
}
fclose (f);
fclose(f);
}
void Cvar_List_f (void)
void
Cvar_List_f(void)
{
cvar_t *var;
int i;
cvar_t *var;
int i;
i = 0;
for (var = cvar_vars ; var ; var = var->next, i++)
for (var = cvar_vars; var; var = var->next, i++)
{
if (var->flags & CVAR_ARCHIVE)
Com_Printf ("*");
{
Com_Printf("*");
}
else
Com_Printf (" ");
{
Com_Printf(" ");
}
if (var->flags & CVAR_USERINFO)
Com_Printf ("U");
{
Com_Printf("U");
}
else
Com_Printf (" ");
{
Com_Printf(" ");
}
if (var->flags & CVAR_SERVERINFO)
Com_Printf ("S");
{
Com_Printf("S");
}
else
Com_Printf (" ");
{
Com_Printf(" ");
}
if (var->flags & CVAR_NOSET)
Com_Printf ("-");
{
Com_Printf("-");
}
else if (var->flags & CVAR_LATCH)
Com_Printf ("L");
{
Com_Printf("L");
}
else
Com_Printf (" ");
{
Com_Printf(" ");
}
Com_Printf (" %s \"%s\"\n", var->name, var->string);
Com_Printf(" %s \"%s\"\n", var->name, var->string);
}
Com_Printf ("%i cvars\n", i);
Com_Printf("%i cvars\n", i);
}
qboolean userinfo_modified;
char *Cvar_BitInfo (int bit)
char *
Cvar_BitInfo(int bit)
{
static char info[MAX_INFO_STRING];
cvar_t *var;
static char info[MAX_INFO_STRING];
cvar_t *var;
info[0] = 0;
for (var = cvar_vars ; var ; var = var->next)
for (var = cvar_vars; var; var = var->next)
{
if (var->flags & bit)
Info_SetValueForKey (info, var->name, var->string);
{
Info_SetValueForKey(info, var->name, var->string);
}
}
return info;
@ -466,26 +554,29 @@ char *Cvar_BitInfo (int bit)
* returns an info string containing
* all the CVAR_USERINFO cvars
*/
char *Cvar_Userinfo (void)
char *
Cvar_Userinfo(void)
{
return Cvar_BitInfo (CVAR_USERINFO);
return Cvar_BitInfo(CVAR_USERINFO);
}
/*
* returns an info string containing
* all the CVAR_SERVERINFO cvars
*/
char *Cvar_Serverinfo (void)
char *
Cvar_Serverinfo(void)
{
return Cvar_BitInfo (CVAR_SERVERINFO);
return Cvar_BitInfo(CVAR_SERVERINFO);
}
/*
* Reads in all archived cvars
*/
void Cvar_Init (void)
void
Cvar_Init(void)
{
Cmd_AddCommand ("set", Cvar_Set_f);
Cmd_AddCommand ("cvarlist", Cvar_List_f);
Cmd_AddCommand("set", Cvar_Set_f);
Cmd_AddCommand("cvarlist", Cvar_List_f);
}

873
src/common/filesystem.c
View file

File diff suppressed because it is too large Load diff

95
src/common/glob.c
View file

@ -31,25 +31,25 @@
* Like glob_match, but match PATTERN against any final segment of TEXT.
*/
static int
glob_match_after_star ( char *pattern, char *text )
glob_match_after_star(char *pattern, char *text)
{
register char *p = pattern, *t = text;
register char c, c1;
while ( ( c = *p++ ) == '?' || c == '*' )
while ((c = *p++) == '?' || c == '*')
{
if ( ( c == '?' ) && ( *t++ == '\0' ) )
if ((c == '?') && (*t++ == '\0'))
{
return ( 0 );
return 0;
}
}
if ( c == '\0' )
if (c == '\0')
{
return ( 1 );
return 1;
}
if ( c == '\\' )
if (c == '\\')
{
c1 = *p;
}
@ -58,16 +58,16 @@ glob_match_after_star ( char *pattern, char *text )
c1 = c;
}
while ( 1 )
while (1)
{
if ( ( ( c == '[' ) || ( *t == c1 ) ) && glob_match( p - 1, t ) )
if (((c == '[') || (*t == c1)) && glob_match(p - 1, t))
{
return ( 1 );
return 1;
}
if ( *t++ == '\0' )
if (*t++ == '\0')
{
return ( 0 );
return 0;
}
}
}
@ -90,20 +90,20 @@ glob_match_after_star ( char *pattern, char *text )
* and match the character exactly, precede it with a `\'.
*/
int
glob_match ( char *pattern, char *text )
glob_match(char *pattern, char *text)
{
register char *p = pattern, *t = text;
register char c;
while ( ( c = *p++ ) != '\0' )
while ((c = *p++) != '\0')
{
switch ( c )
switch (c)
{
case '?':
if ( *t == '\0' )
if (*t == '\0')
{
return ( 0 );
return 0;
}
else
{
@ -114,83 +114,83 @@ glob_match ( char *pattern, char *text )
case '\\':
if ( *p++ != *t++ )
if (*p++ != *t++)
{
return ( 0 );
return 0;
}
break;
case '*':
return ( glob_match_after_star( p, t ) );
return glob_match_after_star(p, t);
case '[':
{
register char c1 = *t++;
int invert;
if ( !c1 )
if (!c1)
{
return ( 0 );
return 0;
}
invert = ( ( *p == '!' ) || ( *p == '^' ) );
invert = ((*p == '!') || (*p == '^'));
if ( invert )
if (invert)
{
p++;
}
c = *p++;
while ( 1 )
while (1)
{
register char cstart = c, cend = c;
if ( c == '\\' )
if (c == '\\')
{
cstart = *p++;
cend = cstart;
}
if ( c == '\0' )
if (c == '\0')
{
return ( 0 );
return 0;
}
c = *p++;
if ( ( c == '-' ) && ( *p != ']' ) )
if ((c == '-') && (*p != ']'))
{
cend = *p++;
if ( cend == '\\' )
if (cend == '\\')
{
cend = *p++;
}
if ( cend == '\0' )
if (cend == '\0')
{
return ( 0 );
return 0;
}
c = *p++;
}
if ( ( c1 >= cstart ) && ( c1 <= cend ) )
if ((c1 >= cstart) && (c1 <= cend))
{
goto match;
}
if ( c == ']' )
if (c == ']')
{
break;
}
}
if ( !invert )
if (!invert)
{
return ( 0 );
return 0;
}
break;
@ -198,28 +198,28 @@ glob_match ( char *pattern, char *text )
match:
/* Skip the rest of the [...] construct that already matched. */
while ( c != ']' )
while (c != ']')
{
if ( c == '\0' )
if (c == '\0')
{
return ( 0 );
return 0;
}
c = *p++;
if ( c == '\0' )
if (c == '\0')
{
return ( 0 );
return 0;
}
else if ( c == '\\' )
else if (c == '\\')
{
++p;
}
}
if ( invert )
if (invert)
{
return ( 0 );
return 0;
}
break;
@ -227,12 +227,13 @@ glob_match ( char *pattern, char *text )
default:
if ( c != *t++ )
if (c != *t++)
{
return ( 0 );
return 0;
}
}
}
return ( *t == '\0' );
return *t == '\0';
}

155
src/common/md4.c
View file

@ -8,23 +8,26 @@
#include <inttypes.h>
#define ROTATELEFT32(x, s) (((x)<<(s))|((x)>>(32-(s))))
#define ROTATELEFT32(x, s) (((x) << (s)) | ((x) >> (32 - (s))))
#define F(X, Y, Z) (((X)&(Y)) | ((~X)&(Z)))
#define G(X, Y, Z) (((X)&(Y)) | ((X)&(Z)) | ((Y)&(Z)))
#define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
#define F(X, Y, Z) (((X)&(Y)) | ((~X) & (Z)))
#define G(X, Y, Z) (((X)&(Y)) | ((X)&(Z)) | ((Y)&(Z)))
#define H(X, Y, Z) ((X) ^ (Y) ^ (Z))
#define S(a, b, c, d, k, s) { \
#define S(a, b, c, d, k, s) \
{ \
a += (F((b), (c), (d)) + X[(k)]); \
a = ROTATELEFT32(a, s); \
a = ROTATELEFT32(a, s); \
}
#define T(a, b, c, d, k, s) { \
#define T(a, b, c, d, k, s) \
{ \
a += (G((b), (c), (d)) + X[(k)] + 0x5A827999); \
a = ROTATELEFT32(a, s); \
a = ROTATELEFT32(a, s); \
}
#define U(a, b, c, d, k, s) { \
#define U(a, b, c, d, k, s) \
{ \
a += (H((b), (c), (d)) + X[(k)] + 0x6ED9EBA1); \
a = ROTATELEFT32(a, s); \
a = ROTATELEFT32(a, s); \
}
static uint32_t X[16];
@ -33,62 +36,63 @@ static uint32_t B, BB;
static uint32_t C, CC;
static uint32_t D, DD;
static void DoMD4()
static void
DoMD4()
{
AA = A;
BB = B;
CC = C;
DD = D;
S(A, B, C, D, 0, 3);
S(D, A, B, C, 1, 7);
S(C, D, A, B, 2, 11);
S(B, C, D, A, 3, 19);
S(A, B, C, D, 4, 3);
S(D, A, B, C, 5, 7);
S(C, D, A, B, 6, 11);
S(B, C, D, A, 7, 19);
S(A, B, C, D, 8, 3);
S(D, A, B, C, 9, 7);
S(A, B, C, D, 0, 3);
S(D, A, B, C, 1, 7);
S(C, D, A, B, 2, 11);
S(B, C, D, A, 3, 19);
S(A, B, C, D, 4, 3);
S(D, A, B, C, 5, 7);
S(C, D, A, B, 6, 11);
S(B, C, D, A, 7, 19);
S(A, B, C, D, 8, 3);
S(D, A, B, C, 9, 7);
S(C, D, A, B, 10, 11);
S(B, C, D, A, 11, 19);
S(A, B, C, D, 12, 3);
S(D, A, B, C, 13, 7);
S(A, B, C, D, 12, 3);
S(D, A, B, C, 13, 7);
S(C, D, A, B, 14, 11);
S(B, C, D, A, 15, 19);
T(A, B, C, D, 0, 3);
T(D, A, B, C, 4, 5);
T(C, D, A, B, 8, 9);
T(A, B, C, D, 0, 3);
T(D, A, B, C, 4, 5);
T(C, D, A, B, 8, 9);
T(B, C, D, A, 12, 13);
T(A, B, C, D, 1, 3);
T(D, A, B, C, 5, 5);
T(C, D, A, B, 9, 9);
T(A, B, C, D, 1, 3);
T(D, A, B, C, 5, 5);
T(C, D, A, B, 9, 9);
T(B, C, D, A, 13, 13);
T(A, B, C, D, 2, 3);
T(D, A, B, C, 6, 5);
T(C, D, A, B, 10, 9);
T(A, B, C, D, 2, 3);
T(D, A, B, C, 6, 5);
T(C, D, A, B, 10, 9);
T(B, C, D, A, 14, 13);
T(A, B, C, D, 3, 3);
T(D, A, B, C, 7, 5);
T(C, D, A, B, 11, 9);
T(A, B, C, D, 3, 3);
T(D, A, B, C, 7, 5);
T(C, D, A, B, 11, 9);
T(B, C, D, A, 15, 13);
U(A, B, C, D, 0, 3);
U(D, A, B, C, 8, 9);
U(C, D, A, B, 4, 11);
U(A, B, C, D, 0, 3);
U(D, A, B, C, 8, 9);
U(C, D, A, B, 4, 11);
U(B, C, D, A, 12, 15);
U(A, B, C, D, 2, 3);
U(D, A, B, C, 10, 9);
U(C, D, A, B, 6, 11);
U(A, B, C, D, 2, 3);
U(D, A, B, C, 10, 9);
U(C, D, A, B, 6, 11);
U(B, C, D, A, 14, 15);
U(A, B, C, D, 1, 3);
U(D, A, B, C, 9, 9);
U(C, D, A, B, 5, 11);
U(A, B, C, D, 1, 3);
U(D, A, B, C, 9, 9);
U(C, D, A, B, 5, 11);
U(B, C, D, A, 13, 15);
U(A, B, C, D, 3, 3);
U(D, A, B, C, 11, 9);
U(C, D, A, B, 7, 11);
U(A, B, C, D, 3, 3);
U(D, A, B, C, 11, 9);
U(C, D, A, B, 7, 11);
U(B, C, D, A, 15, 15);
A += AA;
@ -97,7 +101,8 @@ static void DoMD4()
D += DD;
}
static void PerformMD4(const unsigned char *buf, int length, unsigned char *digest)
static void
PerformMD4(const unsigned char *buf, int length, unsigned char *digest)
{
int len = length / 64; /* number of full blocks */
int rem = length % 64; /* number of left over bytes */
@ -115,8 +120,8 @@ static void PerformMD4(const unsigned char *buf, int length, unsigned char *dige
{
for (j = 0; j < 16; j++)
{
X[j] = ((ptr[0]<< 0)|(ptr[1]<< 8)|
(ptr[2]<<16)|(ptr[3]<<24));
X[j] = ((ptr[0] << 0) | (ptr[1] << 8) |
(ptr[2] << 16) | (ptr[3] << 24));
ptr += 4;
}
@ -128,25 +133,27 @@ static void PerformMD4(const unsigned char *buf, int length, unsigned char *dige
for (j = 0; j < i; j++)
{
X[j] = ((ptr[0]<< 0)|(ptr[1]<< 8)|
(ptr[2]<<16)|(ptr[3]<<24));
X[j] = ((ptr[0] << 0) | (ptr[1] << 8) |
(ptr[2] << 16) | (ptr[3] << 24));
ptr += 4;
}
switch(rem % 4)
switch (rem % 4)
{
case 0:
X[j] = 0x80U;
break;
case 1:
X[j] = ((ptr[0]<< 0)|((0x80U)<< 8));
X[j] = ((ptr[0] << 0) | ((0x80U) << 8));
break;
case 2:
X[j] = ((ptr[0]<< 0)|(ptr[1]<< 8)|((0x80U)<<16));
X[j] = ((ptr[0] << 0) | (ptr[1] << 8) | ((0x80U) << 16));
break;
case 3:
X[j] = ((ptr[0]<< 0)|(ptr[1]<< 8)|(ptr[2]<<16)|((0x80U)<<24));
X[j] =
((ptr[0] <<
0) | (ptr[1] << 8) | (ptr[2] << 16) | ((0x80U) << 24));
break;
}
@ -154,32 +161,36 @@ static void PerformMD4(const unsigned char *buf, int length, unsigned char *dige
if (j > 14)
{
for (; j < 16; j++)
for ( ; j < 16; j++)
{
X[j] = 0;
}
DoMD4();
j = 0;
}
for (; j < 14; j++)
for ( ; j < 14; j++)
{
X[j] = 0;
}
X[14] = (length & 0x1FFFFFFF) << 3;
X[14] = (length & 0x1FFFFFFF) << 3;
X[15] = (length & ~0x1FFFFFFF) >> 29;
DoMD4();
digest[ 0] = (A & 0x000000FF) >> 0;
digest[ 1] = (A & 0x0000FF00) >> 8;
digest[ 2] = (A & 0x00FF0000) >> 16;
digest[ 3] = (A & 0xFF000000) >> 24;
digest[ 4] = (B & 0x000000FF) >> 0;
digest[ 5] = (B & 0x0000FF00) >> 8;
digest[ 6] = (B & 0x00FF0000) >> 16;
digest[ 7] = (B & 0xFF000000) >> 24;
digest[ 8] = (C & 0x000000FF) >> 0;
digest[ 9] = (C & 0x0000FF00) >> 8;
digest[0] = (A & 0x000000FF) >> 0;
digest[1] = (A & 0x0000FF00) >> 8;
digest[2] = (A & 0x00FF0000) >> 16;
digest[3] = (A & 0xFF000000) >> 24;
digest[4] = (B & 0x000000FF) >> 0;
digest[5] = (B & 0x0000FF00) >> 8;
digest[6] = (B & 0x00FF0000) >> 16;
digest[7] = (B & 0xFF000000) >> 24;
digest[8] = (C & 0x000000FF) >> 0;
digest[9] = (C & 0x0000FF00) >> 8;
digest[10] = (C & 0x00FF0000) >> 16;
digest[11] = (C & 0xFF000000) >> 24;
digest[12] = (D & 0x000000FF) >> 0;
@ -193,10 +204,13 @@ static void PerformMD4(const unsigned char *buf, int length, unsigned char *dige
D = DD = 0;
for (j = 0; j < 16; j++)
{
X[j] = 0;
}
}
unsigned Com_BlockChecksum (void *buffer, int length)
unsigned
Com_BlockChecksum(void *buffer, int length)
{
uint32_t digest[4];
unsigned val;
@ -207,3 +221,4 @@ unsigned Com_BlockChecksum (void *buffer, int length)
return val;
}

258
src/common/misc.c
View file

@ -28,24 +28,23 @@
#include "header/zone.h"
#include <setjmp.h>
FILE *log_stats_file;
cvar_t *host_speeds;
cvar_t *log_stats;
cvar_t *developer;
cvar_t *modder;
cvar_t *timescale;
cvar_t *fixedtime;
FILE *log_stats_file;
cvar_t *host_speeds;
cvar_t *log_stats;
cvar_t *developer;
cvar_t *modder;
cvar_t *timescale;
cvar_t *fixedtime;
#ifndef DEDICATED_ONLY
cvar_t *showtrace;
cvar_t *showtrace;
#endif
cvar_t *dedicated;
cvar_t *dedicated;
extern cvar_t *logfile_active;
extern jmp_buf abortframe; /* an ERR_DROP occured, exit the entire frame */
extern zhead_t z_chain;
extern cvar_t *logfile_active;
extern jmp_buf abortframe; /* an ERR_DROP occured, exit the entire frame */
extern zhead_t z_chain;
static byte chktbl[1024] =
{
static byte chktbl[1024] = {
0x84, 0x47, 0x51, 0xc1, 0x93, 0x22, 0x21, 0x24, 0x2f, 0x66, 0x60, 0x4d, 0xb0, 0x7c, 0xda,
0x88, 0x54, 0x15, 0x2b, 0xc6, 0x6c, 0x89, 0xc5, 0x9d, 0x48, 0xee, 0xe6, 0x8a, 0xb5, 0xf4,
0xcb, 0xfb, 0xf1, 0x0c, 0x2e, 0xa0, 0xd7, 0xc9, 0x1f, 0xd6, 0x06, 0x9a, 0x09, 0x41, 0x54,
@ -113,44 +112,51 @@ static byte chktbl[1024] =
};
/* host_speeds times */
int time_before_game;
int time_after_game;
int time_before_ref;
int time_after_ref;
int time_before_game;
int time_after_game;
int time_before_ref;
int time_after_ref;
/*
* For proxy protecting
*/
byte COM_BlockSequenceCRCByte (byte *base, int length, int sequence)
byte
COM_BlockSequenceCRCByte(byte *base, int length, int sequence)
{
int n;
int x;
byte *p;
byte chkb[60 + 4];
unsigned short crc;
byte r;
int n;
int x;
byte *p;
byte chkb[60 + 4];
unsigned short crc;
byte r;
if (sequence < 0)
{
Sys_Error("sequence < 0, this shouldn't happen\n");
}
p = chktbl + (sequence % (sizeof(chktbl) - 4));
if (length > 60)
{
length = 60;
}
memcpy (chkb, base, length);
memcpy(chkb, base, length);
chkb[length] = p[0];
chkb[length+1] = p[1];
chkb[length+2] = p[2];
chkb[length+3] = p[3];
chkb[length + 1] = p[1];
chkb[length + 2] = p[2];
chkb[length + 3] = p[3];
length += 4;
crc = CRC_Block(chkb, length);
for (x=0, n=0; n<length; n++)
for (x = 0, n = 0; n < length; n++)
{
x += chkb[n];
}
r = (crc ^ x) & 0xff;
@ -158,219 +164,234 @@ byte COM_BlockSequenceCRCByte (byte *base, int length, int sequence)
}
#ifndef DEDICATED_ONLY
void Key_Init (void);
void SCR_EndLoadingPlaque (void);
void Key_Init(void);
void SCR_EndLoadingPlaque(void);
#endif
/*
* Just throw a fatal error to
* test error shutdown procedures
*/
void Com_Error_f (void)
void
Com_Error_f(void)
{
Com_Error (ERR_FATAL, "%s", Cmd_Argv(1));
Com_Error(ERR_FATAL, "%s", Cmd_Argv(1));
}
void Qcommon_Init (int argc, char **argv)
void
Qcommon_Init(int argc, char **argv)
{
char *s;
char *s;
if (setjmp (abortframe) )
Sys_Error ("Error during initialization");
if (setjmp(abortframe))
{
Sys_Error("Error during initialization");
}
z_chain.next = z_chain.prev = &z_chain;
/* prepare enough of the subsystems to handle
cvar and command buffer management */
COM_InitArgv (argc, argv);
COM_InitArgv(argc, argv);
Swap_Init ();
Cbuf_Init ();
Swap_Init();
Cbuf_Init();
Cmd_Init ();
Cvar_Init ();
Cmd_Init();
Cvar_Init();
#ifndef DEDICATED_ONLY
Key_Init ();
Key_Init();
#endif
/* we need to add the early commands twice, because
a basedir or cddir needs to be set before execing
config files, but we want other parms to override
the settings of the config files */
Cbuf_AddEarlyCommands (false);
Cbuf_Execute ();
Cbuf_AddEarlyCommands(false);
Cbuf_Execute();
FS_InitFilesystem ();
FS_InitFilesystem();
Cbuf_AddText ("exec default.cfg\n");
Cbuf_AddText ("exec yq2.cfg\n");
Cbuf_AddText ("exec config.cfg\n");
Cbuf_AddText("exec default.cfg\n");
Cbuf_AddText("exec yq2.cfg\n");
Cbuf_AddText("exec config.cfg\n");
Cbuf_AddEarlyCommands (true);
Cbuf_Execute ();
Cbuf_AddEarlyCommands(true);
Cbuf_Execute();
/* init commands and vars */
Cmd_AddCommand ("z_stats", Z_Stats_f);
Cmd_AddCommand ("error", Com_Error_f);
Cmd_AddCommand("z_stats", Z_Stats_f);
Cmd_AddCommand("error", Com_Error_f);
host_speeds = Cvar_Get ("host_speeds", "0", 0);
log_stats = Cvar_Get ("log_stats", "0", 0);
developer = Cvar_Get ("developer", "0", 0);
modder = Cvar_Get ("modder", "0", 0);
timescale = Cvar_Get ("timescale", "1", 0);
fixedtime = Cvar_Get ("fixedtime", "0", 0);
logfile_active = Cvar_Get ("logfile", "0", 0);
host_speeds = Cvar_Get("host_speeds", "0", 0);
log_stats = Cvar_Get("log_stats", "0", 0);
developer = Cvar_Get("developer", "0", 0);
modder = Cvar_Get("modder", "0", 0);
timescale = Cvar_Get("timescale", "1", 0);
fixedtime = Cvar_Get("fixedtime", "0", 0);
logfile_active = Cvar_Get("logfile", "0", 0);
#ifndef DEDICATED_ONLY
showtrace = Cvar_Get ("showtrace", "0", 0);
showtrace = Cvar_Get("showtrace", "0", 0);
#endif
#ifdef DEDICATED_ONLY
dedicated = Cvar_Get ("dedicated", "1", CVAR_NOSET);
dedicated = Cvar_Get("dedicated", "1", CVAR_NOSET);
#else
dedicated = Cvar_Get ("dedicated", "0", CVAR_NOSET);
dedicated = Cvar_Get("dedicated", "0", CVAR_NOSET);
#endif
s = va("%4.2f %s %s %s", VERSION, CPUSTRING, __DATE__, BUILDSTRING);
Cvar_Get ("version", s, CVAR_SERVERINFO|CVAR_NOSET);
Cvar_Get("version", s, CVAR_SERVERINFO | CVAR_NOSET);
if (dedicated->value)
Cmd_AddCommand ("quit", Com_Quit);
{
Cmd_AddCommand("quit", Com_Quit);
}
Sys_Init();
NET_Init();
Netchan_Init ();
SV_Init ();
Netchan_Init();
SV_Init();
#ifndef DEDICATED_ONLY
CL_Init ();
CL_Init();
#endif
/* add + commands from command line */
if (!Cbuf_AddLateCommands ())
if (!Cbuf_AddLateCommands())
{
/* if the user didn't give any commands, run default action */
if (!dedicated->value)
Cbuf_AddText ("d1\n");
{
Cbuf_AddText("d1\n");
}
else
Cbuf_AddText ("dedicated_start\n");
{
Cbuf_AddText("dedicated_start\n");
}
Cbuf_Execute ();
Cbuf_Execute();
}
#ifndef DEDICATED_ONLY
else
{
/* the user asked for something explicit
so drop the loading plaque */
SCR_EndLoadingPlaque ();
SCR_EndLoadingPlaque();
}
#endif
Com_Printf ("==== Yamagi Quake II Initialized ====\n\n");
Com_Printf ("*************************************\n\n");
Com_Printf("==== Yamagi Quake II Initialized ====\n\n");
Com_Printf("*************************************\n\n");
}
void Qcommon_Frame (int msec)
void
Qcommon_Frame(int msec)
{
char *s;
char *s;
#ifndef DEDICATED_ONLY
int time_before = 0;
int time_between = 0;
int time_after;
int time_before = 0;
int time_between = 0;
int time_after;
#endif
if (setjmp (abortframe) )
if (setjmp(abortframe))
{
return; /* an ERR_DROP was thrown */
}
if ( log_stats->modified )
if (log_stats->modified)
{
log_stats->modified = false;
if ( log_stats->value )
if (log_stats->value)
{
if ( log_stats_file )
if (log_stats_file)
{
fclose( log_stats_file );
fclose(log_stats_file);
log_stats_file = 0;
}
log_stats_file = fopen( "stats.log", "w" );
log_stats_file = fopen("stats.log", "w");
if ( log_stats_file )
fprintf( log_stats_file, "entities,dlights,parts,frame time\n" );
if (log_stats_file)
{
fprintf(log_stats_file, "entities,dlights,parts,frame time\n");
}
}
else
{
if ( log_stats_file )
if (log_stats_file)
{
fclose( log_stats_file );
fclose(log_stats_file);
log_stats_file = 0;
}
}
}
if (fixedtime->value)
{
msec = fixedtime->value;
}
else if (timescale->value)
{
msec *= timescale->value;
if (msec < 1)
{
msec = 1;
}
}
#ifndef DEDICATED_ONLY
if (showtrace->value)
{
extern int c_traces, c_brush_traces;
extern int c_pointcontents;
extern int c_traces, c_brush_traces;
extern int c_pointcontents;
Com_Printf ("%4i traces %4i points\n", c_traces, c_pointcontents);
Com_Printf("%4i traces %4i points\n", c_traces, c_pointcontents);
c_traces = 0;
c_brush_traces = 0;
c_pointcontents = 0;
}
#endif
do
{
s = Sys_ConsoleInput ();
s = Sys_ConsoleInput();
if (s)
Cbuf_AddText (va("%s\n",s));
{
Cbuf_AddText(va("%s\n", s));
}
}
while (s);
Cbuf_Execute ();
Cbuf_Execute();
#ifndef DEDICATED_ONLY
if (host_speeds->value)
time_before = Sys_Milliseconds ();
{
time_before = Sys_Milliseconds();
}
#endif
SV_Frame (msec);
SV_Frame(msec);
#ifndef DEDICATED_ONLY
if (host_speeds->value)
time_between = Sys_Milliseconds ();
{
time_between = Sys_Milliseconds();
}
CL_Frame (msec);
CL_Frame(msec);
if (host_speeds->value)
{
int all, sv, gm, cl, rf;
int all, sv, gm, cl, rf;
time_after = Sys_Milliseconds ();
time_after = Sys_Milliseconds();
all = time_after - time_before;
sv = time_between - time_before;
cl = time_after - time_between;
@ -378,13 +399,14 @@ void Qcommon_Frame (int msec)
rf = time_after_ref - time_before_ref;
sv -= gm;
cl -= rf;
Com_Printf ("all:%3i sv:%3i gm:%3i cl:%3i rf:%3i\n",
all, sv, gm, cl, rf);
Com_Printf("all:%3i sv:%3i gm:%3i cl:%3i rf:%3i\n",
all, sv, gm, cl, rf);
}
#endif
}
void Qcommon_Shutdown (void)
void
Qcommon_Shutdown(void)
{
}

214
src/common/netchan.c
View file

@ -19,7 +19,7 @@
*
* =======================================================================
*
* The low level network code
* The low level, platform independant network code
*
* =======================================================================
*/
@ -81,65 +81,69 @@
* something in the unacknowledged reliable
*/
cvar_t *showpackets;
cvar_t *showdrop;
cvar_t *qport;
cvar_t *showpackets;
cvar_t *showdrop;
cvar_t *qport;
netadr_t net_from;
sizebuf_t net_message;
byte net_message_buffer[MAX_MSGLEN];
netadr_t net_from;
sizebuf_t net_message;
byte net_message_buffer[MAX_MSGLEN];
void Netchan_Init (void)
void
Netchan_Init(void)
{
int port;
int port;
/* pick a port value that should be nice and random */
port = Sys_Milliseconds() & 0xffff;
showpackets = Cvar_Get ("showpackets", "0", 0);
showdrop = Cvar_Get ("showdrop", "0", 0);
qport = Cvar_Get ("qport", va("%i", port), CVAR_NOSET);
showpackets = Cvar_Get("showpackets", "0", 0);
showdrop = Cvar_Get("showdrop", "0", 0);
qport = Cvar_Get("qport", va("%i", port), CVAR_NOSET);
}
/*
* Sends an out-of-band datagram
*/
void Netchan_OutOfBand (int net_socket, netadr_t adr, int length, byte *data)
void
Netchan_OutOfBand(int net_socket, netadr_t adr, int length, byte *data)
{
sizebuf_t send;
byte send_buf[MAX_MSGLEN];
sizebuf_t send;
byte send_buf[MAX_MSGLEN];
/* write the packet header */
SZ_Init (&send, send_buf, sizeof(send_buf));
SZ_Init(&send, send_buf, sizeof(send_buf));
MSG_WriteLong (&send, -1); /* -1 sequence means out of band */
SZ_Write (&send, data, length);
MSG_WriteLong(&send, -1); /* -1 sequence means out of band */
SZ_Write(&send, data, length);
/* send the datagram */
NET_SendPacket (net_socket, send.cursize, send.data, adr);
NET_SendPacket(net_socket, send.cursize, send.data, adr);
}
/*
* Sends a text message in an out-of-band datagram
*/
void Netchan_OutOfBandPrint (int net_socket, netadr_t adr, char *format, ...)
void
Netchan_OutOfBandPrint(int net_socket, netadr_t adr, char *format, ...)
{
va_list argptr;
static char string[MAX_MSGLEN - 4];
va_list argptr;
static char string[MAX_MSGLEN - 4];
va_start (argptr, format);
vsnprintf (string, MAX_MSGLEN - 4, format, argptr);
va_end (argptr);
va_start(argptr, format);
vsnprintf(string, MAX_MSGLEN - 4, format, argptr);
va_end(argptr);
Netchan_OutOfBand (net_socket, adr, strlen(string), (byte *)string);
Netchan_OutOfBand(net_socket, adr, strlen(string), (byte *)string);
}
/*
* called to open a channel to a remote system
*/
void Netchan_Setup (netsrc_t sock, netchan_t *chan, netadr_t adr, int qport)
void
Netchan_Setup(netsrc_t sock, netchan_t *chan, netadr_t adr, int qport)
{
memset (chan, 0, sizeof(*chan));
memset(chan, 0, sizeof(*chan));
chan->sock = sock;
chan->remote_address = adr;
@ -148,31 +152,37 @@ void Netchan_Setup (netsrc_t sock, netchan_t *chan, netadr_t adr, int qport)
chan->incoming_sequence = 0;
chan->outgoing_sequence = 1;
SZ_Init (&chan->message, chan->message_buf, sizeof(chan->message_buf));
SZ_Init(&chan->message, chan->message_buf, sizeof(chan->message_buf));
chan->message.allowoverflow = true;
}
/*
* Returns true if the last reliable message has acked
*/
qboolean Netchan_CanReliable (netchan_t *chan)
qboolean
Netchan_CanReliable(netchan_t *chan)
{
if (chan->reliable_length)
{
return false; /* waiting for ack */
}
return true;
}
qboolean Netchan_NeedReliable (netchan_t *chan)
qboolean
Netchan_NeedReliable(netchan_t *chan)
{
qboolean send_reliable;
qboolean send_reliable;
/* if the remote side dropped the last reliable message, resend it */
send_reliable = false;
if (chan->incoming_acknowledged > chan->last_reliable_sequence
&& chan->incoming_reliable_acknowledged != chan->reliable_sequence)
if ((chan->incoming_acknowledged > chan->last_reliable_sequence) &&
(chan->incoming_reliable_acknowledged != chan->reliable_sequence))
{
send_reliable = true;
}
/* if the reliable transmit buffer is empty, copy the current message out */
if (!chan->reliable_length && chan->message.cursize)
@ -189,79 +199,89 @@ qboolean Netchan_NeedReliable (netchan_t *chan)
*
* A 0 length will still generate a packet and deal with the reliable messages.
*/
void Netchan_Transmit (netchan_t *chan, int length, byte *data)
void
Netchan_Transmit(netchan_t *chan, int length, byte *data)
{
sizebuf_t send;
byte send_buf[MAX_MSGLEN];
qboolean send_reliable;
unsigned w1, w2;
sizebuf_t send;
byte send_buf[MAX_MSGLEN];
qboolean send_reliable;
unsigned w1, w2;
/* check for message overflow */
if (chan->message.overflowed)
{
chan->fatal_error = true;
Com_Printf ("%s:Outgoing message overflow\n"
, NET_AdrToString (chan->remote_address));
Com_Printf("%s:Outgoing message overflow\n",
NET_AdrToString(chan->remote_address));
return;
}
send_reliable = Netchan_NeedReliable (chan);
send_reliable = Netchan_NeedReliable(chan);
if (!chan->reliable_length && chan->message.cursize)
{
memcpy (chan->reliable_buf, chan->message_buf, chan->message.cursize);
memcpy(chan->reliable_buf, chan->message_buf, chan->message.cursize);
chan->reliable_length = chan->message.cursize;
chan->message.cursize = 0;
chan->reliable_sequence ^= 1;
}
/* write the packet header */
SZ_Init (&send, send_buf, sizeof(send_buf));
SZ_Init(&send, send_buf, sizeof(send_buf));
w1 = ( chan->outgoing_sequence & ~(1<<31) ) | (send_reliable<<31);
w2 = ( chan->incoming_sequence & ~(1<<31) ) | (chan->incoming_reliable_sequence<<31);
w1 = (chan->outgoing_sequence & ~(1 << 31)) | (send_reliable << 31);
w2 =
(chan->incoming_sequence &
~(1 << 31)) | (chan->incoming_reliable_sequence << 31);
chan->outgoing_sequence++;
chan->last_sent = curtime;
MSG_WriteLong (&send, w1);
MSG_WriteLong (&send, w2);
MSG_WriteLong(&send, w1);
MSG_WriteLong(&send, w2);
/* send the qport if we are a client */
if (chan->sock == NS_CLIENT)
MSG_WriteShort (&send, qport->value);
{
MSG_WriteShort(&send, qport->value);
}
/* copy the reliable message to the packet first */
if (send_reliable)
{
SZ_Write (&send, chan->reliable_buf, chan->reliable_length);
SZ_Write(&send, chan->reliable_buf, chan->reliable_length);
chan->last_reliable_sequence = chan->outgoing_sequence;
}
/* add the unreliable part if space is available */
if (send.maxsize - send.cursize >= length)
SZ_Write (&send, data, length);
{
SZ_Write(&send, data, length);
}
else
Com_Printf ("Netchan_Transmit: dumped unreliable\n");
{
Com_Printf("Netchan_Transmit: dumped unreliable\n");
}
/* send the datagram */
NET_SendPacket (chan->sock, send.cursize, send.data, chan->remote_address);
NET_SendPacket(chan->sock, send.cursize, send.data, chan->remote_address);
if (showpackets->value)
{
if (send_reliable)
Com_Printf ("send %4i : s=%i reliable=%i ack=%i rack=%i\n"
, send.cursize
, chan->outgoing_sequence - 1
, chan->reliable_sequence
, chan->incoming_sequence
, chan->incoming_reliable_sequence);
{
Com_Printf("send %4i : s=%i reliable=%i ack=%i rack=%i\n",
send.cursize, chan->outgoing_sequence - 1,
chan->reliable_sequence, chan->incoming_sequence,
chan->incoming_reliable_sequence);
}
else
Com_Printf ("send %4i : s=%i ack=%i rack=%i\n"
, send.cursize
, chan->outgoing_sequence - 1
, chan->incoming_sequence
, chan->incoming_reliable_sequence);
{
Com_Printf("send %4i : s=%i ack=%i rack=%i\n",
send.cursize, chan->outgoing_sequence - 1,
chan->incoming_sequence,
chan->incoming_reliable_sequence);
}
}
}
@ -269,71 +289,78 @@ void Netchan_Transmit (netchan_t *chan, int length, byte *data)
* called when the current net_message is from remote_address
* modifies net_message so that it points to the packet payload
*/
qboolean Netchan_Process (netchan_t *chan, sizebuf_t *msg)
qboolean
Netchan_Process(netchan_t *chan, sizebuf_t *msg)
{
unsigned sequence, sequence_ack;
unsigned reliable_ack, reliable_message;
unsigned sequence, sequence_ack;
unsigned reliable_ack, reliable_message;
/* get sequence numbers */
MSG_BeginReading (msg);
sequence = MSG_ReadLong (msg);
sequence_ack = MSG_ReadLong (msg);
MSG_BeginReading(msg);
sequence = MSG_ReadLong(msg);
sequence_ack = MSG_ReadLong(msg);
/* read the qport if we are a server */
if (chan->sock == NS_SERVER)
{
(void)MSG_ReadShort(msg);
}
reliable_message = sequence >> 31;
reliable_ack = sequence_ack >> 31;
sequence &= ~(1<<31);
sequence_ack &= ~(1<<31);
sequence &= ~(1 << 31);
sequence_ack &= ~(1 << 31);
if (showpackets->value)
{
if (reliable_message)
Com_Printf ("recv %4i : s=%i reliable=%i ack=%i rack=%i\n"
, msg->cursize
, sequence
, chan->incoming_reliable_sequence ^ 1
, sequence_ack
, reliable_ack);
{
Com_Printf("recv %4i : s=%i reliable=%i ack=%i rack=%i\n",
msg->cursize, sequence,
chan->incoming_reliable_sequence ^ 1,
sequence_ack, reliable_ack);
}
else
Com_Printf ("recv %4i : s=%i ack=%i rack=%i\n"
, msg->cursize
, sequence
, sequence_ack
, reliable_ack);
{
Com_Printf("recv %4i : s=%i ack=%i rack=%i\n",
msg->cursize, sequence, sequence_ack,
reliable_ack);
}
}
/* discard stale or duplicated packets */
if (sequence <= chan->incoming_sequence)
{
if (showdrop->value)
Com_Printf ("%s:Out of order packet %i at %i\n"
, NET_AdrToString (chan->remote_address)
, sequence
, chan->incoming_sequence);
{
Com_Printf("%s:Out of order packet %i at %i\n",
NET_AdrToString(chan->remote_address),
sequence, chan->incoming_sequence);
}
return false;
}
/* dropped packets don't keep the message from being used */
chan->dropped = sequence - (chan->incoming_sequence+1);
chan->dropped = sequence - (chan->incoming_sequence + 1);
if (chan->dropped > 0)
{
if (showdrop->value)
Com_Printf ("%s:Dropped %i packets at %i\n"
, NET_AdrToString (chan->remote_address)
, chan->dropped
, sequence);
{
Com_Printf("%s:Dropped %i packets at %i\n",
NET_AdrToString(chan->remote_address),
chan->dropped, sequence);
}
}
/* if the current outgoing reliable message has been acknowledged
clear the buffer to make way for the next */
* clear the buffer to make way for the next */
if (reliable_ack == chan->reliable_sequence)
{
chan->reliable_length = 0; /* it has been received */
}
/* if this message contains a reliable message, bump incoming_reliable_sequence */
chan->incoming_sequence = sequence;
@ -350,3 +377,4 @@ qboolean Netchan_Process (netchan_t *chan, sizebuf_t *msg)
return true;
}

867
src/common/pmove.c
View file

File diff suppressed because it is too large Load diff

55
src/common/szone.c
View file

@ -26,34 +26,42 @@
#include "header/common.h"
void SZ_Init (sizebuf_t *buf, byte *data, int length)
void
SZ_Init(sizebuf_t *buf, byte *data, int length)
{
memset (buf, 0, sizeof(*buf));
memset(buf, 0, sizeof(*buf));
buf->data = data;
buf->maxsize = length;
}
void SZ_Clear (sizebuf_t *buf)
void
SZ_Clear(sizebuf_t *buf)
{
buf->cursize = 0;
buf->overflowed = false;
}
void *SZ_GetSpace (sizebuf_t *buf, int length)
void *
SZ_GetSpace(sizebuf_t *buf, int length)
{
void *data;
void *data;
if (buf->cursize + length > buf->maxsize)
{
if (!buf->allowoverflow)
Com_Error (ERR_FATAL, "SZ_GetSpace: overflow without allowoverflow set");
{
Com_Error(ERR_FATAL, "SZ_GetSpace: overflow without allowoverflow set");
}
if (length > buf->maxsize)
Com_Error (ERR_FATAL, "SZ_GetSpace: %i is > full buffer size", length);
{
Com_Error(ERR_FATAL, "SZ_GetSpace: %i is > full buffer size",
length);
}
SZ_Clear (buf);
SZ_Clear(buf);
buf->overflowed = true;
Com_Printf ("SZ_GetSpace: overflow\n");
Com_Printf("SZ_GetSpace: overflow\n");
}
data = buf->data + buf->cursize;
@ -62,26 +70,33 @@ void *SZ_GetSpace (sizebuf_t *buf, int length)
return data;
}
void SZ_Write (sizebuf_t *buf, void *data, int length)
void
SZ_Write(sizebuf_t *buf, void *data, int length)
{
memcpy (SZ_GetSpace(buf,length),data,length);
memcpy(SZ_GetSpace(buf, length), data, length);
}
void SZ_Print (sizebuf_t *buf, char *data)
void
SZ_Print(sizebuf_t *buf, char *data)
{
int len;
int len;
len = (int)strlen(data)+1;
len = (int)strlen(data) + 1;
if (buf->cursize)
{
if (buf->data[buf->cursize-1])
memcpy ((byte *)SZ_GetSpace(buf, len),data,len); /* no trailing 0 */
if (buf->data[buf->cursize - 1])
{
memcpy((byte *)SZ_GetSpace(buf, len), data, len); /* no trailing 0 */
}
else
memcpy ((byte *)SZ_GetSpace(buf, len-1)-1,data,len); /* write over trailing 0 */
{
memcpy((byte *)SZ_GetSpace(buf, len - 1) - 1, data, len); /* write over trailing 0 */
}
}
else
memcpy ((byte *)SZ_GetSpace(buf, len),data,len);
{
memcpy((byte *)SZ_GetSpace(buf, len), data, len);
}
}

52
src/common/zone.c
View file

@ -19,7 +19,7 @@
*
* =======================================================================
*
* Zone malloc. It's just a normal mallic with counter.
* Zone malloc. It's just a normal malloc with tags.
*
* =======================================================================
*/
@ -29,20 +29,21 @@
#define Z_MAGIC 0x1d1d
zhead_t z_chain;
int z_count, z_bytes;
zhead_t z_chain;
int z_count, z_bytes;
void Z_Free (void *ptr)
void
Z_Free(void *ptr)
{
zhead_t *z;
zhead_t *z;
z = ((zhead_t *)ptr) - 1;
if (z->magic != Z_MAGIC)
{
printf( "free: %p failed\n", ptr );
printf("free: %p failed\n", ptr);
abort();
Com_Error (ERR_FATAL, "Z_Free: bad magic");
Com_Error(ERR_FATAL, "Z_Free: bad magic");
}
z->prev->next = z->next;
@ -50,38 +51,45 @@ void Z_Free (void *ptr)
z_count--;
z_bytes -= z->size;
free (z);
free(z);
}
void Z_Stats_f (void)
void
Z_Stats_f(void)
{
Com_Printf ("%i bytes in %i blocks\n", z_bytes, z_count);
Com_Printf("%i bytes in %i blocks\n", z_bytes, z_count);
}
void Z_FreeTags (int tag)
void
Z_FreeTags(int tag)
{
zhead_t *z, *next;
zhead_t *z, *next;
for (z=z_chain.next ; z != &z_chain ; z=next)
for (z = z_chain.next; z != &z_chain; z = next)
{
next = z->next;
if (z->tag == tag)
Z_Free ((void *)(z+1));
{
Z_Free((void *)(z + 1));
}
}
}
void *Z_TagMalloc (int size, int tag)
void *
Z_TagMalloc(int size, int tag)
{
zhead_t *z;
zhead_t *z;
size = size + sizeof(zhead_t);
z = malloc(size);
if (!z)
Com_Error (ERR_FATAL, "Z_Malloc: failed on allocation of %i bytes",size);
{
Com_Error(ERR_FATAL, "Z_Malloc: failed on allocation of %i bytes", size);
}
memset (z, 0, size);
memset(z, 0, size);
z_count++;
z_bytes += size;
z->magic = Z_MAGIC;
@ -93,10 +101,12 @@ void *Z_TagMalloc (int size, int tag)
z_chain.next->prev = z;
z_chain.next = z;
return (void *)(z+1);
return (void *)(z + 1);
}
void *Z_Malloc (int size)
void *
Z_Malloc(int size)
{
return Z_TagMalloc (size, 0);
return Z_TagMalloc(size, 0);
}