Cleaned up alot more memory leaks. (still get 720 leaks just running demo1.dem)
[xonotic/darkplaces.git] / common.c
index 8af5518..b45c996 100644 (file)
--- a/common.c
+++ b/common.c
@@ -41,9 +41,10 @@ const char **com_argv;
 char com_cmdline[CMDLINE_LENGTH];
 
 int gamemode;
-char *gamename;
-char *gamedirname;
-char com_modname[MAX_OSPATH];
+const char *gamename;
+const char *gamedirname;
+const char *gamescreenshotname;
+char com_modname[MAX_OSPATH] = "";
 
 
 /*
@@ -54,15 +55,6 @@ char com_modname[MAX_OSPATH];
 ============================================================================
 */
 
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-short   (*BigShort) (short l);
-short   (*LittleShort) (short l);
-int     (*BigLong) (int l);
-int     (*LittleLong) (int l);
-float   (*BigFloat) (float l);
-float   (*LittleFloat) (float l);
-#endif
-
 short   ShortSwap (short l)
 {
        qbyte    b1,b2;
@@ -73,13 +65,6 @@ short   ShortSwap (short l)
        return (b1<<8) + b2;
 }
 
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-short   ShortNoSwap (short l)
-{
-       return l;
-}
-#endif
-
 int    LongSwap (int l)
 {
        qbyte    b1,b2,b3,b4;
@@ -92,13 +77,6 @@ int    LongSwap (int l)
        return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
 }
 
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-int     LongNoSwap (int l)
-{
-       return l;
-}
-#endif
-
 float FloatSwap (float f)
 {
        union
@@ -116,13 +94,6 @@ float FloatSwap (float f)
        return dat2.f;
 }
 
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-float FloatNoSwap (float f)
-{
-       return f;
-}
-#endif
-
 
 // Extract integers from buffers
 
