diff --git a/include/build.h b/include/build.h new file mode 100644 index 0000000..506cfb9 --- /dev/null +++ b/include/build.h @@ -0,0 +1,6 @@ +#ifndef __build_h +#define __build_h + +int build_number( void ); + +#endif diff --git a/include/checksum.h b/include/checksum.h new file mode 100644 index 0000000..af052ca --- /dev/null +++ b/include/checksum.h @@ -0,0 +1,31 @@ +/* +Copyright (C) 1996-1997 Id Software, Inc. + +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. + +*/ + +#ifndef __checksum_h +#define __checksum_h + +#include "qtypes.h" + +unsigned Com_BlockChecksum (void *buffer, int length); +void Com_BlockFullChecksum (void *buffer, int len, unsigned char *outbuf); +byte COM_BlockSequenceCheckByte (byte *base, int length, int sequence, unsigned mapchecksum); +byte COM_BlockSequenceCRCByte (byte *base, int length, int sequence); + +#endif diff --git a/include/info.h b/include/info.h new file mode 100644 index 0000000..68f65f6 --- /dev/null +++ b/include/info.h @@ -0,0 +1,35 @@ +/* +Copyright (C) 1996-1997 Id Software, Inc. + +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. + +*/ + +#ifndef __info_h +#define __info_h + +#define MAX_INFO_STRING 196 +#define MAX_SERVERINFO_STRING 512 +#define MAX_LOCALINFO_STRING 32768 + +char *Info_ValueForKey (char *s, char *key); +void Info_RemoveKey (char *s, char *key); +void Info_RemovePrefixedKeys (char *start, char prefix); +void Info_SetValueForKey (char *s, char *key, char *value, int maxsize); +void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize); +void Info_Print (char *s); + +#endif diff --git a/include/link.h b/include/link.h new file mode 100644 index 0000000..fb05c35 --- /dev/null +++ b/include/link.h @@ -0,0 +1,19 @@ +#ifndef __link_h +#define __link_h + +// (type *)STRUCT_FROM_LINK(link_t *link, type, member) +// ent = STRUCT_FROM_LINK(link,entity_t,order) +// FIXME: remove this mess! +#define STRUCT_FROM_LINK(l,t,m) ((t *)((byte *)l - (int)&(((t *)0)->m))) + +typedef struct link_s +{ + struct link_s *prev, *next; +} link_t; + +void ClearLink (link_t *l); +void RemoveLink (link_t *l); +void InsertLinkBefore (link_t *l, link_t *before); +void InsertLinkAfter (link_t *l, link_t *after); + +#endif diff --git a/include/msg.h b/include/msg.h new file mode 100644 index 0000000..94b7132 --- /dev/null +++ b/include/msg.h @@ -0,0 +1,56 @@ +/* +Copyright (C) 1996-1997 Id Software, Inc. + +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. + +*/ +#ifndef __msg_h +#define __msg_h + +#include "sizebuf.h" + +extern struct usercmd_s nullcmd; + +void MSG_WriteChar (sizebuf_t *sb, int c); +void MSG_WriteByte (sizebuf_t *sb, int c); +void MSG_WriteShort (sizebuf_t *sb, int c); +void MSG_WriteLong (sizebuf_t *sb, int c); +void MSG_WriteFloat (sizebuf_t *sb, float f); +void MSG_WriteString (sizebuf_t *sb, char *s); +void MSG_WriteCoord (sizebuf_t *sb, float f); +void MSG_WriteAngle (sizebuf_t *sb, float f); +void MSG_WriteAngle16 (sizebuf_t *sb, float f); +void MSG_WriteDeltaUsercmd (sizebuf_t *sb, struct usercmd_s *from, struct usercmd_s *cmd); + +extern int msg_readcount; +extern qboolean msg_badread; // set if a read goes beyond end of message + +void MSG_BeginReading (void); +int MSG_GetReadCount(void); +int MSG_ReadChar (void); +int MSG_ReadByte (void); +int MSG_ReadShort (void); +int MSG_ReadLong (void); +float MSG_ReadFloat (void); +char *MSG_ReadString (void); +char *MSG_ReadStringLine (void); + +float MSG_ReadCoord (void); +float MSG_ReadAngle (void); +float MSG_ReadAngle16 (void); +void MSG_ReadDeltaUsercmd (struct usercmd_s *from, struct usercmd_s *cmd); + +#endif diff --git a/include/qargs.h b/include/qargs.h new file mode 100644 index 0000000..498174a --- /dev/null +++ b/include/qargs.h @@ -0,0 +1,46 @@ +/* + qargs.h + + (description) + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifndef _QARGS_H +#define _QARGS_H + +#include + +extern int com_argc; +extern char **com_argv; +extern char *com_cmdline; + +int COM_CheckParm (char *parm); +void COM_AddParm (char *parm); + +void COM_Init (void); +void COM_InitArgv (int argc, char **argv); + +#endif // _QARGS_H diff --git a/include/qdefs.h b/include/qdefs.h new file mode 100644 index 0000000..75ed444 --- /dev/null +++ b/include/qdefs.h @@ -0,0 +1,52 @@ +/* + qdefs.h + + (description) + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifndef _QDEFS_H +#define _QDEFS_H + +#include +#include + +#define MAX_QPATH 64 +#define MAX_CL_STATS 32 +#define NUM_CSHIFTS 4 +#define MAX_MODELS 256 +#define MAX_SOUNDS 256 +#define MAX_SCOREBOARDNAME 16 +#define MAX_STYLESTRING 64 +#define MAX_EDICTS 768 +#define MAX_LIGHTSTYLES 64 +#define MAX_DATAGRAM 1450 + +#define MAX_MSGLEN 1450 + +#define clc_stringcmd 4 + +#endif // _QDEFS_H diff --git a/include/qendian.h b/include/qendian.h new file mode 100644 index 0000000..2f3ff2d --- /dev/null +++ b/include/qendian.h @@ -0,0 +1,71 @@ +/* + qendian.h + + (description) + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifndef _QENDIAN_H +#define _QENDIAN_H + +#include "qtypes.h" + +#ifndef NULL +#define NULL ((void *)0) +#endif + +#define Q_MAXCHAR ((char)0x7f) +#define Q_MAXSHORT ((short)0x7fff) +#define Q_MAXINT ((int)0x7fffffff) +#define Q_MAXLONG ((int)0x7fffffff) +#define Q_MAXFLOAT ((int)0x7fffffff) + +#define Q_MINCHAR ((char)0x80) +#define Q_MINSHORT ((short)0x8000) +#define Q_MININT ((int)0x80000000) +#define Q_MINLONG ((int)0x80000000) +#define Q_MINFLOAT ((int)0x7fffffff) + +//============================================================================ + +extern qboolean bigendien; +extern short (*BigShort) (short l); +extern short (*LittleShort) (short l); +extern int (*BigLong) (int l); +extern int (*LittleLong) (int l); +extern float (*BigFloat) (float l); +extern float (*LittleFloat) (float l); + +short ShortSwap (short l); +short ShortNoSwap (short l); +int LongSwap (int l); +int LongNoSwap (int l); +float FloatSwap (float f); +float FloatNoSwap (float f); + +//============================================================================ + +#endif // _QENDIAN_H diff --git a/include/qstructs.h b/include/qstructs.h new file mode 100644 index 0000000..af549df --- /dev/null +++ b/include/qstructs.h @@ -0,0 +1,60 @@ +/* + qstructs.h + + common structures + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ +#ifndef _QSTRUCTS_H +#define _QSTRUCTS_H + +#include +#include + +//============================================================================= + +// the host system specifies the base of the directory tree, the +// command line parms passed to the program, and the amount of memory +// available for the program to use + +typedef struct +{ + char *basedir; + char *cachedir; // for development over ISDN lines + int argc; + char **argv; + void *membase; + int memsize; +} quakeparms_t; + +//============================================================================= + +typedef struct +{ + int destcolor[3]; + int percent; // 0-256 +} cshift_t; + +#endif // _QSTRUCTS_H diff --git a/include/qtypes.h b/include/qtypes.h new file mode 100644 index 0000000..ef7396b --- /dev/null +++ b/include/qtypes.h @@ -0,0 +1,73 @@ +/* + qtypes.h + + (description) + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifndef _QTYPES_H +#define _QTYPES_H + +#include +#include +#include + +#define MAX_QPATH 64 + +typedef unsigned char byte; + +// KJB Undefined true and false defined in SciTech's DEBUG.H header +#undef true +#undef false +typedef enum {false, true} qboolean; + +// From mathlib... +typedef float vec_t; +typedef vec_t vec3_t[3]; +typedef vec_t vec5_t[5]; +typedef int fixed4_t; +typedef int fixed8_t; +typedef int fixed16_t; + + +typedef int func_t; +typedef int string_t; +typedef byte pixel_t; + +/* +typedef enum {key_game, key_console, key_message, key_menu} keydest_t; +typedef enum { ALIAS_SINGLE=0, ALIAS_GROUP } aliasframetype_t; +typedef enum { ALIAS_SKIN_SINGLE=0, ALIAS_SKIN_GROUP } aliasskintype_t; +typedef enum {ev_void, ev_string, ev_float, ev_vector, ev_entity, ev_field, ev_function, ev_pointer} etype_t; +typedef void (*builtin_t) (void); +typedef enum {touchessolid, drawnode, nodrawnode} solidstate_t; +typedef enum { ST_SYNC=0, ST_RAND } synctype_t; +typedef enum { SPR_SINGLE=0, SPR_GROUP } spriteframetype_t; +typedef enum {MS_WINDOWED, MS_FULLSCREEN, MS_FULLDIB, MS_UNINIT} modestate_t; +typedef enum {mod_brush, mod_sprite, mod_alias} modtype_t; +*/ + +#endif // _QTYPES_H diff --git a/include/quakefs.h b/include/quakefs.h new file mode 100644 index 0000000..157f3fa --- /dev/null +++ b/include/quakefs.h @@ -0,0 +1,66 @@ +/* + quakefs.h + + quake virtual filesystem definitions + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifndef _QUAKEFS_H +#define _QUAKEFS_H + +#include "qtypes.h" +#include "quakeio.h" + +//============================================================================ + +#define MAX_OSPATH 128 // max length of a filesystem pathname + +extern int com_filesize; +struct cache_user_s; + +extern char com_gamedir[MAX_OSPATH]; +extern char gamedirfile[MAX_OSPATH]; + +void COM_WriteFile (char *filename, void *data, int len); +int COM_FOpenFile (char *filename, QFile **gzfile); +void COM_CloseFile (QFile *h); +int COM_filelength (QFile *f); +void COM_FileBase (char *in, char *out); +void COM_DefaultExtension (char *path, char *extension); +char *COM_SkipPath (char *pathname); +void COM_StripExtension (char *in, char *out); + +byte *COM_LoadStackFile (char *path, void *buffer, int bufsize); +byte *COM_LoadTempFile (char *path); +byte *COM_LoadHunkFile (char *path); +void COM_LoadCacheFile (char *path, struct cache_user_s *cu); +void COM_CreatePath (char *path); +void COM_Gamedir (char *dir); +void COM_InitFilesystem (void); +void COM_Path_f (void); +void COM_Maplist_f (void); + +#endif // _QUAKEFS_H diff --git a/include/quakeio.h b/include/quakeio.h new file mode 100644 index 0000000..781562b --- /dev/null +++ b/include/quakeio.h @@ -0,0 +1,64 @@ +/* + quakeio.h + + (description) + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ +#ifndef __quake_io_h +#define __quake_io_h + +#include + +#include +#ifdef HAS_ZLIB +#include +#endif + +typedef struct { + FILE *file; +#ifdef HAS_ZLIB + gzFile *gzfile; +#endif +} QFile; + +void Qexpand_squiggle(const char *path, char *dest); +int Qrename(const char *old, const char *new); +QFile *Qopen(const char *path, const char *mode); +QFile *Qdopen(int fd, const char *mode); +void Qclose(QFile *file); +int Qread(QFile *file, void *buf, int count); +int Qwrite(QFile *file, void *buf, int count); +int Qprintf(QFile *file, const char *fmt, ...); +char *Qgets(QFile *file, char *buf, int count); +int Qgetc(QFile *file); +int Qputc(QFile *file, int c); +int Qseek(QFile *file, long offset, int whence); +long Qtell(QFile *file); +int Qflush(QFile *file); +int Qeof(QFile *file); + + +#endif /*__quake_io_h*/ diff --git a/include/sizebuf.h b/include/sizebuf.h new file mode 100644 index 0000000..4621f7b --- /dev/null +++ b/include/sizebuf.h @@ -0,0 +1,39 @@ +/* +Copyright (C) 1996-1997 Id Software, Inc. + +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. + +*/ +#ifndef __sizebuf_h +#define __sizebuf_h + +#include "qtypes.h" + +typedef struct sizebuf_s +{ + qboolean allowoverflow; // if false, do a Sys_Error + qboolean overflowed; // set to true if the buffer size failed + byte *data; + int maxsize; + int cursize; +} sizebuf_t; + +void SZ_Clear (sizebuf_t *buf); +void *SZ_GetSpace (sizebuf_t *buf, int length); +void SZ_Write (sizebuf_t *buf, void *data, int length); +void SZ_Print (sizebuf_t *buf, char *data); // strcats onto the sizebuf + +#endif diff --git a/source/build.c b/source/build.c new file mode 100644 index 0000000..3a6d78c --- /dev/null +++ b/source/build.c @@ -0,0 +1,66 @@ +/* +Copyright (C) 1996-1997 Id Software, Inc. + +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. + +*/ +#ifdef HAVE_CONFIG_H +# include +#endif + +#include +#include +// char *date = "Oct 24 1996"; +static char *date = __DATE__ ; +static char *mon[12] = +{ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" }; +static char mond[12] = +{ 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }; + +// returns days since Oct 24 1996 +int build_number( void ) +{ + int m = 0; + int d = 0; + int y = 0; + static int b = 0; + + if (b != 0) + return b; + + for (m = 0; m < 11; m++) + { + if (strncasecmp( &date[0], mon[m], 3 ) == 0) + break; + d += mond[m]; + } + + d += atoi( &date[4] ) - 1; + + y = atoi( &date[7] ) - 1900; + + b = d + (int)((y - 1) * 365.25); + + if (((y % 4) == 0) && m > 1) + { + b += 1; + } + + b -= 35778; // Dec 16 1998 + + return b; +} + diff --git a/source/checksum.c b/source/checksum.c new file mode 100644 index 0000000..6e50e57 --- /dev/null +++ b/source/checksum.c @@ -0,0 +1,141 @@ +/* +Copyright (C) 1996-1997 Id Software, Inc. + +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. + +*/ +#ifdef HAVE_CONFIG_H +# include +#endif +#include "checksum.h" +#include "crc.h" + +static byte 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 +}; + +#if 0 +/* +==================== +COM_BlockSequenceCheckByte + +For proxy protecting +==================== +*/ +byte COM_BlockSequenceCheckByte (byte *base, int length, int sequence, unsigned mapchecksum) +{ + int checksum; + byte *p; + + if (last_mapchecksum != mapchecksum) { + last_mapchecksum = mapchecksum; + chktbl[1024] = (mapchecksum & 0xff000000) >> 24; + chktbl[1025] = (mapchecksum & 0x00ff0000) >> 16; + chktbl[1026] = (mapchecksum & 0x0000ff00) >> 8; + chktbl[1027] = (mapchecksum & 0x000000ff); + + Com_BlockFullChecksum (chktbl, sizeof(chktbl), chkbuf); + } + + p = chktbl + (sequence % (sizeof(chktbl) - 8)); + + if (length > 60) + length = 60; + memcpy (chkbuf + 16, base, length); + + length += 16; + + chkbuf[length] = (sequence & 0xff) ^ p[0]; + chkbuf[length+1] = p[1]; + chkbuf[length+2] = ((sequence>>8) & 0xff) ^ p[2]; + chkbuf[length+3] = p[3]; + + length += 4; + + checksum = LittleLong(Com_BlockChecksum (chkbuf, length)); + + checksum &= 0xff; + + return checksum; +} +#endif + +/* +==================== +COM_BlockSequenceCRCByte + +For proxy protecting +==================== +*/ +byte COM_BlockSequenceCRCByte (byte *base, int length, int sequence) +{ + unsigned short crc; + byte *p; + byte 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]; + + length += 4; + + crc = CRC_Block(chkb, length); + + crc &= 0xff; + + return crc; +} diff --git a/source/com.c b/source/com.c new file mode 100644 index 0000000..a37beab --- /dev/null +++ b/source/com.c @@ -0,0 +1,117 @@ +/* + com.c + + (description) + + Copyright (C) 1996-1997 Id Software, Inc. + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ +// com.c -- misc functions used in client and server + +#ifdef HAVE_CONFIG_H +# include +#endif +#include "sys.h" +#include "cvar.h" +#include "qendian.h" +#include "quakefs.h" +#include "cmd.h" +#include "console.h" + +#include + +cvar_t *registered; + +qboolean com_modified; // set true if using non-id files + +int static_registered = 1; // only for startup check, then set + +qboolean msg_suppress_1 = 0; + +void COM_InitFilesystem (void); +void COM_Path_f (void); + + +/* +================ +COM_CheckRegistered + +Looks for the pop.txt file and verifies it. +Sets the "registered" cvar. +Immediately exits out if an alternate game was attempted to be started without +being registered. +================ +*/ +void COM_CheckRegistered (void) +{ + QFile *h; + unsigned short check[128]; + + COM_FOpenFile("gfx/pop.lmp", &h); + static_registered = 0; + + if (h) { + static_registered = 1; + Qread (h, check, sizeof(check)); + Qclose (h); + } + + if (static_registered) { + Cvar_Set (registered, "1"); + Con_Printf ("Playing registered version.\n"); + } +} + + +/* +================ +COM_Init +================ +*/ +void COM_Init (void) +{ +#ifndef WORDS_BIGENDIEN + bigendien = false; + BigShort = ShortSwap; + LittleShort = ShortNoSwap; + BigLong = LongSwap; + LittleLong = LongNoSwap; + BigFloat = FloatSwap; + LittleFloat = FloatNoSwap; +#else + bigendien = true; + BigShort = ShortNoSwap; + LittleShort = ShortSwap; + BigLong = LongNoSwap; + LittleLong = LongSwap; + BigFloat = FloatNoSwap; + LittleFloat = FloatSwap; +#endif + +/* Cvar_RegisterVariable (®istered); + CVAR_FIXME */ + registered = Cvar_Get("registered", "0", CVAR_NONE, "None"); + Cmd_AddCommand ("path", COM_Path_f); + + COM_InitFilesystem (); + COM_CheckRegistered (); +} diff --git a/source/info.c b/source/info.c new file mode 100644 index 0000000..587ab3e --- /dev/null +++ b/source/info.c @@ -0,0 +1,309 @@ +/* + info.c + + (description) + + Copyright (C) 1996-1997 Id Software, Inc. + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifdef HAVE_CONFIG_H +# include +#endif +#include "console.h" + +#include +#include +#include + +/* +===================================================================== + + INFO STRINGS + +===================================================================== +*/ + +/* +=============== +Info_ValueForKey + +Searches the string for the given +key and returns the associated value, or an empty string. +=============== +*/ +char *Info_ValueForKey (char *s, char *key) +{ + char pkey[512]; + static char value[4][512]; // use two buffers so compares + // work without stomping on each other + static int valueindex; + char *o; + + valueindex = (valueindex + 1) % 4; + if (*s == '\\') + s++; + while (1) + { + o = pkey; + while (*s != '\\') + { + if (!*s) + return ""; + *o++ = *s++; + } + *o = 0; + s++; + + o = value[valueindex]; + + while (*s != '\\' && *s) + { + if (!*s) + return ""; + *o++ = *s++; + } + *o = 0; + + if (!strcmp (key, pkey) ) + return value[valueindex]; + + if (!*s) + return ""; + s++; + } +} + +void Info_RemoveKey (char *s, char *key) +{ + char *start; + char pkey[512]; + char value[512]; + char *o; + + if (strstr (key, "\\")) + { + Con_Printf ("Can't use a key with a \\\n"); + return; + } + + while (1) + { + start = s; + if (*s == '\\') + s++; + o = pkey; + while (*s != '\\') + { + if (!*s) + return; + *o++ = *s++; + } + *o = 0; + s++; + + o = value; + while (*s != '\\' && *s) + { + if (!*s) + return; + *o++ = *s++; + } + *o = 0; + + if (!strcmp (key, pkey) ) + { + strcpy (start, s); // remove this part + return; + } + + if (!*s) + return; + } + +} + +void Info_RemovePrefixedKeys (char *start, char prefix) +{ + char *s; + char pkey[512]; + char value[512]; + char *o; + + s = start; + + while (1) + { + if (*s == '\\') + s++; + o = pkey; + while (*s != '\\') + { + if (!*s) + return; + *o++ = *s++; + } + *o = 0; + s++; + + o = value; + while (*s != '\\' && *s) + { + if (!*s) + return; + *o++ = *s++; + } + *o = 0; + + if (pkey[0] == prefix) + { + Info_RemoveKey (start, pkey); + s = start; + } + + if (!*s) + return; + } + +} + + +void Info_SetValueForStarKey (char *s, char *key, char *value, int maxsize) +{ + char newstr[1024], *v; + int c, is_name, is_team; + + if (strstr (key, "\\") || strstr (value, "\\") ) + { + Con_Printf ("Can't use keys or values with a \\\n"); + return; + } + + if (strstr (key, "\"") || strstr (value, "\"") ) + { + Con_Printf ("Can't use keys or values with a \"\n"); + return; + } + + if (strlen(key) > 63 || strlen(value) > 63) + { + Con_Printf ("Keys and values must be < 64 characters.\n"); + return; + } + + // this next line is kinda trippy + if (*(v = Info_ValueForKey(s, key))) { + // key exists, make sure we have enough room for new value, if we don't, + // don't change it! + if (strlen(value) - strlen(v) + strlen(s) > maxsize) { + Con_Printf ("Info string length exceeded\n"); + return; + } + } + Info_RemoveKey (s, key); + if (!value || !strlen(value)) + return; + + snprintf (newstr, sizeof(newstr), "\\%s\\%s", key, value); + + if ((int)(strlen(newstr) + strlen(s)) > maxsize) + { + Con_Printf ("Info string length exceeded\n"); + return; + } + + // only copy ascii values + s += strlen(s); + v = newstr; + is_name = stricmp(key, "name") == 0; + is_team = stricmp(key, "team") == 0; + while (*v) + { + c = (unsigned char)*v++; + // client only allows highbits on name + if (!is_name) { + c &= 127; + if (c < 32 || c > 127) + continue; + // auto lowercase team + if (is_team) + c = tolower(c); + } + if (c > 13) + *s++ = c; + } + *s = 0; +} + +void Info_SetValueForKey (char *s, char *key, char *value, int maxsize) +{ + if (key[0] == '*') + { + Con_Printf ("Can't set * keys\n"); + return; + } + + Info_SetValueForStarKey (s, key, value, maxsize); +} + +void Info_Print (char *s) +{ + char key[512]; + char value[512]; + char *o; + int l; + + if (*s == '\\') + s++; + while (*s) + { + o = key; + while (*s && *s != '\\') + *o++ = *s++; + + l = o - key; + if (l < 20) + { + memset (o, ' ', 20-l); + key[20] = 0; + } + else + *o = 0; + Con_Printf ("%s", key); + + if (!*s) + { + Con_Printf ("MISSING VALUE\n"); + return; + } + + o = value; + s++; + while (*s && *s != '\\') + *o++ = *s++; + *o = 0; + + if (*s) + s++; + Con_Printf ("%s\n", value); + } +} diff --git a/source/link.c b/source/link.c new file mode 100644 index 0000000..5df0758 --- /dev/null +++ b/source/link.c @@ -0,0 +1,51 @@ +/* +Copyright (C) 1996-1997 Id Software, Inc. + +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. + +*/ +#ifdef HAVE_CONFIG_H +# include +#endif +#include "link.h" + +// 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; +} + diff --git a/source/msg.c b/source/msg.c new file mode 100644 index 0000000..2297c82 --- /dev/null +++ b/source/msg.c @@ -0,0 +1,386 @@ +/* + msg.c + + (description) + + Copyright (C) 1996-1997 Id Software, Inc. + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifdef HAVE_CONFIG_H +# include +#endif +#include "msg.h" +#include "net.h" +#include "protocol.h" +#include "qendian.h" +#include "sys.h" + +/* +============================================================================== + + 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 = 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 = 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 = SZ_GetSpace (sb, 2); + buf[0] = c&0xff; + buf[1] = c>>8; +} + +void MSG_WriteLong (sizebuf_t *sb, int c) +{ + byte *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, &dat.l, 4); +} + +void MSG_WriteString (sizebuf_t *sb, char *s) +{ + if (!s) + SZ_Write (sb, "", 1); + else + SZ_Write (sb, s, strlen(s)+1); +} + +void MSG_WriteCoord (sizebuf_t *sb, float f) +{ + MSG_WriteShort (sb, (int)(f*8)); +} + +void MSG_WriteAngle (sizebuf_t *sb, float f) +{ + MSG_WriteByte (sb, (int)(f*256/360) & 255); +} + +void MSG_WriteAngle16 (sizebuf_t *sb, float f) +{ + MSG_WriteShort (sb, (int)(f*65536/360) & 65535); +} + +void MSG_WriteDeltaUsercmd (sizebuf_t *buf, usercmd_t *from, usercmd_t *cmd) +{ + int bits; + +// +// send the movement message +// + bits = 0; + if (cmd->angles[0] != from->angles[0]) + bits |= CM_ANGLE1; + if (cmd->angles[1] != from->angles[1]) + bits |= CM_ANGLE2; + if (cmd->angles[2] != from->angles[2]) + bits |= CM_ANGLE3; + if (cmd->forwardmove != from->forwardmove) + bits |= CM_FORWARD; + if (cmd->sidemove != from->sidemove) + bits |= CM_SIDE; + if (cmd->upmove != from->upmove) + bits |= CM_UP; + if (cmd->buttons != from->buttons) + bits |= CM_BUTTONS; + if (cmd->impulse != from->impulse) + bits |= CM_IMPULSE; + + MSG_WriteByte (buf, bits); + + if (bits & CM_ANGLE1) + MSG_WriteAngle16 (buf, cmd->angles[0]); + if (bits & CM_ANGLE2) + MSG_WriteAngle16 (buf, cmd->angles[1]); + if (bits & CM_ANGLE3) + MSG_WriteAngle16 (buf, cmd->angles[2]); + + if (bits & CM_FORWARD) + MSG_WriteShort (buf, cmd->forwardmove); + if (bits & CM_SIDE) + MSG_WriteShort (buf, cmd->sidemove); + if (bits & CM_UP) + MSG_WriteShort (buf, cmd->upmove); + + if (bits & CM_BUTTONS) + MSG_WriteByte (buf, cmd->buttons); + if (bits & CM_IMPULSE) + MSG_WriteByte (buf, cmd->impulse); + MSG_WriteByte (buf, cmd->msec); +} + + +// +// reading functions +// +int msg_readcount; +qboolean msg_badread; + +void MSG_BeginReading (void) +{ + msg_readcount = 0; + msg_badread = false; +} + +int MSG_GetReadCount(void) +{ + return msg_readcount; +} + +// 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; +} + +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; +} + +char *MSG_ReadString (void) +{ + static char string[2048]; + int l,c; + + l = 0; + do + { + c = MSG_ReadChar (); + if (c == -1 || c == 0) + break; + string[l] = c; + l++; + } while (l < sizeof(string)-1); + + string[l] = 0; + + return string; +} + +char *MSG_ReadStringLine (void) +{ + static char string[2048]; + int l,c; + + l = 0; + do + { + c = MSG_ReadChar (); + if (c == -1 || c == 0 || c == '\n') + break; + string[l] = c; + l++; + } while (l < sizeof(string)-1); + + string[l] = 0; + + return string; +} + +float MSG_ReadCoord (void) +{ + return MSG_ReadShort() * (1.0/8); +} + +float MSG_ReadAngle (void) +{ + return MSG_ReadChar() * (360.0/256); +} + +float MSG_ReadAngle16 (void) +{ + return MSG_ReadShort() * (360.0/65536); +} + +void MSG_ReadDeltaUsercmd (usercmd_t *from, usercmd_t *move) +{ + int bits; + + memcpy (move, from, sizeof(*move)); + + bits = MSG_ReadByte (); + +// read current angles + if (bits & CM_ANGLE1) + move->angles[0] = MSG_ReadAngle16 (); + if (bits & CM_ANGLE2) + move->angles[1] = MSG_ReadAngle16 (); + if (bits & CM_ANGLE3) + move->angles[2] = MSG_ReadAngle16 (); + +// read movement + if (bits & CM_FORWARD) + move->forwardmove = MSG_ReadShort (); + if (bits & CM_SIDE) + move->sidemove = MSG_ReadShort (); + if (bits & CM_UP) + move->upmove = MSG_ReadShort (); + +// read buttons + if (bits & CM_BUTTONS) + move->buttons = MSG_ReadByte (); + + if (bits & CM_IMPULSE) + move->impulse = MSG_ReadByte (); + +// read time to run command + move->msec = MSG_ReadByte (); +} + diff --git a/source/qargs.c b/source/qargs.c new file mode 100644 index 0000000..15cd4a0 --- /dev/null +++ b/source/qargs.c @@ -0,0 +1,160 @@ +/* + qargs.c + + command line argument processing routines + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 Nelson Rush. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifdef HAVE_CONFIG_H +# include +#endif +#include "string.h" +#include "ctype.h" +#include "stdlib.h" +#include "qtypes.h" +#include "crc.h" +#include "sys.h" +#include "cmd.h" +#include "console.h" +#include "client.h" +#include "assert.h" +#include "commdef.h" + +#include + +usercmd_t nullcmd; // guarenteed to be zero + +static char **largv; +static char *argvdummy = " "; + +static char *safeargvs[] = + {"-stdvid", "-nolan", "-nosound", "-nocdaudio", "-nojoy", "-nomouse", "-dibonly"}; + +#define NUM_SAFE_ARGVS (sizeof(safeargvs)/sizeof(safeargvs[0])) + +int com_argc; +char **com_argv; +char *com_cmdline; +cvar_t *cmdline; +qboolean standard_quake = true, rogue, hipnotic; + +/* +================ +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_CheckParm (char *parm) +{ + int i; + + for (i=1 ; i 0); + strcat (com_cmdline, " "); + } + com_cmdline[len - 1] = '\0'; + } + + if (safe) + { + // force all the safe-mode switches. Note that we reserved extra space in + // case we need to add these, so we don't need an overflow check + for (i=0 ; i +#endif +#include +#include + +/* +============================================================================ + + BYTE ORDER FUNCTIONS + +============================================================================ +*/ + +qboolean bigendien; +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; +} diff --git a/source/quakefs.c b/source/quakefs.c new file mode 100644 index 0000000..507238d --- /dev/null +++ b/source/quakefs.c @@ -0,0 +1,1157 @@ +/* + quakefs.c + + virtual filesystem functions + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 Nelson Rush. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifdef HAVE_CONFIG_H +# include +#endif +#include "qtypes.h" +#include "quakefs.h" +#include "sys.h" +#include "console.h" +#include "zone.h" +#include "draw.h" +#include "cmd.h" +#include "cvar.h" +#include "commdef.h" +#include "qendian.h" +#if defined(QUAKEWORLD) && defined(SERVERONLY) +#include "common_protocol.h" +#include "server.h" +#endif + +#include +#include +#include +#ifdef HAVE_UNISTD_H +#include +#endif +#include + +#include +#include + +#ifdef WIN32 +#include +#endif + +#ifdef _MSC_VER +#define _POSIX_ +#endif +#include + + +/* +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. +*/ + +/* +============================================================================= + +QUAKE FILESYSTEM + +============================================================================= +*/ + +char gamedirfile[MAX_OSPATH]; + +cvar_t *fs_basepath; +cvar_t *fs_sharepath; + +#ifdef GENERATIONS +#include +typedef unsigned char byte_t; + +#ifndef _AIX +typedef unsigned int uint_t; +typedef unsigned short ushort_t; +#endif +#endif + +int com_filesize; + +/* + In-memory pack file structs +*/ + +typedef struct +{ + char name[MAX_QPATH]; + int filepos, filelen; +} packfile_t; + +typedef struct pack_s +{ + char filename[MAX_OSPATH]; + QFile *handle; + int numfiles; + packfile_t *files; +} pack_t; + +/* + Structs for pack files on disk +*/ +typedef struct +{ + char name[56]; + int filepos, filelen; +} dpackfile_t; + +typedef struct +{ + char id[4]; + int dirofs; + int dirlen; +} dpackheader_t; + +#define MAX_FILES_IN_PACK 2048 + +char com_gamedir[MAX_OSPATH]; + +typedef struct searchpath_s +{ + char filename[MAX_OSPATH]; + pack_t *pack; // only one of filename / pack will be used + struct searchpath_s *next; +} searchpath_t; + +searchpath_t *com_searchpaths; +searchpath_t *com_base_searchpaths; // without gamedirs + +/* + COM_FileBase +*/ +void +COM_FileBase (char *in, char *out) +{ + char *s, *s2; + + s = in + strlen(in) - 1; + + while (s != in && *s != '.') + s--; + + for (s2 = s ; *s2 && *s2 != '/' ; s2--) + ; + + if (s-s2 < 2) + strcpy (out,"?model?"); + else + { + s--; + strncpy (out,s2+1, s-s2); + out[s-s2] = 0; + } +} + +/* + COM_filelength +*/ +int +COM_filelength (QFile *f) +{ + int pos; + int end; + + pos = Qtell (f); + Qseek (f, 0, SEEK_END); + end = Qtell (f); + Qseek (f, pos, SEEK_SET); + + return end; +} + +/* + COM_FileOpenRead +*/ +int +COM_FileOpenRead (char *path, QFile **hndl) +{ + QFile *f; + + f = Qopen(path, "rbz"); + if (!f) + { + *hndl = NULL; + return -1; + } + *hndl = f; + + return COM_filelength(f); +} + +/* + COM_Path_f +*/ +void +COM_Path_f (void) +{ + searchpath_t *s; + + Con_Printf ("Current search path:\n"); + for (s=com_searchpaths ; s ; s=s->next) + { + if (s == com_base_searchpaths) + Con_Printf ("----------\n"); + if (s->pack) + Con_Printf ("%s (%i files)\n", s->pack->filename, s->pack->numfiles); + else + Con_Printf ("%s\n", s->filename); + } +} + +/* + COM_Maplist_f + + List map files in gamepaths. +*/ +void +COM_Maplist_f ( void ) +{ + searchpath_t *search; + DIR *dir_ptr; + struct dirent *dirent; + char buf[MAX_OSPATH]; + + for (search = com_searchpaths ; search != NULL ; search = search->next) { + if (search->pack) { + int i; + pack_t *pak = search->pack; + Con_Printf ("Looking in %s...\n",search->pack->filename); + for (i=0 ; inumfiles ; i++) { + char *name=pak->files[i].name; + if (!fnmatch ("maps/*.bsp", name, FNM_PATHNAME) + || !fnmatch ("maps/*.bsp.gz", name, FNM_PATHNAME)) + Con_Printf ("%s\n", name+5); + } + } else { + snprintf (buf, sizeof(buf), "%s/maps", search->filename); + dir_ptr = opendir(buf); + Con_Printf ("Looking in %s...\n",buf); + if (!dir_ptr) + continue; + while ((dirent = readdir (dir_ptr))) + if (!fnmatch ("*.bsp", dirent->d_name, 0) + || !fnmatch ("*.bsp.gz", dirent->d_name, 0)) + Con_Printf ("%s\n", dirent->d_name); + closedir (dir_ptr); + } + } +} + +/* + COM_WriteFile + + The filename will be prefixed by the current game directory +*/ +void +COM_WriteFile ( char *filename, void *data, int len ) +{ + QFile *f; + char name[MAX_OSPATH]; + + snprintf(name, sizeof(name), "%s/%s", com_gamedir, filename); + + f = Qopen (name, "wb"); + if (!f) { + Sys_mkdir(com_gamedir); + f = Qopen (name, "wb"); + if (!f) + Sys_Error ("Error opening %s", filename); + } + + Sys_Printf ("COM_WriteFile: %s\n", name); + Qwrite (f, data, len); + Qclose (f); +} + + +/* + COM_CreatePath + + Only used for CopyFile and download +*/ +void +COM_CreatePath ( char *path ) +{ + char *ofs; + char e_path[PATH_MAX]; + + Qexpand_squiggle (path, e_path); + path = e_path; + + for (ofs = path+1 ; *ofs ; ofs++) { + if (*ofs == '/') { // create the directory + *ofs = 0; + Sys_mkdir (path); + *ofs = '/'; + } + } +} + + +/* + COM_CopyFile + + Copies a file over from the net to the local cache, creating any + directories needed. This is for the convenience of developers using + ISDN from home. +*/ +void +COM_CopyFile (char *netpath, char *cachepath) +{ + QFile *in, *out; + int remaining, count; + char buf[4096]; + + remaining = COM_FileOpenRead (netpath, &in); + COM_CreatePath (cachepath); // create directories up to the cache file + out = Qopen(cachepath, "wb"); + if (!out) + Sys_Error ("Error opening %s", cachepath); + + while (remaining) + { + if (remaining < sizeof(buf)) + count = remaining; + else + count = sizeof(buf); + Qread (in, buf, count); + Qwrite (out, buf, count); + remaining -= count; + } + + Qclose (in); + Qclose (out); +} + +/* + COM_OpenRead +*/ +QFile * +COM_OpenRead (const char *path, int offs, int len) +{ + int fd=open(path,O_RDONLY); + unsigned char id[2]; + unsigned char len_bytes[4]; + if (fd==-1) { + Sys_Error ("Couldn't open %s", path); + return 0; + } + if (offs<0 || len<0) { + // normal file + offs=0; + len=lseek(fd,0,SEEK_END); + lseek(fd,0,SEEK_SET); + } + read(fd,id,2); + if (id[0]==0x1f && id[1]==0x8b) { + lseek(fd,offs+len-4,SEEK_SET); + read(fd,len_bytes,4); + len=((len_bytes[3]<<24) + |(len_bytes[2]<<16) + |(len_bytes[1]<<8) + |(len_bytes[0])); + } + lseek(fd,offs,SEEK_SET); + com_filesize=len; + return Qdopen(fd,"rbz"); + return 0; +} + +int file_from_pak; // global indicating file came from pack file ZOID + +/* + COM_FOpenFile + + Finds the file in the search path. + Sets com_filesize and one of handle or file +*/ +int +COM_FOpenFile (char *filename, QFile **gzfile) +{ + searchpath_t *search; + char netpath[MAX_OSPATH]; + pack_t *pak; + int i; + int findtime; +#ifdef HAS_ZLIB + char gzfilename[MAX_OSPATH]; + int filenamelen;; + + filenamelen = strlen(filename); + strncpy(gzfilename,filename,sizeof(gzfilename)); + strncat(gzfilename,".gz",sizeof(gzfilename)); +#endif + + file_from_pak = 0; + +// +// search through the path, one element at a time +// + for (search = com_searchpaths ; search ; search = search->next) + { + // is the element a pak file? + if (search->pack) + { + // look through all the pak file elements + pak = search->pack; + for (i=0 ; inumfiles ; i++) { + char *fn=0; +#ifdef HAS_ZLIB + if (!strncmp(pak->files[i].name, filename, filenamelen)) { + if (!pak->files[i].name[filenamelen]) + fn=filename; + else if (!strcmp (pak->files[i].name, gzfilename)) + fn=gzfilename; + } +#else + if (!strcmp (pak->files[i].name, filename)) + fn=filename; +#endif + if (fn) + { // found it! + if (developer->value) + Sys_Printf ("PackFile: %s : %s\n",pak->filename, fn); + // open a new file on the pakfile + *gzfile=COM_OpenRead(pak->filename,pak->files[i].filepos, + pak->files[i].filelen); + file_from_pak = 1; + return com_filesize; + } + } + } + else + { + // check a file in the directory tree + snprintf(netpath, sizeof(netpath), "%s/%s",search->filename, + filename); + + findtime = Sys_FileTime (netpath); + if (findtime == -1) { +#ifdef HAS_ZLIB + snprintf(netpath, sizeof(netpath), "%s/%s",search->filename, + gzfilename); + findtime = Sys_FileTime (netpath); + if (findtime == -1) +#endif + continue; + } + + if(developer->value) + Sys_Printf ("FindFile: %s\n",netpath); + + *gzfile=COM_OpenRead(netpath,-1,-1); + return com_filesize; + } + + } + + Sys_Printf ("FindFile: can't find %s\n", filename); + + *gzfile = NULL; + com_filesize = -1; + return -1; +} + +cache_user_t *loadcache; +byte *loadbuf; +int loadsize; + +/* + COM_LoadFile + + Filename are relative to the quake directory. + Allways appends a 0 byte to the loaded data. +*/ +byte * +COM_LoadFile (char *path, int usehunk) +{ + QFile *h; + byte *buf; + char base[32]; + int len; + + buf = NULL; // quiet compiler warning + +// look for it in the filesystem or pack files + len = com_filesize = COM_FOpenFile (path, &h); + if (!h) + return NULL; + +// extract the filename base name for hunk tag + COM_FileBase (path, base); + + if (usehunk == 1) + buf = Hunk_AllocName (len+1, base); + else if (usehunk == 2) + buf = Hunk_TempAlloc (len+1); + else if (usehunk == 0) + buf = Z_Malloc (len+1); + else if (usehunk == 3) + buf = Cache_Alloc (loadcache, len+1, base); + else if (usehunk == 4) + { + if (len+1 > loadsize) + buf = Hunk_TempAlloc (len+1); + else + buf = loadbuf; + } + else + Sys_Error ("COM_LoadFile: bad usehunk"); + + if (!buf) + Sys_Error ("COM_LoadFile: not enough space for %s", path); + + ((byte *)buf)[len] = 0; +#ifndef SERVERONLY + Draw_BeginDisc (); +#endif + Qread (h, buf, len); + Qclose (h); +#ifndef SERVERONLY + Draw_EndDisc (); +#endif + + return buf; +} + +byte * +COM_LoadHunkFile (char *path) +{ + return COM_LoadFile (path, 1); +} + +byte * +COM_LoadTempFile (char *path) +{ + return COM_LoadFile (path, 2); +} + +void +COM_LoadCacheFile (char *path, struct cache_user_s *cu) +{ + loadcache = cu; + COM_LoadFile (path, 3); +} + +// uses temp hunk if larger than bufsize +byte * +COM_LoadStackFile (char *path, void *buffer, int bufsize) +{ + byte *buf; + + loadbuf = (byte *)buffer; + loadsize = bufsize; + buf = COM_LoadFile (path, 4); + + return buf; +} + +/* + COM_LoadPackFile + + 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. +*/ +pack_t * +COM_LoadPackFile (char *packfile) +{ + dpackheader_t header; + int i; + packfile_t *newfiles; + int numpackfiles; + pack_t *pack; + QFile *packhandle; + dpackfile_t info[MAX_FILES_IN_PACK]; + + if (COM_FileOpenRead (packfile, &packhandle) == -1) + return NULL; + + Qread (packhandle, &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 (numpackfiles > MAX_FILES_IN_PACK) + Sys_Error ("%s has %i files", packfile, numpackfiles); + + newfiles = Z_Malloc (numpackfiles * sizeof(packfile_t)); + + Qseek (packhandle, header.dirofs, SEEK_SET); + Qread (packhandle, info, header.dirlen); + + +// parse the directory + for (i=0 ; ifilename, packfile); + pack->handle = packhandle; + pack->numfiles = numpackfiles; + pack->files = newfiles; + + Con_Printf ("Added packfile %s (%i files)\n", packfile, numpackfiles); + return pack; +} + +#ifdef GENERATIONS +int +COM_pakzip_checkfile(unzFile *pak, const char *path) +{ + int status; + + status = unzLocateFile(pak, path, 2); + return (status == UNZ_OK); +} + +void +COM_pakzip_closepak(unzFile *pak) +{ + if (pak) + unzClose(pak); + pak = NULL; +} + +void +COM_pakzip_close(unzFile *pak) +{ + unzCloseCurrentFile(pak); +} + +int +COM_pakzip_read(unzFile *pak, void *buf, uint_t size, uint_t nmemb) +{ + int len = unzReadCurrentFile(pak, buf, size * nmemb); + return len / size; +} + +int +COM_pakzip_open(unzFile *pak, const char *path) +{ + if (unzLocateFile(pak, path, 2) != UNZ_OK) + return 0; + if (unzOpenCurrentFile(pak) != UNZ_OK) + return 0; + return 1; +} + +uint_t +COM_pakzip_getlen(unzFile *pak) +{ + unz_file_info info; + + if (unzGetCurrentFileInfo(pak, &info, NULL, 0, NULL, 0, NULL, 0) + != UNZ_OK) + return 0; + return info.uncompressed_size; +} + +uint_t +COM_pakzip_readfile(unzFile *pak, const char *path, uint_t bufsize, byte_t *buf) +{ + uint_t len; + + if (!COM_pakzip_open(pak,path)) + return 0; + + if ((len = COM_pakzip_getlen(pak)) != 0) + { + if (COM_pakzip_read(pak, (void*)buf, 1, len) != len) + len = 0; + } + COM_pakzip_close(pak); + return len; +} + + +pack_t * +COM_LoadPackZipFile (char *packfile) +{ + int i=0; + packfile_t *newfiles; + float numpackfiles; + unzFile *pak; + pack_t *pack_old; + int status; + +// This following variable info is unused ATM. +// dpackfile_t info[MAX_FILES_IN_PACK]; + char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1]; + + pak = unzOpen(packfile); + + numpackfiles = 0; + Con_Printf ("Assigned Numpackfiles\n"); + + if (!pak) + return NULL; + + newfiles = Hunk_AllocName (numpackfiles * sizeof(unzFile), "packfile"); + + status=unzGoToFirstFile(pak); + + while(status == UNZ_OK) { +// unzGetCurrentFileInfo(pak,NULL,&szCurrentFileName,64,NULL,0,NULL,0); + + if(strcmp(newfiles[i].name, szCurrentFileName)==0) + break; + + strcpy (newfiles[i].name, szCurrentFileName); + Con_Printf ("strcpy'ed %s into newfiles[%i].name Ok\n",szCurrentFileName, i); + + newfiles[i].filepos = LittleLong(unztell(pak)); +// newfiles[i].filelen = LittleLong(COM_pak3_readfile(pak,packfile,64,64)); + + Con_Printf ("Added File\n"); + status=unzGoToNextFile(pak); + ++numpackfiles; + ++i; + } + + Con_Printf ("Added files in %s to game data Ok\n", packfile); + + pack_old = Hunk_Alloc (sizeof (pack_t)); + strcpy (pack_old->filename, packfile); + //pack_old->handle = unzGetLocalExtrafield(packfile, NULL, NULL); + pack_old->numfiles = numpackfiles; + pack_old->files = newfiles; + + Con_Printf ("Added packfile %s (%.0f files)\n", packfile, numpackfiles); + + COM_pakzip_close(pak); + return pack_old; +} +#endif + +#define FBLOCK_SIZE 32 +#define FNAME_SIZE MAX_OSPATH + +// Note, this is /NOT/ a work-alike strcmp, this groups numbers sanely. +//int qstrcmp(const char *val, const char *ref) +int qstrcmp(char **os1, char **os2) +{ + int in1, in2, n1, n2; + char *s1, *s2; + s1 = *os1; + s2 = *os2; + + while (1) { + in1 = in2 = n1 = n2 = 0; + + if ((in1 = isdigit((int) *s1))) + n1 = strtol(s1, &s1, 10); + + if ((in2 = isdigit((int) *s2))) + n2 = strtol(s2, &s2, 10); + + if (in1 && in2) { + if (n1 != n2) + return n1-n2; + } else { + if (*s1 != *s2) + return *s1 - *s2; + else if (*s1 == '\0') + return *s1 - *s2; + s1++; + s2++; + } + } +} + + +void +COM_LoadGameDirectory(char *dir) +{ + searchpath_t *search; + pack_t *pak; + DIR *dir_ptr; + struct dirent *dirent; + char **pakfiles = NULL; + int i = 0, bufsize = 0, count = 0; + + Con_DPrintf ("COM_LoadGameDirectory (\"%s\")\n", dir); + + pakfiles = malloc(FBLOCK_SIZE * sizeof(char *)); + bufsize += FBLOCK_SIZE; + if (!pakfiles) + goto COM_LoadGameDirectory_free; + + for (i = count; i < bufsize; i++) { + pakfiles[i] = NULL; + } + + dir_ptr = opendir(dir); + if (!dir_ptr) + return; + + while ((dirent = readdir(dir_ptr))) { + if (!fnmatch("*.pak", dirent->d_name, 0)) { + if (count >= bufsize) { + bufsize += FBLOCK_SIZE; + pakfiles = realloc(pakfiles, bufsize * sizeof(char *)); + if (!pakfiles) + goto COM_LoadGameDirectory_free; + for (i = count; i < bufsize; i++) + pakfiles[i] = NULL; + } + + pakfiles[count] = malloc(FNAME_SIZE); + snprintf(pakfiles[count], FNAME_SIZE - 1, "%s/%s", dir, + dirent->d_name); + pakfiles[count][FNAME_SIZE - 1] = '\0'; + count++; + } + } + closedir(dir_ptr); + + // XXX WARNING!!! This is /NOT/ subtable for strcmp!!!!! + // This passes 'char **' instead of 'char *' to the cmp function! + qsort(pakfiles, count, sizeof(char *), + (int (*)(const void *, const void *)) qstrcmp); + + for (i = 0; i < count; i++) { + pak = COM_LoadPackFile(pakfiles[i]); + + if (!pak) { + Sys_Error(va("Bad pakfile %s!!", pakfiles[i])); + } else { + search = Z_Malloc (sizeof(searchpath_t)); + search->pack = pak; + search->next = com_searchpaths; + com_searchpaths = search; + } + } + +COM_LoadGameDirectory_free: + for (i = 0; i < count; i++) + free(pakfiles[i]); + free(pakfiles); + +#ifdef GENERATIONS + for (done=false, i=0 ; !done ; i++ ) { + snprintf(pakfile, sizeof(pakfile), "%s/pak%i.qz", dir, i); + + pak = COM_LoadPackZipFile(pakfile); + + if(!pak) { + done = true; + } else { + search = Hunk_Alloc (sizeof(searchpath_t)); + search->pack = pak; + search->next = com_searchpaths; + com_searchpaths = search; + } + } +#endif +} + +/* + COM_AddDirectory + + Sets com_gamedir, adds the directory to the head of the path, + then loads and adds pak1.pak pak2.pak ... +*/ +void +COM_AddDirectory (char *dir) +{ + searchpath_t *search; + char *p; + char e_dir[PATH_MAX]; + + Qexpand_squiggle (dir, e_dir); + dir = e_dir; + + if ((p = strrchr(dir, '/')) != NULL) { + strcpy (gamedirfile, ++p); + strcpy (com_gamedir, dir); + } else { + strcpy (gamedirfile, dir); + strcpy (com_gamedir, va("%s/%s", fs_basepath->string, dir)); + } + +// +// add the directory to the search path +// + search = Z_Malloc (sizeof(searchpath_t)); + strcpy (search->filename, dir); + search->next = com_searchpaths; + com_searchpaths = search; + +// +// add any pak files in the format pak0.pak pak1.pak, ... +// + + COM_LoadGameDirectory (dir); +} + +/* + COM_AddGameDirectory + + FIXME: this is a wrapper for COM_AddDirectory (which used to be + this function) to have it load share and base paths. Whenver + someone goes through to clean up the fs code, this function should + merge with COM_AddGameDirectory. +*/ +void +COM_AddGameDirectory (char *dir) +{ + Con_DPrintf ("COM_AddGameDirectory (\"%s/%s\")\n", + fs_sharepath->string, dir); + + if (strcmp (fs_sharepath->string, fs_basepath->string) != 0) + COM_AddDirectory (va("%s/%s", fs_sharepath->string, dir)); + COM_AddDirectory (va("%s/%s", fs_basepath->string, dir)); +} + +/* + COM_Gamedir + + Sets the gamedir and path to a different directory. +*/ +void +COM_Gamedir (char *dir) +{ + searchpath_t *next; + + if (strstr(dir, "..") || strstr(dir, "/") + || strstr(dir, "\\") || strstr(dir, ":") ) + { + Con_Printf ("Gamedir should be a single filename, not a path\n"); + return; + } + + if (strcmp (gamedirfile, dir) == 0) + return; // still the same + strcpy (gamedirfile, dir); + + // + // free up any current game dir info + // + while (com_searchpaths != com_base_searchpaths) + { + if (com_searchpaths->pack) + { + Qclose (com_searchpaths->pack->handle); + Z_Free (com_searchpaths->pack->files); + Z_Free (com_searchpaths->pack); + } + next = com_searchpaths->next; + Z_Free (com_searchpaths); + com_searchpaths = next; + } + + // + // flush all data, so it will be forced to reload + // + Cache_Flush (); + + if (strcmp (dir, BASEGAME) == 0) + return; +#ifdef QUAKEWORLD + if (strcmp (dir, "qw") == 0) + return; +#endif + + COM_AddGameDirectory (dir); +} + +/* +================ +SV_Gamedir_f + +Sets the gamedir and path to a different directory. +================ +*/ + +void COM_Gamedir_f (void) +{ + char *dir; + + if (Cmd_Argc() == 1) + { + Con_Printf ("Current gamedir: %s\n", gamedirfile); + return; + } + + if (Cmd_Argc() != 2) + { + Con_Printf ("Usage: gamedir \n"); + return; + } + + dir = Cmd_Argv(1); + + if (strstr(dir, "..") || strstr(dir, "/") + || strstr(dir, "\\") || strstr(dir, ":") ) + { + Con_Printf ("Gamedir should be a single filename, not a path\n"); + return; + } + + COM_Gamedir (dir); +#if defined(QUAKEWORLD) && defined(SERVERONLY) + Info_SetValueForStarKey (svs.info, "*gamedir", dir, MAX_SERVERINFO_STRING); +#endif +} + +/* + COM_InitFilesystem +*/ +void +COM_InitFilesystem ( void ) +{ +#ifdef UQUAKE + int i; +#endif + + fs_basepath = Cvar_Get ("fs_basepath", FS_USERPATH, CVAR_NONE, + "the location of your game directories"); + fs_sharepath = Cvar_Get ("fs_sharepath", FS_SHAREPATH, + CVAR_NONE, "read-only game directories"); + Cmd_AddCommand ("gamedir", COM_Gamedir_f); + +/* + start up with BASEGAME by default +*/ + COM_AddGameDirectory (BASEGAME); + if (hipnotic) + COM_AddGameDirectory ("hipnotic"); + if (rogue) + COM_AddGameDirectory ("rogue"); + +#ifdef QUAKEWORLD + COM_AddGameDirectory ("qw"); +#elif UQUAKE + i = COM_CheckParm ("-game"); + if (i && i < com_argc-1) + COM_AddGameDirectory (com_argv[i+1]); +#endif + + // any set gamedirs will be freed up to here + com_base_searchpaths = com_searchpaths; +} + +/* +============ +COM_SkipPath +============ +*/ +char *COM_SkipPath (char *pathname) +{ + char *last; + + last = pathname; + while (*pathname) + { + if (*pathname=='/') + last = pathname+1; + pathname++; + } + return last; +} + +/* +============ +COM_StripExtension +============ +*/ +void COM_StripExtension (char *in, char *out) +{ + while (*in && *in != '.') + *out++ = *in++; + *out = 0; +} + +/* +============ +COM_FileExtension +============ +*/ +char *COM_FileExtension (char *in) +{ + static char exten[8]; + int i; + + while (*in && *in != '.') + in++; + if (!*in) + return ""; + in++; + for (i=0 ; i<7 && *in ; i++,in++) + exten[i] = *in; + exten[i] = 0; + return exten; +} + + +/* +================== +COM_DefaultExtension +================== +*/ +void COM_DefaultExtension (char *path, char *extension) +{ + char *src; +// +// if path doesn't have a .EXT, append extension +// (extension should include the .) +// + src = path + strlen(path) - 1; + + while (*src != '/' && src != path) + { + if (*src == '.') + return; // it has an extension + src--; + } + + strcat (path, extension); +} diff --git a/source/quakeio.c b/source/quakeio.c new file mode 100644 index 0000000..b04b3ca --- /dev/null +++ b/source/quakeio.c @@ -0,0 +1,337 @@ +/* + quakeio.c + + (description) + + Copyright (C) 1996-1997 Id Software, Inc. + Copyright (C) 1999,2000 contributors of the QuakeForge project + Please see the file "AUTHORS" for a list of contributors + + 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: + + Free Software Foundation, Inc. + 59 Temple Place - Suite 330 + Boston, MA 02111-1307, USA + + $Id$ +*/ + +#ifdef HAVE_CONFIG_H +# include +#endif +#ifdef HAVE_MALLOC_H +#include +#endif +#include +#include +#include +#include +#ifdef WIN32 +#include +#include +#else +#include +#endif +#ifdef HAVE_UNISTD_H +#include +#endif + +#ifdef _MSC_VER +#define _POSIX_ +#endif +#include + +void +Qexpand_squiggle(const char *path, char *dest) +{ + char *home; +#ifndef _WIN32 + struct passwd *pwd_ent; +#endif + + if (strncmp (path, "~/",2) != 0) { + strcpy (dest,path); + return; + } + +#ifndef _WIN32 + if ((pwd_ent = getpwuid (getuid()))) { + home = pwd_ent->pw_dir; + } else +#endif + home = getenv("HOME"); + + if (home) { + strcpy (dest, home); + strcat (dest, path+1); // skip leading ~ + } else + strcpy (dest,path); +} + +int +Qrename(const char *old, const char *new) +{ + char e_old[PATH_MAX]; + char e_new[PATH_MAX]; + + Qexpand_squiggle (old, e_old); + Qexpand_squiggle (new, e_new); + return rename (e_old, e_new); +} + +QFile * +Qopen(const char *path, const char *mode) +{ + QFile *file; + char m[80],*p; + int zip=0; + char e_path[PATH_MAX]; + + Qexpand_squiggle (path, e_path); + path = e_path; + + for (p=m; *mode && p-m<(sizeof(m)-1); mode++) { + if (*mode=='z') { + zip=1; + continue; + } + *p++=*mode; + } + *p=0; + + file=calloc(sizeof(*file),1); + if (!file) + return 0; +#ifdef HAS_ZLIB + if (zip) { + file->gzfile=gzopen(path,m); + if (!file->gzfile) { + free(file); + return 0; + } + } else +#endif + { + file->file=fopen(path,m); + if (!file->file) { + free(file); + return 0; + } + } + return file; +} + +QFile * +Qdopen(int fd, const char *mode) +{ + QFile *file; + char m[80],*p; + int zip=0; + + for (p=m; *mode && p-m<(sizeof(m)-1); mode++) { + if (*mode=='z') { + zip=1; + continue; + } + *p++=*mode; + } + + *p=0; + + file=calloc(sizeof(*file),1); + if (!file) + return 0; +#ifdef HAS_ZLIB + if (zip) { + file->gzfile=gzdopen(fd,m); + if (!file->gzfile) { + free(file); + return 0; + } + } else +#endif + { + file->file=fdopen(fd,m); + if (!file->file) { + free(file); + return 0; + } + } +#ifdef WIN32 +#ifdef __BORLANDC__ + setmode(_fileno(file->file),O_BINARY); +#else + _setmode(_fileno(file->file),_O_BINARY); +#endif +#endif + return file; +} + +void +Qclose(QFile *file) +{ + if (file->file) + fclose(file->file); +#ifdef HAS_ZLIB + else + gzclose(file->gzfile); +#endif + free(file); +} + +int +Qread(QFile *file, void *buf, int count) +{ + if (file->file) + return fread(buf, 1, count, file->file); +#ifdef HAS_ZLIB + else + return gzread(file->gzfile,buf,count); +#else + return -1; +#endif +} + +int +Qwrite(QFile *file, void *buf, int count) +{ + if (file->file) + return fwrite(buf, 1, count, file->file); +#ifdef HAS_ZLIB + else + return gzwrite(file->gzfile,buf,count); +#else + return -1; +#endif +} + +int +Qprintf(QFile *file, const char *fmt, ...) +{ + va_list args; + int ret=-1; + + va_start(args,fmt); + if (file->file) + ret=vfprintf(file->file, fmt, args); +#ifdef HAS_ZLIB + else { + char buf[4096]; + va_start(args, fmt); +#ifdef HAVE_VSNPRINTF + (void)vsnprintf(buf, sizeof(buf), fmt, args); +#else + (void)vsprintf(buf, fmt, args); +#endif + va_end(args); + ret = strlen(buf); /* some *sprintf don't return the nb of bytes written */ + if (ret>0) + ret=gzwrite(file, buf, (unsigned)ret); + } +#endif + va_end(args); + return ret; +} + +char * +Qgets(QFile *file, char *buf, int count) +{ + if (file->file) + return fgets(buf, count, file->file); +#ifdef HAS_ZLIB + else + return gzgets(file->gzfile,buf,count); +#else + return 0; +#endif +} + +int +Qgetc(QFile *file) +{ + if (file->file) + return fgetc(file->file); +#ifdef HAS_ZLIB + else + return gzgetc(file->gzfile); +#else + return -1; +#endif +} + +int +Qputc(QFile *file, int c) +{ + if (file->file) + return fputc(c, file->file); +#ifdef HAS_ZLIB + else + return gzputc(file->gzfile,c); +#else + return -1; +#endif +} + +int +Qseek(QFile *file, long offset, int whence) +{ + if (file->file) + return fseek(file->file, offset, whence); +#ifdef HAS_ZLIB + else + return gzseek(file->gzfile,offset,whence); +#else + return -1; +#endif +} + +long +Qtell(QFile *file) +{ + if (file->file) + return ftell(file->file); +#ifdef HAS_ZLIB + else + return gztell(file->gzfile); +#else + return -1; +#endif +} + +int +Qflush(QFile *file) +{ + if (file->file) + return fflush(file->file); +#ifdef HAS_ZLIB + else + return gzflush(file->gzfile,Z_SYNC_FLUSH); +#else + return -1; +#endif +} + +int +Qeof(QFile *file) +{ + if (file->file) + return feof(file->file); +#ifdef HAS_ZLIB + else + return gzeof(file->gzfile); +#else + return -1; +#endif +} diff --git a/source/sizebuf.c b/source/sizebuf.c new file mode 100644 index 0000000..103d5c8 --- /dev/null +++ b/source/sizebuf.c @@ -0,0 +1,51 @@ +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif +#include "sizebuf.h" +#include "sys.h" + +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) + Sys_Error ("SZ_GetSpace: overflow without allowoverflow set (%d)", buf->maxsize); + + if (length > buf->maxsize) + Sys_Error ("SZ_GetSpace: %i is > full buffer size", length); + + Sys_Printf ("SZ_GetSpace: overflow\n"); // because Con_Printf may be redirected + SZ_Clear (buf); + buf->overflowed = true; + } + + data = buf->data + buf->cursize; + buf->cursize += length; + + return data; +} + +void SZ_Write (sizebuf_t *buf, void *data, int length) +{ + memcpy (SZ_GetSpace(buf,length),data,length); +} + +void SZ_Print (sizebuf_t *buf, char *data) +{ + int len; + + len = strlen(data)+1; + + if (!buf->cursize || buf->data[buf->cursize-1]) + memcpy ((byte *)SZ_GetSpace(buf, len),data,len); // no trailing 0 + else + memcpy ((byte *)SZ_GetSpace(buf, len-1)-1,data,len); // write over trailing 0 +} diff --git a/source/va.c b/source/va.c new file mode 100644 index 0000000..364494b --- /dev/null +++ b/source/va.c @@ -0,0 +1,44 @@ +/* +Copyright (C) 1996-1997 Id Software, Inc. + +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. + +*/ +#ifdef HAVE_CONFIG_H +# include +#endif +#include +#include + +/* + va + + does a varargs printf into a temp buffer, so I don't need to have + varargs versions of all text functions. + FIXME: make this buffer size safe someday +*/ +char * +va(char *format, ...) +{ + va_list argptr; + static char string[1024]; + + va_start (argptr, format); + vsnprintf (string, sizeof(string), format, argptr); + va_end (argptr); + + return string; +}