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