base/g_game.c

   1
   2 //**************************************************************************
   3 //**
   4 //** g_game.c : Heretic 2 : Raven Software, Corp.
   5 //**
   6 //** $RCSfile$
   7 //** $Revision$
   8 //** $Date$
   9 //** $Author$
  10 //**
  11 //**************************************************************************
  12
  13 #include <string.h>
  14 #include "h2def.h"
  15 #include "p_local.h"
  16 #include "soundst.h"
  17
  18 #define AM_STARTKEY     9
  19
  20 // External functions
  21
  22 extern void R_InitSky(int map);
  23 extern void P_PlayerNextArtifact(player_t *player);
  24
  25 // Functions
  26
  27 boolean G_CheckDemoStatus (void);
  28 void G_ReadDemoTiccmd (ticcmd_t *cmd);
  29 void G_WriteDemoTiccmd (ticcmd_t *cmd);
  30 void G_InitNew (skill_t skill, int episode, int map);
  31
  32 void G_DoReborn (int playernum);
  33
  34 void G_DoLoadLevel(void);
  35 void G_DoInitNew(void);
  36 void G_DoNewGame(void);
  37 void G_DoLoadGame(void);
  38 void G_DoPlayDemo(void);
  39 void G_DoTeleportNewMap(void);
  40 void G_DoCompleted(void);
  41 void G_DoVictory(void);
  42 void G_DoWorldDone(void);
  43 void G_DoSaveGame(void);
  44 void G_DoSingleReborn(void);
  45
  46 void H2_PageTicker(void);
  47 void H2_AdvanceDemo(void);
  48
  49 extern boolean mn_SuicideConsole;
  50
  51 gameaction_t    gameaction;
  52 gamestate_t     gamestate;
  53 skill_t         gameskill;
  54 //boolean         respawnmonsters;
  55 int             gameepisode;
  56 int             gamemap;
  57 int                              prevmap;
  58
  59 boolean         paused;
  60 boolean         sendpause;              // send a pause event next tic
  61 boolean         sendsave;               // send a save event next tic
  62 boolean         usergame;               // ok to save / end game
  63
  64 boolean         timingdemo;             // if true, exit with report on completion
  65 int             starttime;              // for comparative timing purposes
  66
  67 boolean         viewactive;
  68
  69 boolean         deathmatch;             // only if started as net death
  70 boolean         netgame;                // only true if packets are broadcast
  71 boolean         playeringame[MAXPLAYERS];
  72 player_t        players[MAXPLAYERS];
  73 pclass_t                PlayerClass[MAXPLAYERS];
  74
  75 // Position indicator for cooperative net-play reborn
  76 int RebornPosition;
  77
  78 int             consoleplayer;          // player taking events and displaying
  79 int             displayplayer;          // view being displayed
  80 int             gametic;
  81 int             levelstarttic;          // gametic at level start
  82
  83 char            demoname[32];
  84 boolean         demorecording;
  85 boolean         demoplayback;
  86 byte            *demobuffer, *demo_p;
  87 boolean         singledemo;             // quit after playing a demo from cmdline
  88
  89 boolean         precache = true;        // if true, load all graphics at start
  90
  91 short            consistancy[MAXPLAYERS][BACKUPTICS];
  92
  93 //
  94 // controls (have defaults)
  95 //
  96 int key_right, key_left, key_up, key_down;
  97 int key_strafeleft, key_straferight, key_jump;
  98 int key_fire, key_use, key_strafe, key_speed;
  99 int     key_flyup, key_flydown, key_flycenter;
 100 int     key_lookup, key_lookdown, key_lookcenter;
 101 int     key_invleft, key_invright, key_useartifact;
 102
 103 int mouselook;
 104 boolean alwaysrun;
 105
 106 int mousebfire;
 107 int mousebstrafe;
 108 int mousebforward;
 109 int mousebjump;
 110
 111 int joybfire;
 112 int joybstrafe;
 113 int joybuse;
 114 int joybspeed;
 115 int joybjump;
 116
 117 int LeaveMap;
 118 static int LeavePosition;
 119
 120 //#define MAXPLMOVE       0x32 // Old Heretic Max move
 121
 122 fixed_t MaxPlayerMove[NUMCLASSES] = { 0x3C, 0x32, 0x2D,
 123                                         0x3D,
 124                                         0x31 };
 125 fixed_t forwardmove[NUMCLASSES][2] =
 126 {
 127         { 0x1D, 0x3C },
 128         { 0x19, 0x32 },
 129         { 0x16, 0x2E },
 130         { 0x17, 0x3D },
 131         { 0x18, 0x31 }
 132 };
 133
 134 fixed_t sidemove[NUMCLASSES][2] =
 135 {
 136         { 0x1B, 0x3B },
 137         { 0x18, 0x28 },
 138         { 0x15, 0x25 },
 139         { 0x16, 0x3C },
 140         { 0x17, 0x27 }
 141 };
 142
 143 fixed_t angleturn[3] = {640, 1280, 320};     // + slow turn
 144 #define SLOWTURNTICS    6
 145
 146 #define NUMKEYS 256
 147 boolean         gamekeydown[NUMKEYS];
 148 int             turnheld;                   // for accelerative turning
 149 int                              lookheld;
 150
 151
 152 boolean         mousearray[4];
 153 boolean         *mousebuttons = &mousearray[1];
 154
 155         // allow [-1]
 156 int             mousex, mousey;             // mouse values are used once
 157 int             dclicktime, dclickstate, dclicks;
 158 int             dclicktime2, dclickstate2, dclicks2;
 159
 160 int             joyxmove, joyymove;         // joystick values are repeated
 161 boolean         joyarray[5];
 162 boolean         *joybuttons = &joyarray[1];     // allow [-1]
 163
 164 int     savegameslot;
 165 char    savedescription[32];
 166
 167 int inventoryTics;
 168
 169
 170 static skill_t TempSkill;
 171 static int TempEpisode;
 172 static int TempMap;
 173
 174 //=============================================================================
 175 /*
 176 ====================
 177 =
 178 = G_BuildTiccmd
 179 =
 180 = Builds a ticcmd from all of the available inputs or reads it from the
 181 = demo buffer.
 182 = If recording a demo, write it out
 183 ====================
 184 */
 185
 186 extern boolean inventory;
 187 extern int curpos;
 188 extern int inv_ptr;
 189
 190 extern  int             isCyberPresent;     // is CyberMan present?
 191 boolean usearti = true;
 192 void I_ReadCyberCmd (ticcmd_t *cmd);
 193
 194 void G_BuildTiccmd (ticcmd_t *cmd)
 195 {
 196         int             i;
 197         boolean         strafe, bstrafe;
 198         int             speed, tspeed, lspeed;
 199         int             forward, side;
 200         int look, arti;
 201         int flyheight;
 202         int pClass;
 203
 204         extern boolean artiskip;
 205
 206
 207         pClass = players[consoleplayer].class;
 208         memset (cmd,0,sizeof(*cmd));
 209
 210 //      cmd->consistancy =
 211 //              consistancy[consoleplayer][(maketic*ticdup)%BACKUPTICS];
 212
 213         cmd->consistancy =
 214                 consistancy[consoleplayer][maketic%BACKUPTICS];
 215         if (isCyberPresent)
 216                 I_ReadCyberCmd (cmd);
 217
 218 //printf ("cons: %i\n",cmd->consistancy);
 219         strafe = gamekeydown[key_strafe] || mousebuttons[mousebstrafe]
 220                 || joybuttons[joybstrafe];
 221
 222         speed = gamekeydown[key_speed] || joybuttons[joybspeed]
 223                 || joybuttons[joybspeed];
 224         if(alwaysrun && !demoplayback && !demorecording)
 225         speed = !speed;
 226         forward = side = look = arti = flyheight = 0;
 227
 228 //
 229 // use two stage accelerative turning on the keyboard and joystick
 230 //
 231         if (joyxmove < 0 || joyxmove > 0
 232         || gamekeydown[key_right] || gamekeydown[key_left])
 233                 turnheld += ticdup;
 234         else
 235                 turnheld = 0;
 236         if (turnheld < SLOWTURNTICS)
 237                 tspeed = 2;             // slow turn
 238         else
 239                 tspeed = speed;
 240
 241         if(gamekeydown[key_lookdown] || gamekeydown[key_lookup])
 242         {
 243                 lookheld += ticdup;
 244         }
 245         else
 246         {
 247                 lookheld = 0;
 248         }
 249         if(lookheld < SLOWTURNTICS)
 250         {
 251                 lspeed = 1; // 3;
 252         }
 253         else
 254         {
 255                 lspeed = 2; // 5;
 256         }
 257
 258 //
 259 // let movement keys cancel each other out
 260 //
 261         if(strafe)
 262         {
 263                 if (gamekeydown[key_right])
 264                 {
 265                         side += sidemove[pClass][speed];
 266                 }
 267                 if (gamekeydown[key_left])
 268                 {
 269                         side -= sidemove[pClass][speed];
 270                 }
 271                 if (joyxmove > 0)
 272                 {
 273                         side += sidemove[pClass][speed];
 274                 }
 275                 if (joyxmove < 0)
 276                 {
 277                         side -= sidemove[pClass][speed];
 278                 }
 279         }
 280         else
 281         {
 282                 if (gamekeydown[key_right])
 283                         cmd->angleturn -= angleturn[tspeed];
 284                 if (gamekeydown[key_left])
 285                         cmd->angleturn += angleturn[tspeed];
 286                 if (joyxmove > 0)
 287                         cmd->angleturn -= angleturn[tspeed];
 288                 if (joyxmove < 0)
 289                         cmd->angleturn += angleturn[tspeed];
 290         }
 291
 292         if (gamekeydown[key_up])
 293         {
 294                 forward += forwardmove[pClass][speed];
 295         }
 296         if (gamekeydown[key_down])
 297         {
 298                 forward -= forwardmove[pClass][speed];
 299         }
 300         if (joyymove < 0)
 301         {
 302                 forward += forwardmove[pClass][speed];
 303         }
 304         if (joyymove > 0)
 305         {
 306                 forward -= forwardmove[pClass][speed];
 307         }
 308         if (gamekeydown[key_straferight])
 309         {
 310                 side += sidemove[pClass][speed];
 311         }
 312         if (gamekeydown[key_strafeleft])
 313         {
 314                 side -= sidemove[pClass][speed];
 315         }
 316
 317         // Look up/down/center keys
 318         if(gamekeydown[key_lookup])
 319         {
 320                 look = lspeed;
 321         }
 322         if(gamekeydown[key_lookdown])
 323         {
 324                 look = -lspeed;
 325         }
 326         if(gamekeydown[key_lookcenter])
 327         {
 328                 look = TOCENTER;
 329         }
 330
 331         // Fly up/down/drop keys
 332         if(gamekeydown[key_flyup])
 333         {
 334                 flyheight = 5; // note that the actual flyheight will be twice this
 335         }
 336         if(gamekeydown[key_flydown])
 337         {
 338                 flyheight = -5;
 339         }
 340         if(gamekeydown[key_flycenter])
 341         {
 342                 flyheight = TOCENTER;
 343                 look = TOCENTER;
 344         }
 345         // Use artifact key
 346         if(gamekeydown[key_useartifact])
 347         {
 348                 if(gamekeydown[key_speed] && artiskip)
 349                 {
 350                         if(players[consoleplayer].inventory[inv_ptr].type != arti_none)
 351                         { // Skip an artifact
 352                                 gamekeydown[key_useartifact] = false;
 353                                 P_PlayerNextArtifact(&players[consoleplayer]);
 354                         }
 355                 }
 356                 else
 357                 {
 358                         if(inventory)
 359                         {
 360                                 players[consoleplayer].readyArtifact =
 361                                         players[consoleplayer].inventory[inv_ptr].type;
 362                                 inventory = false;
 363                                 cmd->arti = 0;
 364                                 usearti = false;
 365                         }
 366                         else if(usearti)
 367                         {
 368                                 cmd->arti |=
 369                                         players[consoleplayer].inventory[inv_ptr].type&AFLAG_MASK;
 370                                 usearti = false;
 371                         }
 372                 }
 373         }
 374         if(gamekeydown[key_jump] || mousebuttons[mousebjump]
 375                 || joybuttons[joybjump])
 376         {
 377                 cmd->arti |= AFLAG_JUMP;
 378         }
 379         if(mn_SuicideConsole)
 380         {
 381                 cmd->arti |= AFLAG_SUICIDE;
 382                 mn_SuicideConsole = false;
 383         }
 384
 385         // Artifact hot keys
 386         if(gamekeydown[KEY_BACKSPACE] && !cmd->arti)
 387         {
 388                 gamekeydown[KEY_BACKSPACE] = false;     // Use one of each artifact
 389                 cmd->arti = NUMARTIFACTS;
 390         }
 391         else if(gamekeydown[KEY_BACKSLASH] && !cmd->arti
 392         && (players[consoleplayer].mo->health < MAXHEALTH))
 393         {
 394                 gamekeydown[KEY_BACKSLASH] = false;
 395                 cmd->arti = arti_health;
 396         }
 397         else if(gamekeydown[KEY_ZERO] && !cmd->arti)
 398         {
 399         gamekeydown[KEY_ZERO] = false;
 400                 cmd->arti = arti_poisonbag;
 401         }
 402         else if(gamekeydown[KEY_NINE] && !cmd->arti)
 403         {
 404                 gamekeydown[KEY_NINE] = false;
 405                 cmd->arti = arti_blastradius;
 406         }
 407         else if(gamekeydown[KEY_EIGHT] && !cmd->arti)
 408         {
 409                 gamekeydown[KEY_EIGHT] = false;
 410                 cmd->arti = arti_teleport;
 411         }
 412         else if(gamekeydown[KEY_SEVEN] && !cmd->arti)
 413         {
 414                 gamekeydown[KEY_SEVEN] = false;
 415                 cmd->arti = arti_teleportother;
 416         }
 417         else if(gamekeydown[KEY_SIX] && !cmd->arti)
 418         {
 419                 gamekeydown[KEY_SIX] = false;
 420                 cmd->arti = arti_egg;
 421         }
 422         else if(gamekeydown[KEY_FIVE] && !cmd->arti
 423         && !players[consoleplayer].powers[pw_invulnerability])
 424         {
 425                 gamekeydown[KEY_FIVE] = false;
 426                 cmd->arti = arti_invulnerability;
 427         }
 428
 429 //
 430 // buttons
 431 //
 432         cmd->chatchar = CT_dequeueChatChar();
 433         if (gamekeydown[key_fire] || mousebuttons[mousebfire]
 434                 || joybuttons[joybfire])
 435                 cmd->buttons |= BT_ATTACK;
 436
 437         if (gamekeydown[key_use] || joybuttons[joybuse] )
 438         {
 439                 cmd->buttons |= BT_USE;
 440                 dclicks = 0;                    // clear double clicks if hit use button
 441         }
 442
 443         for(i = 0; i < NUMWEAPONS; i++)
 444         {
 445                 if(gamekeydown['1'+i])
 446                 {
 447                         cmd->buttons |= BT_CHANGE;
 448                         cmd->buttons |= i<<BT_WEAPONSHIFT;
 449                         break;
 450                 }
 451         }
 452
 453 //
 454 // mouse
 455 //
 456 #if 0
 457     printf( "%d %d %d %d <%d %d>\n",
 458             mousebuttons[mousebfire], mousebuttons[mousebforward],
 459             mousebuttons[mousebjump], mousebuttons[mousebstrafe],
 460             mousex, mousey );
 461 #endif
 462         if (mousebuttons[mousebforward])
 463         {
 464                 forward += forwardmove[pClass][speed];
 465         }
 466
 467 //
 468 // forward double click
 469 //
 470         if (mousebuttons[mousebforward] != dclickstate && dclicktime > 1 )
 471         {
 472                 dclickstate = mousebuttons[mousebforward];
 473                 if (dclickstate)
 474                         dclicks++;
 475                 if (dclicks == 2)
 476                 {
 477                         cmd->buttons |= BT_USE;
 478                         dclicks = 0;
 479                 }
 480                 else
 481                         dclicktime = 0;
 482         }
 483         else
 484         {
 485                 dclicktime += ticdup;
 486                 if (dclicktime > 20)
 487                 {
 488                         dclicks = 0;
 489                         dclickstate = 0;
 490                 }
 491         }
 492
 493 //
 494 // strafe double click
 495 //
 496         bstrafe = mousebuttons[mousebstrafe]
 497 || joybuttons[joybstrafe];
 498         if (bstrafe != dclickstate2 && dclicktime2 > 1 )
 499         {
 500                 dclickstate2 = bstrafe;
 501                 if (dclickstate2)
 502                         dclicks2++;
 503                 if (dclicks2 == 2)
 504                 {
 505                         cmd->buttons |= BT_USE;
 506                         dclicks2 = 0;
 507                 }
 508                 else
 509                         dclicktime2 = 0;
 510         }
 511         else
 512         {
 513                 dclicktime2 += ticdup;
 514                 if (dclicktime2 > 20)
 515                 {
 516                         dclicks2 = 0;
 517                         dclickstate2 = 0;
 518                 }
 519         }
 520         if (strafe)
 521         {
 522                 side += mousex*2;
 523         }
 524         else
 525         {
 526                 cmd->angleturn -= mousex*0x8;
 527         }
 528
 529     if( demorecording || demoplayback || (mouselook == 0) )
 530     {
 531         forward += mousey;
 532     }
 533     else if( mousey )
 534     {
 535         // We'll directly change the viewing pitch of the console player.
 536         float adj = ((mousey*0x4)<<16) / (float) ANGLE_180*180*110.0/85.0;
 537         float newlookdir = 0; /* jim initialiser added to prevent warning */
 538
 539 #ifndef RENDER3D
 540         adj *= 2;       //Speed up the X11 mlook a little.
 541 #endif
 542
 543         if(mouselook == 1)
 544                 newlookdir = players[consoleplayer].lookdir + adj;
 545         else if(mouselook == 2)
 546                 newlookdir = players[consoleplayer].lookdir - adj;
 547
 548         // vertical view angle taken from p_user.c line 249.
 549         if( newlookdir > 90 )
 550             newlookdir = 90;
 551         if( newlookdir < -110 )
 552             newlookdir = -110;
 553
 554         players[consoleplayer].lookdir = newlookdir;
 555     }
 556
 557         mousex = mousey = 0;
 558
 559         if (forward > MaxPlayerMove[pClass])
 560         {
 561                 forward = MaxPlayerMove[pClass];
 562         }
 563         else if (forward < -MaxPlayerMove[pClass])
 564         {
 565                 forward = -MaxPlayerMove[pClass];
 566         }
 567         if (side > MaxPlayerMove[pClass])
 568         {
 569                 side = MaxPlayerMove[pClass];
 570         }
 571         else if (side < -MaxPlayerMove[pClass])
 572         {
 573                 side = -MaxPlayerMove[pClass];
 574         }
 575         if(players[consoleplayer].powers[pw_speed]
 576                 && !players[consoleplayer].morphTics)
 577         { // Adjust for a player with a speed artifact
 578                 forward = (3*forward)>>1;
 579                 side = (3*side)>>1;
 580         }
 581         cmd->forwardmove += forward;
 582         cmd->sidemove += side;
 583         if(players[consoleplayer].playerstate == PST_LIVE)
 584         {
 585                 if(look < 0)
 586                 {
 587                         look += 16;
 588                 }
 589                 cmd->lookfly = look;
 590         }
 591         if(flyheight < 0)
 592         {
 593                 flyheight += 16;
 594         }
 595         cmd->lookfly |= flyheight<<4;
 596
 597 //
 598 // special buttons
 599 //
 600         if (sendpause)
 601         {
 602                 sendpause = false;
 603                 cmd->buttons = BT_SPECIAL | BTS_PAUSE;
 604         }
 605
 606         if (sendsave)
 607         {
 608                 sendsave = false;
 609                 cmd->buttons = BT_SPECIAL | BTS_SAVEGAME | (savegameslot<<BTS_SAVESHIFT);
 610         }
 611 }
 612
 613
 614 /*
 615 ==============
 616 =
 617 = G_DoLoadLevel
 618 =
 619 ==============
 620 */
 621
 622 void G_DoLoadLevel (void)
 623 {
 624         int             i;
 625
 626         levelstarttic = gametic;        // for time calculation
 627         gamestate = GS_LEVEL;
 628         for (i=0 ; i<MAXPLAYERS ; i++)
 629         {
 630                 if (playeringame[i] && players[i].playerstate == PST_DEAD)
 631                         players[i].playerstate = PST_REBORN;
 632                 memset (players[i].frags,0,sizeof(players[i].frags));
 633         }
 634
 635         SN_StopAllSequences();
 636         P_SetupLevel (gameepisode, gamemap, 0, gameskill);
 637         displayplayer = consoleplayer;      // view the guy you are playing
 638         starttime = I_GetTime ();
 639         gameaction = ga_nothing;
 640         Z_CheckHeap ();
 641
 642 //
 643 // clear cmd building stuff
 644 //
 645
 646         memset (gamekeydown, 0, sizeof(gamekeydown));
 647         joyxmove = joyymove = 0;
 648         mousex = mousey = 0;
 649         sendpause = sendsave = paused = false;
 650         memset (mousebuttons, 0, sizeof(mousebuttons));
 651         memset (joybuttons, 0, sizeof(joybuttons));
 652 }
 653
 654
 655 /*
 656 ===============================================================================
 657 =
 658 = G_Responder
 659 =
 660 = get info needed to make ticcmd_ts for the players
 661 =
 662 ===============================================================================
 663 */
 664
 665 boolean G_Responder(event_t *ev)
 666 {
 667         player_t *plr;
 668         extern boolean MenuActive;
 669
 670         plr = &players[consoleplayer];
 671         if(ev->type == ev_keyup && ev->data1 == key_useartifact)
 672         { // flag to denote that it's okay to use an artifact
 673                 if(!inventory)
 674                 {
 675                         plr->readyArtifact = plr->inventory[inv_ptr].type;
 676                 }
 677                 usearti = true;
 678         }
 679
 680         // Check for spy mode player cycle
 681         if(gamestate == GS_LEVEL && ev->type == ev_keydown
 682                 && ev->data1 == KEY_F12 && !deathmatch)
 683         { // Cycle the display player
 684                 do
 685                 {
 686                         displayplayer++;
 687                         if(displayplayer == MAXPLAYERS)
 688                         {
 689                                 displayplayer = 0;
 690                         }
 691                 } while(!playeringame[displayplayer]
 692                         && displayplayer != consoleplayer);
 693                 return(true);
 694         }
 695
 696         if(CT_Responder(ev))
 697         { // Chat ate the event
 698                 return(true);
 699         }
 700         if(gamestate == GS_LEVEL)
 701         {
 702                 if(SB_Responder(ev))
 703                 { // Status bar ate the event
 704                         return(true);
 705                 }
 706                 if(AM_Responder(ev))
 707                 { // Automap ate the event
 708                         return(true);
 709                 }
 710         }
 711
 712         switch(ev->type)
 713         {
 714                 case ev_keydown:
 715                         if(ev->data1 == key_invleft)
 716                         {
 717                                 inventoryTics = 5*35;
 718                                 if(!inventory)
 719                                 {
 720                                         inventory = true;
 721                                         break;
 722                                 }
 723                                 inv_ptr--;
 724                                 if(inv_ptr < 0)
 725                                 {
 726                                         inv_ptr = 0;
 727                                 }
 728                                 else
 729                                 {
 730                                         curpos--;
 731                                         if(curpos < 0)
 732                                         {
 733                                                 curpos = 0;
 734                                         }
 735                                 }
 736                                 return(true);
 737                         }
 738                         if(ev->data1 == key_invright)
 739                         {
 740                                 inventoryTics = 5*35;
 741                                 if(!inventory)
 742                                 {
 743                                         inventory = true;
 744                                         break;
 745                                 }
 746                                 inv_ptr++;
 747                                 if(inv_ptr >= plr->inventorySlotNum)
 748                                 {
 749                                         inv_ptr--;
 750                                         if(inv_ptr < 0)
 751                                                 inv_ptr = 0;
 752                                 }
 753                                 else
 754                                 {
 755                                         curpos++;
 756                                         if(curpos > 6)
 757                                         {
 758                                                 curpos = 6;
 759                                         }
 760                                 }
 761                                 return(true);
 762                         }
 763                         if(ev->data1 == KEY_PAUSE && !MenuActive)
 764                         {
 765                                 sendpause = true;
 766                                 return(true);
 767                         }
 768                         if(ev->data1 < NUMKEYS)
 769                         {
 770                                 gamekeydown[ev->data1] = true;
 771                         }
 772                         return(true); // eat key down events
 773
 774                 case ev_keyup:
 775                         if(ev->data1 < NUMKEYS)
 776                         {
 777                                 gamekeydown[ev->data1] = false;
 778                         }
 779                         return(false); // always let key up events filter down
 780
 781                 case ev_mouse:
 782
 783                         mousebuttons[0] = ev->data1&1;
 784                         mousebuttons[1] = ev->data1&2;
 785                         mousebuttons[2] = ev->data1&4;
 786                         mousex = ev->data2*(mouseSensitivity+5)/10;
 787                         mousey = ev->data3*(mouseSensitivity+5)/10;
 788                         return(true); // eat events
 789
 790                 case ev_joystick:
 791                         joybuttons[0] = ev->data1&1;
 792                         joybuttons[1] = ev->data1&2;
 793                         joybuttons[2] = ev->data1&4;
 794                         joybuttons[3] = ev->data1&8;
 795                         joyxmove = ev->data2;
 796                         joyymove = ev->data3;
 797                         return(true); // eat events
 798
 799                 default:
 800                         break;
 801         }
 802         return(false);
 803 }
 804
 805
 806 //==========================================================================
 807 //
 808 // G_Ticker
 809 //
 810 //==========================================================================
 811
 812 void G_Ticker(void)
 813 {
 814         int i, buf;
 815         ticcmd_t *cmd=NULL;
 816
 817 //
 818 // do player reborns if needed
 819 //
 820         for (i=0 ; i<MAXPLAYERS ; i++)
 821                 if (playeringame[i] && players[i].playerstate == PST_REBORN)
 822                         G_DoReborn (i);
 823
 824 //
 825 // do things to change the game state
 826 //
 827         while (gameaction != ga_nothing)
 828         {
 829                 switch (gameaction)
 830                 {
 831                         case ga_loadlevel:
 832                                 G_DoLoadLevel();
 833                                 break;
 834                         case ga_initnew:
 835                                 G_DoInitNew();
 836                                 break;
 837                         case ga_newgame:
 838                                 G_DoNewGame();
 839                                 break;
 840                         case ga_loadgame:
 841                                 Draw_LoadIcon();
 842                                 G_DoLoadGame();
 843                                 break;
 844                         case ga_savegame:
 845                                 Draw_SaveIcon();
 846                                 G_DoSaveGame();
 847                                 break;
 848                         case ga_singlereborn:
 849                                 G_DoSingleReborn();
 850                                 break;
 851                         case ga_playdemo:
 852                                 G_DoPlayDemo();
 853                                 break;
 854                         case ga_screenshot:
 855                                 M_ScreenShot();
 856                                 gameaction = ga_nothing;
 857                                 break;
 858                         case ga_leavemap:
 859                                 Draw_TeleportIcon();
 860                                 G_DoTeleportNewMap();
 861                                 break;
 862                         case ga_completed:
 863                                 G_DoCompleted();
 864                                 break;
 865                         case ga_worlddone:
 866                                 G_DoWorldDone();
 867                                 break;
 868                         case ga_victory:
 869                                 F_StartFinale();
 870                                 break;
 871                         default:
 872                                 break;
 873                 }
 874         }
 875
 876
 877 //
 878 // get commands, check consistancy, and build new consistancy check
 879 //
 880         //buf = gametic%BACKUPTICS;
 881
 882
 883         buf = (gametic/ticdup)%BACKUPTICS;
 884
 885         for (i=0 ; i<MAXPLAYERS ; i++)
 886                 if (playeringame[i])
 887                 {
 888                         cmd = &players[i].cmd;
 889
 890                         memcpy (cmd, &netcmds[i][buf], sizeof(ticcmd_t));
 891
 892                         if (demoplayback)
 893                                 G_ReadDemoTiccmd (cmd);
 894                         if (demorecording)
 895                                 G_WriteDemoTiccmd (cmd);
 896
 897                         if (netgame && !(gametic%ticdup) )
 898                         {
 899                                 if (gametic > BACKUPTICS
 900                                 && consistancy[i][buf] != cmd->consistancy)
 901                                 {
 902                                         I_Error ("consistency failure (%i should be %i)",cmd->consistancy, consistancy[i][buf]);
 903                                 }
 904                                 if (players[i].mo)
 905                                         consistancy[i][buf] = players[i].mo->x;
 906                                 else
 907                                         consistancy[i][buf] = rndindex;
 908                         }
 909                 }
 910
 911 //
 912 // check for special buttons
 913 //
 914         for (i=0 ; i<MAXPLAYERS ; i++)
 915                 if (playeringame[i])
 916                 {
 917                         if (players[i].cmd.buttons & BT_SPECIAL)
 918                         {
 919                                 switch (players[i].cmd.buttons & BT_SPECIALMASK)
 920                                 {
 921                                 case BTS_PAUSE:
 922                                         paused ^= 1;
 923                                         if(paused)
 924                                         {
 925                                                 S_PauseSound();
 926                                         }
 927                                         else
 928                                         {
 929                                                 S_ResumeSound();
 930                                         }
 931                                         break;
 932
 933                                 case BTS_SAVEGAME:
 934                                         if (!savedescription[0])
 935                                         {
 936                                                 if(netgame)
 937                                                 {
 938                                                         strcpy (savedescription, "NET GAME");
 939                                                 }
 940                                                 else
 941                                                 {
 942                                                         strcpy(savedescription, "SAVE GAME");
 943                                                 }
 944                                         }
 945                                         savegameslot =
 946                                                 (players[i].cmd.buttons & BTS_SAVEMASK)>>BTS_SAVESHIFT;
 947                                         gameaction = ga_savegame;
 948                                         break;
 949                                 }
 950                         }
 951                 }
 952
 953 // turn inventory off after a certain amount of time
 954         if(inventory && !(--inventoryTics))
 955         {
 956                 players[consoleplayer].readyArtifact =
 957                         players[consoleplayer].inventory[inv_ptr].type;
 958                 inventory = false;
 959                 cmd->arti = 0;
 960         }
 961 //
 962 // do main actions
 963 //
 964 //
 965 // do main actions
 966 //
 967         switch (gamestate)
 968         {
 969                 case GS_LEVEL:
 970                         P_Ticker ();
 971                         SB_Ticker ();
 972                         AM_Ticker ();
 973                         CT_Ticker();
 974                         break;
 975                 case GS_INTERMISSION:
 976                         IN_Ticker ();
 977                         break;
 978                 case GS_FINALE:
 979                         F_Ticker();
 980                         break;
 981                 case GS_DEMOSCREEN:
 982                         H2_PageTicker ();
 983                         break;
 984         }
 985 }
 986
 987
 988 /*
 989 ==============================================================================
 990
 991                                                 PLAYER STRUCTURE FUNCTIONS
 992
 993 also see P_SpawnPlayer in P_Things
 994 ==============================================================================
 995 */
 996
 997 //==========================================================================
 998 //
 999 // G_PlayerExitMap
