base/i_linux.c

   1 //**************************************************************************
   2 //**
   3 //** $Id$
   4 //**
   5 //**************************************************************************
   6
   7
   8 #include <stdlib.h>
   9 #include <stdarg.h>
  10 #include <sys/time.h>
  11 #include "h2def.h"
  12 #include "r_local.h"
  13 #include "p_local.h"    // for P_AproxDistance
  14 #include "sounds.h"
  15 #include "i_sound.h"
  16 #include "soundst.h"
  17 #include "st_start.h"
  18
  19
  20 // Macros
  21
  22 #define stricmp strcasecmp
  23 #define DEFAULT_ARCHIVEPATH     "o:\\sound\\archive\\"
  24 #define PRIORITY_MAX_ADJUST 10
  25 #define DIST_ADJUST (MAX_SND_DIST/PRIORITY_MAX_ADJUST)
  26
  27 #define KEY_LSHIFT      0xfe
  28
  29 #define KEY_INS         (0x80+0x52)
  30 #define KEY_DEL         (0x80+0x53)
  31 #define KEY_PGUP        (0x80+0x49)
  32 #define KEY_PGDN        (0x80+0x51)
  33 #define KEY_HOME        (0x80+0x47)
  34 #define KEY_END         (0x80+0x4f)
  35
  36 extern void **lumpcache;
  37
  38 extern void I_StartupMouse(void);
  39 extern void I_ShutdownGraphics(void);
  40
  41 int i_Vector;
  42 externdata_t *i_ExternData;
  43 boolean useexterndriver;
  44
  45 boolean i_CDMusic;
  46 int i_CDTrack;
  47 int i_CDCurrentTrack;
  48 int i_CDMusicLength;
  49 int oldTic;
  50
  51 extern boolean cdaudio;
  52
  53 extern void I_CDMusShutdown(void);
  54 extern void I_CDMusUpdate(void);
  55
  56 /*
  57 ===============================================================================
  58
  59                 MUSIC & SFX API
  60
  61 ===============================================================================
  62 */
  63
  64 //static channel_t channel[MAX_CHANNELS];
  65
  66 //static int rs; //the current registered song.
  67 //int mus_song = -1;
  68 //int mus_lumpnum;
  69 //void *mus_sndptr;
  70 //byte *soundCurve;
  71
  72 extern sfxinfo_t S_sfx[];
  73 extern musicinfo_t S_music[];
  74
  75 static channel_t Channel[MAX_CHANNELS];
  76 static int RegisteredSong; //the current registered song.
  77 static int NextCleanup;
  78 static boolean MusicPaused;
  79 static int Mus_Song = -1;
  80 static int Mus_LumpNum;
  81 static void *Mus_SndPtr;
  82 static byte *SoundCurve;
  83
  84 static boolean UseSndScript;
  85 static char ArchivePath[128];
  86
  87 extern int snd_MusicDevice;
  88 extern int snd_SfxDevice;
  89 extern int snd_MaxVolume;
  90 extern int snd_MusicVolume;
  91 extern int snd_Channels;
  92
  93 extern int startepisode;
  94 extern int startmap;
  95
  96 // int AmbChan;
  97
  98 boolean S_StopSoundID(int sound_id, int priority);
  99
 100 //==========================================================================
 101 //
 102 // S_Start
 103 //
 104 //==========================================================================
 105
 106 void S_Start(void)
 107 {
 108         S_StopAllSound();
 109         S_StartSong(gamemap, true);
 110 }
 111
 112 //==========================================================================
 113 //
 114 // S_StartSong
 115 //
 116 //==========================================================================
 117
 118 void S_StartSong(int song, boolean loop)
 119 {
 120         char *songLump;
 121         int track;
 122
 123         if(i_CDMusic)
 124         { // Play a CD track, instead
 125                 if(i_CDTrack)
 126                 { // Default to the player-chosen track
 127                         track = i_CDTrack;
 128                 }
 129                 else
 130                 {
 131                         track = P_GetMapCDTrack(gamemap);
 132                 }
 133                 if(track == i_CDCurrentTrack && i_CDMusicLength > 0)
 134                 {
 135                         return;
 136                 }
 137                 if(!I_CDMusPlay(track))
 138                 {
 139 /*                      if(loop)
 140                         {
 141 //                              i_CDMusicLength = 35*I_CDMusTrackLength(track);
 142                                 oldTic = gametic;
 143                         }
 144                         else
 145                         {
 146                                 i_CDMusicLength = -1;
 147                         }
 148 */
 149                         i_CDCurrentTrack = track;
 150                 }
 151         }
 152         else
 153         {
 154                 if(song == Mus_Song)
 155                 { // don't replay an old song
 156                         return;
 157                 }
 158                 if(RegisteredSong)
 159                 {
 160                         I_StopSong(RegisteredSong);
 161                         I_UnRegisterSong(RegisteredSong);
 162                         if(UseSndScript)
 163                         {
 164                                 Z_Free(Mus_SndPtr);
 165                         }
 166                         else
 167                         {
 168                                 Z_ChangeTag(lumpcache[Mus_LumpNum], PU_CACHE);
 169                         }
 170                         RegisteredSong = 0;
 171                 }
 172                 songLump = P_GetMapSongLump(song);
 173                 if(!songLump)
 174                 {
 175                         return;
 176                 }
 177                 if(UseSndScript)
 178                 {
 179                         char name[128];
 180                         sprintf(name, "%s%s.lmp", ArchivePath, songLump);
 181                         M_ReadFile(name, (byte **)&Mus_SndPtr);
 182                 }
 183                 else
 184                 {
 185                         Mus_LumpNum = W_GetNumForName(songLump);
 186                         Mus_SndPtr = W_CacheLumpNum(Mus_LumpNum, PU_MUSIC);
 187                 }
 188                 RegisteredSong = I_RegisterSong(Mus_SndPtr);
 189                 I_PlaySong(RegisteredSong, loop); // 'true' denotes endless looping.
 190                 Mus_Song = song;
 191         }
 192 }
 193
 194 //==========================================================================
 195 //
 196 // S_StartSongName
 197 //
 198 //==========================================================================
 199
 200 void S_StartSongName(char *songLump, boolean loop)
 201 {
 202         int cdTrack;
 203
 204         if(!songLump)
 205         {
 206                 return;
 207         }
 208         if(i_CDMusic)
 209         {
 210                 cdTrack = 0;
 211
 212                 if(!strcmp(songLump, "hexen"))
 213                 {
 214                         cdTrack = P_GetCDTitleTrack();
 215                 }
 216                 else if(!strcmp(songLump, "hub"))
 217                 {
 218                         cdTrack = P_GetCDIntermissionTrack();
 219                 }
 220                 else if(!strcmp(songLump, "hall"))
 221                 {
 222                         cdTrack = P_GetCDEnd1Track();
 223                 }
 224                 else if(!strcmp(songLump, "orb"))
 225                 {
 226                         cdTrack = P_GetCDEnd2Track();
 227                 }
 228                 else if(!strcmp(songLump, "chess") && !i_CDTrack)
 229                 {
 230                         cdTrack = P_GetCDEnd3Track();
 231                 }
 232 /*      Uncomment this, if Kevin writes a specific song for startup
 233                 else if(!strcmp(songLump, "start"))
 234                 {
 235                         cdTrack = P_GetCDStartTrack();
 236                 }
 237 */
 238                 if(!cdTrack || (cdTrack == i_CDCurrentTrack && i_CDMusicLength > 0))
 239                 {
 240                         return;
 241                 }
 242                 if(!I_CDMusPlay(cdTrack))
 243                 {
 244 /*                      if(loop)
 245                         {
 246                                 i_CDMusicLength = 35*I_CDMusTrackLength(cdTrack);
 247                                 oldTic = gametic;
 248                         }
 249                         else
 250                         {
 251                                 i_CDMusicLength = -1;
 252                         }
 253 */
 254                         i_CDCurrentTrack = cdTrack;
 255                         i_CDTrack = false;
 256                 }
 257         }
 258         else
 259         {
 260                 if(RegisteredSong)
 261                 {
 262                         I_StopSong(RegisteredSong);
 263                         I_UnRegisterSong(RegisteredSong);
 264                         if(UseSndScript)
 265                         {
 266                                 Z_Free(Mus_SndPtr);
 267                         }
 268                         else
 269                         {
 270                                 Z_ChangeTag(lumpcache[Mus_LumpNum], PU_CACHE);
 271                         }
 272                         RegisteredSong = 0;
 273                 }
 274                 if(UseSndScript)
 275                 {
 276                         char name[128];
 277                         sprintf(name, "%s%s.lmp", ArchivePath, songLump);
 278                         M_ReadFile(name, (byte **)&Mus_SndPtr);
 279                 }
 280                 else
 281                 {
 282                         Mus_LumpNum = W_GetNumForName(songLump);
 283                         Mus_SndPtr = W_CacheLumpNum(Mus_LumpNum, PU_MUSIC);
 284                 }
 285                 RegisteredSong = I_RegisterSong(Mus_SndPtr);
 286                 I_PlaySong(RegisteredSong, loop); // 'true' denotes endless looping.
 287                 Mus_Song = -1;
 288         }
 289 }
 290
 291 //==========================================================================
 292 //
 293 // S_GetSoundID
 294 //
 295 //==========================================================================
 296
 297 int S_GetSoundID(char *name)
 298 {
 299         int i;
 300
 301         for(i = 0; i < NUMSFX; i++)
 302         {
 303                 if(!strcmp(S_sfx[i].tagName, name))
 304                 {
 305                         return i;
 306                 }
 307         }
 308         return 0;
 309 }
 310
 311 //==========================================================================
 312 //
 313 // S_StartSound
 314 //
 315 //==========================================================================
 316
 317 void S_StartSound(mobj_t *origin, int sound_id)
 318 {
 319         S_StartSoundAtVolume(origin, sound_id, 127);
 320 }
 321
 322 //==========================================================================
 323 //
 324 // S_StartSoundAtVolume
 325 //
 326 //==========================================================================
 327 #if 0
 328 void S_StartSoundAtVolume(mobj_t *origin, int sound_id, int volume)
 329 {
 330         int dist, vol;
 331         int i = 0;       /* jim - initialise to avoid gcc warning */
 332         int priority;
 333         int sep;
 334         int angle;
 335         int absx;
 336         int absy;
 337
 338         static int sndcount = 0;
 339         int chan;
 340
 341     //printf( "S_StartSoundAtVolume: %d\n", sound_id );
 342
 343         if(sound_id == 0 || snd_MaxVolume == 0)
 344                 return;
 345         if(origin == NULL)
 346         {
 347                 origin = players[displayplayer].mo;
 348         }
 349         if(volume == 0)
 350         {
 351                 return;
 352         }
 353
 354     // How does the DOS version work without this check?
 355     // players[0].mo does not get set until P_SpawnPlayer. - KR
 356
 357     if( origin )
 358     {
 359         // calculate the distance before other stuff so that we can throw out
 360         // sounds that are beyond the hearing range.
 361         absx = abs(origin->x-players[displayplayer].mo->x);
 362         absy = abs(origin->y-players[displayplayer].mo->y);
 363         dist = absx+absy-(absx > absy ? absy>>1 : absx>>1);
 364         dist >>= FRACBITS;
 365         if(dist >= MAX_SND_DIST)
 366         {
 367           return; // sound is beyond the hearing range...
 368         }
 369         if(dist < 0)
 370         {
 371             dist = 0;
 372         }
 373         priority = S_sfx[sound_id].priority;
 374         priority *= (PRIORITY_MAX_ADJUST-(dist/DIST_ADJUST));
 375         if(!S_StopSoundID(sound_id, priority))
 376         {
 377             return; // other sounds have greater priority
 378         }
 379         for(i = 0; i<snd_Channels; i++)
 380         {
 381             if(origin->player)
 382             {
 383                 i = snd_Channels;
 384                 break; // let the player have more than one sound.
 385             }
 386             if(origin == Channel[i].mo)
 387             { // only allow other mobjs one sound
 388                 S_StopSound(Channel[i].mo);
 389                 break;
 390             }
 391         }
 392         }
 393     else
 394     {
 395         dist = 0;
 396         priority = S_sfx[sound_id].priority;
 397         if( ! S_StopSoundID( sound_id, priority ) )
 398         {
 399             return; // other sounds have greater priority
 400         }
 401     }
 402
 403         if(i >= snd_Channels)
 404         {
 405                 for(i = 0; i < snd_Channels; i++)
 406                 {
 407                         if(Channel[i].mo == NULL)
 408                         {
 409                                 break;
 410                         }
 411                 }
 412                 if(i >= snd_Channels)
 413                 {
 414                         // look for a lower priority sound to replace.
 415                         sndcount++;
 416                         if(sndcount >= snd_Channels)
 417                         {
 418                                 sndcount = 0;
 419                         }
 420                         for(chan = 0; chan < snd_Channels; chan++)
 421                         {
 422                                 i = (sndcount+chan)%snd_Channels;
 423                                 if(priority >= Channel[i].priority)
 424                                 {
 425                                         chan = -1; //denote that sound should be replaced.
 426                                         break;
 427                                 }
 428                         }
 429                         if(chan != -1)
 430                         {
 431                                 return; //no free channels.
 432                         }
 433                         else //replace the lower priority sound.
 434                         {
 435                                 if(Channel[i].handle)
 436                                 {
 437                                         if(I_SoundIsPlaying(Channel[i].handle))
 438                                         {
 439                                                 I_StopSound(Channel[i].handle);
 440                                         }
 441                                         if(S_sfx[Channel[i].sound_id].usefulness > 0)
 442                                         {
 443                                                 S_sfx[Channel[i].sound_id].usefulness--;
 444                                         }
 445                                 }
 446                         }
 447                 }
 448         }
 449         if(S_sfx[sound_id].lumpnum == 0)
 450         {
 451                 S_sfx[sound_id].lumpnum = I_GetSfxLumpNum(&S_sfx[sound_id]);
 452         }
 453         if(S_sfx[sound_id].snd_ptr == NULL)
 454         {
 455                 if(UseSndScript)
 456                 {
 457                         char name[128];
 458                         sprintf(name, "%s%s.lmp", ArchivePath, S_sfx[sound_id].lumpname);
 459                         M_ReadFile(name, (byte **)&S_sfx[sound_id].snd_ptr);
 460                 }
 461                 else
 462                 {
 463                         S_sfx[sound_id].snd_ptr = W_CacheLumpNum(S_sfx[sound_id].lumpnum,
 464                                 PU_SOUND);
 465                 }
 466         }
 467
 468         vol = (SoundCurve[dist]*(snd_MaxVolume*8)*volume)>>14;
 469         if(origin == players[displayplayer].mo)
 470         {
 471                 sep = 128;
 472 //              vol = (volume*(snd_MaxVolume+1)*8)>>7;
 473         }
 474         else
 475         {
 476 #if 1
 477         // KR - Channel[i].mo = 0 here!
 478         if( Channel[i].mo == NULL )
 479         {
 480             sep = 128;
 481             //printf( " Channel[i].mo not set\n" );
 482         }
 483         else
 484         {
 485 #endif
 486                 angle = R_PointToAngle2(players[displayplayer].mo->x,
 487                         players[displayplayer].mo->y, Channel[i].mo->x, Channel[i].mo->y);
 488                 angle = (angle-viewangle)>>24;
 489                 sep = angle*2-128;
 490                 if(sep < 64)
 491                         sep = -sep;
 492                 if(sep > 192)
 493                         sep = 512-sep;
 494 //              vol = SoundCurve[dist];
 495 #if 1
 496         }
 497 #endif
 498         }
 499
 500         if(S_sfx[sound_id].changePitch)
 501         {
 502                 Channel[i].pitch = (byte)(127+(M_Random()&7)-(M_Random()&7));
 503         }
 504         else
 505         {
 506                 Channel[i].pitch = 127;
 507         }
 508         Channel[i].handle = I_StartSound( sound_id, S_sfx[sound_id].snd_ptr, vol,
 509                                           sep, Channel[i].pitch, 0 );
 510         Channel[i].mo = origin;
 511         Channel[i].sound_id = sound_id;
 512         Channel[i].priority = priority;
 513         Channel[i].volume = volume;
 514         if(S_sfx[sound_id].usefulness < 0)
 515         {
 516                 S_sfx[sound_id].usefulness = 1;
 517         }
 518         else
 519         {
 520                 S_sfx[sound_id].usefulness++;
 521         }
 522 }
 523 #endif
 524 void S_StartSoundAtVolume(mobj_t *origin, int sound_id, int volume)
 525 {
 526         int dist, vol;
 527         int i;
 528         int priority;
 529         int sep;
 530         int angle;
 531         int absx;
 532         int absy;
 533
 534         static int sndcount = 0;
 535         int chan;
 536
 537         if(sound_id == 0 || snd_MaxVolume == 0)
 538                 return;
 539 #if 0
 540         if(origin == NULL)
 541         {
 542 // origin = players[displayplayer].mo; bug -- can be uninitialized
 543         }
 544 #endif
 545         if(volume == 0)
 546         {
 547                 return;
 548         }
 549
 550         // calculate the distance before other stuff so that we can throw out
 551         // sounds that are beyond the hearing range.
 552         if (origin)
 553         {
 554         absx = abs(origin->x-players[displayplayer].mo->x);
 555         absy = abs(origin->y-players[displayplayer].mo->y);
 556         }
 557         else
 558           absx = absy = 0;
 559         dist = absx+absy-(absx > absy ? absy>>1 : absx>>1);
 560         dist >>= FRACBITS;
 561         if(dist >= MAX_SND_DIST)
 562         {
 563           return; // sound is beyond the hearing range...
 564         }
 565         if(dist < 0)
 566         {
 567                 dist = 0;
 568         }
 569         priority = S_sfx[sound_id].priority;
 570         priority *= (PRIORITY_MAX_ADJUST-(dist/DIST_ADJUST));
 571         if(!S_StopSoundID(sound_id, priority))
 572         {
 573                 return; // other sounds have greater priority
 574         }
 575         for(i=0; i<snd_Channels; i++)
 576         {
 577                 if(!origin || origin->player)
 578                 {
 579                         i = snd_Channels;
 580                         break; // let the player have more than one sound.
 581                 }
 582                 if(origin == Channel[i].mo)
 583                 { // only allow other mobjs one sound
 584                         S_StopSound(Channel[i].mo);
 585                         break;
 586                 }
 587         }
 588         if(i >= snd_Channels)
 589         {
 590                 for(i = 0; i < snd_Channels; i++)
 591                 {
 592                         if(Channel[i].mo == NULL)
 593                         {
 594                                 break;
 595                         }
 596                 }
 597                 if(i >= snd_Channels)
 598                 {
 599                         // look for a lower priority sound to replace.
 600                         sndcount++;
 601                         if(sndcount >= snd_Channels)
 602                         {
 603                                 sndcount = 0;
 604                         }
 605                         for(chan = 0; chan < snd_Channels; chan++)
 606                         {
 607                                 i = (sndcount+chan)%snd_Channels;
 608                                 if(priority >= Channel[i].priority)
 609                                 {
 610                                         chan = -1; //denote that sound should be replaced.
 611                                         break;
 612                                 }
 613                         }
 614                         if(chan != -1)
 615                         {
 616                                 return; //no free channels.
 617                         }
 618                         else //replace the lower priority sound.
 619                         {
 620                                 if(Channel[i].handle)
 621                                 {
 622                                         if(I_SoundIsPlaying(Channel[i].handle))
 623                                         {
 624                                                 I_StopSound(Channel[i].handle);
 625                                         }
 626                                         if(S_sfx[Channel[i].sound_id].usefulness > 0)
 627                                         {
 628                                                 S_sfx[Channel[i].sound_id].usefulness--;
 629                                         }
 630                                 }
 631                         }
 632                 }
 633         }
 634         if(S_sfx[sound_id].lumpnum == 0)
 635         {
 636                 S_sfx[sound_id].lumpnum = I_GetSfxLumpNum(&S_sfx[sound_id]);
 637         }
 638         if(S_sfx[sound_id].snd_ptr == NULL)
 639         {
 640                 if(UseSndScript)
 641                 {
 642                         char name[128];
 643                         sprintf(name, "%s%s.lmp", ArchivePath, S_sfx[sound_id].lumpname);
 644                         M_ReadFile(name, (byte **)&S_sfx[sound_id].snd_ptr);
 645                 }
 646                 else
 647                 {
 648                         S_sfx[sound_id].snd_ptr = W_CacheLumpNum(S_sfx[sound_id].lumpnum,
 649                                 PU_SOUND);
 650                 }
 651                 #ifdef __WATCOMC__
 652 //                _dpmi_lockregion(S_sfx[sound_id].snd_ptr,
 653 //                        lumpinfo[S_sfx[sound_id].lumpnum].size);
 654                 #endif
 655         }
 656
 657         vol = (SoundCurve[dist]*(snd_MaxVolume*8)*volume)>>14;
 658         if (!origin || origin == players[displayplayer].mo)
 659         {
 660                 sep = 128;
 661 //              vol = (volume*(snd_MaxVolume+1)*8)>>7;
 662         }
 663         else
 664         {
 665                 angle = R_PointToAngle2(players[displayplayer].mo->x,
 666 // bug!                        players[displayplayer].mo->y, Channel[i].mo->x, Channel[i].mo->y);
 667                         players[displayplayer].mo->y, origin->x, origin->y);
 668                 angle = (angle-viewangle)>>24;
 669                 sep = angle*2-128;
 670                 if(sep < 64)
 671                         sep = -sep;
 672                 if(sep > 192)
 673                         sep = 512-sep;
 674 //              vol = SoundCurve[dist];
 675         }
 676
 677         if(S_sfx[sound_id].changePitch)
 678         {
 679                 Channel[i].pitch = (byte)(127+(M_Random()&7)-(M_Random()&7));
 680         }
 681         else
 682         {
 683                 Channel[i].pitch = 127;
 684         }
 685         Channel[i].handle = I_StartSound(sound_id, S_sfx[sound_id].snd_ptr, vol,
 686                 sep, Channel[i].pitch, 0);
 687         Channel[i].mo = origin;
 688         Channel[i].sound_id = sound_id;
 689         Channel[i].priority = priority;
 690         Channel[i].volume = volume;
 691         if(S_sfx[sound_id].usefulness < 0)
 692         {
 693                 S_sfx[sound_id].usefulness = 1;
 694         }
 695         else
 696         {
 697                 S_sfx[sound_id].usefulness++;
 698         }
 699 }
 700 //==========================================================================
 701 //
 702 // S_StopSoundID
 703 //
 704 //==========================================================================
 705
 706 boolean S_StopSoundID(int sound_id, int priority)
 707 {
 708         int i;
 709         int lp; //least priority
 710         int found;
 711
 712         if(S_sfx[sound_id].numchannels == -1)
 713         {
 714                 return(true);
 715         }
 716         lp = -1; //denote the argument sound_id
 717         found = 0;
 718         for(i=0; i<snd_Channels; i++)
 719         {
 720                 if(Channel[i].sound_id == sound_id && Channel[i].mo)
 721                 {
 722                         found++; //found one.  Now, should we replace it??
 723                         if(priority >= Channel[i].priority)
 724                         { // if we're gonna kill one, then this'll be it
 725                                 lp = i;
 726                                 priority = Channel[i].priority;
 727                         }
 728                 }
 729         }
 730         if(found < S_sfx[sound_id].numchannels)
 731         {
 732                 return(true);
 733         }
 734         else if(lp == -1)
 735         {
 736                 return(false); // don't replace any sounds
 737         }
 738         if(Channel[lp].handle)
 739         {
 740                 if(I_SoundIsPlaying(Channel[lp].handle))
 741                 {
 742                         I_StopSound(Channel[lp].handle);
 743                 }
 744                 if(S_sfx[Channel[lp].sound_id].usefulness > 0)
 745                 {
 746                         S_sfx[Channel[lp].sound_id].usefulness--;
 747                 }
 748                 Channel[lp].mo = NULL;
 749         }
 750         return(true);
 751 }
 752
 753 //==========================================================================
 754 //
 755 // S_StopSound
 756 //
 757 //==========================================================================
 758
 759 void S_StopSound(mobj_t *origin)
 760 {
 761         int i;
 762
 763         for(i=0;i<snd_Channels;i++)
 764         {
 765                 if(Channel[i].mo == origin)
 766                 {
 767                         I_StopSound(Channel[i].handle);
 768                         if(S_sfx[Channel[i].sound_id].usefulness > 0)
 769                         {
 770                                 S_sfx[Channel[i].sound_id].usefulness--;
 771                         }
 772                         Channel[i].handle = 0;
 773                         Channel[i].mo = NULL;
 774                 }
 775         }
 776 }
 777
 778 //==========================================================================
 779 //
 780 // S_StopAllSound
 781 //
 782 //==========================================================================
 783
 784 void S_StopAllSound(void)
 785 {
 786         int i;
 787
 788         //stop all sounds
 789         for(i=0; i < snd_Channels; i++)
 790         {
 791                 if(Channel[i].handle)
 792                 {
 793                         S_StopSound(Channel[i].mo);
 794                 }
 795         }
 796         memset(Channel, 0, 8*sizeof(channel_t));
 797 }
 798
 799 //==========================================================================
 800 //
 801 // S_SoundLink
 802 //
 803 //==========================================================================
 804
 805 void S_SoundLink(mobj_t *oldactor, mobj_t *newactor)
 806 {
 807         int i;
 808
 809         for(i=0;i<snd_Channels;i++)
 810         {
 811                 if(Channel[i].mo == oldactor)
 812                         Channel[i].mo = newactor;
 813         }
 814 }
 815
 816 //==========================================================================
 817 //
 818 // S_PauseSound
 819 //
 820 //==========================================================================
 821
 822 void S_PauseSound(void)
 823 {
 824         if(i_CDMusic)
 825         {
 826                 I_CDMusStop();
 827         }
 828         else
 829         {
 830                 I_PauseSong(RegisteredSong);
 831         }
 832 }
 833
 834 //==========================================================================
 835 //
 836 // S_ResumeSound
 837 //
 838 //==========================================================================
 839
 840 void S_ResumeSound(void)
 841 {
 842         if(i_CDMusic)
 843         {
 844                 I_CDMusResume();
 845         }
 846         else
 847         {
 848                 I_ResumeSong(RegisteredSong);
 849         }
 850 }
 851
 852 //==========================================================================
 853 //
 854 // S_UpdateSounds
 855 //
 856 //==========================================================================
 857
 858 void S_UpdateSounds(mobj_t *listener)
 859 {
 860         int i, dist, vol;
 861         int angle;
 862         int sep;
 863         int priority;
 864         int absx;
 865         int absy;
 866
 867         if(i_CDMusic)
 868         {
 869                 I_CDMusUpdate();
 870         }
 871         if(snd_MaxVolume == 0)
 872         {
 873                 return;
 874         }
 875
 876         // Update any Sequences
 877         SN_UpdateActiveSequences();
 878
 879         if(NextCleanup < gametic)
 880         {
 881                 if(UseSndScript)
 882                 {
 883                         for(i = 0; i < NUMSFX; i++)
 884                         {
 885                                 if(S_sfx[i].usefulness == 0 && S_sfx[i].snd_ptr)
 886                                 {
 887                                         S_sfx[i].usefulness = -1;
 888                                 }
 889                         }
 890                 }
 891                 else
 892                 {
 893                         for(i = 0; i < NUMSFX; i++)
 894                         {
 895                                 if(S_sfx[i].usefulness == 0 && S_sfx[i].snd_ptr)
 896                                 {
 897                                         if(lumpcache[S_sfx[i].lumpnum])
 898                                         {
 899                                                 if(((memblock_t *)((byte*)
 900                                                         (lumpcache[S_sfx[i].lumpnum])-
 901                                                         sizeof(memblock_t)))->id == 0x1d4a11)
 902                                                 { // taken directly from the Z_ChangeTag macro
 903                                                         Z_ChangeTag2(lumpcache[S_sfx[i].lumpnum],
 904                                                                 PU_CACHE);
 905                                                 }
 906                                         }
 907                                         S_sfx[i].usefulness = -1;
 908                                         S_sfx[i].snd_ptr = NULL;
 909                                 }
 910                         }
 911                 }
 912                 NextCleanup = gametic+35*30; // every 30 seconds
 913         }
 914         for(i=0;i<snd_Channels;i++)
 915         {
 916                 if(!Channel[i].handle || S_sfx[Channel[i].sound_id].usefulness == -1)
 917                 {
 918                         continue;
 919                 }
 920                 if(!I_SoundIsPlaying(Channel[i].handle))
 921                 {
 922                         if(S_sfx[Channel[i].sound_id].usefulness > 0)
 923                         {
 924                                 S_sfx[Channel[i].sound_id].usefulness--;
 925                         }
 926                         Channel[i].handle = 0;
 927                         Channel[i].mo = NULL;
 928                         Channel[i].sound_id = 0;
 929                 }
 930                 if(Channel[i].mo == NULL || Channel[i].sound_id == 0
 931                         || Channel[i].mo == listener)
 932                 {
 933                         continue;
 934                 }
 935                 else
 936                 {
 937                         absx = abs(Channel[i].mo->x-listener->x);
 938                         absy = abs(Channel[i].mo->y-listener->y);
 939                         dist = absx+absy-(absx > absy ? absy>>1 : absx>>1);
 940                         dist >>= FRACBITS;
 941
 942                         if(dist >= MAX_SND_DIST)
 943                         {
 944                                 S_StopSound(Channel[i].mo);
 945                                 continue;
 946                         }
 947                         if(dist < 0)
 948                         {
 949                                 dist = 0;
 950                         }
 951                         //vol = SoundCurve[dist];
 952                         vol = (SoundCurve[dist]*(snd_MaxVolume*8)*Channel[i].volume)>>14;
 953                         if(Channel[i].mo == listener)
 954                         {
 955                                 sep = 128;
 956                         }
 957                         else
 958                         {
 959                                 angle = R_PointToAngle2(listener->x, listener->y,
 960                                                                 Channel[i].mo->x, Channel[i].mo->y);
 961                                 angle = (angle-viewangle)>>24;
 962                                 sep = angle*2-128;
 963                                 if(sep < 64)
 964                                         sep = -sep;
 965                                 if(sep > 192)
 966                                         sep = 512-sep;
 967                         }
 968                         I_UpdateSoundParams(Channel[i].handle, vol, sep,
 969                                 Channel[i].pitch);
 970                         priority = S_sfx[Channel[i].sound_id].priority;
 971                         priority *= PRIORITY_MAX_ADJUST-(dist/DIST_ADJUST);
 972                         Channel[i].priority = priority;
 973                 }
 974         }
 975 }
 976
 977 //==========================================================================
 978 //
 979 // S_Init
 980 //
 981 //==========================================================================
 982
 983 void S_Init(void)
 984 {
 985         SoundCurve = W_CacheLumpName("SNDCURVE", PU_STATIC);
 986 //      SoundCurve = Z_Malloc(MAX_SND_DIST, PU_STATIC, NULL);
 987         I_StartupSound();
 988         if(snd_Channels > 8)
 989         {
 990                 snd_Channels = 8;
 991         }
 992         I_SetChannels(snd_Channels);
 993         I_SetMusicVolume(snd_MusicVolume);
 994
 995         // Attempt to setup CD music
 996         if(cdaudio == true)
 997         {
 998                 ST_Message("  Attempting to initialize CD Music: ");
 999                 if(!cdrom)
1000                 {
1001                         i_CDMusic = (I_CDMusInit() != -1);
1002                 }
1003                 else
1004                 { // The user is trying to use the cdrom for both game and music
1005                         i_CDMusic = false;
1006                 }
1007                 if(i_CDMusic)
1008                 {
1009                         ST_Message("initialized.\n");
1010                 }
1011                 else
1012                 {
1013                         ST_Message("failed.\n");
1014                 }
1015         }
1016 }
1017
1018 //==========================================================================
1019 //
1020 // S_GetChannelInfo
1021 //
1022 //==========================================================================
1023
1024 void S_GetChannelInfo(SoundInfo_t *s)
1025 {
1026         int i;
1027         ChanInfo_t *c;
1028
1029         s->channelCount = snd_Channels;
1030         s->musicVolume = snd_MusicVolume;
1031         s->soundVolume = snd_MaxVolume;
1032         for(i = 0; i < snd_Channels; i++)
1033         {
1034                 c = &s->chan[i];
1035                 c->id = Channel[i].sound_id;
1036                 c->priority = Channel[i].priority;
1037                 c->name = S_sfx[c->id].lumpname;
1038                 c->mo = Channel[i].mo;
1039                 c->distance = P_AproxDistance(c->mo->x-viewx, c->mo->y-viewy)
1040                         >>FRACBITS;
1041         }
1042 }
1043
1044 //==========================================================================
1045 //
1046 // S_GetSoundPlayingInfo
1047 //
1048 //==========================================================================
1049
1050 boolean S_GetSoundPlayingInfo(mobj_t *mobj, int sound_id)
1051 {
1052         int i;
1053
1054         for(i = 0; i < snd_Channels; i++)
1055         {
1056                 if(Channel[i].sound_id == sound_id && Channel[i].mo == mobj)
1057                 {
1058                         if(I_SoundIsPlaying(Channel[i].handle))
1059                         {
1060                                 return true;
1061                         }
1062                 }
1063         }
1064         return false;
1065 }
1066
1067 //==========================================================================
1068 //
1069 // S_SetMusicVolume
1070 //
1071 //==========================================================================
1072
1073 void S_SetMusicVolume(void)
1074 {
1075         if(i_CDMusic)
1076         {
1077                 I_CDMusSetVolume(snd_MusicVolume*16); // 0-255
1078         }
1079         else
1080         {
1081                 I_SetMusicVolume(snd_MusicVolume);
1082         }
1083         if(snd_MusicVolume == 0)
1084         {
1085                 if(!i_CDMusic)
1086                 {
1087                         I_PauseSong(RegisteredSong);
1088                 }
1089                 MusicPaused = true;
1090         }
1091         else if(MusicPaused)
1092         {
1093                 if(!i_CDMusic)
1094                 {
1095                         I_ResumeSong(RegisteredSong);
1096                 }
1097                 MusicPaused = false;
1098         }
1099 }
1100
1101 //==========================================================================
1102 //
1103 // S_ShutDown
1104 //
1105 //==========================================================================
1106
1107 void S_ShutDown(void)
1108 {
1109         extern int tsm_ID;
1110         if(tsm_ID != -1)
1111         {
1112                 I_StopSong(RegisteredSong);
1113                 I_UnRegisterSong(RegisteredSong);
1114                 I_ShutdownSound();
1115         }
1116         if(i_CDMusic)
1117         {
1118                 I_CDMusStop();
1119         }
1120         I_CDMusShutdown();
1121 }
1122
1123 //==========================================================================
1124 //
1125 // S_InitScript
1126 //
1127 //==========================================================================
1128
1129 void S_InitScript(void)
1130 {
1131         int p;
1132         int i;
1133
1134         strcpy(ArchivePath, DEFAULT_ARCHIVEPATH);
1135         if(!(p = M_CheckParm("-devsnd")))
1136         {
1137                 UseSndScript = false;
1138                 SC_OpenLump("sndinfo");
1139         }
1140         else
1141         {
1142                 UseSndScript = true;
1143                 SC_OpenFile(myargv[p+1]);
1144         }
1145         while(SC_GetString())
1146         {
1147                 if(*sc_String == '$')
1148                 {
1149                         if(!stricmp(sc_String, "$ARCHIVEPATH"))
1150                         {
1151                                 SC_MustGetString();
1152                                 strcpy(ArchivePath, sc_String);
1153                         }
1154                         else if(!stricmp(sc_String, "$MAP"))
1155                         {
1156                                 SC_MustGetNumber();
1157                                 SC_MustGetString();
1158                                 if(sc_Number)
1159                                 {
1160                                         P_PutMapSongLump(sc_Number, sc_String);
1161                                 }
1162                         }
1163                         continue;
1164                 }
1165                 else
1166                 {
1167                         for(i = 0; i < NUMSFX; i++)
1168                         {
1169                                 if(!strcmp(S_sfx[i].tagName, sc_String))
1170                                 {
1171                                         SC_MustGetString();
1172                                         if(*sc_String != '?')
1173                                         {
1174                                                 strcpy(S_sfx[i].lumpname, sc_String);
1175                                         }
1176                                         else
1177                                         {
1178                                                 strcpy(S_sfx[i].lumpname, "default");
1179                                         }
1180                                         break;
1181                                 }
1182                         }
1183                         if(i == NUMSFX)
1184                         {
1185                                 SC_MustGetString();
1186                         }
1187                 }
1188         }
1189         SC_Close();
1190
1191         for(i = 0; i < NUMSFX; i++)
1192         {
1193                 if(!strcmp(S_sfx[i].lumpname, ""))
1194                 {
1195                         strcpy(S_sfx[i].lumpname, "default");
1196                 }
1197         }
1198 }
1199
1200
1201 //==================================================
1202
1203
1204 int ticcount;
1205
1206 boolean novideo; // if true, stay in text mode for debugging
1207
1208
1209 //==========================================================================
1210
1211
1212 static long _startSec;
1213
1214 void I_StartupTimer(void)
1215 {
1216    struct timeval tv;
1217     gettimeofday( &tv, 0 );
1218     _startSec = tv.tv_sec;
1219 }
1220
1221 //--------------------------------------------------------------------------
1222 //
1223 // FUNC I_GetTime
1224 //
1225 // Returns time in 1/35th second tics.
1226 //
1227 //--------------------------------------------------------------------------
1228
1229 int I_GetTime (void)
1230 {
1231     struct timeval tv;
1232     gettimeofday( &tv, 0 );
1233
1234     //printf( "GT: %lx %lx\n", tv.tv_sec, tv.tv_usec );
1235
1236 //  ticcount = ((tv.tv_sec * 1000000) + tv.tv_usec) / 28571;
1237     ticcount = ((tv.tv_sec - _startSec) * 35) + (tv.tv_usec / 28571);
1238         return( ticcount );
1239 }
1240
1241
1242 /*
1243 ============================================================================
1244
1245                                         JOYSTICK
1246
1247 ============================================================================
1248 */
1249
1250 //==================================================
1251 //
1252 // joystick vars
1253 //
1254 //==================================================
1255
1256 extern int usejoystick;
1257 boolean joystickpresent;
1258 unsigned joystickx, joysticky;
1259
1260 // returns false if not connected
1261 boolean I_ReadJoystick (void)
1262 {
1263     return false;
1264 }
1265
1266
1267 int     joyxl, joyxh, joyyl, joyyh;
1268
1269 boolean WaitJoyButton (void)
1270 {
1271 #if 0
1272         int             oldbuttons, buttons;
1273
1274         oldbuttons = 0;
1275         do
1276         {
1277                 I_WaitVBL (1);
1278                 buttons =  ((inp(0x201) >> 4)&1)^1;
1279                 if (buttons != oldbuttons)
1280                 {
1281                         oldbuttons = buttons;
1282                         continue;
1283                 }
1284
1285                 if ( (lastpress& 0x7f) == 1 )
1286                 {
1287                         joystickpresent = false;
1288                         return false;
1289                 }
1290         } while ( !buttons);
1291
1292         do
1293         {
1294                 I_WaitVBL (1);
1295                 buttons =  ((inp(0x201) >> 4)&1)^1;
1296                 if (buttons != oldbuttons)
1297                 {
1298                         oldbuttons = buttons;
1299                         continue;
1300                 }
1301
1302                 if ( (lastpress& 0x7f) == 1 )
1303                 {
1304                         joystickpresent = false;
1305                         return false;
1306                 }
1307         } while ( buttons);
1308
1309 #endif
1310         return true;
1311 }
1312
1313
1314
1315 /*
1316 ===============
1317 =
1318 = I_StartupJoystick
1319 =
1320 ===============
1321 */
1322
1323 int             basejoyx, basejoyy;
1324
1325 void I_StartupJoystick (void)
1326 {
1327         int     center_x, center_y;
1328
1329         joystickpresent = 0;
1330         if ( M_CheckParm ("-nojoy") || !usejoystick )
1331                 return;
1332
1333         if (!I_ReadJoystick ())
1334         {
1335                 joystickpresent = false;
1336                 ST_Message("joystick not found\n ");
1337                 return;
1338         }
1339         ST_Message("joystick found\n");
1340         joystickpresent = true;
1341
1342         ST_RealMessage("CENTER the joystick and press button 1:");
1343         if (!WaitJoyButton ())
1344                 return;
1345         I_ReadJoystick ();
1346         center_x = joystickx;
1347         center_y = joysticky;
1348
1349         ST_RealMessage("\nPush the joystick to the UPPER LEFT corner and press button 1:");
1350         if (!WaitJoyButton ())
1351                 return;
1352         I_ReadJoystick ();
1353         joyxl = (center_x + joystickx)/2;
1354         joyyl = (center_x + joysticky)/2;
1355
1356         ST_RealMessage("\nPush the joystick to the LOWER RIGHT corner and press button 1:");
1357         if (!WaitJoyButton ())
1358                 return;
1359         I_ReadJoystick ();
1360         joyxh = (center_x + joystickx)/2;
1361         joyyh = (center_y + joysticky)/2;
1362         ST_RealMessage("\n");
1363 }
1364
1365 /*
1366 ===============
1367 =
1368 = I_JoystickEvents
1369 =
1370 ===============
1371 */
1372
1373 void I_JoystickEvents (void)
1374 {
1375         event_t ev;
1376
1377 //
1378 // joystick events
1379 //
1380         if (!joystickpresent)
1381                 return;
1382
1383         I_ReadJoystick();
1384         ev.type = ev_joystick;
1385         ev.data1 =  0;  //((inp(0x201) >> 4)&15)^15;
1386
1387         if (joystickx < joyxl)
1388                 ev.data2 = -1;
1389         else if (joystickx > joyxh)
1390                 ev.data2 = 1;
1391         else
1392                 ev.data2 = 0;
1393         if (joysticky < joyyl)
1394                 ev.data3 = -1;
1395         else if (joysticky > joyyh)
1396                 ev.data3 = 1;
1397         else
1398                 ev.data3 = 0;
1399
1400         H2_PostEvent (&ev);
1401 }
1402
1403
1404 /*
1405    ===============
1406    =
1407    = I_StartFrame
1408    =
1409    ===============
1410    */
1411
1412 void I_StartFrame (void)
1413 {
1414     I_JoystickEvents();
1415 }
1416
1417
1418 /*
1419 ============================================================================
1420
1421                                         DPMI STUFF
1422
1423 ============================================================================
1424 */
1425
1426 void I_DivException (void);
1427 int I_SetDivException (void);
1428
1429
1430
1431 /*
1432 ============================================================================
1433
1434                                         TIMER INTERRUPT
1435
1436 ============================================================================
1437 */
1438
1439
1440 /*
1441 ===============
1442 =
1443 = I_Init
1444 =
1445 = hook interrupts and set graphics mode
1446 =
1447 ===============
1448 */
1449
1450 void I_Init (void)
1451 {
1452         void I_StartupTimer(void);
1453
1454         novideo = M_CheckParm("novideo");
1455         //ST_Message("  I_StartupMouse ");
1456         I_StartupMouse();
1457 //      tprintf("I_StartupJoystick ",1);
1458 //      I_StartupJoystick();
1459         ST_Message("  S_Init... ");
1460         S_Init();
1461         S_Start();
1462
1463     I_StartupTimer();
1464 }
1465
1466
1467 /*
1468 ===============
1469 =
1470 = I_Shutdown
1471 =
1472 = return to default system state
1473 =
1474 ===============
1475 */
1476
1477 void I_Shutdown (void)
1478 {
1479         I_ShutdownGraphics ();
1480         S_ShutDown ();
1481 }
1482
1483
1484 /*
1485 ================
1486 =
1487 = I_Error
1488 =
1489 ================
1490 */
1491
1492 void I_Error (char *error, ...)
1493 {
1494         va_list argptr;
1495
1496         D_QuitNetGame ();
1497         I_Shutdown ();
1498         va_start (argptr,error);
1499         vprintf (error, argptr);
1500         va_end (argptr);
1501         printf ("\n");
1502         exit (1);
1503 }
1504
1505 //--------------------------------------------------------------------------
1506 //
1507 // I_Quit
1508 //
1509 // Shuts down net game, saves defaults, prints the exit text message,
1510 // goes to text mode, and exits.
1511 //
1512 //--------------------------------------------------------------------------
1513
1514 void I_Quit(void)
1515 {
1516         D_QuitNetGame();
1517         M_SaveDefaults();
1518         I_Shutdown();
1519
1520 //      scr = (byte *)W_CacheLumpName("ENDTEXT", PU_CACHE);
1521 /*
1522         memcpy((void *)0xb8000, scr, 80*25*2);
1523         regs.w.ax = 0x0200;
1524         regs.h.bh = 0;
1525         regs.h.dl = 0;
1526         regs.h.dh = 23;
1527         int386(0x10, (const union REGS *)&regs, &regs); // Set text pos
1528         _settextposition(24, 1);
1529 */
1530         printf("\nHexen: Beyond Heretic\n");
1531         exit(0);
1532 }
1533
1534 /*
1535 ===============
1536 =
1537 = I_ZoneBase
1538 =
1539 ===============
1540 */
1541
1542 byte *I_ZoneBase (int *size)
1543 {
1544         byte *ptr;
1545     int heap = 0x800000;
1546
1547     ptr = malloc ( heap );
1548
1549         ST_Message ("  0x%x allocated for zone, ", heap);
1550         ST_Message ("ZoneBase: 0x%X\n", (int)ptr);
1551
1552         if ( ! ptr )
1553                 I_Error ("  Insufficient DPMI memory!");
1554
1555         *size = heap;
1556         return ptr;
1557 }
1558
1559 /*
1560 =============
1561 =
1562 = I_AllocLow
1563 =
1564 =============
1565 */
1566
1567 byte *I_AllocLow (int length)
1568 {
1569         return malloc( length );
1570 }
1571
1572 /*
1573 ============================================================================
1574
1575                                                 NETWORKING
1576
1577 ============================================================================
1578 */
1579
1580 /* // FUCKED LINES
1581 typedef struct
1582 {
1583         char    priv[508];
1584 } doomdata_t;
1585 */ // FUCKED LINES
1586
1587 #define DOOMCOM_ID              0x12345678l
1588
1589 /* // FUCKED LINES
1590 typedef struct
1591 {
1592         long    id;
1593         short   intnum;                 // DOOM executes an int to execute commands
1594
1595 // communication between DOOM and the driver
1596         short   command;                // CMD_SEND or CMD_GET
1597         short   remotenode;             // dest for send, set by get (-1 = no packet)
1598         short   datalength;             // bytes in doomdata to be sent
1599
1600 // info common to all nodes
1601         short   numnodes;               // console is allways node 0
1602         short   ticdup;                 // 1 = no duplication, 2-5 = dup for slow nets
1603         short   extratics;              // 1 = send a backup tic in every packet
1604         short   deathmatch;             // 1 = deathmatch
1605         short   savegame;               // -1 = new game, 0-5 = load savegame
1606         short   episode;                // 1-3
1607         short   map;                    // 1-9
1608         short   skill;                  // 1-5
1609
1610 // info specific to this node
1611         short   consoleplayer;
1612         short   numplayers;
1613         short   angleoffset;    // 1 = left, 0 = center, -1 = right
1614         short   drone;                  // 1 = drone
1615
1616 // packet data to be sent
1617         doomdata_t      data;
1618 } doomcom_t;
1619 */ // FUCKED LINES
1620
1621 extern  doomcom_t               *doomcom;
1622
1623 /*
1624 ====================
1625 =
1626 = I_InitNetwork
1627 =
1628 ====================
1629 */
1630
1631 void I_InitNetwork (void)
1632 {
1633         int             i;
1634
1635         i = M_CheckParm ("-net");
1636         if (!i)
1637         {
1638         //
1639         // single player game
1640         //
1641                 doomcom = malloc (sizeof (*doomcom) );
1642                 memset (doomcom, 0, sizeof(*doomcom) );
1643                 netgame = false;
1644                 doomcom->id = DOOMCOM_ID;
1645                 doomcom->numplayers = doomcom->numnodes = 1;
1646                 doomcom->deathmatch = false;
1647                 doomcom->consoleplayer = 0;
1648                 doomcom->ticdup = 1;
1649                 doomcom->extratics = 0;
1650                 return;
1651         }
1652         netgame = true;
1653         doomcom = (doomcom_t *)atoi(myargv[i+1]);
1654 //DEBUG
1655 doomcom->skill = startskill;
1656 doomcom->episode = startepisode;
1657 doomcom->map = startmap;
1658 doomcom->deathmatch = deathmatch;
1659 }
1660
1661 void I_NetCmd (void)
1662 {
1663         if (!netgame)
1664                 I_Error ("I_NetCmd when not in netgame");
1665 }
1666
1667 //=========================================================================
1668 //
1669 // I_CheckExternDriver
1670 //
1671 //              Checks to see if a vector, and an address for an external driver
1672 //                      have been passed.
1673 //=========================================================================
1674
1675 void I_CheckExternDriver(void)
1676 {
1677         int i;
1678
1679         if(!(i = M_CheckParm("-externdriver")))
1680         {
1681                 return;
1682         }
1683         i_ExternData = (externdata_t *)atoi(myargv[i+1]);
1684         i_Vector = i_ExternData->vector;
1685
1686         useexterndriver = true;
1687 }
1688
1689 void PrintHelp(char *name)
1690 {
1691         printf ("HHexen (%s %d.%d)\n", VERSION_PLATFORM,
1692                         VERSION_MAJ,VERSION_MIN);
1693         printf ("http://icculus.org/hast/\n");
1694         printf ("Please send bug reports or patches to:\n");
1695         printf ("             Dan Olson <theoddone33@icculus.org>\n");
1696         printf ("\n");
1697         printf ("Usage: %s [options]\n", name);
1698         printf ("     [ -h | --help]           Display this help message\n");
1699         printf ("     [ -v | --version]        Display the game version\n");
1700         printf ("     [ -f | --fullscreen]     Run the game fullscreen\n");
1701         printf ("     [ -w | --windowed]       Run the game windowed\n");
1702         printf ("     [ -s | --nosound]        Run the game without sound\n");
1703         printf ("     [ -g | --nograb]         Disable mouse grabbing\n");
1704 #ifdef RENDER3D
1705         //printf ("     [ -l | --gllibrary]      Select 3D rendering library\n");
1706 #endif
1707         printf ("\n");
1708         printf ("You can use the HHEXEN_DATA environment variable to force the\n");
1709         printf ("HHexen data directory.\n");
1710         printf ("\n");
1711 }
1712
1713 void PrintVersion (void)
1714 {
1715         printf ("HHexen (%s %d.%d)\n", VERSION_PLATFORM,
1716                         VERSION_MAJ,VERSION_MIN);
1717 }
1718
1719 int main( int argc, char** argv )
1720 {
1721         myargc = argc;
1722         myargv = argv;
1723         if (M_CheckParm("--help") || M_CheckParm("-h"))
1724         {
1725                 PrintHelp (argv[0]);
1726                 return 0;
1727         }
1728         if (M_CheckParm("--version") || M_CheckParm("-v"))
1729         {
1730                 PrintVersion ();
1731                 return 0;
1732         }
1733         H2_Main();
1734         return 0;
1735 }
1736
1737
1738 //EOF
1739 fixed_t FixedMul (fixed_t a, fixed_t b)
1740 {
1741         fixed_t retval;
1742         __asm__ __volatile__(
1743                 "imull  %%edx                   \n\t"
1744                 "shrdl  $16, %%edx, %%eax       \n\t"
1745                 : "=a" (retval)
1746                 : "a" (a), "d" (b)
1747                 : "cc"
1748         );
1749         return retval;
1750 }
1751 fixed_t FixedDiv2 (fixed_t a, fixed_t b)
1752 {
1753         fixed_t retval;
1754         __asm__ __volatile__(
1755                 "cdq                            \n\t"
1756                 "shldl  $16, %%eax, %%edx       \n\t"
1757                 "sall   $16, %%eax              \n\t"
1758                 "idivl  %%ebx                   \n\t"
1759                 : "=a" (retval)
1760                 : "a" (a), "b" (b)
1761                 : "%edx", "cc"
1762         );
1763         return retval;
1764 }