@@ -148,6 +119,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;
+}
+
+
+/*
 ==============================================================================
 
                        MESSAGE IO FUNCTIONS
@@ -219,30 +250,74 @@ void MSG_WriteString (sizebuf_t *sb, const char *s)
                SZ_Write (sb, s, strlen(s)+1);
 }
 
-// used by server (always latest PROTOCOL_DARKPLACES)
-void MSG_WriteDPCoord (sizebuf_t *sb, float f)
+void MSG_WriteCoord13i (sizebuf_t *sb, float f)
 {
        if (f >= 0)
-               MSG_WriteShort (sb, (int)(f + 0.5f));
+               MSG_WriteShort (sb, (int)(f * 8.0 + 0.5));
        else
-               MSG_WriteShort (sb, (int)(f - 0.5f));
+               MSG_WriteShort (sb, (int)(f * 8.0 - 0.5));
 }
 
-void MSG_WritePreciseAngle (sizebuf_t *sb, float f)
+void MSG_WriteCoord16i (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 + 0.5));
+       else
+               MSG_WriteShort (sb, (int)(f - 0.5));
+}
+
+void MSG_WriteCoord32f (sizebuf_t *sb, float f)
+{
+       MSG_WriteFloat (sb, f);
+}
+
+void MSG_WriteCoord (sizebuf_t *sb, float f, int protocol)
+{
+       if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_NEHAHRAMOVIE)
+               MSG_WriteCoord13i (sb, f);
+       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);
        else
-               MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) - 0.5f) & 65535);
+               Host_Error("MSG_WriteCoord: unknown protocol\n");
+}
+
+void MSG_WriteVector (sizebuf_t *sb, float *v, int protocol)
+{
+       MSG_WriteCoord (sb, v[0], protocol);
+       MSG_WriteCoord (sb, v[1], protocol);
+       MSG_WriteCoord (sb, v[2], protocol);
 }
 
 // LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
-void MSG_WriteAngle (sizebuf_t *sb, float f)
+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.0/360.0) - 0.5) & 255);
+}
+
+void MSG_WriteAngle16i (sizebuf_t *sb, float f)
+{
+       if (f >= 0)
+               MSG_WriteShort (sb, (int)(f*(65536.0/360.0) + 0.5) & 65535);
+       else
+               MSG_WriteShort (sb, (int)(f*(65536.0/360.0) - 0.5) & 65535);
+}
+
+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_WriteByte (sb, (int)(f*(256.0f/360.0f) - 0.5f) & 255);
+               MSG_WriteAngle8i (sb, f);
 }
 
 //
@@ -353,21 +428,62 @@ int MSG_ReadBytes (int numbytes, unsigned char *out)
        return l;
 }
 
-// used by server (always latest PROTOCOL_DARKPLACES)
-float MSG_ReadDPCoord (void)
+float MSG_ReadCoord13i (void)
+{
+       return MSG_ReadLittleShort() * (1.0/8.0);
+}
+
+float MSG_ReadCoord16i (void)
 {
        return (signed short) MSG_ReadLittleShort();
 }
 
-// used by client
-float MSG_ReadCoord (void)
+float MSG_ReadCoord32f (void)
+{
+       return MSG_ReadLittleFloat();
+}
+
+float MSG_ReadCoord (int protocol)
+{
+       if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_NEHAHRAMOVIE)
+               return MSG_ReadCoord13i();
+       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();
+       Host_Error("MSG_ReadCoord: unknown protocol\n");
+       return 0;
+}
+
+void MSG_ReadVector (float *v, int protocol)
+{
+       v[0] = MSG_ReadCoord(protocol);
+       v[1] = MSG_ReadCoord(protocol);
+       v[2] = MSG_ReadCoord(protocol);
+}
+
+// LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
+float MSG_ReadAngle8i (void)
+{
+       return (signed char) MSG_ReadByte () * (360.0/256.0);
+}
+
+float MSG_ReadAngle16i (void)
 {
-       if (cl.protocol == PROTOCOL_DARKPLACES2 || cl.protocol == PROTOCOL_DARKPLACES3 || cl.protocol == PROTOCOL_DARKPLACES4)
-               return (signed short) MSG_ReadLittleShort();
-       else if (cl.protocol == PROTOCOL_DARKPLACES1)
-               return MSG_ReadLittleFloat();
+       return (signed short)MSG_ReadShort () * (360.0/65536.0);
+}
+
+float MSG_ReadAngle32f (void)
+{
+       return MSG_ReadFloat ();
+}
+
+float MSG_ReadAngle (int protocol)
+{
+       if (protocol == PROTOCOL_DARKPLACES5 || protocol == PROTOCOL_DARKPLACES6)
+               return MSG_ReadAngle16i ();
        else
-               return MSG_ReadLittleShort() * (1.0f/8.0f);
+               return MSG_ReadAngle8i ();
 }
 
 
@@ -377,7 +493,7 @@ void SZ_Alloc (sizebuf_t *buf, int startsize, const char *name)
 {
        if (startsize < 256)
                startsize = 256;
-       buf->mempool = Mem_AllocPool(name);
+       buf->mempool = Mem_AllocPool(name, 0, NULL);
        buf->data = Mem_Alloc(buf->mempool, startsize);
        buf->maxsize = startsize;
        buf->cursize = 0;
@@ -410,7 +526,7 @@ void *SZ_GetSpace (sizebuf_t *buf, int length)
                        Host_Error ("SZ_GetSpace: %i is > full buffer size\n", length);
 
                buf->overflowed = true;
-               Con_Print("SZ_GetSpace: overflow\n");
+               Con_Print("SZ_GetSpace: overflow\n");
                SZ_Clear (buf);
        }
 
@@ -444,39 +560,47 @@ void Com_HexDumpToConsole(const qbyte *data, int size)
                if (n > size - i)
                        n = size - i;
                d = data + i;
+               // print offset
                *cur++ = hexchar[(i >> 12) & 15];
                *cur++ = hexchar[(i >>  8) & 15];
                *cur++ = hexchar[(i >>  4) & 15];
                *cur++ = hexchar[(i >>  0) & 15];
                *cur++ = ':';
-               for (j = 0;j < n;j++)
+               // print hex
+               for (j = 0;j < 16;j++)
                {
-                       if (j & 1)
+                       if (j < n)
                        {
-                               *cur++ = hexchar[(d[j] >> 4) & 15] | 0x80;
-                               *cur++ = hexchar[(d[j] >> 0) & 15] | 0x80;
+                               *cur++ = hexchar[(d[j] >> 4) & 15];
+                               *cur++ = hexchar[(d[j] >> 0) & 15];
                        }
                        else
                        {
-                               *cur++ = hexchar[(d[j] >> 4) & 15];
-                               *cur++ = hexchar[(d[j] >> 0) & 15];
+                               *cur++ = ' ';
+                               *cur++ = ' ';
                        }
+                       if ((j & 3) == 3)
+                               *cur++ = ' ';
                }
-               for (;j < 16;j++)
+               // print text
+               for (j = 0;j < 16;j++)
                {
-                       *cur++ = ' ';
-                       *cur++ = ' ';
+                       if (j < n)
+                       {
+                               if (d[j] >= ' ' && d[j] <= 127)
+                                       *cur++ = d[j];
+                               else
+                                       *cur++ = '.';
+                       }
+                       else
+                               *cur++ = ' ';
                }
-               for (j = 0;j < n;j++)
-                       *cur++ = (d[j] >= ' ' && d[j] <= 0x7E) ? d[j] : '.';
-               for (;j < 16;j++)
-                       *cur++ = ' ';
                *cur++ = '\n';
                i += n;
                if (cur >= flushpointer || i >= size)
                {
                        *cur++ = 0;
-                       Con_Printf("%s", text);
+                       Con_Print(text);
                        cur = text;
                }
        }
@@ -545,6 +669,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;
@@ -556,7 +682,26 @@ skipwhite:
                com_token[len] = 0;
                *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 == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == '\'' || *data == ':' || *data == ',' || *data == ';')
        {
                // single character
@@ -568,7 +713,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)
                        {
@@ -701,14 +846,14 @@ void COM_CheckRegistered (void)
        if (!FS_FileExists("gfx/pop.lmp"))
        {
                if (fs_modified)
-                       Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
+                       Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
                else
-                       Con_Print("Playing shareware version.\n");
+                       Con_Print("Playing shareware version.\n");
                return;
        }
 
        Cvar_Set ("registered", "1");
-       Con_Print("Playing registered version.\n");
+       Con_Print("Playing registered version.\n");
 }
 
 
@@ -725,8 +870,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
@@ -735,124 +891,107 @@ void COM_InitArgv (void)
        com_cmdline[n] = 0;
 }
 
+
+//===========================================================================
+
+// Game mods
+
+typedef struct
+{
+       const char* prog_name;
+       const char* cmdline;
+       const char* gamename;
+       const char* gamedirname;
+       const char* gamescreenshotname;
+} gamemode_info_t;
+
+static const gamemode_info_t gamemode_info [] =
+{// prog_name          cmdline                 gamename                                gamedirname     gamescreenshotname
+
+// GAME_NORMAL
+// COMMANDLINEOPTION: Game: -quake runs the game Quake (default)
+{ "",                          "-quake",               "DarkPlaces-Quake",             "",                     "dp" },
+// GAME_HIPNOTIC
+// COMMANDLINEOPTION: Game: -hipnotic runs Quake mission pack 1: The Scourge of Armagon
+{ "hipnotic",          "-hipnotic",    "Darkplaces-Hipnotic",  "hipnotic",     "dp" },
+// GAME_ROGUE
+// COMMANDLINEOPTION: Game: -rogue runs Quake mission pack 2: The Dissolution of Eternity
+{ "rogue",                     "-rogue",               "Darkplaces-Rogue",             "rogue",        "dp" },
+// GAME_NEHAHRA
+// COMMANDLINEOPTION: Game: -nehahra runs The Seal of Nehahra movie and game
+{ "nehahra",           "-nehahra",             "DarkPlaces-Nehahra",   "nehahra",      "dp" },
+// GAME_NEXUIZ
+// COMMANDLINEOPTION: Game: -nexuiz runs the multiplayer game Nexuiz
+{ "nexuiz",                    "-nexuiz",              "Nexuiz",                               "data",         "nexuiz" },
+// GAME_TRANSFUSION
+// COMMANDLINEOPTION: Game: -transfusion runs Transfusion (the recreation of Blood in Quake)
+{ "transfusion",       "-transfusion", "Transfusion",                  "basetf",       "transfusion" },
+// GAME_GOODVSBAD2
+// COMMANDLINEOPTION: Game: -goodvsbad2 runs the psychadelic RTS FPS game Good Vs Bad 2
+{ "gvb2",                      "-goodvsbad2",  "GoodVs.Bad2",                  "rts",          "gvb2" },
+// GAME_TEU
+// COMMANDLINEOPTION: Game: -teu runs The Evil Unleashed (this option is obsolete as they are not using darkplaces)
+{ "teu",                       "-teu",                 "TheEvilUnleashed",             "baseteu",      "teu" },
+// GAME_BATTLEMECH
+// COMMANDLINEOPTION: Game: -battlemech runs the multiplayer topdown deathmatch game BattleMech 
+{ "battlemech",                "-battlemech",  "Battlemech",                   "base",         "battlemech" },
+// GAME_ZYMOTIC
+// COMMANDLINEOPTION: Game: -zymotic runs the singleplayer game Zymotic
+{ "zymotic",           "-zymotic",             "Zymotic",                              "data",         "zymotic" },
+// GAME_FNIGGIUM
+// COMMANDLINEOPTION: Game: -fniggium runs the post apocalyptic melee RPG Fniggium 
+{ "fniggium",          "-fniggium",    "Fniggium",                             "data",         "fniggium" },
+// GAME_SETHERAL
+// COMMANDLINEOPTION: Game: -setheral runs the multiplayer game Setheral 
+{ "setheral",          "-setheral",    "Setheral",                             "data",         "setheral" },
+// GAME_SOM
+// COMMANDLINEOPTION: Game: -som runs the multiplayer game Son Of Man 
+{ "som",                       "-som",                 "Son of Man",                   "sonofman",     "som" },
+// GAME_TENEBRAE
+// COMMANDLINEOPTION: Game: -tenebrae runs the graphics test mod known as Tenebrae (some features not implemented)
+{ "tenebrae",          "-tenebrae",    "DarkPlaces-Tenebrae",  "tenebrae",     "dp" },
+// GAME_NEOTERIC
+// COMMANDLINEOPTION: Game: -neoteric runs the game Neoteric
+{ "neoteric",          "-neoteric",    "Neoteric",                             "neobase",      "neo" },
+// GAME_OPENQUARTZ
+// COMMANDLINEOPTION: Game: -openquartz runs the game OpenQuartz, a standalone GPL replacement of the quake content
+{ "openquartz",                "-openquartz",  "OpenQuartz",                   "id1",          "openquartz"},
+// GAME_PRYDON
+// COMMANDLINEOPTION: Game: -prydon runs the topdown point and click action-RPG Prydon Gate
+{ "prydon",                    "-prydon",              "PrydonGate",                   "prydon",       "prydon"},
+// GAME_NETHERWORLD
+// COMMANDLINEOPTION: Game: -netherworld runs the game Netherworld: Dark Masters
+{ "netherworld",       "-netherworld", "Dark Masters",                 "netherworld",  "nw"},
+};
+
 void COM_InitGameType (void)
 {
-       char name[MAX_OSPATH];
+       char name [MAX_OSPATH];
+       unsigned int i;
+
        FS_StripExtension (com_argv[0], name, sizeof (name));
        COM_ToLowerString (name, name, sizeof (name));
 
-       if (strstr(name, "transfusion"))
-               gamemode = GAME_TRANSFUSION;
-       else if (strstr(name, "nexuiz"))
-               gamemode = GAME_NEXUIZ;
-       else if (strstr(name, "nehahra"))
-               gamemode = GAME_NEHAHRA;
-       else if (strstr(name, "hipnotic"))
-               gamemode = GAME_HIPNOTIC;
-       else if (strstr(name, "rogue"))
-               gamemode = GAME_ROGUE;
-       else if (strstr(name, "gvb2"))
-               gamemode = GAME_GOODVSBAD2;
-       else if (strstr(name, "teu"))
-               gamemode = GAME_TEU;
-       else if (strstr(name, "battlemech"))
-               gamemode = GAME_BATTLEMECH;
-       else if (strstr(name, "zymotic"))
-               gamemode = GAME_ZYMOTIC;
-       else if (strstr(name, "fniggium"))
-               gamemode = GAME_FNIGGIUM;
-       else if (strstr(name, "setheral"))
-               gamemode = GAME_SETHERAL;
-       else if (strstr(name, "som"))
-               gamemode = GAME_SOM;
-       else
-               gamemode = GAME_NORMAL;
-
-       if (COM_CheckParm ("-transfusion"))
-               gamemode = GAME_TRANSFUSION;
-       else if (COM_CheckParm ("-nexuiz"))
-               gamemode = GAME_NEXUIZ;
-       else if (COM_CheckParm ("-nehahra"))
-               gamemode = GAME_NEHAHRA;
-       else if (COM_CheckParm ("-hipnotic"))
-               gamemode = GAME_HIPNOTIC;
-       else if (COM_CheckParm ("-rogue"))
-               gamemode = GAME_ROGUE;
-       else if (COM_CheckParm ("-quake"))
-               gamemode = GAME_NORMAL;
-       else if (COM_CheckParm ("-goodvsbad2"))
-               gamemode = GAME_GOODVSBAD2;
-       else if (COM_CheckParm ("-teu"))
-               gamemode = GAME_TEU;
-       else if (COM_CheckParm ("-battlemech"))
-               gamemode = GAME_BATTLEMECH;
-       else if (COM_CheckParm ("-zymotic"))
-               gamemode = GAME_ZYMOTIC;
-       else if (COM_CheckParm ("-fniggium"))
-               gamemode = GAME_FNIGGIUM;
-       else if (COM_CheckParm ("-setheral"))
-               gamemode = GAME_SETHERAL;
-       else if (COM_CheckParm ("-som"))
-               gamemode = GAME_SOM;
-
-       switch(gamemode)
-       {
-       case GAME_NORMAL:
-               gamename = "DarkPlaces-Quake";
-               gamedirname = "";
-               break;
-       case GAME_HIPNOTIC:
-               gamename = "Darkplaces-Hipnotic";
-               gamedirname = "hipnotic";
-               break;
-       case GAME_ROGUE:
-               gamename = "Darkplaces-Rogue";
-               gamedirname = "rogue";
-               break;
-       case GAME_NEHAHRA:
-               gamename = "DarkPlaces-Nehahra";
-               gamedirname = "nehahra";
-               break;
-       case GAME_NEXUIZ:
-               gamename = "Nexuiz";
-               gamedirname = "data";
-               break;
-       case GAME_TRANSFUSION:
-               gamename = "Transfusion";
-               gamedirname = "basetf";
-               break;
-       case GAME_GOODVSBAD2:
-               gamename = "GoodVs.Bad2";
-               gamedirname = "rts";
-               break;
-       case GAME_TEU:
-               gamename = "TheEvilUnleashed";
-               gamedirname = "baseteu";
-               break;
-       case GAME_BATTLEMECH:
-               gamename = "Battlemech";
-               gamedirname = "base";
-               break;
-       case GAME_ZYMOTIC:
-               gamename = "Zymotic";
-               gamedirname = "data";
-               break;
-       case GAME_FNIGGIUM:
-               gamename = "Fniggium";
-               gamedirname = "data";
-               break;
-       case GAME_SETHERAL:
-               gamename = "Setheral";
-               gamedirname = "data";
-               break;
-       case GAME_SOM:
-               gamename = "Son of Man";
-               gamedirname = "data";
-               break;
-       default:
-               Sys_Error("COM_InitGameType: unknown gamemode %i\n", gamemode);
-               break;
-       }
+       // Check the binary name; default to GAME_NORMAL (0)
+       gamemode = GAME_NORMAL;
+       for (i = 1; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
+               if (strstr (name, gamemode_info[i].prog_name))
+               {
+                       gamemode = i;
+                       break;
+               }
+
+       // Look for a command-line option
+       for (i = 0; i < sizeof (gamemode_info) / sizeof (gamemode_info[0]); i++)
+               if (COM_CheckParm (gamemode_info[i].cmdline))
+               {
+                       gamemode = i;
+                       break;
+               }
+
+       gamename = gamemode_info[gamemode].gamename;
+       gamedirname = gamemode_info[gamemode].gamedirname;
+       gamescreenshotname = gamemode_info[gamemode].gamescreenshotname;
 }
 
 
@@ -866,42 +1005,26 @@ COM_Init
 */
 void COM_Init (void)
 {
-#if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
-       qbyte swaptest[2] = {1,0};
-
-// set the byte swapping variables in a portable manner
-       if ( *(short *)swaptest == 1)
-       {
-               BigShort = ShortSwap;
-               LittleShort = ShortNoSwap;
-               BigLong = LongSwap;
-               LittleLong = LongNoSwap;
-               BigFloat = FloatSwap;
-               LittleFloat = FloatNoSwap;
-       }
-       else
-       {
-               BigShort = ShortNoSwap;
-               LittleShort = ShortSwap;
-               BigLong = LongNoSwap;
-               LittleLong = LongSwap;
-               BigFloat = FloatNoSwap;
-               LittleFloat = FloatSwap;
-       }
-#endif
-
        Cvar_RegisterVariable (&registered);
        Cvar_RegisterVariable (&cmdline);
 
        Mathlib_Init();
 
        FS_Init ();
-       Con_InitLogging();
        COM_CheckRegistered ();
-
-       COM_InitGameType();
 }
 
+extern void FS_Shutdown (void);
+
+/*
+================
+COM_Shutdown
+================
+*/
+void COM_Shutdown (void)
+{
+       FS_Shutdown ();
+}
 
 /*
 ============