X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=common.c;h=74d26067a8d79d74a3f1dca692b7ba59940da51b;hb=49961f0cb9582769e9a181ef319fd55e65ee5a34;hp=89d73de3d0cfc7823805cd620cb2de7c6a53ee0c;hpb=435b52972823fa8e8ceb9b67797ca3f886f6208a;p=xonotic%2Fdarkplaces.git

diff --git a/common.c b/common.c
index 89d73de3..74d26067 100644
--- a/common.c
+++ b/common.c
@@ -40,10 +40,12 @@ const char **com_argv;
 #define CMDLINE_LENGTH	1024
 char com_cmdline[CMDLINE_LENGTH];
 
-int gamemode;
+gamemode_t gamemode;
 const char *gamename;
-const char *gamedirname;
+const char *gamedirname1;
+const char *gamedirname2;
 const char *gamescreenshotname;
+const char *gameuserdirname;
 char com_modname[MAX_OSPATH] = "";
 
 
@@ -118,6 +120,66 @@ unsigned short BuffLittleShort (const qbyte *buffer)
 }
 
 
+/*
+============================================================================
+
+					CRC FUNCTIONS
+
+============================================================================
+*/
+
+// this is a 16 bit, non-reflected CRC using the polynomial 0x1021
+// and the initial and final xor values shown below...  in other words, the
+// CCITT standard CRC used by XMODEM
+
+#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
+};
+
+unsigned short CRC_Block(qbyte *data, int size)
+{
+	unsigned short crc = CRC_INIT_VALUE;
+	while (size--)
+		crc = (crc << 8) ^ crctable[(crc >> 8) ^ (*data++)];
+	return crc ^ CRC_XOR_VALUE;
+}
+
+
 /*
 ==============================================================================
 
@@ -193,17 +255,17 @@ void MSG_WriteString (sizebuf_t *sb, const char *s)
 void MSG_WriteCoord13i (sizebuf_t *sb, float f)
 {
 	if (f >= 0)
-		MSG_WriteShort (sb, (int)(f * 8.0f + 0.5f));
+		MSG_WriteShort (sb, (int)(f * 8.0 + 0.5));
 	else
-		MSG_WriteShort (sb, (int)(f * 8.0f - 0.5f));
+		MSG_WriteShort (sb, (int)(f * 8.0 - 0.5));
 }
 
 void MSG_WriteCoord16i (sizebuf_t *sb, float f)
 {
 	if (f >= 0)
-		MSG_WriteShort (sb, (int)(f + 0.5f));
+		MSG_WriteShort (sb, (int)(f + 0.5));
 	else
-		MSG_WriteShort (sb, (int)(f - 0.5f));
+		MSG_WriteShort (sb, (int)(f - 0.5));
 }
 
 void MSG_WriteCoord32f (sizebuf_t *sb, float f)
@@ -213,9 +275,9 @@ void MSG_WriteCoord32f (sizebuf_t *sb, float f)
 
 void MSG_WriteCoord (sizebuf_t *sb, float f, int protocol)
 {
-	if (protocol == PROTOCOL_QUAKE)
+	if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_NEHAHRAMOVIE)
 		MSG_WriteCoord13i (sb, f);
-	else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5)
+	else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5 || protocol == PROTOCOL_DARKPLACES6)
 		MSG_WriteCoord32f (sb, f);
 	else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
 		MSG_WriteCoord16i (sb, f);
@@ -234,17 +296,17 @@ void MSG_WriteVector (sizebuf_t *sb, float *v, int protocol)
 void MSG_WriteAngle8i (sizebuf_t *sb, float f)
 {
 	if (f >= 0)
-		MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) + 0.5f) & 255);
+		MSG_WriteByte (sb, (int)(f*(256.0/360.0) + 0.5) & 255);
 	else
-		MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) - 0.5f) & 255);
+		MSG_WriteByte (sb, (int)(f*(256.0/360.0) - 0.5) & 255);
 }
 
 void MSG_WriteAngle16i (sizebuf_t *sb, float f)
 {
 	if (f >= 0)
-		MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) + 0.5f) & 65535);
+		MSG_WriteShort (sb, (int)(f*(65536.0/360.0) + 0.5) & 65535);
 	else
-		MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) - 0.5f) & 65535);
+		MSG_WriteShort (sb, (int)(f*(65536.0/360.0) - 0.5) & 65535);
 }
 
 void MSG_WriteAngle32f (sizebuf_t *sb, float f)
@@ -252,6 +314,13 @@ void MSG_WriteAngle32f (sizebuf_t *sb, float f)
 	MSG_WriteFloat (sb, f);
 }
 
+void MSG_WriteAngle (sizebuf_t *sb, float f, int protocol)
+{
+	if (protocol == PROTOCOL_DARKPLACES5 || protocol == PROTOCOL_DARKPLACES6)
+		MSG_WriteAngle16i (sb, f);
+	else
+		MSG_WriteAngle8i (sb, f);
+}
 
 //
 // reading functions
@@ -363,7 +432,7 @@ int MSG_ReadBytes (int numbytes, unsigned char *out)
 
 float MSG_ReadCoord13i (void)
 {
-	return MSG_ReadLittleShort() * (1.0f/8.0f);
+	return MSG_ReadLittleShort() * (1.0/8.0);
 }
 
 float MSG_ReadCoord16i (void)
@@ -378,9 +447,9 @@ float MSG_ReadCoord32f (void)
 
 float MSG_ReadCoord (int protocol)
 {
-	if (protocol == PROTOCOL_QUAKE)
+	if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_NEHAHRAMOVIE)
 		return MSG_ReadCoord13i();
-	else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5)
+	else if (protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES5 || protocol == PROTOCOL_DARKPLACES6)
 		return MSG_ReadCoord32f();
 	else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4)
 		return MSG_ReadCoord16i();
@@ -398,12 +467,12 @@ void MSG_ReadVector (float *v, int protocol)
 // LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
 float MSG_ReadAngle8i (void)
 {
-	return MSG_ReadByte () * (360.0f/256.0f);
+	return (signed char) MSG_ReadByte () * (360.0/256.0);
 }
 
 float MSG_ReadAngle16i (void)
 {
-	return MSG_ReadShort () * (360.0f/65536.0f);
+	return (signed short)MSG_ReadShort () * (360.0/65536.0);
 }
 
 float MSG_ReadAngle32f (void)
@@ -411,27 +480,16 @@ float MSG_ReadAngle32f (void)
 	return MSG_ReadFloat ();
 }
 
-
-//===========================================================================
-
-void SZ_Alloc (sizebuf_t *buf, int startsize, const char *name)
+float MSG_ReadAngle (int protocol)
 {
-	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;
+	if (protocol == PROTOCOL_DARKPLACES5 || protocol == PROTOCOL_DARKPLACES6)
+		return MSG_ReadAngle16i ();
+	else
+		return MSG_ReadAngle8i ();
 }
 
 
-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)
 {
@@ -504,7 +562,7 @@ void Com_HexDumpToConsole(const qbyte *data, int size)
 				*cur++ = ' ';
 				*cur++ = ' ';
 			}
-			if ((j & 3) == 0)
+			if ((j & 3) == 3)
 				*cur++ = ' ';
 		}
 		// print text
@@ -563,7 +621,11 @@ int COM_ParseToken(const char **datapointer, int returnnewline)
 
 // skip whitespace
 skipwhite:
-	for (;*data <= ' ' && (*data != '\n' || !returnnewline);data++)
+	// line endings:
+	// UNIX: \n
+	// Mac: \r
+	// Windows: \r\n
+	for (;*data <= ' ' && ((*data != '\n' && *data != '\r') || !returnnewline);data++)
 	{
 		if (*data == 0)
 		{
@@ -573,10 +635,14 @@ skipwhite:
 		}
 	}
 
+	// handle Windows line ending
+	if (data[0] == '\r' && data[1] == '\n')
+		data++;
+
 	if (data[0] == '/' && data[1] == '/')
 	{
 		// comment
-		while (*data && *data != '\n')
+		while (*data && *data != '\n' && *data != '\r')
 			data++;
 		goto skipwhite;
 	}
@@ -594,6 +660,8 @@ skipwhite:
 		// quoted string
 		for (data++;*data != '\"';data++)
 		{
+			if (*data == '\\' && data[1] == '"' )
+				data++;
 			if (!*data || len >= (int)sizeof(com_token) - 1)
 			{
 				com_token[0] = 0;
@@ -606,6 +674,33 @@ skipwhite:
 		*datapointer = data+1;
 		return true;
 	}
+	else if (*data == '\'')
+	{
+		// quoted string
+		for (data++;*data != '\'';data++)
+		{
+			if (*data == '\\' && data[1] == '\'' )
+				data++;
+			if (!*data || len >= (int)sizeof(com_token) - 1)
+			{
+				com_token[0] = 0;
+				*datapointer = NULL;
+				return false;
+			}
+			com_token[len++] = *data;
+		}
+		com_token[len] = 0;
+		*datapointer = data+1;
+		return true;
+	}
+	else if (*data == '\r')
+	{
+		// translate Mac line ending to UNIX
+		com_token[len++] = '\n';
+		com_token[len] = 0;
+		*datapointer = data;
+		return true;
+	}
 	else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == '\'' || *data == ':' || *data == ',' || *data == ';')
 	{
 		// single character
@@ -617,7 +712,7 @@ skipwhite:
 	else
 	{
 		// regular word
-		for (;*data > ' ' && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != '\'' && *data != ':' && *data != ',' && *data != ';';data++)
+		for (;*data > ' ' && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != '\'' && *data != ':' && *data != ',' && *data != ';' && *data != '\'' && *data != '"';data++)
 		{
 			if (len >= (int)sizeof(com_token) - 1)
 			{
@@ -669,7 +764,7 @@ skipwhite:
 	if (*data == '/' && data[1] == '/')
 	{
 		// comment
-		while (*data && *data != '\n')
+		while (*data && *data != '\n' && *data != '\r')
 			data++;
 		goto skipwhite;
 	}
@@ -774,8 +869,19 @@ void COM_InitArgv (void)
 	for (j = 0;(j < MAX_NUM_ARGVS) && (j < com_argc);j++)
 	{
 		i = 0;
-		while ((n < (CMDLINE_LENGTH - 1)) && com_argv[j][i])
-			com_cmdline[n++] = com_argv[j][i++];
+		if (strstr(com_argv[j], " "))
+		{
+			// arg contains whitespace, store quotes around it
+			com_cmdline[n++] = '\"';
+			while ((n < (CMDLINE_LENGTH - 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])
+				com_cmdline[n++] = com_argv[j][i++];
+		}
 		if (n < (CMDLINE_LENGTH - 1))
 			com_cmdline[n++] = ' ';
 		else
@@ -794,49 +900,72 @@ typedef struct
 	const char* prog_name;
 	const char* cmdline;
 	const char* gamename;
-	const char* gamedirname;
+	const char* gamedirname1;
+	const char* gamedirname2;
 	const char* gamescreenshotname;
+	const char* gameuserdirname;
 } gamemode_info_t;
 
 static const gamemode_info_t gamemode_info [] =
 {// prog_name		cmdline			gamename				gamedirname	gamescreenshotname
 
 // GAME_NORMAL
-{ "",				"-quake",		"DarkPlaces-Quake",		"",			"dp" },
+// COMMANDLINEOPTION: Game: -quake runs the game Quake (default)
+{ "",				"-quake",		"DarkPlaces-Quake",		"id1",		NULL,			"dp",			"darkplaces" },
 // GAME_HIPNOTIC
-{ "hipnotic",		"-hipnotic",	"Darkplaces-Hipnotic",	"hipnotic",	"dp" },
+// COMMANDLINEOPTION: Game: -hipnotic runs Quake mission pack 1: The Scourge of Armagon
+{ "hipnotic",		"-hipnotic",	"Darkplaces-Hipnotic",	"id1",		"hipnotic",		"dp",			"darkplaces" },
 // GAME_ROGUE
-{ "rogue",			"-rogue",		"Darkplaces-Rogue",		"rogue",	"dp" },
+// COMMANDLINEOPTION: Game: -rogue runs Quake mission pack 2: The Dissolution of Eternity
+{ "rogue",			"-rogue",		"Darkplaces-Rogue",		"id1",		"rogue",		"dp",			"darkplaces" },
 // GAME_NEHAHRA
-{ "nehahra",		"-nehahra",		"DarkPlaces-Nehahra",	"nehahra",	"dp" },
+// COMMANDLINEOPTION: Game: -nehahra runs The Seal of Nehahra movie and game
+{ "nehahra",		"-nehahra",		"DarkPlaces-Nehahra",	"id1",		"nehahra",		"dp",			"darkplaces" },
 // GAME_NEXUIZ
-{ "nexuiz",			"-nexuiz",		"Nexuiz",				"data",		"nexuiz" },
+// COMMANDLINEOPTION: Game: -nexuiz runs the multiplayer game Nexuiz
+{ "nexuiz",			"-nexuiz",		"Nexuiz",				"data",		NULL,			"nexuiz",		"nexuiz" },
 // GAME_TRANSFUSION
-{ "transfusion",	"-transfusion",	"Transfusion",			"basetf",	"transfusion" },
+// COMMANDLINEOPTION: Game: -transfusion runs Transfusion (the recreation of Blood in Quake)
+{ "transfusion",	"-transfusion",	"Transfusion",			"basetf",	NULL,			"transfusion",	"transfusion" },
 // GAME_GOODVSBAD2
-{ "gvb2",			"-goodvsbad2",	"GoodVs.Bad2",			"rts",		"gvb2" },
+// COMMANDLINEOPTION: Game: -goodvsbad2 runs the psychadelic RTS FPS game Good Vs Bad 2
+{ "gvb2",			"-goodvsbad2",	"GoodVs.Bad2",			"rts",		NULL,			"gvb2",			"gvb2" },
 // GAME_TEU
-{ "teu",			"-teu",			"TheEvilUnleashed",		"baseteu",	"teu" },
+// COMMANDLINEOPTION: Game: -teu runs The Evil Unleashed (this option is obsolete as they are not using darkplaces)
+{ "teu",			"-teu",			"TheEvilUnleashed",		"baseteu",	NULL,			"teu",			"teu" },
 // GAME_BATTLEMECH
-{ "battlemech",		"-battlemech",	"Battlemech",			"base",		"battlemech" },
+// COMMANDLINEOPTION: Game: -battlemech runs the multiplayer topdown deathmatch game BattleMech
+{ "battlemech",		"-battlemech",	"Battlemech",			"base",		NULL,			"battlemech",	"battlemech" },
 // GAME_ZYMOTIC
-{ "zymotic",		"-zymotic",		"Zymotic",				"data",		"zymotic" },
+// COMMANDLINEOPTION: Game: -zymotic runs the singleplayer game Zymotic
+{ "zymotic",		"-zymotic",		"Zymotic",				"data",		NULL,			"zymotic",		"zymotic" },
 // GAME_FNIGGIUM
-{ "fniggium",		"-fniggium",	"Fniggium",				"data",		"fniggium" },
+// COMMANDLINEOPTION: Game: -fniggium runs the post apocalyptic melee RPG Fniggium
+{ "fniggium",		"-fniggium",	"Fniggium",				"data",		NULL,			"fniggium",		"fniggium" },
 // GAME_SETHERAL
-{ "setheral",		"-setheral",	"Setheral",				"data",		"setheral" },
+// COMMANDLINEOPTION: Game: -setheral runs the multiplayer game Setheral
+{ "setheral",		"-setheral",	"Setheral",				"data",		NULL,			"setheral",		"setheral" },
 // GAME_SOM
-{ "som",			"-som",			"Son of Man",			"sonofman",	"som" },
+// COMMANDLINEOPTION: Game: -som runs the multiplayer game Son Of Man
+{ "som",			"-som",			"Son of Man",			"id1",		"sonofman",		"som",			"darkplaces" },
 // GAME_TENEBRAE
-{ "tenebrae",		"-tenebrae",	"DarkPlaces-Tenebrae",	"tenebrae",	"dp" },
+// COMMANDLINEOPTION: Game: -tenebrae runs the graphics test mod known as Tenebrae (some features not implemented)
+{ "tenebrae",		"-tenebrae",	"DarkPlaces-Tenebrae",	"id1",		"tenebrae",		"dp",			"darkplaces" },
 // GAME_NEOTERIC
-{ "neoteric",		"-neoteric",	"Neoteric",				"neobase",	"neo" },
+// COMMANDLINEOPTION: Game: -neoteric runs the game Neoteric
+{ "neoteric",		"-neoteric",	"Neoteric",				"id1",		"neobase",		"neo",			"darkplaces" },
 // GAME_OPENQUARTZ
-{ "openquartz",		"-openquartz",	"OpenQuartz",			"id1",		"openquartz"},
+// COMMANDLINEOPTION: Game: -openquartz runs the game OpenQuartz, a standalone GPL replacement of the quake content
+{ "openquartz",		"-openquartz",	"OpenQuartz",			"id1",		NULL,			"openquartz",	"darkplaces"},
 // GAME_PRYDON
-{ "prydon",			"-prydon",		"PrydonGate",			"prydon",	"prydon"},
+// COMMANDLINEOPTION: Game: -prydon runs the topdown point and click action-RPG Prydon Gate
+{ "prydon",			"-prydon",		"PrydonGate",			"id1",		"prydon",		"prydon",		"darkplaces"},
 // GAME_NETHERWORLD
-{ "netherworld",	"-netherworld",	"Dark Masters",			"netherworld", 	"nw"},
+// COMMANDLINEOPTION: Game: -netherworld runs the game Netherworld: Dark Masters
+{ "netherworld",	"-netherworld",	"Dark Masters",			"id1",		"netherworld", 	"nw",			"darkplaces"},
+// GAME_THEHUNTED
+// COMMANDLINEOPTION: Game: -netherworld runs the game The Hunted
+{ "thehunted",		"-thehunted",	"The Hunted",			"thdata",	NULL, 			"th",			"thehunted"},
 };
 
 void COM_InitGameType (void)
@@ -865,8 +994,10 @@ void COM_InitGameType (void)
 		}
 
 	gamename = gamemode_info[gamemode].gamename;
-	gamedirname = gamemode_info[gamemode].gamedirname;
+	gamedirname1 = gamemode_info[gamemode].gamedirname1;
+	gamedirname2 = gamemode_info[gamemode].gamedirname2;
 	gamescreenshotname = gamemode_info[gamemode].gamescreenshotname;
+	gameuserdirname = gamemode_info[gamemode].gameuserdirname;
 }
 
 
@@ -886,10 +1017,20 @@ void COM_Init (void)
 	Mathlib_Init();
 
 	FS_Init ();
-	Log_Init ();
 	COM_CheckRegistered ();
 }
 
+extern void FS_Shutdown (void);
+
+/*
+================
+COM_Shutdown
+================
+*/
+void COM_Shutdown (void)
+{
+	FS_Shutdown ();
+}
 
 /*
 ============
@@ -910,13 +1051,54 @@ char *va(const char *format, ...)
 	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)
@@ -970,13 +1152,13 @@ int COM_ReadAndTokenizeLine(const char **text, char **argv, int maxargc, char *t
 	commentprefixlength = 0;
 	if (commentprefix)
 		commentprefixlength = strlen(commentprefix);
-	while (*l && *l != '\n')
+	while (*l && *l != '\n' && *l != '\r')
 	{
 		if (*l > ' ')
 		{
 			if (commentprefixlength && !strncmp(l, commentprefix, commentprefixlength))
 			{
-				while (*l && *l != '\n')
+				while (*l && *l != '\n' && *l != '\r')
 					l++;
 				break;
 			}
@@ -1011,6 +1193,12 @@ int COM_ReadAndTokenizeLine(const char **text, char **argv, int maxargc, char *t
 		else
 			l++;
 	}
+	// line endings:
+	// UNIX: \n
+	// Mac: \r
+	// Windows: \r\n
+	if (*l == '\r')
+		l++;
 	if (*l == '\n')
 		l++;
 	*text = l;