2 Copyright (C) 1996-1997 Id Software, Inc.
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
13 See the GNU General Public License for more details.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 // common.c -- misc functions used in client and server
24 #define NUM_SAFE_ARGVS 7
26 static char *largv[MAX_NUM_ARGVS + NUM_SAFE_ARGVS + 1];
27 static char *argvdummy = " ";
29 static char *safeargvs[NUM_SAFE_ARGVS] =
30 {"-stdvid", "-nolan", "-nosound", "-nocdaudio", "-nojoy", "-nomouse", "-dibonly"};
32 cvar_t registered = {"registered","0"};
33 cvar_t cmdline = {"cmdline","0", false, true};
35 qboolean com_modified; // set true if using non-id files
39 int static_registered = 1; // only for startup check, then set
41 qboolean msg_suppress_1 = 0;
43 void COM_InitFilesystem (void);
45 // if a packfile directory differs from this, it is assumed to be hacked
46 #define PAK0_COUNT 339
47 #define PAK0_CRC 32981
53 #define CMDLINE_LENGTH 256
54 char com_cmdline[CMDLINE_LENGTH];
56 qboolean standard_quake = true, rogue = false, hipnotic = false, nehahra = false;
58 // this graphic needs to be in the pak file to use registered features
59 unsigned short pop[] =
61 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000
62 ,0x0000,0x0000,0x6600,0x0000,0x0000,0x0000,0x6600,0x0000
63 ,0x0000,0x0066,0x0000,0x0000,0x0000,0x0000,0x0067,0x0000
64 ,0x0000,0x6665,0x0000,0x0000,0x0000,0x0000,0x0065,0x6600
65 ,0x0063,0x6561,0x0000,0x0000,0x0000,0x0000,0x0061,0x6563
66 ,0x0064,0x6561,0x0000,0x0000,0x0000,0x0000,0x0061,0x6564
67 ,0x0064,0x6564,0x0000,0x6469,0x6969,0x6400,0x0064,0x6564
68 ,0x0063,0x6568,0x6200,0x0064,0x6864,0x0000,0x6268,0x6563
69 ,0x0000,0x6567,0x6963,0x0064,0x6764,0x0063,0x6967,0x6500
70 ,0x0000,0x6266,0x6769,0x6a68,0x6768,0x6a69,0x6766,0x6200
71 ,0x0000,0x0062,0x6566,0x6666,0x6666,0x6666,0x6562,0x0000
72 ,0x0000,0x0000,0x0062,0x6364,0x6664,0x6362,0x0000,0x0000
73 ,0x0000,0x0000,0x0000,0x0062,0x6662,0x0000,0x0000,0x0000
74 ,0x0000,0x0000,0x0000,0x0061,0x6661,0x0000,0x0000,0x0000
75 ,0x0000,0x0000,0x0000,0x0000,0x6500,0x0000,0x0000,0x0000
76 ,0x0000,0x0000,0x0000,0x0000,0x6400,0x0000,0x0000,0x0000
82 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.
84 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
85 only used during filesystem initialization.
87 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.
89 The "cache directory" is only used during development to save network bandwidth, especially over ISDN / T1 lines. If there is a cache directory
90 specified, when a file is found by the normal search path, it will be mirrored
91 into the cache directory, then opened there.
96 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.
100 //============================================================================
103 // ClearLink is used for new headnodes
104 void ClearLink (link_t *l)
106 l->prev = l->next = l;
109 void RemoveLink (link_t *l)
111 l->next->prev = l->prev;
112 l->prev->next = l->next;
115 void InsertLinkBefore (link_t *l, link_t *before)
118 l->prev = before->prev;
122 void InsertLinkAfter (link_t *l, link_t *after)
124 l->next = after->next;
131 ============================================================================
133 LIBRARY REPLACEMENT FUNCTIONS
135 ============================================================================
139 void Q_memset (void *dest, int fill, int count)
143 if ( (((long)dest | count) & 3) == 0)
146 fill = fill | (fill<<8) | (fill<<16) | (fill<<24);
147 for (i=0 ; i<count ; i++)
148 ((int *)dest)[i] = fill;
151 for (i=0 ; i<count ; i++)
152 ((byte *)dest)[i] = fill;
155 void Q_memcpy (void *dest, void *src, int count)
159 if (( ( (long)dest | (long)src | count) & 3) == 0 )
162 for (i=0 ; i<count ; i++)
163 ((int *)dest)[i] = ((int *)src)[i];
166 for (i=0 ; i<count ; i++)
167 ((byte *)dest)[i] = ((byte *)src)[i];
170 int Q_memcmp (void *m1, void *m2, int count)
175 if (((byte *)m1)[count] != ((byte *)m2)[count])
181 void Q_strcpy (char *dest, char *src)
190 void Q_strncpy (char *dest, char *src, int count)
192 while (*src && count--)
200 int Q_strlen (char *str)
211 char *Q_strrchr(char *s, char c)
213 int len = Q_strlen(s);
216 if (*--s == c) return s;
220 void Q_strcat (char *dest, char *src)
222 dest += Q_strlen(dest);
223 Q_strcpy (dest, src);
226 int Q_strcmp (char *s1, char *s2)
231 return -1; // strings not equal
233 return 0; // strings are equal
241 int Q_strncmp (char *s1, char *s2, int count)
248 return -1; // strings not equal
250 return 0; // strings are equal
258 int Q_strncasecmp (char *s1, char *s2, int n)
268 return 0; // strings are equal until end point
272 if (c1 >= 'a' && c1 <= 'z')
274 if (c2 >= 'a' && c2 <= 'z')
277 return -1; // strings not equal
280 return 0; // strings are equal
288 int Q_strcasecmp (char *s1, char *s2)
290 return Q_strncasecmp (s1, s2, 99999);
293 int Q_atoi (char *str)
312 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
318 if (c >= '0' && c <= '9')
319 val = (val<<4) + c - '0';
320 else if (c >= 'a' && c <= 'f')
321 val = (val<<4) + c - 'a' + 10;
322 else if (c >= 'A' && c <= 'F')
323 val = (val<<4) + c - 'A' + 10;
330 // check for character
334 return sign * str[1];
343 if (c <'0' || c > '9')
345 val = val*10 + c - '0';
352 float Q_atof (char *str)
372 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
378 if (c >= '0' && c <= '9')
379 val = (val*16) + c - '0';
380 else if (c >= 'a' && c <= 'f')
381 val = (val*16) + c - 'a' + 10;
382 else if (c >= 'A' && c <= 'F')
383 val = (val*16) + c - 'A' + 10;
390 // check for character
394 return sign * str[1];
410 if (c <'0' || c > '9')
412 val = val*10 + c - '0';
418 while (total > decimal)
429 ============================================================================
433 ============================================================================
437 short (*BigShort) (short l);
438 short (*LittleShort) (short l);
439 int (*BigLong) (int l);
440 int (*LittleLong) (int l);
441 float (*BigFloat) (float l);
442 float (*LittleFloat) (float l);
445 short ShortSwap (short l)
455 short ShortNoSwap (short l)
469 return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
472 int LongNoSwap (int l)
477 float FloatSwap (float f)
487 dat2.b[0] = dat1.b[3];
488 dat2.b[1] = dat1.b[2];
489 dat2.b[2] = dat1.b[1];
490 dat2.b[3] = dat1.b[0];
494 float FloatNoSwap (float f)
500 ==============================================================================
504 Handles byte ordering and avoids alignment errors
505 ==============================================================================
512 void MSG_WriteChar (sizebuf_t *sb, int c)
517 // if (c < -128 || c > 127)
518 // Sys_Error ("MSG_WriteChar: range error");
521 buf = SZ_GetSpace (sb, 1);
525 void MSG_WriteByte (sizebuf_t *sb, int c)
530 // if (c < 0 || c > 255)
531 // Sys_Error ("MSG_WriteByte: range error");
534 buf = SZ_GetSpace (sb, 1);
538 void MSG_WriteShort (sizebuf_t *sb, int c)
543 // if (c < ((short)0x8000) || c > (short)0x7fff)
544 // Sys_Error ("MSG_WriteShort: range error");
547 buf = SZ_GetSpace (sb, 2);
552 void MSG_WriteLong (sizebuf_t *sb, int c)
556 buf = SZ_GetSpace (sb, 4);
558 buf[1] = (c>>8)&0xff;
559 buf[2] = (c>>16)&0xff;
563 void MSG_WriteFloat (sizebuf_t *sb, float f)
573 dat.l = LittleLong (dat.l);
575 SZ_Write (sb, &dat.l, 4);
578 void MSG_WriteString (sizebuf_t *sb, char *s)
581 SZ_Write (sb, "", 1);
583 SZ_Write (sb, s, strlen(s)+1);
587 void MSG_WriteCoord (sizebuf_t *sb, float f)
593 buf = SZ_GetSpace (sb, 3);
595 buf[1] = (c >> 8) & 0xff;
596 buf[2] = (c >> 16) & 0xff;
599 MSG_WriteShort (sb, (int)(f*8));
603 void MSG_WriteCoord (sizebuf_t *sb, float f)
606 MSG_WriteFloat(sb, f);
609 int i = (int) (f * 16.0f), j = 0, k, l;
610 // 1 sign bit, 5bit exponent, 10bit mantissa with implicit 1
617 // LordHavoc: lets hope the compiler is good, if not it will still perform tolerably
618 for (k = 31,l = 0x80000000;!(i & l);k--,l >>= 1);
619 j |= k << 10 | ((i >> (k - 10)) & 0x3FF);
621 MSG_WriteShort(sb, j);
625 MSG_WriteShort (sb, (int)(f*8));
628 void MSG_WritePreciseAngle (sizebuf_t *sb, float f)
630 MSG_WriteShort (sb, (int) (f*65536.0f/360) & 65535);
633 void MSG_WriteAngle (sizebuf_t *sb, float f)
635 MSG_WriteByte (sb, ((int)f*256/360) & 255);
642 qboolean msg_badread;
644 void MSG_BeginReading (void)
651 // returns -1 and sets msg_badread if no more characters are available
652 int MSG_ReadChar (void)
656 // LordHavoc: minor optimization
657 if (msg_readcount >= net_message.cursize)
658 // if (msg_readcount+1 > net_message.cursize)
664 c = (signed char)net_message.data[msg_readcount];
670 int MSG_ReadByte (void)
674 // LordHavoc: minor optimization
675 if (msg_readcount >= net_message.cursize)
676 // if (msg_readcount+1 > net_message.cursize)
682 c = (unsigned char)net_message.data[msg_readcount];
689 int MSG_ReadShort (void)
693 if (msg_readcount+2 > net_message.cursize)
699 c = (short)(net_message.data[msg_readcount]
700 + (net_message.data[msg_readcount+1]<<8));
707 int MSG_ReadLong (void)
711 if (msg_readcount+4 > net_message.cursize)
717 c = net_message.data[msg_readcount]
718 + (net_message.data[msg_readcount+1]<<8)
719 + (net_message.data[msg_readcount+2]<<16)
720 + (net_message.data[msg_readcount+3]<<24);
727 float MSG_ReadFloat (void)
736 dat.b[0] = net_message.data[msg_readcount];
737 dat.b[1] = net_message.data[msg_readcount+1];
738 dat.b[2] = net_message.data[msg_readcount+2];
739 dat.b[3] = net_message.data[msg_readcount+3];
742 dat.l = LittleLong (dat.l);
747 char *MSG_ReadString (void)
749 static char string[2048];
756 if (c == -1 || c == 0)
760 } while (l < sizeof(string)-1);
768 float MSG_ReadAbsoluteCoord (void)
774 if (msg_readcount+3 > net_message.cursize)
780 c = net_message.data[msg_readcount ];
781 c |= net_message.data[msg_readcount+1] << 8;
782 c |= net_message.data[msg_readcount+2] << 16;
784 c |= ~0xFFFFFF; // sign extend
788 return (float) c * (1.0f / 16.0f);
794 if (msg_readcount+2 > net_message.cursize)
800 c = (short) (net_message.data[msg_readcount ] |= net_message.data[msg_readcount+1] << 8);
804 return (float) c * (1.0f / 8.0f);
805 // return MSG_ReadShort() * (1.0f/8.0f);
810 float MSG_ReadCoord (void)
813 return MSG_ReadFloat();
818 if (msg_readcount+2 > net_message.cursize)
824 c = net_message.data[msg_readcount ] |= net_message.data[msg_readcount+1] << 8;
830 // 1 sign bit, 5bit exponent, 10bit mantissa with implicit 1
831 i = ((c & 0x03FF) | (0x0400)) << (((c & 0x7C00) >> 10) - 10);
834 return i * (1.0f / 16.0f);
841 if (msg_readcount+2 > net_message.cursize)
847 c = (short) (net_message.data[msg_readcount ] | (net_message.data[msg_readcount+1] << 8));
851 return ((float) c * (1.0f / 8.0f));
852 // return MSG_ReadShort() * (1.0f/8.0f);
857 float MSG_ReadCoord (void)
859 return MSG_ReadShort() * (1.0f/8.0f);
862 float MSG_ReadAngle (void)
864 return MSG_ReadChar() * (360.0f/256.0f);
868 float MSG_ReadPreciseAngle (void)
870 return MSG_ReadShort() * (360.0f/65536);
874 //===========================================================================
876 void SZ_Alloc (sizebuf_t *buf, int startsize)
880 buf->data = Hunk_AllocName (startsize, "sizebuf");
881 buf->maxsize = startsize;
886 void SZ_Free (sizebuf_t *buf)
888 // Z_Free (buf->data);
894 void SZ_Clear (sizebuf_t *buf)
899 void *SZ_GetSpace (sizebuf_t *buf, int length)
903 if (buf->cursize + length > buf->maxsize)
905 if (!buf->allowoverflow)
906 Host_Error ("SZ_GetSpace: overflow without allowoverflow set - use -zone on the commandline for more zone memory, default: 512k (quake original default was 48k)");
908 if (length > buf->maxsize)
909 Host_Error ("SZ_GetSpace: %i is > full buffer size", length);
911 buf->overflowed = true;
912 Con_Printf ("SZ_GetSpace: overflow");
916 data = buf->data + buf->cursize;
917 buf->cursize += length;
922 void SZ_Write (sizebuf_t *buf, void *data, int length)
924 memcpy (SZ_GetSpace(buf,length),data,length);
927 void SZ_Print (sizebuf_t *buf, char *data)
931 len = strlen(data)+1;
933 // byte * cast to keep VC++ happy
934 if (buf->data[buf->cursize-1])
935 memcpy ((byte *)SZ_GetSpace(buf, len),data,len); // no trailing 0
937 memcpy ((byte *)SZ_GetSpace(buf, len-1)-1,data,len); // write over trailing 0
941 //============================================================================
949 char *COM_SkipPath (char *pathname)
968 void COM_StripExtension (char *in, char *out)
970 while (*in && *in != '.')
980 char *COM_FileExtension (char *in)
982 static char exten[8];
985 while (*in && *in != '.')
990 for (i=0 ; i<7 && *in ; i++,in++)
1001 void COM_FileBase (char *in, char *out)
1005 s = in + strlen(in) - 1;
1007 while (s != in && *s != '.')
1010 for (s2 = s ; *s2 && *s2 != '/' ; s2--)
1014 strcpy (out,"?model?");
1018 strncpy (out,s2+1, s-s2);
1026 COM_DefaultExtension
1029 void COM_DefaultExtension (char *path, char *extension)
1033 // if path doesn't have a .EXT, append extension
1034 // (extension should include the .)
1036 src = path + strlen(path) - 1;
1038 while (*src != '/' && src != path)
1041 return; // it has an extension
1045 strcat (path, extension);
1053 Parse a token out of a string
1056 char *COM_Parse (char *data)
1069 while ( (c = *data) <= ' ')
1072 return NULL; // end of file;
1077 if (c=='/' && data[1] == '/')
1079 while (*data && *data != '\n')
1085 // handle quoted strings specially
1102 // parse single characters
1103 if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
1111 // parse a regular word
1118 if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
1131 Returns the position (1 to argc-1) in the program's argument list
1132 where the given parameter apears, or 0 if not present
1135 int COM_CheckParm (char *parm)
1139 for (i=1 ; i<com_argc ; i++)
1142 continue; // NEXTSTEP sometimes clears appkit vars.
1143 if (!strcmp (parm,com_argv[i]))
1154 Looks for the pop.txt file and verifies it.
1155 Sets the "registered" cvar.
1156 Immediately exits out if an alternate game was attempted to be started without
1160 void COM_CheckRegistered (void)
1163 unsigned short check[128];
1166 Cvar_Set ("cmdline", com_cmdline);
1168 COM_OpenFile("gfx/pop.lmp", &h, false);
1169 static_registered = 0;
1174 Con_Printf ("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1176 Con_Printf ("Playing shareware version.\n");
1178 // Sys_Error ("This dedicated server requires a full registered copy of Quake");
1180 // Con_Printf ("Playing shareware version.\n");
1181 // if (com_modified)
1182 // Sys_Error ("You must have the registered version to use modified games");
1186 Sys_FileRead (h, check, sizeof(check));
1189 for (i=0 ; i<128 ; i++)
1190 if (pop[i] != (unsigned short)BigShort (check[i]))
1191 Sys_Error ("Corrupted data file.");
1193 // Cvar_Set ("cmdline", com_cmdline);
1194 Cvar_Set ("registered", "1");
1195 static_registered = 1;
1196 Con_Printf ("Playing registered version.\n");
1200 void COM_Path_f (void);
1208 void COM_InitArgv (int argc, char **argv)
1213 // reconstitute the command line for the cmdline externally visible cvar
1216 for (j=0 ; (j<MAX_NUM_ARGVS) && (j< argc) ; j++)
1220 while ((n < (CMDLINE_LENGTH - 1)) && argv[j][i])
1222 com_cmdline[n++] = argv[j][i++];
1225 if (n < (CMDLINE_LENGTH - 1))
1226 com_cmdline[n++] = ' ';
1235 for (com_argc=0 ; (com_argc<MAX_NUM_ARGVS) && (com_argc < argc) ;
1238 largv[com_argc] = argv[com_argc];
1239 if (!strcmp ("-safe", argv[com_argc]))
1245 // force all the safe-mode switches. Note that we reserved extra space in
1246 // case we need to add these, so we don't need an overflow check
1247 for (i=0 ; i<NUM_SAFE_ARGVS ; i++)
1249 largv[com_argc] = safeargvs[i];
1254 largv[com_argc] = argvdummy;
1259 standard_quake = false;
1261 if (COM_CheckParm ("-rogue"))
1264 standard_quake = false;
1267 if (COM_CheckParm ("-hipnotic"))
1270 standard_quake = false;
1273 if (COM_CheckParm ("-nehahra"))
1276 standard_quake = false;
1287 void COM_Init (char *basedir)
1290 byte swaptest[2] = {1,0};
1292 // set the byte swapping variables in a portable manner
1293 if ( *(short *)swaptest == 1)
1295 BigShort = ShortSwap;
1296 LittleShort = ShortNoSwap;
1298 LittleLong = LongNoSwap;
1299 BigFloat = FloatSwap;
1300 LittleFloat = FloatNoSwap;
1304 BigShort = ShortNoSwap;
1305 LittleShort = ShortSwap;
1306 BigLong = LongNoSwap;
1307 LittleLong = LongSwap;
1308 BigFloat = FloatNoSwap;
1309 LittleFloat = FloatSwap;
1313 Cvar_RegisterVariable (®istered);
1314 Cvar_RegisterVariable (&cmdline);
1315 Cmd_AddCommand ("path", COM_Path_f);
1317 COM_InitFilesystem ();
1318 COM_CheckRegistered ();
1326 does a varargs printf into a temp buffer, so I don't need to have
1327 varargs versions of all text functions.
1328 FIXME: make this buffer size safe someday
1331 char *va(char *format, ...)
1334 static char string[1024];
1336 va_start (argptr, format);
1337 vsprintf (string, format,argptr);
1344 /// just for debugging
1345 int memsearch (byte *start, int count, int search)
1349 for (i=0 ; i<count ; i++)
1350 if (start[i] == search)
1356 =============================================================================
1360 =============================================================================
1372 char name[MAX_QPATH];
1373 int filepos, filelen;
1376 typedef struct pack_s
1378 char filename[MAX_OSPATH];
1390 int filepos, filelen;
1400 // LordHavoc: was 2048, increased to 16384 and changed info[MAX_PACK_FILES] to a temporary malloc to avoid stack overflows
1401 #define MAX_FILES_IN_PACK 16384
1403 char com_cachedir[MAX_OSPATH];
1404 char com_gamedir[MAX_OSPATH];
1406 typedef struct searchpath_s
1408 char filename[MAX_OSPATH];
1409 pack_t *pack; // only one of filename / pack will be used
1410 struct searchpath_s *next;
1413 searchpath_t *com_searchpaths;
1421 void COM_Path_f (void)
1425 Con_Printf ("Current search path:\n");
1426 for (s=com_searchpaths ; s ; s=s->next)
1430 Con_Printf ("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
1433 Con_Printf ("%s\n", s->filename);
1441 The filename will be prefixed by the current game directory
1444 void COM_WriteFile (char *filename, void *data, int len)
1447 char name[MAX_OSPATH];
1449 sprintf (name, "%s/%s", com_gamedir, filename);
1451 handle = Sys_FileOpenWrite (name);
1454 Sys_Printf ("COM_WriteFile: failed on %s\n", name);
1458 Sys_Printf ("COM_WriteFile: %s\n", name);
1459 Sys_FileWrite (handle, data, len);
1460 Sys_FileClose (handle);
1468 Only used for CopyFile
1471 void COM_CreatePath (char *path)
1475 for (ofs = path+1 ; *ofs ; ofs++)
1478 { // create the directory
1491 Copies a file over from the net to the local cache, creating any directories
1492 needed. This is for the convenience of developers using ISDN from home.
1495 void COM_CopyFile (char *netpath, char *cachepath)
1498 int remaining, count;
1501 remaining = Sys_FileOpenRead (netpath, &in);
1502 COM_CreatePath (cachepath); // create directories up to the cache file
1503 out = Sys_FileOpenWrite (cachepath);
1507 if (remaining < sizeof(buf))
1510 count = sizeof(buf);
1511 Sys_FileRead (in, buf, count);
1512 Sys_FileWrite (out, buf, count);
1517 Sys_FileClose (out);
1524 Finds the file in the search path.
1525 Sets com_filesize and one of handle or file
1528 int COM_FindFile (char *filename, int *handle, FILE **file, qboolean quiet)
1530 searchpath_t *search;
1531 char netpath[MAX_OSPATH];
1532 char cachepath[MAX_OSPATH];
1535 int findtime, cachetime;
1538 Sys_Error ("COM_FindFile: both handle and file set");
1539 if (!file && !handle)
1540 Sys_Error ("COM_FindFile: neither handle or file set");
1543 // search through the path, one element at a time
1545 search = com_searchpaths;
1547 { // gross hack to use quake 1 progs with quake 2 maps
1548 if (!strcmp(filename, "progs.dat"))
1549 search = search->next;
1552 for ( ; search ; search = search->next)
1554 // is the element a pak file?
1557 // look through all the pak file elements
1559 for (i=0 ; i<pak->numfiles ; i++)
1560 if (!strcmp (pak->files[i].name, filename))
1563 Sys_Printf ("PackFile: %s : %s\n",pak->filename, filename);
1566 *handle = pak->handle;
1567 Sys_FileSeek (pak->handle, pak->files[i].filepos);
1570 { // open a new file on the pakfile
1571 *file = fopen (pak->filename, "rb");
1573 fseek (*file, pak->files[i].filepos, SEEK_SET);
1575 com_filesize = pak->files[i].filelen;
1576 return com_filesize;
1581 // check a file in the directory tree
1582 // if (!static_registered)
1583 // { // if not a registered version, don't ever go beyond base
1584 // if ( strchr (filename, '/') || strchr (filename,'\\'))
1588 sprintf (netpath, "%s/%s",search->filename, filename);
1590 findtime = Sys_FileTime (netpath);
1594 // see if the file needs to be updated in the cache
1595 if (!com_cachedir[0])
1596 strcpy (cachepath, netpath);
1600 if ((strlen(netpath) < 2) || (netpath[1] != ':'))
1601 sprintf (cachepath,"%s%s", com_cachedir, netpath);
1603 sprintf (cachepath,"%s%s", com_cachedir, netpath+2);
1605 sprintf (cachepath,"%s%s", com_cachedir, netpath);
1608 cachetime = Sys_FileTime (cachepath);
1610 if (cachetime < findtime)
1611 COM_CopyFile (netpath, cachepath);
1612 strcpy (netpath, cachepath);
1616 Sys_Printf ("FindFile: %s\n",netpath);
1617 com_filesize = Sys_FileOpenRead (netpath, &i);
1623 *file = fopen (netpath, "rb");
1625 return com_filesize;
1631 Sys_Printf ("FindFile: can't find %s\n", filename);
1646 filename never has a leading slash, but may contain directory walks
1647 returns a handle and a length
1648 it may actually be inside a pak file
1651 int COM_OpenFile (char *filename, int *handle, qboolean quiet)
1653 return COM_FindFile (filename, handle, NULL, quiet);
1660 If the requested file is inside a packfile, a new FILE * will be opened
1664 int COM_FOpenFile (char *filename, FILE **file, qboolean quiet)
1666 return COM_FindFile (filename, NULL, file, quiet);
1673 If it is a pak file handle, don't really close it
1676 void COM_CloseFile (int h)
1680 for (s = com_searchpaths ; s ; s=s->next)
1681 if (s->pack && s->pack->handle == h)
1692 Filename are reletive to the quake directory.
1693 Allways appends a 0 byte.
1696 cache_user_t *loadcache;
1699 byte *COM_LoadFile (char *path, int usehunk, qboolean quiet)
1706 buf = NULL; // quiet compiler warning
1708 // look for it in the filesystem or pack files
1709 len = COM_OpenFile (path, &h, quiet);
1713 // extract the filename base name for hunk tag
1714 COM_FileBase (path, base);
1717 buf = Hunk_AllocName (len+1, base);
1718 else if (usehunk == 2)
1719 buf = Hunk_TempAlloc (len+1);
1720 else if (usehunk == 0)
1721 buf = Z_Malloc (len+1);
1722 else if (usehunk == 3)
1723 buf = Cache_Alloc (loadcache, len+1, base);
1724 else if (usehunk == 4)
1726 if (len+1 > loadsize)
1727 buf = Hunk_TempAlloc (len+1);
1731 else if (usehunk == 5)
1732 buf = malloc (len+1);
1734 Sys_Error ("COM_LoadFile: bad usehunk");
1737 Sys_Error ("COM_LoadFile: not enough space for %s", path);
1739 ((byte *)buf)[len] = 0;
1741 Sys_FileRead (h, buf, len);
1747 byte *COM_LoadHunkFile (char *path, qboolean quiet)
1749 return COM_LoadFile (path, 1, quiet);
1752 byte *COM_LoadTempFile (char *path, qboolean quiet)
1754 return COM_LoadFile (path, 2, quiet);
1757 // LordHavoc: returns malloc'd memory
1758 byte *COM_LoadMallocFile (char *path, qboolean quiet)
1760 return COM_LoadFile (path, 5, quiet);
1763 void COM_LoadCacheFile (char *path, struct cache_user_s *cu, qboolean quiet)
1766 COM_LoadFile (path, 3, quiet);
1769 // uses temp hunk if larger than bufsize
1770 byte *COM_LoadStackFile (char *path, void *buffer, int bufsize, qboolean quiet)
1774 loadbuf = (byte *)buffer;
1776 buf = COM_LoadFile (path, 4, quiet);
1785 Takes an explicit (not game tree related) path to a pak file.
1787 Loads the header and directory, adding the files at the beginning
1788 of the list so they override previous pack files.
1791 pack_t *COM_LoadPackFile (char *packfile)
1793 dpackheader_t header;
1795 packfile_t *newfiles;
1799 // LordHavoc: changed from stack array to temporary malloc, allowing huge pack directories
1803 if (Sys_FileOpenRead (packfile, &packhandle) == -1)
1805 // Con_Printf ("Couldn't open %s\n", packfile);
1808 Sys_FileRead (packhandle, (void *)&header, sizeof(header));
1809 if (header.id[0] != 'P' || header.id[1] != 'A'
1810 || header.id[2] != 'C' || header.id[3] != 'K')
1811 Sys_Error ("%s is not a packfile", packfile);
1812 header.dirofs = LittleLong (header.dirofs);
1813 header.dirlen = LittleLong (header.dirlen);
1815 numpackfiles = header.dirlen / sizeof(dpackfile_t);
1817 if (numpackfiles > MAX_FILES_IN_PACK)
1818 Sys_Error ("%s has %i files", packfile, numpackfiles);
1820 if (numpackfiles != PAK0_COUNT)
1821 com_modified = true; // not the original file
1823 newfiles = Hunk_AllocName (numpackfiles * sizeof(packfile_t), "packfile");
1825 info = malloc(sizeof(*info)*MAX_FILES_IN_PACK);
1826 Sys_FileSeek (packhandle, header.dirofs);
1827 Sys_FileRead (packhandle, (void *)info, header.dirlen);
1829 // crc the directory to check for modifications
1831 // LordHavoc: speedup
1832 CRC_ProcessBytes(&crc, (byte *)info, header.dirlen);
1833 // for (i=0 ; i<header.dirlen ; i++)
1834 // CRC_ProcessByte (&crc, ((byte *)info)[i]);
1835 if (crc != PAK0_CRC)
1836 com_modified = true;
1838 // parse the directory
1839 for (i=0 ; i<numpackfiles ; i++)
1841 strcpy (newfiles[i].name, info[i].name);
1842 newfiles[i].filepos = LittleLong(info[i].filepos);
1843 newfiles[i].filelen = LittleLong(info[i].filelen);
1847 pack = Hunk_Alloc (sizeof (pack_t));
1848 strcpy (pack->filename, packfile);
1849 pack->handle = packhandle;
1850 pack->numfiles = numpackfiles;
1851 pack->files = newfiles;
1853 Con_Printf ("Added packfile %s (%i files)\n", packfile, numpackfiles);
1860 COM_AddGameDirectory
1862 Sets com_gamedir, adds the directory to the head of the path,
1863 then loads and adds pak1.pak pak2.pak ...
1866 void COM_AddGameDirectory (char *dir)
1869 searchpath_t *search;
1871 char pakfile[MAX_OSPATH];
1873 strcpy (com_gamedir, dir);
1876 // add the directory to the search path
1878 search = Hunk_Alloc (sizeof(searchpath_t));
1879 strcpy (search->filename, dir);
1880 search->next = com_searchpaths;
1881 com_searchpaths = search;
1884 // add any pak files in the format pak0.pak pak1.pak, ...
1888 sprintf (pakfile, "%s/pak%i.pak", dir, i);
1889 pak = COM_LoadPackFile (pakfile);
1892 search = Hunk_Alloc (sizeof(searchpath_t));
1894 search->next = com_searchpaths;
1895 com_searchpaths = search;
1899 // add the contents of the parms.txt file to the end of the command line
1909 void COM_InitFilesystem (void)
1912 char basedir[MAX_OSPATH];
1913 searchpath_t *search;
1917 // Overrides the system supplied base directory (under GAMENAME)
1919 i = COM_CheckParm ("-basedir");
1920 if (i && i < com_argc-1)
1921 strcpy (basedir, com_argv[i+1]);
1923 strcpy (basedir, host_parms.basedir);
1925 j = strlen (basedir);
1929 if ((basedir[j-1] == '\\') || (basedir[j-1] == '/'))
1935 // Overrides the system supplied cache directory (NULL or /qcache)
1936 // -cachedir - will disable caching.
1938 i = COM_CheckParm ("-cachedir");
1939 if (i && i < com_argc-1)
1941 if (com_argv[i+1][0] == '-')
1942 com_cachedir[0] = 0;
1944 strcpy (com_cachedir, com_argv[i+1]);
1946 else if (host_parms.cachedir)
1947 strcpy (com_cachedir, host_parms.cachedir);
1949 com_cachedir[0] = 0;
1952 // start up with GAMENAME by default (id1)
1954 COM_AddGameDirectory (va("%s/"GAMENAME, basedir) );
1957 COM_AddGameDirectory (va("%s/nehahra", basedir) );
1959 if (COM_CheckParm ("-rogue"))
1960 COM_AddGameDirectory (va("%s/rogue", basedir) );
1961 if (COM_CheckParm ("-hipnotic"))
1962 COM_AddGameDirectory (va("%s/hipnotic", basedir) );
1963 if (COM_CheckParm ("-nehahra"))
1964 COM_AddGameDirectory (va("%s/nehahra", basedir) );
1969 // Adds basedir/gamedir as an override game
1971 i = COM_CheckParm ("-game");
1972 if (i && i < com_argc-1)
1974 com_modified = true;
1975 COM_AddGameDirectory (va("%s/%s", basedir, com_argv[i+1]));
1979 // -path <dir or packfile> [<dir or packfile>] ...
1980 // Fully specifies the exact serach path, overriding the generated one
1982 i = COM_CheckParm ("-path");
1985 com_modified = true;
1986 com_searchpaths = NULL;
1987 while (++i < com_argc)
1989 if (!com_argv[i] || com_argv[i][0] == '+' || com_argv[i][0] == '-')
1992 search = Hunk_Alloc (sizeof(searchpath_t));
1993 if ( !strcmp(COM_FileExtension(com_argv[i]), "pak") )
1995 search->pack = COM_LoadPackFile (com_argv[i]);
1997 Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
2000 strcpy (search->filename, com_argv[i]);
2001 search->next = com_searchpaths;
2002 com_searchpaths = search;
2006 if (COM_CheckParm ("-proghack"))
2010 int COM_FileExists(char *filename)
2012 searchpath_t *search;
2013 char netpath[MAX_OSPATH];
2018 for (search = com_searchpaths;search;search = search->next)
2023 for (i = 0;i < pak->numfiles;i++)
2024 if (!strcmp (pak->files[i].name, filename))
2029 sprintf (netpath, "%s/%s",search->filename, filename);
2030 findtime = Sys_FileTime (netpath);