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);
586 void MSG_WriteCoord (sizebuf_t *sb, float f)
589 MSG_WriteFloat(sb, f);
591 MSG_WriteShort (sb, (int)(f*8));
594 void MSG_WritePreciseAngle (sizebuf_t *sb, float f)
596 MSG_WriteShort (sb, (int) (f*65536.0f/360) & 65535);
599 void MSG_WriteAngle (sizebuf_t *sb, float f)
601 MSG_WriteByte (sb, ((int)f*256/360) & 255);
608 qboolean msg_badread;
610 void MSG_BeginReading (void)
617 // returns -1 and sets msg_badread if no more characters are available
618 int MSG_ReadChar (void)
622 // LordHavoc: minor optimization
623 if (msg_readcount >= net_message.cursize)
624 // if (msg_readcount+1 > net_message.cursize)
630 c = (signed char)net_message.data[msg_readcount];
636 int MSG_ReadByte (void)
640 // LordHavoc: minor optimization
641 if (msg_readcount >= net_message.cursize)
642 // if (msg_readcount+1 > net_message.cursize)
648 c = (unsigned char)net_message.data[msg_readcount];
655 int MSG_ReadShort (void)
659 if (msg_readcount+2 > net_message.cursize)
665 c = (short)(net_message.data[msg_readcount]
666 + (net_message.data[msg_readcount+1]<<8));
673 int MSG_ReadLong (void)
677 if (msg_readcount+4 > net_message.cursize)
683 c = net_message.data[msg_readcount]
684 + (net_message.data[msg_readcount+1]<<8)
685 + (net_message.data[msg_readcount+2]<<16)
686 + (net_message.data[msg_readcount+3]<<24);
693 float MSG_ReadFloat (void)
702 dat.b[0] = net_message.data[msg_readcount];
703 dat.b[1] = net_message.data[msg_readcount+1];
704 dat.b[2] = net_message.data[msg_readcount+2];
705 dat.b[3] = net_message.data[msg_readcount+3];
708 dat.l = LittleLong (dat.l);
713 char *MSG_ReadString (void)
715 static char string[2048];
722 if (c == -1 || c == 0)
726 } while (l < sizeof(string)-1);
733 float MSG_ReadCoord (void)
736 return MSG_ReadFloat();
738 return MSG_ReadShort() * (1.0f/8.0f);
742 float MSG_ReadCoord (void)
744 return MSG_ReadShort() * (1.0f/8.0f);
747 float MSG_ReadAngle (void)
749 return MSG_ReadChar() * (360.0f/256.0f);
752 float MSG_ReadPreciseAngle (void)
754 return MSG_ReadShort() * (360.0f/65536);
759 //===========================================================================
761 void SZ_Alloc (sizebuf_t *buf, int startsize)
765 buf->data = Hunk_AllocName (startsize, "sizebuf");
766 buf->maxsize = startsize;
771 void SZ_Free (sizebuf_t *buf)
773 // Z_Free (buf->data);
779 void SZ_Clear (sizebuf_t *buf)
784 void *SZ_GetSpace (sizebuf_t *buf, int length)
788 if (buf->cursize + length > buf->maxsize)
790 if (!buf->allowoverflow)
791 Host_Error ("SZ_GetSpace: overflow without allowoverflow set - use -zone on the commandline for more zone memory, default: 512k (quake original default was 48k)");
793 if (length > buf->maxsize)
794 Host_Error ("SZ_GetSpace: %i is > full buffer size", length);
796 buf->overflowed = true;
797 Con_Printf ("SZ_GetSpace: overflow");
801 data = buf->data + buf->cursize;
802 buf->cursize += length;
807 void SZ_Write (sizebuf_t *buf, void *data, int length)
809 memcpy (SZ_GetSpace(buf,length),data,length);
812 void SZ_Print (sizebuf_t *buf, char *data)
816 len = strlen(data)+1;
818 // byte * cast to keep VC++ happy
819 if (buf->data[buf->cursize-1])
820 memcpy ((byte *)SZ_GetSpace(buf, len),data,len); // no trailing 0
822 memcpy ((byte *)SZ_GetSpace(buf, len-1)-1,data,len); // write over trailing 0
826 //============================================================================
834 char *COM_SkipPath (char *pathname)
853 void COM_StripExtension (char *in, char *out)
855 while (*in && *in != '.')
865 char *COM_FileExtension (char *in)
867 static char exten[8];
870 while (*in && *in != '.')
875 for (i=0 ; i<7 && *in ; i++,in++)
886 void COM_FileBase (char *in, char *out)
890 s = in + strlen(in) - 1;
892 while (s != in && *s != '.')
895 for (s2 = s ; *s2 && *s2 != '/' ; s2--)
899 strcpy (out,"?model?");
903 strncpy (out,s2+1, s-s2);
914 void COM_DefaultExtension (char *path, char *extension)
918 // if path doesn't have a .EXT, append extension
919 // (extension should include the .)
921 src = path + strlen(path) - 1;
923 while (*src != '/' && src != path)
926 return; // it has an extension
930 strcat (path, extension);
938 Parse a token out of a string
941 char *COM_Parse (char *data)
954 while ( (c = *data) <= ' ')
957 return NULL; // end of file;
962 if (c=='/' && data[1] == '/')
964 while (*data && *data != '\n')
970 // handle quoted strings specially
987 // parse single characters
988 if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
996 // parse a regular word
1003 if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
1016 Returns the position (1 to argc-1) in the program's argument list
1017 where the given parameter apears, or 0 if not present
1020 int COM_CheckParm (char *parm)
1024 for (i=1 ; i<com_argc ; i++)
1027 continue; // NEXTSTEP sometimes clears appkit vars.
1028 if (!strcmp (parm,com_argv[i]))
1039 Looks for the pop.txt file and verifies it.
1040 Sets the "registered" cvar.
1041 Immediately exits out if an alternate game was attempted to be started without
1045 void COM_CheckRegistered (void)
1048 unsigned short check[128];
1051 Cvar_Set ("cmdline", com_cmdline);
1053 COM_OpenFile("gfx/pop.lmp", &h, false);
1054 static_registered = 0;
1059 Con_Printf ("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1061 Con_Printf ("Playing shareware version.\n");
1063 // Sys_Error ("This dedicated server requires a full registered copy of Quake");
1065 // Con_Printf ("Playing shareware version.\n");
1066 // if (com_modified)
1067 // Sys_Error ("You must have the registered version to use modified games");
1071 Sys_FileRead (h, check, sizeof(check));
1074 for (i=0 ; i<128 ; i++)
1075 if (pop[i] != (unsigned short)BigShort (check[i]))
1076 Sys_Error ("Corrupted data file.");
1078 // Cvar_Set ("cmdline", com_cmdline);
1079 Cvar_Set ("registered", "1");
1080 static_registered = 1;
1081 Con_Printf ("Playing registered version.\n");
1085 void COM_Path_f (void);
1093 void COM_InitArgv (int argc, char **argv)
1098 // reconstitute the command line for the cmdline externally visible cvar
1101 for (j=0 ; (j<MAX_NUM_ARGVS) && (j< argc) ; j++)
1105 while ((n < (CMDLINE_LENGTH - 1)) && argv[j][i])
1107 com_cmdline[n++] = argv[j][i++];
1110 if (n < (CMDLINE_LENGTH - 1))
1111 com_cmdline[n++] = ' ';
1120 for (com_argc=0 ; (com_argc<MAX_NUM_ARGVS) && (com_argc < argc) ;
1123 largv[com_argc] = argv[com_argc];
1124 if (!strcmp ("-safe", argv[com_argc]))
1130 // force all the safe-mode switches. Note that we reserved extra space in
1131 // case we need to add these, so we don't need an overflow check
1132 for (i=0 ; i<NUM_SAFE_ARGVS ; i++)
1134 largv[com_argc] = safeargvs[i];
1139 largv[com_argc] = argvdummy;
1144 standard_quake = false;
1146 if (COM_CheckParm ("-rogue"))
1149 standard_quake = false;
1152 if (COM_CheckParm ("-hipnotic"))
1155 standard_quake = false;
1158 if (COM_CheckParm ("-nehahra"))
1161 standard_quake = false;
1172 void COM_Init (char *basedir)
1175 byte swaptest[2] = {1,0};
1177 // set the byte swapping variables in a portable manner
1178 if ( *(short *)swaptest == 1)
1180 BigShort = ShortSwap;
1181 LittleShort = ShortNoSwap;
1183 LittleLong = LongNoSwap;
1184 BigFloat = FloatSwap;
1185 LittleFloat = FloatNoSwap;
1189 BigShort = ShortNoSwap;
1190 LittleShort = ShortSwap;
1191 BigLong = LongNoSwap;
1192 LittleLong = LongSwap;
1193 BigFloat = FloatNoSwap;
1194 LittleFloat = FloatSwap;
1198 Cvar_RegisterVariable (®istered);
1199 Cvar_RegisterVariable (&cmdline);
1200 Cmd_AddCommand ("path", COM_Path_f);
1202 COM_InitFilesystem ();
1203 COM_CheckRegistered ();
1211 does a varargs printf into a temp buffer, so I don't need to have
1212 varargs versions of all text functions.
1213 FIXME: make this buffer size safe someday
1216 char *va(char *format, ...)
1219 static char string[1024];
1221 va_start (argptr, format);
1222 vsprintf (string, format,argptr);
1229 /// just for debugging
1230 int memsearch (byte *start, int count, int search)
1234 for (i=0 ; i<count ; i++)
1235 if (start[i] == search)
1241 =============================================================================
1245 =============================================================================
1257 char name[MAX_QPATH];
1258 int filepos, filelen;
1261 typedef struct pack_s
1263 char filename[MAX_OSPATH];
1275 int filepos, filelen;
1285 // LordHavoc: was 2048, increased to 16384 and changed info[MAX_PACK_FILES] to a temporary malloc to avoid stack overflows
1286 #define MAX_FILES_IN_PACK 16384
1288 char com_cachedir[MAX_OSPATH];
1289 char com_gamedir[MAX_OSPATH];
1291 typedef struct searchpath_s
1293 char filename[MAX_OSPATH];
1294 pack_t *pack; // only one of filename / pack will be used
1295 struct searchpath_s *next;
1298 searchpath_t *com_searchpaths;
1306 void COM_Path_f (void)
1310 Con_Printf ("Current search path:\n");
1311 for (s=com_searchpaths ; s ; s=s->next)
1315 Con_Printf ("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
1318 Con_Printf ("%s\n", s->filename);
1326 The filename will be prefixed by the current game directory
1329 void COM_WriteFile (char *filename, void *data, int len)
1332 char name[MAX_OSPATH];
1334 sprintf (name, "%s/%s", com_gamedir, filename);
1336 handle = Sys_FileOpenWrite (name);
1339 Sys_Printf ("COM_WriteFile: failed on %s\n", name);
1343 Sys_Printf ("COM_WriteFile: %s\n", name);
1344 Sys_FileWrite (handle, data, len);
1345 Sys_FileClose (handle);
1353 Only used for CopyFile
1356 void COM_CreatePath (char *path)
1360 for (ofs = path+1 ; *ofs ; ofs++)
1363 { // create the directory
1376 Copies a file over from the net to the local cache, creating any directories
1377 needed. This is for the convenience of developers using ISDN from home.
1380 void COM_CopyFile (char *netpath, char *cachepath)
1383 int remaining, count;
1386 remaining = Sys_FileOpenRead (netpath, &in);
1387 COM_CreatePath (cachepath); // create directories up to the cache file
1388 out = Sys_FileOpenWrite (cachepath);
1392 if (remaining < sizeof(buf))
1395 count = sizeof(buf);
1396 Sys_FileRead (in, buf, count);
1397 Sys_FileWrite (out, buf, count);
1402 Sys_FileClose (out);
1409 Finds the file in the search path.
1410 Sets com_filesize and one of handle or file
1413 int COM_FindFile (char *filename, int *handle, FILE **file, qboolean quiet)
1415 searchpath_t *search;
1416 char netpath[MAX_OSPATH];
1417 char cachepath[MAX_OSPATH];
1420 int findtime, cachetime;
1423 Sys_Error ("COM_FindFile: both handle and file set");
1424 if (!file && !handle)
1425 Sys_Error ("COM_FindFile: neither handle or file set");
1428 // search through the path, one element at a time
1430 search = com_searchpaths;
1432 { // gross hack to use quake 1 progs with quake 2 maps
1433 if (!strcmp(filename, "progs.dat"))
1434 search = search->next;
1437 for ( ; search ; search = search->next)
1439 // is the element a pak file?
1442 // look through all the pak file elements
1444 for (i=0 ; i<pak->numfiles ; i++)
1445 if (!strcmp (pak->files[i].name, filename))
1448 Sys_Printf ("PackFile: %s : %s\n",pak->filename, filename);
1451 *handle = pak->handle;
1452 Sys_FileSeek (pak->handle, pak->files[i].filepos);
1455 { // open a new file on the pakfile
1456 *file = fopen (pak->filename, "rb");
1458 fseek (*file, pak->files[i].filepos, SEEK_SET);
1460 com_filesize = pak->files[i].filelen;
1461 return com_filesize;
1466 // check a file in the directory tree
1467 // if (!static_registered)
1468 // { // if not a registered version, don't ever go beyond base
1469 // if ( strchr (filename, '/') || strchr (filename,'\\'))
1473 sprintf (netpath, "%s/%s",search->filename, filename);
1475 findtime = Sys_FileTime (netpath);
1479 // see if the file needs to be updated in the cache
1480 if (!com_cachedir[0])
1481 strcpy (cachepath, netpath);
1485 if ((strlen(netpath) < 2) || (netpath[1] != ':'))
1486 sprintf (cachepath,"%s%s", com_cachedir, netpath);
1488 sprintf (cachepath,"%s%s", com_cachedir, netpath+2);
1490 sprintf (cachepath,"%s%s", com_cachedir, netpath);
1493 cachetime = Sys_FileTime (cachepath);
1495 if (cachetime < findtime)
1496 COM_CopyFile (netpath, cachepath);
1497 strcpy (netpath, cachepath);
1501 Sys_Printf ("FindFile: %s\n",netpath);
1502 com_filesize = Sys_FileOpenRead (netpath, &i);
1508 *file = fopen (netpath, "rb");
1510 return com_filesize;
1516 Sys_Printf ("FindFile: can't find %s\n", filename);
1531 filename never has a leading slash, but may contain directory walks
1532 returns a handle and a length
1533 it may actually be inside a pak file
1536 int COM_OpenFile (char *filename, int *handle, qboolean quiet)
1538 return COM_FindFile (filename, handle, NULL, quiet);
1545 If the requested file is inside a packfile, a new FILE * will be opened
1549 int COM_FOpenFile (char *filename, FILE **file, qboolean quiet)
1551 return COM_FindFile (filename, NULL, file, quiet);
1558 If it is a pak file handle, don't really close it
1561 void COM_CloseFile (int h)
1565 for (s = com_searchpaths ; s ; s=s->next)
1566 if (s->pack && s->pack->handle == h)
1577 Filename are reletive to the quake directory.
1578 Allways appends a 0 byte.
1581 cache_user_t *loadcache;
1584 byte *COM_LoadFile (char *path, int usehunk, qboolean quiet)
1591 buf = NULL; // quiet compiler warning
1593 // look for it in the filesystem or pack files
1594 len = COM_OpenFile (path, &h, quiet);
1598 // extract the filename base name for hunk tag
1599 COM_FileBase (path, base);
1602 buf = Hunk_AllocName (len+1, base);
1603 else if (usehunk == 2)
1604 buf = Hunk_TempAlloc (len+1);
1605 else if (usehunk == 0)
1606 buf = Z_Malloc (len+1);
1607 else if (usehunk == 3)
1608 buf = Cache_Alloc (loadcache, len+1, base);
1609 else if (usehunk == 4)
1611 if (len+1 > loadsize)
1612 buf = Hunk_TempAlloc (len+1);
1616 else if (usehunk == 5)
1617 buf = malloc (len+1);
1619 Sys_Error ("COM_LoadFile: bad usehunk");
1622 Sys_Error ("COM_LoadFile: not enough space for %s", path);
1624 ((byte *)buf)[len] = 0;
1626 Sys_FileRead (h, buf, len);
1632 byte *COM_LoadHunkFile (char *path, qboolean quiet)
1634 return COM_LoadFile (path, 1, quiet);
1637 byte *COM_LoadTempFile (char *path, qboolean quiet)
1639 return COM_LoadFile (path, 2, quiet);
1642 // LordHavoc: returns malloc'd memory
1643 byte *COM_LoadMallocFile (char *path, qboolean quiet)
1645 return COM_LoadFile (path, 5, quiet);
1648 void COM_LoadCacheFile (char *path, struct cache_user_s *cu, qboolean quiet)
1651 COM_LoadFile (path, 3, quiet);
1654 // uses temp hunk if larger than bufsize
1655 byte *COM_LoadStackFile (char *path, void *buffer, int bufsize, qboolean quiet)
1659 loadbuf = (byte *)buffer;
1661 buf = COM_LoadFile (path, 4, quiet);
1670 Takes an explicit (not game tree related) path to a pak file.
1672 Loads the header and directory, adding the files at the beginning
1673 of the list so they override previous pack files.
1676 pack_t *COM_LoadPackFile (char *packfile)
1678 dpackheader_t header;
1680 packfile_t *newfiles;
1684 // LordHavoc: changed from stack array to temporary malloc, allowing huge pack directories
1688 if (Sys_FileOpenRead (packfile, &packhandle) == -1)
1690 // Con_Printf ("Couldn't open %s\n", packfile);
1693 Sys_FileRead (packhandle, (void *)&header, sizeof(header));
1694 if (header.id[0] != 'P' || header.id[1] != 'A'
1695 || header.id[2] != 'C' || header.id[3] != 'K')
1696 Sys_Error ("%s is not a packfile", packfile);
1697 header.dirofs = LittleLong (header.dirofs);
1698 header.dirlen = LittleLong (header.dirlen);
1700 numpackfiles = header.dirlen / sizeof(dpackfile_t);
1702 if (numpackfiles > MAX_FILES_IN_PACK)
1703 Sys_Error ("%s has %i files", packfile, numpackfiles);
1705 if (numpackfiles != PAK0_COUNT)
1706 com_modified = true; // not the original file
1708 newfiles = Hunk_AllocName (numpackfiles * sizeof(packfile_t), "packfile");
1710 info = malloc(sizeof(*info)*MAX_FILES_IN_PACK);
1711 Sys_FileSeek (packhandle, header.dirofs);
1712 Sys_FileRead (packhandle, (void *)info, header.dirlen);
1714 // crc the directory to check for modifications
1716 // LordHavoc: speedup
1717 CRC_ProcessBytes(&crc, (byte *)info, header.dirlen);
1718 // for (i=0 ; i<header.dirlen ; i++)
1719 // CRC_ProcessByte (&crc, ((byte *)info)[i]);
1720 if (crc != PAK0_CRC)
1721 com_modified = true;
1723 // parse the directory
1724 for (i=0 ; i<numpackfiles ; i++)
1726 strcpy (newfiles[i].name, info[i].name);
1727 newfiles[i].filepos = LittleLong(info[i].filepos);
1728 newfiles[i].filelen = LittleLong(info[i].filelen);
1732 pack = Hunk_Alloc (sizeof (pack_t));
1733 strcpy (pack->filename, packfile);
1734 pack->handle = packhandle;
1735 pack->numfiles = numpackfiles;
1736 pack->files = newfiles;
1738 Con_Printf ("Added packfile %s (%i files)\n", packfile, numpackfiles);
1745 COM_AddGameDirectory
1747 Sets com_gamedir, adds the directory to the head of the path,
1748 then loads and adds pak1.pak pak2.pak ...
1751 void COM_AddGameDirectory (char *dir)
1754 searchpath_t *search;
1756 char pakfile[MAX_OSPATH];
1758 strcpy (com_gamedir, dir);
1761 // add the directory to the search path
1763 search = Hunk_Alloc (sizeof(searchpath_t));
1764 strcpy (search->filename, dir);
1765 search->next = com_searchpaths;
1766 com_searchpaths = search;
1769 // add any pak files in the format pak0.pak pak1.pak, ...
1773 sprintf (pakfile, "%s/pak%i.pak", dir, i);
1774 pak = COM_LoadPackFile (pakfile);
1777 search = Hunk_Alloc (sizeof(searchpath_t));
1779 search->next = com_searchpaths;
1780 com_searchpaths = search;
1784 // add the contents of the parms.txt file to the end of the command line
1794 void COM_InitFilesystem (void)
1797 char basedir[MAX_OSPATH];
1798 searchpath_t *search;
1802 // Overrides the system supplied base directory (under GAMENAME)
1804 i = COM_CheckParm ("-basedir");
1805 if (i && i < com_argc-1)
1806 strcpy (basedir, com_argv[i+1]);
1808 strcpy (basedir, host_parms.basedir);
1810 j = strlen (basedir);
1814 if ((basedir[j-1] == '\\') || (basedir[j-1] == '/'))
1820 // Overrides the system supplied cache directory (NULL or /qcache)
1821 // -cachedir - will disable caching.
1823 i = COM_CheckParm ("-cachedir");
1824 if (i && i < com_argc-1)
1826 if (com_argv[i+1][0] == '-')
1827 com_cachedir[0] = 0;
1829 strcpy (com_cachedir, com_argv[i+1]);
1831 else if (host_parms.cachedir)
1832 strcpy (com_cachedir, host_parms.cachedir);
1834 com_cachedir[0] = 0;
1837 // start up with GAMENAME by default (id1)
1839 COM_AddGameDirectory (va("%s/"GAMENAME, basedir) );
1842 COM_AddGameDirectory (va("%s/nehahra", basedir) );
1844 if (COM_CheckParm ("-rogue"))
1845 COM_AddGameDirectory (va("%s/rogue", basedir) );
1846 if (COM_CheckParm ("-hipnotic"))
1847 COM_AddGameDirectory (va("%s/hipnotic", basedir) );
1848 if (COM_CheckParm ("-nehahra"))
1849 COM_AddGameDirectory (va("%s/nehahra", basedir) );
1854 // Adds basedir/gamedir as an override game
1856 i = COM_CheckParm ("-game");
1857 if (i && i < com_argc-1)
1859 com_modified = true;
1860 COM_AddGameDirectory (va("%s/%s", basedir, com_argv[i+1]));
1864 // -path <dir or packfile> [<dir or packfile>] ...
1865 // Fully specifies the exact serach path, overriding the generated one
1867 i = COM_CheckParm ("-path");
1870 com_modified = true;
1871 com_searchpaths = NULL;
1872 while (++i < com_argc)
1874 if (!com_argv[i] || com_argv[i][0] == '+' || com_argv[i][0] == '-')
1877 search = Hunk_Alloc (sizeof(searchpath_t));
1878 if ( !strcmp(COM_FileExtension(com_argv[i]), "pak") )
1880 search->pack = COM_LoadPackFile (com_argv[i]);
1882 Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
1885 strcpy (search->filename, com_argv[i]);
1886 search->next = com_searchpaths;
1887 com_searchpaths = search;
1891 if (COM_CheckParm ("-proghack"))
1895 int COM_FileExists(char *filename)
1897 searchpath_t *search;
1898 char netpath[MAX_OSPATH];
1903 for (search = com_searchpaths;search;search = search->next)
1908 for (i = 0;i < pak->numfiles;i++)
1909 if (!strcmp (pak->files[i].name, filename))
1914 sprintf (netpath, "%s/%s",search->filename, filename);
1915 findtime = Sys_FileTime (netpath);