]> icculus.org git repositories - divverent/darkplaces.git/blob - common.c
copyentity builtin added
[divverent/darkplaces.git] / common.c
1 /*
2 Copyright (C) 1996-1997 Id Software, Inc.
3
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.
8
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.  
12
13 See the GNU General Public License for more details.
14
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.
18
19 */
20 // common.c -- misc functions used in client and server
21
22 #include "quakedef.h"
23
24 #define NUM_SAFE_ARGVS  7
25
26 static char     *largv[MAX_NUM_ARGVS + NUM_SAFE_ARGVS + 1];
27 static char     *argvdummy = " ";
28
29 static char     *safeargvs[NUM_SAFE_ARGVS] =
30         {"-stdvid", "-nolan", "-nosound", "-nocdaudio", "-nojoy", "-nomouse", "-dibonly"};
31
32 cvar_t  registered = {"registered","0"};
33 cvar_t  cmdline = {"cmdline","0", false, true};
34
35 qboolean        com_modified;   // set true if using non-id files
36
37 qboolean                proghack;
38
39 int             static_registered = 1;  // only for startup check, then set
40
41 qboolean                msg_suppress_1 = 0;
42
43 void COM_InitFilesystem (void);
44
45 // if a packfile directory differs from this, it is assumed to be hacked
46 #define PAK0_COUNT              339
47 #define PAK0_CRC                32981
48
49 char    com_token[1024];
50 int             com_argc;
51 char    **com_argv;
52
53 #define CMDLINE_LENGTH  256
54 char    com_cmdline[CMDLINE_LENGTH];
55
56 qboolean                standard_quake = true, rogue = false, hipnotic = false, nehahra = false;
57
58 // this graphic needs to be in the pak file to use registered features
59 unsigned short pop[] =
60 {
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
77 };
78
79 /*
80
81
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.
83
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.
86
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.
88
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.
92
93
94
95 FIXME:
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.
97         
98 */
99
100 //============================================================================
101
102
103 // ClearLink is used for new headnodes
104 void ClearLink (link_t *l)
105 {
106         l->prev = l->next = l;
107 }
108
109 void RemoveLink (link_t *l)
110 {
111         l->next->prev = l->prev;
112         l->prev->next = l->next;
113 }
114
115 void InsertLinkBefore (link_t *l, link_t *before)
116 {
117         l->next = before;
118         l->prev = before->prev;
119         l->prev->next = l;
120         l->next->prev = l;
121 }
122 void InsertLinkAfter (link_t *l, link_t *after)
123 {
124         l->next = after->next;
125         l->prev = after;
126         l->prev->next = l;
127         l->next->prev = l;
128 }
129
130 /*
131 ============================================================================
132
133                                         LIBRARY REPLACEMENT FUNCTIONS
134
135 ============================================================================
136 */
137
138 /*
139 void Q_memset (void *dest, int fill, int count)
140 {
141         int             i;
142         
143         if ( (((long)dest | count) & 3) == 0)
144         {
145                 count >>= 2;
146                 fill = fill | (fill<<8) | (fill<<16) | (fill<<24);
147                 for (i=0 ; i<count ; i++)
148                         ((int *)dest)[i] = fill;
149         }
150         else
151                 for (i=0 ; i<count ; i++)
152                         ((byte *)dest)[i] = fill;
153 }
154
155 void Q_memcpy (void *dest, void *src, int count)
156 {
157         int             i;
158         
159         if (( ( (long)dest | (long)src | count) & 3) == 0 )
160         {
161                 count>>=2;
162                 for (i=0 ; i<count ; i++)
163                         ((int *)dest)[i] = ((int *)src)[i];
164         }
165         else
166                 for (i=0 ; i<count ; i++)
167                         ((byte *)dest)[i] = ((byte *)src)[i];
168 }
169
170 int Q_memcmp (void *m1, void *m2, int count)
171 {
172         while(count)
173         {
174                 count--;
175                 if (((byte *)m1)[count] != ((byte *)m2)[count])
176                         return -1;
177         }
178         return 0;
179 }
180
181 void Q_strcpy (char *dest, char *src)
182 {
183         while (*src)
184         {
185                 *dest++ = *src++;
186         }
187         *dest++ = 0;
188 }
189
190 void Q_strncpy (char *dest, char *src, int count)
191 {
192         while (*src && count--)
193         {
194                 *dest++ = *src++;
195         }
196         if (count)
197                 *dest++ = 0;
198 }
199
200 int Q_strlen (char *str)
201 {
202         int             count;
203         
204         count = 0;
205         while (str[count])
206                 count++;
207
208         return count;
209 }
210
211 char *Q_strrchr(char *s, char c)
212 {
213     int len = Q_strlen(s);
214     s += len;
215     while (len--)
216         if (*--s == c) return s;
217     return 0;
218 }
219
220 void Q_strcat (char *dest, char *src)
221 {
222         dest += Q_strlen(dest);
223         Q_strcpy (dest, src);
224 }
225
226 int Q_strcmp (char *s1, char *s2)
227 {
228         while (1)
229         {
230                 if (*s1 != *s2)
231                         return -1;              // strings not equal    
232                 if (!*s1)
233                         return 0;               // strings are equal
234                 s1++;
235                 s2++;
236         }
237         
238         return -1;
239 }
240
241 int Q_strncmp (char *s1, char *s2, int count)
242 {
243         while (1)
244         {
245                 if (!count--)
246                         return 0;
247                 if (*s1 != *s2)
248                         return -1;              // strings not equal    
249                 if (!*s1)
250                         return 0;               // strings are equal
251                 s1++;
252                 s2++;
253         }
254         
255         return -1;
256 }
257 */
258 int Q_strncasecmp (char *s1, char *s2, int n)
259 {
260         int             c1, c2;
261         
262         while (1)
263         {
264                 c1 = *s1++;
265                 c2 = *s2++;
266
267                 if (!n--)
268                         return 0;               // strings are equal until end point
269                 
270                 if (c1 != c2)
271                 {
272                         if (c1 >= 'a' && c1 <= 'z')
273                                 c1 -= ('a' - 'A');
274                         if (c2 >= 'a' && c2 <= 'z')
275                                 c2 -= ('a' - 'A');
276                         if (c1 != c2)
277                                 return -1;              // strings not equal
278                 }
279                 if (!c1)
280                         return 0;               // strings are equal
281 //              s1++;
282 //              s2++;
283         }
284         
285         return -1;
286 }
287
288 int Q_strcasecmp (char *s1, char *s2)
289 {
290         return Q_strncasecmp (s1, s2, 99999);
291 }
292 /*
293 int Q_atoi (char *str)
294 {
295         int             val;
296         int             sign;
297         int             c;
298         
299         if (*str == '-')
300         {
301                 sign = -1;
302                 str++;
303         }
304         else
305                 sign = 1;
306                 
307         val = 0;
308
309 //
310 // check for hex
311 //
312         if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
313         {
314                 str += 2;
315                 while (1)
316                 {
317                         c = *str++;
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;
324                         else
325                                 return val*sign;
326                 }
327         }
328         
329 //
330 // check for character
331 //
332         if (str[0] == '\'')
333         {
334                 return sign * str[1];
335         }
336         
337 //
338 // assume decimal
339 //
340         while (1)
341         {
342                 c = *str++;
343                 if (c <'0' || c > '9')
344                         return val*sign;
345                 val = val*10 + c - '0';
346         }
347         
348         return 0;
349 }
350
351
352 float Q_atof (char *str)
353 {
354         double                  val;
355         int             sign;
356         int             c;
357         int             decimal, total;
358         
359         if (*str == '-')
360         {
361                 sign = -1;
362                 str++;
363         }
364         else
365                 sign = 1;
366                 
367         val = 0;
368
369 //
370 // check for hex
371 //
372         if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X') )
373         {
374                 str += 2;
375                 while (1)
376                 {
377                         c = *str++;
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;
384                         else
385                                 return val*sign;
386                 }
387         }
388         
389 //
390 // check for character
391 //
392         if (str[0] == '\'')
393         {
394                 return sign * str[1];
395         }
396         
397 //
398 // assume decimal
399 //
400         decimal = -1;
401         total = 0;
402         while (1)
403         {
404                 c = *str++;
405                 if (c == '.')
406                 {
407                         decimal = total;
408                         continue;
409                 }
410                 if (c <'0' || c > '9')
411                         break;
412                 val = val*10 + c - '0';
413                 total++;
414         }
415
416         if (decimal == -1)
417                 return val*sign;
418         while (total > decimal)
419         {
420                 val /= 10;
421                 total--;
422         }
423         
424         return val*sign;
425 }
426 */
427
428 /*
429 ============================================================================
430
431                                         BYTE ORDER FUNCTIONS
432
433 ============================================================================
434 */
435
436 #ifndef WIN32
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);
443 #endif
444
445 short   ShortSwap (short l)
446 {
447         byte    b1,b2;
448
449         b1 = l&255;
450         b2 = (l>>8)&255;
451
452         return (b1<<8) + b2;
453 }
454
455 short   ShortNoSwap (short l)
456 {
457         return l;
458 }
459
460 int    LongSwap (int l)
461 {
462         byte    b1,b2,b3,b4;
463
464         b1 = l&255;
465         b2 = (l>>8)&255;
466         b3 = (l>>16)&255;
467         b4 = (l>>24)&255;
468
469         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
470 }
471
472 int     LongNoSwap (int l)
473 {
474         return l;
475 }
476
477 float FloatSwap (float f)
478 {
479         union
480         {
481                 float   f;
482                 byte    b[4];
483         } dat1, dat2;
484         
485         
486         dat1.f = 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];
491         return dat2.f;
492 }
493
494 float FloatNoSwap (float f)
495 {
496         return f;
497 }
498
499 /*
500 ==============================================================================
501
502                         MESSAGE IO FUNCTIONS
503
504 Handles byte ordering and avoids alignment errors
505 ==============================================================================
506 */
507
508 //
509 // writing functions
510 //
511
512 void MSG_WriteChar (sizebuf_t *sb, int c)
513 {
514         byte    *buf;
515         
516 //#ifdef PARANOID
517 //      if (c < -128 || c > 127)
518 //              Sys_Error ("MSG_WriteChar: range error");
519 //#endif
520
521         buf = SZ_GetSpace (sb, 1);
522         buf[0] = c;
523 }
524
525 void MSG_WriteByte (sizebuf_t *sb, int c)
526 {
527         byte    *buf;
528         
529 //#ifdef PARANOID
530 //      if (c < 0 || c > 255)
531 //              Sys_Error ("MSG_WriteByte: range error");
532 //#endif
533
534         buf = SZ_GetSpace (sb, 1);
535         buf[0] = c;
536 }
537
538 void MSG_WriteShort (sizebuf_t *sb, int c)
539 {
540         byte    *buf;
541         
542 //#ifdef PARANOID
543 //      if (c < ((short)0x8000) || c > (short)0x7fff)
544 //              Sys_Error ("MSG_WriteShort: range error");
545 //#endif
546
547         buf = SZ_GetSpace (sb, 2);
548         buf[0] = c&0xff;
549         buf[1] = c>>8;
550 }
551
552 void MSG_WriteLong (sizebuf_t *sb, int c)
553 {
554         byte    *buf;
555         
556         buf = SZ_GetSpace (sb, 4);
557         buf[0] = c&0xff;
558         buf[1] = (c>>8)&0xff;
559         buf[2] = (c>>16)&0xff;
560         buf[3] = c>>24;
561 }
562
563 void MSG_WriteFloat (sizebuf_t *sb, float f)
564 {
565         union
566         {
567                 float   f;
568                 int     l;
569         } dat;
570         
571         
572         dat.f = f;
573         dat.l = LittleLong (dat.l);
574         
575         SZ_Write (sb, &dat.l, 4);
576 }
577
578 void MSG_WriteString (sizebuf_t *sb, char *s)
579 {
580         if (!s)
581                 SZ_Write (sb, "", 1);
582         else
583                 SZ_Write (sb, s, strlen(s)+1);
584 }
585
586 void MSG_WriteCoord (sizebuf_t *sb, float f)
587 {
588         MSG_WriteShort (sb, (int)(f*8));
589 }
590
591 void MSG_WriteAngle (sizebuf_t *sb, float f)
592 {
593         MSG_WriteByte (sb, ((int)f*256/360) & 255);
594 }
595
596 //
597 // reading functions
598 //
599 int                     msg_readcount;
600 qboolean        msg_badread;
601
602 void MSG_BeginReading (void)
603 {
604         msg_readcount = 0;
605         msg_badread = false;
606 }
607
608 /*
609 // returns -1 and sets msg_badread if no more characters are available
610 int MSG_ReadChar (void)
611 {
612         int     c;
613         
614         // LordHavoc: minor optimization
615         if (msg_readcount >= net_message.cursize)
616 //      if (msg_readcount+1 > net_message.cursize)
617         {
618                 msg_badread = true;
619                 return -1;
620         }
621                 
622         c = (signed char)net_message.data[msg_readcount];
623         msg_readcount++;
624         
625         return c;
626 }
627
628 int MSG_ReadByte (void)
629 {
630         int     c;
631         
632         // LordHavoc: minor optimization
633         if (msg_readcount >= net_message.cursize)
634 //      if (msg_readcount+1 > net_message.cursize)
635         {
636                 msg_badread = true;
637                 return -1;
638         }
639                 
640         c = (unsigned char)net_message.data[msg_readcount];
641         msg_readcount++;
642         
643         return c;
644 }
645 */
646
647 int MSG_ReadShort (void)
648 {
649         int     c;
650         
651         if (msg_readcount+2 > net_message.cursize)
652         {
653                 msg_badread = true;
654                 return -1;
655         }
656                 
657         c = (short)(net_message.data[msg_readcount]
658         + (net_message.data[msg_readcount+1]<<8));
659         
660         msg_readcount += 2;
661         
662         return c;
663 }
664
665 int MSG_ReadLong (void)
666 {
667         int     c;
668         
669         if (msg_readcount+4 > net_message.cursize)
670         {
671                 msg_badread = true;
672                 return -1;
673         }
674                 
675         c = net_message.data[msg_readcount]
676         + (net_message.data[msg_readcount+1]<<8)
677         + (net_message.data[msg_readcount+2]<<16)
678         + (net_message.data[msg_readcount+3]<<24);
679         
680         msg_readcount += 4;
681         
682         return c;
683 }
684
685 float MSG_ReadFloat (void)
686 {
687         union
688         {
689                 byte    b[4];
690                 float   f;
691                 int     l;
692         } dat;
693         
694         dat.b[0] =      net_message.data[msg_readcount];
695         dat.b[1] =      net_message.data[msg_readcount+1];
696         dat.b[2] =      net_message.data[msg_readcount+2];
697         dat.b[3] =      net_message.data[msg_readcount+3];
698         msg_readcount += 4;
699         
700         dat.l = LittleLong (dat.l);
701
702         return dat.f;   
703 }
704
705 char *MSG_ReadString (void)
706 {
707         static char     string[2048];
708         int             l,c;
709         
710         l = 0;
711         do
712         {
713                 c = MSG_ReadChar ();
714                 if (c == -1 || c == 0)
715                         break;
716                 string[l] = c;
717                 l++;
718         } while (l < sizeof(string)-1);
719         
720         string[l] = 0;
721         
722         return string;
723 }
724
725 /*
726 float MSG_ReadCoord (void)
727 {
728         return MSG_ReadShort() * (1.0f/8.0f);
729 }
730
731 float MSG_ReadAngle (void)
732 {
733         return MSG_ReadChar() * (360.0f/256.0f);
734 }
735 */
736
737
738
739 //===========================================================================
740
741 void SZ_Alloc (sizebuf_t *buf, int startsize)
742 {
743         if (startsize < 256)
744                 startsize = 256;
745         buf->data = Hunk_AllocName (startsize, "sizebuf");
746         buf->maxsize = startsize;
747         buf->cursize = 0;
748 }
749
750
751 void SZ_Free (sizebuf_t *buf)
752 {
753 //      Z_Free (buf->data);
754 //      buf->data = NULL;
755 //      buf->maxsize = 0;
756         buf->cursize = 0;
757 }
758
759 void SZ_Clear (sizebuf_t *buf)
760 {
761         buf->cursize = 0;
762 }
763
764 void *SZ_GetSpace (sizebuf_t *buf, int length)
765 {
766         void    *data;
767         
768         if (buf->cursize + length > buf->maxsize)
769         {
770                 if (!buf->allowoverflow)
771                         Host_Error ("SZ_GetSpace: overflow without allowoverflow set - use -zone on the commandline for more zone memory, default: 512k (quake original default was 48k)");
772                 
773                 if (length > buf->maxsize)
774                         Host_Error ("SZ_GetSpace: %i is > full buffer size", length);
775                         
776                 buf->overflowed = true;
777                 Con_Printf ("SZ_GetSpace: overflow");
778                 SZ_Clear (buf); 
779         }
780
781         data = buf->data + buf->cursize;
782         buf->cursize += length;
783         
784         return data;
785 }
786
787 void SZ_Write (sizebuf_t *buf, void *data, int length)
788 {
789         memcpy (SZ_GetSpace(buf,length),data,length);         
790 }
791
792 void SZ_Print (sizebuf_t *buf, char *data)
793 {
794         int             len;
795         
796         len = strlen(data)+1;
797
798 // byte * cast to keep VC++ happy
799         if (buf->data[buf->cursize-1])
800                 memcpy ((byte *)SZ_GetSpace(buf, len),data,len); // no trailing 0
801         else
802                 memcpy ((byte *)SZ_GetSpace(buf, len-1)-1,data,len); // write over trailing 0
803 }
804
805
806 //============================================================================
807
808
809 /*
810 ============
811 COM_SkipPath
812 ============
813 */
814 char *COM_SkipPath (char *pathname)
815 {
816         char    *last;
817         
818         last = pathname;
819         while (*pathname)
820         {
821                 if (*pathname=='/')
822                         last = pathname+1;
823                 pathname++;
824         }
825         return last;
826 }
827
828 /*
829 ============
830 COM_StripExtension
831 ============
832 */
833 void COM_StripExtension (char *in, char *out)
834 {
835         while (*in && *in != '.')
836                 *out++ = *in++;
837         *out = 0;
838 }
839
840 /*
841 ============
842 COM_FileExtension
843 ============
844 */
845 char *COM_FileExtension (char *in)
846 {
847         static char exten[8];
848         int             i;
849
850         while (*in && *in != '.')
851                 in++;
852         if (!*in)
853                 return "";
854         in++;
855         for (i=0 ; i<7 && *in ; i++,in++)
856                 exten[i] = *in;
857         exten[i] = 0;
858         return exten;
859 }
860
861 /*
862 ============
863 COM_FileBase
864 ============
865 */
866 void COM_FileBase (char *in, char *out)
867 {
868         char *s, *s2;
869         
870         s = in + strlen(in) - 1;
871         
872         while (s != in && *s != '.')
873                 s--;
874         
875         for (s2 = s ; *s2 && *s2 != '/' ; s2--)
876         ;
877         
878         if (s-s2 < 2)
879                 strcpy (out,"?model?");
880         else
881         {
882                 s--;
883                 strncpy (out,s2+1, s-s2);
884                 out[s-s2] = 0;
885         }
886 }
887
888
889 /*
890 ==================
891 COM_DefaultExtension
892 ==================
893 */
894 void COM_DefaultExtension (char *path, char *extension)
895 {
896         char    *src;
897 //
898 // if path doesn't have a .EXT, append extension
899 // (extension should include the .)
900 //
901         src = path + strlen(path) - 1;
902
903         while (*src != '/' && src != path)
904         {
905                 if (*src == '.')
906                         return;                 // it has an extension
907                 src--;
908         }
909
910         strcat (path, extension);
911 }
912
913
914 /*
915 ==============
916 COM_Parse
917
918 Parse a token out of a string
919 ==============
920 */
921 char *COM_Parse (char *data)
922 {
923         int             c;
924         int             len;
925         
926         len = 0;
927         com_token[0] = 0;
928         
929         if (!data)
930                 return NULL;
931                 
932 // skip whitespace
933 skipwhite:
934         while ( (c = *data) <= ' ')
935         {
936                 if (c == 0)
937                         return NULL;                    // end of file;
938                 data++;
939         }
940         
941 // skip // comments
942         if (c=='/' && data[1] == '/')
943         {
944                 while (*data && *data != '\n')
945                         data++;
946                 goto skipwhite;
947         }
948         
949
950 // handle quoted strings specially
951         if (c == '\"')
952         {
953                 data++;
954                 while (1)
955                 {
956                         c = *data++;
957                         if (c=='\"' || !c)
958                         {
959                                 com_token[len] = 0;
960                                 return data;
961                         }
962                         com_token[len] = c;
963                         len++;
964                 }
965         }
966
967 // parse single characters
968         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
969         {
970                 com_token[len] = c;
971                 len++;
972                 com_token[len] = 0;
973                 return data+1;
974         }
975
976 // parse a regular word
977         do
978         {
979                 com_token[len] = c;
980                 data++;
981                 len++;
982                 c = *data;
983         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
984                         break;
985         } while (c>32);
986         
987         com_token[len] = 0;
988         return data;
989 }
990
991
992 /*
993 ================
994 COM_CheckParm
995
996 Returns the position (1 to argc-1) in the program's argument list
997 where the given parameter apears, or 0 if not present
998 ================
999 */
1000 int COM_CheckParm (char *parm)
1001 {
1002         int             i;
1003         
1004         for (i=1 ; i<com_argc ; i++)
1005         {
1006                 if (!com_argv[i])
1007                         continue;               // NEXTSTEP sometimes clears appkit vars.
1008                 if (!strcmp (parm,com_argv[i]))
1009                         return i;
1010         }
1011                 
1012         return 0;
1013 }
1014
1015 /*
1016 ================
1017 COM_CheckRegistered
1018
1019 Looks for the pop.txt file and verifies it.
1020 Sets the "registered" cvar.
1021 Immediately exits out if an alternate game was attempted to be started without
1022 being registered.
1023 ================
1024 */
1025 void COM_CheckRegistered (void)
1026 {
1027         int             h;
1028         unsigned short  check[128];
1029         int                     i;
1030
1031         Cvar_Set ("cmdline", com_cmdline);
1032
1033         COM_OpenFile("gfx/pop.lmp", &h, false);
1034         static_registered = 0;
1035
1036         if (h == -1)
1037         {
1038                 if (com_modified)
1039                         Con_Printf ("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
1040                 else
1041                         Con_Printf ("Playing shareware version.\n");
1042 //#if WINDED
1043 //      Sys_Error ("This dedicated server requires a full registered copy of Quake");
1044 //#endif
1045 //              Con_Printf ("Playing shareware version.\n");
1046 //              if (com_modified)
1047 //                      Sys_Error ("You must have the registered version to use modified games");
1048                 return;
1049         }
1050
1051         Sys_FileRead (h, check, sizeof(check));
1052         COM_CloseFile (h);
1053         
1054         for (i=0 ; i<128 ; i++)
1055                 if (pop[i] != (unsigned short)BigShort (check[i]))
1056                         Sys_Error ("Corrupted data file.");
1057         
1058 //      Cvar_Set ("cmdline", com_cmdline);
1059         Cvar_Set ("registered", "1");
1060         static_registered = 1;
1061         Con_Printf ("Playing registered version.\n");
1062 }
1063
1064
1065 void COM_Path_f (void);
1066
1067
1068 /*
1069 ================
1070 COM_InitArgv
1071 ================
1072 */
1073 void COM_InitArgv (int argc, char **argv)
1074 {
1075         qboolean        safe;
1076         int             i, j, n;
1077
1078 // reconstitute the command line for the cmdline externally visible cvar
1079         n = 0;
1080
1081         for (j=0 ; (j<MAX_NUM_ARGVS) && (j< argc) ; j++)
1082         {
1083                 i = 0;
1084
1085                 while ((n < (CMDLINE_LENGTH - 1)) && argv[j][i])
1086                 {
1087                         com_cmdline[n++] = argv[j][i++];
1088                 }
1089
1090                 if (n < (CMDLINE_LENGTH - 1))
1091                         com_cmdline[n++] = ' ';
1092                 else
1093                         break;
1094         }
1095
1096         com_cmdline[n] = 0;
1097
1098         safe = false;
1099
1100         for (com_argc=0 ; (com_argc<MAX_NUM_ARGVS) && (com_argc < argc) ;
1101                  com_argc++)
1102         {
1103                 largv[com_argc] = argv[com_argc];
1104                 if (!strcmp ("-safe", argv[com_argc]))
1105                         safe = true;
1106         }
1107
1108         if (safe)
1109         {
1110         // force all the safe-mode switches. Note that we reserved extra space in
1111         // case we need to add these, so we don't need an overflow check
1112                 for (i=0 ; i<NUM_SAFE_ARGVS ; i++)
1113                 {
1114                         largv[com_argc] = safeargvs[i];
1115                         com_argc++;
1116                 }
1117         }
1118
1119         largv[com_argc] = argvdummy;
1120         com_argv = largv;
1121
1122 #ifdef NEHAHRA
1123         nehahra = true;
1124         standard_quake = false;
1125 #else
1126         if (COM_CheckParm ("-rogue"))
1127         {
1128                 rogue = true;
1129                 standard_quake = false;
1130         }
1131
1132         if (COM_CheckParm ("-hipnotic"))
1133         {
1134                 hipnotic = true;
1135                 standard_quake = false;
1136         }
1137
1138         if (COM_CheckParm ("-nehahra"))
1139         {
1140                 nehahra = true;
1141                 standard_quake = false;
1142         }
1143 #endif
1144 }
1145
1146
1147 /*
1148 ================
1149 COM_Init
1150 ================
1151 */
1152 void COM_Init (char *basedir)
1153 {
1154 #ifndef WIN32
1155         byte    swaptest[2] = {1,0};
1156
1157 // set the byte swapping variables in a portable manner 
1158         if ( *(short *)swaptest == 1)
1159         {
1160                 BigShort = ShortSwap;
1161                 LittleShort = ShortNoSwap;
1162                 BigLong = LongSwap;
1163                 LittleLong = LongNoSwap;
1164                 BigFloat = FloatSwap;
1165                 LittleFloat = FloatNoSwap;
1166         }
1167         else
1168         {
1169                 BigShort = ShortNoSwap;
1170                 LittleShort = ShortSwap;
1171                 BigLong = LongNoSwap;
1172                 LittleLong = LongSwap;
1173                 BigFloat = FloatNoSwap;
1174                 LittleFloat = FloatSwap;
1175         }
1176 #endif
1177
1178         Cvar_RegisterVariable (&registered);
1179         Cvar_RegisterVariable (&cmdline);
1180         Cmd_AddCommand ("path", COM_Path_f);
1181
1182         COM_InitFilesystem ();
1183         COM_CheckRegistered ();
1184 }
1185
1186
1187 /*
1188 ============
1189 va
1190
1191 does a varargs printf into a temp buffer, so I don't need to have
1192 varargs versions of all text functions.
1193 FIXME: make this buffer size safe someday
1194 ============
1195 */
1196 char    *va(char *format, ...)
1197 {
1198         va_list         argptr;
1199         static char             string[1024];
1200         
1201         va_start (argptr, format);
1202         vsprintf (string, format,argptr);
1203         va_end (argptr);
1204
1205         return string;  
1206 }
1207
1208
1209 /// just for debugging
1210 int     memsearch (byte *start, int count, int search)
1211 {
1212         int             i;
1213         
1214         for (i=0 ; i<count ; i++)
1215                 if (start[i] == search)
1216                         return i;
1217         return -1;
1218 }
1219
1220 /*
1221 =============================================================================
1222
1223 QUAKE FILESYSTEM
1224
1225 =============================================================================
1226 */
1227
1228 int     com_filesize;
1229
1230
1231 //
1232 // in memory
1233 //
1234
1235 typedef struct
1236 {
1237         char    name[MAX_QPATH];
1238         int             filepos, filelen;
1239 } packfile_t;
1240
1241 typedef struct pack_s
1242 {
1243         char    filename[MAX_OSPATH];
1244         int             handle;
1245         int             numfiles;
1246         packfile_t      *files;
1247 } pack_t;
1248
1249 //
1250 // on disk
1251 //
1252 typedef struct
1253 {
1254         char    name[56];
1255         int             filepos, filelen;
1256 } dpackfile_t;
1257
1258 typedef struct
1259 {
1260         char    id[4];
1261         int             dirofs;
1262         int             dirlen;
1263 } dpackheader_t;
1264
1265 #define MAX_FILES_IN_PACK       2048
1266
1267 char    com_cachedir[MAX_OSPATH];
1268 char    com_gamedir[MAX_OSPATH];
1269
1270 typedef struct searchpath_s
1271 {
1272         char    filename[MAX_OSPATH];
1273         pack_t  *pack;          // only one of filename / pack will be used
1274         struct searchpath_s *next;
1275 } searchpath_t;
1276
1277 searchpath_t    *com_searchpaths;
1278
1279 /*
1280 ============
1281 COM_Path_f
1282
1283 ============
1284 */
1285 void COM_Path_f (void)
1286 {
1287         searchpath_t    *s;
1288         
1289         Con_Printf ("Current search path:\n");
1290         for (s=com_searchpaths ; s ; s=s->next)
1291         {
1292                 if (s->pack)
1293                 {
1294                         Con_Printf ("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
1295                 }
1296                 else
1297                         Con_Printf ("%s\n", s->filename);
1298         }
1299 }
1300
1301 /*
1302 ============
1303 COM_WriteFile
1304
1305 The filename will be prefixed by the current game directory
1306 ============
1307 */
1308 void COM_WriteFile (char *filename, void *data, int len)
1309 {
1310         int             handle;
1311         char    name[MAX_OSPATH];
1312         
1313         sprintf (name, "%s/%s", com_gamedir, filename);
1314
1315         handle = Sys_FileOpenWrite (name);
1316         if (handle == -1)
1317         {
1318                 Sys_Printf ("COM_WriteFile: failed on %s\n", name);
1319                 return;
1320         }
1321         
1322         Sys_Printf ("COM_WriteFile: %s\n", name);
1323         Sys_FileWrite (handle, data, len);
1324         Sys_FileClose (handle);
1325 }
1326
1327
1328 /*
1329 ============
1330 COM_CreatePath
1331
1332 Only used for CopyFile
1333 ============
1334 */
1335 void    COM_CreatePath (char *path)
1336 {
1337         char    *ofs;
1338         
1339         for (ofs = path+1 ; *ofs ; ofs++)
1340         {
1341                 if (*ofs == '/')
1342                 {       // create the directory
1343                         *ofs = 0;
1344                         Sys_mkdir (path);
1345                         *ofs = '/';
1346                 }
1347         }
1348 }
1349
1350
1351 /*
1352 ===========
1353 COM_CopyFile
1354
1355 Copies a file over from the net to the local cache, creating any directories
1356 needed.  This is for the convenience of developers using ISDN from home.
1357 ===========
1358 */
1359 void COM_CopyFile (char *netpath, char *cachepath)
1360 {
1361         int             in, out;
1362         int             remaining, count;
1363         char    buf[4096];
1364         
1365         remaining = Sys_FileOpenRead (netpath, &in);            
1366         COM_CreatePath (cachepath);     // create directories up to the cache file
1367         out = Sys_FileOpenWrite (cachepath);
1368         
1369         while (remaining)
1370         {
1371                 if (remaining < sizeof(buf))
1372                         count = remaining;
1373                 else
1374                         count = sizeof(buf);
1375                 Sys_FileRead (in, buf, count);
1376                 Sys_FileWrite (out, buf, count);
1377                 remaining -= count;
1378         }
1379
1380         Sys_FileClose (in);
1381         Sys_FileClose (out);    
1382 }
1383
1384 /*
1385 ===========
1386 COM_FindFile
1387
1388 Finds the file in the search path.
1389 Sets com_filesize and one of handle or file
1390 ===========
1391 */
1392 int COM_FindFile (char *filename, int *handle, FILE **file, qboolean quiet)
1393 {
1394         searchpath_t    *search;
1395         char            netpath[MAX_OSPATH];
1396         char            cachepath[MAX_OSPATH];
1397         pack_t          *pak;
1398         int                     i;
1399         int                     findtime, cachetime;
1400
1401         if (file && handle)
1402                 Sys_Error ("COM_FindFile: both handle and file set");
1403         if (!file && !handle)
1404                 Sys_Error ("COM_FindFile: neither handle or file set");
1405                 
1406 //
1407 // search through the path, one element at a time
1408 //
1409         search = com_searchpaths;
1410         if (proghack)
1411         {       // gross hack to use quake 1 progs with quake 2 maps
1412                 if (!strcmp(filename, "progs.dat"))
1413                         search = search->next;
1414         }
1415
1416         for ( ; search ; search = search->next)
1417         {
1418         // is the element a pak file?
1419                 if (search->pack)
1420                 {
1421                 // look through all the pak file elements
1422                         pak = search->pack;
1423                         for (i=0 ; i<pak->numfiles ; i++)
1424                                 if (!strcmp (pak->files[i].name, filename))
1425                                 {       // found it!
1426                                         if (!quiet)
1427                                                 Sys_Printf ("PackFile: %s : %s\n",pak->filename, filename);
1428                                         if (handle)
1429                                         {
1430                                                 *handle = pak->handle;
1431                                                 Sys_FileSeek (pak->handle, pak->files[i].filepos);
1432                                         }
1433                                         else
1434                                         {       // open a new file on the pakfile
1435                                                 *file = fopen (pak->filename, "rb");
1436                                                 if (*file)
1437                                                         fseek (*file, pak->files[i].filepos, SEEK_SET);
1438                                         }
1439                                         com_filesize = pak->files[i].filelen;
1440                                         return com_filesize;
1441                                 }
1442                 }
1443                 else
1444                 {               
1445         // check a file in the directory tree
1446 //                      if (!static_registered)
1447 //                      {       // if not a registered version, don't ever go beyond base
1448 //                              if ( strchr (filename, '/') || strchr (filename,'\\'))
1449 //                                      continue;
1450 //                      }
1451                         
1452                         sprintf (netpath, "%s/%s",search->filename, filename);
1453                         
1454                         findtime = Sys_FileTime (netpath);
1455                         if (findtime == -1)
1456                                 continue;
1457                                 
1458                 // see if the file needs to be updated in the cache
1459                         if (!com_cachedir[0])
1460                                 strcpy (cachepath, netpath);
1461                         else
1462                         {       
1463 #if defined(_WIN32)
1464                                 if ((strlen(netpath) < 2) || (netpath[1] != ':'))
1465                                         sprintf (cachepath,"%s%s", com_cachedir, netpath);
1466                                 else
1467                                         sprintf (cachepath,"%s%s", com_cachedir, netpath+2);
1468 #else
1469                                 sprintf (cachepath,"%s%s", com_cachedir, netpath);
1470 #endif
1471
1472                                 cachetime = Sys_FileTime (cachepath);
1473                         
1474                                 if (cachetime < findtime)
1475                                         COM_CopyFile (netpath, cachepath);
1476                                 strcpy (netpath, cachepath);
1477                         }       
1478
1479                         if (!quiet)
1480                                 Sys_Printf ("FindFile: %s\n",netpath);
1481                         com_filesize = Sys_FileOpenRead (netpath, &i);
1482                         if (handle)
1483                                 *handle = i;
1484                         else
1485                         {
1486                                 Sys_FileClose (i);
1487                                 *file = fopen (netpath, "rb");
1488                         }
1489                         return com_filesize;
1490                 }
1491                 
1492         }
1493         
1494         if (!quiet)
1495                 Sys_Printf ("FindFile: can't find %s\n", filename);
1496         
1497         if (handle)
1498                 *handle = -1;
1499         else
1500                 *file = NULL;
1501         com_filesize = -1;
1502         return -1;
1503 }
1504
1505
1506 /*
1507 ===========
1508 COM_OpenFile
1509
1510 filename never has a leading slash, but may contain directory walks
1511 returns a handle and a length
1512 it may actually be inside a pak file
1513 ===========
1514 */
1515 int COM_OpenFile (char *filename, int *handle, qboolean quiet)
1516 {
1517         return COM_FindFile (filename, handle, NULL, quiet);
1518 }
1519
1520 /*
1521 ===========
1522 COM_FOpenFile
1523
1524 If the requested file is inside a packfile, a new FILE * will be opened
1525 into the file.
1526 ===========
1527 */
1528 int COM_FOpenFile (char *filename, FILE **file, qboolean quiet)
1529 {
1530         return COM_FindFile (filename, NULL, file, quiet);
1531 }
1532
1533 /*
1534 ============
1535 COM_CloseFile
1536
1537 If it is a pak file handle, don't really close it
1538 ============
1539 */
1540 void COM_CloseFile (int h)
1541 {
1542         searchpath_t    *s;
1543         
1544         for (s = com_searchpaths ; s ; s=s->next)
1545                 if (s->pack && s->pack->handle == h)
1546                         return;
1547                         
1548         Sys_FileClose (h);
1549 }
1550
1551
1552 /*
1553 ============
1554 COM_LoadFile
1555
1556 Filename are reletive to the quake directory.
1557 Allways appends a 0 byte.
1558 ============
1559 */
1560 cache_user_t *loadcache;
1561 byte    *loadbuf;
1562 int             loadsize;
1563 byte *COM_LoadFile (char *path, int usehunk, qboolean quiet)
1564 {
1565         int             h;
1566         byte    *buf;
1567         char    base[32];
1568         int             len;
1569
1570         buf = NULL;     // quiet compiler warning
1571
1572 // look for it in the filesystem or pack files
1573         len = COM_OpenFile (path, &h, quiet);
1574         if (h == -1)
1575                 return NULL;
1576         
1577 // extract the filename base name for hunk tag
1578         COM_FileBase (path, base);
1579         
1580         if (usehunk == 1)
1581                 buf = Hunk_AllocName (len+1, base);
1582         else if (usehunk == 2)
1583                 buf = Hunk_TempAlloc (len+1);
1584         else if (usehunk == 0)
1585                 buf = Z_Malloc (len+1);
1586         else if (usehunk == 3)
1587                 buf = Cache_Alloc (loadcache, len+1, base);
1588         else if (usehunk == 4)
1589         {
1590                 if (len+1 > loadsize)
1591                         buf = Hunk_TempAlloc (len+1);
1592                 else
1593                         buf = loadbuf;
1594         }
1595         else if (usehunk == 5)
1596                 buf = malloc (len+1);
1597         else
1598                 Sys_Error ("COM_LoadFile: bad usehunk");
1599
1600         if (!buf)
1601                 Sys_Error ("COM_LoadFile: not enough space for %s", path);
1602                 
1603         ((byte *)buf)[len] = 0;
1604
1605         Sys_FileRead (h, buf, len);                     
1606         COM_CloseFile (h);
1607
1608         return buf;
1609 }
1610
1611 byte *COM_LoadHunkFile (char *path, qboolean quiet)
1612 {
1613         return COM_LoadFile (path, 1, quiet);
1614 }
1615
1616 byte *COM_LoadTempFile (char *path, qboolean quiet)
1617 {
1618         return COM_LoadFile (path, 2, quiet);
1619 }
1620
1621 // LordHavoc: returns malloc'd memory
1622 byte *COM_LoadMallocFile (char *path, qboolean quiet)
1623 {
1624         return COM_LoadFile (path, 5, quiet);
1625 }
1626
1627 void COM_LoadCacheFile (char *path, struct cache_user_s *cu, qboolean quiet)
1628 {
1629         loadcache = cu;
1630         COM_LoadFile (path, 3, quiet);
1631 }
1632
1633 // uses temp hunk if larger than bufsize
1634 byte *COM_LoadStackFile (char *path, void *buffer, int bufsize, qboolean quiet)
1635 {
1636         byte    *buf;
1637         
1638         loadbuf = (byte *)buffer;
1639         loadsize = bufsize;
1640         buf = COM_LoadFile (path, 4, quiet);
1641         
1642         return buf;
1643 }
1644
1645 /*
1646 =================
1647 COM_LoadPackFile
1648
1649 Takes an explicit (not game tree related) path to a pak file.
1650
1651 Loads the header and directory, adding the files at the beginning
1652 of the list so they override previous pack files.
1653 =================
1654 */
1655 pack_t *COM_LoadPackFile (char *packfile)
1656 {
1657         dpackheader_t   header;
1658         int                             i;
1659         packfile_t              *newfiles;
1660         int                             numpackfiles;
1661         pack_t                  *pack;
1662         int                             packhandle;
1663         dpackfile_t             info[MAX_FILES_IN_PACK];
1664         unsigned short          crc;
1665
1666         if (Sys_FileOpenRead (packfile, &packhandle) == -1)
1667         {
1668 //              Con_Printf ("Couldn't open %s\n", packfile);
1669                 return NULL;
1670         }
1671         Sys_FileRead (packhandle, (void *)&header, sizeof(header));
1672         if (header.id[0] != 'P' || header.id[1] != 'A'
1673         || header.id[2] != 'C' || header.id[3] != 'K')
1674                 Sys_Error ("%s is not a packfile", packfile);
1675         header.dirofs = LittleLong (header.dirofs);
1676         header.dirlen = LittleLong (header.dirlen);
1677
1678         numpackfiles = header.dirlen / sizeof(dpackfile_t);
1679
1680         if (numpackfiles > MAX_FILES_IN_PACK)
1681                 Sys_Error ("%s has %i files", packfile, numpackfiles);
1682
1683         if (numpackfiles != PAK0_COUNT)
1684                 com_modified = true;    // not the original file
1685
1686         newfiles = Hunk_AllocName (numpackfiles * sizeof(packfile_t), "packfile");
1687
1688         Sys_FileSeek (packhandle, header.dirofs);
1689         Sys_FileRead (packhandle, (void *)info, header.dirlen);
1690
1691 // crc the directory to check for modifications
1692         CRC_Init (&crc);
1693         // LordHavoc: speedup
1694         CRC_ProcessBytes(&crc, (byte *)info, header.dirlen);
1695 //      for (i=0 ; i<header.dirlen ; i++)
1696 //              CRC_ProcessByte (&crc, ((byte *)info)[i]);
1697         if (crc != PAK0_CRC)
1698                 com_modified = true;
1699
1700 // parse the directory
1701         for (i=0 ; i<numpackfiles ; i++)
1702         {
1703                 strcpy (newfiles[i].name, info[i].name);
1704                 newfiles[i].filepos = LittleLong(info[i].filepos);
1705                 newfiles[i].filelen = LittleLong(info[i].filelen);
1706         }
1707
1708         pack = Hunk_Alloc (sizeof (pack_t));
1709         strcpy (pack->filename, packfile);
1710         pack->handle = packhandle;
1711         pack->numfiles = numpackfiles;
1712         pack->files = newfiles;
1713         
1714         Con_Printf ("Added packfile %s (%i files)\n", packfile, numpackfiles);
1715         return pack;
1716 }
1717
1718
1719 /*
1720 ================
1721 COM_AddGameDirectory
1722
1723 Sets com_gamedir, adds the directory to the head of the path,
1724 then loads and adds pak1.pak pak2.pak ... 
1725 ================
1726 */
1727 void COM_AddGameDirectory (char *dir)
1728 {
1729         int                             i;
1730         searchpath_t    *search;
1731         pack_t                  *pak;
1732         char                    pakfile[MAX_OSPATH];
1733
1734         strcpy (com_gamedir, dir);
1735
1736 //
1737 // add the directory to the search path
1738 //
1739         search = Hunk_Alloc (sizeof(searchpath_t));
1740         strcpy (search->filename, dir);
1741         search->next = com_searchpaths;
1742         com_searchpaths = search;
1743
1744 //
1745 // add any pak files in the format pak0.pak pak1.pak, ...
1746 //
1747         for (i=0 ; ; i++)
1748         {
1749                 sprintf (pakfile, "%s/pak%i.pak", dir, i);
1750                 pak = COM_LoadPackFile (pakfile);
1751                 if (!pak)
1752                         break;
1753                 search = Hunk_Alloc (sizeof(searchpath_t));
1754                 search->pack = pak;
1755                 search->next = com_searchpaths;
1756                 com_searchpaths = search;               
1757         }
1758
1759 //
1760 // add the contents of the parms.txt file to the end of the command line
1761 //
1762
1763 }
1764
1765 /*
1766 ================
1767 COM_InitFilesystem
1768 ================
1769 */
1770 void COM_InitFilesystem (void)
1771 {
1772         int             i, j;
1773         char    basedir[MAX_OSPATH];
1774         searchpath_t    *search;
1775
1776 //
1777 // -basedir <path>
1778 // Overrides the system supplied base directory (under GAMENAME)
1779 //
1780         i = COM_CheckParm ("-basedir");
1781         if (i && i < com_argc-1)
1782                 strcpy (basedir, com_argv[i+1]);
1783         else
1784                 strcpy (basedir, host_parms.basedir);
1785
1786         j = strlen (basedir);
1787
1788         if (j > 0)
1789         {
1790                 if ((basedir[j-1] == '\\') || (basedir[j-1] == '/'))
1791                         basedir[j-1] = 0;
1792         }
1793
1794 //
1795 // -cachedir <path>
1796 // Overrides the system supplied cache directory (NULL or /qcache)
1797 // -cachedir - will disable caching.
1798 //
1799         i = COM_CheckParm ("-cachedir");
1800         if (i && i < com_argc-1)
1801         {
1802                 if (com_argv[i+1][0] == '-')
1803                         com_cachedir[0] = 0;
1804                 else
1805                         strcpy (com_cachedir, com_argv[i+1]);
1806         }
1807         else if (host_parms.cachedir)
1808                 strcpy (com_cachedir, host_parms.cachedir);
1809         else
1810                 com_cachedir[0] = 0;
1811
1812 //
1813 // start up with GAMENAME by default (id1)
1814 //
1815         COM_AddGameDirectory (va("%s/"GAMENAME, basedir) );
1816
1817 #ifdef NEHAHRA
1818         COM_AddGameDirectory (va("%s/nehahra", basedir) );
1819 #else
1820         if (COM_CheckParm ("-rogue"))
1821                 COM_AddGameDirectory (va("%s/rogue", basedir) );
1822         if (COM_CheckParm ("-hipnotic"))
1823                 COM_AddGameDirectory (va("%s/hipnotic", basedir) );
1824         if (COM_CheckParm ("-nehahra"))
1825                 COM_AddGameDirectory (va("%s/nehahra", basedir) );
1826 #endif
1827
1828 //
1829 // -game <gamedir>
1830 // Adds basedir/gamedir as an override game
1831 //
1832         i = COM_CheckParm ("-game");
1833         if (i && i < com_argc-1)
1834         {
1835                 com_modified = true;
1836                 COM_AddGameDirectory (va("%s/%s", basedir, com_argv[i+1]));
1837         }
1838
1839 //
1840 // -path <dir or packfile> [<dir or packfile>] ...
1841 // Fully specifies the exact serach path, overriding the generated one
1842 //
1843         i = COM_CheckParm ("-path");
1844         if (i)
1845         {
1846                 com_modified = true;
1847                 com_searchpaths = NULL;
1848                 while (++i < com_argc)
1849                 {
1850                         if (!com_argv[i] || com_argv[i][0] == '+' || com_argv[i][0] == '-')
1851                                 break;
1852                         
1853                         search = Hunk_Alloc (sizeof(searchpath_t));
1854                         if ( !strcmp(COM_FileExtension(com_argv[i]), "pak") )
1855                         {
1856                                 search->pack = COM_LoadPackFile (com_argv[i]);
1857                                 if (!search->pack)
1858                                         Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
1859                         }
1860                         else
1861                                 strcpy (search->filename, com_argv[i]);
1862                         search->next = com_searchpaths;
1863                         com_searchpaths = search;
1864                 }
1865         }
1866
1867         if (COM_CheckParm ("-proghack"))
1868                 proghack = true;
1869 }
1870
1871 int COM_FileExists(char *filename)
1872 {
1873         searchpath_t    *search;
1874         char                    netpath[MAX_OSPATH];
1875         pack_t                  *pak;
1876         int                             i;
1877         int                             findtime;
1878
1879         for (search = com_searchpaths;search;search = search->next)
1880         {
1881                 if (search->pack)
1882                 {
1883                         pak = search->pack;
1884                         for (i = 0;i < pak->numfiles;i++)
1885                                 if (!strcmp (pak->files[i].name, filename))
1886                                         return true;
1887                 }
1888                 else
1889                 {
1890                         sprintf (netpath, "%s/%s",search->filename, filename);               
1891                         findtime = Sys_FileTime (netpath);
1892                         if (findtime != -1)
1893                                 return true;
1894                 }               
1895         }
1896
1897         return false;
1898 }
1899