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