1000 //
1001 // Called when the player leaves a map.
1002 //
1003 //==========================================================================
1004
1005 void G_PlayerExitMap(int playerNumber)
1006 {
1007         int i;
1008         player_t *player;
1009         int flightPower;
1010
1011         player = &players[playerNumber];
1012
1013 //      if(deathmatch)
1014 //      {
1015 //              // Strip all but one of each type of artifact
1016 //              for(i = 0; i < player->inventorySlotNum; i++)
1017 //              {
1018 //                      player->inventory[i].count = 1;
1019 //              }
1020 //              player->artifactCount = player->inventorySlotNum;
1021 //      }
1022 //      else
1023
1024         // Strip all current powers (retain flight)
1025         flightPower = player->powers[pw_flight];
1026         memset(player->powers, 0, sizeof(player->powers));
1027         player->powers[pw_flight] = flightPower;
1028
1029         if(deathmatch)
1030         {
1031                 player->powers[pw_flight] = 0;
1032         }
1033         else
1034         {
1035                 if(P_GetMapCluster(gamemap) != P_GetMapCluster(LeaveMap))
1036                 { // Entering new cluster
1037                         // Strip all keys
1038                         player->keys = 0;
1039
1040                         // Strip flight artifact
1041                         for(i = 0; i < 25; i++)
1042                         {
1043                                 player->powers[pw_flight] = 0;
1044                                 P_PlayerUseArtifact(player, arti_fly);
1045                         }
1046                         player->powers[pw_flight] = 0;
1047                 }
1048         }
1049
1050         if(player->morphTics)
1051         {
1052                 player->readyweapon = player->mo->special1; // Restore weapon
1053                 player->morphTics = 0;
1054         }
1055         player->messageTics = 0;
1056         player->lookdir = 0;
1057         player->mo->flags &= ~MF_SHADOW; // Remove invisibility
1058         player->extralight = 0; // Remove weapon flashes
1059         player->fixedcolormap = 0; // Remove torch
1060         player->damagecount = 0; // No palette changes
1061         player->bonuscount = 0;
1062         player->poisoncount = 0;
1063         if(player == &players[consoleplayer])
1064         {
1065                 SB_state = -1; // refresh the status bar
1066                 viewangleoffset = 0;
1067         }
1068 }
1069
1070 //==========================================================================
1071 //
1072 // G_PlayerReborn
1073 //
1074 // Called after a player dies.  Almost everything is cleared and
1075 // initialized.
1076 //
1077 //==========================================================================
1078
1079 void G_PlayerReborn(int player)
1080 {
1081         player_t *p;
1082         int frags[MAXPLAYERS];
1083         int killcount, itemcount, secretcount;
1084         uint worldTimer;
1085
1086         memcpy(frags, players[player].frags, sizeof(frags));
1087         killcount = players[player].killcount;
1088         itemcount = players[player].itemcount;
1089         secretcount = players[player].secretcount;
1090         worldTimer = players[player].worldTimer;
1091
1092         p = &players[player];
1093         memset(p, 0, sizeof(*p));
1094
1095         memcpy(players[player].frags, frags, sizeof(players[player].frags));
1096         players[player].killcount = killcount;
1097         players[player].itemcount = itemcount;
1098         players[player].secretcount = secretcount;
1099         players[player].worldTimer = worldTimer;
1100         players[player].class = PlayerClass[player];
1101
1102         p->usedown = p->attackdown = true; // don't do anything immediately
1103         p->playerstate = PST_LIVE;
1104         p->health = MAXHEALTH;
1105         p->readyweapon = p->pendingweapon = WP_FIRST;
1106         p->weaponowned[WP_FIRST] = true;
1107         p->messageTics = 0;
1108         p->lookdir = 0;
1109         localQuakeHappening[player] = false;
1110         if(p == &players[consoleplayer])
1111         {
1112                 SB_state = -1; // refresh the status bar
1113                 inv_ptr = 0; // reset the inventory pointer
1114                 curpos = 0;
1115                 viewangleoffset = 0;
1116         }
1117 }
1118
1119 /*
1120 ====================
1121 =
1122 = G_CheckSpot
1123 =
1124 = Returns false if the player cannot be respawned at the given mapthing_t spot
1125 = because something is occupying it
1126 ====================
1127 */
1128
1129 void P_SpawnPlayer (mapthing_t *mthing);
1130
1131 boolean G_CheckSpot (int playernum, mapthing_t *mthing)
1132 {
1133         fixed_t         x,y;
1134         subsector_t *ss;
1135         unsigned        an;
1136         mobj_t      *mo;
1137
1138         x = mthing->x << FRACBITS;
1139         y = mthing->y << FRACBITS;
1140
1141         players[playernum].mo->flags2 &= ~MF2_PASSMOBJ;
1142         if (!P_CheckPosition (players[playernum].mo, x, y) )
1143         {
1144                 players[playernum].mo->flags2 |= MF2_PASSMOBJ;
1145                 return false;
1146         }
1147         players[playernum].mo->flags2 |= MF2_PASSMOBJ;
1148
1149 // spawn a teleport fog
1150         ss = R_PointInSubsector (x,y);
1151         an = ( ANG45 * (mthing->angle/45) ) >> ANGLETOFINESHIFT;
1152
1153         mo = P_SpawnMobj (x+20*finecosine[an], y+20*finesine[an],
1154                 ss->sector->floorheight+TELEFOGHEIGHT, MT_TFOG);
1155
1156         if (players[consoleplayer].viewz != 1)
1157                 S_StartSound (mo, SFX_TELEPORT);  // don't start sound on first frame
1158
1159         return true;
1160 }
1161
1162 /*
1163 ====================
1164 =
1165 = G_DeathMatchSpawnPlayer
1166 =
1167 = Spawns a player at one of the random death match spots
1168 = called at level load and each death
1169 ====================
1170 */
1171
1172 void G_DeathMatchSpawnPlayer (int playernum)
1173 {
1174         int             i,j;
1175         int             selections;
1176
1177         selections = deathmatch_p - deathmatchstarts;
1178
1179         // This check has been moved to p_setup.c:P_LoadThings()
1180         //if (selections < 8)
1181         //      I_Error ("Only %i deathmatch spots, 8 required", selections);
1182
1183         for (j=0 ; j<20 ; j++)
1184         {
1185                 i = P_Random() % selections;
1186                 if (G_CheckSpot (playernum, &deathmatchstarts[i]) )
1187                 {
1188                         deathmatchstarts[i].type = playernum+1;
1189                         P_SpawnPlayer (&deathmatchstarts[i]);
1190                         return;
1191                 }
1192         }
1193
1194 // no good spot, so the player will probably get stuck
1195         P_SpawnPlayer (&playerstarts[0][playernum]);
1196 }
1197
1198 //==========================================================================
1199 //
1200 // G_DoReborn
1201 //
1202 //==========================================================================
1203
1204 void G_DoReborn(int playernum)
1205 {
1206         int i;
1207         boolean oldWeaponowned[NUMWEAPONS];
1208         int oldKeys;
1209         int oldPieces;
1210         boolean foundSpot;
1211         int bestWeapon;
1212
1213         if(G_CheckDemoStatus())
1214         {
1215                 return;
1216         }
1217         if(!netgame)
1218         {
1219                 if(SV_RebornSlotAvailable())
1220                 { // Use the reborn code if the slot is available
1221                         gameaction = ga_singlereborn;
1222                 }
1223                 else
1224                 { // Start a new game if there's no reborn info
1225                         gameaction = ga_newgame;
1226                 }
1227         }
1228         else
1229         { // Net-game
1230                 players[playernum].mo->player = NULL; // Dissassociate the corpse
1231
1232                 if(deathmatch)
1233                 { // Spawn at random spot if in death match
1234                         G_DeathMatchSpawnPlayer(playernum);
1235                         return;
1236                 }
1237
1238                 // Cooperative net-play, retain keys and weapons
1239                 oldKeys = players[playernum].keys;
1240                 oldPieces = players[playernum].pieces;
1241                 for(i = 0; i < NUMWEAPONS; i++)
1242                 {
1243                         oldWeaponowned[i] = players[playernum].weaponowned[i];
1244                 }
1245
1246                 foundSpot = false;
1247                 if(G_CheckSpot(playernum,
1248                         &playerstarts[RebornPosition][playernum]))
1249                 { // Appropriate player start spot is open
1250                         P_SpawnPlayer(&playerstarts[RebornPosition][playernum]);
1251                         foundSpot = true;
1252                 }
1253                 else
1254                 {
1255                         // Try to spawn at one of the other player start spots
1256                         for(i = 0; i < MAXPLAYERS; i++)
1257                         {
1258                                 if(G_CheckSpot(playernum, &playerstarts[RebornPosition][i]))
1259                                 { // Found an open start spot
1260
1261                                         // Fake as other player
1262                                         playerstarts[RebornPosition][i].type = playernum+1;
1263                                         P_SpawnPlayer(&playerstarts[RebornPosition][i]);
1264
1265                                         // Restore proper player type
1266                                         playerstarts[RebornPosition][i].type = i+1;
1267
1268                                         foundSpot = true;
1269                                         break;
1270                                 }
1271                         }
1272                 }
1273
1274                 if(foundSpot == false)
1275                 { // Player's going to be inside something
1276                         P_SpawnPlayer(&playerstarts[RebornPosition][playernum]);
1277                 }
1278
1279                 // Restore keys and weapons
1280                 players[playernum].keys = oldKeys;
1281                 players[playernum].pieces = oldPieces;
1282                 for(bestWeapon = 0, i = 0; i < NUMWEAPONS; i++)
1283                 {
1284                         if(oldWeaponowned[i])
1285                         {
1286                                 bestWeapon = i;
1287                                 players[playernum].weaponowned[i] = true;
1288                         }
1289                 }
1290                 players[playernum].mana[MANA_1] = 25;
1291                 players[playernum].mana[MANA_2] = 25;
1292                 if(bestWeapon)
1293                 { // Bring up the best weapon
1294                         players[playernum].pendingweapon = bestWeapon;
1295                 }
1296         }
1297 }
1298
1299 void G_ScreenShot (void)
1300 {
1301         gameaction = ga_screenshot;
1302 }
1303
1304 //==========================================================================
1305 //
1306 // G_StartNewInit
1307 //
1308 //==========================================================================
1309
1310 void G_StartNewInit(void)
1311 {
1312         SV_InitBaseSlot();
1313         SV_ClearRebornSlot();
1314         P_ACSInitNewGame();
1315         // Default the player start spot group to 0
1316         RebornPosition = 0;
1317 }
1318
1319 //==========================================================================
1320 //
1321 // G_StartNewGame
1322 //
1323 //==========================================================================
1324
1325 void G_StartNewGame(skill_t skill)
1326 {
1327         int realMap;
1328
1329         G_StartNewInit();
1330         realMap = P_TranslateMap(1);
1331         if(realMap == -1)
1332         {
1333                 realMap = 1;
1334         }
1335         G_InitNew(TempSkill, 1, realMap);
1336 }
1337
1338 //==========================================================================
1339 //
1340 // G_TeleportNewMap
1341 //
1342 // Only called by the warp cheat code.  Works just like normal map to map
1343 // teleporting, but doesn't do any interlude stuff.
1344 //
1345 //==========================================================================
1346
1347 void G_TeleportNewMap(int map, int position)
1348 {
1349         gameaction = ga_leavemap;
1350         LeaveMap = map;
1351         LeavePosition = position;
1352 }
1353
1354 //==========================================================================
1355 //
1356 // G_DoTeleportNewMap
1357 //
1358 //==========================================================================
1359
1360 void G_DoTeleportNewMap(void)
1361 {
1362         SV_MapTeleport(LeaveMap, LeavePosition);
1363         gamestate = GS_LEVEL;
1364         gameaction = ga_nothing;
1365         RebornPosition = LeavePosition;
1366 }
1367
1368 /*
1369 boolean secretexit;
1370 void G_ExitLevel (void)
1371 {
1372         secretexit = false;
1373         gameaction = ga_completed;
1374 }
1375 void G_SecretExitLevel (void)
1376 {
1377         secretexit = true;
1378         gameaction = ga_completed;
1379 }
1380 */
1381
1382 //==========================================================================
1383 //
1384 // G_Completed
1385 //
1386 // Starts intermission routine, which is used only during hub exits,
1387 // and DeathMatch games.
1388 //==========================================================================
1389
1390 void G_Completed(int map, int position)
1391 {
1392         gameaction = ga_completed;
1393         LeaveMap = map;
1394         LeavePosition = position;
1395 }
1396
1397 void G_DoCompleted(void)
1398 {
1399         int i;
1400
1401         gameaction = ga_nothing;
1402         if(G_CheckDemoStatus())
1403         {
1404                 return;
1405         }
1406         for(i = 0; i < MAXPLAYERS; i++)
1407         {
1408                 if(playeringame[i])
1409                 {
1410                         G_PlayerExitMap(i);
1411                 }
1412         }
1413         if(LeaveMap == -1 && LeavePosition == -1)
1414         {
1415                 gameaction = ga_victory;
1416                 return;
1417         }
1418         else
1419         {
1420                 gamestate = GS_INTERMISSION;
1421                 IN_Start();
1422         }
1423
1424 /*
1425         int i;
1426         static int afterSecret[3] = { 7, 5, 5 };
1427
1428         gameaction = ga_nothing;
1429         if(G_CheckDemoStatus())
1430         {
1431                 return;
1432         }
1433         for(i = 0; i < MAXPLAYERS; i++)
1434         {
1435                 if(playeringame[i])
1436                 {
1437                         G_PlayerFinishLevel(i);
1438                 }
1439         }
1440         prevmap = gamemap;
1441         if(secretexit == true)
1442         {
1443                 gamemap = 9;
1444         }
1445         else if(gamemap == 9)
1446         { // Finished secret level
1447                 gamemap = afterSecret[gameepisode-1];
1448         }
1449         else if(gamemap == 8)
1450         {
1451                 gameaction = ga_victory;
1452                 return;
1453         }
1454         else
1455         {
1456                 gamemap++;
1457         }
1458         gamestate = GS_INTERMISSION;
1459         IN_Start();
1460 */
1461 }
1462
1463 //============================================================================
1464 //
1465 // G_WorldDone
1466 //
1467 //============================================================================
1468
1469 void G_WorldDone(void)
1470 {
1471         gameaction = ga_worlddone;
1472 }
1473
1474 //============================================================================
1475 //
1476 // G_DoWorldDone
1477 //
1478 //============================================================================
1479
1480 void G_DoWorldDone(void)
1481 {
1482         gamestate = GS_LEVEL;
1483         G_DoLoadLevel();
1484         gameaction = ga_nothing;
1485         viewactive = true;
1486 }
1487
1488 //==========================================================================
1489 //
1490 // G_DoSingleReborn
1491 //
1492 // Called by G_Ticker based on gameaction.  Loads a game from the reborn
1493 // save slot.
1494 //
1495 //==========================================================================
1496
1497 void G_DoSingleReborn(void)
1498 {
1499         gameaction = ga_nothing;
1500         SV_LoadGame(SV_GetRebornSlot());
1501         SB_SetClassData();
1502 }
1503
1504 //==========================================================================
1505 //
1506 // G_LoadGame
1507 //
1508 // Can be called by the startup code or the menu task.
1509 //
1510 //==========================================================================
1511
1512 static int GameLoadSlot;
1513
1514 void G_LoadGame(int slot)
1515 {
1516         GameLoadSlot = slot;
1517         gameaction = ga_loadgame;
1518 }
1519
1520 //==========================================================================
1521 //
1522 // G_DoLoadGame
1523 //
1524 // Called by G_Ticker based on gameaction.
1525 //
1526 //==========================================================================
1527
1528 void G_DoLoadGame(void)
1529 {
1530         gameaction = ga_nothing;
1531         SV_LoadGame(GameLoadSlot);
1532         if(!netgame)
1533         { // Copy the base slot to the reborn slot
1534                 SV_UpdateRebornSlot();
1535         }
1536         SB_SetClassData();
1537 }
1538
1539 //==========================================================================
1540 //
1541 // G_SaveGame
1542 //
1543 // Called by the menu task.  <description> is a 24 byte text string.
1544 //
1545 //==========================================================================
1546
1547 void G_SaveGame(int slot, char *description)
1548 {
1549         savegameslot = slot;
1550         strcpy(savedescription, description);
1551         sendsave = true;
1552 }
1553
1554 //==========================================================================
1555 //
1556 // G_DoSaveGame
1557 //
1558 // Called by G_Ticker based on gameaction.
1559 //
1560 //==========================================================================
1561
1562 void G_DoSaveGame(void)
1563 {
1564         SV_SaveGame(savegameslot, savedescription);
1565         gameaction = ga_nothing;
1566         savedescription[0] = 0;
1567         P_SetMessage(&players[consoleplayer], TXT_GAMESAVED, true);
1568 }
1569
1570 //==========================================================================
1571 //
1572 // G_DeferredNewGame
1573 //
1574 //==========================================================================
1575
1576 void G_DeferredNewGame(skill_t skill)
1577 {
1578         TempSkill = skill;
1579         gameaction = ga_newgame;
1580 }
1581
1582 //==========================================================================
1583 //
1584 // G_DoNewGame
1585 //
1586 //==========================================================================
1587
1588 void G_DoNewGame(void)
1589 {
1590         G_StartNewGame(TempSkill);
1591         gameaction = ga_nothing;
1592 }
1593
1594 /*
1595 ====================
1596 =
1597 = G_InitNew
1598 =
1599 = Can be called by the startup code or the menu task
1600 = consoleplayer, displayplayer, playeringame[] should be set
1601 ====================
1602 */
1603
1604 void G_DeferedInitNew(skill_t skill, int episode, int map)
1605 {
1606         TempSkill = skill;
1607         TempEpisode = episode;
1608         TempMap = map;
1609         gameaction = ga_initnew;
1610 }
1611
1612 void G_DoInitNew(void)
1613 {
1614         SV_InitBaseSlot();
1615         G_InitNew(TempSkill, TempEpisode, TempMap);
1616         gameaction = ga_nothing;
1617 }
1618
1619 void G_InitNew(skill_t skill, int episode, int map)
1620 {
1621         int i;
1622
1623         if(paused)
1624         {
1625                 paused = false;
1626                 S_ResumeSound();
1627         }
1628         if(skill < sk_baby)
1629         {
1630                 skill = sk_baby;
1631         }
1632         if(skill > sk_nightmare)
1633         {
1634                 skill = sk_nightmare;
1635         }
1636         if(map < 1)
1637         {
1638                 map = 1;
1639         }
1640         if(map > 99)
1641         {
1642                 map = 99;
1643         }
1644         M_ClearRandom();
1645         // Force players to be initialized upon first level load
1646         for(i = 0; i < MAXPLAYERS; i++)
1647         {
1648                 players[i].playerstate = PST_REBORN;
1649                 players[i].worldTimer = 0;
1650         }
1651
1652         // Set up a bunch of globals
1653         usergame = true; // will be set false if a demo
1654         paused = false;
1655         demorecording = false;
1656         demoplayback = false;
1657         viewactive = true;
1658         gameepisode = episode;
1659         gamemap = map;
1660         gameskill = skill;
1661         BorderNeedRefresh = true;
1662
1663         // Initialize the sky
1664         R_InitSky(map);
1665
1666         // Give one null ticcmd_t
1667         //gametic = 0;
1668         //maketic = 1;
1669         //for (i=0 ; i<MAXPLAYERS ; i++)
1670         //      nettics[i] = 1; // one null event for this gametic
1671         //memset (localcmds,0,sizeof(localcmds));
1672         //memset (netcmds,0,sizeof(netcmds));
1673
1674         G_DoLoadLevel();
1675 }
1676
1677 /*
1678 ===============================================================================
1679
1680                                                         DEMO RECORDING
1681
1682 ===============================================================================
1683 */
1684
1685 #define DEMOMARKER      0x80
1686
1687 void G_ReadDemoTiccmd (ticcmd_t *cmd)
1688 {
1689         if (*demo_p == DEMOMARKER)
1690         {       // end of demo data stream
1691                 G_CheckDemoStatus ();
1692                 return;
1693         }
1694         cmd->forwardmove = ((signed char)*demo_p++);
1695         cmd->sidemove = ((signed char)*demo_p++);
1696         cmd->angleturn = ((unsigned char)*demo_p++)<<8;
1697         cmd->buttons = (unsigned char)*demo_p++;
1698         cmd->lookfly = (unsigned char)*demo_p++;
1699         cmd->arti = (unsigned char)*demo_p++;
1700 }
1701
1702 void G_WriteDemoTiccmd (ticcmd_t *cmd)
1703 {
1704         if (gamekeydown['q'])           // press q to end demo recording
1705                 G_CheckDemoStatus ();
1706         *demo_p++ = cmd->forwardmove;
1707         *demo_p++ = cmd->sidemove;
1708         *demo_p++ = cmd->angleturn>>8;
1709         *demo_p++ = cmd->buttons;
1710         *demo_p++ = cmd->lookfly;
1711         *demo_p++ = cmd->arti;
1712         demo_p -= 6;
1713         G_ReadDemoTiccmd (cmd);         // make SURE it is exactly the same
1714 }
1715
1716
1717
1718 /*
1719 ===================
1720 =
1721 = G_RecordDemo
1722 =
1723 ===================
1724 */
1725
1726 void G_RecordDemo (skill_t skill, int numplayers, int episode, int map, char *name)
1727 {
1728         int             i;
1729
1730         G_InitNew (skill, episode, map);
1731         usergame = false;
1732         strcpy (demoname, name);
1733         strcat (demoname, ".lmp");
1734         demobuffer = demo_p = Z_Malloc (0x20000,PU_STATIC,NULL);
1735         *demo_p++ = skill;
1736         *demo_p++ = episode;
1737         *demo_p++ = map;
1738
1739         for (i=0 ; i<MAXPLAYERS ; i++)
1740         {
1741                 *demo_p++ = playeringame[i];
1742                 *demo_p++ = PlayerClass[i];
1743         }
1744         demorecording = true;
1745 }
1746
1747
1748 /*
1749 ===================
1750 =
1751 = G_PlayDemo
1752 =
1753 ===================
1754 */
1755
1756 char    *defdemoname;
1757
1758 void G_DeferedPlayDemo (char *name)
1759 {
1760         defdemoname = name;
1761         gameaction = ga_playdemo;
1762 }
1763
1764 void G_DoPlayDemo (void)
1765 {
1766         skill_t skill;
1767         int             i, episode, map;
1768
1769         gameaction = ga_nothing;
1770         demobuffer = demo_p = W_CacheLumpName (defdemoname, PU_STATIC);
1771         skill = *demo_p++;
1772         episode = *demo_p++;
1773         map = *demo_p++;
1774
1775         for (i=0 ; i<MAXPLAYERS ; i++)
1776         {
1777                 playeringame[i] = *demo_p++;
1778                 PlayerClass[i] = *demo_p++;
1779         }
1780
1781         // Initialize world info, etc.
1782         G_StartNewInit();
1783
1784         precache = false;               // don't spend a lot of time in loadlevel
1785         G_InitNew (skill, episode, map);
1786         precache = true;
1787         usergame = false;
1788         demoplayback = true;
1789 }
1790
1791
1792 /*
1793 ===================
1794 =
1795 = G_TimeDemo
1796 =
1797 ===================
1798 */
1799
1800 void G_TimeDemo (char *name)
1801 {
1802         skill_t skill;
1803         int             episode, map;
1804
1805         demobuffer = demo_p = W_CacheLumpName (name, PU_STATIC);
1806         skill = *demo_p++;
1807         episode = *demo_p++;
1808         map = *demo_p++;
1809         G_InitNew (skill, episode, map);
1810         usergame = false;
1811         demoplayback = true;
1812         timingdemo = true;
1813         singletics = true;
1814 }
1815
1816
1817 /*
1818 ===================
1819 =
1820 = G_CheckDemoStatus
1821 =
1822 = Called after a death or level completion to allow demos to be cleaned up
1823 = Returns true if a new demo loop action will take place
1824 ===================
1825 */
1826
1827 boolean G_CheckDemoStatus (void)
1828 {
1829         int             endtime;
1830
1831         if (timingdemo)
1832         {
1833                 endtime = I_GetTime ();
1834                 I_Error ("timed %i gametics in %i realtics",gametic
1835                 , endtime-starttime);
1836         }
1837
1838         if (demoplayback)
1839         {
1840                 if (singledemo)
1841                         I_Quit ();
1842
1843                 Z_ChangeTag (demobuffer, PU_CACHE);
1844                 demoplayback = false;
1845                 H2_AdvanceDemo();
1846                 return true;
1847         }
1848
1849         if (demorecording)
1850         {
1851                 *demo_p++ = DEMOMARKER;
1852                 M_WriteFile (demoname, demobuffer, demo_p - demobuffer);
1853                 Z_Free (demobuffer);
1854                 demorecording = false;
1855                 I_Error ("Demo %s recorded",demoname);
1856         }
1857
1858         return false;
1859 }