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