src/g_game.c

   1 // Emacs style mode select   -*- C++ -*-
   2 //-----------------------------------------------------------------------------
   3 //
   4 // Copyright(C) 1993-1996 Id Software, Inc.
   5 // Copyright(C) 2005 Simon Howard
   6 //
   7 // This program is free software; you can redistribute it and/or
   8 // modify it under the terms of the GNU General Public License
   9 // as published by the Free Software Foundation; either version 2
  10 // of the License, or (at your option) any later version.
  11 //
  12 // This program is distributed in the hope that it will be useful,
  13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 // GNU General Public License for more details.
  16 //
  17 // You should have received a copy of the GNU General Public License
  18 // along with this program; if not, write to the Free Software
  19 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  20 // 02111-1307, USA.
  21 //
  22 // DESCRIPTION:  none
  23 //
  24 //-----------------------------------------------------------------------------
  25
  26
  27
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <math.h>
  31
  32 #include "doomdef.h"
  33 #include "doomstat.h"
  34
  35 #include "deh_main.h"
  36 #include "deh_misc.h"
  37
  38 #include "z_zone.h"
  39 #include "f_finale.h"
  40 #include "m_argv.h"
  41 #include "m_misc.h"
  42 #include "m_menu.h"
  43 #include "m_random.h"
  44 #include "i_system.h"
  45 #include "i_timer.h"
  46 #include "i_video.h"
  47
  48 #include "p_setup.h"
  49 #include "p_saveg.h"
  50 #include "p_tick.h"
  51
  52 #include "d_main.h"
  53
  54 #include "wi_stuff.h"
  55 #include "hu_stuff.h"
  56 #include "st_stuff.h"
  57 #include "am_map.h"
  58
  59 // Needs access to LFB.
  60 #include "v_video.h"
  61
  62 #include "w_wad.h"
  63
  64 #include "p_local.h"
  65
  66 #include "s_sound.h"
  67
  68 // Data.
  69 #include "dstrings.h"
  70 #include "sounds.h"
  71
  72 // SKY handling - still the wrong place.
  73 #include "r_data.h"
  74 #include "r_sky.h"
  75
  76
  77
  78 #include "g_game.h"
  79
  80
  81 #define SAVEGAMESIZE    0x2c000
  82
  83
  84
  85 boolean G_CheckDemoStatus (void);
  86 void    G_ReadDemoTiccmd (ticcmd_t* cmd);
  87 void    G_WriteDemoTiccmd (ticcmd_t* cmd);
  88 void    G_PlayerReborn (int player);
  89 void    G_InitNew (skill_t skill, int episode, int map);
  90
  91 void    G_DoReborn (int playernum);
  92
  93 void    G_DoLoadLevel (void);
  94 void    G_DoNewGame (void);
  95 void    G_DoLoadGame (void);
  96 void    G_DoPlayDemo (void);
  97 void    G_DoCompleted (void);
  98 void    G_DoVictory (void);
  99 void    G_DoWorldDone (void);
 100 void    G_DoSaveGame (void);
 101
 102 // Gamestate the last time G_Ticker was called.
 103
 104 gamestate_t     oldgamestate;
 105
 106 gameaction_t    gameaction;
 107 gamestate_t     gamestate;
 108 skill_t         gameskill;
 109 boolean         respawnmonsters;
 110 int             gameepisode;
 111 int             gamemap;
 112
 113 // If non-zero, exit the level after this number of minutes.
 114
 115 int             timelimit;
 116
 117 boolean         paused;
 118 boolean         sendpause;              // send a pause event next tic
 119 boolean         sendsave;               // send a save event next tic
 120 boolean         usergame;               // ok to save / end game
 121
 122 boolean         timingdemo;             // if true, exit with report on completion
 123 boolean         nodrawers;              // for comparative timing purposes
 124 boolean         noblit;                 // for comparative timing purposes
 125 int             starttime;              // for comparative timing purposes
 126
 127 boolean         viewactive;
 128
 129 boolean         deathmatch;             // only if started as net death
 130 boolean         netgame;                // only true if packets are broadcast
 131 boolean         playeringame[MAXPLAYERS];
 132 player_t        players[MAXPLAYERS];
 133
 134 boolean         turbodetected[MAXPLAYERS];
 135
 136 int             consoleplayer;          // player taking events and displaying
 137 int             displayplayer;          // view being displayed
 138 int             gametic;
 139 int             levelstarttic;          // gametic at level start
 140 int             totalkills, totalitems, totalsecret;    // for intermission
 141
 142 char            demoname[32];
 143 boolean         demorecording;
 144 boolean         longtics;               // cph's doom 1.91 longtics hack
 145 boolean         lowres_turn;            // low resolution turning for longtics
 146 boolean         demoplayback;
 147 boolean         netdemo;
 148 byte*           demobuffer;
 149 byte*           demo_p;
 150 byte*           demoend;
 151 boolean         singledemo;             // quit after playing a demo from cmdline
 152
 153 boolean         precache = true;        // if true, load all graphics at start
 154
 155 boolean         testcontrols = false;    // Invoked by setup to test controls
 156
 157 wbstartstruct_t wminfo;                 // parms for world map / intermission
 158
 159 byte            consistancy[MAXPLAYERS][BACKUPTICS];
 160
 161
 162 //
 163 // Controls
 164 //
 165 int             key_right = KEY_RIGHTARROW;
 166 int             key_left = KEY_LEFTARROW;
 167
 168 int             key_up = KEY_UPARROW;
 169 int             key_down = KEY_DOWNARROW;
 170 int             key_strafeleft = ',';
 171 int             key_straferight = '.';
 172 int             key_fire = KEY_RCTRL;
 173 int             key_use = ' ';
 174 int             key_strafe = KEY_RALT;
 175 int             key_speed = KEY_RSHIFT;
 176
 177 int             key_weapon1 = '1';
 178 int             key_weapon2 = '2';
 179 int             key_weapon3 = '3';
 180 int             key_weapon4 = '4';
 181 int             key_weapon5 = '5';
 182 int             key_weapon6 = '6';
 183 int             key_weapon7 = '7';
 184 int             key_weapon8 = '8';
 185
 186 int             key_pause = KEY_PAUSE;
 187
 188 int             mousebfire = 0;
 189 int             mousebstrafe = 1;
 190 int             mousebforward = 2;
 191
 192 int             mousebstrafeleft = -1;
 193 int             mousebstraferight = -1;
 194 int             mousebbackward = -1;
 195 int             mousebuse = -1;
 196
 197 // Control whether if a mouse button is double clicked, it acts like
 198 // "use" has been pressed
 199
 200 int             dclick_use = 1;
 201
 202 int             joybfire = 0;
 203 int             joybstrafe = 1;
 204 int             joybuse = 3;
 205 int             joybspeed = 2;
 206 int             joybstrafeleft = -1;
 207 int             joybstraferight = -1;
 208
 209 // fraggle: Disallow mouse and joystick movement to cause forward/backward
 210 // motion.  Specified with the '-novert' command line parameter.
 211 // This is an int to allow saving to config file
 212
 213 int             novert = 0;
 214
 215
 216
 217 #define MAXPLMOVE               (forwardmove[1])
 218
 219 #define TURBOTHRESHOLD  0x32
 220
 221 fixed_t         forwardmove[2] = {0x19, 0x32};
 222 fixed_t         sidemove[2] = {0x18, 0x28};
 223 fixed_t         angleturn[3] = {640, 1280, 320};    // + slow turn
 224
 225 static int *weapon_keys[] = {
 226     &key_weapon1,
 227     &key_weapon2,
 228     &key_weapon3,
 229     &key_weapon4,
 230     &key_weapon5,
 231     &key_weapon6,
 232     &key_weapon7,
 233     &key_weapon8
 234 };
 235
 236 #define SLOWTURNTICS    6
 237
 238 #define NUMKEYS         256
 239
 240 static boolean  gamekeydown[NUMKEYS];
 241 static int      turnheld;               // for accelerative turning
 242
 243 static boolean  mousearray[4];
 244 static boolean *mousebuttons = &mousearray[1];  // allow [-1]
 245
 246 // mouse values are used once
 247 int             mousex;
 248 int             mousey;
 249
 250 static int      dclicktime;
 251 static boolean  dclickstate;
 252 static int      dclicks;
 253 static int      dclicktime2;
 254 static boolean  dclickstate2;
 255 static int      dclicks2;
 256
 257 #define MAX_JOY_BUTTONS 20
 258
 259 // joystick values are repeated
 260 static int      joyxmove;
 261 static int      joyymove;
 262 static boolean  joyarray[MAX_JOY_BUTTONS + 1];
 263 static boolean *joybuttons = &joyarray[1];              // allow [-1]
 264
 265 static int      savegameslot;
 266 static char     savedescription[32];
 267
 268 static int      testcontrols_mousespeed;
 269
 270 #define BODYQUESIZE     32
 271
 272 mobj_t*         bodyque[BODYQUESIZE];
 273 int             bodyqueslot;
 274
 275 int             vanilla_savegame_limit = 1;
 276 int             vanilla_demo_limit = 1;
 277
 278
 279 #define MOUSE_SPEED_BOX_WIDTH 16
 280 #define COLOR_RED    0xb0
 281 #define COLOR_BLACK  0x00
 282 #define COLOR_WHITE  0x04
 283 #define COLOR_YELLOW 0xe7
 284
 285 void G_DrawMouseSpeedBox(void)
 286 {
 287     extern int usemouse;
 288     int i;
 289     int box_x, box_y;
 290     int original_speed;
 291     int x, y;
 292     int redline_x;
 293     int linelen;
 294     char *lumpname;
 295     int color;
 296
 297     // If the mouse is turned off or acceleration is turned off, don't
 298     // draw the box at all.
 299
 300     if (!usemouse || fabs(mouse_acceleration - 1) < 0.01)
 301     {
 302         return;
 303     }
 304
 305     // Calculate box position
 306
 307     box_x = SCREENWIDTH - MOUSE_SPEED_BOX_WIDTH * 8;
 308     box_y = SCREENHEIGHT - 9;
 309
 310     // Draw the box.
 311
 312     x = box_x;
 313
 314     for (i=0; i<MOUSE_SPEED_BOX_WIDTH; ++i)
 315     {
 316         if (i == 0)
 317         {
 318             lumpname = "M_LSLEFT";
 319         }
 320         else if (i == MOUSE_SPEED_BOX_WIDTH - 1)
 321         {
 322             lumpname = "M_LSRGHT";
 323         }
 324         else
 325         {
 326             lumpname = "M_LSCNTR";
 327         }
 328
 329         V_DrawPatchDirect(x, box_y, 0, W_CacheLumpName(DEH_String(lumpname),
 330                                                        PU_CACHE));
 331         x += 8;
 332     }
 333
 334     // Calculate the position of the red line.  This is 1/3 of the way
 335     // along the box.
 336
 337     redline_x = (MOUSE_SPEED_BOX_WIDTH / 3) * 8;
 338
 339     // Undo acceleration and get back the original mouse speed
 340
 341     if (testcontrols_mousespeed < mouse_threshold)
 342     {
 343         original_speed = testcontrols_mousespeed;
 344     }
 345     else
 346     {
 347         original_speed = testcontrols_mousespeed - mouse_threshold;
 348         original_speed = (int) (original_speed / mouse_acceleration);
 349         original_speed += mouse_threshold;
 350     }
 351
 352     // Calculate line length
 353
 354     linelen = (original_speed * redline_x) / mouse_threshold;
 355
 356     // Draw horizontal "thermometer"
 357
 358     for (x=0; x<(MOUSE_SPEED_BOX_WIDTH - 1) * 8; ++x)
 359     {
 360         if (x < linelen)
 361         {
 362             if (x < redline_x)
 363             {
 364                 color = COLOR_WHITE;
 365             }
 366             else
 367             {
 368                 color = COLOR_YELLOW;
 369             }
 370         }
 371         else
 372         {
 373             color = COLOR_BLACK;
 374         }
 375
 376         screens[0][(box_y - 4) * SCREENWIDTH + box_x + x + 1] = color;
 377     }
 378
 379     // Draw red line
 380
 381     for (y=box_y - 8; y<box_y; ++y)
 382     {
 383         screens[0][y * SCREENWIDTH + box_x + redline_x] = COLOR_RED;
 384     }
 385 }
 386
 387 int G_CmdChecksum (ticcmd_t* cmd)
 388 {
 389     size_t              i;
 390     int         sum = 0;
 391
 392     for (i=0 ; i< sizeof(*cmd)/4 - 1 ; i++)
 393         sum += ((int *)cmd)[i];
 394
 395     return sum;
 396 }
 397
 398
 399 //
 400 // G_BuildTiccmd
 401 // Builds a ticcmd from all of the available inputs
 402 // or reads it from the demo buffer.
 403 // If recording a demo, write it out
 404 //
 405 void G_BuildTiccmd (ticcmd_t* cmd)
 406 {
 407     int         i;
 408     boolean     strafe;
 409     boolean     bstrafe;
 410     int         speed;
 411     int         tspeed;
 412     int         forward;
 413     int         side;
 414
 415     memset(cmd, 0, sizeof(ticcmd_t));
 416
 417     cmd->consistancy =
 418         consistancy[consoleplayer][maketic%BACKUPTICS];
 419
 420     strafe = gamekeydown[key_strafe] || mousebuttons[mousebstrafe]
 421         || joybuttons[joybstrafe];
 422
 423     // fraggle: support the old "joyb_speed = 31" hack which
 424     // allowed an autorun effect
 425
 426     speed = key_speed >= NUMKEYS
 427          || joybspeed >= MAX_JOY_BUTTONS
 428          || gamekeydown[key_speed]
 429          || joybuttons[joybspeed];
 430
 431     forward = side = 0;
 432
 433     // use two stage accelerative turning
 434     // on the keyboard and joystick
 435     if (joyxmove < 0
 436         || joyxmove > 0
 437         || gamekeydown[key_right]
 438         || gamekeydown[key_left])
 439         turnheld += ticdup;
 440     else
 441         turnheld = 0;
 442
 443     if (turnheld < SLOWTURNTICS)
 444         tspeed = 2;             // slow turn
 445     else
 446         tspeed = speed;
 447
 448     // let movement keys cancel each other out
 449     if (strafe)
 450     {
 451         if (gamekeydown[key_right])
 452         {
 453             // fprintf(stderr, "strafe right\n");
 454             side += sidemove[speed];
 455         }
 456         if (gamekeydown[key_left])
 457         {
 458             //  fprintf(stderr, "strafe left\n");
 459             side -= sidemove[speed];
 460         }
 461         if (joyxmove > 0)
 462             side += sidemove[speed];
 463         if (joyxmove < 0)
 464             side -= sidemove[speed];
 465
 466     }
 467     else
 468     {
 469         if (gamekeydown[key_right])
 470             cmd->angleturn -= angleturn[tspeed];
 471         if (gamekeydown[key_left])
 472             cmd->angleturn += angleturn[tspeed];
 473         if (joyxmove > 0)
 474             cmd->angleturn -= angleturn[tspeed];
 475         if (joyxmove < 0)
 476             cmd->angleturn += angleturn[tspeed];
 477     }
 478
 479     if (gamekeydown[key_up])
 480     {
 481         // fprintf(stderr, "up\n");
 482         forward += forwardmove[speed];
 483     }
 484     if (gamekeydown[key_down])
 485     {
 486         // fprintf(stderr, "down\n");
 487         forward -= forwardmove[speed];
 488     }
 489
 490     if (joyymove < 0)
 491         forward += forwardmove[speed];
 492     if (joyymove > 0)
 493         forward -= forwardmove[speed];
 494
 495     if (gamekeydown[key_strafeleft]
 496      || joybuttons[joybstrafeleft]
 497      || mousebuttons[mousebstrafeleft])
 498     {
 499         side -= sidemove[speed];
 500     }
 501
 502     if (gamekeydown[key_straferight]
 503      || joybuttons[joybstraferight]
 504      || mousebuttons[mousebstraferight])
 505     {
 506         side += sidemove[speed];
 507     }
 508
 509     // buttons
 510     cmd->chatchar = HU_dequeueChatChar();
 511
 512     if (gamekeydown[key_fire] || mousebuttons[mousebfire]
 513         || joybuttons[joybfire])
 514         cmd->buttons |= BT_ATTACK;
 515
 516     if (gamekeydown[key_use]
 517      || joybuttons[joybuse]
 518      || mousebuttons[mousebuse])
 519     {
 520         cmd->buttons |= BT_USE;
 521         // clear double clicks if hit use button
 522         dclicks = 0;
 523     }
 524
 525     // chainsaw overrides
 526
 527     for (i=0; i<arrlen(weapon_keys); ++i)
 528     {
 529         int key = *weapon_keys[i];
 530
 531         if (gamekeydown[key])
 532         {
 533             cmd->buttons |= BT_CHANGE;
 534             cmd->buttons |= i<<BT_WEAPONSHIFT;
 535             break;
 536         }
 537     }
 538
 539     // mouse
 540     if (mousebuttons[mousebforward])
 541     {
 542         forward += forwardmove[speed];
 543     }
 544     if (mousebuttons[mousebbackward])
 545     {
 546         forward -= forwardmove[speed];
 547     }
 548
 549     if (dclick_use)
 550     {
 551         // forward double click
 552         if (mousebuttons[mousebforward] != dclickstate && dclicktime > 1 )
 553         {
 554             dclickstate = mousebuttons[mousebforward];
 555             if (dclickstate)
 556                 dclicks++;
 557             if (dclicks == 2)
 558             {
 559                 cmd->buttons |= BT_USE;
 560                 dclicks = 0;
 561             }
 562             else
 563                 dclicktime = 0;
 564         }
 565         else
 566         {
 567             dclicktime += ticdup;
 568             if (dclicktime > 20)
 569             {
 570                 dclicks = 0;
 571                 dclickstate = 0;
 572             }
 573         }
 574
 575         // strafe double click
 576         bstrafe =
 577             mousebuttons[mousebstrafe]
 578             || joybuttons[joybstrafe];
 579         if (bstrafe != dclickstate2 && dclicktime2 > 1 )
 580         {
 581             dclickstate2 = bstrafe;
 582             if (dclickstate2)
 583                 dclicks2++;
 584             if (dclicks2 == 2)
 585             {
 586                 cmd->buttons |= BT_USE;
 587                 dclicks2 = 0;
 588             }
 589             else
 590                 dclicktime2 = 0;
 591         }
 592         else
 593         {
 594             dclicktime2 += ticdup;
 595             if (dclicktime2 > 20)
 596             {
 597                 dclicks2 = 0;
 598                 dclickstate2 = 0;
 599             }
 600         }
 601     }
 602
 603     // fraggle: allow disabling mouse y movement
 604
 605     if (!novert)
 606     {
 607         forward += mousey;
 608     }
 609
 610     if (strafe)
 611         side += mousex*2;
 612     else
 613         cmd->angleturn -= mousex*0x8;
 614
 615     if (mousex == 0)
 616     {
 617         // No movement in the previous frame
 618
 619         testcontrols_mousespeed = 0;
 620     }
 621
 622     mousex = mousey = 0;
 623
 624     if (forward > MAXPLMOVE)
 625         forward = MAXPLMOVE;
 626     else if (forward < -MAXPLMOVE)
 627         forward = -MAXPLMOVE;
 628     if (side > MAXPLMOVE)
 629         side = MAXPLMOVE;
 630     else if (side < -MAXPLMOVE)
 631         side = -MAXPLMOVE;
 632
 633     cmd->forwardmove += forward;
 634     cmd->sidemove += side;
 635
 636     // special buttons
 637     if (sendpause)
 638     {
 639         sendpause = false;
 640         cmd->buttons = BT_SPECIAL | BTS_PAUSE;
 641     }
 642
 643     if (sendsave)
 644     {
 645         sendsave = false;
 646         cmd->buttons = BT_SPECIAL | BTS_SAVEGAME | (savegameslot<<BTS_SAVESHIFT);
 647     }
 648
 649     // low-res turning
 650
 651     if (lowres_turn)
 652     {
 653         // round angleturn to the nearest 256 boundary
 654         // for recording demos with single byte values for turn
 655
 656         cmd->angleturn = (cmd->angleturn + 128) & 0xff00;
 657     }
 658 }
 659
 660
 661 //
 662 // G_DoLoadLevel
 663 //
 664 extern  gamestate_t     wipegamestate;
 665
 666 void G_DoLoadLevel (void)
 667 {
 668     int             i;
 669
 670     // Set the sky map.
 671     // First thing, we have a dummy sky texture name,
 672     //  a flat. The data is in the WAD only because
 673     //  we look for an actual index, instead of simply
 674     //  setting one.
 675
 676     skyflatnum = R_FlatNumForName(DEH_String(SKYFLATNAME));
 677
 678     levelstarttic = gametic;        // for time calculation
 679
 680     if (wipegamestate == GS_LEVEL)
 681         wipegamestate = -1;             // force a wipe
 682
 683     gamestate = GS_LEVEL;
 684
 685     for (i=0 ; i<MAXPLAYERS ; i++)
 686     {
 687         turbodetected[i] = false;
 688         if (playeringame[i] && players[i].playerstate == PST_DEAD)
 689             players[i].playerstate = PST_REBORN;
 690         memset (players[i].frags,0,sizeof(players[i].frags));
 691     }
 692
 693     P_SetupLevel (gameepisode, gamemap, 0, gameskill);
 694     displayplayer = consoleplayer;              // view the guy you are playing
 695     gameaction = ga_nothing;
 696     Z_CheckHeap ();
 697
 698     // clear cmd building stuff
 699
 700     memset (gamekeydown, 0, sizeof(gamekeydown));
 701     joyxmove = joyymove = 0;
 702     mousex = mousey = 0;
 703     sendpause = sendsave = paused = false;
 704     memset (mousebuttons, 0, sizeof(mousebuttons));
 705     memset (joybuttons, 0, sizeof(joybuttons));
 706
 707     if (testcontrols)
 708     {
 709         players[consoleplayer].message = "Press escape to quit.";
 710     }
 711 }
 712
 713
 714 static void SetJoyButtons(unsigned int buttons_mask)
 715 {
 716     int i;
 717
 718     for (i=0; i<MAX_JOY_BUTTONS; ++i)
 719     {
 720         joybuttons[i] = (buttons_mask & (1 << i)) != 0;
 721     }
 722 }
 723
 724 //
 725 // G_Responder
 726 // Get info needed to make ticcmd_ts for the players.
 727 //
 728 boolean G_Responder (event_t* ev)
 729 {
 730     // allow spy mode changes even during the demo
 731     if (gamestate == GS_LEVEL && ev->type == ev_keydown
 732      && ev->data1 == KEY_F12 && (singledemo || !deathmatch) )
 733     {
 734         // spy mode
 735         do
 736         {
 737             displayplayer++;
 738             if (displayplayer == MAXPLAYERS)
 739                 displayplayer = 0;
 740         } while (!playeringame[displayplayer] && displayplayer != consoleplayer);
 741         return true;
 742     }
 743
 744     // any other key pops up menu if in demos
 745     if (gameaction == ga_nothing && !singledemo &&
 746         (demoplayback || gamestate == GS_DEMOSCREEN)
 747         )
 748     {
 749         if (ev->type == ev_keydown ||
 750             (ev->type == ev_mouse && ev->data1) ||
 751             (ev->type == ev_joystick && ev->data1) )
 752         {
 753             M_StartControlPanel ();
 754             return true;
 755         }
 756         return false;
 757     }
 758
 759     if (gamestate == GS_LEVEL)
 760     {
 761 #if 0
 762         if (devparm && ev->type == ev_keydown && ev->data1 == ';')
 763         {
 764             G_DeathMatchSpawnPlayer (0);
 765             return true;
 766         }
 767 #endif
 768         if (HU_Responder (ev))
 769             return true;        // chat ate the event
 770         if (ST_Responder (ev))
 771             return true;        // status window ate it
 772         if (AM_Responder (ev))
 773             return true;        // automap ate it
 774     }
 775
 776     if (gamestate == GS_FINALE)
 777     {
 778         if (F_Responder (ev))
 779             return true;        // finale ate the event
 780     }
 781
 782     if (testcontrols && ev->type == ev_mouse)
 783     {
 784         // If we are invoked by setup to test the controls, save the
 785         // mouse speed so that we can display it on-screen.
 786         // Perform a low pass filter on this so that the thermometer
 787         // appears to move smoothly.
 788
 789         testcontrols_mousespeed = abs(ev->data2);
 790     }
 791
 792     switch (ev->type)
 793     {
 794       case ev_keydown:
 795         if (ev->data1 == key_pause)
 796         {
 797             sendpause = true;
 798         }
 799         else if (ev->data1 <NUMKEYS)
 800         {
 801             gamekeydown[ev->data1] = true;
 802         }
 803
 804         return true;    // eat key down events
 805
 806       case ev_keyup:
 807         if (ev->data1 <NUMKEYS)
 808             gamekeydown[ev->data1] = false;
 809         return false;   // always let key up events filter down
 810
 811       case ev_mouse:
 812         mousebuttons[0] = ev->data1 & 1;
 813         mousebuttons[1] = ev->data1 & 2;
 814         mousebuttons[2] = ev->data1 & 4;
 815         mousex = ev->data2*(mouseSensitivity+5)/10;
 816         mousey = ev->data3*(mouseSensitivity+5)/10;
 817         return true;    // eat events
 818
 819       case ev_joystick:
 820         SetJoyButtons(ev->data1);
 821         joyxmove = ev->data2;
 822         joyymove = ev->data3;
 823         return true;    // eat events
 824
 825       default:
 826         break;
 827     }
 828
 829     return false;
 830 }
 831
 832
 833
 834 //
 835 // G_Ticker
 836 // Make ticcmd_ts for the players.
 837 //
 838 void G_Ticker (void)
 839 {
 840     int         i;
 841     int         buf;
 842     ticcmd_t*   cmd;
 843
 844     // do player reborns if needed
 845     for (i=0 ; i<MAXPLAYERS ; i++)
 846         if (playeringame[i] && players[i].playerstate == PST_REBORN)
 847             G_DoReborn (i);
 848
 849     // do things to change the game state
 850     while (gameaction != ga_nothing)
 851     {
 852         switch (gameaction)
 853         {
 854           case ga_loadlevel:
 855             G_DoLoadLevel ();
 856             break;
 857           case ga_newgame:
 858             G_DoNewGame ();
 859             break;
 860           case ga_loadgame:
 861             G_DoLoadGame ();
 862             break;
 863           case ga_savegame:
 864             G_DoSaveGame ();
 865             break;
 866           case ga_playdemo:
 867             G_DoPlayDemo ();
 868             break;
 869           case ga_completed:
 870             G_DoCompleted ();
 871             break;
 872           case ga_victory:
 873             F_StartFinale ();
 874             break;
 875           case ga_worlddone:
 876             G_DoWorldDone ();
 877             break;
 878           case ga_screenshot:
 879             V_ScreenShot ();
 880             players[consoleplayer].message = DEH_String("screen shot");
 881             gameaction = ga_nothing;
 882             break;
 883           case ga_nothing:
 884             break;
 885         }
 886     }
 887
 888     // get commands, check consistancy,
 889     // and build new consistancy check
 890     buf = (gametic/ticdup)%BACKUPTICS;
 891
 892     for (i=0 ; i<MAXPLAYERS ; i++)
 893     {
 894         if (playeringame[i])
 895         {
 896             cmd = &players[i].cmd;
 897
 898             memcpy (cmd, &netcmds[i][buf], sizeof(ticcmd_t));
 899
 900             if (demoplayback)
 901                 G_ReadDemoTiccmd (cmd);
 902             if (demorecording)
 903                 G_WriteDemoTiccmd (cmd);
 904
 905             // check for turbo cheats
 906
 907             // check ~ 4 seconds whether to display the turbo message.
 908             // store if the turbo threshold was exceeded in any tics
 909             // over the past 4 seconds.  offset the checking period
 910             // for each player so messages are not displayed at the
 911             // same time.
 912
 913             if (cmd->forwardmove > TURBOTHRESHOLD)
 914             {
 915                 turbodetected[i] = true;
 916             }
 917
 918             if ((gametic & 31) == 0
 919              && ((gametic >> 5) % MAXPLAYERS) == i
 920              && turbodetected[i])
 921             {
 922                 static char turbomessage[80];
 923                 extern char *player_names[4];
 924                 sprintf (turbomessage, "%s is turbo!",player_names[i]);
 925                 players[consoleplayer].message = turbomessage;
 926                 turbodetected[i] = false;
 927             }
 928
 929             if (netgame && !netdemo && !(gametic%ticdup) )
 930             {
 931                 if (gametic > BACKUPTICS
 932                     && consistancy[i][buf] != cmd->consistancy)
 933                 {
 934                     I_Error ("consistency failure (%i should be %i)",
 935                              cmd->consistancy, consistancy[i][buf]);
 936                 }
 937                 if (players[i].mo)
 938                     consistancy[i][buf] = players[i].mo->x;
 939                 else
 940                     consistancy[i][buf] = rndindex;
 941             }
 942         }
 943     }
 944
 945     // check for special buttons
 946     for (i=0 ; i<MAXPLAYERS ; i++)
 947     {
 948         if (playeringame[i])
 949         {
 950             if (players[i].cmd.buttons & BT_SPECIAL)
 951             {
 952                 switch (players[i].cmd.buttons & BT_SPECIALMASK)
 953                 {
 954                   case BTS_PAUSE:
 955                     paused ^= 1;
 956                     if (paused)
 957                         S_PauseSound ();
 958                     else
 959                         S_ResumeSound ();
 960                     break;
 961
 962                   case BTS_SAVEGAME:
 963                     if (!savedescription[0])
 964                         strcpy (savedescription, "NET GAME");
 965                     savegameslot =
 966                         (players[i].cmd.buttons & BTS_SAVEMASK)>>BTS_SAVESHIFT;
 967                     gameaction = ga_savegame;
 968                     break;
 969                 }
 970             }
 971         }
 972     }
 973
 974     // Have we just finished displaying an intermission screen?
 975
 976     if (oldgamestate == GS_INTERMISSION && gamestate != GS_INTERMISSION)
 977     {
 978         WI_End();
 979     }
 980
 981     oldgamestate = gamestate;
 982
 983     // do main actions
 984     switch (gamestate)
 985     {
 986       case GS_LEVEL:
 987         P_Ticker ();
 988         ST_Ticker ();
 989         AM_Ticker ();
 990         HU_Ticker ();
 991         break;
 992
 993       case GS_INTERMISSION:
 994         WI_Ticker ();
 995         break;
 996
 997       case GS_FINALE:
 998         F_Ticker ();
 999         break;
1000
1001       case GS_DEMOSCREEN:
1002         D_PageTicker ();
1003         break;
1004     }
1005 }
1006
1007
1008 //
1009 // PLAYER STRUCTURE FUNCTIONS
1010 // also see P_SpawnPlayer in P_Things
1011 //
1012
1013 //
1014 // G_InitPlayer
1015 // Called at the start.
1016 // Called by the game initialization functions.
1017 //
1018 void G_InitPlayer (int player)
1019 {
1020     player_t*   p;
1021
1022     // set up the saved info
1023     p = &players[player];
1024
1025     // clear everything else to defaults
1026     G_PlayerReborn (player);
1027
1028 }
1029
1030
1031
1032 //
1033 // G_PlayerFinishLevel
1034 // Can when a player completes a level.
1035 //
1036 void G_PlayerFinishLevel (int player)
1037 {
1038     player_t*   p;
1039
1040     p = &players[player];
1041
1042     memset (p->powers, 0, sizeof (p->powers));
1043     memset (p->cards, 0, sizeof (p->cards));
1044     p->mo->flags &= ~MF_SHADOW;         // cancel invisibility
1045     p->extralight = 0;                  // cancel gun flashes
1046     p->fixedcolormap = 0;               // cancel ir gogles
1047     p->damagecount = 0;                 // no palette changes
1048     p->bonuscount = 0;
1049 }
1050
1051
1052 //
1053 // G_PlayerReborn
1054 // Called after a player dies
1055 // almost everything is cleared and initialized
1056 //
1057 void G_PlayerReborn (int player)
1058 {
1059     player_t*   p;
1060     int         i;
1061     int         frags[MAXPLAYERS];
1062     int         killcount;
1063     int         itemcount;
1064     int         secretcount;
1065
1066     memcpy (frags,players[player].frags,sizeof(frags));
1067     killcount = players[player].killcount;
1068     itemcount = players[player].itemcount;
1069     secretcount = players[player].secretcount;
1070
1071     p = &players[player];
1072     memset (p, 0, sizeof(*p));
1073
1074     memcpy (players[player].frags, frags, sizeof(players[player].frags));
1075     players[player].killcount = killcount;
1076     players[player].itemcount = itemcount;
1077     players[player].secretcount = secretcount;
1078
1079     p->usedown = p->attackdown = true;  // don't do anything immediately
1080     p->playerstate = PST_LIVE;
1081     p->health = deh_initial_health;     // Use dehacked value
1082     p->readyweapon = p->pendingweapon = wp_pistol;
1083     p->weaponowned[wp_fist] = true;
1084     p->weaponowned[wp_pistol] = true;
1085     p->ammo[am_clip] = deh_initial_bullets;
1086
1087     for (i=0 ; i<NUMAMMO ; i++)
1088         p->maxammo[i] = maxammo[i];
1089
1090 }
1091
1092 //
1093 // G_CheckSpot
1094 // Returns false if the player cannot be respawned
1095 // at the given mapthing_t spot
1096 // because something is occupying it
1097 //
1098 void P_SpawnPlayer (mapthing_t* mthing);
1099
1100 boolean
1101 G_CheckSpot
1102 ( int           playernum,
1103   mapthing_t*   mthing )
1104 {
1105     fixed_t             x;
1106     fixed_t             y;
1107     subsector_t*        ss;
1108     unsigned            an;
1109     mobj_t*             mo;
1110     int                 i;
1111
1112     if (!players[playernum].mo)
1113     {
1114         // first spawn of level, before corpses
1115         for (i=0 ; i<playernum ; i++)
1116             if (players[i].mo->x == mthing->x << FRACBITS
1117                 && players[i].mo->y == mthing->y << FRACBITS)
1118                 return false;
1119         return true;
1120     }
1121
1122     x = mthing->x << FRACBITS;
1123     y = mthing->y << FRACBITS;
1124
1125     if (!P_CheckPosition (players[playernum].mo, x, y) )
1126         return false;
1127
1128     // flush an old corpse if needed
1129     if (bodyqueslot >= BODYQUESIZE)
1130         P_RemoveMobj (bodyque[bodyqueslot%BODYQUESIZE]);
1131     bodyque[bodyqueslot%BODYQUESIZE] = players[playernum].mo;
1132     bodyqueslot++;
1133
1134     // spawn a teleport fog
1135     ss = R_PointInSubsector (x,y);
1136     an = ( ANG45 * (((unsigned int) mthing->angle)/45) ) >> ANGLETOFINESHIFT;
1137
1138     mo = P_SpawnMobj (x+20*finecosine[an], y+20*finesine[an]
1139                       , ss->sector->floorheight
1140                       , MT_TFOG);
1141
1142     if (players[consoleplayer].viewz != 1)
1143         S_StartSound (mo, sfx_telept);  // don't start sound on first frame
1144
1145     return true;
1146 }
1147
1148
1149 //
1150 // G_DeathMatchSpawnPlayer
1151 // Spawns a player at one of the random death match spots
1152 // called at level load and each death
1153 //
1154 void G_DeathMatchSpawnPlayer (int playernum)
1155 {
1156     int             i,j;
1157     int                         selections;
1158
1159     selections = deathmatch_p - deathmatchstarts;
1160     if (selections < 4)
1161         I_Error ("Only %i deathmatch spots, 4 required", selections);
1162
1163     for (j=0 ; j<20 ; j++)
1164     {
1165         i = P_Random() % selections;
1166         if (G_CheckSpot (playernum, &deathmatchstarts[i]) )
1167         {
1168             deathmatchstarts[i].type = playernum+1;
1169             P_SpawnPlayer (&deathmatchstarts[i]);
1170             return;
1171         }
1172     }
1173
1174     // no good spot, so the player will probably get stuck
1175     P_SpawnPlayer (&playerstarts[playernum]);
1176 }
1177
1178 //
1179 // G_DoReborn
1180 //
1181 void G_DoReborn (int playernum)
1182 {
1183     int                             i;
1184
1185     if (!netgame)
1186     {
1187         // reload the level from scratch
1188         gameaction = ga_loadlevel;
1189     }
1190     else
1191     {
1192         // respawn at the start
1193
1194         // first dissasociate the corpse
1195         players[playernum].mo->player = NULL;
1196
1197         // spawn at random spot if in death match
1198         if (deathmatch)
1199         {
1200             G_DeathMatchSpawnPlayer (playernum);
1201             return;
1202         }
1203
1204         if (G_CheckSpot (playernum, &playerstarts[playernum]) )
1205         {
1206             P_SpawnPlayer (&playerstarts[playernum]);
1207             return;
1208         }
1209
1210         // try to spawn at one of the other players spots
1211         for (i=0 ; i<MAXPLAYERS ; i++)
1212         {
1213             if (G_CheckSpot (playernum, &playerstarts[i]) )
1214             {
1215                 playerstarts[i].type = playernum+1;     // fake as other player
1216                 P_SpawnPlayer (&playerstarts[i]);
1217                 playerstarts[i].type = i+1;             // restore
1218                 return;
1219             }
1220             // he's going to be inside something.  Too bad.
1221         }
1222         P_SpawnPlayer (&playerstarts[playernum]);
1223     }
1224 }
1225
1226
1227 void G_ScreenShot (void)
1228 {
1229     gameaction = ga_screenshot;
1230 }
1231
1232
1233
1234 // DOOM Par Times
1235 int pars[4][10] =
1236 {
1237     {0},
1238     {0,30,75,120,90,165,180,180,30,165},
1239     {0,90,90,90,120,90,360,240,30,170},
1240     {0,90,45,90,150,90,90,165,30,135}
1241 };
1242
1243 // DOOM II Par Times
1244 int cpars[32] =
1245 {
1246     30,90,120,120,90,150,120,120,270,90,        //  1-10
1247     210,150,150,150,210,150,420,150,210,150,    // 11-20
1248     240,150,180,150,150,300,330,420,300,180,    // 21-30
1249     120,30                                      // 31-32
1250 };
1251
1252
1253 //
1254 // G_DoCompleted
1255 //
1256 boolean         secretexit;
1257 extern char*    pagename;
1258
1259 void G_ExitLevel (void)
1260 {
1261     secretexit = false;
1262     gameaction = ga_completed;
1263 }
1264
1265 // Here's for the german edition.
1266 void G_SecretExitLevel (void)
1267 {
1268     // IF NO WOLF3D LEVELS, NO SECRET EXIT!
1269     if ( (gamemode == commercial)
1270       && (W_CheckNumForName("map31")<0))
1271         secretexit = false;
1272     else
1273         secretexit = true;
1274     gameaction = ga_completed;
1275 }
1276
1277 void G_DoCompleted (void)
1278 {
1279     int             i;
1280
1281     gameaction = ga_nothing;
1282
1283     for (i=0 ; i<MAXPLAYERS ; i++)
1284         if (playeringame[i])
1285             G_PlayerFinishLevel (i);        // take away cards and stuff
1286
1287     if (automapactive)
1288         AM_Stop ();
1289
1290     if (gamemode != commercial)
1291     {
1292         // Chex Quest ends after 5 levels, rather than 8.
1293
1294         if (gameversion == exe_chex)
1295         {
1296             if (gamemap == 5)
1297             {
1298                 gameaction = ga_victory;
1299                 return;
1300             }
1301         }
1302         else
1303         {
1304             switch(gamemap)
1305             {
1306               case 8:
1307                 gameaction = ga_victory;
1308                 return;
1309               case 9:
1310                 for (i=0 ; i<MAXPLAYERS ; i++)
1311                     players[i].didsecret = true;
1312                 break;
1313             }
1314         }
1315     }
1316
1317 //#if 0  Hmmm - why?
1318     if ( (gamemap == 8)
1319          && (gamemode != commercial) )
1320     {
1321         // victory
1322         gameaction = ga_victory;
1323         return;
1324     }
1325
1326     if ( (gamemap == 9)
1327          && (gamemode != commercial) )
1328     {
1329         // exit secret level
1330         for (i=0 ; i<MAXPLAYERS ; i++)
1331             players[i].didsecret = true;
1332     }
1333 //#endif
1334
1335
1336     wminfo.didsecret = players[consoleplayer].didsecret;
1337     wminfo.epsd = gameepisode -1;
1338     wminfo.last = gamemap -1;
1339
1340     // wminfo.next is 0 biased, unlike gamemap
1341     if ( gamemode == commercial)
1342     {
1343         if (secretexit)
1344             switch(gamemap)
1345             {
1346               case 15: wminfo.next = 30; break;
1347               case 31: wminfo.next = 31; break;
1348             }
1349         else
1350             switch(gamemap)
1351             {
1352               case 31:
1353               case 32: wminfo.next = 15; break;
1354               default: wminfo.next = gamemap;
1355             }
1356     }
1357     else
1358     {
1359         if (secretexit)
1360             wminfo.next = 8;    // go to secret level
1361         else if (gamemap == 9)
1362         {
1363             // returning from secret level
1364             switch (gameepisode)
1365             {
1366               case 1:
1367                 wminfo.next = 3;
1368                 break;
1369               case 2:
1370                 wminfo.next = 5;
1371                 break;
1372               case 3:
1373                 wminfo.next = 6;
1374                 break;
1375               case 4:
1376                 wminfo.next = 2;
1377                 break;
1378             }
1379         }
1380         else
1381             wminfo.next = gamemap;          // go to next level
1382     }
1383
1384     wminfo.maxkills = totalkills;
1385     wminfo.maxitems = totalitems;
1386     wminfo.maxsecret = totalsecret;
1387     wminfo.maxfrags = 0;
1388     if ( gamemode == commercial )
1389         wminfo.partime = TICRATE*cpars[gamemap-1];
1390     else
1391         wminfo.partime = TICRATE*pars[gameepisode][gamemap];
1392     wminfo.pnum = consoleplayer;
1393
1394     for (i=0 ; i<MAXPLAYERS ; i++)
1395     {
1396         wminfo.plyr[i].in = playeringame[i];
1397         wminfo.plyr[i].skills = players[i].killcount;
1398         wminfo.plyr[i].sitems = players[i].itemcount;
1399         wminfo.plyr[i].ssecret = players[i].secretcount;
1400         wminfo.plyr[i].stime = leveltime;
1401         memcpy (wminfo.plyr[i].frags, players[i].frags
1402                 , sizeof(wminfo.plyr[i].frags));
1403     }
1404
1405     gamestate = GS_INTERMISSION;
1406     viewactive = false;
1407     automapactive = false;
1408
1409     WI_Start (&wminfo);
1410 }
1411
1412
1413 //
1414 // G_WorldDone
1415 //
1416 void G_WorldDone (void)
1417 {
1418     gameaction = ga_worlddone;
1419
1420     if (secretexit)
1421         players[consoleplayer].didsecret = true;
1422
1423     if ( gamemode == commercial )
1424     {
1425         switch (gamemap)
1426         {
1427           case 15:
1428           case 31:
1429             if (!secretexit)
1430                 break;
1431           case 6:
1432           case 11:
1433           case 20:
1434           case 30:
1435             F_StartFinale ();
1436             break;
1437         }
1438     }
1439 }
1440
1441 void G_DoWorldDone (void)
1442 {
1443     gamestate = GS_LEVEL;
1444     gamemap = wminfo.next+1;
1445     G_DoLoadLevel ();
1446     gameaction = ga_nothing;
1447     viewactive = true;
1448 }
1449
1450
1451
1452 //
1453 // G_InitFromSavegame
1454 // Can be called by the startup code or the menu task.
1455 //
1456 extern boolean setsizeneeded;
1457 void R_ExecuteSetViewSize (void);
1458
1459 char    savename[256];
1460
1461 void G_LoadGame (char* name)
1462 {
1463     strcpy (savename, name);
1464     gameaction = ga_loadgame;
1465 }
1466
1467 #define VERSIONSIZE             16
1468
1469
1470 void G_DoLoadGame (void)
1471 {
1472     int savedleveltime;
1473
1474     gameaction = ga_nothing;
1475
1476     save_stream = fopen(savename, "rb");
1477
1478     if (save_stream == NULL)
1479     {
1480         return;
1481     }
1482
1483     if (!P_ReadSaveGameHeader())
1484     {
1485         fclose(save_stream);
1486         return;
1487     }
1488
1489     savedleveltime = leveltime;
1490
1491     // load a base level
1492     G_InitNew (gameskill, gameepisode, gamemap);
1493
1494     leveltime = savedleveltime;
1495
1496     // dearchive all the modifications
1497     P_UnArchivePlayers ();
1498     P_UnArchiveWorld ();
1499     P_UnArchiveThinkers ();
1500     P_UnArchiveSpecials ();
1501
1502     if (!P_ReadSaveGameEOF())
1503         I_Error ("Bad savegame");
1504
1505     fclose(save_stream);
1506
1507     if (setsizeneeded)
1508         R_ExecuteSetViewSize ();
1509
1510     // draw the pattern into the back screen
1511     R_FillBackScreen ();
1512 }
1513
1514
1515 //
1516 // G_SaveGame
1517 // Called by the menu task.
1518 // Description is a 24 byte text string
1519 //
1520 void
1521 G_SaveGame
1522 ( int   slot,
1523   char* description )
1524 {
1525     savegameslot = slot;
1526     strcpy (savedescription, description);
1527     sendsave = true;
1528 }
1529
1530 void G_DoSaveGame (void)
1531 {
1532     char *savegame_file;
1533     char *temp_savegame_file;
1534
1535     temp_savegame_file = P_TempSaveGameFile();
1536     savegame_file = P_SaveGameFile(savegameslot);
1537
1538     // Open the savegame file for writing.  We write to a temporary file
1539     // and then rename it at the end if it was successfully written.
1540     // This prevents an existing savegame from being overwritten by
1541     // a corrupted one, or if a savegame buffer overrun occurs.
1542
1543     save_stream = fopen(temp_savegame_file, "wb");
1544
1545     if (save_stream == NULL)
1546     {
1547         return;
1548     }
1549
1550     P_WriteSaveGameHeader(savedescription);
1551
1552     P_ArchivePlayers ();
1553     P_ArchiveWorld ();
1554     P_ArchiveThinkers ();
1555     P_ArchiveSpecials ();
1556
1557     P_WriteSaveGameEOF();
1558
1559     // Enforce the same savegame size limit as in Vanilla Doom,
1560     // except if the vanilla_savegame_limit setting is turned off.
1561
1562     if (vanilla_savegame_limit && ftell(save_stream) > SAVEGAMESIZE)
1563     {
1564         I_Error ("Savegame buffer overrun");
1565     }
1566
1567     // Finish up, close the savegame file.
1568
1569     fclose(save_stream);
1570
1571     // Now rename the temporary savegame file to the actual savegame
1572     // file, overwriting the old savegame if there was one there.
1573
1574     remove(savegame_file);
1575     rename(temp_savegame_file, savegame_file);
1576
1577     gameaction = ga_nothing;
1578     strcpy(savedescription, "");
1579
1580     players[consoleplayer].message = DEH_String(GGSAVED);
1581
1582     // draw the pattern into the back screen
1583     R_FillBackScreen ();
1584 }
1585
1586
1587 //
1588 // G_InitNew
1589 // Can be called by the startup code or the menu task,
1590 // consoleplayer, displayplayer, playeringame[] should be set.
1591 //
1592 skill_t d_skill;
1593 int     d_episode;
1594 int     d_map;
1595
1596 void
1597 G_DeferedInitNew
1598 ( skill_t       skill,
1599   int           episode,
1600   int           map)
1601 {
1602     d_skill = skill;
1603     d_episode = episode;
1604     d_map = map;
1605     gameaction = ga_newgame;
1606 }
1607
1608
1609 void G_DoNewGame (void)
1610 {
1611     demoplayback = false;
1612     netdemo = false;
1613     netgame = false;
1614     deathmatch = false;
1615     playeringame[1] = playeringame[2] = playeringame[3] = 0;
1616     respawnparm = false;
1617     fastparm = false;
1618     nomonsters = false;
1619     consoleplayer = 0;
1620     G_InitNew (d_skill, d_episode, d_map);
1621     gameaction = ga_nothing;
1622 }
1623
1624 // The sky texture to be used instead of the F_SKY1 dummy.
1625 extern  int     skytexture;
1626
1627
1628 void
1629 G_InitNew
1630 ( skill_t       skill,
1631   int           episode,
1632   int           map )
1633 {
1634     char *skytexturename;
1635     int             i;
1636
1637     if (paused)
1638     {
1639         paused = false;
1640         S_ResumeSound ();
1641     }
1642
1643
1644     if (skill > sk_nightmare)
1645         skill = sk_nightmare;
1646
1647
1648     // This was quite messy with SPECIAL and commented parts.
1649     // Supposedly hacks to make the latest edition work.
1650     // It might not work properly.
1651     if (episode < 1)
1652       episode = 1;
1653
1654     if ( gamemode == retail )
1655     {
1656       if (episode > 4)
1657         episode = 4;
1658     }
1659     else if ( gamemode == shareware )
1660     {
1661       if (episode > 1)
1662            episode = 1; // only start episode 1 on shareware
1663     }
1664     else
1665     {
1666       if (episode > 3)
1667         episode = 3;
1668     }
1669
1670
1671
1672     if (map < 1)
1673         map = 1;
1674
1675     if ( (map > 9)
1676          && ( gamemode != commercial) )
1677       map = 9;
1678
1679     M_ClearRandom ();
1680
1681     if (skill == sk_nightmare || respawnparm )
1682         respawnmonsters = true;
1683     else
1684         respawnmonsters = false;
1685
1686     if (fastparm || (skill == sk_nightmare && gameskill != sk_nightmare) )
1687     {
1688         for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++)
1689             states[i].tics >>= 1;
1690         mobjinfo[MT_BRUISERSHOT].speed = 20*FRACUNIT;
1691         mobjinfo[MT_HEADSHOT].speed = 20*FRACUNIT;
1692         mobjinfo[MT_TROOPSHOT].speed = 20*FRACUNIT;
1693     }
1694     else if (skill != sk_nightmare && gameskill == sk_nightmare)
1695     {
1696         for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++)
1697             states[i].tics <<= 1;
1698         mobjinfo[MT_BRUISERSHOT].speed = 15*FRACUNIT;
1699         mobjinfo[MT_HEADSHOT].speed = 10*FRACUNIT;
1700         mobjinfo[MT_TROOPSHOT].speed = 10*FRACUNIT;
1701     }
1702
1703
1704     // force players to be initialized upon first level load
1705     for (i=0 ; i<MAXPLAYERS ; i++)
1706         players[i].playerstate = PST_REBORN;
1707
1708     usergame = true;                // will be set false if a demo
1709     paused = false;
1710     demoplayback = false;
1711     automapactive = false;
1712     viewactive = true;
1713     gameepisode = episode;
1714     gamemap = map;
1715     gameskill = skill;
1716
1717     viewactive = true;
1718
1719     // Set the sky to use.
1720     //
1721     // Note: This IS broken, but it is how Vanilla Doom behaves.
1722     // See http://doom.wikia.com/wiki/Sky_never_changes_in_Doom_II.
1723     //
1724     // Because we set the sky here at the start of a game, not at the
1725     // start of a level, the sky texture never changes unless we
1726     // restore from a saved game.  This was fixed before the Doom
1727     // source release, but this IS the way Vanilla DOS Doom behaves.
1728
1729     if (gamemode == commercial)
1730     {
1731         if (gamemap < 12)
1732             skytexturename = "SKY1";
1733         else if (gamemap < 21)
1734             skytexturename = "SKY2";
1735         else
1736             skytexturename = "SKY3";
1737     }
1738     else
1739     {
1740         switch (gameepisode)
1741         {
1742           default:
1743           case 1:
1744             skytexturename = "SKY1";
1745             break;
1746           case 2:
1747             skytexturename = "SKY2";
1748             break;
1749           case 3:
1750             skytexturename = "SKY3";
1751             break;
1752           case 4:        // Special Edition sky
1753             skytexturename = "SKY4";
1754             break;
1755         }
1756     }
1757
1758     skytexturename = DEH_String(skytexturename);
1759
1760     skytexture = R_TextureNumForName(skytexturename);
1761
1762
1763     G_DoLoadLevel ();
1764 }
1765
1766
1767 //
1768 // DEMO RECORDING
1769 //
1770 #define DEMOMARKER              0x80
1771
1772
1773 void G_ReadDemoTiccmd (ticcmd_t* cmd)
1774 {
1775     if (*demo_p == DEMOMARKER)
1776     {
1777         // end of demo data stream
1778         G_CheckDemoStatus ();
1779         return;
1780     }
1781     cmd->forwardmove = ((signed char)*demo_p++);
1782     cmd->sidemove = ((signed char)*demo_p++);
1783
1784     // If this is a longtics demo, read back in higher resolution
1785
1786     if (longtics)
1787     {
1788         cmd->angleturn = *demo_p++;
1789         cmd->angleturn |= (*demo_p++) << 8;
1790     }
1791     else
1792     {
1793         cmd->angleturn = ((unsigned char) *demo_p++)<<8;
1794     }
1795
1796     cmd->buttons = (unsigned char)*demo_p++;
1797 }
1798
1799 // Increase the size of the demo buffer to allow unlimited demos
1800
1801 static void IncreaseDemoBuffer(void)
1802 {
1803     int current_length;
1804     byte *new_demobuffer;
1805     byte *new_demop;
1806     int new_length;
1807
1808     // Find the current size
1809
1810     current_length = demoend - demobuffer;
1811
1812     // Generate a new buffer twice the size
1813     new_length = current_length * 2;
1814
1815     new_demobuffer = Z_Malloc(new_length, PU_STATIC, 0);
1816     new_demop = new_demobuffer + (demo_p - demobuffer);
1817
1818     // Copy over the old data
1819
1820     memcpy(new_demobuffer, demobuffer, current_length);
1821
1822     // Free the old buffer and point the demo pointers at the new buffer.
1823
1824     Z_Free(demobuffer);
1825
1826     demobuffer = new_demobuffer;
1827     demo_p = new_demop;
1828     demoend = demobuffer + new_length;
1829 }
1830
1831 void G_WriteDemoTiccmd (ticcmd_t* cmd)
1832 {
1833     byte *demo_start;
1834
1835     if (gamekeydown['q'])           // press q to end demo recording
1836         G_CheckDemoStatus ();
1837
1838     demo_start = demo_p;
1839
1840     *demo_p++ = cmd->forwardmove;
1841     *demo_p++ = cmd->sidemove;
1842
1843     // If this is a longtics demo, record in higher resolution
1844
1845     if (longtics)
1846     {
1847         *demo_p++ = (cmd->angleturn & 0xff);
1848         *demo_p++ = (cmd->angleturn >> 8) & 0xff;
1849     }
1850     else
1851     {
1852         *demo_p++ = cmd->angleturn >> 8;
1853     }
1854
1855     *demo_p++ = cmd->buttons;
1856
1857     // reset demo pointer back
1858     demo_p = demo_start;
1859
1860     if (demo_p > demoend - 16)
1861     {
1862         if (vanilla_demo_limit)
1863         {
1864             // no more space
1865             G_CheckDemoStatus ();
1866             return;
1867         }
1868         else
1869         {
1870             // Vanilla demo limit disabled: unlimited
1871             // demo lengths!
1872
1873             IncreaseDemoBuffer();
1874         }
1875     }
1876
1877     G_ReadDemoTiccmd (cmd);         // make SURE it is exactly the same
1878 }
1879
1880
1881
1882 //
1883 // G_RecordDemo
1884 //
1885 void G_RecordDemo (char* name)
1886 {
1887     int             i;
1888     int                         maxsize;
1889
1890     usergame = false;
1891     strcpy (demoname, name);
1892     strcat (demoname, ".lmp");
1893     maxsize = 0x20000;
1894
1895     //!
1896     // @arg <size>
1897     // @category demo
1898     // @vanilla
1899     //
1900     // Specify the demo buffer size (KiB)
1901     //
1902
1903     i = M_CheckParm ("-maxdemo");
1904     if (i && i<myargc-1)
1905         maxsize = atoi(myargv[i+1])*1024;
1906     demobuffer = Z_Malloc (maxsize,PU_STATIC,NULL);
1907     demoend = demobuffer + maxsize;
1908
1909     demorecording = true;
1910 }
1911
1912
1913 void G_BeginRecording (void)
1914 {
1915     int             i;
1916
1917     //!
1918     // @category demo
1919     //
1920     // Record a high resolution "Doom 1.91" demo.
1921     //
1922
1923     longtics = M_CheckParm("-longtics") != 0;
1924
1925     // If not recording a longtics demo, record in low res
1926
1927     lowres_turn = !longtics;
1928
1929     demo_p = demobuffer;
1930
1931     // Save the right version code for this demo
1932
1933     if (longtics)
1934     {
1935         *demo_p++ = DOOM_191_VERSION;
1936     }
1937     else
1938     {
1939         *demo_p++ = DOOM_VERSION;
1940     }
1941
1942     *demo_p++ = gameskill;
1943     *demo_p++ = gameepisode;
1944     *demo_p++ = gamemap;
1945     *demo_p++ = deathmatch;
1946     *demo_p++ = respawnparm;
1947     *demo_p++ = fastparm;
1948     *demo_p++ = nomonsters;
1949     *demo_p++ = consoleplayer;
1950
1951     for (i=0 ; i<MAXPLAYERS ; i++)
1952         *demo_p++ = playeringame[i];
1953 }
1954
1955
1956 //
1957 // G_PlayDemo
1958 //
1959
1960 char*   defdemoname;
1961
1962 void G_DeferedPlayDemo (char* name)
1963 {
1964     defdemoname = name;
1965     gameaction = ga_playdemo;
1966 }
1967
1968 // Generate a string describing a demo version
1969
1970 static char *DemoVersionDescription(int version)
1971 {
1972     static char resultbuf[16];
1973
1974     switch (version)
1975     {
1976         case 104:
1977             return "v1.4";
1978         case 105:
1979             return "v1.5";
1980         case 106:
1981             return "v1.6/v1.666";
1982         case 107:
1983             return "v1.7/v1.7a";
1984         case 108:
1985             return "v1.8";
1986         case 109:
1987             return "v1.9";
1988         default:
1989             break;
1990     }
1991
1992     // Unknown version.  Perhaps this is a pre-v1.4 IWAD?  If the version
1993     // byte is in the range 0-4 then it can be a v1.0-v1.2 demo.
1994
1995     if (version >= 0 && version <= 4)
1996     {
1997         return "v1.0/v1.1/v1.2";
1998     }
1999     else
2000     {
2001         sprintf(resultbuf, "%i.%i (unknown)", version / 100, version % 100);
2002         return resultbuf;
2003     }
2004 }
2005
2006 void G_DoPlayDemo (void)
2007 {
2008     skill_t skill;
2009     int             i, episode, map;
2010     int demoversion;
2011
2012     gameaction = ga_nothing;
2013     demobuffer = demo_p = W_CacheLumpName (defdemoname, PU_STATIC);
2014
2015     demoversion = *demo_p++;
2016
2017     if (demoversion == DOOM_VERSION)
2018     {
2019         longtics = false;
2020     }
2021     else if (demoversion == DOOM_191_VERSION)
2022     {
2023         // demo recorded with cph's modified "v1.91" doom exe
2024         longtics = true;
2025     }
2026     else
2027     {
2028         char *message = "Demo is from a different game version!\n"
2029                         "(read %i, should be %i)\n"
2030                         "\n"
2031                         "*** You may need to upgrade your version "
2032                             "of Doom to v1.9. ***\n"
2033                         "    See: http://doomworld.com/files/patches.shtml\n"
2034                         "    This appears to be %s.";
2035
2036         I_Error(message, demoversion, DOOM_VERSION,
2037                          DemoVersionDescription(demoversion));
2038     }
2039
2040     skill = *demo_p++;
2041     episode = *demo_p++;
2042     map = *demo_p++;
2043     deathmatch = *demo_p++;
2044     respawnparm = *demo_p++;
2045     fastparm = *demo_p++;
2046     nomonsters = *demo_p++;
2047     consoleplayer = *demo_p++;
2048
2049     for (i=0 ; i<MAXPLAYERS ; i++)
2050         playeringame[i] = *demo_p++;
2051
2052     //!
2053     // @category demo
2054     //
2055     // Play back a demo recorded in a netgame with a single player.
2056     //
2057
2058     if (playeringame[1] || M_CheckParm("-netdemo") > 0)
2059     {
2060         netgame = true;
2061         netdemo = true;
2062     }
2063
2064     // don't spend a lot of time in loadlevel
2065     precache = false;
2066     G_InitNew (skill, episode, map);
2067     precache = true;
2068     starttime = I_GetTime ();
2069
2070     usergame = false;
2071     demoplayback = true;
2072 }
2073
2074 //
2075 // G_TimeDemo
2076 //
2077 void G_TimeDemo (char* name)
2078 {
2079     //!
2080     // @vanilla
2081     //
2082     // Disable rendering the screen entirely.
2083     //
2084
2085     nodrawers = M_CheckParm ("-nodraw");
2086
2087     //!
2088     // @vanilla
2089     //
2090     // Disable blitting the screen.
2091     //
2092
2093     noblit = M_CheckParm ("-noblit");
2094     timingdemo = true;
2095     singletics = true;
2096
2097     defdemoname = name;
2098     gameaction = ga_playdemo;
2099 }
2100
2101
2102 /*
2103 ===================
2104 =
2105 = G_CheckDemoStatus
2106 =
2107 = Called after a death or level completion to allow demos to be cleaned up
2108 = Returns true if a new demo loop action will take place
2109 ===================
2110 */
2111
2112 boolean G_CheckDemoStatus (void)
2113 {
2114     int             endtime;
2115
2116     if (timingdemo)
2117     {
2118         float fps;
2119         int realtics;
2120
2121         endtime = I_GetTime ();
2122         realtics = endtime - starttime;
2123         fps = ((float) gametic * TICRATE) / realtics;
2124
2125         // Prevent recursive calls
2126         timingdemo = false;
2127         demoplayback = false;
2128
2129         I_Error ("timed %i gametics in %i realtics (%f fps)",
2130                  gametic, realtics, fps);
2131     }
2132
2133     if (demoplayback)
2134     {
2135         W_ReleaseLumpName(defdemoname);
2136         demoplayback = false;
2137         netdemo = false;
2138         netgame = false;
2139         deathmatch = false;
2140         playeringame[1] = playeringame[2] = playeringame[3] = 0;
2141         respawnparm = false;
2142         fastparm = false;
2143         nomonsters = false;
2144         consoleplayer = 0;
2145
2146         if (singledemo)
2147             I_Quit ();
2148         else
2149             D_AdvanceDemo ();
2150
2151         return true;
2152     }
2153
2154     if (demorecording)
2155     {
2156         *demo_p++ = DEMOMARKER;
2157         M_WriteFile (demoname, demobuffer, demo_p - demobuffer);
2158         Z_Free (demobuffer);
2159         demorecording = false;
2160         I_Error ("Demo %s recorded",demoname);
2161     }
2162
2163     return false;
2164 }
2165
2166
2167