X-Git-Url: http://git.xonotic.org/?p=xonotic%2Fdarkplaces.git;a=blobdiff_plain;f=common.c;h=8db1f27025ab61c545583f0f2cba1821ab41ff6d;hp=199d106a798546136492daa19ac056805d82de54;hb=00b6d96fd1220b1df82036c445389ae19a08709e;hpb=1f47451425131763c87dbd55ac9d913b21702625 diff --git a/common.c b/common.c index 199d106a..8db1f270 100644 --- a/common.c +++ b/common.c @@ -1,5 +1,6 @@ /* Copyright (C) 1996-1997 Id Software, Inc. +Copyright (C) 2000-2020 DarkPlaces contributors This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License @@ -28,545 +29,14 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. #include "quakedef.h" #include "utf8lib.h" -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"}; +cvar_t registered = {CF_CLIENT | CF_SERVER, "registered","0", "indicates if this is running registered quake (whether gfx/pop.lmp was found)"}; +cvar_t cmdline = {CF_CLIENT | CF_SERVER, "cmdline","0", "contains commandline the engine was launched with"}; -char com_token[MAX_INPUTLINE]; -int com_argc; -const char **com_argv; -int com_selffd = -1; - -gamemode_t gamemode; -const char *gamename; -const char *gamedirname1; -const char *gamedirname2; -const char *gamescreenshotname; -const char *gameuserdirname; -char com_modname[MAX_OSPATH] = ""; - - -/* -============================================================================ - - BYTE ORDER FUNCTIONS - -============================================================================ -*/ - - -float BuffBigFloat (const unsigned char *buffer) -{ - union - { - float f; - unsigned int i; - } - u; - u.i = (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]; - return u.f; -} - -int BuffBigLong (const unsigned char *buffer) -{ - return (buffer[0] << 24) | (buffer[1] << 16) | (buffer[2] << 8) | buffer[3]; -} - -short BuffBigShort (const unsigned char *buffer) -{ - return (buffer[0] << 8) | buffer[1]; -} - -float BuffLittleFloat (const unsigned char *buffer) -{ - union - { - float f; - unsigned int i; - } - u; - u.i = (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0]; - return u.f; -} - -int BuffLittleLong (const unsigned char *buffer) -{ - return (buffer[3] << 24) | (buffer[2] << 16) | (buffer[1] << 8) | buffer[0]; -} - -short BuffLittleShort (const unsigned char *buffer) -{ - return (buffer[1] << 8) | buffer[0]; -} - -void StoreBigLong (unsigned char *buffer, unsigned int i) -{ - buffer[0] = (i >> 24) & 0xFF; - buffer[1] = (i >> 16) & 0xFF; - buffer[2] = (i >> 8) & 0xFF; - buffer[3] = i & 0xFF; -} - -void StoreBigShort (unsigned char *buffer, unsigned short i) -{ - buffer[0] = (i >> 8) & 0xFF; - buffer[1] = i & 0xFF; -} - -void StoreLittleLong (unsigned char *buffer, unsigned int i) -{ - buffer[0] = i & 0xFF; - buffer[1] = (i >> 8) & 0xFF; - buffer[2] = (i >> 16) & 0xFF; - buffer[3] = (i >> 24) & 0xFF; -} - -void StoreLittleShort (unsigned char *buffer, unsigned short i) -{ - buffer[0] = i & 0xFF; - buffer[1] = (i >> 8) & 0xFF; -} - -/* -============================================================================ - - 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; -} - -unsigned short CRC_Block_CaseInsensitive(const unsigned char *data, size_t size) -{ - unsigned short crc = CRC_INIT_VALUE; - while (size--) - crc = (crc << 8) ^ crctable[(crc >> 8) ^ (tolower(*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; -} - -/* -============================================================================== - - MESSAGE IO FUNCTIONS - -Handles byte ordering and avoids alignment errors -============================================================================== -*/ - -// -// writing functions -// - -void MSG_WriteChar (sizebuf_t *sb, int c) -{ - unsigned char *buf; - - buf = SZ_GetSpace (sb, 1); - buf[0] = c; -} - -void MSG_WriteByte (sizebuf_t *sb, int c) -{ - unsigned char *buf; - - buf = SZ_GetSpace (sb, 1); - buf[0] = c; -} - -void MSG_WriteShort (sizebuf_t *sb, int c) -{ - unsigned char *buf; - - buf = SZ_GetSpace (sb, 2); - buf[0] = c&0xff; - buf[1] = c>>8; -} - -void MSG_WriteLong (sizebuf_t *sb, int c) -{ - unsigned char *buf; - - buf = SZ_GetSpace (sb, 4); - buf[0] = c&0xff; - buf[1] = (c>>8)&0xff; - buf[2] = (c>>16)&0xff; - buf[3] = c>>24; -} - -void MSG_WriteFloat (sizebuf_t *sb, float f) -{ - union - { - float f; - int l; - } dat; - - - dat.f = f; - dat.l = LittleLong (dat.l); - - SZ_Write (sb, (unsigned char *)&dat.l, 4); -} - -void MSG_WriteString (sizebuf_t *sb, const char *s) -{ - if (!s || !*s) - MSG_WriteChar (sb, 0); - else - SZ_Write (sb, (unsigned char *)s, (int)strlen(s)+1); -} - -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 * 8.0 + 0.5)); - else - 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.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_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_WriteAngle8i (sizebuf_t *sb, float f) -{ - if (f >= 0) - 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, 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); -} - -// -// reading functions -// - -void MSG_BeginReading(sizebuf_t *sb) -{ - sb->readcount = 0; - sb->badread = false; -} - -int MSG_ReadLittleShort(sizebuf_t *sb) -{ - if (sb->readcount+2 > sb->cursize) - { - sb->badread = true; - return -1; - } - sb->readcount += 2; - return (short)(sb->data[sb->readcount-2] | (sb->data[sb->readcount-1]<<8)); -} - -int MSG_ReadBigShort (sizebuf_t *sb) -{ - if (sb->readcount+2 > sb->cursize) - { - sb->badread = true; - return -1; - } - sb->readcount += 2; - return (short)((sb->data[sb->readcount-2]<<8) + sb->data[sb->readcount-1]); -} - -int MSG_ReadLittleLong (sizebuf_t *sb) -{ - if (sb->readcount+4 > sb->cursize) - { - sb->badread = true; - return -1; - } - sb->readcount += 4; - return sb->data[sb->readcount-4] | (sb->data[sb->readcount-3]<<8) | (sb->data[sb->readcount-2]<<16) | (sb->data[sb->readcount-1]<<24); -} - -int MSG_ReadBigLong (sizebuf_t *sb) -{ - if (sb->readcount+4 > sb->cursize) - { - sb->badread = true; - return -1; - } - sb->readcount += 4; - return (sb->data[sb->readcount-4]<<24) + (sb->data[sb->readcount-3]<<16) + (sb->data[sb->readcount-2]<<8) + sb->data[sb->readcount-1]; -} - -float MSG_ReadLittleFloat (sizebuf_t *sb) -{ - union - { - float f; - int l; - } dat; - if (sb->readcount+4 > sb->cursize) - { - sb->badread = true; - return -1; - } - sb->readcount += 4; - dat.l = sb->data[sb->readcount-4] | (sb->data[sb->readcount-3]<<8) | (sb->data[sb->readcount-2]<<16) | (sb->data[sb->readcount-1]<<24); - return dat.f; -} - -float MSG_ReadBigFloat (sizebuf_t *sb) -{ - union - { - float f; - int l; - } dat; - if (sb->readcount+4 > sb->cursize) - { - sb->badread = true; - return -1; - } - sb->readcount += 4; - dat.l = (sb->data[sb->readcount-4]<<24) | (sb->data[sb->readcount-3]<<16) | (sb->data[sb->readcount-2]<<8) | sb->data[sb->readcount-1]; - return dat.f; -} - -char *MSG_ReadString (sizebuf_t *sb, char *string, size_t maxstring) -{ - int c; - size_t l = 0; - // read string into sbfer, but only store as many characters as will fit - while ((c = MSG_ReadByte(sb)) > 0) - if (l < maxstring - 1) - string[l++] = c; - string[l] = 0; - return string; -} - -int MSG_ReadBytes (sizebuf_t *sb, int numbytes, unsigned char *out) -{ - int l, c; - for (l = 0;l < numbytes && (c = MSG_ReadByte(sb)) != -1;l++) - out[l] = c; - return l; -} - -float MSG_ReadCoord13i (sizebuf_t *sb) -{ - return MSG_ReadLittleShort(sb) * (1.0/8.0); -} - -float MSG_ReadCoord16i (sizebuf_t *sb) -{ - return (signed short) MSG_ReadLittleShort(sb); -} - -float MSG_ReadCoord32f (sizebuf_t *sb) -{ - return MSG_ReadLittleFloat(sb); -} - -float MSG_ReadCoord (sizebuf_t *sb, 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) - return MSG_ReadCoord13i(sb); - else if (protocol == PROTOCOL_DARKPLACES1) - return MSG_ReadCoord32f(sb); - else if (protocol == PROTOCOL_DARKPLACES2 || protocol == PROTOCOL_DARKPLACES3 || protocol == PROTOCOL_DARKPLACES4) - return MSG_ReadCoord16i(sb); - else - return MSG_ReadCoord32f(sb); -} - -void MSG_ReadVector (sizebuf_t *sb, float *v, protocolversion_t protocol) -{ - v[0] = MSG_ReadCoord(sb, protocol); - v[1] = MSG_ReadCoord(sb, protocol); - v[2] = MSG_ReadCoord(sb, protocol); -} - -// LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem -float MSG_ReadAngle8i (sizebuf_t *sb) -{ - return (signed char) MSG_ReadByte (sb) * (360.0/256.0); -} - -float MSG_ReadAngle16i (sizebuf_t *sb) -{ - return (signed short)MSG_ReadShort (sb) * (360.0/65536.0); -} - -float MSG_ReadAngle32f (sizebuf_t *sb) -{ - return MSG_ReadFloat (sb); -} - -float MSG_ReadAngle (sizebuf_t *sb, 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) - return MSG_ReadAngle8i (sb); - else - return MSG_ReadAngle16i (sb); -} +// FIXME: Find a better place for these. +cvar_t cl_playermodel = {CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playermodel", "", "current player model in Nexuiz/Xonotic"}; +cvar_t cl_playerskin = {CF_CLIENT | CF_SERVER | CF_USERINFO | CF_ARCHIVE, "playerskin", "", "current player skin in Nexuiz/Xonotic"}; +char com_token[MAX_INPUTLINE]; //=========================================================================== @@ -603,7 +73,7 @@ void SZ_Write (sizebuf_t *buf, const unsigned char *data, int length) memcpy (SZ_GetSpace(buf,length),data,length); } -// LordHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my +// LadyHavoc: thanks to Fuh for bringing the pure evil of SZ_Print to my // attention, it has been eradicated from here, its only (former) use in // all of darkplaces. @@ -711,7 +181,7 @@ int COM_Wordwrap(const char *string, size_t length, float continuationWidth, flo // If it fits, append it. Continue. // If it doesn't fit, output current line, advance to next line. Append the word. This is a continuation. Continue. - qboolean isContinuation = false; + qbool isContinuation = false; float spaceWidth; const char *startOfLine = string; const char *cursor = string; @@ -734,7 +204,6 @@ int COM_Wordwrap(const char *string, size_t length, float continuationWidth, flo { case 0: // end of string result += processLine(passthroughPL, startOfLine, cursor - startOfLine, spaceUsedInLine, isContinuation); - isContinuation = false; goto out; case '\n': // end of line result += processLine(passthroughPL, startOfLine, cursor - startOfLine, spaceUsedInLine, isContinuation); @@ -790,7 +259,7 @@ int COM_Wordwrap(const char *string, size_t length, float continuationWidth, flo return result; /* - qboolean isContinuation = false; + qbool isContinuation = false; float currentWordSpace = 0; const char *currentWord = 0; float minReserve = 0; @@ -989,7 +458,7 @@ COM_ParseToken_Simple Parse a token out of a string ============== */ -int COM_ParseToken_Simple(const char **datapointer, qboolean returnnewline, qboolean parsebackslash, qboolean parsecomments) +int COM_ParseToken_Simple(const char **datapointer, qbool returnnewline, qbool parsebackslash, qbool parsecomments) { int len; int c; @@ -1102,7 +571,7 @@ COM_ParseToken_QuakeC Parse a token out of a string ============== */ -int COM_ParseToken_QuakeC(const char **datapointer, qboolean returnnewline) +int COM_ParseToken_QuakeC(const char **datapointer, qbool returnnewline) { int len; int c; @@ -1216,7 +685,7 @@ COM_ParseToken_VM_Tokenize Parse a token out of a string ============== */ -int COM_ParseToken_VM_Tokenize(const char **datapointer, qboolean returnnewline) +int COM_ParseToken_VM_Tokenize(const char **datapointer, qbool returnnewline) { int len; int c; @@ -1392,184 +861,34 @@ skipwhite: return true; } - /* -================ -COM_CheckParm +=============== +Com_CalcRoll -Returns the position (1 to argc-1) in the program's argument list -where the given parameter apears, or 0 if not present -================ +Used by view and sv_user +=============== */ -int COM_CheckParm (const char *parm) +float Com_CalcRoll (const vec3_t angles, const vec3_t velocity, const vec_t angleval, const vec_t velocityval) { - int i; - - for (i=1 ; i= 0 && gamemode != gamemode_info[index].mode) - COM_SetGameType(index); -} + if (side < velocityval) + side = side * angleval / velocityval; + else + side = angleval; -static void COM_SetGameType(int index) -{ - int i, t; - if (index < 0 || index >= (int)(sizeof (gamemode_info) / sizeof (gamemode_info[0]))) - index = 0; - gamemode = gamemode_info[index].mode; - gamename = gamemode_info[index].gamename; - gamedirname1 = gamemode_info[index].gamedirname1; - gamedirname2 = gamemode_info[index].gamedirname2; - gamescreenshotname = gamemode_info[index].gamescreenshotname; - gameuserdirname = gamemode_info[index].gameuserdirname; - - if (gamemode == com_startupgamemode) - { - if((t = COM_CheckParm("-customgamename")) && t + 1 < com_argc) - gamename = com_argv[t+1]; - if((t = COM_CheckParm("-customgamedirname1")) && t + 1 < com_argc) - gamedirname1 = com_argv[t+1]; - if((t = COM_CheckParm("-customgamedirname2")) && t + 1 < com_argc) - gamedirname2 = *com_argv[t+1] ? com_argv[t+1] : NULL; - if((t = COM_CheckParm("-customgamescreenshotname")) && t + 1 < com_argc) - gamescreenshotname = com_argv[t+1]; - if((t = COM_CheckParm("-customgameuserdirname")) && t + 1 < com_argc) - gameuserdirname = com_argv[t+1]; - } + return side*sign; - if (gamedirname2 && gamedirname2[0]) - Con_Printf("Game is %s using base gamedirs %s %s", gamename, gamedirname1, gamedirname2); - else - Con_Printf("Game is %s using base gamedir %s", gamename, gamedirname1); - for (i = 0;i < fs_numgamedirs;i++) - { - if (i == 0) - Con_Printf(", with mod gamedirs"); - Con_Printf(" %s", fs_gamedirs[i]); - } - Con_Printf("\n"); } +//=========================================================================== /* ================ @@ -1583,24 +902,37 @@ void COM_Init_Commands (void) Cvar_RegisterVariable (®istered); Cvar_RegisterVariable (&cmdline); + Cvar_RegisterVariable(&cl_playermodel); + Cvar_RegisterVirtual(&cl_playermodel, "_cl_playermodel"); + Cvar_RegisterVariable(&cl_playerskin); + Cvar_RegisterVirtual(&cl_playerskin, "_cl_playerskin"); // reconstitute the command line for the cmdline externally visible cvar n = 0; - for (j = 0;(j < MAX_NUM_ARGVS) && (j < com_argc);j++) + for (j = 0;(j < MAX_NUM_ARGVS) && (j < sys.argc);j++) { i = 0; - if (strstr(com_argv[j], " ")) + if (strstr(sys.argv[j], " ")) { // arg contains whitespace, store quotes around it + // This condition checks whether we can allow to put + // in two quote characters. + if (n >= ((int)sizeof(com_cmdline) - 2)) + break; com_cmdline[n++] = '\"'; - while ((n < ((int)sizeof(com_cmdline) - 1)) && com_argv[j][i]) - com_cmdline[n++] = com_argv[j][i++]; + // This condition checks whether we can allow one + // more character and a quote character. + while ((n < ((int)sizeof(com_cmdline) - 2)) && sys.argv[j][i]) + // FIXME: Doesn't quote special characters. + com_cmdline[n++] = sys.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++]; + // This condition checks whether we can allow one + // more character. + while ((n < ((int)sizeof(com_cmdline) - 1)) && sys.argv[j][i]) + com_cmdline[n++] = sys.argv[j][i++]; } if (n < ((int)sizeof(com_cmdline) - 1)) com_cmdline[n++] = ' '; @@ -1608,7 +940,7 @@ void COM_Init_Commands (void) break; } com_cmdline[n] = 0; - Cvar_Set ("cmdline", com_cmdline); + Cvar_SetQuick(&cmdline, com_cmdline); } /* @@ -1832,7 +1164,7 @@ all characters until the zero terminator. ============ */ size_t -COM_StringLengthNoColors(const char *s, size_t size_s, qboolean *valid) +COM_StringLengthNoColors(const char *s, size_t size_s, qbool *valid) { const char *end = size_s ? (s + size_s) : NULL; size_t len = 0; @@ -1842,7 +1174,7 @@ COM_StringLengthNoColors(const char *s, size_t size_s, qboolean *valid) { case 0: if(valid) - *valid = TRUE; + *valid = true; return len; case STRING_COLOR_TAG: ++s; @@ -1862,7 +1194,7 @@ COM_StringLengthNoColors(const char *s, size_t size_s, qboolean *valid) case 0: // ends with unfinished color code! ++len; if(valid) - *valid = FALSE; + *valid = false; return len; case STRING_COLOR_TAG: // escaped ^ ++len; @@ -1905,20 +1237,20 @@ For size_in, specify the maximum number of characters from in to use, or 0 to us 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) +qbool +COM_StringDecolorize(const char *in, size_t size_in, char *out, size_t size_out, qbool escape_carets) { -#define APPEND(ch) do { if(--size_out) { *out++ = (ch); } else { *out++ = 0; return FALSE; } } while(0) +#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; + return false; for(;;) { switch((in == end) ? 0 : *in) { case 0: *out++ = 0; - return TRUE; + return true; case STRING_COLOR_TAG: ++in; switch((in == end) ? 0 : *in) @@ -1942,7 +1274,7 @@ COM_StringDecolorize(const char *in, size_t size_in, char *out, size_t size_out, if(escape_carets) APPEND(STRING_COLOR_TAG); *out++ = 0; - return TRUE; + return true; case STRING_COLOR_TAG: // escaped ^ APPEND(STRING_COLOR_TAG); // append a ^ twice when escaping @@ -1968,144 +1300,11 @@ COM_StringDecolorize(const char *in, size_t size_in, char *out, size_t size_out, #undef APPEND } -char *InfoString_GetValue(const char *buffer, const char *key, char *value, size_t valuelength) -{ - int pos = 0, j; - size_t keylength; - if (!key) - key = ""; - keylength = strlen(key); - if (valuelength < 1 || !value) - { - Con_Printf("InfoString_GetValue: no room in value\n"); - return NULL; - } - value[0] = 0; - if (strchr(key, '\\')) - { - Con_Printf("InfoString_GetValue: key name \"%s\" contains \\ which is not possible in an infostring\n", key); - return NULL; - } - if (strchr(key, '\"')) - { - Con_Printf("InfoString_SetValue: key name \"%s\" contains \" which is not allowed in an infostring\n", key); - return NULL; - } - if (!key[0]) - { - Con_Printf("InfoString_GetValue: can not look up a key with no name\n"); - return NULL; - } - 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 value; - } - for (pos++;buffer[pos] && buffer[pos] != '\\';pos++); - for (pos++;buffer[pos] && buffer[pos] != '\\';pos++); - } - // if we reach this point the key was not found - return NULL; -} - -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[MAX_INPUTLINE]; - strlcpy(tempbuffer, buffer + pos2, sizeof(tempbuffer)); - dpsnprintf(buffer + pos, bufferlength - 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[MAX_INPUTLINE]; - char value[MAX_INPUTLINE]; - 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 /* - * Copyright (c) 1998 Todd C. Miller + * Copyright (c) 1998, 2015 Todd C. Miller * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -2120,66 +1319,65 @@ void InfoString_Print(char *buffer) * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -/* $OpenBSD: strlcat.c,v 1.11 2003/06/17 21:56:24 millert Exp $ */ -/* $OpenBSD: strlcpy.c,v 1.8 2003/06/17 21:56:24 millert Exp $ */ +/* $OpenBSD: strlcat.c,v 1.19 2019/01/25 00:19:25 millert Exp $ */ +/* $OpenBSD: strlcpy.c,v 1.16 2019/01/25 00:19:25 millert Exp $ */ #ifndef HAVE_STRLCAT size_t -strlcat(char *dst, const char *src, size_t siz) +strlcat(char *dst, const char *src, size_t dsize) { - register char *d = dst; - register const char *s = src; - register size_t n = siz; + const char *odst = dst; + const char *osrc = src; + size_t n = dsize; size_t dlen; - /* Find the end of dst and adjust bytes left but don't go past end */ - while (n-- != 0 && *d != '\0') - d++; - dlen = d - dst; - n = siz - dlen; - - if (n == 0) - return(dlen + strlen(s)); - while (*s != '\0') { - if (n != 1) { - *d++ = *s; + /* Find the end of dst and adjust bytes left but don't go past end. */ + while (n-- != 0 && *dst != '\0') + dst++; + dlen = dst - odst; + n = dsize - dlen; + + if (n-- == 0) + return(dlen + strlen(src)); + while (*src != '\0') { + if (n != 0) { + *dst++ = *src; n--; } - s++; + src++; } - *d = '\0'; + *dst = '\0'; - return(dlen + (s - src)); /* count does not include NUL */ + return(dlen + (src - osrc)); /* count does not include NUL */ } #endif // #ifndef HAVE_STRLCAT #ifndef HAVE_STRLCPY size_t -strlcpy(char *dst, const char *src, size_t siz) +strlcpy(char *dst, const char *src, size_t dsize) { - register char *d = dst; - register const char *s = src; - register size_t n = siz; - - /* Copy as many bytes as will fit */ - if (n != 0 && --n != 0) { - do { - if ((*d++ = *s++) == 0) + const char *osrc = src; + size_t nleft = dsize; + + /* Copy as many bytes as will fit. */ + if (nleft != 0) { + while (--nleft != 0) { + if ((*dst++ = *src++) == '\0') break; - } while (--n != 0); + } } - /* Not enough room in dst, add NUL and traverse rest of src */ - if (n == 0) { - if (siz != 0) - *d = '\0'; /* NUL-terminate dst */ - while (*s++) + /* Not enough room in dst, add NUL and traverse rest of src. */ + if (nleft == 0) { + if (dsize != 0) + *dst = '\0'; /* NUL-terminate dst */ + while (*src++) ; } - return(s - src - 1); /* count does not include NUL */ + return(src - osrc - 1); /* count does not include NUL */ } #endif // #ifndef HAVE_STRLCPY @@ -2260,7 +1458,7 @@ size_t base64_encode(unsigned char *buf, size_t buflen, size_t outbuflen) for(i = blocks; i > 0; ) { --i; - base64_3to4(buf + 3*i, buf + 4*i, buflen - 3*i); + base64_3to4(buf + 3*i, buf + 4*i, (int)(buflen - 3*i)); } return blocks * 4; }