X-Git-Url: http://de.git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=common.c;h=32a57efcfd367bda809468e7c71c3eb008c1daf6;hp=147393cd909fa2e6946c652512576f81d04d199b;hb=be511c50c3e4e5fa25e56fb957690072d51314c5;hpb=24e64d668f12eb0821eaf86ceee459be3661192d diff --git a/common.c b/common.c index 147393cd..32a57efc 100644 --- a/common.c +++ b/common.c @@ -19,30 +19,27 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ // common.c -- misc functions used in client and server +#include "quakedef.h" + #include #include #ifndef WIN32 #include #endif -#include "quakedef.h" - -cvar_t registered = {0, "registered","0"}; -cvar_t cmdline = {0, "cmdline","0"}; +cvar_t registered = {0, "registered","0", "indicates if this is running registered quake (whether gfx/pop.lmp was found)"}; +cvar_t cmdline = {0, "cmdline","0", "contains commandline the engine was launched with"}; -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]; - -int gamemode; -char *gamename; -char *gamedirname; +gamemode_t gamemode; +const char *gamename; +const char *gamedirname1; +const char *gamedirname2; +const char *gamescreenshotname; +const char *gameuserdirname; char com_modname[MAX_OSPATH] = ""; @@ -56,7 +53,7 @@ char com_modname[MAX_OSPATH] = ""; short ShortSwap (short l) { - qbyte b1,b2; + unsigned char b1,b2; b1 = l&255; b2 = (l>>8)&255; @@ -66,7 +63,7 @@ short ShortSwap (short l) int LongSwap (int l) { - qbyte b1,b2,b3,b4; + unsigned char b1,b2,b3,b4; b1 = l&255; b2 = (l>>8)&255; @@ -81,7 +78,7 @@ float FloatSwap (float f) union { float f; - qbyte b[4]; + unsigned char b[4]; } dat1, dat2; @@ -96,27 +93,146 @@ float FloatSwap (float f) // 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]; } +/* +============================================================================ + + 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(const unsigned char *data, size_t size) +{ + unsigned short crc = CRC_INIT_VALUE; + while (size--) + crc = (crc << 8) ^ crctable[(crc >> 8) ^ (*data++)]; + return crc ^ CRC_XOR_VALUE; +} + +// QuakeWorld +static unsigned char chktbl[1024 + 4] = +{ + 0x78,0xd2,0x94,0xe3,0x41,0xec,0xd6,0xd5,0xcb,0xfc,0xdb,0x8a,0x4b,0xcc,0x85,0x01, + 0x23,0xd2,0xe5,0xf2,0x29,0xa7,0x45,0x94,0x4a,0x62,0xe3,0xa5,0x6f,0x3f,0xe1,0x7a, + 0x64,0xed,0x5c,0x99,0x29,0x87,0xa8,0x78,0x59,0x0d,0xaa,0x0f,0x25,0x0a,0x5c,0x58, + 0xfb,0x00,0xa7,0xa8,0x8a,0x1d,0x86,0x80,0xc5,0x1f,0xd2,0x28,0x69,0x71,0x58,0xc3, + 0x51,0x90,0xe1,0xf8,0x6a,0xf3,0x8f,0xb0,0x68,0xdf,0x95,0x40,0x5c,0xe4,0x24,0x6b, + 0x29,0x19,0x71,0x3f,0x42,0x63,0x6c,0x48,0xe7,0xad,0xa8,0x4b,0x91,0x8f,0x42,0x36, + 0x34,0xe7,0x32,0x55,0x59,0x2d,0x36,0x38,0x38,0x59,0x9b,0x08,0x16,0x4d,0x8d,0xf8, + 0x0a,0xa4,0x52,0x01,0xbb,0x52,0xa9,0xfd,0x40,0x18,0x97,0x37,0xff,0xc9,0x82,0x27, + 0xb2,0x64,0x60,0xce,0x00,0xd9,0x04,0xf0,0x9e,0x99,0xbd,0xce,0x8f,0x90,0x4a,0xdd, + 0xe1,0xec,0x19,0x14,0xb1,0xfb,0xca,0x1e,0x98,0x0f,0xd4,0xcb,0x80,0xd6,0x05,0x63, + 0xfd,0xa0,0x74,0xa6,0x86,0xf6,0x19,0x98,0x76,0x27,0x68,0xf7,0xe9,0x09,0x9a,0xf2, + 0x2e,0x42,0xe1,0xbe,0x64,0x48,0x2a,0x74,0x30,0xbb,0x07,0xcc,0x1f,0xd4,0x91,0x9d, + 0xac,0x55,0x53,0x25,0xb9,0x64,0xf7,0x58,0x4c,0x34,0x16,0xbc,0xf6,0x12,0x2b,0x65, + 0x68,0x25,0x2e,0x29,0x1f,0xbb,0xb9,0xee,0x6d,0x0c,0x8e,0xbb,0xd2,0x5f,0x1d,0x8f, + 0xc1,0x39,0xf9,0x8d,0xc0,0x39,0x75,0xcf,0x25,0x17,0xbe,0x96,0xaf,0x98,0x9f,0x5f, + 0x65,0x15,0xc4,0x62,0xf8,0x55,0xfc,0xab,0x54,0xcf,0xdc,0x14,0x06,0xc8,0xfc,0x42, + 0xd3,0xf0,0xad,0x10,0x08,0xcd,0xd4,0x11,0xbb,0xca,0x67,0xc6,0x48,0x5f,0x9d,0x59, + 0xe3,0xe8,0x53,0x67,0x27,0x2d,0x34,0x9e,0x9e,0x24,0x29,0xdb,0x69,0x99,0x86,0xf9, + 0x20,0xb5,0xbb,0x5b,0xb0,0xf9,0xc3,0x67,0xad,0x1c,0x9c,0xf7,0xcc,0xef,0xce,0x69, + 0xe0,0x26,0x8f,0x79,0xbd,0xca,0x10,0x17,0xda,0xa9,0x88,0x57,0x9b,0x15,0x24,0xba, + 0x84,0xd0,0xeb,0x4d,0x14,0xf5,0xfc,0xe6,0x51,0x6c,0x6f,0x64,0x6b,0x73,0xec,0x85, + 0xf1,0x6f,0xe1,0x67,0x25,0x10,0x77,0x32,0x9e,0x85,0x6e,0x69,0xb1,0x83,0x00,0xe4, + 0x13,0xa4,0x45,0x34,0x3b,0x40,0xff,0x41,0x82,0x89,0x79,0x57,0xfd,0xd2,0x8e,0xe8, + 0xfc,0x1d,0x19,0x21,0x12,0x00,0xd7,0x66,0xe5,0xc7,0x10,0x1d,0xcb,0x75,0xe8,0xfa, + 0xb6,0xee,0x7b,0x2f,0x1a,0x25,0x24,0xb9,0x9f,0x1d,0x78,0xfb,0x84,0xd0,0x17,0x05, + 0x71,0xb3,0xc8,0x18,0xff,0x62,0xee,0xed,0x53,0xab,0x78,0xd3,0x65,0x2d,0xbb,0xc7, + 0xc1,0xe7,0x70,0xa2,0x43,0x2c,0x7c,0xc7,0x16,0x04,0xd2,0x45,0xd5,0x6b,0x6c,0x7a, + 0x5e,0xa1,0x50,0x2e,0x31,0x5b,0xcc,0xe8,0x65,0x8b,0x16,0x85,0xbf,0x82,0x83,0xfb, + 0xde,0x9f,0x36,0x48,0x32,0x79,0xd6,0x9b,0xfb,0x52,0x45,0xbf,0x43,0xf7,0x0b,0x0b, + 0x19,0x19,0x31,0xc3,0x85,0xec,0x1d,0x8c,0x20,0xf0,0x3a,0xfa,0x80,0x4d,0x2c,0x7d, + 0xac,0x60,0x09,0xc0,0x40,0xee,0xb9,0xeb,0x13,0x5b,0xe8,0x2b,0xb1,0x20,0xf0,0xce, + 0x4c,0xbd,0xc6,0x04,0x86,0x70,0xc6,0x33,0xc3,0x15,0x0f,0x65,0x19,0xfd,0xc2,0xd3, + + // map checksum goes here + 0x00,0x00,0x00,0x00 +}; + +// QuakeWorld +unsigned char COM_BlockSequenceCRCByteQW(unsigned char *base, int length, int sequence) +{ + unsigned char *p; + unsigned char chkb[60 + 4]; + + p = chktbl + (sequence % (sizeof(chktbl) - 8)); + + if (length > 60) + length = 60; + memcpy(chkb, base, length); + + chkb[length] = (sequence & 0xff) ^ p[0]; + chkb[length+1] = p[1]; + chkb[length+2] = ((sequence>>8) & 0xff) ^ p[2]; + chkb[length+3] = p[3]; + + return CRC_Block(chkb, length + 4) & 0xff; +} + /* ============================================================================== @@ -132,7 +248,7 @@ Handles byte ordering and avoids alignment errors void MSG_WriteChar (sizebuf_t *sb, int c) { - qbyte *buf; + unsigned char *buf; buf = SZ_GetSpace (sb, 1); buf[0] = c; @@ -140,7 +256,7 @@ void MSG_WriteChar (sizebuf_t *sb, int c) void MSG_WriteByte (sizebuf_t *sb, int c) { - qbyte *buf; + unsigned char *buf; buf = SZ_GetSpace (sb, 1); buf[0] = c; @@ -148,7 +264,7 @@ void MSG_WriteByte (sizebuf_t *sb, int c) void MSG_WriteShort (sizebuf_t *sb, int c) { - qbyte *buf; + unsigned char *buf; buf = SZ_GetSpace (sb, 2); buf[0] = c&0xff; @@ -157,7 +273,7 @@ void MSG_WriteShort (sizebuf_t *sb, int c) void MSG_WriteLong (sizebuf_t *sb, int c) { - qbyte *buf; + unsigned char *buf; buf = SZ_GetSpace (sb, 4); buf[0] = c&0xff; @@ -178,41 +294,91 @@ void MSG_WriteFloat (sizebuf_t *sb, float f) 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); + if (!s || !*s) + MSG_WriteChar (sb, 0); else - SZ_Write (sb, s, strlen(s)+1); + SZ_Write (sb, (unsigned char *)s, (int)strlen(s)+1); } -// used by server (always latest PROTOCOL_DARKPLACES) -void MSG_WriteDPCoord (sizebuf_t *sb, float f) +void MSG_WriteUnterminatedString (sizebuf_t *sb, const char *s) +{ + if (s && *s) + SZ_Write (sb, (unsigned char *)s, (int)strlen(s)); +} + +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, protocolversion_t protocol) +{ + if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_NEHAHRABJP || protocol == PROTOCOL_NEHAHRABJP2 || protocol == PROTOCOL_NEHAHRABJP3 || protocol == PROTOCOL_QUAKEWORLD) + MSG_WriteCoord13i (sb, f); + 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 - MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) - 0.5f) & 65535); + MSG_WriteCoord32f (sb, f); +} + +void MSG_WriteVector (sizebuf_t *sb, float *v, protocolversion_t 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.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.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, protocolversion_t protocol) +{ + if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_NEHAHRABJP || protocol == PROTOCOL_NEHAHRABJP2 || protocol == PROTOCOL_NEHAHRABJP3 || protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4 || protocol == PROTOCOL_QUAKEWORLD) + MSG_WriteAngle8i (sb, f); + else + MSG_WriteAngle16i (sb, f); } // @@ -307,9 +473,9 @@ float MSG_ReadBigFloat (void) 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++) + for (l = 0;l < (int) sizeof(string) - 1 && (c = MSG_ReadByte()) != -1 && c != 0;l++) string[l] = c; string[l] = 0; return string; @@ -318,60 +484,88 @@ char *MSG_ReadString (void) int MSG_ReadBytes (int numbytes, unsigned char *out) { int l, c; - for (l = 0;l < numbytes && (c = MSG_ReadChar()) != -1;l++) + for (l = 0;l < numbytes && (c = MSG_ReadByte()) != -1;l++) out[l] = c; return l; } -// used by client -float MSG_ReadCoord (void) +float MSG_ReadCoord13i (void) +{ + return MSG_ReadLittleShort() * (1.0/8.0); +} + +float MSG_ReadCoord16i (void) +{ + return (signed short) MSG_ReadLittleShort(); +} + +float MSG_ReadCoord32f (void) +{ + return MSG_ReadLittleFloat(); +} + +float MSG_ReadCoord (protocolversion_t protocol) { - if (cl.protocol == PROTOCOL_DARKPLACES2 || cl.protocol == PROTOCOL_DARKPLACES3 || cl.protocol == PROTOCOL_DARKPLACES4 || cl.protocol == PROTOCOL_DARKPLACES5) - return (signed short) MSG_ReadLittleShort(); - else if (cl.protocol == PROTOCOL_DARKPLACES1) - return MSG_ReadLittleFloat(); + if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_NEHAHRABJP || protocol == PROTOCOL_NEHAHRABJP2 || protocol == PROTOCOL_NEHAHRABJP3 || protocol == PROTOCOL_QUAKEWORLD) + return MSG_ReadCoord13i(); + else if (protocol == PROTOCOL_DARKPLACES1) + return MSG_ReadCoord32f(); + else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4) + return MSG_ReadCoord16i(); else - return MSG_ReadLittleShort() * (1.0f/8.0f); + return MSG_ReadCoord32f(); } +void MSG_ReadVector (float *v, protocolversion_t 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); +} -void SZ_Alloc (sizebuf_t *buf, int startsize, const char *name) +float MSG_ReadAngle16i (void) { - if (startsize < 256) - startsize = 256; - buf->mempool = Mem_AllocPool(name); - buf->data = Mem_Alloc(buf->mempool, startsize); - buf->maxsize = startsize; - buf->cursize = 0; + return (signed short)MSG_ReadShort () * (360.0/65536.0); } +float MSG_ReadAngle32f (void) +{ + return MSG_ReadFloat (); +} -void SZ_Free (sizebuf_t *buf) +float MSG_ReadAngle (protocolversion_t protocol) { - Mem_FreePool(&buf->mempool); - buf->data = NULL; - buf->maxsize = 0; - buf->cursize = 0; + if (protocol == PROTOCOL_QUAKE || protocol == PROTOCOL_QUAKEDP || protocol == PROTOCOL_NEHAHRAMOVIE || protocol == PROTOCOL_NEHAHRABJP || protocol == PROTOCOL_NEHAHRABJP2 || protocol == PROTOCOL_NEHAHRABJP3 || protocol == PROTOCOL_DARKPLACES1 || protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4 || protocol == PROTOCOL_QUAKEWORLD) + return MSG_ReadAngle8i (); + else + return MSG_ReadAngle16i (); } + +//=========================================================================== + 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"); @@ -384,7 +578,7 @@ void *SZ_GetSpace (sizebuf_t *buf, int length) 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); } @@ -394,12 +588,12 @@ void SZ_Write (sizebuf_t *buf, const void *data, int 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;) @@ -427,7 +621,7 @@ void Com_HexDumpToConsole(const qbyte *data, int size) *cur++ = ' '; *cur++ = ' '; } - if ((j & 3) == 0) + if ((j & 3) == 3) *cur++ = ' '; } // print text @@ -435,7 +629,13 @@ void Com_HexDumpToConsole(const qbyte *data, int size) { if (j < n) { - if (d[j] >= ' ' && d[j] <= 127) + // color change prefix character has to be treated specially + if (d[j] == STRING_COLOR_TAG) + { + *cur++ = STRING_COLOR_TAG; + *cur++ = STRING_COLOR_TAG; + } + else if (d[j] >= ' ') *cur++ = d[j]; else *cur++ = '.'; @@ -465,14 +665,15 @@ void SZ_HexDumpToConsole(const sizebuf_t *buf) /* ============== -COM_ParseToken +COM_ParseToken_Simple Parse a token out of a string ============== */ -int COM_ParseToken(const char **datapointer, int returnnewline) +int COM_ParseToken_Simple(const char **datapointer, qboolean returnnewline, qboolean parsebackslash) { int len; + int c; const char *data = *datapointer; len = 0; @@ -486,7 +687,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) { @@ -496,10 +701,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; } @@ -509,27 +718,45 @@ skipwhite: data++; while (*data && (data[0] != '*' || data[1] != '/')) data++; - data += 2; + if (*data) + data++; + if (*data) + data++; goto skipwhite; } else if (*data == '\"') { // quoted string - for (data++;*data != '\"';data++) + for (data++;*data && *data != '\"';data++) { - if (!*data || len >= (int)sizeof(com_token) - 1) + c = *data; + if (*data == '\\' && parsebackslash) { - com_token[0] = 0; - *datapointer = NULL; - return false; + data++; + c = *data; + if (c == 'n') + c = '\n'; + else if (c == 't') + c = '\t'; } - com_token[len++] = *data; + if (len < (int)sizeof(com_token) - 1) + com_token[len++] = c; } com_token[len] = 0; - *datapointer = data+1; + if (*data == '\"') + data++; + *datapointer = data; + return true; + } + else if (*data == '\r') + { + // translate Mac line ending to UNIX + com_token[len++] = '\n';data++; + com_token[len] = 0; + *datapointer = data; return true; } - else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == '\'' || *data == ':' || *data == ',' || *data == ';') + else if (*data == '\n') { // single character com_token[len++] = *data++; @@ -540,17 +767,124 @@ skipwhite: else { // regular word - for (;*data > ' ' && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != '\'' && *data != ':' && *data != ',' && *data != ';';data++) + for (;*data > ' ';data++) + if (len < (int)sizeof(com_token) - 1) + com_token[len++] = *data; + com_token[len] = 0; + *datapointer = data; + return true; + } +} + +/* +============== +COM_ParseToken_QuakeC + +Parse a token out of a string +============== +*/ +int COM_ParseToken_QuakeC(const char **datapointer, qboolean returnnewline) +{ + int len; + int c; + const char *data = *datapointer; + + len = 0; + com_token[0] = 0; + + if (!data) + { + *datapointer = NULL; + return false; + } + +// skip whitespace +skipwhite: + // line endings: + // UNIX: \n + // Mac: \r + // Windows: \r\n + for (;*data <= ' ' && ((*data != '\n' && *data != '\r') || !returnnewline);data++) + { + if (*data == 0) + { + // end of file + *datapointer = NULL; + return false; + } + } + + // handle Windows line ending + if (data[0] == '\r' && data[1] == '\n') + data++; + + if (data[0] == '/' && data[1] == '/') + { + // comment + while (*data && *data != '\n' && *data != '\r') + data++; + goto skipwhite; + } + else if (data[0] == '/' && data[1] == '*') + { + // comment + data++; + while (*data && (data[0] != '*' || data[1] != '/')) + data++; + if (*data) + data++; + if (*data) + data++; + goto skipwhite; + } + else if (*data == '\"' || *data == '\'') + { + // quoted string + char quote = *data; + for (data++;*data && *data != quote;data++) { - if (len >= (int)sizeof(com_token) - 1) + c = *data; + if (*data == '\\') { - com_token[0] = 0; - *datapointer = NULL; - return false; + data++; + c = *data; + if (c == 'n') + c = '\n'; + else if (c == 't') + c = '\t'; } - com_token[len++] = *data; + if (len < (int)sizeof(com_token) - 1) + com_token[len++] = c; } com_token[len] = 0; + if (*data == quote) + data++; + *datapointer = data; + return true; + } + else if (*data == '\r') + { + // translate Mac line ending to UNIX + com_token[len++] = '\n';data++; + com_token[len] = 0; + *datapointer = data; + return true; + } + else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == ':' || *data == ',' || *data == ';') + { + // single character + com_token[len++] = *data++; + com_token[len] = 0; + *datapointer = data; + return true; + } + else + { + // regular word + for (;*data > ' ' && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != ':' && *data != ',' && *data != ';';data++) + if (len < (int)sizeof(com_token) - 1) + com_token[len++] = *data; + com_token[len] = 0; *datapointer = data; return true; } @@ -558,14 +892,15 @@ skipwhite: /* ============== -COM_ParseTokenConsole +COM_ParseToken_VM_Tokenize -Parse a token out of a string, behaving like the qwcl console +Parse a token out of a string ============== */ -int COM_ParseTokenConsole(const char **datapointer) +int COM_ParseToken_VM_Tokenize(const char **datapointer, qboolean returnnewline) { int len; + int c; const char *data = *datapointer; len = 0; @@ -579,7 +914,11 @@ int COM_ParseTokenConsole(const char **datapointer) // skip whitespace skipwhite: - for (;*data <= ' ';data++) + // line endings: + // UNIX: \n + // Mac: \r + // Windows: \r\n + for (;*data <= ' ' && ((*data != '\n' && *data != '\r') || !returnnewline);data++) { if (*data == 0) { @@ -589,47 +928,149 @@ skipwhite: } } - if (*data == '/' && data[1] == '/') + // 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; } - else if (*data == '\"') + else if (data[0] == '/' && data[1] == '*') { + // comment + data++; + while (*data && (data[0] != '*' || data[1] != '/')) + data++; + if (*data) + data++; + if (*data) + data++; + goto skipwhite; + } + else if (*data == '\"' || *data == '\'') + { + char quote = *data; // quoted string - for (data++;*data != '\"';data++) + for (data++;*data && *data != quote;data++) { - if (!*data || len >= (int)sizeof(com_token) - 1) + c = *data; + if (*data == '\\') { - com_token[0] = 0; - *datapointer = NULL; - return false; + data++; + c = *data; + if (c == 'n') + c = '\n'; + else if (c == 't') + c = '\t'; } - com_token[len++] = *data; + if (len < (int)sizeof(com_token) - 1) + com_token[len++] = c; } com_token[len] = 0; - *datapointer = data+1; + if (*data == quote) + data++; + *datapointer = data; + return true; + } + else if (*data == '\r') + { + // translate Mac line ending to UNIX + com_token[len++] = '\n';data++; + com_token[len] = 0; + *datapointer = data; + return true; + } + else if (*data == '\n' || *data == '{' || *data == '}' || *data == ')' || *data == '(' || *data == ']' || *data == '[' || *data == ':' || *data == ',' || *data == ';') + { + // single character + com_token[len++] = *data++; + com_token[len] = 0; + *datapointer = data; return true; } else { // regular word - for (;*data > ' ';data++) + for (;*data > ' ' && *data != ',' && *data != ';' && *data != '{' && *data != '}' && *data != ')' && *data != '(' && *data != ']' && *data != '[' && *data != ':' && *data != ',' && *data != ';';data++) + if (len < (int)sizeof(com_token) - 1) + com_token[len++] = *data; + com_token[len] = 0; + *datapointer = data; + return true; + } +} + +/* +============== +COM_ParseToken_Console + +Parse a token out of a string, behaving like the qwcl console +============== +*/ +int COM_ParseToken_Console(const char **datapointer) +{ + int len; + const char *data = *datapointer; + + len = 0; + com_token[0] = 0; + + if (!data) + { + *datapointer = NULL; + return false; + } + +// skip whitespace +skipwhite: + for (;*data <= ' ';data++) + { + if (*data == 0) { - if (len >= (int)sizeof(com_token) - 1) - { - com_token[0] = 0; - *datapointer = NULL; - return false; - } - com_token[len++] = *data; + // end of file + *datapointer = NULL; + return false; + } + } + + if (*data == '/' && data[1] == '/') + { + // comment + while (*data && *data != '\n' && *data != '\r') + data++; + goto skipwhite; + } + else if (*data == '\"') + { + // quoted string + for (data++;*data && *data != '\"';data++) + { + // allow escaped " and \ case + if (*data == '\\' && (data[1] == '\"' || data[1] == '\\')) + data++; + if (len < (int)sizeof(com_token) - 1) + com_token[len++] = *data; } com_token[len] = 0; + if (*data == '\"') + data++; + *datapointer = data; + } + else + { + // regular word + for (;*data > ' ';data++) + if (len < (int)sizeof(com_token) - 1) + com_token[len++] = *data; + com_token[len] = 0; *datapointer = data; - return true; } + + return true; } @@ -656,209 +1097,162 @@ int COM_CheckParm (const char *parm) return 0; } -/* -================ -COM_CheckRegistered +//=========================================================================== -Looks for the pop.txt file and verifies it. -Sets the "registered" cvar. -Immediately exits out if an alternate game was attempted to be started without -being registered. -================ -*/ -void COM_CheckRegistered (void) +// Game mods + +typedef struct gamemode_info_s { - Cvar_Set ("cmdline", com_cmdline); + const char* prog_name; + const char* cmdline; + const char* gamename; + 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 +// COMMANDLINEOPTION: Game: -quake runs the game Quake (default) +{ "", "-quake", "DarkPlaces-Quake", "id1", NULL, "dp", "darkplaces" }, +// GAME_HIPNOTIC +// COMMANDLINEOPTION: Game: -hipnotic runs Quake mission pack 1: The Scourge of Armagon +{ "hipnotic", "-hipnotic", "Darkplaces-Hipnotic", "id1", "hipnotic", "dp", "darkplaces" }, +// GAME_ROGUE +// COMMANDLINEOPTION: Game: -rogue runs Quake mission pack 2: The Dissolution of Eternity +{ "rogue", "-rogue", "Darkplaces-Rogue", "id1", "rogue", "dp", "darkplaces" }, +// GAME_NEHAHRA +// COMMANDLINEOPTION: Game: -nehahra runs The Seal of Nehahra movie and game +{ "nehahra", "-nehahra", "DarkPlaces-Nehahra", "id1", "nehahra", "dp", "darkplaces" }, +// GAME_NEXUIZ +// COMMANDLINEOPTION: Game: -nexuiz runs the multiplayer game Nexuiz +{ "nexuiz", "-nexuiz", "Nexuiz", "data", NULL, "nexuiz", "nexuiz" }, +// GAME_TRANSFUSION +// COMMANDLINEOPTION: Game: -transfusion runs Transfusion (the recreation of Blood in Quake) +{ "transfusion", "-transfusion", "Transfusion", "basetf", NULL, "transfusion", "transfusion" }, +// GAME_GOODVSBAD2 +// COMMANDLINEOPTION: Game: -goodvsbad2 runs the psychadelic RTS FPS game Good Vs Bad 2 +{ "gvb2", "-goodvsbad2", "GoodVs.Bad2", "rts", NULL, "gvb2", "gvb2" }, +// GAME_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 +// COMMANDLINEOPTION: Game: -battlemech runs the multiplayer topdown deathmatch game BattleMech +{ "battlemech", "-battlemech", "Battlemech", "base", NULL, "battlemech", "battlemech" }, +// GAME_ZYMOTIC +// COMMANDLINEOPTION: Game: -zymotic runs the singleplayer game Zymotic +{ "zymotic", "-zymotic", "Zymotic", "basezym", NULL, "zymotic", "zymotic" }, +// GAME_SETHERAL +// COMMANDLINEOPTION: Game: -setheral runs the multiplayer game Setheral +{ "setheral", "-setheral", "Setheral", "data", NULL, "setheral", "setheral" }, +// GAME_SOM +// COMMANDLINEOPTION: Game: -som runs the multiplayer game Son Of Man +{ "som", "-som", "Son of Man", "id1", "sonofman", "som", "darkplaces" }, +// GAME_TENEBRAE +// 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 +// COMMANDLINEOPTION: Game: -neoteric runs the game Neoteric +{ "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" }, +// GAME_PRYDON +// COMMANDLINEOPTION: Game: -prydon runs the topdown point and click action-RPG Prydon Gate +{ "prydon", "-prydon", "PrydonGate", "id1", "prydon", "prydon", "darkplaces" }, +// GAME_DELUXEQUAKE +// COMMANDLINEOPTION: Game: -dq runs the game Deluxe Quake +{ "dq", "-dq", "Deluxe Quake", "basedq", "extradq", "basedq", "dq" }, +// 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" }, +// GAME_DARSANA +// COMMANDLINEOPTION: Game: -darsana runs the game Darsana +{ "darsana", "-darsana", "Darsana", "ddata", NULL, "darsana", "darsana" }, +// GAME_CONTAGIONTHEORY +// COMMANDLINEOPTION: Game: -contagiontheory runs the game Contagion Theory +{ "contagiontheory", "-contagiontheory", "Contagion Theory", "ctdata", NULL, "ct", "contagiontheory" }, +}; - if (!FS_FileExists("gfx/pop.lmp")) - { - if (fs_modified) - Con_Print("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n"); - else - Con_Print("Playing shareware version.\n"); - return; - } +void COM_InitGameType (void) +{ + char name [MAX_OSPATH]; + unsigned int i; - Cvar_Set ("registered", "1"); - Con_Print("Playing registered version.\n"); + FS_StripExtension (com_argv[0], name, sizeof (name)); + COM_ToLowerString (name, name, sizeof (name)); + + // 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 = (gamemode_t)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 = (gamemode_t)i; + break; + } + + gamename = gamemode_info[gamemode].gamename; + gamedirname1 = gamemode_info[gamemode].gamedirname1; + gamedirname2 = gamemode_info[gamemode].gamedirname2; + gamescreenshotname = gamemode_info[gamemode].gamescreenshotname; + gameuserdirname = gamemode_info[gamemode].gameuserdirname; } /* ================ -COM_InitArgv +COM_Init ================ */ -void COM_InitArgv (void) +void COM_Init_Commands (void) { int i, j, n; + char com_cmdline[MAX_INPUTLINE]; + + Cvar_RegisterVariable (®istered); + Cvar_RegisterVariable (&cmdline); + // reconstitute the command line for the cmdline externally visible cvar n = 0; 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 (n < (CMDLINE_LENGTH - 1)) + if (strstr(com_argv[j], " ")) + { + // arg contains whitespace, store quotes around it + com_cmdline[n++] = '\"'; + while ((n < ((int)sizeof(com_cmdline) - 1)) && com_argv[j][i]) + com_cmdline[n++] = com_argv[j][i++]; + com_cmdline[n++] = '\"'; + } + else + { + while ((n < ((int)sizeof(com_cmdline) - 1)) && com_argv[j][i]) + com_cmdline[n++] = com_argv[j][i++]; + } + if (n < ((int)sizeof(com_cmdline) - 1)) com_cmdline[n++] = ' '; else break; } com_cmdline[n] = 0; + Cvar_Set ("cmdline", com_cmdline); } -void COM_InitGameType (void) -{ - char name[MAX_OSPATH]; - 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 if (strstr(name, "tenebrae")) - gamemode = GAME_TENEBRAE; - 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; - else if (COM_CheckParm ("-tenebrae")) - gamemode = GAME_TENEBRAE; - - 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; - case GAME_TENEBRAE: - gamename = "DarkPlaces-Tenebrae"; - gamedirname = "tenebrae"; - break; - default: - Sys_Error("COM_InitGameType: unknown gamemode %i\n", gamemode); - break; - } -} - - -extern void Mathlib_Init(void); -extern void FS_Init (void); - -/* -================ -COM_Init -================ -*/ -void COM_Init (void) -{ - Cvar_RegisterVariable (®istered); - Cvar_RegisterVariable (&cmdline); - - Mathlib_Init(); - - FS_Init (); - Log_Init (); - COM_CheckRegistered (); - - COM_InitGameType(); -} - - /* ============ va @@ -878,13 +1272,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) @@ -937,14 +1372,14 @@ int COM_ReadAndTokenizeLine(const char **text, char **argv, int maxargc, char *t l = *text; commentprefixlength = 0; if (commentprefix) - commentprefixlength = strlen(commentprefix); - while (*l && *l != '\n') + commentprefixlength = (int)strlen(commentprefix); + 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; } @@ -979,17 +1414,152 @@ 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; return argc; } +/* +============ +COM_StringLengthNoColors + +calculates the visible width of a color coded string. + +*valid is filled with TRUE if the string is a valid colored string (that is, if +it does not end with an unfinished color code). If it gets filled with FALSE, a +fix would be adding a STRING_COLOR_TAG at the end of the string. + +valid can be set to NULL if the caller doesn't care. + +For size_s, specify the maximum number of characters from s to use, or 0 to use +all characters until the zero terminator. +============ +*/ +size_t +COM_StringLengthNoColors(const char *s, size_t size_s, qboolean *valid) +{ + const char *end = size_s ? (s + size_s) : NULL; + size_t len = 0; + for(;;) + { + switch((s == end) ? 0 : *s) + { + case 0: + if(valid) + *valid = TRUE; + return len; + case STRING_COLOR_TAG: + ++s; + switch((s == end) ? 0 : *s) + { + case 0: // ends with unfinished color code! + ++len; + if(valid) + *valid = FALSE; + return len; + case STRING_COLOR_TAG: // escaped ^ + ++len; + break; + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': // color code + break; + default: // not a color code + ++len; // STRING_COLOR_TAG + ++len; // the character + break; + } + break; + default: + ++len; + break; + } + ++s; + } + // never get here +} + +/* +============ +COM_StringDecolorize + +removes color codes from a string. + +If escape_carets is true, the resulting string will be safe for printing. If +escape_carets is false, the function will just strip color codes (for logging +for example). + +If the output buffer size did not suffice for converting, the function returns +FALSE. Generally, if escape_carets is false, the output buffer needs +strlen(str)+1 bytes, and if escape_carets is true, it can need strlen(str)+2 +bytes. In any case, the function makes sure that the resulting string is +zero terminated. + +For size_in, specify the maximum number of characters from in to use, or 0 to use +all characters until the zero terminator. +============ +*/ +qboolean +COM_StringDecolorize(const char *in, size_t size_in, char *out, size_t size_out, qboolean escape_carets) +{ +#define APPEND(ch) do { if(--size_out) { *out++ = (ch); } else { *out++ = 0; return FALSE; } } while(0) + const char *end = size_in ? (in + size_in) : NULL; + if(size_out < 1) + return FALSE; + for(;;) + { + switch((in == end) ? 0 : *in) + { + case 0: + *out++ = 0; + return TRUE; + case STRING_COLOR_TAG: + ++in; + switch((in == end) ? 0 : *in) + { + case 0: // ends with unfinished color code! + APPEND(STRING_COLOR_TAG); + // finish the code by appending another caret when escaping + if(escape_carets) + APPEND(STRING_COLOR_TAG); + *out++ = 0; + return TRUE; + case STRING_COLOR_TAG: // escaped ^ + APPEND(STRING_COLOR_TAG); + // append a ^ twice when escaping + if(escape_carets) + APPEND(STRING_COLOR_TAG); + break; + case '0': case '1': case '2': case '3': case '4': + case '5': case '6': case '7': case '8': case '9': // color code + break; + default: // not a color code + APPEND(STRING_COLOR_TAG); + APPEND(*in); + break; + } + break; + default: + APPEND(*in); + break; + } + ++in; + } + // never get here +#undef APPEND +} + // 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; @@ -1047,6 +1617,139 @@ char *SearchInfostring(const char *infostring, const char *key) } } +void InfoString_GetValue(const char *buffer, const char *key, char *value, size_t valuelength) +{ + int pos = 0, j; + size_t keylength; + if (!key) + key = ""; + if (!value) + value = ""; + keylength = strlen(key); + if (valuelength < 1 || !value) + { + Con_Printf("InfoString_GetValue: no room in value\n"); + return; + } + value[0] = 0; + if (strchr(key, '\\')) + { + Con_Printf("InfoString_GetValue: key name \"%s\" contains \\ which is not possible in an infostring\n", key); + return; + } + if (strchr(key, '\"')) + { + Con_Printf("InfoString_SetValue: key name \"%s\" contains \" which is not allowed in an infostring\n", key); + return; + } + if (!key[0]) + { + Con_Printf("InfoString_GetValue: can not look up a key with no name\n"); + return; + } + while (buffer[pos] == '\\') + { + if (!memcmp(buffer + pos+1, key, keylength)) + { + for (pos++;buffer[pos] && buffer[pos] != '\\';pos++); + pos++; + for (j = 0;buffer[pos+j] && buffer[pos+j] != '\\' && j < (int)valuelength - 1;j++) + value[j] = buffer[pos+j]; + value[j] = 0; + return; + } + for (pos++;buffer[pos] && buffer[pos] != '\\';pos++); + for (pos++;buffer[pos] && buffer[pos] != '\\';pos++); + } + // if we reach this point the key was not found +} + +void InfoString_SetValue(char *buffer, size_t bufferlength, const char *key, const char *value) +{ + int pos = 0, pos2; + size_t keylength; + if (!key) + key = ""; + if (!value) + value = ""; + keylength = strlen(key); + if (strchr(key, '\\') || strchr(value, '\\')) + { + Con_Printf("InfoString_SetValue: \"%s\" \"%s\" contains \\ which is not possible to store in an infostring\n", key, value); + return; + } + if (strchr(key, '\"') || strchr(value, '\"')) + { + Con_Printf("InfoString_SetValue: \"%s\" \"%s\" contains \" which is not allowed in an infostring\n", key, value); + return; + } + if (!key[0]) + { + Con_Printf("InfoString_SetValue: can not set a key with no name\n"); + return; + } + while (buffer[pos] == '\\') + { + if (!memcmp(buffer + pos+1, key, keylength)) + break; + for (pos++;buffer[pos] && buffer[pos] != '\\';pos++); + for (pos++;buffer[pos] && buffer[pos] != '\\';pos++); + } + // if we found the key, find the end of it because we will be replacing it + pos2 = pos; + if (buffer[pos] == '\\') + { + for (pos2++;buffer[pos2] && buffer[pos2] != '\\';pos2++); + for (pos2++;buffer[pos2] && buffer[pos2] != '\\';pos2++); + } + if (bufferlength <= pos + 1 + strlen(key) + 1 + strlen(value) + strlen(buffer + pos2)) + { + Con_Printf("InfoString_SetValue: no room for \"%s\" \"%s\" in infostring\n", key, value); + return; + } + if (value && value[0]) + { + // set the key/value and append the remaining text + char tempbuffer[4096]; + strlcpy(tempbuffer, buffer + pos2, sizeof(tempbuffer)); + sprintf(buffer + pos, "\\%s\\%s%s", key, value, tempbuffer); + } + else + { + // just remove the key from the text + strlcpy(buffer + pos, buffer + pos2, bufferlength - pos); + } +} + +void InfoString_Print(char *buffer) +{ + int i; + char key[2048]; + char value[2048]; + while (*buffer) + { + if (*buffer != '\\') + { + Con_Printf("InfoString_Print: corrupt string\n"); + return; + } + for (buffer++, i = 0;*buffer && *buffer != '\\';buffer++) + if (i < (int)sizeof(key)-1) + key[i++] = *buffer; + key[i] = 0; + if (*buffer != '\\') + { + Con_Printf("InfoString_Print: corrupt string\n"); + return; + } + for (buffer++, i = 0;*buffer && *buffer != '\\';buffer++) + if (i < (int)sizeof(value)-1) + value[i++] = *buffer; + value[i] = 0; + // empty value is an error case + Con_Printf("%20s %s\n", key, value[0] ? value : "NO VALUE"); + } +} //======================================================== // strlcat and strlcpy, from OpenBSD