fte/quakespasm
2
0
Fork 0
mirror of https://github.com/Shpoike/Quakespasm.git synced 2024-11-14 00:50:38 +00:00
Code Issues Projects Releases Packages Wiki Activity
quakespasm/Quake/common.c
Shpoike 49822069a3 Fix stupid zip decompression error.
2023-07-07 12:10:53 +01:00

3909 lines
83 KiB
C
Raw Blame History

/*
Copyright (C) 1996-2001 Id Software, Inc.
Copyright (C) 2002-2009 John Fitzgibbons and others
Copyright (C) 2010-2014 QuakeSpasm developers
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
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 "q_ctype.h"
#include <errno.h>
#include <sys/stat.h>
#ifndef _WIN32
#include <dirent.h>
#include <fnmatch.h>
#ifndef FNM_CASEFOLD
#define FNM_CASEFOLD 0 //not available. I guess we're not on gnu/linux
#endif
#endif
static char *largv[MAX_NUM_ARGVS + 1];
static char argvdummy[] = " ";
int safemode;
cvar_t registered = {"registered","1",CVAR_ROM}; /* set to correct value in COM_CheckRegistered() */
cvar_t cmdline = {"cmdline","",CVAR_ROM/*|CVAR_SERVERINFO*/}; /* sending cmdline upon CCREQ_RULE_INFO is evil */
cvar_t allow_download = {"allow_download", "1"}; /*set to 0 to block file downloads, both client+server*/
static qboolean com_modified; // set true if using non-id files
qboolean fitzmode;
static void COM_Path_f (void);
// if a packfile directory differs from this, it is assumed to be hacked
#define PAK0_COUNT 339 /* id1/pak0.pak - v1.0x */
#define PAK0_CRC_V100 13900 /* id1/pak0.pak - v1.00 */
#define PAK0_CRC_V101 62751 /* id1/pak0.pak - v1.01 */
#define PAK0_CRC_V106 32981 /* id1/pak0.pak - v1.06 */
#define PAK0_CRC (PAK0_CRC_V106)
#define PAK0_COUNT_V091 308 /* id1/pak0.pak - v0.91/0.92, not supported */
#define PAK0_CRC_V091 28804 /* id1/pak0.pak - v0.91/0.92, not supported */
char com_token[1024];
int com_argc;
char **com_argv;
#define CMDLINE_LENGTH 256 /* johnfitz -- mirrored in cmd.c */
char com_cmdline[CMDLINE_LENGTH];
qboolean standard_quake = true, rogue, hipnotic;
// this graphic needs to be in the pak file to use registered features
static unsigned short pop[] =
{
0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,
0x0000,0x0000,0x6600,0x0000,0x0000,0x0000,0x6600,0x0000,
0x0000,0x0066,0x0000,0x0000,0x0000,0x0000,0x0067,0x0000,
0x0000,0x6665,0x0000,0x0000,0x0000,0x0000,0x0065,0x6600,
0x0063,0x6561,0x0000,0x0000,0x0000,0x0000,0x0061,0x6563,
0x0064,0x6561,0x0000,0x0000,0x0000,0x0000,0x0061,0x6564,
0x0064,0x6564,0x0000,0x6469,0x6969,0x6400,0x0064,0x6564,
0x0063,0x6568,0x6200,0x0064,0x6864,0x0000,0x6268,0x6563,
0x0000,0x6567,0x6963,0x0064,0x6764,0x0063,0x6967,0x6500,
0x0000,0x6266,0x6769,0x6a68,0x6768,0x6a69,0x6766,0x6200,
0x0000,0x0062,0x6566,0x6666,0x6666,0x6666,0x6562,0x0000,
0x0000,0x0000,0x0062,0x6364,0x6664,0x6362,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0062,0x6662,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0061,0x6661,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x6500,0x0000,0x0000,0x0000,
0x0000,0x0000,0x0000,0x0000,0x6400,0x0000,0x0000,0x0000
};
/*
All of Quake's data access is through a hierchal file system, but the contents
of the file system can be transparently merged from several sources.
The "base directory" is the path to the directory holding the quake.exe and all
game directories. The sys_* files pass this to host_init in quakeparms_t->basedir.
This can be overridden with the "-basedir" command line parm to allow code
debugging in a different directory. The base directory is only used during
filesystem initialization.
The "game directory" is the first tree on the search path and directory that all
generated files (savegames, screenshots, demos, config files) will be saved to.
This can be overridden with the "-game" command line parameter. The game
directory can never be changed while quake is executing. This is a precacution
against having a malicious server instruct clients to write files over areas they
shouldn't.
The "cache directory" is only used during development to save network bandwidth,
especially over ISDN / T1 lines. If there is a cache directory specified, when
a file is found by the normal search path, it will be mirrored into the cache
directory, then opened there.
FIXME:
The file "parms.txt" will be read out of the game directory and appended to the
current command line arguments to allow different games to initialize startup
parms differently. This could be used to add a "-sspeed 22050" for the high
quality sound edition. Because they are added at the end, they will not
override an explicit setting on the original command line.
*/
//============================================================================
// ClearLink is used for new headnodes
void ClearLink (link_t *l)
{
l->prev = l->next = l;
}
void RemoveLink (link_t *l)
{
l->next->prev = l->prev;
l->prev->next = l->next;
}
void InsertLinkBefore (link_t *l, link_t *before)
{
l->next = before;
l->prev = before->prev;
l->prev->next = l;
l->next->prev = l;
}
void InsertLinkAfter (link_t *l, link_t *after)
{
l->next = after->next;
l->prev = after;
l->prev->next = l;
l->next->prev = l;
}
/*
============================================================================
LIBRARY REPLACEMENT FUNCTIONS
============================================================================
*/
int q_strcasecmp(const char * s1, const char * s2)
{
const char * p1 = s1;
const char * p2 = s2;
char c1, c2;
if (p1 == p2)
return 0;
do
{
c1 = q_tolower (*p1++);
c2 = q_tolower (*p2++);
if (c1 == '\0')
break;
} while (c1 == c2);
return (int)(c1 - c2);
}
int q_strncasecmp(const char *s1, const char *s2, size_t n)
{
const char * p1 = s1;
const char * p2 = s2;
char c1, c2;
if (p1 == p2 || n == 0)
return 0;
do
{
c1 = q_tolower (*p1++);
c2 = q_tolower (*p2++);
if (c1 == '\0' || c1 != c2)
break;
} while (--n > 0);
return (int)(c1 - c2);
}
//spike -- grabbed this from fte, because its useful to me
char *q_strcasestr(const char *haystack, const char *needle)
{
int c1, c2, c2f;
int i;
c2f = *needle;
if (c2f >= 'a' && c2f <= 'z')
c2f -= ('a' - 'A');
if (!c2f)
return (char*)haystack;
while (1)
{
c1 = *haystack;
if (!c1)
return NULL;
if (c1 >= 'a' && c1 <= 'z')
c1 -= ('a' - 'A');
if (c1 == c2f)
{
for (i = 1; ; i++)
{
c1 = haystack[i];
c2 = needle[i];
if (c1 >= 'a' && c1 <= 'z')
c1 -= ('a' - 'A');
if (c2 >= 'a' && c2 <= 'z')
c2 -= ('a' - 'A');
if (!c2)
return (char*)haystack; //end of needle means we found a complete match
if (!c1) //end of haystack means we can't possibly find needle in it any more
return NULL;
if (c1 != c2) //mismatch means no match starting at haystack[0]
break;
}
}
haystack++;
}
return NULL; //didn't find it
}
char *q_strlwr (char *str)
{
char *c;
c = str;
while (*c)
{
*c = q_tolower(*c);
c++;
}
return str;
}
char *q_strupr (char *str)
{
char *c;
c = str;
while (*c)
{
*c = q_toupper(*c);
c++;
}
return str;
}
/* platform dependant (v)snprintf function names: */
#if defined(_WIN32)
#define snprintf_func _snprintf
#define vsnprintf_func _vsnprintf
#else
#define snprintf_func snprintf
#define vsnprintf_func vsnprintf
#endif
int q_vsnprintf(char *str, size_t size, const char *format, va_list args)
{
int ret;
ret = vsnprintf_func (str, size, format, args);
if (ret < 0)
ret = (int)size;
if (size == 0) /* no buffer */
return ret;
if ((size_t)ret >= size)
str[size - 1] = '\0';
return ret;
}
int q_snprintf (char *str, size_t size, const char *format, ...)
{
int ret;
va_list argptr;
va_start (argptr, format);
ret = q_vsnprintf (str, size, format, argptr);
va_end (argptr);
return ret;
}
void Q_memset (void *dest, int fill, size_t count)
{
size_t i;
if ( (((uintptr_t)dest | count) & 3) == 0)
{
count >>= 2;
fill = fill | (fill<<8) | (fill<<16) | (fill<<24);
for (i = 0; i < count; i++)
((int *)dest)[i] = fill;
}
else
for (i = 0; i < count; i++)
((byte *)dest)[i] = fill;
}
void Q_memcpy (void *dest, const void *src, size_t count)
{
size_t i;
if (( ( (uintptr_t)dest | (uintptr_t)src | count) & 3) == 0)
{
count >>= 2;
for (i = 0; i < count; i++)
((int *)dest)[i] = ((int *)src)[i];
}
else
for (i = 0; i < count; i++)
((byte *)dest)[i] = ((byte *)src)[i];
}
int Q_memcmp (const void *m1, const void *m2, size_t count)
{
while(count)
{
count--;
if (((byte *)m1)[count] != ((byte *)m2)[count])
return -1;
}
return 0;
}
void Q_strcpy (char *dest, const char *src)
{
while (*src)
{
*dest++ = *src++;
}
*dest++ = 0;
}
void Q_strncpy (char *dest, const char *src, int count)
{
while (*src && count--)
{
*dest++ = *src++;
}
if (count)
*dest++ = 0;
}
int Q_strlen (const char *str)
{
int count;
count = 0;
while (str[count])
count++;
return count;
}
char *Q_strrchr(const char *s, char c)
{
int len = Q_strlen(s);
s += len;
while (len--)
{
if (*--s == c)
return (char *)s;
}
return NULL;
}
void Q_strcat (char *dest, const char *src)
{
dest += Q_strlen(dest);
Q_strcpy (dest, src);
}
int Q_strcmp (const char *s1, const char *s2)
{
while (1)
{
if (*s1 != *s2)
return -1; // strings not equal
if (!*s1)
return 0; // strings are equal
s1++;
s2++;
}
return -1;
}
int Q_strncmp (const char *s1, const char *s2, int count)
{
while (1)
{
if (!count--)
return 0;
if (*s1 != *s2)
return -1; // strings not equal
if (!*s1)
return 0; // strings are equal
s1++;
s2++;
}
return -1;
}
int Q_atoi (const char *str)
{
int val;
int sign;
int c;
while (q_isspace (*str))
++str;
if (*str == '-')
{
sign = -1;
str++;
}
else
sign = 1;
val = 0;
//
// check for hex
//
if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
{
str += 2;
while (1)
{
c = *str++;
if (c >= '0' && c <= '9')
val = (val<<4) + c - '0';
else if (c >= 'a' && c <= 'f')
val = (val<<4) + c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
val = (val<<4) + c - 'A' + 10;
else
return val*sign;
}
}
//
// check for character
//
if (str[0] == '\'')
{
return sign * str[1];
}
//
// assume decimal
//
while (1)
{
c = *str++;
if (c <'0' || c > '9')
return val*sign;
val = val*10 + c - '0';
}
return 0;
}
float Q_atof (const char *str)
{
double val;
int sign;
int c;
int decimal, total;
while (q_isspace (*str))
++str;
if (*str == '-')
{
sign = -1;
str++;
}
else
sign = 1;
val = 0;
//
// check for hex
//
if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
{
str += 2;
while (1)
{
c = *str++;
if (c >= '0' && c <= '9')
val = (val*16) + c - '0';
else if (c >= 'a' && c <= 'f')
val = (val*16) + c - 'a' + 10;
else if (c >= 'A' && c <= 'F')
val = (val*16) + c - 'A' + 10;
else
return val*sign;
}
}
//
// check for character
//
if (str[0] == '\'')
{
return sign * str[1];
}
//
// assume decimal
//
decimal = -1;
total = 0;
while (1)
{
c = *str++;
if (c == '.')
{
decimal = total;
continue;
}
if (c <'0' || c > '9')
break;
val = val*10 + c - '0';
total++;
}
if (decimal == -1)
return val*sign;
while (total > decimal)
{
val /= 10;
total--;
}
return val*sign;
}
// Q_ftoa: convert IEEE 754 float to a base-10 string with "infinite" decimal places
void Q_ftoa(char *str, float in)
{
struct {
float f;
unsigned int i;
} u = {in};
int signbit = (u.i & 0x80000000) >> 31;
int exp = (signed int)((u.i & 0x7F800000) >> 23) - 127;
int mantissa = (u.i & 0x007FFFFF);
if (exp == 128) // 255(NaN/Infinity bits) - 127(bias)
{
if (signbit)
{
*str = '-';
str++;
}
if (mantissa == 0) // infinity
strcpy(str, "1.#INF");
else // NaN or indeterminate
strcpy(str, "1.#NAN");
return;
}
exp = -exp;
exp = (int)(exp * 0.30102999957f); // convert base 2 to base 10
exp += 8;
if (exp <= 0)
sprintf(str, "%.0f", in);
else
{
char tstr[32];
char *lsig = str - 1;
sprintf(tstr, "%%.%if", exp);
sprintf(str, tstr, in);
// find last significant digit and trim
while (*str)
{
if (*str >= '1' && *str <= '9')
lsig = str;
else if (*str == '.')
lsig = str - 1;
str++;
}
lsig[1] = '\0';
}
}
int wildcmp(const char *wild, const char *string)
{ //case-insensitive string compare with wildcards. returns true for a match.
while (*string)
{
if (*wild == '*')
{
if (*string == '/' || *string == '\\')
{
//* terminates if we get a match on the char following it, or if its a \ or / char
wild++;
continue;
}
if (wildcmp(wild+1, string))
return true;
string++;
}
else if ((q_tolower(*wild) == q_tolower(*string)) || (*wild == '?'))
{
//this char matches
wild++;
string++;
}
else
{
//failure
return false;
}
}
while (*wild == '*')
{
wild++;
}
return !*wild;
}
void Info_RemoveKey(char *info, const char *key)
{ //only shrinks, so no need for max size.
size_t keylen = strlen(key);
while(*info)
{
char *l = info;
if (*info++ != '\\')
break; //error / end-of-string
if (!strncmp(info, key, keylen) && info[keylen] == '\\')
{
//skip the key name
info += keylen+1;
//this is the old value for the key. skip over it
while (*info && *info != '\\')
info++;
//okay, we found it. strip it out now.
memmove(l, info, strlen(info)+1);
return;
}
else
{
//skip the key
while (*info && *info != '\\')
info++;
//validate that its a value now
if (*info++ != '\\')
break; //error
//skip the value
while (*info && *info != '\\')
info++;
}
}
}
void Info_SetKey(char *info, size_t infosize, const char *key, const char *val)
{
size_t keylen = strlen(key);
size_t vallen = strlen(val);
Info_RemoveKey(info, key);
if (vallen)
{
char *o = info + strlen(info);
char *e = info + infosize-1;
if (!*key || strchr(key, '\\') || strchr(val, '\\'))
Con_Warning("Info_SetKey(%s): invalid key/value\n", key);
else if (o + 2 + keylen + vallen >= e)
Con_Warning("Info_SetKey(%s): length exceeds max\n", key);
else
{
*o++ = '\\';
memcpy(o, key, keylen);
o += keylen;
*o++ = '\\';
memcpy(o, val, vallen);
o += vallen;
*o = 0;
}
}
}
const char *Info_GetKey(const char *info, const char *key, char *out, size_t outsize)
{
const char *r = out;
size_t keylen = strlen(key);
outsize--;
while(*info)
{
if (*info++ != '\\')
break; //error / end-of-string
if (!strncmp(info, key, keylen) && info[keylen] == '\\')
{
//skip the key name
info += keylen+1;
//this is the value for the key. copy it out
while (*info && *info != '\\' && outsize-->0)
*out++ = *info++;
break;
}
else
{
//skip the key
while (*info && *info != '\\')
info++;
//validate that its a value now
if (*info++ != '\\')
break; //error
//skip the value
while (*info && *info != '\\')
info++;
}
}
*out = 0;
return r;
}
void Info_Enumerate(const char *info, void(*cb)(void *ctx, const char *key, const char *value), void *cbctx)
{
char key[1024];
char val[1024];
size_t kl, vl;
while(*info)
{
kl=vl=0;
if (*info++ != '\\')
break; //error / end-of-string
//skip the key
while (*info && *info != '\\')
{
if (kl < sizeof(key)-1)
key[kl++] = *info;
info++;
}
//validate that its a value now
if (*info++ != '\\')
break; //error
//skip the value
while (*info && *info != '\\')
{
if (vl < sizeof(val)-1)
val[vl++] = *info;
info++;
}
key[kl] = 0;
val[vl] = 0;
cb(cbctx, key, val);
}
}
static void Info_Print_Callback(void *ctx, const char *key, const char *val)
{
Con_Printf("%20s: %s\n", key, val);
}
void Info_Print(const char *info)
{
Info_Enumerate(info, Info_Print_Callback, NULL);
}
/*
============================================================================
BYTE ORDER FUNCTIONS
============================================================================
*/
qboolean host_bigendian;
short (*BigShort) (short l);
short (*LittleShort) (short l);
int (*BigLong) (int l);
int (*LittleLong) (int l);
float (*BigFloat) (float l);
float (*LittleFloat) (float l);
short ShortSwap (short l)
{
byte b1, b2;
b1 = l&255;
b2 = (l>>8)&255;
return (b1<<8) + b2;
}
short ShortNoSwap (short l)
{
return l;
}
int LongSwap (int l)
{
byte b1, b2, b3, b4;
b1 = l&255;
b2 = (l>>8)&255;
b3 = (l>>16)&255;
b4 = (l>>24)&255;
return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
}
int LongNoSwap (int l)
{
return l;
}
float FloatSwap (float f)
{
union
{
float f;
byte b[4];
} dat1, dat2;
dat1.f = f;
dat2.b[0] = dat1.b[3];
dat2.b[1] = dat1.b[2];
dat2.b[2] = dat1.b[1];
dat2.b[3] = dat1.b[0];
return dat2.f;
}
float FloatNoSwap (float f)
{
return f;
}
/*
==============================================================================
MESSAGE IO FUNCTIONS
Handles byte ordering and avoids alignment errors
==============================================================================
*/
//
// writing functions
//
void MSG_WriteChar (sizebuf_t *sb, int c)
{
byte *buf;
#ifdef PARANOID
if (c < -128 || c > 127)
Sys_Error ("MSG_WriteChar: range error");
#endif
buf = (byte *) SZ_GetSpace (sb, 1);
buf[0] = c;
}
void MSG_WriteByte (sizebuf_t *sb, int c)
{
byte *buf;
#ifdef PARANOID
if (c < 0 || c > 255)
Sys_Error ("MSG_WriteByte: range error");
#endif
buf = (byte *) SZ_GetSpace (sb, 1);
buf[0] = c;
}
void MSG_WriteShort (sizebuf_t *sb, int c)
{
byte *buf;
#ifdef PARANOID
if (c < ((short)0x8000) || c > (short)0x7fff)
Sys_Error ("MSG_WriteShort: range error");
#endif
buf = (byte *) SZ_GetSpace (sb, 2);
buf[0] = c&0xff;
buf[1] = c>>8;
}
void MSG_WriteLong (sizebuf_t *sb, int c)
{
byte *buf;
buf = (byte *) SZ_GetSpace (sb, 4);
buf[0] = c&0xff;
buf[1] = (c>>8)&0xff;
buf[2] = (c>>16)&0xff;
buf[3] = c>>24;
}
void MSG_WriteUInt64 (sizebuf_t *sb, unsigned long long c)
{ //0* 10*,*, 110*,*,* etc, up to 0xff followed by 8 continuation bytes
byte *buf;
int b = 0;
unsigned long long l = 128;
while (c > l-1u)
{ //count the extra bytes we need
b++;
l <<= 7; //each byte we add gains 8 bits, but we spend one on length.
}
buf = (byte*)SZ_GetSpace (sb, 1+b);
*buf++ = 0xffu<<(8-b) | (c >> (b*8));
while(b --> 0)
*buf++ = (c >> (b*8))&0xff;
}
void MSG_WriteInt64 (sizebuf_t *sb, long long c)
{ //move the sign bit into the low bit and avoid sign extension for more efficient length coding.
if (c < 0)
MSG_WriteUInt64(sb, ((unsigned long long)(-1-c)<<1)|1);
else
MSG_WriteUInt64(sb, c<<1);
}
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, &dat.l, 4);
}
void MSG_WriteDouble (sizebuf_t *sb, double f)
{
union
{
double f;
int64_t l;
} dat;
byte *o = SZ_GetSpace (sb, sizeof(f));
dat.f = f;
o[0] = dat.l>>0;
o[1] = dat.l>>8;
o[2] = dat.l>>16;
o[3] = dat.l>>24;
o[4] = dat.l>>32;
o[5] = dat.l>>40;
o[6] = dat.l>>48;
o[7] = dat.l>>56;
}
void MSG_WriteString (sizebuf_t *sb, const char *s)
{
if (!s)
SZ_Write (sb, "", 1);
else
SZ_Write (sb, s, Q_strlen(s)+1);
}
void MSG_WriteStringUnterminated (sizebuf_t *sb, const char *s)
{
SZ_Write (sb, s, Q_strlen(s));
}
//johnfitz -- original behavior, 13.3 fixed point coords, max range +-4096
void MSG_WriteCoord16 (sizebuf_t *sb, float f)
{
MSG_WriteShort (sb, Q_rint(f*8));
}
//johnfitz -- 16.8 fixed point coords, max range +-32768
void MSG_WriteCoord24 (sizebuf_t *sb, float f)
{
MSG_WriteShort (sb, f);
MSG_WriteByte (sb, (int)(f*255)%255);
}
//johnfitz -- 32-bit float coords
void MSG_WriteCoord32f (sizebuf_t *sb, float f)
{
MSG_WriteFloat (sb, f);
}
void MSG_WriteCoord (sizebuf_t *sb, float f, unsigned int flags)
{
if (flags & PRFL_FLOATCOORD)
MSG_WriteFloat (sb, f);
else if (flags & PRFL_INT32COORD)
MSG_WriteLong (sb, Q_rint (f * 16));
else if (flags & PRFL_24BITCOORD)
MSG_WriteCoord24 (sb, f);
else MSG_WriteCoord16 (sb, f);
}
void MSG_WriteAngle (sizebuf_t *sb, float f, unsigned int flags)
{
if (flags & PRFL_FLOATANGLE)
MSG_WriteFloat (sb, f);
else if (flags & PRFL_SHORTANGLE)
MSG_WriteShort (sb, Q_rint(f * 65536.0 / 360.0) & 65535);
else MSG_WriteByte (sb, Q_rint(f * 256.0 / 360.0) & 255); //johnfitz -- use Q_rint instead of (int) }
}
//johnfitz -- for PROTOCOL_FITZQUAKE
void MSG_WriteAngle16 (sizebuf_t *sb, float f, unsigned int flags)
{
if (flags & PRFL_FLOATANGLE)
MSG_WriteFloat (sb, f);
else MSG_WriteShort (sb, Q_rint(f * 65536.0 / 360.0) & 65535);
}
//johnfitz
//spike -- for PEXT2_REPLACEMENTDELTAS
void MSG_WriteEntity (sizebuf_t *sb, unsigned int entnum, unsigned int pext2)
{
//high short, low byte
if (entnum > 0x7fff && (pext2 & PEXT2_REPLACEMENTDELTAS))
{
MSG_WriteShort(sb, 0x8000|(entnum>>8));
MSG_WriteByte(sb, entnum&0xff);
}
else
MSG_WriteShort(sb, entnum);
}
//
// reading functions
//
int msg_readcount;
qboolean msg_badread;
void MSG_BeginReading (void)
{
msg_readcount = 0;
msg_badread = false;
}
// returns -1 and sets msg_badread if no more characters are available
int MSG_ReadChar (void)
{
int c;
if (msg_readcount+1 > net_message.cursize)
{
msg_badread = true;
return -1;
}
c = (signed char)net_message.data[msg_readcount];
msg_readcount++;
return c;
}
int MSG_ReadByte (void)
{
int c;
if (msg_readcount+1 > net_message.cursize)
{
msg_badread = true;
return -1;
}
c = (unsigned char)net_message.data[msg_readcount];
msg_readcount++;
return c;
}
int MSG_ReadShort (void)
{
int c;
if (msg_readcount+2 > net_message.cursize)
{
msg_badread = true;
return -1;
}
c = (short)(net_message.data[msg_readcount]
+ (net_message.data[msg_readcount+1]<<8));
msg_readcount += 2;
return c;
}
int MSG_ReadLong (void)
{
int c;
if (msg_readcount+4 > net_message.cursize)
{
msg_badread = true;
return -1;
}
c = net_message.data[msg_readcount]
+ (net_message.data[msg_readcount+1]<<8)
+ (net_message.data[msg_readcount+2]<<16)
+ (net_message.data[msg_readcount+3]<<24);
msg_readcount += 4;
return c;
}
unsigned long long MSG_ReadUInt64 (void)
{ //0* 10*,*, 110*,*,* etc, up to 0xff followed by 8 continuation bytes
byte l=0x80, v, b = 0;
unsigned long long r;
v = MSG_ReadByte();
for (; v&l; l>>=1)
{
v-=l;
b++;
}
r = v<<(b*8);
while(b --> 0)
r |= MSG_ReadByte()<<(b*8);
return r;
}
long long MSG_ReadInt64 (void)
{ //we do some fancy bit recoding for more efficient length coding.
unsigned long long c = MSG_ReadUInt64();
if (c&1)
return -1-(long long)(c>>1);
else
return (long long)(c>>1);
}
float MSG_ReadFloat (void)
{
union
{
byte b[4];
float f;
int l;
} dat;
dat.b[0] = net_message.data[msg_readcount];
dat.b[1] = net_message.data[msg_readcount+1];
dat.b[2] = net_message.data[msg_readcount+2];
dat.b[3] = net_message.data[msg_readcount+3];
msg_readcount += 4;
dat.l = LittleLong (dat.l);
return dat.f;
}
float MSG_ReadDouble (void)
{
union
{
double f;
uint64_t l;
} dat;
dat.l = ((uint64_t)net_message.data[msg_readcount ]<<0 ) |
((uint64_t)net_message.data[msg_readcount+1]<<8 ) |
((uint64_t)net_message.data[msg_readcount+2]<<16) |
((uint64_t)net_message.data[msg_readcount+3]<<24) |
((uint64_t)net_message.data[msg_readcount+4]<<32) |
((uint64_t)net_message.data[msg_readcount+5]<<40) |
((uint64_t)net_message.data[msg_readcount+6]<<48) |
((uint64_t)net_message.data[msg_readcount+7]<<56) ;
msg_readcount += 8;
return dat.f;
}
const char *MSG_ReadString (void)
{
static char string[2048];
int c;
size_t l;
l = 0;
do
{
c = MSG_ReadByte ();
if (c == -1 || c == 0)
break;
string[l] = c;
l++;
} while (l < sizeof(string) - 1);
string[l] = 0;
return string;
}
//johnfitz -- original behavior, 13.3 fixed point coords, max range +-4096
float MSG_ReadCoord16 (void)
{
return MSG_ReadShort() * (1.0/8);
}
//johnfitz -- 16.8 fixed point coords, max range +-32768
float MSG_ReadCoord24 (void)
{
return MSG_ReadShort() + MSG_ReadByte() * (1.0/255);
}
//johnfitz -- 32-bit float coords
float MSG_ReadCoord32f (void)
{
return MSG_ReadFloat();
}
float MSG_ReadCoord (unsigned int flags)
{
if (flags & PRFL_FLOATCOORD)
return MSG_ReadFloat ();
else if (flags & PRFL_INT32COORD)
return MSG_ReadLong () * (1.0 / 16.0);
else if (flags & PRFL_24BITCOORD)
return MSG_ReadCoord24 ();
else return MSG_ReadCoord16 ();
}
float MSG_ReadAngle (unsigned int flags)
{
if (flags & PRFL_FLOATANGLE)
return MSG_ReadFloat ();
else if (flags & PRFL_SHORTANGLE)
return MSG_ReadShort () * (360.0 / 65536);
else return MSG_ReadChar () * (360.0 / 256);
}
//johnfitz -- for PROTOCOL_FITZQUAKE
float MSG_ReadAngle16 (unsigned int flags)
{
if (flags & PRFL_FLOATANGLE)
return MSG_ReadFloat (); // make sure
else return MSG_ReadShort () * (360.0 / 65536);
}
//johnfitz
unsigned int MSG_ReadEntity(unsigned int pext2)
{
unsigned int e = (unsigned short)MSG_ReadShort();
if (pext2 & PEXT2_REPLACEMENTDELTAS)
{
if (e & 0x8000)
{
e = (e & 0x7fff) << 8;
e |= MSG_ReadByte();
}
}
return e;
}
//spike -- for downloads
byte *MSG_ReadData (unsigned int length)
{
byte *data;
if (msg_readcount+length > (unsigned int)net_message.cursize)
{
msg_badread = true;
return NULL;
}
data = net_message.data+msg_readcount;
msg_readcount += length;
return data;
}
//===========================================================================
void SZ_Alloc (sizebuf_t *buf, int startsize)
{
if (startsize < 256)
startsize = 256;
buf->data = (byte *) Hunk_AllocName (startsize, "sizebuf");
buf->maxsize = startsize;
buf->cursize = 0;
}
void SZ_Free (sizebuf_t *buf)
{
// Z_Free (buf->data);
// buf->data = NULL;
// buf->maxsize = 0;
buf->cursize = 0;
}
void SZ_Clear (sizebuf_t *buf)
{
buf->cursize = 0;
buf->overflowed = false;
}
void *SZ_GetSpace (sizebuf_t *buf, int length)
{
void *data;
if (buf->cursize + length > buf->maxsize)
{
if (!buf->allowoverflow)
Host_Error ("SZ_GetSpace: overflow without allowoverflow set"); // ericw -- made Host_Error to be less annoying
if (length > buf->maxsize)
Sys_Error ("SZ_GetSpace: %i is > full buffer size", length);
Con_Printf ("SZ_GetSpace: overflow\n");
SZ_Clear (buf);
buf->overflowed = true;
}
data = buf->data + buf->cursize;
buf->cursize += length;
return data;
}
void SZ_Write (sizebuf_t *buf, const void *data, int length)
{
Q_memcpy (SZ_GetSpace(buf,length),data,length);
}
void SZ_Print (sizebuf_t *buf, const char *data)
{
int len = Q_strlen(data) + 1;
if (buf->data[buf->cursize-1])
{ /* no trailing 0 */
Q_memcpy ((byte *)SZ_GetSpace(buf, len ) , data, len);
}
else
{ /* write over trailing 0 */
Q_memcpy ((byte *)SZ_GetSpace(buf, len-1)-1, data, len);
}
}
//============================================================================
/*
============
COM_SkipPath
============
*/
const char *COM_SkipPath (const char *pathname)
{
const char *last;
last = pathname;
while (*pathname)
{
if (*pathname == '/')
last = pathname + 1;
pathname++;
}
return last;
}
/*
============
COM_StripExtension
============
*/
void COM_StripExtension (const char *in, char *out, size_t outsize)
{
int length;
if (!*in)
{
*out = '\0';
return;
}
if (in != out) /* copy when not in-place editing */
q_strlcpy (out, in, outsize);
length = (int)strlen(out) - 1;
while (length > 0 && out[length] != '.')
{
--length;
if (out[length] == '/' || out[length] == '\\')
return; /* no extension */
}
if (length > 0)
out[length] = '\0';
}
/*
============
COM_FileGetExtension - doesn't return NULL
============
*/
const char *COM_FileGetExtension (const char *in)
{
const char *src;
size_t len;
len = strlen(in);
if (len < 2) /* nothing meaningful */
return "";
src = in + len - 1;
while (src != in && src[-1] != '.')
src--;
if (src == in || strchr(src, '/') != NULL || strchr(src, '\\') != NULL)
return ""; /* no extension, or parent directory has a dot */
return src;
}
/*
============
COM_ExtractExtension
============
*/
void COM_ExtractExtension (const char *in, char *out, size_t outsize)
{
const char *ext = COM_FileGetExtension (in);
if (! *ext)
*out = '\0';
else
q_strlcpy (out, ext, outsize);
}
/*
============
COM_FileBase
take 'somedir/otherdir/filename.ext',
write only 'filename' to the output
============
*/
void COM_FileBase (const char *in, char *out, size_t outsize)
{
const char *dot, *slash, *s;
s = in;
slash = in;
dot = NULL;
while (*s)
{
if (*s == '/')
slash = s + 1;
if (*s == '.')
dot = s;
s++;
}
if (dot == NULL)
dot = s;
if (dot - slash < 2)
q_strlcpy (out, "?model?", outsize);
else
{
size_t len = dot - slash;
if (len >= outsize)
len = outsize - 1;
memcpy (out, slash, len);
out[len] = '\0';
}
}
/*
==================
COM_DefaultExtension
if path doesn't have a .EXT, append extension
(extension should include the leading ".")
==================
*/
#if 0 /* can be dangerous */
void COM_DefaultExtension (char *path, const char *extension, size_t len)
{
char *src;
if (!*path) return;
src = path + strlen(path) - 1;
while (*src != '/' && *src != '\\' && src != path)
{
if (*src == '.')
return; // it has an extension
src--;
}
q_strlcat(path, extension, len);
}
#endif
/*
==================
COM_AddExtension
if path extension doesn't match .EXT, append it
(extension should include the leading ".")
==================
*/
void COM_AddExtension (char *path, const char *extension, size_t len)
{
if (strcmp(COM_FileGetExtension(path), extension + 1) != 0)
q_strlcat(path, extension, len);
}
/*
spike -- this function simply says whether a filename is acceptable for downloading (used by both client+server)
*/
qboolean COM_DownloadNameOkay(const char *filename)
{
if (!allow_download.value)
return false;
//quickly test the prefix to ensure that its in one of the allowed subdirs
if (strncmp(filename, "sound/", 6) &&
strncmp(filename, "progs/", 6) &&
strncmp(filename, "maps/", 5) &&
strncmp(filename, "models/", 7))
return false;
//windows paths are NOT permitted, nor are alternative data streams, nor wildcards, and double quotes are always bad(which allows for spaces)
if (strchr(filename, '\\') || strchr(filename, ':') || strchr(filename, '*') || strchr(filename, '?') || strchr(filename, '\"'))
return false;
//some operating systems interpret this as 'parent directory'
if (strstr(filename, "//"))
return false;
//block unix hidden files, also blocks relative paths.
if (*filename == '.' || strstr(filename, "/."))
return false;
//test the extension to ensure that its in one of the allowed file types
//(no .dll, .so, .com, .exe, .bat, .vbs, .xls, .doc, etc please)
//also don't allow config files.
filename = COM_FileGetExtension(filename);
if (
//model formats
q_strcasecmp(filename, "bsp") &&
q_strcasecmp(filename, "mdl") &&
q_strcasecmp(filename, "iqm") && //in case we ever support these later
q_strcasecmp(filename, "md3") &&
q_strcasecmp(filename, "spr") &&
q_strcasecmp(filename, "spr32") &&
//audio formats
q_strcasecmp(filename, "wav") &&
q_strcasecmp(filename, "ogg") &&
//image formats (if we ever need that)
q_strcasecmp(filename, "tga") &&
q_strcasecmp(filename, "png") &&
//misc stuff
q_strcasecmp(filename, "lux") &&
q_strcasecmp(filename, "lit2") &&
q_strcasecmp(filename, "lit"))
return false;
//okay, well, we didn't throw a hissy fit, so whatever dude, go ahead and download
return true;
}
/*
==============
COM_Parse
Parse a token out of a string
==============
*/
const char *COM_Parse (const char *data)
{
int c;
int len;
len = 0;
com_token[0] = 0;
if (!data)
return NULL;
// skip whitespace
skipwhite:
while ((c = *data) <= ' ')
{
if (c == 0)
return NULL; // end of file
data++;
}
// skip // comments
if (c == '/' && data[1] == '/')
{
while (*data && *data != '\n')
data++;
goto skipwhite;
}
// skip /*..*/ comments
if (c == '/' && data[1] == '*')
{
data += 2;
while (*data && !(*data == '*' && data[1] == '/'))
data++;
if (*data)
data += 2;
goto skipwhite;
}
// handle quoted strings specially
if (c == '\"')
{
data++;
while (1)
{
if ((c = *data) != 0)
++data;
if (c == '\"' || !c)
{
com_token[len] = 0;
return data;
}
com_token[len] = c;
len++;
}
}
// parse single characters
if (c == '{' || c == '}'|| c == '('|| c == ')' || c == '\'' || c == ':')
{
com_token[len] = c;
len++;
com_token[len] = 0;
return data+1;
}
// parse a regular word
do
{
com_token[len] = c;
data++;
len++;
c = *data;
/* commented out the check for ':' so that ip:port works */
if (c == '{' || c == '}'|| c == '('|| c == ')' || c == '\''/* || c == ':' */)
break;
} while (c > 32);
com_token[len] = 0;
return data;
}
/*
================
COM_CheckParm
Returns the position (1 to argc-1) in the program's argument list
where the given parameter apears, or 0 if not present
================
*/
int COM_CheckParmNext (int last, const char *parm)
{
int i;
for (i = last+1; i < com_argc; i++)
{
if (!com_argv[i])
continue; // NEXTSTEP sometimes clears appkit vars.
if (!Q_strcmp (parm,com_argv[i]))
return i;
}
return 0;
}
int COM_CheckParm (const char *parm)
{
return COM_CheckParmNext(0, parm);
}
/*
================
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.
================
*/
static void COM_CheckRegistered (void)
{
int h;
unsigned short check[128];
int i;
COM_OpenFile("gfx/pop.lmp", &h, NULL);
if (h == -1)
{
Cvar_SetROM ("registered", "0");
Con_Printf ("Playing shareware version.\n");
if (com_modified)
Sys_Error ("You must have the registered version to use modified games.\n\n"
"Basedir is: %s\n\n"
"Check that this has an " GAMENAME " subdirectory containing pak0.pak and pak1.pak, "
"or use the -basedir command-line option to specify another directory.",
com_basedir);
return;
}
Sys_FileRead (h, check, sizeof(check));
COM_CloseFile (h);
for (i = 0; i < 128; i++)
{
if (pop[i] != (unsigned short)BigShort (check[i]))
Sys_Error ("Corrupted data file.");
}
for (i = 0; com_cmdline[i]; i++)
{
if (com_cmdline[i]!= ' ')
break;
}
Cvar_SetROM ("cmdline", &com_cmdline[i]);
Cvar_SetROM ("registered", "1");
Con_Printf ("Playing registered version.\n");
}
/*
================
COM_InitArgv
================
*/
void COM_InitArgv (int argc, char **argv)
{
int i, j, n;
// reconstitute the command line for the cmdline externally visible cvar
n = 0;
for (j = 0; (j<MAX_NUM_ARGVS) && (j< argc); j++)
{
i = 0;
while ((n < (CMDLINE_LENGTH - 1)) && argv[j][i])
{
com_cmdline[n++] = argv[j][i++];
}
if (n < (CMDLINE_LENGTH - 1))
com_cmdline[n++] = ' ';
else
break;
}
if (n > 0 && com_cmdline[n-1] == ' ')
com_cmdline[n-1] = 0; //johnfitz -- kill the trailing space
Con_Printf("Command line: %s\n", com_cmdline);
for (com_argc = 0; (com_argc < MAX_NUM_ARGVS) && (com_argc < argc); com_argc++)
{
largv[com_argc] = argv[com_argc];
if (!Q_strcmp ("-safe", argv[com_argc]))
safemode = 1;
}
largv[com_argc] = argvdummy;
com_argv = largv;
if (COM_CheckParm ("-rogue"))
{
rogue = true;
standard_quake = false;
}
if (COM_CheckParm ("-hipnotic") || COM_CheckParm ("-quoth")) //johnfitz -- "-quoth" support
{
hipnotic = true;
standard_quake = false;
}
}
entity_state_t nullentitystate;
static void COM_SetupNullState(void)
{
//the null state has some specific default values
// nullentitystate.drawflags = /*SCALE_ORIGIN_ORIGIN*/96;
nullentitystate.colormod[0] = 32;
nullentitystate.colormod[1] = 32;
nullentitystate.colormod[2] = 32;
nullentitystate.glowmod[0] = 32;
nullentitystate.glowmod[1] = 32;
nullentitystate.glowmod[2] = 32;
nullentitystate.alpha = ENTALPHA_DEFAULT; //fte has 255 by default, with 0 for invisible. fitz uses 1 for invisible, 0 default, and 255=full alpha
nullentitystate.scale = ENTSCALE_DEFAULT;
nullentitystate.solidsize = ES_SOLID_NOT;
}
/*
================
COM_Init
================
*/
void COM_Init (void)
{
int i = 0x12345678;
/* U N I X */
/*
BE_ORDER: 12 34 56 78
U N I X
LE_ORDER: 78 56 34 12
X I N U
PDP_ORDER: 34 12 78 56
N U X I
*/
if ( *(char *)&i == 0x12 )
host_bigendian = true;
else if ( *(char *)&i == 0x78 )
host_bigendian = false;
else /* if ( *(char *)&i == 0x34 ) */
Sys_Error ("Unsupported endianism.");
if (host_bigendian)
{
BigShort = ShortNoSwap;
LittleShort = ShortSwap;
BigLong = LongNoSwap;
LittleLong = LongSwap;
BigFloat = FloatNoSwap;
LittleFloat = FloatSwap;
}
else /* assumed LITTLE_ENDIAN. */
{
BigShort = ShortSwap;
LittleShort = ShortNoSwap;
BigLong = LongSwap;
LittleLong = LongNoSwap;
BigFloat = FloatSwap;
LittleFloat = FloatNoSwap;
}
if (COM_CheckParm("-fitz"))
{
fitzmode = true;
cl_demoreel.string = "1"; //shouldn't be registered yet.
}
COM_SetupNullState();
}
/*
============
va
does a varargs printf into a temp buffer. cycles between
4 different static buffers. the number of buffers cycled
is defined in VA_NUM_BUFFS.
FIXME: make this buffer size safe someday
============
*/
#define VA_NUM_BUFFS 4
#define VA_BUFFERLEN 1024
static char *get_va_buffer(void)
{
static char va_buffers[VA_NUM_BUFFS][VA_BUFFERLEN];
static int buffer_idx = 0;
buffer_idx = (buffer_idx + 1) & (VA_NUM_BUFFS - 1);
return va_buffers[buffer_idx];
}
char *va (const char *format, ...)
{
va_list argptr;
char *va_buf;
va_buf = get_va_buffer ();
va_start (argptr, format);
q_vsnprintf (va_buf, VA_BUFFERLEN, format, argptr);
va_end (argptr);
return va_buf;
}
/*
=============================================================================
QUAKE FILESYSTEM
=============================================================================
*/
qofs_t com_filesize;
//
// on-disk pakfile
//
typedef struct
{
char name[56];
unsigned int filepos, filelen;
} dpackfile_t;
typedef struct
{
char id[4];
unsigned int dirofs;
unsigned int dirlen;
} dpackheader_t;
#define MAX_FILES_IN_PACK 4096
char com_gamenames[1024]; //eg: "hipnotic;quoth;warp", no id1, no private stuff
char com_gamedir[MAX_OSPATH];
char com_basedir[MAX_OSPATH];
int file_from_pak; // ZOID: global indicating that file came from a pak
searchpath_t *com_searchpaths;
searchpath_t *com_base_searchpaths;
/*
============
COM_Path_f
============
*/
static void COM_Path_f (void)
{
searchpath_t *s;
Con_Printf ("Current search path:\n");
for (s = com_searchpaths; s; s = s->next)
{
if (s->pack)
{
Con_Printf ("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
}
else
Con_Printf ("%s\n", s->filename);
}
}
/*
============
COM_WriteFile
The filename will be prefixed by the current game directory
============
*/
void COM_WriteFile (const char *filename, const void *data, int len)
{
int handle;
char name[MAX_OSPATH];
Sys_mkdir (com_gamedir); //johnfitz -- if we've switched to a nonexistant gamedir, create it now so we don't crash
q_snprintf (name, sizeof(name), "%s/%s", com_gamedir, filename);
handle = Sys_FileOpenWrite (name);
if (handle == -1)
{
Sys_Printf ("COM_WriteFile: failed on %s\n", name);
return;
}
Sys_Printf ("COM_WriteFile: %s\n", name);
Sys_FileWrite (handle, data, len);
Sys_FileClose (handle);
}
/*
============
COM_CreatePath
============
*/
void COM_CreatePath (char *path)
{
char *ofs;
for (ofs = path + 1; *ofs; ofs++)
{
if (*ofs == '/')
{ // create the directory
*ofs = 0;
Sys_mkdir (path);
*ofs = '/';
}
}
}
/*
================
COM_filelength
================
*/
long COM_filelength (FILE *f)
{
long pos, end;
pos = ftell (f);
fseek (f, 0, SEEK_END);
end = ftell (f);
fseek (f, pos, SEEK_SET);
return end;
}
/*
===========
COM_FindFile
Finds the file in the search path.
Sets com_filesize and one of handle or file
If neither of file or handle is set, this
can be used for detecting a file's presence.
===========
*/
static int COM_FindFile (const char *filename, int *handle, FILE **file,
unsigned int *path_id)
{
searchpath_t *search;
char netpath[MAX_OSPATH];
pack_t *pak;
int i;
const char *ext;
if (file && handle)
Sys_Error ("COM_FindFile: both handle and file set");
file_from_pak = 0;
//
// search through the path, one element at a time
//
for (search = com_searchpaths; search; search = search->next)
{
if (search->pack) /* look through all the pak file elements */
{
pak = search->pack;
for (i = 0; i < pak->numfiles; i++)
{
if (strcmp(pak->files[i].name, filename) != 0)
continue;
// found it!
com_filesize = pak->files[i].filelen;
file_from_pak = 1;
if (path_id)
*path_id = search->path_id;
if (handle)
{
if (pak->files[i].deflatedsize)
{
FILE *f;
f = fopen (pak->filename, "rb");
if (f)
{
fseek (f, pak->files[i].filepos, SEEK_SET);
f = FSZIP_Deflate(f, pak->files[i].deflatedsize, pak->files[i].filelen, pak->files[i].name);
if (f)
*handle = Sys_FileOpenStdio(f);
else
{ //error!
com_filesize = -1;
*handle = -1;
}
}
else
{ //error!
com_filesize = -1;
*handle = -1;
}
}
else
{
*handle = pak->handle;
Sys_FileSeek (pak->handle, pak->files[i].filepos);
}
return com_filesize;
}
else if (file)
{ /* open a new file on the pakfile */
*file = fopen (pak->filename, "rb");
if (*file)
{
fseek (*file, pak->files[i].filepos, SEEK_SET);
if (pak->files[i].deflatedsize)
*file = FSZIP_Deflate(*file, pak->files[i].deflatedsize, pak->files[i].filelen, pak->files[i].name);
}
return com_filesize;
}
else /* for COM_FileExists() */
{
return com_filesize;
}
}
}
else /* check a file in the directory tree */
{
if (!registered.value)
{ /* if not a registered version, don't ever go beyond base */
if ( strchr (filename, '/') || strchr (filename,'\\'))
continue;
if (!q_strcasecmp(COM_FileGetExtension(filename), "dat")) //don't load custom progs.dats either
continue;
}
q_snprintf (netpath, sizeof(netpath), "%s/%s",search->filename, filename);
if (! (Sys_FileType(netpath) & FS_ENT_FILE))
continue;
if (path_id)
*path_id = search->path_id;
if (handle)
{
com_filesize = Sys_FileOpenRead (netpath, &i);
*handle = i;
return com_filesize;
}
else if (file)
{
*file = fopen (netpath, "rb");
com_filesize = (*file == NULL) ? -1 : COM_filelength (*file);
return com_filesize;
}
else
{
return 0; /* dummy valid value for COM_FileExists() */
}
}
}
ext = COM_FileGetExtension(filename);
if (strcmp(ext, "pcx") != 0
&& strcmp(ext, "tga") != 0
&& strcmp(ext, "png") != 0
&& strcmp(ext, "jpg") != 0
&& strcmp(ext, "jpeg") != 0
&& strcmp(ext, "dds") != 0
&& strcmp(ext, "lmp") != 0
&& strcmp(ext, "iqm") != 0
&& strcmp(ext, "md3") != 0
&& strcmp(ext, "md5mesh") != 0
&& strcmp(ext, "md5anim") != 0
&& strcmp(ext, "lit") != 0
&& strcmp(ext, "vis") != 0
&& strcmp(ext, "ent") != 0)
Con_DPrintf ("FindFile: can't find %s\n", filename);
else Con_DPrintf2("FindFile: can't find %s\n", filename);
if (handle)
*handle = -1;
if (file)
*file = NULL;
com_filesize = -1;
return com_filesize;
}
/*
===========
COM_FileExists
Returns whether the file is found in the quake filesystem.
===========
*/
qboolean COM_FileExists (const char *filename, unsigned int *path_id)
{
int ret = COM_FindFile (filename, NULL, NULL, path_id);
return (ret == -1) ? false : true;
}
/*
===========
COM_OpenFile
filename never has a leading slash, but may contain directory walks
returns a handle and a length
it may actually be inside a pak file
===========
*/
int COM_OpenFile (const char *filename, int *handle, unsigned int *path_id)
{
return COM_FindFile (filename, handle, NULL, path_id);
}
/*
===========
COM_FOpenFile
If the requested file is inside a packfile, a new FILE * will be opened
into the file.
===========
*/
int COM_FOpenFile (const char *filename, FILE **file, unsigned int *path_id)
{
return COM_FindFile (filename, NULL, file, path_id);
}
/*
============
COM_CloseFile
If it is a pak file handle, don't really close it
============
*/
void COM_CloseFile (int h)
{
searchpath_t *s;
for (s = com_searchpaths; s; s = s->next)
if (s->pack && s->pack->handle == h)
return;
Sys_FileClose (h);
}
/*
============
COM_LoadFile
Filename are reletive to the quake directory.
Allways appends a 0 byte.
============
*/
#define LOADFILE_ZONE 0
#define LOADFILE_HUNK 1
#define LOADFILE_TEMPHUNK 2
#define LOADFILE_CACHE 3
#define LOADFILE_STACK 4
#define LOADFILE_MALLOC 5
static byte *loadbuf;
static cache_user_t *loadcache;
static int loadsize;
byte *COM_LoadFile (const char *path, int usehunk, unsigned int *path_id)
{
int h;
byte *buf;
char base[32];
int len;
buf = NULL; // quiet compiler warning
// look for it in the filesystem or pack files
len = COM_OpenFile (path, &h, path_id);
if (h == -1)
return NULL;
// extract the filename base name for hunk tag
COM_FileBase (path, base, sizeof(base));
switch (usehunk)
{
case LOADFILE_HUNK:
buf = (byte *) Hunk_AllocName (len+1, base);
break;
case LOADFILE_TEMPHUNK:
buf = (byte *) Hunk_TempAlloc (len+1);
break;
case LOADFILE_ZONE:
buf = (byte *) Z_Malloc (len+1);
break;
case LOADFILE_CACHE:
buf = (byte *) Cache_Alloc (loadcache, len+1, base);
break;
case LOADFILE_STACK:
if (len < loadsize)
buf = loadbuf;
else
buf = (byte *) Hunk_TempAlloc (len+1);
break;
case LOADFILE_MALLOC:
buf = (byte *) malloc (len+1);
break;
default:
Sys_Error ("COM_LoadFile: bad usehunk");
}
if (!buf)
Sys_Error ("COM_LoadFile: not enough space for %s", path);
((byte *)buf)[len] = 0;
Sys_FileRead (h, buf, len);
COM_CloseFile (h);
return buf;
}
byte *COM_LoadHunkFile (const char *path, unsigned int *path_id)
{
return COM_LoadFile (path, LOADFILE_HUNK, path_id);
}
byte *COM_LoadZoneFile (const char *path, unsigned int *path_id)
{
return COM_LoadFile (path, LOADFILE_ZONE, path_id);
}
byte *COM_LoadTempFile (const char *path, unsigned int *path_id)
{
return COM_LoadFile (path, LOADFILE_TEMPHUNK, path_id);
}
void COM_LoadCacheFile (const char *path, struct cache_user_s *cu, unsigned int *path_id)
{
loadcache = cu;
COM_LoadFile (path, LOADFILE_CACHE, path_id);
}
// uses temp hunk if larger than bufsize
byte *COM_LoadStackFile (const char *path, void *buffer, int bufsize, unsigned int *path_id)
{
byte *buf;
loadbuf = (byte *)buffer;
loadsize = bufsize;
buf = COM_LoadFile (path, LOADFILE_STACK, path_id);
return buf;
}
// returns malloc'd memory
byte *COM_LoadMallocFile (const char *path, unsigned int *path_id)
{
return COM_LoadFile (path, LOADFILE_MALLOC, path_id);
}
byte *COM_LoadMallocFile_TextMode_OSPath (const char *path, long *len_out)
{
FILE *f;
byte *data;
long len, actuallen;
// ericw -- this is used by Host_Loadgame_f. Translate CRLF to LF on load games,
// othewise multiline messages have a garbage character at the end of each line.
// TODO: could handle in a way that allows loading CRLF savegames on mac/linux
// without the junk characters appearing.
f = fopen (path, "rt");
if (f == NULL)
return NULL;
len = COM_filelength (f);
if (len < 0)
{
fclose (f);
return NULL;
}
data = (byte *) malloc (len + 1);
if (data == NULL)
{
fclose (f);
return NULL;
}
// (actuallen < len) if CRLF to LF translation was performed
actuallen = fread (data, 1, len, f);
if (ferror(f))
{
fclose (f);
free (data);
return NULL;
}
data[actuallen] = '\0';
if (len_out != NULL)
*len_out = actuallen;
fclose (f);
return data;
}
const char *COM_ParseIntNewline(const char *buffer, int *value)
{
int consumed = 0;
sscanf (buffer, "%i\n%n", value, &consumed);
return buffer + consumed;
}
const char *COM_ParseFloatNewline(const char *buffer, float *value)
{
int consumed = 0;
sscanf (buffer, "%f\n%n", value, &consumed);
return buffer + consumed;
}
const char *COM_ParseStringNewline(const char *buffer)
{
int consumed = 0;
com_token[0] = '\0';
sscanf (buffer, "%1023s\n%n", com_token, &consumed);
return buffer + consumed;
}
/*
=================
COM_LoadPackFile -- johnfitz -- modified based on topaz's tutorial
Takes an explicit (not game tree related) path to a pak file.
Loads the header and directory, adding the files at the beginning
of the list so they override previous pack files.
=================
*/
static pack_t *COM_LoadPackFile (const char *packfile)
{
dpackheader_t header;
int i;
packfile_t *newfiles;
int numpackfiles;
pack_t *pack;
int packhandle;
dpackfile_t info[MAX_FILES_IN_PACK];
unsigned short crc;
if (Sys_FileOpenRead (packfile, &packhandle) == -1)
return NULL;
Sys_FileRead (packhandle, (void *)&header, sizeof(header));
if (header.id[0] != 'P' || header.id[1] != 'A' || header.id[2] != 'C' || header.id[3] != 'K')
Sys_Error ("%s is not a packfile", packfile);
header.dirofs = LittleLong (header.dirofs);
header.dirlen = LittleLong (header.dirlen);
numpackfiles = header.dirlen / sizeof(dpackfile_t);
if (header.dirlen < 0 || header.dirofs < 0)
{
Sys_Error ("Invalid packfile %s (dirlen: %i, dirofs: %i)",
packfile, header.dirlen, header.dirofs);
}
if (!numpackfiles)
{
Sys_Printf ("WARNING: %s has no files, ignored\n", packfile);
Sys_FileClose (packhandle);
return NULL;
}
if (numpackfiles > MAX_FILES_IN_PACK)
Sys_Error ("%s has %i files", packfile, numpackfiles);
newfiles = (packfile_t *) Z_Malloc(numpackfiles * sizeof(packfile_t));
Sys_FileSeek (packhandle, header.dirofs);
Sys_FileRead (packhandle, (void *)info, header.dirlen);
if (numpackfiles != PAK0_COUNT)
com_modified = true; // not the original file
else
{
// crc the directory to check for modifications
CRC_Init (&crc);
for (i = 0; i < header.dirlen; i++)
CRC_ProcessByte (&crc, ((byte *)info)[i]);
if (crc != PAK0_CRC_V106 && crc != PAK0_CRC_V101 && crc != PAK0_CRC_V100)
com_modified = true;
}
// parse the directory
for (i = 0; i < numpackfiles; i++)
{
q_strlcpy (newfiles[i].name, info[i].name, sizeof(newfiles[i].name));
newfiles[i].filepos = LittleLong(info[i].filepos);
newfiles[i].filelen = LittleLong(info[i].filelen);
}
pack = (pack_t *) Z_Malloc (sizeof (pack_t));
q_strlcpy (pack->filename, packfile, sizeof(pack->filename));
pack->handle = packhandle;
pack->numfiles = numpackfiles;
pack->files = newfiles;
//Sys_Printf ("Added packfile %s (%i files)\n", packfile, numpackfiles);
return pack;
}
#ifdef _WIN32
static time_t Sys_FileTimeToTime(FILETIME ft)
{
ULARGE_INTEGER ull;
ull.LowPart = ft.dwLowDateTime;
ull.HighPart = ft.dwHighDateTime;
return ull.QuadPart / 10000000u - 11644473600u;
}
#endif
void COM_ListSystemFiles(void *ctx, const char *gamedir, const char *ext, qboolean (*cb)(void *ctx, const char *fname))
{
#ifdef _WIN32
WIN32_FIND_DATA fdat;
HANDLE fhnd;
char filestring[MAX_OSPATH];
q_snprintf (filestring, sizeof(filestring), "%s/*.%s", gamedir, ext);
fhnd = FindFirstFile(filestring, &fdat);
if (fhnd == INVALID_HANDLE_VALUE)
return;
do
{
cb (ctx, fdat.cFileName);
} while (FindNextFile(fhnd, &fdat));
FindClose(fhnd);
#else
DIR *dir_p;
struct dirent *dir_t;
dir_p = opendir(gamedir);
if (dir_p == NULL)
return;
while ((dir_t = readdir(dir_p)) != NULL)
{
if (q_strcasecmp(COM_FileGetExtension(dir_t->d_name), ext) != 0)
continue;
cb (ctx, dir_t->d_name);
}
closedir(dir_p);
#endif
}
static void COM_ListFiles(void *ctx, searchpath_t *spath, const char *pattern, qboolean (*cb)(void *ctx, const char *fname, time_t mtime, size_t fsize, searchpath_t *spath))
{
char prefixdir[MAX_OSPATH];
char *sl;
sl = strrchr(pattern, '/');
if (sl)
{
sl++;
if (sl-pattern >= MAX_OSPATH)
return;
memcpy(prefixdir, pattern, sl-pattern);
prefixdir[sl-pattern] = 0;
pattern = sl;
}
else
*prefixdir = 0;
#ifdef _WIN32
{
char filestring[MAX_OSPATH];
WIN32_FIND_DATA fdat;
HANDLE fhnd;
q_snprintf (filestring, sizeof(filestring), "%s/%s%s", spath->filename, prefixdir, pattern);
fhnd = FindFirstFile(filestring, &fdat);
if (fhnd == INVALID_HANDLE_VALUE)
return;
do
{
q_snprintf (filestring, sizeof(filestring), "%s%s", prefixdir, fdat.cFileName);
cb (ctx, filestring, Sys_FileTimeToTime(fdat.ftLastWriteTime), fdat.nFileSizeLow, spath);
} while (FindNextFile(fhnd, &fdat));
FindClose(fhnd);
}
#else
{
char filestring[MAX_OSPATH];
DIR *dir_p;
struct dirent *dir_t;
q_snprintf (filestring, sizeof(filestring), "%s/%s", spath->filename, prefixdir);
dir_p = opendir(filestring);
if (dir_p == NULL)
return;
while ((dir_t = readdir(dir_p)) != NULL)
{
if (*dir_t->d_name == '.') //ignore hidden paths... and parent etc weirdness.
continue;
if (!fnmatch(pattern, dir_t->d_name, FNM_NOESCAPE|FNM_PATHNAME|FNM_CASEFOLD))
{
struct stat s;
q_snprintf (filestring, sizeof(filestring), "%s/%s%s", spath->filename, prefixdir, dir_t->d_name);
if (stat(filestring, &s) < 0)
memset(&s, 0, sizeof(s));
q_snprintf (filestring, sizeof(filestring), "%s%s", prefixdir, dir_t->d_name);
cb (ctx, filestring, s.st_mtime, s.st_size, spath);
}
}
closedir(dir_p);
}
#endif
}
void COM_ListAllFiles(void *ctx, const char *pattern, qboolean (*cb)(void *ctx, const char *fname, time_t mtime, size_t fsize, searchpath_t *spath), unsigned int flags, const char *pkgfilter)
{
searchpath_t *search;
const char *sp;
qboolean foundpackage = false;
if (*pattern == '/' || strchr(pattern, ':') //block absolute paths
|| strchr(pattern, '\\') //block unportable paths (also ones that mess up other checks)
|| strstr(pattern, "./")) //block evil relative paths (any kind)
{
Con_Printf("Blocking absolute/non-portable/dodgy search pattern: %s\n", pattern);
return;
}
//don't add the same pak twice.
for (search = com_searchpaths; search; search = search->next)
{
if (pkgfilter)
{
if (flags & (1u<<1))
sp = search->purename;
else
{
sp = strchr(search->purename, '/');
if (sp && !strchr(++sp, '/'))
;
else
continue; //ignore packages inside other packages. they're just too weird.
}
if (strcmp(pkgfilter, sp))
continue; //ignore this package
}
foundpackage = true;
if (search->pack)
{
pack_t *pak = search->pack;
int i;
for (i = 0; i < pak->numfiles; i++)
{
if (wildcmp(pattern, pak->files[i].name))
cb(ctx, pak->files[i].name, pak->mtime, pak->files[i].filelen, search);
}
}
else
{
COM_ListFiles(ctx, search, pattern, cb);
}
}
if (flags & (1u<<1) && (flags & (1u<<2)) && pkgfilter && foundpackage)
{ //if we're using full package paths, and we're trying to force the search, then be prepared to search gamedirs which are not currently active too if we didn't already search it.
// searchpath_t dummy;
// dummy.filename =
Con_Printf("search_begin: SB_FORCESEARCH not supported\n");
}
}
static qboolean COM_AddPackage(searchpath_t *basepath, const char *pakfile, const char *purename)
{
searchpath_t *search;
pack_t *pak;
const char *ext = COM_FileGetExtension(pakfile);
//don't add the same pak twice.
for (search = com_searchpaths; search; search = search->next)
{
if (search->pack)
if (!q_strcasecmp(pakfile, search->pack->filename))
return true;
}
{
struct stat sb;
char pakdir[MAX_OSPATH];
q_snprintf(pakdir, sizeof(pakdir), "%sdir", pakfile);
if (!stat(pakdir, &sb) && (sb.st_mode&S_IFMT)==S_IFDIR)
{
search = (searchpath_t *) Z_Malloc(sizeof(searchpath_t));
q_strlcpy(search->filename, pakdir, sizeof(search->filename));
q_strlcpy(search->purename, purename, sizeof(search->purename));
search->path_id = basepath?basepath->path_id:0; //doesn't count as a new gamedir.
search->pack = NULL;
search->next = com_searchpaths;
com_searchpaths = search;
com_modified = true;
return true;
}
}
if (!q_strcasecmp(ext, "pak"))
pak = COM_LoadPackFile (pakfile);
else if (!q_strcasecmp(ext, "pk3") || !q_strcasecmp(ext, "pk4") || !q_strcasecmp(ext, "zip") || !q_strcasecmp(ext, "apk") || !q_strcasecmp(ext, "kpf"))
{
pak = FSZIP_LoadArchive(pakfile);
if (pak)
com_modified = true; //would always be true, so we don't bother with crcs.
}
else
pak = NULL;
if (!pak)
return false;
{
struct stat s;
if (stat(pakfile, &s) >= 0)
pak->mtime = s.st_mtime;
}
search = (searchpath_t *) Z_Malloc(sizeof(searchpath_t));
q_strlcpy(search->filename, pakfile, sizeof(search->filename));
q_strlcpy(search->purename, purename, sizeof(search->purename));
search->path_id = basepath?basepath->path_id:0;
search->pack = pak;
search->next = com_searchpaths;
com_searchpaths = search;
return true;
}
static qboolean COM_AddEnumeratedPackage(void *ctx, const char *pakfile)
{
searchpath_t *basepath = ctx;
char fullpakfile[MAX_OSPATH];
char purepakfile[MAX_OSPATH];
q_snprintf (fullpakfile, sizeof(fullpakfile), "%s/%s", basepath->filename, pakfile);
q_snprintf (purepakfile, sizeof(purepakfile), "%s/%s", basepath->purename, pakfile);
return COM_AddPackage(basepath, fullpakfile, purepakfile);
}
const char *COM_GetGameNames(qboolean full)
{
if (full)
{
if (*com_gamenames)
return va("%s;%s", GAMENAME, com_gamenames);
else
return GAMENAME;
}
return com_gamenames;
// return COM_SkipPath(com_gamedir);
}
//if either contain id1 then that gets ignored
qboolean COM_GameDirMatches(const char *tdirs)
{
int gnl = strlen(GAMENAME);
const char *odirs = COM_GetGameNames(false);
//ignore any core paths.
if (!strncmp(tdirs, GAMENAME, gnl) && (tdirs[gnl] == ';' || !tdirs[gnl]))
{
tdirs+=gnl;
if (*tdirs == ';')
tdirs++;
}
if (!strncmp(odirs, GAMENAME, gnl) && (odirs[gnl] == ';' || !odirs[gnl]))
{
odirs+=gnl;
if (*odirs == ';')
odirs++;
}
//skip any qw in there from quakeworld (remote servers should really be skipping this, unless its maybe the only one in the path).
if (!strncmp(tdirs, "qw;", 3) || !strcmp(tdirs, "qw"))
{
tdirs+=2;
if (*tdirs==';')
tdirs++;
}
if (!strncmp(odirs, "qw;", 3) || !strcmp(odirs, "qw")) //need to cope with ourselves setting it that way too, just in case.
{
odirs+=2;
if (*odirs==';')
odirs++;
}
//okay, now check it properly
if (!strcmp(odirs, tdirs))
return true;
return false;
}
/*
=================
COM_AddGameDirectory -- johnfitz -- modified based on topaz's tutorial
=================
*/
static void COM_AddGameDirectory (const char *dir)
{
const char *base = com_basedir;
int i;
unsigned int path_id;
searchpath_t *searchdir;
char pakfile[MAX_OSPATH];
char purename[MAX_OSPATH];
qboolean been_here = false;
FILE *listing;
qboolean found;
const char *enginepackname = "quakespasm";
if (*dir == '*')
dir++;
else if (!strchr(dir, '/') && !strchr(dir, '\\'))
{
//fixme: block dupes
if (*com_gamenames)
q_strlcat(com_gamenames, ";", sizeof(com_gamenames));
q_strlcat(com_gamenames, dir, sizeof(com_gamenames));
}
//quakespasm enables mission pack flags automatically, so -game rogue works without breaking the hud
//we might as well do that here to simplify the code.
if (!q_strcasecmp(dir,"rogue")) {
rogue = true;
standard_quake = false;
}
if (!q_strcasecmp(dir,"hipnotic") || !q_strcasecmp(dir,"quoth")) {
hipnotic = true;
standard_quake = false;
}
q_strlcpy (com_gamedir, va("%s/%s", base, dir), sizeof(com_gamedir));
// assign a path_id to this game directory
if (com_searchpaths && com_searchpaths->path_id)
path_id = com_searchpaths->path_id << 1;
else path_id = 1U;
_add_path:
searchdir = (searchpath_t *) Z_Malloc(sizeof(searchpath_t));
searchdir->path_id = path_id;
q_strlcpy (searchdir->filename, com_gamedir, sizeof(searchdir->filename));
q_strlcpy (searchdir->purename, dir, sizeof(searchdir->purename));
q_snprintf (pakfile, sizeof(pakfile), "%s/pak.lst", com_gamedir);
listing = fopen(pakfile, "rb");
if (listing)
{
int len;
char *buffer;
const char *name;
fseek(listing, 0, SEEK_END);
len = ftell(listing);
fseek(listing, 0, SEEK_SET);
buffer = Z_Malloc(len+1);
fread(buffer, 1, len, listing);
buffer[len] = 0;
fclose(listing);
name = buffer;
com_modified = true; //any reordering of paks should be frowned upon
while ((name = COM_Parse(name)))
{
if (!*com_token)
continue;
if (strchr(com_token, '/') || strchr(com_token, '\\') || strchr(com_token, ':'))
continue;
q_snprintf (pakfile, sizeof(pakfile), "%s/%s", com_gamedir, com_token);
q_snprintf (purename, sizeof(purename), "%s/%s", dir, com_token);
COM_AddPackage(searchdir, pakfile, purename);
if (path_id == 1 && !fitzmode && !q_strncasecmp(com_token, "pak0.", 5))
{ //add this now, to try to retain correct ordering.
qboolean old = com_modified;
if (been_here) base = host_parms->userdir;
q_snprintf (pakfile, sizeof(pakfile), "%s/%s.%s", base, enginepackname, COM_FileGetExtension(com_token));
q_snprintf (purename, sizeof(purename), "%s.%s", enginepackname, COM_FileGetExtension(com_token));
COM_AddPackage(searchdir, pakfile, purename);
com_modified = old;
}
}
}
// add any pak files in the format pak0.pak pak1.pak, ...
for (i = 0; ; i++)
{
found = false;
q_snprintf (pakfile, sizeof(pakfile), "%s/pak%i.pak", com_gamedir, i);
q_snprintf (purename, sizeof(purename), "%s/pak%i.pak", dir, i);
found |= COM_AddPackage(searchdir, pakfile, purename);
q_snprintf (pakfile, sizeof(pakfile), "%s/pak%i.pk3", com_gamedir, i);
q_snprintf (purename, sizeof(purename), "%s/pak%i.pk3", dir, i);
found |= COM_AddPackage(searchdir, pakfile, purename);
if (i == 0 && path_id == 1 && !fitzmode)
{
qboolean old = com_modified;
if (been_here) base = host_parms->userdir;
q_snprintf (pakfile, sizeof(pakfile), "%s/%s.pak", base, enginepackname);
q_snprintf (purename, sizeof(purename), "%s.pak", enginepackname);
COM_AddPackage(searchdir, pakfile, purename);
q_snprintf (pakfile, sizeof(pakfile), "%s/%s.pk3", base, enginepackname);
q_snprintf (purename, sizeof(purename), "%s.pk3", enginepackname);
COM_AddPackage(searchdir, pakfile, purename);
com_modified = old;
}
if (!found)
break;
}
i = COM_CheckParm ("-nowildpaks");
if (!i)
{
COM_ListSystemFiles(searchdir, com_gamedir, "pak", COM_AddEnumeratedPackage);
COM_ListSystemFiles(searchdir, com_gamedir, "pk3", COM_AddEnumeratedPackage);
}
// then finally link the directory to the search path
//spike -- moved this last (also explicitly blocked loading progs.dat from system paths when running the demo)
searchdir->next = com_searchpaths;
com_searchpaths = searchdir;
if (!been_here && host_parms->userdir != host_parms->basedir)
{
been_here = true;
q_strlcpy(com_gamedir, va("%s/%s", host_parms->userdir, dir), sizeof(com_gamedir));
Sys_mkdir(com_gamedir);
goto _add_path;
}
}
void COM_ResetGameDirectories(char *newgamedirs)
{
char *newpath, *path;
searchpath_t *search;
//Kill the extra game if it is loaded
while (com_searchpaths != com_base_searchpaths)
{
if (com_searchpaths->pack)
{
Sys_FileClose (com_searchpaths->pack->handle);
Z_Free (com_searchpaths->pack->files);
Z_Free (com_searchpaths->pack);
}
search = com_searchpaths->next;
Z_Free (com_searchpaths);
com_searchpaths = search;
}
hipnotic = false;
rogue = false;
standard_quake = true;
//wipe the list of mod gamedirs
*com_gamenames = 0;
//reset this too
q_strlcpy (com_gamedir, va("%s/%s", (host_parms->userdir != host_parms->basedir)?host_parms->userdir:com_basedir, GAMENAME), sizeof(com_gamedir));
for(newpath = newgamedirs; newpath && *newpath; )
{
char *e = strchr(newpath, ';');
if (e)
*e++ = 0;
if (!q_strcasecmp(GAMENAME, newpath))
path = NULL;
else for (path = newgamedirs; path < newpath; path += strlen(path)+1)
{
if (!q_strcasecmp(path, newpath))
break;
}
if (path == newpath) //not already loaded
COM_AddGameDirectory(newpath);
newpath = e;
}
}
//==============================================================================
//johnfitz -- dynamic gamedir stuff -- modified by QuakeSpasm team.
//==============================================================================
static void COM_Game_f (void)
{
if (Cmd_Argc() > 1)
{
int i, pri;
char paths[1024];
if (!registered.value) //disable shareware quake
{
Con_Printf("You must have the registered version to use modified games\n");
return;
}
*paths = 0;
q_strlcat(paths, GAMENAME, sizeof(paths));
for (pri = 0; pri <= 1; pri++)
{
for (i = 1; i < Cmd_Argc(); i++)
{
const char *p = Cmd_Argv(i);
if (!*p)
p = GAMENAME;
if (pri == 0)
{
if (*p != '-')
continue;
p++;
}
else if (*p == '-')
continue;
if (!*p || !strcmp(p, ".") || strstr(p, "..") || strstr(p, "/") || strstr(p, "\\") || strstr(p, ":"))
{
Con_Printf ("gamedir should be a single directory name, not a path\n");
return;
}
if (!q_strcasecmp(p, GAMENAME))
continue; //don't add id1, its not interesting enough.
if (*paths)
q_strlcat(paths, ";", sizeof(paths));
q_strlcat(paths, p, sizeof(paths));
}
}
if (!q_strcasecmp(paths, COM_GetGameNames(true)))
{
Con_Printf("\"game\" is already \"%s\"\n", COM_GetGameNames(true));
return;
}
com_modified = true;
//Kill the server
CL_Disconnect ();
Host_ShutdownServer(true);
//Write config file
//fixme -- writing configs without reloading when switching between many mods is SERIOUSLY dangerous. ignore if no 'exec default.cfg' commands were used?
Host_WriteConfiguration ();
COM_ResetGameDirectories(paths);
//clear out and reload appropriate data
Cache_Flush ();
Mod_ResetAll();
Sky_ClearAll();
if (!isDedicated)
Draw_ReloadTextures(true);
ExtraMaps_NewGame ();
Host_Resetdemos ();
DemoList_Rebuild ();
Con_Printf("\"game\" changed to \"%s\"\n", COM_GetGameNames(true));
VID_Lock ();
Cbuf_AddText ("exec quake.rc\n");
Cbuf_AddText ("vid_unlock\n");
}
else //Diplay the current gamedir
Con_Printf("\"game\" is \"%s\"\n", COM_GetGameNames(true));
}
//
//Spike -- so people can more easily see where their files are actually coming from (to help resolve file conflicts)
//lack of mouse-coy makes this a pain to report still, however
//
static qboolean COM_Dir_Result2(void *ctx, const char *fname, time_t mtime, size_t fsize, searchpath_t *spath)
{
searchpath_t **primary = ctx;
if (!*primary)
*primary = spath;
return false;
}
static qboolean COM_Dir_Result(void *ctx, const char *fname, time_t mtime, size_t fsize, searchpath_t *spath)
{
searchpath_t *primary = NULL;
const char *prefix;
COM_ListAllFiles(&primary, fname, COM_Dir_Result2, 0, NULL);
if (primary == spath)
prefix = "^m"; //file that will be opened.
else
prefix = ""; //file that will be ignored.
if (fsize > 1024*1024*1024)
Con_SafePrintf("%s %6.1fgb %-32s %s\n", prefix, (double)fsize/(1024*1024*1024), fname, spath->filename);
else if (fsize > 1024*1024)
Con_SafePrintf("%s %6.1fmb %-32s %s\n", prefix, (double)fsize/(1024*1024), fname, spath->filename);
else if (fsize > 1024)
Con_SafePrintf("%s %6.1fkb %-32s %s\n", prefix, (double)fsize/1024, fname, spath->filename);
else
Con_SafePrintf("%s %4.0fb %-32s %s\n", prefix, (double)fsize, fname, spath->filename);
return true;
}
static void COM_Dir_f(void)
{
int i;
for (i = 1; i < Cmd_Argc(); i++)
COM_ListAllFiles(NULL, Cmd_Argv(i), COM_Dir_Result, 0, NULL);
}
static qboolean COM_SameDirs(const char *dir1, const char *dir2)
{
#ifdef _WIN32
//windows docs say it doesn't provide any inode equivelent for most windows filesystems.
char p1[4096], p2[4096];
size_t l;
GetFullPathName(dir1, countof(p1), p1, NULL);
GetFullPathName(dir2, countof(p2), p2, NULL);
//kill any trailing slashes, to make sure they're actually the same...
for (l = strlen(p1); l > 0 && (p1[l-1] == '/' || p1[l-1] == '\\'); )
p1[--l] = 0;
for (l = strlen(p2); l > 0 && (p2[l-1] == '/' || p2[l-1] == '\\'); )
p2[--l] = 0;
return !strcmp(p1, p2);
#else
struct stat bd, gd;
if (!stat(dir1, &bd) && bd.st_ino &&
!stat(dir2, &gd) && gd.st_ino &&
bd.st_dev == gd.st_dev && bd.st_ino == gd.st_ino)
return true;
#endif
return false;
}
/*
=================
COM_InitFilesystem
=================
*/
void COM_InitFilesystem (void) //johnfitz -- modified based on topaz's tutorial
{
int i, j;
const char *p;
Cvar_RegisterVariable (&allow_download);
Cvar_RegisterVariable (&registered);
Cvar_RegisterVariable (&cmdline);
Cmd_AddCommand ("path", COM_Path_f);
Cmd_AddCommand ("dir", COM_Dir_f);
Cmd_AddCommand ("ls", COM_Dir_f);
Cmd_AddCommand ("which", COM_Dir_f);
Cmd_AddCommand ("flocate", COM_Dir_f);
Cmd_AddCommand ("game", COM_Game_f); //johnfitz
Cmd_AddCommand ("gamedir", COM_Game_f); //Spike -- alternative name for it, consistent with quakeworld and a few other engines
i = COM_CheckParm ("-basedir");
if (i && i < com_argc-1)
q_strlcpy (com_basedir, com_argv[i + 1], sizeof(com_basedir));
else
q_strlcpy (com_basedir, host_parms->basedir, sizeof(com_basedir));
j = strlen (com_basedir);
if (j < 1) Sys_Error("Bad argument to -basedir");
if ((com_basedir[j-1] == '\\') || (com_basedir[j-1] == '/'))
com_basedir[j-1] = 0;
//this is horrible.
if (!fitzmode)
{
if (!COM_AddPackage(NULL, va("%s/QuakeEX.kpf", host_parms->userdir), "QuakeEX.kpf") && strcmp(com_basedir, host_parms->userdir))
COM_AddPackage(NULL, va("%s/QuakeEX.kpf", com_basedir), "QuakeEX.kpf");
}
i = COM_CheckParmNext (i, "-basegame");
if (i)
{ //-basegame:
// a) replaces all hardcoded dirs (read: alternative to id1)
// b) isn't flushed on normal gamedir switches (like id1).
com_modified = true; //shouldn't be relevant when not using id content... but we don't really know.
for(;; i = COM_CheckParmNext (i, "-basegame"))
{
if (!i || i >= com_argc-1)
break;
p = com_argv[i + 1];
if (!*p || !strcmp(p, ".") || strstr(p, "..") || *p=='/' || *p=='\\' || strstr(p, ":"))
Sys_Error ("gamedir should be a single directory name, not a path\n");
if (p != NULL)
COM_AddGameDirectory (p);
}
}
else
{
// start up with GAMENAME by default (id1)
COM_AddGameDirectory (GAMENAME);
}
/* this is the end of our base searchpath:
* any set gamedirs, such as those from -game command line
* arguments or by the 'game' console command will be freed
* up to here upon a new game command. */
com_base_searchpaths = com_searchpaths;
COM_ResetGameDirectories("");
// add mission pack requests (only one should be specified)
if (COM_CheckParm ("-rogue"))
COM_AddGameDirectory ("rogue");
if (COM_CheckParm ("-hipnotic"))
COM_AddGameDirectory ("hipnotic");
if (COM_CheckParm ("-quoth"))
COM_AddGameDirectory ("quoth");
for(i = 0;;)
{
i = COM_CheckParmNext (i, "-game");
if (!i || i >= com_argc-1)
break;
p = com_argv[i + 1];
if (p != NULL)
{
if (!*p || !strcmp(p, ".") || strstr(p, "..") || *p=='/' || *p=='\\' || strstr(p, ":"))
Sys_Error ("gamedir should be a single directory name, not a path\n");
com_modified = true;
COM_AddGameDirectory (p);
}
}
if (com_argc>1 && (p=com_argv[1]))
if (*p != '+' && *p != '-')
{
//weird variation of COM_SkipPath that doesn't get confused over trailing slashes.
char *n = va("%s", p);
size_t l = strlen(n);
p = n;
while (l > 0 && (n[l-1] == '/' || n[l-1] == '\\'))
n[--l] = 0;
while (l --> 0)
{
if (n[l] == '/' || n[l] == '\\')
{
l++;
break;
}
}
n+=l;
if (COM_SameDirs(va("%s", p), va("%s/%s", com_basedir, n)))
{
com_modified = true;
COM_AddGameDirectory (n);
}
}
COM_CheckRegistered ();
}
/* The following FS_*() stdio replacements are necessary if one is
* to perform non-sequential reads on files reopened on pak files
* because we need the bookkeeping about file start/end positions.
* Allocating and filling in the fshandle_t structure is the users'
* responsibility when the file is initially opened. */
size_t FS_fread(void *ptr, size_t size, size_t nmemb, fshandle_t *fh)
{
long byte_size;
long bytes_read;
size_t nmemb_read;
if (!fh) {
errno = EBADF;
return 0;
}
if (!ptr) {
errno = EFAULT;
return 0;
}
if (!size || !nmemb) { /* no error, just zero bytes wanted */
errno = 0;
return 0;
}
byte_size = nmemb * size;
if (byte_size > fh->length - fh->pos) /* just read to end */
byte_size = fh->length - fh->pos;
bytes_read = fread(ptr, 1, byte_size, fh->file);
fh->pos += bytes_read;
/* fread() must return the number of elements read,
* not the total number of bytes. */
nmemb_read = bytes_read / size;
/* even if the last member is only read partially
* it is counted as a whole in the return value. */
if (bytes_read % size)
nmemb_read++;
return nmemb_read;
}
int FS_fseek(fshandle_t *fh, long offset, int whence)
{
/* I don't care about 64 bit off_t or fseeko() here.
* the quake/hexen2 file system is 32 bits, anyway. */
int ret;
if (!fh) {
errno = EBADF;
return -1;
}
/* the relative file position shouldn't be smaller
* than zero or bigger than the filesize. */
switch (whence)
{
case SEEK_SET:
break;
case SEEK_CUR:
offset += fh->pos;
break;
case SEEK_END:
offset = fh->length + offset;
break;
default:
errno = EINVAL;
return -1;
}
if (offset < 0) {
errno = EINVAL;
return -1;
}
if (offset > fh->length) /* just seek to end */
offset = fh->length;
ret = fseek(fh->file, fh->start + offset, SEEK_SET);
if (ret < 0)
return ret;
fh->pos = offset;
return 0;
}
int FS_fclose(fshandle_t *fh)
{
if (!fh) {
errno = EBADF;
return -1;
}
return fclose(fh->file);
}
long FS_ftell(fshandle_t *fh)
{
if (!fh) {
errno = EBADF;
return -1;
}
return fh->pos;
}
void FS_rewind(fshandle_t *fh)
{
if (!fh) return;
clearerr(fh->file);
fseek(fh->file, fh->start, SEEK_SET);
fh->pos = 0;
}
int FS_feof(fshandle_t *fh)
{
if (!fh) {
errno = EBADF;
return -1;
}
if (fh->pos >= fh->length)
return -1;
return 0;
}
int FS_ferror(fshandle_t *fh)
{
if (!fh) {
errno = EBADF;
return -1;
}
return ferror(fh->file);
}
int FS_fgetc(fshandle_t *fh)
{
if (!fh) {
errno = EBADF;
return EOF;
}
if (fh->pos >= fh->length)
return EOF;
fh->pos += 1;
return fgetc(fh->file);
}
char *FS_fgets(char *s, int size, fshandle_t *fh)
{
char *ret;
if (FS_feof(fh))
return NULL;
if (size > (fh->length - fh->pos) + 1)
size = (fh->length - fh->pos) + 1;
ret = fgets(s, size, fh->file);
fh->pos = ftell(fh->file) - fh->start;
return ret;
}
long FS_filelength (fshandle_t *fh)
{
if (!fh) {
errno = EBADF;
return -1;
}
return fh->length;
}
//for compat with dpp7 protocols, and mods that cba to precache things.
void COM_Effectinfo_Enumerate(int (*cb)(const char *pname))
{
int i;
const char *f, *e;
char *buf;
static const char *dpnames[] =
{
"TE_GUNSHOT",
"TE_GUNSHOTQUAD",
"TE_SPIKE",
"TE_SPIKEQUAD",
"TE_SUPERSPIKE",
"TE_SUPERSPIKEQUAD",
"TE_WIZSPIKE",
"TE_KNIGHTSPIKE",
"TE_EXPLOSION",
"TE_EXPLOSIONQUAD",
"TE_TAREXPLOSION",
"TE_TELEPORT",
"TE_LAVASPLASH",
"TE_SMALLFLASH",
"TE_FLAMEJET",
"EF_FLAME",
"TE_BLOOD",
"TE_SPARK",
"TE_PLASMABURN",
"TE_TEI_G3",
"TE_TEI_SMOKE",
"TE_TEI_BIGEXPLOSION",
"TE_TEI_PLASMAHIT",
"EF_STARDUST",
"TR_ROCKET",
"TR_GRENADE",
"TR_BLOOD",
"TR_WIZSPIKE",
"TR_SLIGHTBLOOD",
"TR_KNIGHTSPIKE",
"TR_VORESPIKE",
"TR_NEHAHRASMOKE",
"TR_NEXUIZPLASMA",
"TR_GLOWTRAIL",
"SVC_PARTICLE",
NULL
};
buf = (char*)COM_LoadMallocFile("effectinfo.txt", NULL);
if (!buf)
return;
for (i = 0; dpnames[i]; i++)
cb(dpnames[i]);
for (f = buf; f; f = e)
{
e = COM_Parse (f);
if (!strcmp(com_token, "effect"))
{
e = COM_Parse (e);
cb(com_token);
}
while (e && *e && *e != '\n')
e++;
}
free(buf);
}
/*
============================================================================
LOCALIZATION
============================================================================
*/
typedef struct
{
char *key;
char *value;
} locentry_t;
typedef struct
{
int numentries;
int maxnumentries;
int numindices;
unsigned *indices;
locentry_t *entries;
char *text;
} localization_t;
static localization_t localization;
/*
================
COM_HashString
Computes the FNV-1a hash of string str
================
*/
unsigned COM_HashString (const char *str)
{
unsigned hash = 0x811c9dc5u;
while (*str)
{
hash ^= *str++;
hash *= 0x01000193u;
}
return hash;
}
/*
================
LOC_LoadFile
================
*/
void LOC_LoadFile (const char *file)
{
int i,lineno;
char *cursor;
// clear existing data
if (localization.text)
{
free(localization.text);
localization.text = NULL;
}
localization.numentries = 0;
localization.numindices = 0;
if (!file || !*file)
return;
Con_Printf("\nLanguage initialization\n");
localization.text = (char*)COM_LoadFile(file, LOADFILE_MALLOC, NULL);
if (!localization.text)
{
Con_Printf("Couldn't load '%s'\nfrom '%s'\n", file, com_basedir);
return;
}
cursor = localization.text;
// skip BOM
if ((unsigned char)(cursor[0]) == 0xEF && (unsigned char)(cursor[1]) == 0xBB && (unsigned char)(cursor[2]) == 0xBF)
cursor += 3;
lineno = 0;
while (*cursor)
{
char *line, *equals;
lineno++;
// skip leading whitespace
while (q_isblank(*cursor))
++cursor;
line = cursor;
equals = NULL;
// find line end and first equals sign, if any
while (*cursor && *cursor != '\n')
{
if (*cursor == '=' && !equals)
equals = cursor;
cursor++;
}
if (line[0] == '/')
{
if (line[1] != '/')
Con_DPrintf("LOC_LoadFile: malformed comment on line %d\n", lineno);
}
else if (equals)
{
char *key_end = equals;
qboolean leading_quote;
qboolean trailing_quote;
locentry_t *entry;
char *value_src;
char *value_dst;
char *value;
// trim whitespace before equals sign
while (key_end != line && q_isspace(key_end[-1]))
key_end--;
*key_end = 0;
value = equals + 1;
// skip whitespace after equals sign
while (value != cursor && q_isspace(*value))
value++;
leading_quote = (*value == '\"');
trailing_quote = false;
value += leading_quote;
// transform escape sequences in-place
value_src = value;
value_dst = value;
while (value_src != cursor)
{
if (*value_src == '\\' && value_src + 1 != cursor)
{
char c = value_src[1];
value_src += 2;
switch (c)
{
case 'n': *value_dst++ = '\n'; break;
case 't': *value_dst++ = '\t'; break;
case 'v': *value_dst++ = '\v'; break;
case 'b': *value_dst++ = '\b'; break;
case 'f': *value_dst++ = '\f'; break;
case '"':
case '\'':
*value_dst++ = c;
break;
default:
Con_Printf("LOC_LoadFile: unrecognized escape sequence \\%c on line %d\n", c, lineno);
*value_dst++ = c;
break;
}
continue;
}
if (*value_src == '\"')
{
trailing_quote = true;
*value_dst = 0;
break;
}
*value_dst++ = *value_src++;
}
// if not a quoted string, trim trailing whitespace
if (!trailing_quote)
{
while (value_dst != value && q_isblank(value_dst[-1]))
{
*value_dst = 0;
value_dst--;
}
}
if (localization.numentries == localization.maxnumentries)
{
// grow by 50%
localization.maxnumentries += localization.maxnumentries >> 1;
localization.maxnumentries = q_max(localization.maxnumentries, 32);
localization.entries = (locentry_t*) realloc(localization.entries, sizeof(*localization.entries) * localization.maxnumentries);
}
entry = &localization.entries[localization.numentries++];
entry->key = line;
entry->value = value;
}
if (*cursor)
*cursor++ = 0; // terminate line and advance to next
}
// hash all entries
localization.numindices = localization.numentries * 2; // 50% load factor
if (localization.numindices == 0)
{
Con_Printf("No localized strings in file '%s'\n", file);
return;
}
localization.indices = (unsigned*) realloc(localization.indices, localization.numindices * sizeof(*localization.indices));
memset(localization.indices, 0, localization.numindices * sizeof(*localization.indices));
for (i = 0; i < localization.numentries; i++)
{
locentry_t *entry = &localization.entries[i];
unsigned pos = COM_HashString(entry->key) % localization.numindices, end = pos;
for (;;)
{
if (!localization.indices[pos])
{
localization.indices[pos] = i + 1;
break;
}
++pos;
if (pos == localization.numindices)
pos = 0;
if (pos == end)
Sys_Error("LOC_LoadFile failed");
}
}
Con_Printf("Loaded %d strings from '%s'\n", localization.numentries, file);
}
/*
================
LOC_Init
================
*/
void LOC_Init(void)
{
LOC_LoadFile("localization/loc_english.txt");
}
/*
================
LOC_Shutdown
================
*/
void LOC_Shutdown(void)
{
free(localization.indices);
free(localization.entries);
free(localization.text);
}
/*
================
LOC_GetRawString
Returns localized string if available, or NULL otherwise
================
*/
const char* LOC_GetRawString (const char *key)
{
unsigned pos, end;
if (!localization.numindices || !key || !*key || *key != '$')
return NULL;
key++;
pos = COM_HashString(key) % localization.numindices;
end = pos;
do
{
unsigned idx = localization.indices[pos];
locentry_t *entry;
if (!idx)
return NULL;
entry = &localization.entries[idx - 1];
if (!Q_strcmp(entry->key, key))
return entry->value;
++pos;
if (pos == localization.numindices)
pos = 0;
} while (pos != end);
return NULL;
}
/*
================
LOC_GetString
Returns localized string if available, or input string otherwise
================
*/
const char* LOC_GetString (const char *key)
{
const char* value = LOC_GetRawString(key);
return value ? value : key;
}
/*
================
LOC_ParseArg
Returns argument index (>= 0) and advances the string if it starts with a placeholder ({} or {N}),
otherwise returns a negative value and leaves the pointer unchanged
================
*/
static int LOC_ParseArg (const char **pstr)
{
int arg;
const char *str = *pstr;
// opening brace
if (*str++ != '{')
return -1;
// optional index, defaulting to 0
arg = 0;
while (q_isdigit(*str))
arg = arg * 10 + *str++ - '0';
// closing brace
if (*str != '}')
return -1;
*pstr = ++str;
return arg;
}
/*
================
LOC_HasPlaceholders
================
*/
qboolean LOC_HasPlaceholders (const char *str)
{
if (!localization.numindices)
return false;
while (*str)
{
if (LOC_ParseArg(&str) >= 0)
return true;
str++;
}
return false;
}
/*
================
LOC_Format
Replaces placeholders (of the form {} or {N}) with the corresponding arguments
Returns number of written chars, excluding the NUL terminator
If len > 0, output is always NUL-terminated
================
*/
size_t LOC_Format (const char *format, const char* (*getarg_fn) (int idx, void* userdata), void* userdata, char* out, size_t len)
{
size_t written = 0;
int numargs = 0;
if (!len)
{
Con_DPrintf("LOC_Format: no output space\n");
return 0;
}
--len; // reserve space for the terminator
while (*format && written < len)
{
const char* insert;
size_t space_left;
size_t insert_len;
int argindex = LOC_ParseArg(&format);
if (argindex < 0)
{
out[written++] = *format++;
continue;
}
insert = getarg_fn(argindex, userdata);
space_left = len - written;
insert_len = Q_strlen(insert);
if (insert_len > space_left)
{
Con_DPrintf("LOC_Format: overflow at argument #%d\n", numargs);
insert_len = space_left;
}
Q_memcpy(out + written, insert, insert_len);
written += insert_len;
}
if (*format)
Con_DPrintf("LOC_Format: overflow\n");
out[written] = 0;
return written;
}
Reference in a new issue View git blame Copy permalink