extern qboolean fs_modified; // set true if using non-id files
-char com_token[1024];
+char com_token[MAX_INPUTLINE];
int com_argc;
const char **com_argv;
-// LordHavoc: made commandline 1024 characters instead of 256
-#define CMDLINE_LENGTH 1024
-char com_cmdline[CMDLINE_LENGTH];
+char com_cmdline[MAX_INPUTLINE];
-int gamemode;
+gamemode_t gamemode;
const char *gamename;
const char *gamedirname1;
const char *gamedirname2;
short ShortSwap (short l)
{
- qbyte b1,b2;
+ unsigned char b1,b2;
b1 = l&255;
b2 = (l>>8)&255;
int LongSwap (int l)
{
- qbyte b1,b2,b3,b4;
+ unsigned char b1,b2,b3,b4;
b1 = l&255;
b2 = (l>>8)&255;
union
{
float f;
- qbyte b[4];
+ unsigned char b[4];
} dat1, dat2;
// Extract integers from buffers
-unsigned int BuffBigLong (const qbyte *buffer)
+unsigned int BuffBigLong (const unsigned char *buffer)
{
return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3];
}
-unsigned short BuffBigShort (const qbyte *buffer)
+unsigned short BuffBigShort (const unsigned char *buffer)
{
return (buffer[0] << 8) | buffer[1];
}
-unsigned int BuffLittleLong (const qbyte *buffer)
+unsigned int BuffLittleLong (const unsigned char *buffer)
{
return (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0];
}
-unsigned short BuffLittleShort (const qbyte *buffer)
+unsigned short BuffLittleShort (const unsigned char *buffer)
{
return (buffer[1] << 8) | buffer[0];
}
0x6e17, 0x7e36, 0x4e55, 0x5e74, 0x2e93, 0x3eb2, 0x0ed1, 0x1ef0
};
-unsigned short CRC_Block(qbyte *data, int size)
+unsigned short CRC_Block(const unsigned char *data, size_t size)
{
unsigned short crc = CRC_INIT_VALUE;
while (size--)
void MSG_WriteChar (sizebuf_t *sb, int c)
{
- qbyte *buf;
+ unsigned char *buf;
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
void MSG_WriteByte (sizebuf_t *sb, int c)
{
- qbyte *buf;
+ unsigned char *buf;
buf = SZ_GetSpace (sb, 1);
buf[0] = c;
void MSG_WriteShort (sizebuf_t *sb, int c)
{
- qbyte *buf;
+ unsigned char *buf;
buf = SZ_GetSpace (sb, 2);
buf[0] = c&0xff;
void MSG_WriteLong (sizebuf_t *sb, int c)
{
- qbyte *buf;
+ unsigned char *buf;
buf = SZ_GetSpace (sb, 4);
buf[0] = c&0xff;
dat.f = f;
dat.l = LittleLong (dat.l);
- SZ_Write (sb, &dat.l, 4);
+ SZ_Write (sb, (unsigned char *)&dat.l, 4);
}
void MSG_WriteString (sizebuf_t *sb, const char *s)
{
if (!s)
- SZ_Write (sb, "", 1);
+ SZ_Write (sb, (unsigned char *)"", 1);
else
- SZ_Write (sb, s, strlen(s)+1);
+ SZ_Write (sb, (unsigned char *)s, (int)strlen(s)+1);
+}
+
+void MSG_WriteUnterminatedString (sizebuf_t *sb, const char *s)
+{
+ if (s)
+ SZ_Write (sb, (unsigned char *)s, (int)strlen(s));
}
void MSG_WriteCoord13i (sizebuf_t *sb, float f)
MSG_WriteFloat (sb, f);
}
-void MSG_WriteCoord (sizebuf_t *sb, float f, int protocol)
+void MSG_WriteCoord (sizebuf_t *sb, float f, protocolversion_t protocol)
{
- if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_NEHAHRAMOVIE)
+ if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE)
MSG_WriteCoord13i (sb, f);
- else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5 || protocol == PROTOCOL_DARKPLACES6)
+ else if (protocol == PROTOCOL_DARKPLACES1)
MSG_WriteCoord32f (sb, f);
else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
MSG_WriteCoord16i (sb, f);
else
- Host_Error("MSG_WriteCoord: unknown protocol\n");
+ MSG_WriteCoord32f (sb, f);
}
-void MSG_WriteVector (sizebuf_t *sb, float *v, int protocol)
+void MSG_WriteVector (sizebuf_t *sb, float *v, protocolversion_t protocol)
{
MSG_WriteCoord (sb, v[0], protocol);
MSG_WriteCoord (sb, v[1], protocol);
MSG_WriteFloat (sb, f);
}
-void MSG_WriteAngle (sizebuf_t *sb, float f, int protocol)
+void MSG_WriteAngle (sizebuf_t *sb, float f, protocolversion_t protocol)
{
- if (protocol == PROTOCOL_DARKPLACES5 || protocol == PROTOCOL_DARKPLACES6)
- MSG_WriteAngle16i (sb, f);
- else
+ if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
MSG_WriteAngle8i (sb, f);
+ else
+ MSG_WriteAngle16i (sb, f);
}
//
char *MSG_ReadString (void)
{
- static char string[2048];
+ static char string[MAX_INPUTLINE];
int l,c;
for (l = 0;l < (int) sizeof(string) - 1 && (c = MSG_ReadChar()) != -1 && c != 0;l++)
string[l] = c;
return MSG_ReadLittleFloat();
}
-float MSG_ReadCoord (int protocol)
+float MSG_ReadCoord (protocolversion_t protocol)
{
- if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_NEHAHRAMOVIE)
+ if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE)
return MSG_ReadCoord13i();
- else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5 || protocol == PROTOCOL_DARKPLACES6)
+ else if (protocol == PROTOCOL_DARKPLACES1)
return MSG_ReadCoord32f();
else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
return MSG_ReadCoord16i();
- Host_Error("MSG_ReadCoord: unknown protocol\n");
- return 0;
+ else
+ return MSG_ReadCoord32f();
}
-void MSG_ReadVector (float *v, int protocol)
+void MSG_ReadVector (float *v, protocolversion_t protocol)
{
v[0] = MSG_ReadCoord(protocol);
v[1] = MSG_ReadCoord(protocol);
return MSG_ReadFloat ();
}
-float MSG_ReadAngle (int protocol)
+float MSG_ReadAngle (protocolversion_t protocol)
{
- if (protocol == PROTOCOL_DARKPLACES5 || protocol == PROTOCOL_DARKPLACES6)
- return MSG_ReadAngle16i ();
- else
+ if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
return MSG_ReadAngle8i ();
+ else
+ return MSG_ReadAngle16i ();
}
//===========================================================================
-void SZ_Alloc (sizebuf_t *buf, int startsize, const char *name)
-{
- if (startsize < 256)
- startsize = 256;
- buf->mempool = Mem_AllocPool(name, 0, NULL);
- buf->data = Mem_Alloc(buf->mempool, startsize);
- buf->maxsize = startsize;
- buf->cursize = 0;
-}
-
-
-void SZ_Free (sizebuf_t *buf)
-{
- Mem_FreePool(&buf->mempool);
- buf->data = NULL;
- buf->maxsize = 0;
- buf->cursize = 0;
-}
-
void SZ_Clear (sizebuf_t *buf)
{
buf->cursize = 0;
}
-void *SZ_GetSpace (sizebuf_t *buf, int length)
+unsigned char *SZ_GetSpace (sizebuf_t *buf, int length)
{
- void *data;
+ unsigned char *data;
if (buf->cursize + length > buf->maxsize)
{
if (!buf->allowoverflow)
- Host_Error ("SZ_GetSpace: overflow without allowoverflow set\n");
+ Host_Error ("SZ_GetSpace: overflow without allowoverflow set");
if (length > buf->maxsize)
- Host_Error ("SZ_GetSpace: %i is > full buffer size\n", length);
+ Host_Error ("SZ_GetSpace: %i is > full buffer size", length);
buf->overflowed = true;
Con_Print("SZ_GetSpace: overflow\n");
return data;
}
-void SZ_Write (sizebuf_t *buf, const void *data, int length)
+void SZ_Write (sizebuf_t *buf, const unsigned char *data, int length)
{
memcpy (SZ_GetSpace(buf,length),data,length);
}
// all of darkplaces.
static char *hexchar = "0123456789ABCDEF";
-void Com_HexDumpToConsole(const qbyte *data, int size)
+void Com_HexDumpToConsole(const unsigned char *data, int size)
{
int i, j, n;
char text[1024];
char *cur, *flushpointer;
- const qbyte *d;
+ const unsigned char *d;
cur = text;
flushpointer = text + 512;
for (i = 0;i < size;)
}
com_token[len] = 0;
*datapointer = data+1;
- return true;
}
else
{
}
com_token[len] = 0;
*datapointer = data;
- return true;
}
+
+ return true;
}
{
Cvar_Set ("cmdline", com_cmdline);
- if (!FS_FileExists("gfx/pop.lmp"))
+ if (gamemode == GAME_NORMAL && !FS_FileExists("gfx/pop.lmp"))
{
if (fs_modified)
Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
{
// arg contains whitespace, store quotes around it
com_cmdline[n++] = '\"';
- while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
+ while ((n < ((int)sizeof(com_cmdline) - 1)) && com_argv[j][i])
com_cmdline[n++] = com_argv[j][i++];
com_cmdline[n++] = '\"';
}
else
{
- while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
+ while ((n < ((int)sizeof(com_cmdline) - 1)) && com_argv[j][i])
com_cmdline[n++] = com_argv[j][i++];
}
- if (n < (CMDLINE_LENGTH - 1))
+ if (n < ((int)sizeof(com_cmdline) - 1))
com_cmdline[n++] = ' ';
else
break;
// Game mods
-typedef struct
+typedef struct gamemode_info_s
{
const char* prog_name;
const char* cmdline;
{ "battlemech", "-battlemech", "Battlemech", "base", NULL, "battlemech", "battlemech" },
// GAME_ZYMOTIC
// COMMANDLINEOPTION: Game: -zymotic runs the singleplayer game Zymotic
-{ "zymotic", "-zymotic", "Zymotic", "data", NULL, "zymotic", "zymotic" },
+{ "zymotic", "-zymotic", "Zymotic", "basezym", NULL, "zymotic", "zymotic" },
// GAME_FNIGGIUM
// COMMANDLINEOPTION: Game: -fniggium runs the post apocalyptic melee RPG Fniggium
{ "fniggium", "-fniggium", "Fniggium", "data", NULL, "fniggium", "fniggium" },
{ "neoteric", "-neoteric", "Neoteric", "id1", "neobase", "neo", "darkplaces" },
// GAME_OPENQUARTZ
// COMMANDLINEOPTION: Game: -openquartz runs the game OpenQuartz, a standalone GPL replacement of the quake content
-{ "openquartz", "-openquartz", "OpenQuartz", "id1", NULL, "openquartz", "darkplaces"},
+{ "openquartz", "-openquartz", "OpenQuartz", "id1", NULL, "openquartz", "darkplaces" },
// GAME_PRYDON
// COMMANDLINEOPTION: Game: -prydon runs the topdown point and click action-RPG Prydon Gate
-{ "prydon", "-prydon", "PrydonGate", "id1", "prydon", "prydon", "darkplaces"},
+{ "prydon", "-prydon", "PrydonGate", "id1", "prydon", "prydon", "darkplaces" },
// GAME_NETHERWORLD
-// COMMANDLINEOPTION: Game: -netherworld runs the game Netherworld: Dark Masters
-{ "netherworld", "-netherworld", "Dark Masters", "id1", "netherworld", "nw", "darkplaces"},
+// COMMANDLINEOPTION: Game: -netherworld runs the game Netherworld: Dark Master
+{ "netherworld", "-netherworld", "Netherworld: Dark Master", "id1", "netherworld", "nw", "darkplaces" },
+// GAME_THEHUNTED
+// COMMANDLINEOPTION: Game: -thehunted runs the game The Hunted
+{ "thehunted", "-thehunted", "The Hunted", "thdata", NULL, "th", "thehunted" },
+// GAME_DEFEATINDETAIL2
+// COMMANDLINEOPTION: Game: -did2 runs the game Defeat In Detail 2
+{ "did2", "-did2", "Defeat In Detail 2", "data", NULL, "did2_", "did2" },
};
void COM_InitGameType (void)
for (i = 1; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
if (strstr (name, gamemode_info[i].prog_name))
{
- gamemode = i;
+ gamemode = (gamemode_t)i;
break;
}
for (i = 0; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
if (COM_CheckParm (gamemode_info[i].cmdline))
{
- gamemode = i;
+ gamemode = (gamemode_t)i;
break;
}
}
-extern void Mathlib_Init(void);
-extern void FS_Init (void);
-
/*
================
COM_Init
================
*/
-void COM_Init (void)
+void COM_Init_Commands (void)
{
Cvar_RegisterVariable (®istered);
Cvar_RegisterVariable (&cmdline);
-
- Mathlib_Init();
-
- FS_Init ();
- COM_CheckRegistered ();
-}
-
-extern void FS_Shutdown (void);
-
-/*
-================
-COM_Shutdown
-================
-*/
-void COM_Shutdown (void)
-{
- FS_Shutdown ();
}
/*
s = string[stringindex];
stringindex = (stringindex + 1) & 7;
va_start (argptr, format);
- vsnprintf (s, sizeof (string[0]), format,argptr);
+ dpvsnprintf (s, sizeof (string[0]), format,argptr);
va_end (argptr);
return s;
}
+//======================================
+
+// snprintf and vsnprintf are NOT portable. Use their DP counterparts instead
+
+#undef snprintf
+#undef vsnprintf
+
+#ifdef WIN32
+# define snprintf _snprintf
+# define vsnprintf _vsnprintf
+#endif
+
+
+int dpsnprintf (char *buffer, size_t buffersize, const char *format, ...)
+{
+ va_list args;
+ int result;
+
+ va_start (args, format);
+ result = dpvsnprintf (buffer, buffersize, format, args);
+ va_end (args);
+
+ return result;
+}
+
+
+int dpvsnprintf (char *buffer, size_t buffersize, const char *format, va_list args)
+{
+ int result;
+
+ result = vsnprintf (buffer, buffersize, format, args);
+ if (result < 0 || (size_t)result >= buffersize)
+ {
+ buffer[buffersize - 1] = '\0';
+ return -1;
+ }
+
+ return result;
+}
+
+
//======================================
void COM_ToLowerString (const char *in, char *out, size_t size_out)
l = *text;
commentprefixlength = 0;
if (commentprefix)
- commentprefixlength = strlen(commentprefix);
+ commentprefixlength = (int)strlen(commentprefix);
while (*l && *l != '\n' && *l != '\r')
{
if (*l > ' ')
// written by Elric, thanks Elric!
char *SearchInfostring(const char *infostring, const char *key)
{
- static char value [256];
- char crt_key [256];
+ static char value [MAX_INPUTLINE];
+ char crt_key [MAX_INPUTLINE];
size_t value_ind, key_ind;
char c;