开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
g_game.c
资源名称：21.rar　[点击查看]
上传用户：xuyinpeng
上传日期：2021-05-12
资源大小：455k
文件大小：48k
源码类别：

射击游戏

开发平台：

Visual C++

g_game.c：源码内容
  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. //-----------------------------------------------------------------------------
  24. static const char
  25. rcsid[] = "$Id: g_game.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";
  27. #include <string.h>
  28. #include <stdlib.h>
  30. #include "doomdef.h" 
  31. #include "doomstat.h"
  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"
  41. #include "p_setup.h"
  42. #include "p_saveg.h"
  43. #include "p_tick.h"
  45. #include "d_main.h"
  47. #include "wi_stuff.h"
  48. #include "hu_stuff.h"
  49. #include "st_stuff.h"
  50. #include "am_map.h"
  52. // Needs access to LFB.
  53. #include "v_video.h"
  55. #include "w_wad.h"
  57. #include "p_local.h" 
  59. #include "s_sound.h"
  61. // Data.
  62. #include "dstrings.h"
  63. #include "sounds.h"
  65. // SKY handling - still the wrong place.
  66. #include "r_data.h"
  67. #include "r_sky.h"
  71. #include "g_game.h"
  74. #define SAVEGAMESIZE 0x2c000
  75. #define SAVESTRINGSIZE 24
  77. void WriteDebug(char *);
  78. char MsgText[256];
  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_DoPlayDemo_II(void); 
  93. void G_DoCompleted (void); 
  94. void G_DoVictory (void); 
  95. void G_DoWorldDone (void); 
  96. void G_DoSaveGame (void); 
  97.  
  98.  
  99. gameaction_t    gameaction; 
  100. gamestate_t     gamestate; 
  101. skill_t         gameskill; 
  102. boolean respawnmonsters;
  103. int             gameepisode; 
  104. int             gamemap; 
  105.  
  106. boolean         paused; 
  107. boolean         sendpause;              // send a pause event next tic 
  108. boolean         sendsave;              // send a save event next tic 
  109. boolean         usergame;               // ok to save / end game 
  110.  
  111. boolean         timingdemo;             // if true, exit with report on completion 
  112. boolean         nodrawers;              // for comparative timing purposes 
  113. boolean         noblit;                 // for comparative timing purposes 
  114. int             starttime;           // for comparative timing purposes    
  115.  
  116. boolean         viewactive; 
  117.  
  118. boolean         deathmatch;            // only if started as net death 
  119. boolean         netgame;                // only true if packets are broadcast 
  120. boolean         playeringame[MAXPLAYERS]; 
  121. player_t        players[MAXPLAYERS]; 
  122.  
  123. int             consoleplayer;          // player taking events and displaying 
  124. int             displayplayer;          // view being displayed 
  125. int             gametic; 
  126. int             levelstarttic;          // gametic at level start 
  127. int             totalkills, totalitems, totalsecret;    // for intermission 
  128.  
  129. char            demoname[32]; 
  130. int             demotype; 
  131. boolean         demorecording; 
  132. boolean         demoplayback; 
  133. boolean netdemo; 
  134. byte* demobuffer;
  135. byte* demo_p;
  136. byte* demoend; 
  137. boolean         singledemo;             // quit after playing a demo from cmdline 
  138.  
  139. boolean         precache = true;        // if true, load all graphics at start 
  140.  
  141. wbstartstruct_t wminfo;                // parms for world map / intermission 
  142.  
  143. short consistancy[MAXPLAYERS][BACKUPTICS]; 
  144.  
  145. byte* savebuffer;
  146.  
  147.  
  148. // 
  149. // controls (have defaults) 
  150. // 
  151. int     key_right;
  152. int key_left;
  154. int key_up;
  155. int key_down; 
  156. int     key_strafeleft;
  157. int     key_straferight; 
  158. int     key_fire;
  159. int key_use;
  160. int key_strafe;
  161. int     key_speed; 
  163. int     key_mvert;
  164.  
  165. int     mousebfire; 
  166. int     mousebstrafe; 
  167. int     mousebforward; 
  168.  
  169. int     mouseb1;
  170. int     mouseb2;
  171. int     mouseb3;
  173. int     joybfire; 
  174. int     joybstrafe; 
  175. int     joybuse; 
  176. int     joybspeed; 
  178. int     joyb1;
  179. int     joyb2;
  180. int     joyb3;
  181. int     joyb4;
  182.  
  183. int     always_run;
  184. int     swap_stereo;
  185. int     mvert;
  186. int     keylink;
  187. int     link_alt;
  188.  
  189. #define MAXPLMOVE (forwardmove[1]) 
  190.  
  191. #define TURBOTHRESHOLD 0x32
  193. fixed_t forwardmove[2] = {0x19, 0x32};
  194. fixed_t sidemove[2] = {0x18, 0x28}; 
  195. fixed_t angleturn[3] = {640, 1280, 320}; // + slow turn 
  197. #define SLOWTURNTICS 6 
  198.  
  199. #define NUMKEYS 256 
  201. boolean         gamekeydown[NUMKEYS]; 
  202. int             turnheld; // for accelerative turning 
  203.  
  204. boolean mousearray[4]; 
  205. boolean* mousebuttons = &mousearray[1]; // allow [-1]
  207. // mouse values are used once 
  208. int             mousex;
  209. int mousey;         
  211. int             dclicktime;
  212. int dclickstate;
  213. int dclicks; 
  214. int             dclicktime2;
  215. int dclickstate2;
  216. int dclicks2;
  218. // joystick values are repeated 
  219. int             joyxmove;
  220. int joyymove;
  221. boolean         joyarray[5]; 
  222. boolean* joybuttons = &joyarray[1]; // allow [-1] 
  223.  
  224. int savegameslot; 
  225. char savedescription[32]; 
  226.  
  227.  
  228. #define BODYQUESIZE 32
  230. mobj_t* bodyque[BODYQUESIZE]; 
  231. int bodyqueslot; 
  232.  
  233. void* statcopy; // for statistics driver
  234.  
  235.  
  236.  
  237. int G_CmdChecksum (ticcmd_t* cmd) 
  238. { 
  239.     int i;
  240.     int sum = 0; 
  241.  
  242.     for (i=0 ; i< sizeof(*cmd)/4 - 1 ; i++) 
  243. sum += ((int *)cmd)[i]; 
  244.  
  245.     return sum; 
  246. } 
  247.  
  249. //
  250. // G_BuildTiccmd
  251. // Builds a ticcmd from all of the available inputs
  252. // or reads it from the demo buffer. 
  253. // If recording a demo, write it out 
  254. // 
  255. void G_BuildTiccmd (ticcmd_t* cmd) 
  256.    { 
  257.     int       i; 
  258.     boolean   strafe;
  259.     boolean   bstrafe; 
  260.     int       speed;
  261.     int       tspeed; 
  262.     int       forward;
  263.     int       side;
  264.     ticcmd_t *base;
  267.     base = I_BaseTiccmd (); // empty, or external driver
  268.     memcpy (cmd,base,sizeof(*cmd)); 
  270.     cmd->consistancy = consistancy[consoleplayer][maketic%BACKUPTICS]; 
  271.  
  272.     strafe = gamekeydown[key_strafe] || mousebuttons[mousebstrafe] || joybuttons[joybstrafe]; 
  273.     if ((joybspeed == 31) || (always_run == TRUE))
  274.        speed = 1;
  275.     else
  276.        speed = gamekeydown[key_speed] || joybuttons[joybspeed];
  277.     
  278.  
  279.     forward = side = 0;
  280.     
  281.     // use two stage accelerative turning on the keyboard and joystick
  282.     if (joyxmove < 0 || joyxmove > 0 || gamekeydown[key_right] || gamekeydown[key_left]) 
  283.         turnheld += ticdup; 
  284.     else 
  285.         turnheld = 0; 
  287.     if (turnheld < SLOWTURNTICS) 
  288.         tspeed = 2;             // slow turn 
  289.     else 
  290.         tspeed = speed;
  291.     
  292.     // let movement keys cancel each other out
  293.     if (strafe) 
  294.        { 
  295.         if (gamekeydown[key_right]) 
  296.            {
  297.             // fprintf(stderr, "strafe rightn");
  298.             side += sidemove[speed]; 
  299.            }
  300.         if (gamekeydown[key_left]) 
  301.            {
  302.             // fprintf(stderr, "strafe leftn");
  303.             side -= sidemove[speed]; 
  304.            }
  305.         if (joyxmove > 0) 
  306.             side += sidemove[speed]; 
  307.         if (joyxmove < 0) 
  308.             side -= sidemove[speed]; 
  309.        } 
  310.     else 
  311.        { 
  312.         if (gamekeydown[key_right]) 
  313.             cmd->angleturn -= angleturn[tspeed]; 
  314.         if (gamekeydown[key_left]) 
  315.             cmd->angleturn += angleturn[tspeed]; 
  316.         if (joyxmove > 0) 
  317.             cmd->angleturn -= angleturn[tspeed]; 
  318.         if (joyxmove < 0) 
  319.             cmd->angleturn += angleturn[tspeed]; 
  320.        } 
  321.  
  322.     if (gamekeydown[key_up]) 
  323.        {
  324.         // fprintf(stderr, "upn");
  325.         forward += forwardmove[speed]; 
  326.        }
  327.     if (gamekeydown[key_down]) 
  328.        {
  329.         // fprintf(stderr, "downn");
  330.         forward -= forwardmove[speed]; 
  331.        }
  332.     if (joyymove < 0) 
  333.         forward += forwardmove[speed]; 
  334.     if (joyymove > 0) 
  335.         forward -= forwardmove[speed]; 
  336.     if (gamekeydown[key_straferight]) 
  337.         side += sidemove[speed]; 
  338.     if (gamekeydown[key_strafeleft]) 
  339.         side -= sidemove[speed];
  340.     
  341.     // buttons
  342.     cmd->chatchar = HU_dequeueChatChar(); 
  343.  
  344.     if (gamekeydown[key_fire] || mousebuttons[mousebfire] || joybuttons[joybfire]) 
  345.        {
  346.         cmd->buttons |= BT_ATTACK;
  347.        }
  348.  
  349.     if (gamekeydown[key_use] || joybuttons[joybuse] ) 
  350.        { 
  351.         cmd->buttons |= BT_USE;
  352.         // clear double clicks if hit use button 
  353.         dclicks = 0;                   
  354.        } 
  356.     // chainsaw overrides 
  357.     for (i = 0; i < NUMWEAPONS-1; i++)
  358.         if (gamekeydown[KEY_1+i])
  359.            { 
  360.             cmd->buttons |= BT_CHANGE; 
  361.             cmd->buttons |= i<<BT_WEAPONSHIFT; 
  362.             break; 
  363.            }
  364.     
  365.     // mouse
  366.     if (mousebuttons[mousebforward]) 
  367.         forward += forwardmove[speed];
  368.     
  369.     // forward double click
  370.     if (mousebuttons[mousebforward] != dclickstate && dclicktime > 1 ) 
  371.        { 
  372.         dclickstate = mousebuttons[mousebforward]; 
  373.         if (dclickstate) 
  374.             dclicks++; 
  375.         if (dclicks == 2) 
  376.            { 
  377.             cmd->buttons |= BT_USE; 
  378.             dclicks = 0; 
  379.            } 
  380.         else 
  381.             dclicktime = 0; 
  382.        } 
  383.     else 
  384.        { 
  385.         dclicktime += ticdup; 
  386.         if (dclicktime > 20) 
  387.            { 
  388.             dclicks = 0; 
  389.             dclickstate = 0; 
  390.            } 
  391.        }
  392.     
  393.     // strafe double click
  394.     bstrafe = mousebuttons[mousebstrafe] || joybuttons[joybstrafe]; 
  395.     if (bstrafe != dclickstate2 && dclicktime2 > 1 ) 
  396.        { 
  397.         dclickstate2 = bstrafe; 
  398.         if (dclickstate2) 
  399.             dclicks2++; 
  400.         if (dclicks2 == 2) 
  401.            { 
  402.             cmd->buttons |= BT_USE; 
  403.             dclicks2 = 0; 
  404.            } 
  405.         else 
  406.            dclicktime2 = 0; 
  407.        } 
  408.     else 
  409.        { 
  410.         dclicktime2 += ticdup; 
  411.         if (dclicktime2 > 20) 
  412.            { 
  413.             dclicks2 = 0; 
  414.             dclickstate2 = 0; 
  415.            } 
  416.        } 
  417.  
  418.     forward += mousey; 
  419.     if (strafe) 
  420.         side += mousex*2; 
  421.     else 
  422.         cmd->angleturn -= mousex*0x8; 
  424.     mousex = mousey = 0;
  425.  
  426.     if (forward > MAXPLMOVE) 
  427.         forward = MAXPLMOVE; 
  428.     else
  429.     if (forward < -MAXPLMOVE) 
  430.         forward = -MAXPLMOVE; 
  431.     if (side > MAXPLMOVE) 
  432.         side = MAXPLMOVE; 
  433.     else
  434.     if (side < -MAXPLMOVE) 
  435.         side = -MAXPLMOVE; 
  436.  
  437.     cmd->forwardmove += forward; 
  438.     cmd->sidemove += side;
  439.     
  440.     // special buttons
  441.     if (sendpause)
  442.        { 
  443.         sendpause = false; 
  444.         cmd->buttons = BT_SPECIAL | BTS_PAUSE; 
  445.        } 
  446.  
  447.     if (sendsave)
  448.        { 
  449.         sendsave = false; 
  450.         cmd->buttons = BT_SPECIAL | BTS_SAVEGAME | (savegameslot << BTS_SAVESHIFT); 
  451.        } 
  452.    } 
  453.  
  455. //
  456. // G_DoLoadLevel 
  457. //
  458. extern  gamestate_t     wipegamestate; 
  459.  
  460. void G_DoLoadLevel (void) 
  461. { 
  462.     int             i; 
  464.     // Set the sky map.
  465.     // First thing, we have a dummy sky texture name,
  466.     //  a flat. The data is in the WAD only because
  467.     //  we look for an actual index, instead of simply
  468.     //  setting one.
  469.     skyflatnum = R_FlatNumForName ( SKYFLATNAME );
  471.     // DOOM determines the sky texture to be used
  472.     // depending on the current episode, and the game version.
  473.     if ( (gamemode == commercial) // Doom II
  474.  || ( gamemode == addon_tnt )
  475.  || ( gamemode == addon_plut ) )
  476.     {
  477. skytexture = R_TextureNumForName ("SKY3");
  478. if (gamemap < 12)
  479.     skytexture = R_TextureNumForName ("SKY1");
  480. else
  481.     if (gamemap < 21)
  482. skytexture = R_TextureNumForName ("SKY2");
  483.     //WriteDebug("Sky set...n");
  484.     }
  486.     levelstarttic = gametic;        // for time calculation
  487.     
  488.     if (wipegamestate == GS_LEVEL) 
  489. wipegamestate = -1;             // force a wipe 
  491.     gamestate = GS_LEVEL; 
  493.     for (i=0 ; i<MAXPLAYERS ; i++) 
  494.     { 
  495. if (playeringame[i] && players[i].playerstate == PST_DEAD) 
  496.     players[i].playerstate = PST_REBORN; 
  497. memset (players[i].frags,0,sizeof(players[i].frags)); 
  498.     } 
  499.  
  500.     //WriteDebug("P_SetupLeveln");
  501.     P_SetupLevel (gameepisode, gamemap, 0, gameskill);    
  502.     displayplayer = consoleplayer; // view the guy you are playing    
  503.     starttime = I_GetTime (); 
  504.     gameaction = ga_nothing; 
  505.     //WriteDebug("Z_CheckHeapn");
  506.     Z_CheckHeap ();
  507.     
  508.     // clear cmd building stuff
  509.     memset (gamekeydown, 0, sizeof(gamekeydown)); 
  510.     joyxmove = joyymove = 0; 
  511.     mousex = mousey = 0; 
  512.     sendpause = sendsave = paused = false; 
  513.     memset (mousebuttons, 0, sizeof(mousebuttons)); 
  514.     memset (joybuttons, 0, sizeof(joybuttons)); 
  515.     //WriteDebug("G_DoLoadLevel donen");
  516.     R_FillBackScreen();
  518. } 
  519.  
  520.  
  521. //
  522. // G_Responder  
  523. // Get info needed to make ticcmd_ts for the players.
  524. // 
  525. boolean G_Responder(event_t* ev) 
  526.    { 
  527.     // allow spy mode changes even during the demo
  528.     if (gamestate == GS_LEVEL && ev->type == ev_keydown && ev->data1 == KEY_F12 && (singledemo || !deathmatch))
  529.        {
  530.         // spy mode 
  531.         do 
  532.            { 
  533.             displayplayer++; 
  534.             if (displayplayer == MAXPLAYERS) 
  535.                 displayplayer = 0; 
  536.             }
  537.         while (!playeringame[displayplayer] && displayplayer != consoleplayer); 
  538.         return true; 
  539.        }
  541.     if ((ev->type == ev_keydown) && (ev->data1 == key_mvert))
  542.        {
  543.         // don't like this - mvert = !mvert;
  544.         if (mvert == 0)
  545.            mvert = 1;
  546.         else
  547.            mvert = 0;
  548.         return true;
  549.        }
  550.     
  551.     // any other key pops up menu if in demos
  552.     if (gameaction == ga_nothing && !singledemo && (demoplayback || gamestate == GS_DEMOSCREEN)) 
  553.        { 
  554.         if (ev->type == ev_keydown || (ev->type == ev_mouse && ev->data1) || (ev->type == ev_joystick && ev->data1))
  555.            {
  556.             // except the console key...
  557.             if ((ev->type != ev_keydown) || (ev->data1 != KEY_CONSOLE))
  558.                {
  559.                 M_StartControlPanel (); 
  560.                 return true; 
  561.                }
  562.            } 
  563.         return false; 
  564.        } 
  565.  
  566.     if (gamestate == GS_LEVEL) 
  567.        { 
  568. #if 0 
  569.         if (devparm && ev->type == ev_keydown && ev->data1 == ';') 
  570.            { 
  571.             G_DeathMatchSpawnPlayer(0); 
  572.             return true; 
  573.            } 
  574. #endif 
  575.         if (HU_Responder (ev)) 
  576.            {
  577.             return true; // chat ate the event 
  578.            }
  579.         if (ST_Responder (ev)) 
  580.            {
  581.             return true; // status window ate it 
  582.            }
  583.         if (AM_Responder (ev)) 
  584.             return true; // automap ate it 
  585.        } 
  586.  
  587.     if (gamestate == GS_FINALE) 
  588.        { 
  589.         if (F_Responder (ev)) 
  590.             return true; // finale ate the event 
  591.        } 
  592.  
  593.     switch (ev->type) 
  594.        { 
  595.         case ev_keydown: 
  596.              if (ev->data1 == KEY_PAUSE) 
  597.                 { 
  598.                  sendpause = true; 
  599.                  return true; 
  600.                 } 
  601.              if (ev->data1 < NUMKEYS) 
  602.                 gamekeydown[ev->data1] = true; 
  603.              return true;    // eat key down events 
  604.  
  605.         case ev_keyup: 
  606.              if (ev->data1 < NUMKEYS) 
  607.                  gamekeydown[ev->data1] = false; 
  608.              return false;   // always let key up events filter down 
  609.  
  610.         case ev_mouse: 
  611.              mousebuttons[0] = ev->data1 & 1; 
  612.              mousebuttons[1] = ev->data1 & 2; 
  613.              mousebuttons[2] = ev->data1 & 4; 
  614.              mousex = ev->data2*(mouseSensitivity+5)/10; 
  615.              mousey = ev->data3*(mouseSensitivity+5)/10; 
  616.              return true;    // eat events 
  617.  
  618.         case ev_joystick: 
  619.              joybuttons[0] = ev->data1 & 1; 
  620.              joybuttons[1] = ev->data1 & 2; 
  621.              joybuttons[2] = ev->data1 & 4; 
  622.              joybuttons[3] = ev->data1 & 8; 
  623.              joyxmove = ev->data2; 
  624.              joyymove = ev->data3; 
  625.              return true;    // eat events 
  626.  
  627.         default: 
  628.              break; 
  629.        } 
  630.  
  631.     return false; 
  632.    } 
  633.  
  634.  
  635.  
  636. //
  637. // G_Ticker
  638. // Make ticcmd_ts for the players.
  639. //
  640. void G_Ticker (void) 
  641. { 
  642.     int i;
  643.     int buf; 
  644.     ticcmd_t* cmd;
  645.     
  646.     // do player reborns if needed
  647.     for (i=0 ; i<MAXPLAYERS ; i++) 
  648. if (playeringame[i] && players[i].playerstate == PST_REBORN) 
  649.        {
  650.         //WriteDebug("Players being "reborn"n");
  651.     G_DoReborn (i);
  652.        }
  653.     
  654.     // do things to change the game state
  655.     while (gameaction != ga_nothing) 
  656.     { 
  657. switch (gameaction) 
  658. { 
  659.   case ga_loadlevel: 
  660.     G_DoLoadLevel (); 
  661.     break; 
  662.   case ga_newgame: 
  663.     G_DoNewGame (); 
  664.     break; 
  665.   case ga_loadgame: 
  666.     G_DoLoadGame (); 
  667.     break; 
  668.   case ga_savegame: 
  669.     G_DoSaveGame (); 
  670.     break; 
  671.   case ga_playdemo: 
  672.          //WriteDebug("Playing demo...n");
  673.          if (demotype == DEMO_I)
  674.          G_DoPlayDemo();
  675.          else
  676.              G_DoPlayDemo_II();
  677.     break; 
  678.   case ga_completed: 
  679.     G_DoCompleted (); 
  680.     break; 
  681.   case ga_victory: 
  682.     F_StartFinale (); 
  683.     break; 
  684.   case ga_worlddone: 
  685.     G_DoWorldDone (); 
  686.     break; 
  687.   case ga_screenshot: 
  688.     M_ScreenShot (); 
  689.     gameaction = ga_nothing; 
  690.     break; 
  691.   case ga_nothing: 
  692.     break; 
  693. } 
  694.     }
  695.     
  696.     // get commands, check consistancy,
  697.     // and build new consistancy check
  698.     buf = (gametic/ticdup)%BACKUPTICS; 
  700.     for (i=0 ; i<MAXPLAYERS ; i++)
  701.     {
  702. if (playeringame[i]) 
  703. { 
  704.     cmd = &players[i].cmd; 
  705.  
  706.     memcpy (cmd, &netcmds[i][buf], sizeof(ticcmd_t)); 
  707.  
  708.     if (demoplayback) 
  709.            {
  710.            //WriteDebug("G_ReadDemoTiccmdn");
  711. G_ReadDemoTiccmd (cmd); 
  712.            }
  713.     if (demorecording) 
  714. G_WriteDemoTiccmd (cmd);
  715.     
  716.     // check for turbo cheats
  717.     if (cmd->forwardmove > TURBOTHRESHOLD 
  718. && !(gametic&31) && ((gametic>>5)&3) == i )
  719.     {
  720. static char turbomessage[80];
  721. extern char *player_names[4];
  722. sprintf (turbomessage, "%s is turbo!",player_names[i]);
  723. players[consoleplayer].message = turbomessage;
  724.     }
  726.     if (netgame && !netdemo && !(gametic%ticdup) ) 
  727.     { 
  728. if (gametic > BACKUPTICS 
  729.     && consistancy[i][buf] != cmd->consistancy) 
  730. { 
  731.     I_Error ("consistency failure (%i should be %i)",
  732.      cmd->consistancy, consistancy[i][buf]); 
  733. } 
  734. if (players[i].mo) 
  735.     consistancy[i][buf] = players[i].mo->x; 
  736. else 
  737.     consistancy[i][buf] = rndindex; 
  738.     } 
  739. }
  740.     }
  741.     
  742.     // check for special buttons
  743.     for (i=0 ; i<MAXPLAYERS ; i++)
  744.     {
  745. if (playeringame[i]) 
  746. { 
  747.     if (players[i].cmd.buttons & BT_SPECIAL) 
  748.     { 
  749. switch (players[i].cmd.buttons & BT_SPECIALMASK) 
  750. { 
  751.   case BTS_PAUSE: 
  752.     paused ^= 1; 
  753.     if (paused) 
  754. S_PauseSound (); 
  755.     else 
  756. S_ResumeSound (); 
  757.     break; 
  758.  
  759.   case BTS_SAVEGAME: 
  760.     if (!savedescription[0]) 
  761. strcpy (savedescription, "NET GAME"); 
  762.     savegameslot =  
  763. (players[i].cmd.buttons & BTS_SAVEMASK)>>BTS_SAVESHIFT; 
  764.     gameaction = ga_savegame; 
  765.     break; 
  766. } 
  767.     } 
  768. }
  769.     }
  771.     // do main actions
  772.     switch (gamestate) 
  773.     { 
  774.       case GS_LEVEL: 
  775.          //WriteDebug("P_Ticker...n");
  776. P_Ticker (); 
  777.          //WriteDebug("ST_Ticker...n");
  778. ST_Ticker (); 
  779.          //WriteDebug("AM_Ticker...n");
  780. AM_Ticker (); 
  781.          //WriteDebug("HU_Ticker...n");
  782. HU_Ticker ();            
  783. break; 
  784.  
  785.       case GS_INTERMISSION: 
  786.          //WriteDebug("WI_Ticker...n");
  787. WI_Ticker (); 
  788. break; 
  789.  
  790.       case GS_FINALE: 
  791.          //WriteDebug("F_Ticker...n");
  792. F_Ticker (); 
  793. break; 
  794.  
  795.       case GS_DEMOSCREEN: 
  796.          //WriteDebug("D_PageTicker...n");
  797. D_PageTicker (); 
  798. break; 
  799.     }        
  800. } 
  801.  
  802.  
  803. //
  804. // PLAYER STRUCTURE FUNCTIONS
  805. // also see P_SpawnPlayer in P_Things
  806. //
  808. //
  809. // G_InitPlayer 
  810. // Called at the start.
  811. // Called by the game initialization functions.
  812. //
  813. void G_InitPlayer (int player) 
  814. { 
  815.     player_t* p; 
  816.  
  817.     // set up the saved info         
  818.     p = &players[player]; 
  819.  
  820.     // clear everything else to defaults 
  821.     G_PlayerReborn (player); 
  822.  
  823. } 
  824.  
  825.  
  827. //
  828. // G_PlayerFinishLevel
  829. // Can when a player completes a level.
  830. //
  831. void G_PlayerFinishLevel (int player) 
  832. { 
  833.     player_t* p; 
  834.  
  835.     p = &players[player]; 
  836.  
  837.     memset (p->powers, 0, sizeof (p->powers)); 
  838.     memset (p->cards, 0, sizeof (p->cards)); 
  839.     p->mo->flags &= ~MF_SHADOW; // cancel invisibility 
  840.     p->extralight = 0; // cancel gun flashes 
  841.     p->fixedcolormap = 0; // cancel ir gogles 
  842.     p->damagecount = 0; // no palette changes 
  843.     p->bonuscount = 0; 
  844. } 
  845.  
  847. //
  848. // G_PlayerReborn
  849. // Called after a player dies 
  850. // almost everything is cleared and initialized 
  851. //
  852. void G_PlayerReborn (int player) 
  853. { 
  854.     player_t* p; 
  855.     int i; 
  856.     int frags[MAXPLAYERS]; 
  857.     int killcount;
  858.     int itemcount;
  859.     int secretcount; 
  860.  
  861.     memcpy (frags,players[player].frags,sizeof(frags)); 
  862.     killcount = players[player].killcount; 
  863.     itemcount = players[player].itemcount; 
  864.     secretcount = players[player].secretcount; 
  865.  
  866.     p = &players[player]; 
  867.     memset (p, 0, sizeof(*p)); 
  868.  
  869.     memcpy (players[player].frags, frags, sizeof(players[player].frags)); 
  870.     players[player].killcount = killcount; 
  871.     players[player].itemcount = itemcount; 
  872.     players[player].secretcount = secretcount; 
  873.  
  874.     p->usedown = p->attackdown = true; // don't do anything immediately 
  875.     p->playerstate = PST_LIVE;       
  876.     p->health = MAXHEALTH; 
  877.     p->readyweapon = p->pendingweapon = wp_pistol; 
  878.     p->weaponowned[wp_fist] = true; 
  879.     p->weaponowned[wp_pistol] = true; 
  880.     p->ammo[am_clip] = 50; 
  881.  
  882.     for (i=0 ; i<NUMAMMO ; i++) 
  883. p->maxammo[i] = maxammo[i]; 
  884.  
  885. }
  887. //
  888. // G_CheckSpot  
  889. // Returns false if the player cannot be respawned
  890. // at the given mapthing_t spot  
  891. // because something is occupying it 
  892. //
  893. void P_SpawnPlayer (mapthing_t* mthing); 
  894.  
  895. boolean
  896. G_CheckSpot
  897. ( int playernum,
  898.   mapthing_t* mthing ) 
  899. { 
  900.     fixed_t x;
  901.     fixed_t y; 
  902.     subsector_t* ss; 
  903.     unsigned an; 
  904.     mobj_t* mo; 
  905.     int i;
  907.     if (players[playernum].mo == NULL)
  908.     {
  909. // first spawn of level, before corpses
  910. for (i=0 ; i<playernum ; i++)
  911.        {
  912.         if (players[i].mo != NULL)
  913.            {
  914.         if (players[i].mo->x == mthing->x << FRACBITS && players[i].mo->y == mthing->y << FRACBITS)
  915.                {
  916.                 return false;
  917.                }
  918.            }
  919.        }
  920. return true;
  921.     }
  923.     x = mthing->x << FRACBITS; 
  924.     y = mthing->y << FRACBITS; 
  926.     if (!P_CheckPosition (players[playernum].mo, x, y) ) 
  927. return false; 
  928.  
  929.     // flush an old corpse if needed 
  930.     if (bodyqueslot >= BODYQUESIZE) 
  931. P_RemoveMobj (bodyque[bodyqueslot%BODYQUESIZE]); 
  932.     bodyque[bodyqueslot%BODYQUESIZE] = players[playernum].mo; 
  933.     bodyqueslot++; 
  935.     // spawn a teleport fog 
  936.     ss = R_PointInSubsector (x,y); 
  937.     an = ( ANG45 * (mthing->angle/45) ) >> ANGLETOFINESHIFT; 
  938.  
  939.     mo = P_SpawnMobj (x+20*finecosine[an], y+20*finesine[an] 
  940.       , ss->sector->floorheight 
  941.       , MT_TFOG); 
  942.  
  943.     if (players[consoleplayer].viewz != 1) 
  944. S_StartSound (mo, sfx_telept); // don't start sound on first frame 
  945.  
  946.     return true; 
  947. } 
  950. //
  951. // G_DeathMatchSpawnPlayer 
  952. // Spawns a player at one of the random death match spots 
  953. // called at level load and each death 
  954. //
  955. void G_DeathMatchSpawnPlayer (int playernum) 
  956. { 
  957.     int             i,j; 
  958.     int selections; 
  959.  
  960.     selections = deathmatch_p - deathmatchstarts; 
  961.     if (selections < 4) 
  962.        {
  963.     I_Error ("Only %i deathmatch spots, 4 required", selections); 
  964.        }
  965.  
  966.     for (j=0 ; j<20 ; j++) 
  967.     { 
  968. i = P_Random() % selections; 
  969. if (G_CheckSpot (playernum, &deathmatchstarts[i]) ) 
  970. { 
  971.     deathmatchstarts[i].type = playernum+1; 
  972.         //WriteDebug("Fn");
  973.     P_SpawnPlayer (&deathmatchstarts[i]); 
  974.     return; 
  975. } 
  976.     } 
  977.  
  978.     // no good spot, so the player will probably get stuck 
  979.     //WriteDebug("Yn");
  980.     P_SpawnPlayer (&playerstarts[playernum]); 
  981.     //WriteDebug("Zn");
  982. } 
  984. //
  985. // G_DoReborn 
  986. // 
  987. void G_DoReborn (int playernum) 
  988. { 
  989.     int                             i; 
  990.  
  991.     if (!netgame)
  992.     {
  993. // reload the level from scratch
  994. gameaction = ga_loadlevel;  
  995.     }
  996.     else 
  997.     {
  998. // respawn at the start
  1000. // first dissasociate the corpse 
  1001. players[playernum].mo->player = NULL;   
  1002.  
  1003. // spawn at random spot if in death match 
  1004. if (deathmatch) 
  1005. { 
  1006.     G_DeathMatchSpawnPlayer (playernum); 
  1007.     return; 
  1008. } 
  1009.  
  1010. if (G_CheckSpot (playernum, &playerstarts[playernum]) ) 
  1011. { 
  1012.     P_SpawnPlayer (&playerstarts[playernum]); 
  1013.     return; 
  1014. }
  1016. // try to spawn at one of the other players spots 
  1017. for (i=0 ; i<MAXPLAYERS ; i++)
  1018. {
  1019.     if (G_CheckSpot (playernum, &playerstarts[i]) ) 
  1020.     { 
  1021. playerstarts[i].type = playernum+1; // fake as other player 
  1022. P_SpawnPlayer (&playerstarts[i]); 
  1023. playerstarts[i].type = i+1; // restore 
  1024. return; 
  1025.     }     
  1026.     // he's going to be inside something.  Too bad.
  1027. }
  1028. P_SpawnPlayer (&playerstarts[playernum]); 
  1029.     } 
  1030. } 
  1031.  
  1032.  
  1033. void G_ScreenShot (void) 
  1034. { 
  1035.     gameaction = ga_screenshot; 
  1036. } 
  1037.  
  1040. // DOOM Par Times
  1041. int pars[4][10] = 
  1042. { 
  1043.     {0}, 
  1044.     {0,30,75,120,90,165,180,180,30,165}, 
  1045.     {0,90,90,90,120,90,360,240,30,170}, 
  1046.     {0,90,45,90,150,90,90,165,30,135} 
  1047. }; 
  1049. // DOOM II Par Times
  1050. int cpars[32] =
  1051. {
  1052.     30,90,120,120,90,150,120,120,270,90, //  1-10
  1053.     210,150,150,150,210,150,420,150,210,150, // 11-20
  1054.     240,150,180,150,150,300,330,420,300,180, // 21-30
  1055.     120,30 // 31-32
  1056. };
  1057.  
  1059. //
  1060. // G_DoCompleted 
  1061. //
  1062. boolean secretexit; 
  1063. extern char* pagename; 
  1064.  
  1065. void G_ExitLevel (void) 
  1066. { 
  1067.     secretexit = false; 
  1068.     gameaction = ga_completed; 
  1069. } 
  1071. // Here's for the german edition.
  1072. void G_SecretExitLevel (void) 
  1073. { 
  1074.     // IF NO WOLF3D LEVELS, NO SECRET EXIT!
  1075.     if ( (gamemode == commercial)
  1076.       && (W_CheckNumForName("map31")<0))
  1077. secretexit = false;
  1078.     else
  1079. secretexit = true; 
  1080.     gameaction = ga_completed; 
  1081. } 
  1082.  
  1083. void G_DoCompleted (void) 
  1084. { 
  1085.     int             i; 
  1086.  
  1087.     gameaction = ga_nothing; 
  1088.  
  1089.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1090. if (playeringame[i]) 
  1091.     G_PlayerFinishLevel (i);        // take away cards and stuff 
  1092.  
  1093.     if (automapactive) 
  1094. AM_Stop (); 
  1096.     if ( gamemode != commercial)
  1097. switch(gamemap)
  1098. {
  1099.   case 8:
  1100.     gameaction = ga_victory;
  1101.     return;
  1102.   case 9: 
  1103.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1104. players[i].didsecret = true; 
  1105.     break;
  1106. }
  1108. //#if 0  Hmmm - why?
  1109.     if ( (gamemap == 8)
  1110.  && (gamemode != commercial) ) 
  1111.     {
  1112. // victory 
  1113. gameaction = ga_victory; 
  1114. return; 
  1115.     } 
  1116.  
  1117.     if ( (gamemap == 9)
  1118.  && (gamemode != commercial) ) 
  1119.     {
  1120. // exit secret level 
  1121. for (i=0 ; i<MAXPLAYERS ; i++) 
  1122.     players[i].didsecret = true; 
  1123.     } 
  1124. //#endif
  1125.     
  1126.  
  1127.     wminfo.didsecret = players[consoleplayer].didsecret; 
  1128.     wminfo.epsd = gameepisode -1; 
  1129.     wminfo.last = gamemap -1;
  1130.     
  1131.     // wminfo.next is 0 biased, unlike gamemap
  1132.     if ( gamemode == commercial)
  1133.     {
  1134. if (secretexit)
  1135.     switch(gamemap)
  1136.     {
  1137.       case 15: wminfo.next = 30; break;
  1138.       case 31: wminfo.next = 31; break;
  1139.     }
  1140. else
  1141.     switch(gamemap)
  1142.     {
  1143.       case 31:
  1144.       case 32: wminfo.next = 15; break;
  1145.       default: wminfo.next = gamemap;
  1146.     }
  1147.     }
  1148.     else
  1149.     {
  1150. if (secretexit) 
  1151.     wminfo.next = 8;  // go to secret level 
  1152. else if (gamemap == 9) 
  1153. {
  1154.     // returning from secret level 
  1155.     switch (gameepisode) 
  1156.     { 
  1157.       case 1: 
  1158. wminfo.next = 3; 
  1159. break; 
  1160.       case 2: 
  1161. wminfo.next = 5; 
  1162. break; 
  1163.       case 3: 
  1164. wminfo.next = 6; 
  1165. break; 
  1166.       case 4:
  1167. wminfo.next = 2;
  1168. break;
  1169.     }                
  1170. } 
  1171. else 
  1172.     wminfo.next = gamemap;          // go to next level 
  1173.     }
  1174.  
  1175.     wminfo.maxkills = totalkills; 
  1176.     wminfo.maxitems = totalitems; 
  1177.     wminfo.maxsecret = totalsecret; 
  1178.     wminfo.maxfrags = 0; 
  1179.     if ( gamemode == commercial )
  1180. wminfo.partime = 35*cpars[gamemap-1]; 
  1181.     else
  1182. wminfo.partime = 35*pars[gameepisode][gamemap]; 
  1183.     wminfo.pnum = consoleplayer; 
  1184.  
  1185.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1186.     { 
  1187. wminfo.plyr[i].in = playeringame[i]; 
  1188. wminfo.plyr[i].skills = players[i].killcount; 
  1189. wminfo.plyr[i].sitems = players[i].itemcount; 
  1190. wminfo.plyr[i].ssecret = players[i].secretcount; 
  1191. wminfo.plyr[i].stime = leveltime; 
  1192. memcpy (wminfo.plyr[i].frags, players[i].frags 
  1193. , sizeof(wminfo.plyr[i].frags)); 
  1194.     } 
  1195.  
  1196.     gamestate = GS_INTERMISSION; 
  1197.     viewactive = false; 
  1198.     automapactive = false; 
  1199.  
  1200.     if (statcopy)
  1201. memcpy (statcopy, &wminfo, sizeof(wminfo));
  1203.     WI_Start (&wminfo); 
  1204. } 
  1207. //
  1208. // G_WorldDone 
  1209. //
  1210. void G_WorldDone (void) 
  1211. { 
  1212.     gameaction = ga_worlddone; 
  1214.     if (secretexit) 
  1215. players[consoleplayer].didsecret = true; 
  1217.     if ( gamemode == commercial )
  1218.     {
  1219. switch (gamemap)
  1220. {
  1221.   case 15:
  1222.   case 31:
  1223.     if (!secretexit)
  1224. break;
  1225.   case 6:
  1226.   case 11:
  1227.   case 20:
  1228.   case 30:
  1229.     F_StartFinale ();
  1230.     break;
  1231. }
  1232.     }
  1233. } 
  1234.  
  1235. void G_DoWorldDone (void) 
  1236. {        
  1237.     gamestate = GS_LEVEL; 
  1238.     gamemap = wminfo.next+1; 
  1239.     G_DoLoadLevel (); 
  1240.     gameaction = ga_nothing; 
  1241.     viewactive = true; 
  1242. } 
  1243.  
  1246. //
  1247. // G_InitFromSavegame
  1248. // Can be called by the startup code or the menu task. 
  1249. //
  1250. extern boolean setsizeneeded;
  1251. void R_ExecuteSetViewSize (void);
  1253. char savename[256];
  1255. void G_LoadGame (char* name) 
  1256. { 
  1257.     strcpy (savename, name); 
  1258.     gameaction = ga_loadgame; 
  1259. } 
  1260.  
  1261. #define VERSIONSIZE 16 
  1264. void G_DoLoadGame (void) 
  1265. { 
  1266.     int length; 
  1267.     int i; 
  1268.     int a,b,c; 
  1269.     char vcheck[VERSIONSIZE]; 
  1270.  
  1271.     gameaction = ga_nothing; 
  1272.  
  1273.     length = M_ReadFile (savename, &savebuffer); 
  1274.     save_p = savebuffer + SAVESTRINGSIZE;
  1275.     
  1276.     // skip the description field 
  1277.     memset (vcheck,0,sizeof(vcheck)); 
  1278.     sprintf (vcheck,"version %i",VERSION); 
  1279.     if (strcmp (save_p, vcheck)) 
  1280. return; // bad version 
  1281.     save_p += VERSIONSIZE; 
  1282.  
  1283.     gameskill = *save_p++; 
  1284.     gameepisode = *save_p++; 
  1285.     gamemap = *save_p++; 
  1286.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1287. playeringame[i] = *save_p++; 
  1289.     // load a base level 
  1290.     G_InitNew (gameskill, gameepisode, gamemap);
  1291.  
  1292.     // get the times 
  1293.     a = *save_p++; 
  1294.     b = *save_p++; 
  1295.     c = *save_p++; 
  1296.     leveltime = (a<<16) + (b<<8) + c; 
  1297.  
  1298.     // dearchive all the modifications
  1299.     P_UnArchivePlayers (); 
  1300.     P_UnArchiveWorld (); 
  1301.     P_UnArchiveThinkers (); 
  1302.     P_UnArchiveSpecials (); 
  1303.  
  1304.     if (*save_p != 0x1d) 
  1305. I_Error ("Bad savegame");
  1306.     
  1307.     // done 
  1308.     Z_Free (savebuffer); 
  1310.     if (setsizeneeded)
  1311. R_ExecuteSetViewSize ();
  1313.     // draw the pattern into the back screen
  1314.     WriteDebug("Calling R_FileBackScreen...n");
  1315.     R_FillBackScreen();
  1317.     WriteDebug("Calling R_DrawViewBorder...n");
  1318.     R_DrawViewBorder();
  1319. } 
  1320.  
  1322. //
  1323. // G_SaveGame
  1324. // Called by the menu task.
  1325. // Description is a 24 byte text string 
  1326. //
  1327. void
  1328. G_SaveGame
  1329. ( int slot,
  1330.   char* description ) 
  1331. { 
  1332.     savegameslot = slot; 
  1333.     strcpy (savedescription, description); 
  1334.     sendsave = true; 
  1335. } 
  1336.  
  1337. void G_DoSaveGame (void) 
  1338. { 
  1339.     char name[100]; 
  1340.     char name2[VERSIONSIZE]; 
  1341.     char* description; 
  1342.     int length; 
  1343.     int i; 
  1345.     if (M_CheckParm("-cdrom"))
  1346. sprintf(name,"c:\doomdata\"SAVEGAMENAME"%d.dsg",savegameslot);
  1347.     else
  1348. sprintf (name,SAVEGAMENAME"%d.dsg",savegameslot); 
  1349.     description = savedescription; 
  1350.  
  1351.     save_p = savebuffer = screens[1]+0x4000; 
  1352.  
  1353.     memcpy (save_p, description, SAVESTRINGSIZE); 
  1354.     save_p += SAVESTRINGSIZE; 
  1355.     memset (name2,0,sizeof(name2)); 
  1356.     sprintf (name2,"version %i",VERSION); 
  1357.     memcpy (save_p, name2, VERSIONSIZE); 
  1358.     save_p += VERSIONSIZE; 
  1359.  
  1360.     *save_p++ = gameskill; 
  1361.     *save_p++ = gameepisode; 
  1362.     *save_p++ = gamemap; 
  1363.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1364. *save_p++ = playeringame[i]; 
  1365.     *save_p++ = leveltime>>16; 
  1366.     *save_p++ = leveltime>>8; 
  1367.     *save_p++ = leveltime; 
  1368.  
  1369.     P_ArchivePlayers (); 
  1370.     P_ArchiveWorld (); 
  1371.     P_ArchiveThinkers (); 
  1372.     P_ArchiveSpecials (); 
  1373.  
  1374.     *save_p++ = 0x1d; // consistancy marker 
  1375.  
  1376.     length = save_p - savebuffer; 
  1377.     if (length > SAVEGAMESIZE) 
  1378. I_Error ("Savegame buffer overrun"); 
  1379.     M_WriteFile (name, savebuffer, length); 
  1380.     gameaction = ga_nothing; 
  1381.     savedescription[0] = 0;  
  1382.  
  1383.     players[consoleplayer].message = GGSAVED; 
  1385.     // draw the pattern into the back screen
  1386.     R_FillBackScreen ();
  1387. } 
  1388.  
  1390. //
  1391. // G_InitNew
  1392. // Can be called by the startup code or the menu task,
  1393. // consoleplayer, displayplayer, playeringame[] should be set. 
  1394. //
  1395. skill_t d_skill; 
  1396. int     d_episode; 
  1397. int     d_map; 
  1398.  
  1399. void
  1400. G_DeferedInitNew
  1401. ( skill_t skill,
  1402.   int episode,
  1403.   int map) 
  1404. { 
  1405.     d_skill = skill; 
  1406.     d_episode = episode; 
  1407.     d_map = map; 
  1408.     gameaction = ga_newgame; 
  1409. } 
  1412. void G_DoNewGame (void) 
  1413. {
  1414.     demoplayback = false; 
  1415.     netdemo = false;
  1416.     netgame = false;
  1417.     deathmatch = false;
  1418.     playeringame[1] = playeringame[2] = playeringame[3] = 0;
  1419.     respawnparm = false;
  1420.     fastparm = false;
  1421.     nomonsters = false;
  1422.     consoleplayer = 0;
  1423.     G_InitNew (d_skill, d_episode, d_map); 
  1424.     gameaction = ga_nothing; 
  1425. } 
  1427. // The sky texture to be used instead of the F_SKY1 dummy.
  1428. extern  int skytexture; 
  1431. void
  1432. G_InitNew
  1433. ( skill_t skill,
  1434.   int episode,
  1435.   int map ) 
  1436. { 
  1437.     int             i; 
  1438.  
  1439.     if (paused) 
  1440.     { 
  1441. paused = false; 
  1442. S_ResumeSound (); 
  1443.     } 
  1446.     if (skill > sk_nightmare) 
  1447. skill = sk_nightmare;
  1450.     // This was quite messy with SPECIAL and commented parts.
  1451.     // Supposedly hacks to make the latest edition work.
  1452.     // It might not work properly.
  1453.     if (episode < 1)
  1454.       episode = 1; 
  1456.     if ( gamemode == retail )
  1457.     {
  1458.       if (episode > 4)
  1459. episode = 4;
  1460.     }
  1461.     else if ( gamemode == shareware )
  1462.     {
  1463.       if (episode > 1) 
  1464.    episode = 1; // only start episode 1 on shareware
  1465.     }  
  1466.     else
  1467.     {
  1468.       if (episode > 3)
  1469. episode = 3;
  1470.     }
  1471.     
  1473.   
  1474.     if (map < 1) 
  1475. map = 1;
  1476.     
  1477.     if ( (map > 9)
  1478.  && ( gamemode != commercial) )
  1479.       map = 9; 
  1480.  
  1481.     //WriteDebug("M_ClearRandomn");
  1482.     M_ClearRandom (); 
  1483.  
  1484.     if (skill == sk_nightmare || respawnparm )
  1485. respawnmonsters = true;
  1486.     else
  1487. respawnmonsters = false;
  1489.     if (fastparm || (skill == sk_nightmare && gameskill != sk_nightmare) )
  1490.     { 
  1491. for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++) 
  1492.     states[i].tics >>= 1; 
  1493. mobjinfo[MT_BRUISERSHOT].speed = 20*FRACUNIT; 
  1494. mobjinfo[MT_HEADSHOT].speed = 20*FRACUNIT; 
  1495. mobjinfo[MT_TROOPSHOT].speed = 20*FRACUNIT; 
  1496.     } 
  1497.     else if (skill != sk_nightmare && gameskill == sk_nightmare) 
  1498.     { 
  1499. for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++) 
  1500.     states[i].tics <<= 1; 
  1501. mobjinfo[MT_BRUISERSHOT].speed = 15*FRACUNIT; 
  1502. mobjinfo[MT_HEADSHOT].speed = 10*FRACUNIT; 
  1503. mobjinfo[MT_TROOPSHOT].speed = 10*FRACUNIT; 
  1504.     } 
  1505.  
  1506.  
  1507.     // force players to be initialized upon first level load         
  1508.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1509. players[i].playerstate = PST_REBORN; 
  1510.  
  1511.     usergame = true;                // will be set false if a demo 
  1512.     paused = false; 
  1513.     demoplayback = false; 
  1514.     automapactive = false; 
  1515.     viewactive = true; 
  1516.     gameepisode = episode; 
  1517.     gamemap = map; 
  1518.     gameskill = skill; 
  1519.  
  1520.     viewactive = true;
  1521.     
  1522.     // set the sky map for the episode
  1523.     if ( gamemode == commercial)
  1524.     {
  1525. skytexture = R_TextureNumForName ("SKY3");
  1526. if (gamemap < 12)
  1527.     skytexture = R_TextureNumForName ("SKY1");
  1528. else
  1529.     if (gamemap < 21)
  1530. skytexture = R_TextureNumForName ("SKY2");
  1531.     }
  1532.     else
  1533. switch (episode) 
  1534. { 
  1535.   case 1: 
  1536.     skytexture = R_TextureNumForName ("SKY1"); 
  1537.     break; 
  1538.   case 2: 
  1539.     skytexture = R_TextureNumForName ("SKY2"); 
  1540.     break; 
  1541.   case 3: 
  1542.     skytexture = R_TextureNumForName ("SKY3"); 
  1543.     break; 
  1544.   case 4: // Special Edition sky
  1545.     skytexture = R_TextureNumForName ("SKY4");
  1546.     break;
  1547. } 
  1548.  
  1549.     //WriteDebug("G_DoLoadLeveln");
  1550.     setsizeneeded = TRUE;
  1551.     G_DoLoadLevel (); 
  1552. } 
  1553.  
  1555. //
  1556. // DEMO RECORDING 
  1557. // 
  1558. #define DEMOMARKER 0x80
  1561. void G_ReadDemoTiccmd (ticcmd_t* cmd) 
  1562. { 
  1563.     if (*demo_p == DEMOMARKER) 
  1564.     {
  1565. // end of demo data stream 
  1566. G_CheckDemoStatus (); 
  1567. return; 
  1568.     } 
  1569.     cmd->forwardmove = ((signed char)*demo_p++); 
  1570.     cmd->sidemove = ((signed char)*demo_p++); 
  1571.     cmd->angleturn = ((unsigned char)*demo_p++)<<8; 
  1572.     cmd->buttons = (unsigned char)*demo_p++; 
  1573. } 
  1576. void G_WriteDemoTiccmd (ticcmd_t* cmd) 
  1577. { 
  1578.     if (gamekeydown[KEY_Q])           // press q to end demo recording 
  1579. G_CheckDemoStatus (); 
  1580.     *demo_p++ = cmd->forwardmove; 
  1581.     *demo_p++ = cmd->sidemove; 
  1582.     *demo_p++ = (cmd->angleturn+128)>>8; 
  1583.     *demo_p++ = cmd->buttons; 
  1584.     demo_p -= 4; 
  1585.     if (demo_p > demoend - 16)
  1586.     {
  1587. // no more space 
  1588. G_CheckDemoStatus (); 
  1589. return; 
  1590.     } 
  1592.     G_ReadDemoTiccmd (cmd);         // make SURE it is exactly the same 
  1593. } 
  1594.  
  1595.  
  1596.  
  1597. //
  1598. // G_RecordDemo 
  1599. // 
  1600. void G_RecordDemo (char* name) 
  1601. { 
  1602.     int             i; 
  1603.     int maxsize;
  1605.     usergame = false; 
  1606.     strcpy (demoname, name); 
  1607.     strcat (demoname, ".lmp"); 
  1608.     sprintf(MsgText, "Record demo : %sn", demoname);
  1609.     WriteDebug(MsgText);
  1610.     maxsize = 0x20000;
  1611.     i = M_CheckParm ("-maxdemo");
  1612.     if (i && i<myargc-1)
  1613. maxsize = atoi(myargv[i+1])*1024;
  1614.     demobuffer = Z_Malloc (maxsize,PU_STATIC,NULL);
  1615.     demoend = demobuffer + maxsize;
  1617.     demotype = DEMO_I;
  1619.     demorecording = true; 
  1620. } 
  1622. //
  1623. // New Demo Recording stuff...
  1624. // 
  1625. // Doom demos assume that the demo starts at the
  1626. // beginning of a level and that the normal level
  1627. // state will apply - any deviation from that
  1628. // and playback will be out of "sync".  Synchronization
  1629. // information must be written out to the demo file
  1630. // so that the state of the entire game is saved
  1631. // Probably it should use the save game function to
  1632. // save the game state then save the demo data after
  1633. // it... A new extension of "DEM" should also be used.
  1634. //
  1635. // G_RecordDemo_II
  1636. // 
  1637. void G_RecordDemo_II (char* name) 
  1638. { 
  1639.     int             i; 
  1640.     int maxsize;
  1642.     usergame = false; 
  1643.     strcpy (demoname, name); 
  1644.     strcat (demoname, ".dem"); 
  1645.     sprintf(MsgText, "Record demo II : %sn", demoname);
  1646.     WriteDebug(MsgText);
  1647.     maxsize = 0x20000;
  1648.     i = M_CheckParm ("-maxdemo");
  1649.     if (i && i < myargc-1)
  1650.     maxsize = atoi(myargv[i+1])*1024;
  1651.     demobuffer = Z_Malloc (maxsize,PU_STATIC,NULL);
  1652.     demoend = demobuffer + maxsize;
  1654.     demotype = DEMO_II;
  1656.     demorecording = true; 
  1657. } 
  1658.  
  1659. void G_BeginRecording_II (void) 
  1660.    { 
  1661.     char name2[VERSIONSIZE]; 
  1662.     char    description[] = "WINDOOM: DEMO VERSION II";
  1663.     int length; 
  1664.     int i; 
  1666.     save_p = demobuffer;
  1667.  
  1668.     memcpy (save_p, description, SAVESTRINGSIZE);
  1669.     save_p += SAVESTRINGSIZE; 
  1670.     memset (name2,0,sizeof(name2)); 
  1671.     sprintf (name2,"version %i",VERSION); 
  1672.     memcpy (save_p, name2, VERSIONSIZE); 
  1673.     save_p += VERSIONSIZE; 
  1674.  
  1675.     *save_p++ = gameskill;
  1676.     *save_p++ = gameepisode;
  1677.     *save_p++ = gamemap;
  1678.     for (i = 0; i < MAXPLAYERS; i++)
  1679.     *save_p++ = playeringame[i];
  1681.     *save_p++ = deathmatch;
  1682.     *save_p++ = respawnparm;
  1683.     *save_p++ = fastparm;
  1684.     *save_p++ = nomonsters;
  1685.     *save_p++ = consoleplayer;
  1686.  
  1687.     *save_p++ = leveltime >> 16;
  1688.     *save_p++ = leveltime >> 8;
  1689.     *save_p++ = leveltime;
  1690.  
  1691.     P_ArchivePlayers();
  1692.     P_ArchiveWorld();
  1693.     P_ArchiveThinkers();
  1694.     P_ArchiveSpecials();
  1695.  
  1696.     *save_p++ = 0x1d; // consistancy marker 
  1697.  
  1698.     length = save_p - demobuffer;
  1699.     if (length > SAVEGAMESIZE) 
  1700.     I_Error ("Savegame buffer overrun"); 
  1701.     M_WriteFile (demoname, demobuffer, length);
  1703.     gameaction = ga_nothing;
  1704.  
  1705.     demo_p = demobuffer;
  1707. //    *demo_p++ = VERSION;
  1708. //    *demo_p++ = gameskill; 
  1709. //    *demo_p++ = gameepisode; 
  1710. //    *demo_p++ = gamemap; 
  1711. /*
  1712.     *demo_p++ = deathmatch;
  1713.     *demo_p++ = respawnparm;
  1714.     *demo_p++ = fastparm;
  1715.     *demo_p++ = nomonsters;
  1716.     *demo_p++ = consoleplayer;
  1717. */
  1718. //    for (i = 0; i < MAXPLAYERS; i++) 
  1719. //       {
  1720. //     *demo_p++ = playeringame[i];
  1721. //       }
  1723.     // draw the pattern into the back screen
  1724.     R_FillBackScreen ();
  1725.    } 
  1726.  
  1727.  
  1728. void G_BeginRecording (void) 
  1729. { 
  1730.     int             i; 
  1732.     demo_p = demobuffer;
  1734.     *demo_p++ = VERSION;
  1735.     *demo_p++ = gameskill; 
  1736.     *demo_p++ = gameepisode; 
  1737.     *demo_p++ = gamemap; 
  1738.     *demo_p++ = deathmatch; 
  1739.     *demo_p++ = respawnparm;
  1740.     *demo_p++ = fastparm;
  1741.     *demo_p++ = nomonsters;
  1742.     *demo_p++ = consoleplayer;
  1743.  
  1744.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1745. *demo_p++ = playeringame[i];   
  1747.     demotype = DEMO_I;
  1749. } 
  1750.  
  1752. //
  1753. // G_PlayDemo 
  1754. //
  1756. int access( const char *path, int mode );
  1758. char* defdemoname; 
  1759.  
  1760. boolean G_DeferedPlayDemo_II (char* name)
  1761.    { 
  1762.     static char demofilename[128];
  1763.     sprintf(demofilename, "%s.dem", name);
  1764.     if (access(demofilename, 0) != 0)
  1765.         return false;
  1766.     sprintf(MsgText, "-playdemo2: %sn", demofilename);
  1767.     WriteDebug(MsgText);
  1768.     defdemoname = demofilename;
  1769.     gameaction = ga_playdemo;
  1770.     demotype = DEMO_II;
  1771.     return true;
  1772. } 
  1773.  
  1774. void G_DoPlayDemo_II(void) 
  1775.    { 
  1776.     int length; 
  1777.     int i; 
  1778.     int a,b,c; 
  1779.     char vcheck[VERSIONSIZE]; 
  1780.     skill_t skill; 
  1781.     int     episode, map, dversion, tversion;
  1783.     demotype = DEMO_II;
  1785.     gameaction = ga_nothing;
  1787.     sprintf(MsgText, "Playing demo II : %sn", defdemoname);
  1788.     WriteDebug(MsgText);
  1789.     length = M_GetFileSize(defdemoname);
  1790.     demobuffer = (unsigned char *)malloc(length);
  1791.     demoend = demobuffer + length;
  1793.     length = M_ReadFile(defdemoname, &demobuffer);
  1794.     save_p = demobuffer + SAVESTRINGSIZE;
  1795.     
  1796.     // skip the description field 
  1797.     memset (vcheck,0,sizeof(vcheck)); 
  1798.     sprintf (vcheck,"version %i",VERSION); 
  1799.     if (strcmp (save_p, vcheck)) 
  1800.         return; // bad version 
  1801.     save_p += VERSIONSIZE; 
  1802.  
  1803.     gameskill = *save_p++;
  1804.     gameepisode = *save_p++;
  1805.     gamemap = *save_p++;
  1806.     for (i = 0; i < MAXPLAYERS; i++)
  1807.        playeringame[i] = *save_p++; 
  1809.     deathmatch = *save_p++;
  1810.     respawnparm = *save_p++;
  1811.     fastparm = *save_p++;
  1812.     nomonsters = *save_p++;
  1813.     consoleplayer = *save_p++;
  1815. //    for (i=0 ; i<MAXPLAYERS ; i++)
  1816. //       playeringame[i] = *demo_p++;
  1817.     if (playeringame[1]) 
  1818.     { 
  1819. netgame = true; 
  1820. netdemo = true; 
  1821.     }
  1823.     // load a base level 
  1824.     G_InitNew (gameskill, gameepisode, gamemap);
  1825.  
  1826.     // get the times 
  1827.     a = *save_p++;
  1828.     b = *save_p++;
  1829.     c = *save_p++;
  1830.     leveltime = (a << 16) + (b << 8) + c;
  1831.  
  1832.     // dearchive all the modifications
  1833.     P_UnArchivePlayers (); 
  1834.     P_UnArchiveWorld (); 
  1835.     P_UnArchiveThinkers (); 
  1836.     P_UnArchiveSpecials (); 
  1837.  
  1838.     if (*save_p++ != 0x1d) 
  1839.     I_Error ("Bad savegame");
  1840.     
  1841.     // done 
  1842. //    Z_Free (savebuffer);
  1844.     if (setsizeneeded)
  1845.     R_ExecuteSetViewSize();
  1847.     // draw the pattern into the back screen
  1848.     WriteDebug("Calling R_FillBackScreen...n");
  1849.     R_FillBackScreen();
  1851.     WriteDebug("Calling R_DrawViewBorder...n");
  1852.     R_DrawViewBorder();
  1854. //    tversion = VERSION;
  1855. //    gameaction = ga_nothing; 
  1856. //    demobuffer = demo_p = W_CacheLumpName(defdemoname, PU_STATIC);
  1857. //    if (demobuffer == NULL)
  1858. //       {
  1859. //        sprintf(MsgText,"Demo %s is not in the WAD...n", defdemoname);
  1860. //        WriteDebug(MsgText);
  1861. //        gameaction = ga_nothing;
  1862. //        return;
  1863. //       }
  1865.     demo_p = save_p;
  1866. /*
  1868.     dversion = *demo_p;
  1869.     if ( *demo_p++ != tversion)
  1870.     {
  1871.       sprintf(MsgText, "Demo version : %d.%d Game version : %d.%dn",
  1872.               dversion/100, dversion %100, VERSION/100, VERSION%100);
  1873.       WriteDebug(MsgText);
  1874.       gameaction = ga_nothing;
  1875.       return;
  1876.     }
  1877. */
  1879. //    skill = *demo_p++;
  1880. //    episode = *demo_p++;
  1881. //    map = *demo_p++;
  1882. /*
  1883.     deathmatch = *demo_p++;
  1884.     respawnparm = *demo_p++;
  1885.     fastparm = *demo_p++;
  1886.     nomonsters = *demo_p++;
  1887.     consoleplayer = *demo_p++;
  1888. //    for (i=0 ; i<MAXPLAYERS ; i++)
  1889. //       playeringame[i] = *demo_p++;
  1890.     if (playeringame[1]) 
  1891.     { 
  1892. netgame = true; 
  1893. netdemo = true; 
  1894.     }
  1895.     // don't spend a lot of time in loadlevel 
  1896. //    precache = false;
  1897. //    G_InitNew (skill, episode, map); 
  1898. //    precache = true; 
  1899. */
  1901.     usergame = false;
  1902.     demoplayback = true;
  1903. } 
  1905. void G_DeferedPlayDemo (char* name) 
  1906. { 
  1907.     sprintf(MsgText, "-playdemo: %sn", name);
  1908.     WriteDebug(MsgText);
  1909.     defdemoname = name;
  1910.     gameaction = ga_playdemo;
  1911.     demotype = DEMO_I;
  1912. } 
  1913.  
  1914. void G_DoPlayDemo (void) 
  1915. { 
  1916.     skill_t skill; 
  1917.     int             i, episode, map, dversion, tversion;
  1918.  
  1919.     demotype = DEMO_I;
  1921.     tversion = VERSION;
  1922.     gameaction = ga_nothing; 
  1923.     demobuffer = demo_p = W_CacheLumpName(defdemoname, PU_STATIC);
  1924.     if (demobuffer == NULL)
  1925.        {
  1926.         sprintf(MsgText,"Demo %s is not in the WAD...n", defdemoname);
  1927.         WriteDebug(MsgText);
  1928.         gameaction = ga_nothing;
  1929.         return;
  1930.        }
  1932.     dversion = *demo_p;
  1933.     if ( *demo_p++ != tversion)
  1934.     {
  1935.       sprintf(MsgText, "Demo version : %d.%d Game version : %d.%dn",
  1936.               dversion/100, dversion %100, VERSION/100, VERSION%100);
  1937.       WriteDebug(MsgText);
  1938.       gameaction = ga_nothing;
  1939.       return;
  1940.     }
  1941.     skill = *demo_p++; 
  1942.     episode = *demo_p++; 
  1943.     map = *demo_p++; 
  1944.     deathmatch = *demo_p++;
  1945.     respawnparm = *demo_p++;
  1946.     fastparm = *demo_p++;
  1947.     nomonsters = *demo_p++;
  1948.     consoleplayer = *demo_p++;
  1950.     for (i=0 ; i<MAXPLAYERS ; i++) 
  1951. playeringame[i] = *demo_p++; 
  1952.     if (playeringame[1]) 
  1953.     { 
  1954. netgame = true; 
  1955. netdemo = true; 
  1956.     }
  1958.     // don't spend a lot of time in loadlevel 
  1959.     precache = false;
  1960.     G_InitNew (skill, episode, map); 
  1961.     precache = true; 
  1963.     usergame = false; 
  1964.     demoplayback = true; 
  1965. } 
  1967. //
  1968. // G_TimeDemo 
  1969. //
  1970. boolean G_TimeDemo_II (char* name) 
  1971. {   
  1972.     static char demofilename[128];
  1973.     sprintf(demofilename, "%s.dem", name);
  1974.     if (access(demofilename, 0) != 0)
  1975.         return false;
  1976.     nodrawers = M_CheckParm ("-nodraw"); 
  1977.     noblit = M_CheckParm ("-noblit"); 
  1978.     timingdemo = true; 
  1979.     singletics = true; 
  1981.     defdemoname = demofilename;
  1982.     gameaction = ga_playdemo; 
  1983.     demotype = DEMO_II;
  1984.     sprintf(MsgText, "Playing timedemo II %s -noblit %d -nodraw %dn", name, noblit, nodrawers);
  1985.     WriteDebug(MsgText);
  1986.     return true;
  1987. } 
  1988.  
  1989. //
  1990. // G_TimeDemo 
  1991. //
  1992. void G_TimeDemo (char* name) 
  1993. {   
  1994.     nodrawers = M_CheckParm ("-nodraw"); 
  1995.     noblit = M_CheckParm ("-noblit"); 
  1996.     timingdemo = true; 
  1997.     singletics = true; 
  1999.     defdemoname = name; 
  2000.     gameaction = ga_playdemo; 
  2001.     sprintf(MsgText, "Playing timedemo %s -noblit %d -nodraw %dn", name, noblit, nodrawers);
  2002.     WriteDebug(MsgText);
  2003. } 
  2004.  
  2005.  
  2006. /* 
  2007. =================== 
  2008. = 
  2009. = G_CheckDemoStatus 
  2010. = 
  2011. = Called after a death or level completion to allow demos to be cleaned up 
  2012. = Returns true if a new demo loop action will take place 
  2013. =================== 
  2014. */ 
  2015.  
  2016. boolean G_CheckDemoStatus (void) 
  2017. { 
  2018.     int             endtime; 
  2019.  
  2020.     WriteDebug("G_CheckDemoStatus...n");
  2021.     if (timingdemo) 
  2022.     { 
  2023. endtime = I_GetTime (); 
  2024.     I_Error ("timed %i gametics in %i realtics : %d FPS" ,gametic, endtime-starttime, (gametic*TICRATE)/(endtime-starttime)); 
  2025.     } 
  2026.  
  2027.     if (demoplayback) 
  2028.     { 
  2029. if (singledemo) 
  2030.     I_Quit (); 
  2031.  
  2032. Z_ChangeTag (demobuffer, PU_CACHE); 
  2033. demoplayback = false; 
  2034. netdemo = false;
  2035. netgame = false;
  2036. deathmatch = false;
  2037. playeringame[1] = playeringame[2] = playeringame[3] = 0;
  2038. respawnparm = false;
  2039. fastparm = false;
  2040. nomonsters = false;
  2041. consoleplayer = 0;
  2042. D_AdvanceDemo (); 
  2043. return true; 
  2044.     } 
  2045.  
  2046.     if (demorecording) 
  2047.     { 
  2048.      G_EndDemo();
  2049. I_Error ("Demo %s recorded",demoname); 
  2050.     } 
  2051.  
  2052.     return false; 
  2053. } 
  2054.  
  2056. void G_EndDemo_II()
  2057.    {
  2058. *demo_p++ = DEMOMARKER; 
  2059. M_AppendFile(demoname, demobuffer, demo_p - demobuffer);
  2060. Z_Free (demobuffer);
  2061. demorecording = false;
  2062.    }
  2063.  
  2064. void G_EndDemo()
  2065.    {
  2066. *demo_p++ = DEMOMARKER; 
  2067. M_WriteFile (demoname, demobuffer, demo_p - demobuffer); 
  2068. Z_Free (demobuffer); 
  2069. demorecording = false; 
  2070.    }
  2071.