home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 28 / amigaformatcd28.iso / -screenplay- / otherstuff / adoomppc_src / g_game.c < prev    next >
C/C++ Source or Header  |  1998-04-23  |  42KB  |  1,695 lines
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:  none
  20. //
  21. //-----------------------------------------------------------------------------
  22.  
  23.  
  24. static const char
  25. rcsid[] = "$Id: g_game.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";
  26.  
  27. #include <string.h>
  28. #include <stdlib.h>
  29.  
  30. #include "doomdef.h" 
  31. #include "doomstat.h"
  32.  
  33. #include "z_zone.h"
  34. #include "f_finale.h"
  35. #include "m_argv.h"
  36. #include "m_misc.h"
  37. #include "m_menu.h"
  38. #include "m_random.h"
  39. #include "i_system.h"
  40.  
  41. #include "p_setup.h"
  42. #include "p_saveg.h"
  43. #include "p_tick.h"
  44.  
  45. #include "d_main.h"
  46.  
  47. #include "wi_stuff.h"
  48. #include "hu_stuff.h"
  49. #include "st_stuff.h"
  50. #include "am_map.h"
  51.  
  52. // Needs access to LFB.
  53. #include "v_video.h"
  54.  
  55. #include "w_wad.h"
  56.  
  57. #include "p_local.h" 
  58.  
  59. #include "s_sound.h"
  60.  
  61. // Data.
  62. #include "dstrings.h"
  63. #include "sounds.h"
  64.  
  65. // SKY handling - still the wrong place.
  66. #include "r_data.h"
  67. #include "r_sky.h"
  68.  
  69.  
  70.  
  71. #include "g_game.h"
  72.  
  73.  
  74. //#define SAVEGAMESIZE  0x2c000
  75. #define SAVEGAMESIZE    0x50000
  76. #define SAVESTRINGSIZE  24
  77.  
  78.  
  79.  
  80. boolean G_CheckDemoStatus (void); 
  81. void    G_ReadDemoTiccmd (ticcmd_t* cmd); 
  82. void    G_WriteDemoTiccmd (ticcmd_t* cmd); 
  83. void    G_PlayerReborn (int player); 
  84. void    G_InitNew (skill_t skill, int episode, int map); 
  85.  
  86. void    G_DoReborn (int playernum); 
  87.  
  88. void    G_DoLoadLevel (void); 
  89. void    G_DoNewGame (void); 
  90. void    G_DoLoadGame (void); 
  91. void    G_DoPlayDemo (void); 
  92. void    G_DoCompleted (void); 
  93. void    G_DoVictory (void); 
  94. void    G_DoWorldDone (void); 
  95. void    G_DoSaveGame (void); 
  96.  
  97.  
  98. gameaction_t    gameaction; 
  99. gamestate_t     gamestate; 
  100. skill_t         gameskill; 
  101. boolean         respawnmonsters;
  102. int             gameepisode; 
  103. int             gamemap; 
  104.  
  105. boolean         paused; 
  106. boolean         sendpause;              // send a pause event next tic 
  107. boolean         sendsave;               // send a save event next tic 
  108. boolean         usergame;               // ok to save / end game 
  109.  
  110. boolean         timingdemo;             // if true, exit with report on completion 
  111. boolean         nodrawers;              // for comparative timing purposes 
  112. boolean         noblit;                 // for comparative timing purposes 
  113. int             starttime;              // for comparative timing purposes       
  114.  
  115. boolean         viewactive; 
  116.  
  117. boolean         deathmatch;             // only if started as net death 
  118. boolean         netgame;                // only true if packets are broadcast 
  119. boolean         playeringame[MAXPLAYERS]; 
  120. player_t        players[MAXPLAYERS]; 
  121.  
  122. int             consoleplayer;          // player taking events and displaying 
  123. int             displayplayer;          // view being displayed 
  124. int             gametic; 
  125. int             levelstarttic;          // gametic at level start 
  126. int             totalkills, totalitems, totalsecret;    // for intermission 
  127.  
  128. char            demoname[32]; 
  129. boolean         demorecording; 
  130. boolean         demoplayback; 
  131. boolean         netdemo; 
  132. byte*           demobuffer;
  133. byte*           demo_p;
  134. byte*           demoend; 
  135. boolean         singledemo;             // quit after playing a demo from cmdline 
  136.  
  137. boolean         precache = true;        // if true, load all graphics at start 
  138.  
  139. wbstartstruct_t wminfo;                 // parms for world map / intermission 
  140.  
  141. short           consistancy[MAXPLAYERS][BACKUPTICS]; 
  142.  
  143. byte*           savebuffer;
  144.  
  145. // Dehacked
  146. int initial_health=100;
  147. int initial_bullets=50;
  148.  
  149. // 
  150. // controls (have defaults) 
  151. // 
  152. int             key_right;
  153. int             key_left;
  154.  
  155. int             key_up;
  156. int             key_down; 
  157. int             key_strafeleft;
  158. int             key_straferight; 
  159. int             key_fire;
  160. int             key_use;
  161. int             key_strafe;
  162. int             key_speed; 
  163.  
  164. int             mousebfire; 
  165. int             mousebstrafe; 
  166. int             mousebforward; 
  167.  
  168. int             joybfire; 
  169. int             joybstrafe; 
  170. int             joybuse; 
  171. int             joybspeed; 
  172.  
  173.  
  174.  
  175. #define MAXPLMOVE               (forwardmove[1]) 
  176.  
  177. #define TURBOTHRESHOLD  0x32
  178.  
  179. fixed_t         forwardmove[2] = {0x19, 0x32}; 
  180. fixed_t         sidemove[2] = {0x18, 0x28}; 
  181. fixed_t         angleturn[3] = {640, 1280, 320};        // + slow turn 
  182.  
  183. #define SLOWTURNTICS    6 
  184.  
  185. #define NUMKEYS         256 
  186.  
  187. boolean         gamekeydown[NUMKEYS]; 
  188. int             turnheld;                               // for accelerative turning 
  189.  
  190. boolean         mousearray[4]; 
  191. boolean*        mousebuttons = &mousearray[1];          // allow [-1]
  192.  
  193. // mouse values are used once 
  194. int             mousex;
  195. int             mousey;         
  196.  
  197. int             dclicktime;
  198. int             dclickstate;
  199. int             dclicks; 
  200. int             dclicktime2;
  201. int             dclickstate2;
  202. int             dclicks2;
  203.  
  204. // joystick values are repeated 
  205. int             joyxmove;
  206. int             joyymove;
  207. boolean         joyarray[5]; 
  208. boolean*        joybuttons = &joyarray[1];              // allow [-1] 
  209.  
  210. int             savegameslot; 
  211. char            savedescription[32]; 
  212.  
  213.  
  214. #define BODYQUESIZE     32
  215.  
  216. mobj_t*         bodyque[BODYQUESIZE]; 
  217. int             bodyqueslot; 
  218.  
  219. void*           statcopy;                               // for statistics driver
  220.  
  221.  
  222.  
  223. int G_CmdChecksum (ticcmd_t* cmd) 
  224. { 
  225.     int         i;
  226.     int         sum = 0; 
  227.          
  228.     for (i=0 ; i< sizeof(*cmd)/4 - 1 ; i++) 
  229.         sum += ((int *)cmd)[i]; 
  230.                  
  231.     return sum; 
  232. } 
  233.  
  234.  
  235. //
  236. // G_BuildTiccmd
  237. // Builds a ticcmd from all of the available inputs
  238. // or reads it from the demo buffer. 
  239. // If recording a demo, write it out 
  240. // 
  241. void G_BuildTiccmd (ticcmd_t* cmd) 
  242. { 
  243.     int         i; 
  244.     boolean     strafe;
  245.     boolean     bstrafe; 
  246.     int         speed;
  247.     int         tspeed; 
  248.     int         forward;
  249.     int         side;
  250.     
  251.     ticcmd_t*   base;
  252.  
  253.     base = I_BaseTiccmd ();             // empty, or external driver
  254.     memcpy (cmd,base,sizeof(*cmd)); 
  255.         
  256.     cmd->consistancy = 
  257.         consistancy[consoleplayer][maketic%BACKUPTICS]; 
  258.  
  259.  
  260.     strafe = gamekeydown[key_strafe] || mousebuttons[mousebstrafe] 
  261.         || joybuttons[joybstrafe]; 
  262.     speed = gamekeydown[key_speed] || joybuttons[joybspeed];
  263.  
  264.     forward = side = 0;
  265.     
  266.     // use two stage accelerative turning
  267.     // on the keyboard and joystick
  268.     if (joyxmove < 0
  269.         || joyxmove > 0  
  270.         || gamekeydown[key_right]
  271.         || gamekeydown[key_left]) 
  272.         turnheld += ticdup; 
  273.     else 
  274.         turnheld = 0; 
  275.  
  276.     if (turnheld < SLOWTURNTICS) 
  277.         tspeed = 2;             // slow turn 
  278.     else 
  279.         tspeed = speed;
  280.     
  281.     // let movement keys cancel each other out
  282.     if (strafe) 
  283.     { 
  284.         if (gamekeydown[key_right]) 
  285.         {
  286.             // fprintf(stderr, "strafe right\n");
  287.             side += sidemove[speed]; 
  288.         }
  289.         if (gamekeydown[key_left]) 
  290.         {
  291.             //  fprintf(stderr, "strafe left\n");
  292.             side -= sidemove[speed]; 
  293.         }
  294.         if (joyxmove > 0) 
  295.             side += sidemove[speed]; 
  296.         if (joyxmove < 0) 
  297.             side -= sidemove[speed]; 
  298.  
  299.     } 
  300.     else 
  301.     { 
  302.         if (gamekeydown[key_right]) 
  303.             cmd->angleturn -= angleturn[tspeed]; 
  304.         if (gamekeydown[key_left]) 
  305.             cmd->angleturn += angleturn[tspeed]; 
  306.         if (joyxmove > 0) 
  307.             cmd->angleturn -= angleturn[tspeed]; 
  308.         if (joyxmove < 0) 
  309.             cmd->angleturn += angleturn[tspeed]; 
  310.     } 
  311.  
  312.     if (gamekeydown[key_up]) 
  313.     {
  314.         // fprintf(stderr, "up\n");
  315.         forward += forwardmove[speed]; 
  316.     }
  317.     if (gamekeydown[key_down]) 
  318.     {
  319.         // fprintf(stderr, "down\n");
  320.         forward -= forwardmove[speed]; 
  321.     }
  322.     if (joyymove < 0) 
  323.         forward += forwardmove[speed]; 
  324.     if (joyymove > 0) 
  325.         forward -= forwardmove[speed]; 
  326.     if (gamekeydown[key_straferight]) 
  327.         side += sidemove[speed]; 
  328.     if (gamekeydown[key_strafeleft]) 
  329.         side -= sidemove[speed];
  330.     
  331.     // buttons
  332.     cmd->chatchar = HU_dequeueChatChar(); 
  333.  
  334.     if (gamekeydown[key_fire] || mousebuttons[mousebfire] 
  335.         || joybuttons[joybfire]) 
  336.         cmd->buttons |= BT_ATTACK; 
  337.  
  338.     if (gamekeydown[key_use] || joybuttons[joybuse] ) 
  339.     { 
  340.         cmd->buttons |= BT_USE;
  341.         // clear double clicks if hit use button 
  342.         dclicks = 0;                   
  343.     } 
  344.  
  345.     // chainsaw overrides 
  346.     for (i=0 ; i<NUMWEAPONS-1 ; i++)        
  347.         if (gamekeydown['1'+i]) 
  348.         { 
  349.             cmd->buttons |= BT_CHANGE; 
  350.             cmd->buttons |= i<<BT_WEAPONSHIFT; 
  351.             break; 
  352.         }
  353.     
  354.     // mouse
  355.     if (mousebuttons[mousebforward]) 
  356.         forward += forwardmove[speed];
  357.     
  358.     // forward double click
  359.     if (mousebuttons[mousebforward] != dclickstate && dclicktime > 1 ) 
  360.     { 
  361.         dclickstate = mousebuttons[mousebforward]; 
  362.         if (dclickstate) 
  363.             dclicks++; 
  364.         if (dclicks == 2) 
  365.         { 
  366.             cmd->buttons |= BT_USE; 
  367.             dclicks = 0; 
  368.         } 
  369.         else 
  370.             dclicktime = 0; 
  371.     } 
  372.     else 
  373.     { 
  374.         dclicktime += ticdup; 
  375.         if (dclicktime > 20) 
  376.         { 
  377.             dclicks = 0; 
  378.             dclickstate = 0; 
  379.         } 
  380.     }
  381.     
  382.     // strafe double click
  383.     bstrafe =
  384.         mousebuttons[mousebstrafe] 
  385.         || joybuttons[joybstrafe]; 
  386.     if (bstrafe != dclickstate2 && dclicktime2 > 1 ) 
  387.     { 
  388.         dclickstate2 = bstrafe; 
  389.         if (dclickstate2) 
  390.             dclicks2++; 
  391.         if (dclicks2 == 2) 
  392.         { 
  393.             cmd->buttons |= BT_USE; 
  394.             dclicks2 = 0; 
  395.         } 
  396.         else 
  397.             dclicktime2 = 0; 
  398.     } 
  399.     else 
  400.     { 
  401.         dclicktime2 += ticdup; 
  402.         if (dclicktime2 > 20) 
  403.         { 
  404.             dclicks2 = 0; 
  405.             dclickstate2 = 0; 
  406.         } 
  407.     } 
  408.  
  409.     forward += mousey; 
  410.     if (strafe) 
  411.         side += mousex*2; 
  412.     else 
  413.         cmd->angleturn -= mousex*0x8; 
  414.  
  415.     mousex = mousey = 0; 
  416.          
  417.     if (forward > MAXPLMOVE) 
  418.         forward = MAXPLMOVE; 
  419.     else if (forward < -MAXPLMOVE) 
  420.         forward = -MAXPLMOVE; 
  421.     if (side > MAXPLMOVE) 
  422.         side = MAXPLMOVE; 
  423.     else if (side < -MAXPLMOVE) 
  424.         side = -MAXPLMOVE; 
  425.  
  426.     cmd->forwardmove += forward; 
  427.     cmd->sidemove += side;
  428.     
  429.     // special buttons
  430.     if (sendpause) 
  431.     { 
  432.         sendpause = false; 
  433.         cmd->buttons = BT_SPECIAL | BTS_PAUSE; 
  434.     } 
  435.  
  436.     if (sendsave) 
  437.     { 
  438.         sendsave = false; 
  439.         cmd->buttons = BT_SPECIAL | BTS_SAVEGAME | (savegameslot<<BTS_SAVESHIFT); 
  440.     } 
  441. } 
  442.  
  443.  
  444. //
  445. // G_DoLoadLevel 
  446. //
  447. extern  gamestate_t     wipegamestate; 
  448.  
  449. void G_DoLoadLevel (void) 
  450. { 
  451.     int             i; 
  452.  
  453.     // Set the sky map.
  454.     // First thing, we have a dummy sky texture name,
  455.     //  a flat. The data is in the WAD only because
  456.     //  we look for an actual index, instead of simply
  457.     //  setting one.
  458.     skyflatnum = R_FlatNumForName ( SKYFLATNAME );
  459.  
  460.     // DOOM determines the sky texture to be used
  461.     // depending on the current episode, and the game version.
  462.     if ( (gamemode == commercial)
  463.          || ( gamemode == pack_tnt )
  464.          || ( gamemode == pack_plut ) )
  465.     {
  466.         skytexture = R_TextureNumForName ("SKY3");
  467.         if (gamemap < 12)
  468.             skytexture = R_TextureNumForName ("SKY1");
  469.         else
  470.             if (gamemap < 21)
  471.                 skytexture = R_TextureNumForName ("SKY2");
  472.     }
  473.  
  474.     levelstarttic = gametic;        // for time calculation
  475.     
  476.     if (wipegamestate == GS_LEVEL) 
  477.         wipegamestate = -1;             // force a wipe 
  478.  
  479.     gamestate = GS_LEVEL; 
  480.  
  481.     for (i=0 ; i<MAXPLAYERS ; i++) 
  482.     { 
  483.         if (playeringame[i] && players[i].playerstate == PST_DEAD) 
  484.             players[i].playerstate = PST_REBORN; 
  485.         memset (players[i].frags,0,sizeof(players[i].frags)); 
  486.     } 
  487.                  
  488.     P_SetupLevel (gameepisode, gamemap, 0, gameskill);    
  489.     displayplayer = consoleplayer;              // view the guy you are playing    
  490.     starttime = I_GetTime (); 
  491.     gameaction = ga_nothing; 
  492.     Z_CheckHeap ();
  493.     
  494.     // clear cmd building stuff
  495.     memset (gamekeydown, 0, sizeof(gamekeydown)); 
  496.     joyxmove = joyymove = 0; 
  497.     mousex = mousey = 0; 
  498.     sendpause = sendsave = paused = false; 
  499.     memset (mousebuttons, 0, sizeof(mousebuttons)); 
  500.     memset (joybuttons, 0, sizeof(joybuttons)); 
  501. } 
  502.  
  503.  
  504. //
  505. // G_Responder  
  506. // Get info needed to make ticcmd_ts for the players.
  507. // 
  508. boolean G_Responder (event_t* ev) 
  509. { 
  510.     // allow spy mode changes even during the demo
  511.     if (gamestate == GS_LEVEL && ev->type == ev_keydown 
  512.         && ev->data1 == KEY_F12 && (singledemo || !deathmatch) )
  513.     {
  514.         // spy mode 
  515.         do 
  516.         { 
  517.             displayplayer++; 
  518.             if (displayplayer == MAXPLAYERS) 
  519.                 displayplayer = 0; 
  520.         } while (!playeringame[displayplayer] && displayplayer != consoleplayer); 
  521.         return true; 
  522.     }
  523.     
  524.     // any other key pops up menu if in demos
  525.     if (gameaction == ga_nothing && !singledemo && 
  526.         (demoplayback || gamestate == GS_DEMOSCREEN) 
  527.         ) 
  528.     { 
  529.         if (ev->type == ev_keydown ||  
  530.             (ev->type == ev_mouse && ev->data1) || 
  531.             (ev->type == ev_joystick && ev->data1) ) 
  532.         { 
  533.             M_StartControlPanel (); 
  534.             return true; 
  535.         } 
  536.         return false; 
  537.     } 
  538.  
  539.     if (gamestate == GS_LEVEL) 
  540.     { 
  541. #if 0 
  542.         if (devparm && ev->type == ev_keydown && ev->data1 == ';') 
  543.         { 
  544.             G_DeathMatchSpawnPlayer (0); 
  545.             return true; 
  546.         } 
  547. #endif 
  548.         if (HU_Responder (ev)) 
  549.             return true;        // chat ate the event 
  550.         if (ST_Responder (ev)) 
  551.             return true;        // status window ate it 
  552.         if (AM_Responder (ev)) 
  553.             return true;        // automap ate it 
  554.     } 
  555.          
  556.     if (gamestate == GS_FINALE) 
  557.     { 
  558.         if (F_Responder (ev)) 
  559.             return true;        // finale ate the event 
  560.     } 
  561.          
  562.     switch (ev->type) 
  563.     { 
  564.       case ev_keydown: 
  565.         if (ev->data1 == KEY_PAUSE) 
  566.         { 
  567.             sendpause = true; 
  568.             return true; 
  569.         } 
  570.         if (ev->data1 <NUMKEYS) 
  571.             gamekeydown[ev->data1] = true; 
  572.         return true;    // eat key down events 
  573.  
  574.       case ev_keyup: 
  575.         if (ev->data1 <NUMKEYS) 
  576.             gamekeydown[ev->data1] = false; 
  577.         return false;   // always let key up events filter down 
  578.                  
  579.       case ev_mouse: 
  580.         mousebuttons[0] = ev->data1 & 1; 
  581.         mousebuttons[1] = ev->data1 & 2; 
  582.         mousebuttons[2] = ev->data1 & 4; 
  583.         mousex = ev->data2*(mouseSensitivity+5)/10; 
  584.         mousey = ev->data3*(mouseSensitivity+5)/10; 
  585.         return true;    // eat events 
  586.  
  587.       case ev_joystick: 
  588.         joybuttons[0] = ev->data1 & 1; 
  589.         joybuttons[1] = ev->data1 & 2; 
  590.         joybuttons[2] = ev->data1 & 4; 
  591.         joybuttons[3] = ev->data1 & 8; 
  592.         joyxmove = ev->data2; 
  593.         joyymove = ev->data3; 
  594.         return true;    // eat events 
  595.  
  596.       default: 
  597.         break; 
  598.     } 
  599.  
  600.     return false; 
  601. } 
  602.  
  603.  
  604.  
  605. //
  606. // G_Ticker
  607. // Make ticcmd_ts for the players.
  608. //
  609. void G_Ticker (void) 
  610. { 
  611.     int         i;
  612.     int         buf; 
  613.     ticcmd_t*   cmd;
  614.     
  615.     // do player reborns if needed
  616.     for (i=0 ; i<MAXPLAYERS ; i++) 
  617.         if (playeringame[i] && players[i].playerstate == PST_REBORN) 
  618.             G_DoReborn (i);
  619.     
  620.     // do things to change the game state
  621.     while (gameaction != ga_nothing) 
  622.     { 
  623.         switch (gameaction) 
  624.         { 
  625.           case ga_loadlevel: 
  626.             G_DoLoadLevel (); 
  627.             break; 
  628.           case ga_newgame: 
  629.             G_DoNewGame (); 
  630.             break; 
  631.           case ga_loadgame: 
  632.             G_DoLoadGame (); 
  633.             break; 
  634.           case ga_savegame: 
  635.             G_DoSaveGame (); 
  636.             break; 
  637.           case ga_playdemo: 
  638.             G_DoPlayDemo (); 
  639.             break; 
  640.           case ga_completed: 
  641.             G_DoCompleted (); 
  642.             break; 
  643.           case ga_victory: 
  644.             F_StartFinale (); 
  645.             break; 
  646.           case ga_worlddone: 
  647.             G_DoWorldDone (); 
  648.             break; 
  649.           case ga_screenshot: 
  650.             M_ScreenShot (); 
  651.             gameaction = ga_nothing; 
  652.             break; 
  653.           case ga_nothing: 
  654.             break; 
  655.         } 
  656.     }
  657.     
  658.     // get commands, check consistancy,
  659.     // and build new consistancy check
  660.     buf = (gametic/ticdup)%BACKUPTICS; 
  661.  
  662.     for (i=0 ; i<MAXPLAYERS ; i++)
  663.     {
  664.         if (playeringame[i]) 
  665.         { 
  666.             cmd = &players[i].cmd; 
  667.  
  668.             memcpy (cmd, &netcmds[i][buf], sizeof(ticcmd_t)); 
  669.  
  670.             if (demoplayback) 
  671.                 G_ReadDemoTiccmd (cmd); 
  672.             if (demorecording) 
  673.                 G_WriteDemoTiccmd (cmd);
  674.             
  675.             // check for turbo cheats
  676.             if (cmd->forwardmove > TURBOTHRESHOLD 
  677.                 && !(gametic&31) && ((gametic>>5)&3) == i )
  678.             {
  679.                 static char turbomessage[80];
  680.                 extern char *player_names[4];
  681.                 sprintf (turbomessage, "%s is turbo!",player_names[i]);
  682.                 players[consoleplayer].message = turbomessage;
  683.             }
  684.                         
  685.             if (netgame && !netdemo && !(gametic%ticdup) ) 
  686.             { 
  687.                 if (gametic > BACKUPTICS 
  688.                     && consistancy[i][buf] != cmd->consistancy) 
  689.                 { 
  690.                     I_Error ("consistency failure (%i should be %i)",
  691.                              cmd->consistancy, consistancy[i][buf]); 
  692.                 } 
  693.                 if (players[i].mo) 
  694.                     consistancy[i][buf] = players[i].mo->x; 
  695.                 else 
  696.                     consistancy[i][buf] = rndindex; 
  697.             } 
  698.         }
  699.     }
  700.     
  701.     // check for special buttons
  702.     for (i=0 ; i<MAXPLAYERS ; i++)
  703.     {
  704.         if (playeringame[i]) 
  705.         { 
  706.             if (players[i].cmd.buttons & BT_SPECIAL) 
  707.             { 
  708.                 switch (players[i].cmd.buttons & BT_SPECIALMASK) 
  709.                 { 
  710.                   case BTS_PAUSE: 
  711.                     paused ^= 1; 
  712.                     if (paused) 
  713.                         S_PauseSound (); 
  714.                     else 
  715.                         S_ResumeSound (); 
  716.                     break; 
  717.                                          
  718.                   case BTS_SAVEGAME: 
  719.                     if (!savedescription[0]) 
  720.                         strcpy (savedescription, "NET GAME"); 
  721.                     savegameslot =  
  722.                         (players[i].cmd.buttons & BTS_SAVEMASK)>>BTS_SAVESHIFT; 
  723.                     gameaction = ga_savegame; 
  724.                     break; 
  725.                 } 
  726.             } 
  727.         }
  728.     }
  729.     
  730.     // do main actions
  731.     switch (gamestate) 
  732.     { 
  733.       case GS_LEVEL: 
  734.         P_Ticker (); 
  735.         ST_Ticker (); 
  736.         AM_Ticker (); 
  737.         HU_Ticker ();            
  738.         break; 
  739.          
  740.       case GS_INTERMISSION: 
  741.         WI_Ticker (); 
  742.         break; 
  743.                          
  744.       case GS_FINALE: 
  745.         F_Ticker (); 
  746.         break; 
  747.  
  748.       case GS_DEMOSCREEN: 
  749.         D_PageTicker (); 
  750.         break; 
  751.     }        
  752. } 
  753.  
  754.  
  755. //
  756. // PLAYER STRUCTURE FUNCTIONS
  757. // also see P_SpawnPlayer in P_Things
  758. //
  759.  
  760. //
  761. // G_InitPlayer 
  762. // Called at the start.
  763. // Called by the game initialization functions.
  764. //
  765. void G_InitPlayer (int player) 
  766. { 
  767.     player_t*   p; 
  768.  
  769.     // set up the saved info         
  770.     p = &players[player]; 
  771.          
  772.     // clear everything else to defaults 
  773.     G_PlayerReborn (player); 
  774.          
  775. } 
  776.  
  777.  
  778.  
  779. //
  780. // G_PlayerFinishLevel
  781. // Can when a player completes a level.
  782. //
  783. void G_PlayerFinishLevel (int player) 
  784. { 
  785.     player_t*   p; 
  786.          
  787.     p = &players[player]; 
  788.          
  789.     memset (p->powers, 0, sizeof (p->powers)); 
  790.     memset (p->cards, 0, sizeof (p->cards)); 
  791.     p->mo->flags &= ~MF_SHADOW;         // cancel invisibility 
  792.     p->extralight = 0;                  // cancel gun flashes 
  793.     p->fixedcolormap = 0;               // cancel ir gogles 
  794.     p->damagecount = 0;                 // no palette changes 
  795.     p->bonuscount = 0; 
  796. } 
  797.  
  798.  
  799. //
  800. // G_PlayerReborn
  801. // Called after a player dies 
  802. // almost everything is cleared and initialized 
  803. //
  804. void G_PlayerReborn (int player) 
  805. { 
  806.     player_t*   p; 
  807.     int         i; 
  808.     int         frags[MAXPLAYERS]; 
  809.     int         killcount;
  810.     int         itemcount;
  811.     int         secretcount; 
  812.          
  813.     memcpy (frags,players[player].frags,sizeof(frags)); 
  814.     killcount = players[player].killcount; 
  815.     itemcount = players[player].itemcount; 
  816.     secretcount = players[player].secretcount; 
  817.          
  818.     p = &players[player]; 
  819.     memset (p, 0, sizeof(*p)); 
  820.  
  821.     memcpy (players[player].frags, frags, sizeof(players[player].frags)); 
  822.     players[player].killcount = killcount; 
  823.     players[player].itemcount = itemcount; 
  824.     players[player].secretcount = secretcount; 
  825.  
  826.     p->usedown = p->attackdown = true;  // don't do anything immediately 
  827.     p->playerstate = PST_LIVE;       
  828.     p->health = initial_health; // Dehacked
  829.     p->readyweapon = p->pendingweapon = wp_pistol; 
  830.     p->weaponowned[wp_fist] = true; 
  831.     p->weaponowned[wp_pistol] = true; 
  832.     p->ammo[am_clip] = initial_bullets; // Dehacked
  833.          
  834.     for (i=0 ; i<NUMAMMO ; i++) 
  835.         p->maxammo[i] = maxammo[i]; 
  836.                  
  837. }
  838.  
  839. //
  840. // G_CheckSpot  
  841. // Returns false if the player cannot be respawned
  842. // at the given mapthing_t spot  
  843. // because something is occupying it 
  844. //
  845. void P_SpawnPlayer (mapthing_t* mthing); 
  846.  
  847. boolean
  848. G_CheckSpot
  849. ( int           playernum,
  850.   mapthing_t*   mthing ) 
  851. { 
  852.     fixed_t             x;
  853.     fixed_t             y; 
  854.     subsector_t*        ss; 
  855.     unsigned            an; 
  856.     mobj_t*             mo; 
  857.     int                 i;
  858.         
  859.     if (!players[playernum].mo)
  860.     {
  861.         // first spawn of level, before corpses
  862.         for (i=0 ; i<playernum ; i++)
  863.             if (players[i].mo->x == mthing->x << FRACBITS
  864.                 && players[i].mo->y == mthing->y << FRACBITS)
  865.                 return false;   
  866.         return true;
  867.     }
  868.                 
  869.     x = mthing->x << FRACBITS; 
  870.     y = mthing->y << FRACBITS; 
  871.          
  872.     if (!P_CheckPosition (players[playernum].mo, x, y) ) 
  873.         return false; 
  874.  
  875.     // flush an old corpse if needed 
  876.     if (bodyqueslot >= BODYQUESIZE) 
  877.         P_RemoveMobj (bodyque[bodyqueslot%BODYQUESIZE]); 
  878.     bodyque[bodyqueslot%BODYQUESIZE] = players[playernum].mo; 
  879.     bodyqueslot++; 
  880.         
  881.     // spawn a teleport fog 
  882.     ss = R_PointInSubsector (x,y); 
  883.     an = ( ANG45 * (mthing->angle/45) ) >> ANGLETOFINESHIFT; 
  884.  
  885.     mo = P_SpawnMobj (x+20*finecosine[an], y+20*finesine[an] 
  886.                       , ss->sector->floorheight 
  887.                       , MT_TFOG); 
  888.          
  889.     if (players[consoleplayer].viewz != 1) 
  890.         S_StartSound (mo, sfx_telept);  // don't start sound on first frame 
  891.  
  892.     return true; 
  893. } 
  894.  
  895.  
  896. //
  897. // G_DeathMatchSpawnPlayer 
  898. // Spawns a player at one of the random death match spots 
  899. // called at level load and each death 
  900. //
  901. void G_DeathMatchSpawnPlayer (int playernum) 
  902. { 
  903.     int             i,j; 
  904.     int                         selections; 
  905.          
  906.     selections = deathmatch_p - deathmatchstarts; 
  907.     if (selections < 4) 
  908.         I_Error ("Only %i deathmatch spots, 4 required", selections); 
  909.  
  910.     for (j=0 ; j<20 ; j++) 
  911.     { 
  912.         i = P_Random() % selections; 
  913.         if (G_CheckSpot (playernum, &deathmatchstarts[i]) ) 
  914.         { 
  915.             deathmatchstarts[i].type = playernum+1; 
  916.             P_SpawnPlayer (&deathmatchstarts[i]); 
  917.             return; 
  918.         } 
  919.     } 
  920.  
  921.     // no good spot, so the player will probably get stuck 
  922.     P_SpawnPlayer (&playerstarts[playernum]); 
  923. } 
  924.  
  925. //
  926. // G_DoReborn 
  927. // 
  928. void G_DoReborn (int playernum) 
  929. { 
  930.     int                             i; 
  931.          
  932.     if (!netgame)
  933.     {
  934.         // reload the level from scratch
  935.         gameaction = ga_loadlevel;  
  936.     }
  937.     else 
  938.     {
  939.         // respawn at the start
  940.  
  941.         // first dissasociate the corpse 
  942.         players[playernum].mo->player = NULL;   
  943.                  
  944.         // spawn at random spot if in death match 
  945.         if (deathmatch) 
  946.         { 
  947.             G_DeathMatchSpawnPlayer (playernum); 
  948.             return; 
  949.         } 
  950.                  
  951.         if (G_CheckSpot (playernum, &playerstarts[playernum]) ) 
  952.         { 
  953.             P_SpawnPlayer (&playerstarts[playernum]); 
  954.             return; 
  955.         }
  956.         
  957.         // try to spawn at one of the other players spots 
  958.         for (i=0 ; i<MAXPLAYERS ; i++)
  959.         {
  960.             if (G_CheckSpot (playernum, &playerstarts[i]) ) 
  961.             { 
  962.                 playerstarts[i].type = playernum+1;     // fake as other player 
  963.                 P_SpawnPlayer (&playerstarts[i]); 
  964.                 playerstarts[i].type = i+1;             // restore 
  965.                 return; 
  966.             }       
  967.             // he's going to be inside something.  Too bad.
  968.         }
  969.         P_SpawnPlayer (&playerstarts[playernum]); 
  970.     } 
  971. } 
  972.  
  973.  
  974. void G_ScreenShot (void) 
  975. { 
  976.     gameaction = ga_screenshot; 
  977. } 
  978.  
  979.  
  980.  
  981. // DOOM Par Times
  982. int pars[4][10] = 
  983. { 
  984.     {0}, 
  985.     {0,30,75,120,90,165,180,180,30,165}, 
  986.     {0,90,90,90,120,90,360,240,30,170}, 
  987.     {0,90,45,90,150,90,90,165,30,135} 
  988. }; 
  989.  
  990. // DOOM II Par Times
  991. int cpars[32] =
  992. {
  993.     30,90,120,120,90,150,120,120,270,90,        //  1-10
  994.     210,150,150,150,210,150,420,150,210,150,    // 11-20
  995.     240,150,180,150,150,300,330,420,300,180,    // 21-30
  996.     120,30                                      // 31-32
  997. };
  998.  
  999.  
  1000. //
  1001. // G_DoCompleted 
  1002. //
  1003. boolean         secretexit; 
  1004. extern char*    pagename; 
  1005.  
  1006. void G_ExitLevel (void) 
  1007. { 
  1008.     secretexit = false; 
  1009.     gameaction = ga_completed; 
  1010. } 
  1011.  
  1012. // Here's for the german edition.
  1013. void G_SecretExitLevel (void) 
  1014. { 
  1015.     // IF NO WOLF3D LEVELS, NO SECRET EXIT!
  1016.     if ( (gamemode == commercial)
  1017.       && (W_CheckNumForName("map31")<0))
  1018.         secretexit = false;
  1019.     else
  1020.         secretexit = true; 
  1021.     gameaction = ga_completed; 
  1022. } 
  1023.  
  1024. void G_DoCompleted (void) 
  1025. { 
  1026.     int             i; 
  1027.          
  1028.     gameaction = ga_nothing; 
  1029.  
  1030.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1031.         if (playeringame[i]) 
  1032.             G_PlayerFinishLevel (i);        // take away cards and stuff 
  1033.          
  1034.     if (automapactive) 
  1035.         AM_Stop (); 
  1036.         
  1037.     if ( gamemode != commercial)
  1038.         switch(gamemap)
  1039.         {
  1040.           case 8:
  1041.             gameaction = ga_victory;
  1042.             return;
  1043.           case 9: 
  1044.             for (i=0 ; i<MAXPLAYERS ; i++) 
  1045.                 players[i].didsecret = true; 
  1046.             break;
  1047.         }
  1048.                 
  1049. //#if 0  Hmmm - why?
  1050.     if ( (gamemap == 8)
  1051.          && (gamemode != commercial) ) 
  1052.     {
  1053.         // victory 
  1054.         gameaction = ga_victory; 
  1055.         return; 
  1056.     } 
  1057.          
  1058.     if ( (gamemap == 9)
  1059.          && (gamemode != commercial) ) 
  1060.     {
  1061.         // exit secret level 
  1062.         for (i=0 ; i<MAXPLAYERS ; i++) 
  1063.             players[i].didsecret = true; 
  1064.     } 
  1065. //#endif
  1066.     
  1067.          
  1068.     wminfo.didsecret = players[consoleplayer].didsecret; 
  1069.     wminfo.epsd = gameepisode -1; 
  1070.     wminfo.last = gamemap -1;
  1071.     
  1072.     // wminfo.next is 0 biased, unlike gamemap
  1073.     if ( gamemode == commercial)
  1074.     {
  1075.         if (secretexit)
  1076.             switch(gamemap)
  1077.             {
  1078.               case 15: wminfo.next = 30; break;
  1079.               case 31: wminfo.next = 31; break;
  1080.             }
  1081.         else
  1082.             switch(gamemap)
  1083.             {
  1084.               case 31:
  1085.               case 32: wminfo.next = 15; break;
  1086.               default: wminfo.next = gamemap;
  1087.             }
  1088.     }
  1089.     else
  1090.     {
  1091.         if (secretexit) 
  1092.             wminfo.next = 8;    // go to secret level 
  1093.         else if (gamemap == 9) 
  1094.         {
  1095.             // returning from secret level 
  1096.             switch (gameepisode) 
  1097.             { 
  1098.               case 1: 
  1099.                 wminfo.next = 3; 
  1100.                 break; 
  1101.               case 2: 
  1102.                 wminfo.next = 5; 
  1103.                 break; 
  1104.               case 3: 
  1105.                 wminfo.next = 6; 
  1106.                 break; 
  1107.               case 4:
  1108.                 wminfo.next = 2;
  1109.                 break;
  1110.             }                
  1111.         } 
  1112.         else 
  1113.             wminfo.next = gamemap;          // go to next level 
  1114.     }
  1115.                  
  1116.     wminfo.maxkills = totalkills; 
  1117.     wminfo.maxitems = totalitems; 
  1118.     wminfo.maxsecret = totalsecret; 
  1119.     wminfo.maxfrags = 0; 
  1120.     if ( gamemode == commercial )
  1121.         wminfo.partime = 35*cpars[gamemap-1]; 
  1122.     else
  1123.         wminfo.partime = 35*pars[gameepisode][gamemap]; 
  1124.     wminfo.pnum = consoleplayer; 
  1125.  
  1126.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1127.     { 
  1128.         wminfo.plyr[i].in = playeringame[i]; 
  1129.         wminfo.plyr[i].skills = players[i].killcount; 
  1130.         wminfo.plyr[i].sitems = players[i].itemcount; 
  1131.         wminfo.plyr[i].ssecret = players[i].secretcount; 
  1132.         wminfo.plyr[i].stime = leveltime; 
  1133.         memcpy (wminfo.plyr[i].frags, players[i].frags 
  1134.                 , sizeof(wminfo.plyr[i].frags)); 
  1135.     } 
  1136.  
  1137.     gamestate = GS_INTERMISSION; 
  1138.     viewactive = false; 
  1139.     automapactive = false; 
  1140.  
  1141.     if (statcopy)
  1142.         memcpy (statcopy, &wminfo, sizeof(wminfo));
  1143.         
  1144.     WI_Start (&wminfo); 
  1145. } 
  1146.  
  1147.  
  1148. //
  1149. // G_WorldDone 
  1150. //
  1151. void G_WorldDone (void) 
  1152. { 
  1153.     gameaction = ga_worlddone; 
  1154.  
  1155.     if (secretexit) 
  1156.         players[consoleplayer].didsecret = true; 
  1157.  
  1158.     if ( gamemode == commercial )
  1159.     {
  1160.         switch (gamemap)
  1161.         {
  1162.           case 15:
  1163.           case 31:
  1164.             if (!secretexit)
  1165.                 break;
  1166.           case 6:
  1167.           case 11:
  1168.           case 20:
  1169.           case 30:
  1170.             F_StartFinale ();
  1171.             break;
  1172.         }
  1173.     }
  1174. } 
  1175.  
  1176. void G_DoWorldDone (void) 
  1177. {        
  1178.     gamestate = GS_LEVEL; 
  1179.     gamemap = wminfo.next+1; 
  1180.     G_DoLoadLevel (); 
  1181.     gameaction = ga_nothing; 
  1182.     viewactive = true; 
  1183. } 
  1184.  
  1185.  
  1186.  
  1187. //
  1188. // G_InitFromSavegame
  1189. // Can be called by the startup code or the menu task. 
  1190. //
  1191. extern boolean setsizeneeded;
  1192. void R_ExecuteSetViewSize (void);
  1193.  
  1194. char    savename[256];
  1195.  
  1196. void G_LoadGame (char* name) 
  1197. { 
  1198.     strcpy (savename, name); 
  1199.     gameaction = ga_loadgame; 
  1200. } 
  1201.  
  1202. #define VERSIONSIZE             16 
  1203.  
  1204.  
  1205. void G_DoLoadGame (void) 
  1206. { 
  1207.     int         length; 
  1208.     int         i; 
  1209.     int         a,b,c; 
  1210.     char        vcheck[VERSIONSIZE]; 
  1211.          
  1212.     gameaction = ga_nothing; 
  1213.          
  1214.     length = M_ReadFile (savename, &savebuffer); 
  1215.     save_p = savebuffer + SAVESTRINGSIZE;
  1216.     
  1217.     // skip the description field 
  1218.     memset (vcheck,0,sizeof(vcheck)); 
  1219.     sprintf (vcheck,"version %i",VERSION); 
  1220.     if (strcmp (save_p, vcheck)) 
  1221.         return;                         // bad version 
  1222.     save_p += VERSIONSIZE; 
  1223.                          
  1224.     gameskill = *save_p++; 
  1225.     gameepisode = *save_p++; 
  1226.     gamemap = *save_p++; 
  1227.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1228.         playeringame[i] = *save_p++; 
  1229.  
  1230.     // load a base level 
  1231.     G_InitNew (gameskill, gameepisode, gamemap); 
  1232.  
  1233.     // get the times 
  1234.     a = *save_p++; 
  1235.     b = *save_p++; 
  1236.     c = *save_p++; 
  1237.     leveltime = (a<<16) + (b<<8) + c; 
  1238.          
  1239.     // dearchive all the modifications
  1240.     P_UnArchivePlayers (); 
  1241.     P_UnArchiveWorld (); 
  1242.     P_UnArchiveThinkers (); 
  1243.     P_UnArchiveSpecials (); 
  1244.  
  1245.     if (*save_p != 0x1d) 
  1246.         I_Error ("Bad savegame");
  1247.     
  1248.     // done 
  1249.     Z_Free (savebuffer); 
  1250.  
  1251.     if (setsizeneeded)
  1252.         R_ExecuteSetViewSize ();
  1253.     
  1254.     // draw the pattern into the back screen
  1255.     R_FillBackScreen ();   
  1256. } 
  1257.  
  1258.  
  1259. //
  1260. // G_SaveGame
  1261. // Called by the menu task.
  1262. // Description is a 24 byte text string 
  1263. //
  1264. void
  1265. G_SaveGame
  1266. ( int   slot,
  1267.   char* description ) 
  1268. { 
  1269.     savegameslot = slot; 
  1270.     strcpy (savedescription, description); 
  1271.     sendsave = true; 
  1272. } 
  1273.  
  1274. void G_DoSaveGame (void) 
  1275. { 
  1276.     char        name[100]; 
  1277.     char        name2[VERSIONSIZE]; 
  1278.     char*       description; 
  1279.     int         length; 
  1280.     int         i; 
  1281.         
  1282.     if (M_CheckParm("-cdrom"))
  1283.         sprintf(name,"c:\\doomdata\\"SAVEGAMENAME"%d.dsg",savegameslot);
  1284.     else
  1285.         sprintf (name,SAVEGAMENAME"%d.dsg",savegameslot); 
  1286.     description = savedescription; 
  1287.          
  1288.     save_p = savebuffer = screens[1]+0x4000; 
  1289.          
  1290.     memcpy (save_p, description, SAVESTRINGSIZE); 
  1291.     save_p += SAVESTRINGSIZE; 
  1292.     memset (name2,0,sizeof(name2)); 
  1293.     sprintf (name2,"version %i",VERSION); 
  1294.     memcpy (save_p, name2, VERSIONSIZE); 
  1295.     save_p += VERSIONSIZE; 
  1296.          
  1297.     *save_p++ = gameskill; 
  1298.     *save_p++ = gameepisode; 
  1299.     *save_p++ = gamemap; 
  1300.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1301.         *save_p++ = playeringame[i]; 
  1302.     *save_p++ = leveltime>>16; 
  1303.     *save_p++ = leveltime>>8; 
  1304.     *save_p++ = leveltime; 
  1305.  
  1306.     P_ArchivePlayers (); 
  1307.     P_ArchiveWorld (); 
  1308.     P_ArchiveThinkers (); 
  1309.     P_ArchiveSpecials (); 
  1310.          
  1311.     *save_p++ = 0x1d;           // consistancy marker 
  1312.          
  1313.     length = save_p - savebuffer; 
  1314.     if (length > SAVEGAMESIZE) 
  1315.         I_Error ("Savegame buffer overrun"); 
  1316.     M_WriteFile (name, savebuffer, length); 
  1317.     gameaction = ga_nothing; 
  1318.     savedescription[0] = 0;              
  1319.          
  1320.     players[consoleplayer].message = GGSAVED; 
  1321.  
  1322.     // draw the pattern into the back screen
  1323.     R_FillBackScreen ();        
  1324. } 
  1325.  
  1326.  
  1327. //
  1328. // G_InitNew
  1329. // Can be called by the startup code or the menu task,
  1330. // consoleplayer, displayplayer, playeringame[] should be set. 
  1331. //
  1332. skill_t d_skill; 
  1333. int     d_episode; 
  1334. int     d_map; 
  1335.  
  1336. void
  1337. G_DeferedInitNew
  1338. ( skill_t       skill,
  1339.   int           episode,
  1340.   int           map) 
  1341. { 
  1342.     d_skill = skill; 
  1343.     d_episode = episode; 
  1344.     d_map = map; 
  1345.     gameaction = ga_newgame; 
  1346. } 
  1347.  
  1348.  
  1349. void G_DoNewGame (void) 
  1350. {
  1351.     demoplayback = false; 
  1352.     netdemo = false;
  1353.     netgame = false;
  1354.     deathmatch = false;
  1355.     playeringame[1] = playeringame[2] = playeringame[3] = 0;
  1356.     respawnparm = false;
  1357.     fastparm = false;
  1358.     nomonsters = false;
  1359.     consoleplayer = 0;
  1360.     G_InitNew (d_skill, d_episode, d_map); 
  1361.     gameaction = ga_nothing; 
  1362. } 
  1363.  
  1364. // The sky texture to be used instead of the F_SKY1 dummy.
  1365. extern  int     skytexture; 
  1366.  
  1367.  
  1368. void
  1369. G_InitNew
  1370. ( skill_t       skill,
  1371.   int           episode,
  1372.   int           map ) 
  1373. { 
  1374.     int             i; 
  1375.          
  1376.     if (paused) 
  1377.     { 
  1378.         paused = false; 
  1379.         S_ResumeSound (); 
  1380.     } 
  1381.         
  1382.  
  1383.     if (skill > sk_nightmare) 
  1384.         skill = sk_nightmare;
  1385.  
  1386.  
  1387.     // This was quite messy with SPECIAL and commented parts.
  1388.     // Supposedly hacks to make the latest edition work.
  1389.     // It might not work properly.
  1390.     if (episode < 1)
  1391.       episode = 1; 
  1392.  
  1393.     if ( gamemode == retail )
  1394.     {
  1395.       if (episode > 4)
  1396.         episode = 4;
  1397.     }
  1398.     else if ( gamemode == shareware )
  1399.     {
  1400.       if (episode > 1) 
  1401.            episode = 1; // only start episode 1 on shareware
  1402.     }  
  1403.     else
  1404.     {
  1405.       if (episode > 3)
  1406.         episode = 3;
  1407.     }
  1408.     
  1409.  
  1410.   
  1411.     if (map < 1) 
  1412.         map = 1;
  1413.     
  1414.     if ( (map > 9)
  1415.          && ( gamemode != commercial) )
  1416.       map = 9; 
  1417.                  
  1418.     M_ClearRandom (); 
  1419.          
  1420.     if (skill == sk_nightmare || respawnparm )
  1421.         respawnmonsters = true;
  1422.     else
  1423.         respawnmonsters = false;
  1424.                 
  1425.     if (fastparm || (skill == sk_nightmare && gameskill != sk_nightmare) )
  1426.     { 
  1427.         for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++) 
  1428.             states[i].tics >>= 1; 
  1429.         mobjinfo[MT_BRUISERSHOT].speed = 20*FRACUNIT; 
  1430.         mobjinfo[MT_HEADSHOT].speed = 20*FRACUNIT; 
  1431.         mobjinfo[MT_TROOPSHOT].speed = 20*FRACUNIT; 
  1432.     } 
  1433.     else if (skill != sk_nightmare && gameskill == sk_nightmare) 
  1434.     { 
  1435.         for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++) 
  1436.             states[i].tics <<= 1; 
  1437.         mobjinfo[MT_BRUISERSHOT].speed = 15*FRACUNIT; 
  1438.         mobjinfo[MT_HEADSHOT].speed = 10*FRACUNIT; 
  1439.         mobjinfo[MT_TROOPSHOT].speed = 10*FRACUNIT; 
  1440.     } 
  1441.          
  1442.                          
  1443.     // force players to be initialized upon first level load         
  1444.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1445.         players[i].playerstate = PST_REBORN; 
  1446.  
  1447.     usergame = true;                // will be set false if a demo 
  1448.     paused = false; 
  1449.     demoplayback = false; 
  1450.     automapactive = false; 
  1451.     viewactive = true; 
  1452.     gameepisode = episode; 
  1453.     gamemap = map; 
  1454.     gameskill = skill; 
  1455.  
  1456.     viewactive = true;
  1457.     
  1458.     // set the sky map for the episode
  1459.     if ( gamemode == commercial)
  1460.     {
  1461.         skytexture = R_TextureNumForName ("SKY3");
  1462.         if (gamemap < 12)
  1463.             skytexture = R_TextureNumForName ("SKY1");
  1464.         else
  1465.             if (gamemap < 21)
  1466.                 skytexture = R_TextureNumForName ("SKY2");
  1467.     }
  1468.     else
  1469.         switch (episode) 
  1470.         { 
  1471.           case 1: 
  1472.             skytexture = R_TextureNumForName ("SKY1"); 
  1473.             break; 
  1474.           case 2: 
  1475.             skytexture = R_TextureNumForName ("SKY2"); 
  1476.             break; 
  1477.           case 3: 
  1478.             skytexture = R_TextureNumForName ("SKY3"); 
  1479.             break; 
  1480.           case 4:       // Special Edition sky
  1481.             skytexture = R_TextureNumForName ("SKY4");
  1482.             break;
  1483.         } 
  1484.  
  1485.     G_DoLoadLevel (); 
  1486. } 
  1487.  
  1488.  
  1489. //
  1490. // DEMO RECORDING 
  1491. // 
  1492. #define DEMOMARKER              0x80
  1493.  
  1494.  
  1495. void G_ReadDemoTiccmd (ticcmd_t* cmd) 
  1496. { 
  1497.     if (*demo_p == DEMOMARKER) 
  1498.     {
  1499.         // end of demo data stream 
  1500.         G_CheckDemoStatus (); 
  1501.         return; 
  1502.     } 
  1503.     cmd->forwardmove = ((signed char)*demo_p++); 
  1504.     cmd->sidemove = ((signed char)*demo_p++); 
  1505.     cmd->angleturn = ((unsigned char)*demo_p++)<<8; 
  1506.     cmd->buttons = (unsigned char)*demo_p++; 
  1507. } 
  1508.  
  1509.  
  1510. void G_WriteDemoTiccmd (ticcmd_t* cmd) 
  1511. { 
  1512.     if (gamekeydown['q'])           // press q to end demo recording 
  1513.         G_CheckDemoStatus (); 
  1514.     *demo_p++ = cmd->forwardmove; 
  1515.     *demo_p++ = cmd->sidemove; 
  1516.     *demo_p++ = (cmd->angleturn+128)>>8; 
  1517.     *demo_p++ = cmd->buttons; 
  1518.     demo_p -= 4; 
  1519.     if (demo_p > demoend - 16)
  1520.     {
  1521.         // no more space 
  1522.         G_CheckDemoStatus (); 
  1523.         return; 
  1524.     } 
  1525.         
  1526.     G_ReadDemoTiccmd (cmd);         // make SURE it is exactly the same 
  1527. } 
  1528.  
  1529.  
  1530.  
  1531. //
  1532. // G_RecordDemo 
  1533. // 
  1534. void G_RecordDemo (char* name) 
  1535. { 
  1536.     int             i; 
  1537.     int                         maxsize;
  1538.         
  1539.     usergame = false; 
  1540.     strcpy (demoname, name); 
  1541.     strcat (demoname, ".lmp"); 
  1542.     maxsize = 0x20000;
  1543.     i = M_CheckParm ("-maxdemo");
  1544.     if (i && i<myargc-1)
  1545.         maxsize = atoi(myargv[i+1])*1024;
  1546.     demobuffer = Z_Malloc (maxsize,PU_STATIC,NULL); 
  1547.     demoend = demobuffer + maxsize;
  1548.         
  1549.     demorecording = true; 
  1550. } 
  1551.  
  1552.  
  1553. void G_BeginRecording (void) 
  1554. { 
  1555.     int             i; 
  1556.                 
  1557.     demo_p = demobuffer;
  1558.         
  1559.     *demo_p++ = VERSION;
  1560.     *demo_p++ = gameskill; 
  1561.     *demo_p++ = gameepisode; 
  1562.     *demo_p++ = gamemap; 
  1563.     *demo_p++ = deathmatch; 
  1564.     *demo_p++ = respawnparm;
  1565.     *demo_p++ = fastparm;
  1566.     *demo_p++ = nomonsters;
  1567.     *demo_p++ = consoleplayer;
  1568.          
  1569.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1570.         *demo_p++ = playeringame[i];             
  1571. } 
  1572.  
  1573.  
  1574. //
  1575. // G_PlayDemo 
  1576. //
  1577.  
  1578. char*   defdemoname; 
  1579.  
  1580. void G_DeferedPlayDemo (char* name) 
  1581. { 
  1582.     defdemoname = name; 
  1583.     gameaction = ga_playdemo; 
  1584. } 
  1585.  
  1586. void G_DoPlayDemo (void) 
  1587. { 
  1588.     skill_t skill; 
  1589.     int             i, episode, map; 
  1590.          
  1591.     gameaction = ga_nothing; 
  1592.     demobuffer = demo_p = W_CacheLumpName (defdemoname, PU_STATIC); 
  1593.     if ( *demo_p++ != VERSION && !M_CheckParm("-forcedemo"))
  1594.     {
  1595.       fprintf( stderr, "Demo is from a different game version!\n");
  1596.       gameaction = ga_nothing;
  1597.       return;
  1598.     }
  1599.     
  1600.     skill = *demo_p++; 
  1601.     episode = *demo_p++; 
  1602.     map = *demo_p++; 
  1603.     deathmatch = *demo_p++;
  1604.     respawnparm = *demo_p++;
  1605.     fastparm = *demo_p++;
  1606.     nomonsters = *demo_p++;
  1607.     consoleplayer = *demo_p++;
  1608.         
  1609.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1610.         playeringame[i] = *demo_p++; 
  1611.     if (playeringame[1]) 
  1612.     { 
  1613.         netgame = true; 
  1614.         netdemo = true; 
  1615.     }
  1616.  
  1617.     // don't spend a lot of time in loadlevel 
  1618.     precache = false;
  1619.     G_InitNew (skill, episode, map); 
  1620.     precache = true; 
  1621.  
  1622.     usergame = false; 
  1623.     demoplayback = true; 
  1624. } 
  1625.  
  1626. //
  1627. // G_TimeDemo 
  1628. //
  1629. void G_TimeDemo (char* name) 
  1630. {        
  1631.     nodrawers = M_CheckParm ("-nodraw"); 
  1632.     noblit = M_CheckParm ("-noblit"); 
  1633.     timingdemo = true; 
  1634.     singletics = true; 
  1635.  
  1636.     defdemoname = name; 
  1637.     gameaction = ga_playdemo; 
  1638. } 
  1639.  
  1640.  
  1641. /* 
  1642. =================== 
  1643. = 
  1644. = G_CheckDemoStatus 
  1645. = 
  1646. = Called after a death or level completion to allow demos to be cleaned up 
  1647. = Returns true if a new demo loop action will take place 
  1648. =================== 
  1649. */ 
  1650.  
  1651. boolean G_CheckDemoStatus (void) 
  1652. { 
  1653.     int             endtime; 
  1654.          
  1655.     if (timingdemo) 
  1656.     { 
  1657.         endtime = I_GetTime (); 
  1658.         I_Error ("timed %i gametics in %i realtics",gametic 
  1659.                  , endtime-starttime); 
  1660.     } 
  1661.          
  1662.     if (demoplayback) 
  1663.     { 
  1664.         if (singledemo) 
  1665.             I_Quit (); 
  1666.                          
  1667.         Z_ChangeTag (demobuffer, PU_CACHE); 
  1668.         demoplayback = false; 
  1669.         netdemo = false;
  1670.         netgame = false;
  1671.         deathmatch = false;
  1672.         playeringame[1] = playeringame[2] = playeringame[3] = 0;
  1673.         respawnparm = false;
  1674.         fastparm = false;
  1675.         nomonsters = false;
  1676.         consoleplayer = 0;
  1677.         D_AdvanceDemo (); 
  1678.         return true; 
  1679.     } 
  1680.  
  1681.     if (demorecording) 
  1682.     { 
  1683.         *demo_p++ = DEMOMARKER; 
  1684.         M_WriteFile (demoname, demobuffer, demo_p - demobuffer); 
  1685.         Z_Free (demobuffer); 
  1686.         demorecording = false; 
  1687.         I_Error ("Demo %s recorded",demoname); 
  1688.     } 
  1689.          
  1690.     return false; 
  1691. } 
  1692.  
  1693.  
  1694.  
  1695.