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 <stdlib.h>
  23 #include <fcntl.h>
  24 #ifdef WIN32
  25 #include <io.h>
  26 #else
  27 #include <unistd.h>
  28 #endif
  29
  30 #include "quakedef.h"
  31
  32 #define NUM_SAFE_ARGVS  7
  33
  34 static char *largv[MAX_NUM_ARGVS + NUM_SAFE_ARGVS + 1];
  35 static char *argvdummy = " ";
  36
  37 static char *safeargvs[NUM_SAFE_ARGVS] =
  38         {"-stdvid", "-nolan", "-nosound", "-nocdaudio", "-nojoy", "-nomouse", "-window"};
  39
  40 cvar_t registered = {0, "registered","0"};
  41 cvar_t cmdline = {0, "cmdline","0"};
  42
  43 mempool_t *pak_mempool;
  44
  45 qboolean com_modified;   // set true if using non-id files
  46
  47 qboolean msg_suppress_1 = 0;
  48
  49 void COM_InitFilesystem (void);
  50
  51 char com_token[1024];
  52 int com_argc;
  53 char **com_argv;
  54
  55 // LordHavoc: made commandline 1024 characters instead of 256
  56 #define CMDLINE_LENGTH  1024
  57 char com_cmdline[CMDLINE_LENGTH];
  58
  59 int gamemode;
  60 char *gamename;
  61
  62 /*
  63
  64
  65 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.
  66
  67 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
  68 only used during filesystem initialization.
  69
  70 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.
  71
  72 The "cache directory" is only used during development to save network bandwidth, especially over ISDN / T1 lines.  If there is a cache directory
  73 specified, when a file is found by the normal search path, it will be mirrored
  74 into the cache directory, then opened there.
  75
  76
  77
  78 FIXME:
  79 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.
  80
  81 */
  82
  83 //============================================================================
  84
  85
  86 /*
  87 ============================================================================
  88
  89                                         LIBRARY REPLACEMENT FUNCTIONS
  90
  91 ============================================================================
  92 */
  93
  94 int Q_strncasecmp (char *s1, char *s2, int n)
  95 {
  96         int             c1, c2;
  97
  98         while (1)
  99         {
 100                 c1 = *s1++;
 101                 c2 = *s2++;
 102
 103                 if (!n--)
 104                         return 0;               // strings are equal until end point
 105
 106                 if (c1 != c2)
 107                 {
 108                         if (c1 >= 'a' && c1 <= 'z')
 109                                 c1 -= ('a' - 'A');
 110                         if (c2 >= 'a' && c2 <= 'z')
 111                                 c2 -= ('a' - 'A');
 112                         if (c1 != c2)
 113                                 return -1;              // strings not equal
 114                 }
 115                 if (!c1)
 116                         return 0;               // strings are equal
 117         }
 118
 119         return -1;
 120 }
 121
 122 int Q_strcasecmp (char *s1, char *s2)
 123 {
 124         return Q_strncasecmp (s1, s2, 99999);
 125 }
 126
 127 /*
 128 ============================================================================
 129
 130                                         BYTE ORDER FUNCTIONS
 131
 132 ============================================================================
 133 */
 134
 135 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
 136 short   (*BigShort) (short l);
 137 short   (*LittleShort) (short l);
 138 int     (*BigLong) (int l);
 139 int     (*LittleLong) (int l);
 140 float   (*BigFloat) (float l);
 141 float   (*LittleFloat) (float l);
 142 #endif
 143
 144 short   ShortSwap (short l)
 145 {
 146         qbyte    b1,b2;
 147
 148         b1 = l&255;
 149         b2 = (l>>8)&255;
 150
 151         return (b1<<8) + b2;
 152 }
 153
 154 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
 155 short   ShortNoSwap (short l)
 156 {
 157         return l;
 158 }
 159 #endif
 160
 161 int    LongSwap (int l)
 162 {
 163         qbyte    b1,b2,b3,b4;
 164
 165         b1 = l&255;
 166         b2 = (l>>8)&255;
 167         b3 = (l>>16)&255;
 168         b4 = (l>>24)&255;
 169
 170         return ((int)b1<<24) + ((int)b2<<16) + ((int)b3<<8) + b4;
 171 }
 172
 173 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
 174 int     LongNoSwap (int l)
 175 {
 176         return l;
 177 }
 178 #endif
 179
 180 float FloatSwap (float f)
 181 {
 182         union
 183         {
 184                 float   f;
 185                 qbyte    b[4];
 186         } dat1, dat2;
 187
 188
 189         dat1.f = f;
 190         dat2.b[0] = dat1.b[3];
 191         dat2.b[1] = dat1.b[2];
 192         dat2.b[2] = dat1.b[1];
 193         dat2.b[3] = dat1.b[0];
 194         return dat2.f;
 195 }
 196
 197 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
 198 float FloatNoSwap (float f)
 199 {
 200         return f;
 201 }
 202 #endif
 203
 204 /*
 205 ==============================================================================
 206
 207                         MESSAGE IO FUNCTIONS
 208
 209 Handles byte ordering and avoids alignment errors
 210 ==============================================================================
 211 */
 212
 213 //
 214 // writing functions
 215 //
 216
 217 void MSG_WriteChar (sizebuf_t *sb, int c)
 218 {
 219         qbyte    *buf;
 220
 221         buf = SZ_GetSpace (sb, 1);
 222         buf[0] = c;
 223 }
 224
 225 void MSG_WriteByte (sizebuf_t *sb, int c)
 226 {
 227         qbyte    *buf;
 228
 229         buf = SZ_GetSpace (sb, 1);
 230         buf[0] = c;
 231 }
 232
 233 void MSG_WriteShort (sizebuf_t *sb, int c)
 234 {
 235         qbyte    *buf;
 236
 237         buf = SZ_GetSpace (sb, 2);
 238         buf[0] = c&0xff;
 239         buf[1] = c>>8;
 240 }
 241
 242 void MSG_WriteLong (sizebuf_t *sb, int c)
 243 {
 244         qbyte    *buf;
 245
 246         buf = SZ_GetSpace (sb, 4);
 247         buf[0] = c&0xff;
 248         buf[1] = (c>>8)&0xff;
 249         buf[2] = (c>>16)&0xff;
 250         buf[3] = c>>24;
 251 }
 252
 253 void MSG_WriteFloat (sizebuf_t *sb, float f)
 254 {
 255         union
 256         {
 257                 float   f;
 258                 int     l;
 259         } dat;
 260
 261
 262         dat.f = f;
 263         dat.l = LittleLong (dat.l);
 264
 265         SZ_Write (sb, &dat.l, 4);
 266 }
 267
 268 void MSG_WriteString (sizebuf_t *sb, char *s)
 269 {
 270         if (!s)
 271                 SZ_Write (sb, "", 1);
 272         else
 273                 SZ_Write (sb, s, strlen(s)+1);
 274 }
 275
 276 // used by server (always latest dpprotocol)
 277 void MSG_WriteDPCoord (sizebuf_t *sb, float f)
 278 {
 279         if (f >= 0)
 280                 MSG_WriteShort (sb, (int)(f + 0.5f));
 281         else
 282                 MSG_WriteShort (sb, (int)(f - 0.5f));
 283 }
 284
 285 void MSG_WritePreciseAngle (sizebuf_t *sb, float f)
 286 {
 287         if (f >= 0)
 288                 MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) + 0.5f) & 65535);
 289         else
 290                 MSG_WriteShort (sb, (int)(f*(65536.0f/360.0f) - 0.5f) & 65535);
 291 }
 292
 293 // LordHavoc: round to nearest value, rather than rounding toward zero, fixes crosshair problem
 294 void MSG_WriteAngle (sizebuf_t *sb, float f)
 295 {
 296         if (f >= 0)
 297                 MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) + 0.5f) & 255);
 298         else
 299                 MSG_WriteByte (sb, (int)(f*(256.0f/360.0f) - 0.5f) & 255);
 300 }
 301
 302 //
 303 // reading functions
 304 //
 305 int                     msg_readcount;
 306 qboolean        msg_badread;
 307
 308 void MSG_BeginReading (void)
 309 {
 310         msg_readcount = 0;
 311         msg_badread = false;
 312 }
 313
 314 int MSG_ReadShort (void)
 315 {
 316         int     c;
 317
 318         if (msg_readcount+2 > net_message.cursize)
 319         {
 320                 msg_badread = true;
 321                 return -1;
 322         }
 323
 324         c = (short)(net_message.data[msg_readcount]
 325         + (net_message.data[msg_readcount+1]<<8));
 326
 327         msg_readcount += 2;
 328
 329         return c;
 330 }
 331
 332 int MSG_ReadLong (void)
 333 {
 334         int     c;
 335
 336         if (msg_readcount+4 > net_message.cursize)
 337         {
 338                 msg_badread = true;
 339                 return -1;
 340         }
 341
 342         c = net_message.data[msg_readcount]
 343         + (net_message.data[msg_readcount+1]<<8)
 344         + (net_message.data[msg_readcount+2]<<16)
 345         + (net_message.data[msg_readcount+3]<<24);
 346
 347         msg_readcount += 4;
 348
 349         return c;
 350 }
 351
 352 float MSG_ReadFloat (void)
 353 {
 354         union
 355         {
 356                 qbyte    b[4];
 357                 float   f;
 358                 int     l;
 359         } dat;
 360
 361         dat.b[0] =      net_message.data[msg_readcount];
 362         dat.b[1] =      net_message.data[msg_readcount+1];
 363         dat.b[2] =      net_message.data[msg_readcount+2];
 364         dat.b[3] =      net_message.data[msg_readcount+3];
 365         msg_readcount += 4;
 366
 367         dat.l = LittleLong (dat.l);
 368
 369         return dat.f;
 370 }
 371
 372 char *MSG_ReadString (void)
 373 {
 374         static char     string[2048];
 375         int             l,c;
 376
 377         l = 0;
 378         do
 379         {
 380                 c = MSG_ReadChar ();
 381                 if (c == -1 || c == 0)
 382                         break;
 383                 string[l] = c;
 384                 l++;
 385         } while (l < sizeof(string)-1);
 386
 387         string[l] = 0;
 388
 389         return string;
 390 }
 391
 392 // used by server (always latest dpprotocol)
 393 float MSG_ReadDPCoord (void)
 394 {
 395         return (signed short) MSG_ReadShort();
 396 }
 397
 398 // used by client
 399 float MSG_ReadCoord (void)
 400 {
 401         if (dpprotocol == DPPROTOCOL_VERSION2 || dpprotocol == DPPROTOCOL_VERSION3)
 402                 return (signed short) MSG_ReadShort();
 403         else if (dpprotocol == DPPROTOCOL_VERSION1)
 404                 return MSG_ReadFloat();
 405         else
 406                 return MSG_ReadShort() * (1.0f/8.0f);
 407 }
 408
 409
 410 //===========================================================================
 411
 412 void SZ_Alloc (sizebuf_t *buf, int startsize, char *name)
 413 {
 414         if (startsize < 256)
 415                 startsize = 256;
 416         buf->mempool = Mem_AllocPool(name);
 417         buf->data = Mem_Alloc(buf->mempool, startsize);
 418         buf->maxsize = startsize;
 419         buf->cursize = 0;
 420 }
 421
 422
 423 void SZ_Free (sizebuf_t *buf)
 424 {
 425         Mem_FreePool(&buf->mempool);
 426         buf->data = NULL;
 427         buf->maxsize = 0;
 428         buf->cursize = 0;
 429 }
 430
 431 void SZ_Clear (sizebuf_t *buf)
 432 {
 433         buf->cursize = 0;
 434 }
 435
 436 void *SZ_GetSpace (sizebuf_t *buf, int length)
 437 {
 438         void    *data;
 439
 440         if (buf->cursize + length > buf->maxsize)
 441         {
 442                 if (!buf->allowoverflow)
 443                         Host_Error ("SZ_GetSpace: overflow without allowoverflow set");
 444
 445                 if (length > buf->maxsize)
 446                         Host_Error ("SZ_GetSpace: %i is > full buffer size", length);
 447
 448                 buf->overflowed = true;
 449                 Con_Printf ("SZ_GetSpace: overflow");
 450                 SZ_Clear (buf);
 451         }
 452
 453         data = buf->data + buf->cursize;
 454         buf->cursize += length;
 455
 456         return data;
 457 }
 458
 459 void SZ_Write (sizebuf_t *buf, void *data, int length)
 460 {
 461         memcpy (SZ_GetSpace(buf,length),data,length);
 462 }
 463
 464 void SZ_Print (sizebuf_t *buf, char *data)
 465 {
 466         int             len;
 467
 468         len = strlen(data)+1;
 469
 470 // byte * cast to keep VC++ happy
 471         if (buf->data[buf->cursize-1])
 472                 memcpy ((qbyte *)SZ_GetSpace(buf, len),data,len); // no trailing 0
 473         else
 474                 memcpy ((qbyte *)SZ_GetSpace(buf, len-1)-1,data,len); // write over trailing 0
 475 }
 476
 477
 478 //============================================================================
 479
 480
 481 /*
 482 ============
 483 COM_SkipPath
 484 ============
 485 */
 486 char *COM_SkipPath (char *pathname)
 487 {
 488         char    *last;
 489
 490         last = pathname;
 491         while (*pathname)
 492         {
 493                 if (*pathname=='/')
 494                         last = pathname+1;
 495                 pathname++;
 496         }
 497         return last;
 498 }
 499
 500 /*
 501 ============
 502 COM_StripExtension
 503 ============
 504 */
 505 // LordHavoc: replacement for severely broken COM_StripExtension that was used in original quake.
 506 void COM_StripExtension (char *in, char *out)
 507 {
 508         char *last = NULL;
 509         while (*in)
 510         {
 511                 if (*in == '.')
 512                         last = out;
 513                 else if (*in == '/' || *in == '\\' || *in == ':')
 514                         last = NULL;
 515                 *out++ = *in++;
 516         }
 517         if (last)
 518                 *last = 0;
 519 }
 520
 521 /*
 522 ============
 523 COM_FileExtension
 524 ============
 525 */
 526 char *COM_FileExtension (char *in)
 527 {
 528         static char exten[8];
 529         int             i;
 530
 531         while (*in && *in != '.')
 532                 in++;
 533         if (!*in)
 534                 return "";
 535         in++;
 536         for (i=0 ; i<7 && *in ; i++,in++)
 537                 exten[i] = *in;
 538         exten[i] = 0;
 539         return exten;
 540 }
 541
 542 /*
 543 ============
 544 COM_FileBase
 545 ============
 546 */
 547 void COM_FileBase (char *in, char *out)
 548 {
 549         char *slash, *dot;
 550         char *s;
 551
 552         slash = in;
 553         dot = NULL;
 554         s = in;
 555         while(*s)
 556         {
 557                 if (*s == '/')
 558                         slash = s + 1;
 559                 if (*s == '.')
 560                         dot = s;
 561                 s++;
 562         }
 563         if (dot == NULL)
 564                 dot = s;
 565         if (dot - slash < 2)
 566                 strcpy (out,"?model?");
 567         else
 568         {
 569                 while (slash < dot)
 570                         *out++ = *slash++;
 571                 *out++ = 0;
 572         }
 573 }
 574
 575
 576 /*
 577 ==================
 578 COM_DefaultExtension
 579 ==================
 580 */
 581 void COM_DefaultExtension (char *path, char *extension)
 582 {
 583         char    *src;
 584 //
 585 // if path doesn't have a .EXT, append extension
 586 // (extension should include the .)
 587 //
 588         src = path + strlen(path) - 1;
 589
 590         while (*src != '/' && src != path)
 591         {
 592                 if (*src == '.')
 593                         return;                 // it has an extension
 594                 src--;
 595         }
 596
 597         strcat (path, extension);
 598 }
 599
 600
 601 /*
 602 ==============
 603 COM_Parse
 604
 605 Parse a token out of a string
 606 ==============
 607 */
 608 char *COM_Parse (char *data)
 609 {
 610         int             c;
 611         int             len;
 612
 613         len = 0;
 614         com_token[0] = 0;
 615
 616         if (!data)
 617                 return NULL;
 618
 619 // skip whitespace
 620 skipwhite:
 621         while ( (c = *data) <= ' ')
 622         {
 623                 if (c == 0)
 624                         return NULL;                    // end of file;
 625                 data++;
 626         }
 627
 628 // skip // comments
 629         if (c=='/' && data[1] == '/')
 630         {
 631                 while (*data && *data != '\n')
 632                         data++;
 633                 goto skipwhite;
 634         }
 635
 636
 637 // handle quoted strings specially
 638         if (c == '\"')
 639         {
 640                 data++;
 641                 while (1)
 642                 {
 643                         c = *data++;
 644                         if (c=='\"' || !c)
 645                         {
 646                                 com_token[len] = 0;
 647                                 return data;
 648                         }
 649                         com_token[len] = c;
 650                         len++;
 651                 }
 652         }
 653
 654 // parse single characters
 655         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
 656         {
 657                 com_token[len] = c;
 658                 len++;
 659                 com_token[len] = 0;
 660                 return data+1;
 661         }
 662
 663 // parse a regular word
 664         do
 665         {
 666                 com_token[len] = c;
 667                 data++;
 668                 len++;
 669                 c = *data;
 670         if (c=='{' || c=='}'|| c==')'|| c=='(' || c=='\'' || c==':')
 671                         break;
 672         } while (c>32);
 673
 674         com_token[len] = 0;
 675         return data;
 676 }
 677
 678
 679 /*
 680 ================
 681 COM_CheckParm
 682
 683 Returns the position (1 to argc-1) in the program's argument list
 684 where the given parameter apears, or 0 if not present
 685 ================
 686 */
 687 int COM_CheckParm (char *parm)
 688 {
 689         int             i;
 690
 691         for (i=1 ; i<com_argc ; i++)
 692         {
 693                 if (!com_argv[i])
 694                         continue;               // NEXTSTEP sometimes clears appkit vars.
 695                 if (!strcmp (parm,com_argv[i]))
 696                         return i;
 697         }
 698
 699         return 0;
 700 }
 701
 702 /*
 703 ================
 704 COM_CheckRegistered
 705
 706 Looks for the pop.txt file and verifies it.
 707 Sets the "registered" cvar.
 708 Immediately exits out if an alternate game was attempted to be started without
 709 being registered.
 710 ================
 711 */
 712 void COM_CheckRegistered (void)
 713 {
 714         Cvar_Set ("cmdline", com_cmdline);
 715
 716         if (!Sys_FileTime("gfx/pop.lmp"))
 717         {
 718                 if (com_modified)
 719                         Con_Printf ("Playing shareware version, with modification.\nwarning: most mods require full quake data.\n");
 720                 else
 721                         Con_Printf ("Playing shareware version.\n");
 722                 return;
 723         }
 724
 725         Cvar_Set ("registered", "1");
 726         Con_Printf ("Playing registered version.\n");
 727 }
 728
 729
 730 void COM_Path_f (void);
 731
 732
 733 /*
 734 ================
 735 COM_InitArgv
 736 ================
 737 */
 738 void COM_InitArgv (int argc, char **argv)
 739 {
 740         qboolean        safe;
 741         int             i, j, n;
 742
 743 // reconstitute the command line for the cmdline externally visible cvar
 744         n = 0;
 745
 746         for (j=0 ; (j<MAX_NUM_ARGVS) && (j< argc) ; j++)
 747         {
 748                 i = 0;
 749
 750                 while ((n < (CMDLINE_LENGTH - 1)) && argv[j][i])
 751                 {
 752                         com_cmdline[n++] = argv[j][i++];
 753                 }
 754
 755                 if (n < (CMDLINE_LENGTH - 1))
 756                         com_cmdline[n++] = ' ';
 757                 else
 758                         break;
 759         }
 760
 761         com_cmdline[n] = 0;
 762
 763         safe = false;
 764
 765         for (com_argc=0 ; (com_argc<MAX_NUM_ARGVS) && (com_argc < argc) ;
 766                  com_argc++)
 767         {
 768                 largv[com_argc] = argv[com_argc];
 769                 if (!strcmp ("-safe", argv[com_argc]))
 770                         safe = true;
 771         }
 772
 773         if (safe)
 774         {
 775         // force all the safe-mode switches. Note that we reserved extra space in
 776         // case we need to add these, so we don't need an overflow check
 777                 for (i=0 ; i<NUM_SAFE_ARGVS ; i++)
 778                 {
 779                         largv[com_argc] = safeargvs[i];
 780                         com_argc++;
 781                 }
 782         }
 783
 784         largv[com_argc] = argvdummy;
 785         com_argv = largv;
 786
 787 #if BLOODBATH
 788         gamemode = GAME_BLOODBATH;
 789 #elif ZYMOTIC
 790         gamemode = GAME_ZYMOTIC;
 791 #elif FIENDARENA
 792         gamemode = GAME_FIENDARENA;
 793 #elif NEHAHRA
 794         gamemode = GAME_NEHAHRA;
 795 #else
 796         if (COM_CheckParm ("-bloodbath"))
 797                 gamemode = GAME_BLOODBATH;
 798         else if (COM_CheckParm ("-zymotic"))
 799                 gamemode = GAME_ZYMOTIC;
 800         else if (COM_CheckParm ("-fiendarena"))
 801                 gamemode = GAME_FIENDARENA;
 802         else if (COM_CheckParm ("-nehahra"))
 803                 gamemode = GAME_NEHAHRA;
 804         else if (COM_CheckParm ("-hipnotic"))
 805                 gamemode = GAME_HIPNOTIC;
 806         else if (COM_CheckParm ("-rogue"))
 807                 gamemode = GAME_ROGUE;
 808 #endif
 809         switch(gamemode)
 810         {
 811         case GAME_NORMAL:
 812                 gamename = "DarkPlaces";
 813                 break;
 814         case GAME_HIPNOTIC:
 815                 gamename = "Darkplaces-Hipnotic";
 816                 break;
 817         case GAME_ROGUE:
 818                 gamename = "Darkplaces-Rogue";
 819                 break;
 820         case GAME_NEHAHRA:
 821                 gamename = "DarkPlaces-Nehahra";
 822                 break;
 823         case GAME_FIENDARENA:
 824                 gamename = "FiendArena";
 825                 break;
 826         case GAME_ZYMOTIC:
 827                 gamename = "Zymotic";
 828                 break;
 829         case GAME_BLOODBATH:
 830                 gamename = "BloodBath";
 831                 break;
 832         default:
 833                 Sys_Error("COM_InitArgv: unknown gamemode %i\n", gamemode);
 834                 break;
 835         }
 836 }
 837
 838
 839 extern void Mathlib_Init(void);
 840
 841 /*
 842 ================
 843 COM_Init
 844 ================
 845 */
 846 void COM_Init (void)
 847 {
 848 #if !defined(ENDIAN_LITTLE) && !defined(ENDIAN_BIG)
 849         qbyte    swaptest[2] = {1,0};
 850
 851 // set the byte swapping variables in a portable manner
 852         if ( *(short *)swaptest == 1)
 853         {
 854                 BigShort = ShortSwap;
 855                 LittleShort = ShortNoSwap;
 856                 BigLong = LongSwap;
 857                 LittleLong = LongNoSwap;
 858                 BigFloat = FloatSwap;
 859                 LittleFloat = FloatNoSwap;
 860         }
 861         else
 862         {
 863                 BigShort = ShortNoSwap;
 864                 LittleShort = ShortSwap;
 865                 BigLong = LongNoSwap;
 866                 LittleLong = LongSwap;
 867                 BigFloat = FloatNoSwap;
 868                 LittleFloat = FloatSwap;
 869         }
 870 #endif
 871
 872         pak_mempool = Mem_AllocPool("paks");
 873
 874         Cvar_RegisterVariable (&registered);
 875         Cvar_RegisterVariable (&cmdline);
 876         Cmd_AddCommand ("path", COM_Path_f);
 877
 878         Mathlib_Init();
 879
 880         COM_InitFilesystem ();
 881         COM_CheckRegistered ();
 882 }
 883
 884
 885 /*
 886 ============
 887 va
 888
 889 does a varargs printf into a temp buffer, so I don't need to have
 890 varargs versions of all text functions.
 891 FIXME: make this buffer size safe someday
 892 ============
 893 */
 894 char    *va(char *format, ...)
 895 {
 896         va_list argptr;
 897         // LordHavoc: now cycles through 8 buffers to avoid problems in most cases
 898         static char string[8][1024], *s;
 899         static int stringindex = 0;
 900
 901         s = string[stringindex];
 902         stringindex = (stringindex + 1) & 7;
 903         va_start (argptr, format);
 904         vsprintf (s, format,argptr);
 905         va_end (argptr);
 906
 907         return s;
 908 }
 909
 910
 911 /*
 912 =============================================================================
 913
 914 QUAKE FILESYSTEM
 915
 916 =============================================================================
 917 */
 918
 919 int     com_filesize;
 920
 921
 922 //
 923 // in memory
 924 //
 925
 926 typedef struct
 927 {
 928         char name[MAX_QPATH];
 929         int filepos, filelen;
 930 } packfile_t;
 931
 932 typedef struct pack_s
 933 {
 934         char filename[MAX_OSPATH];
 935         int handle;
 936         int numfiles;
 937         packfile_t *files;
 938         mempool_t *mempool;
 939         struct pack_s *next;
 940 } pack_t;
 941
 942 //
 943 // on disk
 944 //
 945 typedef struct
 946 {
 947         char name[56];
 948         int filepos, filelen;
 949 } dpackfile_t;
 950
 951 typedef struct
 952 {
 953         char id[4];
 954         int dirofs;
 955         int dirlen;
 956 } dpackheader_t;
 957
 958 // LordHavoc: was 2048, increased to 65536 and changed info[MAX_PACK_FILES] to a temporary alloc
 959 #define MAX_FILES_IN_PACK       65536
 960
 961 pack_t  *packlist = NULL;
 962
 963 #if CACHEENABLE
 964 char    com_cachedir[MAX_OSPATH];
 965 #endif
 966 char    com_gamedir[MAX_OSPATH];
 967
 968 typedef struct searchpath_s
 969 {
 970         char filename[MAX_OSPATH];
 971         pack_t *pack;          // only one of filename / pack will be used
 972         struct searchpath_s *next;
 973 } searchpath_t;
 974
 975 searchpath_t    *com_searchpaths;
 976
 977 /*
 978 ============
 979 COM_Path_f
 980
 981 ============
 982 */
 983 void COM_Path_f (void)
 984 {
 985         searchpath_t    *s;
 986
 987         Con_Printf ("Current search path:\n");
 988         for (s=com_searchpaths ; s ; s=s->next)
 989         {
 990                 if (s->pack)
 991                 {
 992                         Con_Printf ("%s (%i files)\n", s->pack->filename, s->pack->numfiles);
 993                 }
 994                 else
 995                         Con_Printf ("%s\n", s->filename);
 996         }
 997 }
 998
 999 /*
1000 ============
1001 COM_CreatePath
1002
1003 LordHavoc: Previously only used for CopyFile, now also used for COM_WriteFile.
1004 ============
1005 */
1006 void    COM_CreatePath (char *path)
1007 {
1008         char    *ofs, save;
1009
1010         for (ofs = path+1 ; *ofs ; ofs++)
1011         {
1012                 if (*ofs == '/' || *ofs == '\\')
1013                 {
1014                         // create the directory
1015                         save = *ofs;
1016                         *ofs = 0;
1017                         Sys_mkdir (path);
1018                         *ofs = save;
1019                 }
1020         }
1021 }
1022
1023
1024 /*
1025 ============
1026 COM_WriteFile
1027
1028 The filename will be prefixed by the current game directory
1029 ============
1030 */
1031 qboolean COM_WriteFile (char *filename, void *data, int len)
1032 {
1033         int             handle;
1034         char    name[MAX_OSPATH];
1035
1036         sprintf (name, "%s/%s", com_gamedir, filename);
1037
1038         // LordHavoc: added this
1039         COM_CreatePath (name); // create directories up to the file
1040
1041         handle = Sys_FileOpenWrite (name);
1042         if (handle == -1)
1043         {
1044                 Con_Printf ("COM_WriteFile: failed on %s\n", name);
1045                 return false;
1046         }
1047
1048         Con_DPrintf ("COM_WriteFile: %s\n", name);
1049         Sys_FileWrite (handle, data, len);
1050         Sys_FileClose (handle);
1051         return true;
1052 }
1053
1054
1055 /*
1056 ===========
1057 COM_CopyFile
1058
1059 Copies a file over from the net to the local cache, creating any directories
1060 needed.  This is for the convenience of developers using ISDN from home.
1061 ===========
1062 */
1063 void COM_CopyFile (char *netpath, char *cachepath)
1064 {
1065         int             in, out;
1066         int             remaining, count;
1067         char    buf[4096];
1068
1069         remaining = Sys_FileOpenRead (netpath, &in);
1070         COM_CreatePath (cachepath);     // create directories up to the cache file
1071         out = Sys_FileOpenWrite (cachepath);
1072
1073         while (remaining)
1074         {
1075                 if (remaining < sizeof(buf))
1076                         count = remaining;
1077                 else
1078                         count = sizeof(buf);
1079                 Sys_FileRead (in, buf, count);
1080                 Sys_FileWrite (out, buf, count);
1081                 remaining -= count;
1082         }
1083
1084         Sys_FileClose (in);
1085         Sys_FileClose (out);
1086 }
1087
1088 /*
1089 ===========
1090 COM_OpenRead
1091 ===========
1092 */
1093 QFile * COM_OpenRead (const char *path, int offs, int len, qboolean zip)
1094 {
1095         int                             fd = open (path, O_RDONLY);
1096         unsigned char   id[2];
1097         unsigned char   len_bytes[4];
1098
1099         if (fd == -1)
1100         {
1101                 Sys_Error ("Couldn't open %s", path);
1102                 return 0;
1103         }
1104         if (offs < 0 || len < 0)
1105         {
1106                 // normal file
1107                 offs = 0;
1108                 len = lseek (fd, 0, SEEK_END);
1109                 lseek (fd, 0, SEEK_SET);
1110         }
1111         lseek (fd, offs, SEEK_SET);
1112         if (zip)
1113         {
1114                 read (fd, id, 2);
1115                 if (id[0] == 0x1f && id[1] == 0x8b)
1116                 {
1117                         lseek (fd, offs + len - 4, SEEK_SET);
1118                         read (fd, len_bytes, 4);
1119                         len = ((len_bytes[3] << 24)
1120                                    | (len_bytes[2] << 16)
1121                                    | (len_bytes[1] << 8)
1122                                    | (len_bytes[0]));
1123                 }
1124         }
1125         lseek (fd, offs, SEEK_SET);
1126         com_filesize = len;
1127
1128 #ifdef WIN32
1129         setmode (fd, O_BINARY);
1130 #endif
1131         if (zip)
1132                 return Qdopen (fd, "rbz");
1133         else
1134                 return Qdopen (fd, "rb");
1135 }
1136
1137 /*
1138 ===========
1139 COM_FindFile
1140
1141 Finds the file in the search path.
1142 Sets com_filesize and one of handle or file
1143 ===========
1144 */
1145 int COM_FindFile (char *filename, QFile **file, qboolean quiet, qboolean zip)
1146 {
1147         searchpath_t    *search;
1148         char                    netpath[MAX_OSPATH];
1149 #if CACHEENABLE
1150         char                    cachepath[MAX_OSPATH];
1151         int                             cachetime;
1152 #endif
1153         pack_t                  *pak;
1154         int                             i;
1155         int                             findtime;
1156         char                    gzfilename[MAX_OSPATH];
1157         int                             filenamelen;
1158
1159         filenamelen = strlen (filename);
1160         sprintf (gzfilename, "%s.gz", filename);
1161
1162         if (!file)
1163                 Sys_Error ("COM_FindFile: file not set");
1164
1165 //
1166 // search through the path, one element at a time
1167 //
1168         search = com_searchpaths;
1169
1170         for ( ; search ; search = search->next)
1171         {
1172         // is the element a pak file?
1173                 if (search->pack)
1174                 {
1175                 // look through all the pak file elements
1176                         pak = search->pack;
1177                         for (i=0 ; i<pak->numfiles ; i++)
1178                                 if (!strcmp (pak->files[i].name, filename)
1179                                     || !strcmp (pak->files[i].name, gzfilename))
1180                                 {       // found it!
1181                                         if (!quiet)
1182                                                 Sys_Printf ("PackFile: %s : %s\n",pak->filename, pak->files[i].name);
1183                                         // open a new file on the pakfile
1184                                         *file = COM_OpenRead (pak->filename, pak->files[i].filepos, pak->files[i].filelen, zip);
1185                                         return com_filesize;
1186                                 }
1187                 }
1188                 else
1189                 {
1190                         sprintf (netpath, "%s/%s",search->filename, filename);
1191
1192                         findtime = Sys_FileTime (netpath);
1193                         if (findtime == -1)
1194                                 continue;
1195
1196 #if CACHEENABLE
1197                         // see if the file needs to be updated in the cache
1198                         if (com_cachedir[0])
1199                         {
1200 #if defined(_WIN32)
1201                                 if ((strlen(netpath) < 2) || (netpath[1] != ':'))
1202                                         sprintf (cachepath,"%s%s", com_cachedir, netpath);
1203                                 else
1204                                         sprintf (cachepath,"%s%s", com_cachedir, netpath+2);
1205 #else
1206                                 sprintf (cachepath,"%s%s", com_cachedir, netpath);
1207 #endif
1208
1209                                 cachetime = Sys_FileTime (cachepath);
1210
1211                                 if (cachetime < findtime)
1212                                         COM_CopyFile (netpath, cachepath);
1213                                 strcpy (netpath, cachepath);
1214                         }
1215 #endif
1216
1217                         if (!quiet)
1218                                 Sys_Printf ("FindFile: %s\n",netpath);
1219                         *file = COM_OpenRead (netpath, -1, -1, zip);
1220                         return com_filesize;
1221                 }
1222
1223         }
1224
1225         if (!quiet)
1226                 Sys_Printf ("FindFile: can't find %s\n", filename);
1227
1228         *file = NULL;
1229         com_filesize = -1;
1230         return -1;
1231 }
1232
1233
1234 /*
1235 ===========
1236 COM_FOpenFile
1237
1238 If the requested file is inside a packfile, a new QFile * will be opened
1239 into the file.
1240 ===========
1241 */
1242 int COM_FOpenFile (char *filename, QFile **file, qboolean quiet, qboolean zip)
1243 {
1244         return COM_FindFile (filename, file, quiet, zip);
1245 }
1246
1247
1248 /*
1249 ============
1250 COM_LoadFile
1251
1252 Filename are reletive to the quake directory.
1253 Always appends a 0 byte.
1254 ============
1255 */
1256 qbyte *loadbuf;
1257 int loadsize;
1258 qbyte *COM_LoadFile (char *path, qboolean quiet)
1259 {
1260         QFile *h;
1261         qbyte *buf;
1262         char base[1024];
1263         int len;
1264
1265         buf = NULL;     // quiet compiler warning
1266         loadsize = 0;
1267
1268 // look for it in the filesystem or pack files
1269         len = COM_FOpenFile (path, &h, quiet, true);
1270         if (!h)
1271                 return NULL;
1272
1273         loadsize = len;
1274
1275 // extract the filename base name for hunk tag
1276         COM_FileBase (path, base);
1277
1278         buf = Mem_Alloc(tempmempool, len+1);
1279         if (!buf)
1280                 Sys_Error ("COM_LoadFile: not enough available memory for %s (size %i)", path, len);
1281
1282         ((qbyte *)buf)[len] = 0;
1283
1284         Qread (h, buf, len);
1285         Qclose (h);
1286
1287         return buf;
1288 }
1289
1290 /*
1291 =================
1292 COM_LoadPackFile
1293
1294 Takes an explicit (not game tree related) path to a pak file.
1295
1296 Loads the header and directory, adding the files at the beginning
1297 of the list so they override previous pack files.
1298 =================
1299 */
1300 pack_t *COM_LoadPackFile (char *packfile)
1301 {
1302         dpackheader_t   header;
1303         int                             i;
1304         int                             numpackfiles;
1305         pack_t                  *pack;
1306         int                             packhandle;
1307         // LordHavoc: changed from stack array to temporary alloc, allowing huge pack directories
1308         dpackfile_t             *info;
1309
1310         if (Sys_FileOpenRead (packfile, &packhandle) == -1)
1311                 return NULL;
1312
1313         Sys_FileRead (packhandle, (void *)&header, sizeof(header));
1314         if (memcmp(header.id, "PACK", 4))
1315                 Sys_Error ("%s is not a packfile", packfile);
1316         header.dirofs = LittleLong (header.dirofs);
1317         header.dirlen = LittleLong (header.dirlen);
1318
1319         if (header.dirlen % sizeof(dpackfile_t))
1320                 Sys_Error ("%s has an invalid directory size", packfile);
1321
1322         numpackfiles = header.dirlen / sizeof(dpackfile_t);
1323
1324         if (numpackfiles > MAX_FILES_IN_PACK)
1325                 Sys_Error ("%s has %i files", packfile, numpackfiles);
1326
1327         pack = Mem_Alloc(pak_mempool, sizeof (pack_t));
1328         strcpy (pack->filename, packfile);
1329         pack->handle = packhandle;
1330         pack->numfiles = numpackfiles;
1331         pack->mempool = Mem_AllocPool(packfile);
1332         pack->files = Mem_Alloc(pack->mempool, numpackfiles * sizeof(packfile_t));
1333         pack->next = packlist;
1334         packlist = pack;
1335
1336         info = Mem_Alloc(tempmempool, sizeof(*info) * numpackfiles);
1337         Sys_FileSeek (packhandle, header.dirofs);
1338         Sys_FileRead (packhandle, (void *)info, header.dirlen);
1339
1340 // parse the directory
1341         for (i = 0;i < numpackfiles;i++)
1342         {
1343                 strcpy (pack->files[i].name, info[i].name);
1344                 pack->files[i].filepos = LittleLong(info[i].filepos);
1345                 pack->files[i].filelen = LittleLong(info[i].filelen);
1346         }
1347
1348         Mem_Free(info);
1349
1350         Con_Printf ("Added packfile %s (%i files)\n", packfile, numpackfiles);
1351         return pack;
1352 }
1353
1354
1355 /*
1356 ================
1357 COM_AddGameDirectory
1358
1359 Sets com_gamedir, adds the directory to the head of the path,
1360 then loads and adds pak1.pak pak2.pak ...
1361 ================
1362 */
1363 void COM_AddGameDirectory (char *dir)
1364 {
1365         stringlist_t *list, *current;
1366         searchpath_t *search;
1367         pack_t *pak;
1368         char pakfile[MAX_OSPATH];
1369
1370         strcpy (com_gamedir, dir);
1371
1372 //
1373 // add the directory to the search path
1374 //
1375         search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
1376         strcpy (search->filename, dir);
1377         search->next = com_searchpaths;
1378         com_searchpaths = search;
1379
1380         // add any paks in the directory
1381         list = listdirectory(dir);
1382         for (current = list;current;current = current->next)
1383         {
1384                 if (matchpattern(current->text, "*.pak"))
1385                 {
1386                         sprintf (pakfile, "%s/%s", dir, current->text);
1387                         pak = COM_LoadPackFile (pakfile);
1388                         if (pak)
1389                         {
1390                                 search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
1391                                 search->pack = pak;
1392                                 search->next = com_searchpaths;
1393                                 com_searchpaths = search;
1394                         }
1395                         else
1396                                 Con_Printf("unable to load pak \"%s\"\n", pakfile);
1397                 }
1398         }
1399         freedirectory(list);
1400 }
1401
1402 /*
1403 ================
1404 COM_InitFilesystem
1405 ================
1406 */
1407 void COM_InitFilesystem (void)
1408 {
1409         int             i, j;
1410         char    basedir[MAX_OSPATH];
1411         searchpath_t    *search;
1412
1413 //
1414 // -basedir <path>
1415 // Overrides the system supplied base directory (under GAMENAME)
1416 //
1417         i = COM_CheckParm ("-basedir");
1418         if (i && i < com_argc-1)
1419                 strcpy (basedir, com_argv[i+1]);
1420         else
1421                 strcpy (basedir, host_parms.basedir);
1422
1423         j = strlen (basedir);
1424
1425         if (j > 0)
1426         {
1427                 if ((basedir[j-1] == '\\') || (basedir[j-1] == '/'))
1428                         basedir[j-1] = 0;
1429         }
1430
1431 #if CACHEENABLE
1432 //
1433 // -cachedir <path>
1434 // Overrides the system supplied cache directory (NULL or /qcache)
1435 // -cachedir - will disable caching.
1436 //
1437         i = COM_CheckParm ("-cachedir");
1438         if (i && i < com_argc-1)
1439         {
1440                 if (com_argv[i+1][0] == '-')
1441                         com_cachedir[0] = 0;
1442                 else
1443                         strcpy (com_cachedir, com_argv[i+1]);
1444         }
1445         else if (host_parms.cachedir)
1446                 strcpy (com_cachedir, host_parms.cachedir);
1447         else
1448                 com_cachedir[0] = 0;
1449 #endif
1450
1451 // start up with GAMENAME by default (id1)
1452         COM_AddGameDirectory (va("%s/"GAMENAME, basedir) );
1453
1454         switch(gamemode)
1455         {
1456         case GAME_NORMAL:
1457                 break;
1458         case GAME_HIPNOTIC:
1459                 COM_AddGameDirectory (va("%s/hipnotic", basedir) );
1460                 break;
1461         case GAME_ROGUE:
1462                 COM_AddGameDirectory (va("%s/rogue", basedir) );
1463                 break;
1464         case GAME_NEHAHRA:
1465                 COM_AddGameDirectory (va("%s/nehahra", basedir) );
1466                 break;
1467         case GAME_FIENDARENA:
1468                 COM_AddGameDirectory (va("%s/fiendarena", basedir) );
1469                 break;
1470         case GAME_ZYMOTIC:
1471                 COM_AddGameDirectory (va("%s/zymotic", basedir) );
1472                 break;
1473         case GAME_BLOODBATH:
1474                 COM_AddGameDirectory (va("%s/bb", basedir) );
1475                 break;
1476         default:
1477                 Sys_Error("COM_InitFilesystem: unknown gamemode %i\n", gamemode);
1478                 break;
1479         }
1480
1481 //
1482 // -game <gamedir>
1483 // Adds basedir/gamedir as an override game
1484 //
1485         i = COM_CheckParm ("-game");
1486         if (i && i < com_argc-1)
1487         {
1488                 com_modified = true;
1489                 COM_AddGameDirectory (va("%s/%s", basedir, com_argv[i+1]));
1490         }
1491
1492 //
1493 // -path <dir or packfile> [<dir or packfile>] ...
1494 // Fully specifies the exact search path, overriding the generated one
1495 //
1496         i = COM_CheckParm ("-path");
1497         if (i)
1498         {
1499                 com_modified = true;
1500                 com_searchpaths = NULL;
1501                 while (++i < com_argc)
1502                 {
1503                         if (!com_argv[i] || com_argv[i][0] == '+' || com_argv[i][0] == '-')
1504                                 break;
1505
1506                         search = Mem_Alloc(pak_mempool, sizeof(searchpath_t));
1507                         if ( !strcmp(COM_FileExtension(com_argv[i]), "pak") )
1508                         {
1509                                 search->pack = COM_LoadPackFile (com_argv[i]);
1510                                 if (!search->pack)
1511                                         Sys_Error ("Couldn't load packfile: %s", com_argv[i]);
1512                         }
1513                         else
1514                                 strcpy (search->filename, com_argv[i]);
1515                         search->next = com_searchpaths;
1516                         com_searchpaths = search;
1517                 }
1518         }
1519 }
1520
1521 int COM_FileExists(char *filename)
1522 {
1523         searchpath_t    *search;
1524         char                    netpath[MAX_OSPATH];
1525         pack_t                  *pak;
1526         int                             i;
1527         int                             findtime;
1528
1529         for (search = com_searchpaths;search;search = search->next)
1530         {
1531                 if (search->pack)
1532                 {
1533                         pak = search->pack;
1534                         for (i = 0;i < pak->numfiles;i++)
1535                                 if (!strcmp (pak->files[i].name, filename))
1536                                         return true;
1537                 }
1538                 else
1539                 {
1540                         sprintf (netpath, "%s/%s",search->filename, filename);
1541                         findtime = Sys_FileTime (netpath);
1542                         if (findtime != -1)
1543                                 return true;
1544                 }
1545         }
1546
1547         return false;
1548 }
1549
1550
1551 //======================================
1552 // LordHavoc: added these because they are useful
1553
1554 void COM_ToLowerString(char *in, char *out)
1555 {
1556         while (*in)
1557         {
1558                 if (*in >= 'A' && *in <= 'Z')
1559                         *out++ = *in++ + 'a' - 'A';
1560                 else
1561                         *out++ = *in++;
1562         }
1563 }
1564
1565 void COM_ToUpperString(char *in, char *out)
1566 {
1567         while (*in)
1568         {
1569                 if (*in >= 'a' && *in <= 'z')
1570                         *out++ = *in++ + 'A' - 'a';
1571                 else
1572                         *out++ = *in++;
1573         }
1574 }
1575