Source to src/g_game.c
// Emacs style mode select -*- C++ -*-
//-----------------------------------------------------------------------------
//
// $Id:$
//
// Copyright (C) 1993-1996 by id Software, Inc.
//
// This source is available for distribution and/or modification
// only under the terms of the DOOM Source Code License as
// published by id Software. All rights reserved.
//
// The source is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
// for more details.
//
// $Log:$
//
// DESCRIPTION: none
//
//-----------------------------------------------------------------------------
static const char
rcsid[] = "$Id: g_game.c,v 1.8 1997/02/03 22:45:09 b1 Exp $";
#include <string.h>
#include <stdlib.h>
#include "doomdef.h"
#include "doomstat.h"
#include "z_zone.h"
#include "f_finale.h"
#include "m_argv.h"
#include "m_misc.h"
#include "m_menu.h"
#include "m_random.h"
#include "i_system.h"
#include "p_setup.h"
#include "p_saveg.h"
#include "p_tick.h"
#include "d_main.h"
#include "wi_stuff.h"
#include "hu_stuff.h"
#include "st_stuff.h"
#include "am_map.h"
// Needs access to LFB.
#include "v_video.h"
#include "w_wad.h"
#include "p_local.h"
#include "s_sound.h"
// Data.
#include "dstrings.h"
#include "sounds.h"
// SKY handling - still the wrong place.
#include "r_data.h"
#include "r_sky.h"
#include "g_game.h"
#define SAVEGAMESIZE 0x2c000
#define SAVESTRINGSIZE 24
void WriteDebug(char *);
char MsgText[256];
boolean G_CheckDemoStatus (void);
void G_ReadDemoTiccmd (ticcmd_t* cmd);
void G_WriteDemoTiccmd (ticcmd_t* cmd);
void G_PlayerReborn (int player);
void G_InitNew (skill_t skill, int episode, int map);
void G_DoReborn (int playernum);
void G_DoLoadLevel (void);
void G_DoNewGame (void);
void G_DoLoadGame (void);
void G_DoPlayDemo (void);
void G_DoPlayDemo_II(void);
void G_DoCompleted (void);
void G_DoVictory (void);
void G_DoWorldDone (void);
void G_DoSaveGame (void);
gameaction_t gameaction;
gamestate_t gamestate;
skill_t gameskill;
boolean respawnmonsters;
int gameepisode;
int gamemap;
boolean paused;
boolean sendpause; // send a pause event next tic
boolean sendsave; // send a save event next tic
boolean usergame; // ok to save / end game
boolean timingdemo; // if true, exit with report on completion
boolean nodrawers; // for comparative timing purposes
boolean noblit; // for comparative timing purposes
int starttime; // for comparative timing purposes
boolean viewactive;
boolean deathmatch; // only if started as net death
boolean netgame; // only true if packets are broadcast
boolean playeringame[MAXPLAYERS];
player_t players[MAXPLAYERS];
boolean internetgame; //11.12.98 dlw optimize for internet
int consoleplayer; // player taking events and displaying
int displayplayer; // view being displayed
int gametic;
int levelstarttic; // gametic at level start
int totalkills, totalitems, totalsecret; // for intermission
long totalscore; // 10.15.98 scorekeeping dlw (2billion?)
char totalscoretextline[200];
char scoreuserwad[256];
char HUDscoretext[200];
char keepscore;
char showscoreHUD;
char DOUBLESTUFF; //11.4.98 optimize dlw
long SCREENMULT; //11.5.98 optimize dlw width x height
char demoname[32];
int demotype;
boolean demorecording;
boolean demoplayback;
boolean netdemo;
byte* demobuffer;
byte* demo_p;
byte* demoend;
boolean singledemo; // quit after playing a demo from cmdline
boolean precache = true; // if true, load all graphics at start
wbstartstruct_t wminfo; // parms for world map / intermission
short consistancy[MAXPLAYERS][BACKUPTICS];
byte* savebuffer;
//
// controls (have defaults)
//
int key_right;
int key_left;
int key_up;
int key_down;
int key_strafeleft;
int key_straferight;
int key_fire;
int key_use;
int key_strafe;
int key_speed;
int key_mvert;
int mousebfire;
int mousebstrafe;
int mousebforward;
int mouseb1;
int mouseb2;
int mouseb3;
int joybfire;
int joybstrafe;
int joybuse;
int joybspeed;
int joyb1;
int joyb2;
int joyb3;
int joyb4;
int always_run;
int swap_stereo;
int mvert;
int keylink;
int link_alt;
extern int usemouse;
extern int usejoystick;
#define MAXPLMOVE (forwardmove[1])
#define TURBOTHRESHOLD 0x32
fixed_t forwardmove[2] = {0x19, 0x32};
fixed_t sidemove[2] = {0x18, 0x28};
fixed_t angleturn[3] = {640, 1280, 320}; // + slow turn
#define SLOWTURNTICS 6
#define NUMKEYS 256
boolean gamekeydown[NUMKEYS];
int turnheld; // for accelerative turning
boolean mousearray[4];
boolean* mousebuttons = &mousearray[1]; // allow [-1]
// mouse values are used once
int mousex;
int mousey;
int dclicktime;
int dclickstate;
int dclicks;
int dclicktime2;
int dclickstate2;
int dclicks2;
// joystick values are repeated
int joyxmove;
int joyymove;
boolean joyarray[5];
boolean* joybuttons = &joyarray[1]; // allow [-1]
int savegameslot;
char savedescription[32];
#define BODYQUESIZE 32
mobj_t* bodyque[BODYQUESIZE];
int bodyqueslot;
void* statcopy; // for statistics driver
int G_CmdChecksum (ticcmd_t* cmd)
{
int i;
int sum = 0;
for (i=0 ; i< sizeof(*cmd)/4 - 1 ; i++)
sum += ((int *)cmd)[i];
return sum;
}
//
// G_BuildTiccmd
// Builds a ticcmd from all of the available inputs
// or reads it from the demo buffer.
// If recording a demo, write it out
//
void G_BuildTiccmd(ticcmd_t* cmd)
{
int i;
boolean strafe;
boolean bstrafe;
int speed;
int tspeed;
int forward;
int side;
// ticcmd_t *base; //11.7.98 dlw original code not optimal
//11.7.98 dlw opt
cmd->forwardmove=0;
cmd->sidemove=0;
cmd->angleturn=0;
//cmd->consistancy=0;
cmd->chatchar=0;
cmd->buttons=0;
//base = I_BaseTiccmd(); // empty, or external driver
//memcpy(cmd, base, sizeof(*cmd)); //11.7.98 dlw unneeded
cmd->consistancy = consistancy[consoleplayer][maketic%BACKUPTICS];
strafe = gamekeydown[key_strafe] || mousebuttons[mousebstrafe] || joybuttons[joybstrafe];
if ((joybspeed == 31) || (always_run == TRUE))
speed = 1;
else
speed = gamekeydown[key_speed] || joybuttons[joybspeed];
forward = side = 0;
// use two stage accelerative turning on the keyboard and joystick
// little optimized 11.8.98 dlw
//if(joyxmove < 0 || joyxmove > 0 || gamekeydown[key_right] || gamekeydown[key_left])
if(joyxmove || gamekeydown[key_right] || gamekeydown[key_left])
turnheld += ticdup;
else
turnheld = 0;
if (turnheld < SLOWTURNTICS)
tspeed = 2; // slow turn
else
tspeed = speed;
// let movement keys cancel each other out
if(strafe)
{
if(gamekeydown[key_right])
{
// fprintf(stderr, "strafe right\n");
side += sidemove[speed];
}
if(gamekeydown[key_left])
{
// fprintf(stderr, "strafe left\n");
side -= sidemove[speed];
}
if(usejoystick)
{
if (joyxmove > 0)
side += sidemove[speed];
if (joyxmove < 0)
side -= sidemove[speed];
}
}
else
{
if (gamekeydown[key_right])
cmd->angleturn -= angleturn[tspeed];
if (gamekeydown[key_left])
cmd->angleturn += angleturn[tspeed];
if(usejoystick)
{
if (joyxmove > 0)
cmd->angleturn -= angleturn[tspeed];
if (joyxmove < 0)
cmd->angleturn += angleturn[tspeed];
}
}
if (gamekeydown[key_up])
{
// fprintf(stderr, "up\n");
forward += forwardmove[speed];
}
if (gamekeydown[key_down])
{
// fprintf(stderr, "down\n");
forward -= forwardmove[speed];
}
if(usejoystick)
{
if (joyymove < 0)
forward += forwardmove[speed];
if (joyymove > 0)
forward -= forwardmove[speed];
}
if(gamekeydown[key_straferight])
side += sidemove[speed];
if(gamekeydown[key_strafeleft])
side -= sidemove[speed];
// buttons
cmd->chatchar = HU_dequeueChatChar();
if (gamekeydown[key_fire] || mousebuttons[mousebfire] || joybuttons[joybfire])
{
cmd->buttons |= BT_ATTACK;
}
if(gamekeydown[key_use] || joybuttons[joybuse] )
{
cmd->buttons |= BT_USE;
// clear double clicks if hit use button
dclicks = 0;
}
// chainsaw overrides
for(i = 0; i < NUMWEAPONS-1; i++)
if (gamekeydown[KEY_1+i])
{
cmd->buttons |= BT_CHANGE;
cmd->buttons |= i<<BT_WEAPONSHIFT;
break;
}
// mouse
if(usemouse)
{
if(mousebuttons[mousebforward])
forward += forwardmove[speed];
// forward double click
if(mousebuttons[mousebforward] != dclickstate && dclicktime > 1 )
{
dclickstate = mousebuttons[mousebforward];
if (dclickstate)
dclicks++;
if (dclicks == 2)
{
cmd->buttons |= BT_USE;
dclicks = 0;
}
else
dclicktime = 0;
}
else
{
dclicktime += ticdup;
if (dclicktime > 20)
{
dclicks = 0;
dclickstate = 0;
}
}
forward += mousey;
if (strafe)
side += mousex*2;
else
cmd->angleturn -= mousex*0x8;
mousex = mousey = 0;
}// usemouse
// 11.8.98 dlw not working FIXME
// strafe double click
/*bstrafe = mousebuttons[mousebstrafe] || joybuttons[joybstrafe];
if(bstrafe != dclickstate2 && dclicktime2 > 1 )
{
dclickstate2 = bstrafe;
if(dclickstate2) dclicks2++;
if(dclicks2 == 2)
{
cmd->buttons |= BT_USE;
dclicks2 = 0;
}
else
dclicktime2 = 0;
}
else
{
dclicktime2 += ticdup;
if(dclicktime2 > 20)
{
dclicks2 = 0;
dclickstate2 = 0;
}
} FIXME */
if(forward > MAXPLMOVE) forward = MAXPLMOVE;
else if (forward < -MAXPLMOVE) forward = -MAXPLMOVE;
if(side > MAXPLMOVE) side = MAXPLMOVE;
else if (side < -MAXPLMOVE) side = -MAXPLMOVE;
cmd->forwardmove += forward;
cmd->sidemove += side;
// special buttons
if(sendpause)
{
sendpause = false;
cmd->buttons = BT_SPECIAL | BTS_PAUSE;
}
if(sendsave)
{
sendsave = false;
cmd->buttons = BT_SPECIAL | BTS_SAVEGAME | (savegameslot << BTS_SAVESHIFT);
}
}
//
// G_DoLoadLevel
//
extern gamestate_t wipegamestate;
void G_DoLoadLevel(void)
{
int i;
// Set the sky map.
// First thing, we have a dummy sky texture name,
// a flat. The data is in the WAD only because
// we look for an actual index, instead of simply
// setting one.
skyflatnum = R_FlatNumForName ( SKYFLATNAME );
// DOOM determines the sky texture to be used
// depending on the current episode, and the game version.
if ( (gamemode == commercial) // Doom II
|| ( gamemode == addon_tnt )
|| ( gamemode == addon_plut ) )
{
skytexture = R_TextureNumForName ("SKY3");
if (gamemap < 12)
skytexture = R_TextureNumForName ("SKY1");
else if (gamemap < 21)
skytexture = R_TextureNumForName ("SKY2");
//WriteDebug("Sky set...\n");
}
levelstarttic = gametic; // for time calculation
if (wipegamestate == GS_LEVEL)
wipegamestate = -1; // force a wipe
gamestate = GS_LEVEL;
for (i=0 ; i<MAXPLAYERS ; i++)
{
if (playeringame[i] && players[i].playerstate == PST_DEAD)
players[i].playerstate = PST_REBORN;
memset (players[i].frags,0,sizeof(players[i].frags));
}
//WriteDebug("P_SetupLevel\n");
P_SetupLevel(gameepisode, gamemap, 0, gameskill);
displayplayer = consoleplayer; // view the guy you are playing
starttime = I_GetTime();
gameaction = ga_nothing;
//WriteDebug("Z_CheckHeap\n");
Z_CheckHeap ();
// clear cmd building stuff
memset (gamekeydown, 0, sizeof(gamekeydown));
joyxmove = joyymove = 0;
mousex = mousey = 0;
sendpause = sendsave = paused = false;
memset (mousebuttons, 0, sizeof(mousebuttons));
memset (joybuttons, 0, sizeof(joybuttons));
//WriteDebug("G_DoLoadLevel done\n");
R_FillBackScreen();
}
//
// G_Responder
// Get info needed to make ticcmd_ts for the players.
//
boolean G_Responder(event_t* ev)
{
// 11.7.98 another optimization mess.. redundant checking
// 11.7.98 sort thru it if you can... original left for
// schooling dlw
// allow spy mode changes even during the demo
// 11.7.98 look at gslevel below->redundant
/* if(gamestate == GS_LEVEL && ev->type == ev_keydown && ev->data1 == KEY_F12 && (singledemo || !deathmatch))
{
// spy mode
do
{
displayplayer++;
if(displayplayer == MAXPLAYERS) displayplayer = 0;
}while(!playeringame[displayplayer] && displayplayer != consoleplayer);
return true;
}
*/
if ((ev->type == ev_keydown) && (ev->data1 == key_mvert))
{
// don't like this - mvert = !mvert;
/* if (mvert == 0)
mvert = 1;
else
mvert = 0; 11.7.98 don't like it either dlw */
mvert= !mvert;
return true;
}
// any other key pops up menu if in demos
if(gameaction == ga_nothing && !singledemo && (demoplayback || gamestate == GS_DEMOSCREEN))
{
if(ev->type == ev_keydown || (ev->type == ev_mouse && ev->data1) || (ev->type == ev_joystick && ev->data1))
{
// except the console key...
if((ev->type != ev_keydown) || (ev->data1 != KEY_CONSOLE))
{
M_StartControlPanel();
return true;
}
}
return false;
}
if(gamestate == GS_LEVEL)
{
#if 0
if (devparm && ev->type == ev_keydown && ev->data1 == ';')
{
G_DeathMatchSpawnPlayer(0);
return true;
}
#endif
if(ev->type == ev_keydown && ev->data1 == KEY_F12 && (singledemo || !deathmatch))
{
// spy mode
do
{
displayplayer++;
if(displayplayer == MAXPLAYERS) displayplayer = 0;
}while(!playeringame[displayplayer] && displayplayer != consoleplayer);
return true;
}
if(HU_Responder(ev)) return true; // chat ate the event
/* 11.7.98 This thing only returns false so... kill the if opt dlw
if (ST_Responder (ev))
return true; // status window ate it */
ST_Responder(ev);
if(AM_Responder(ev)) return true; // automap ate it
} //gamestate==GS_LEVEL
else if(gamestate == GS_FINALE) //11.7.98 else added
{
if (F_Responder(ev))
return true; // finale ate the event
}
switch (ev->type)
{
case ev_keydown:
if (ev->data1 == KEY_PAUSE)
{
sendpause = true;
return true;
}
if (ev->data1 < NUMKEYS)
gamekeydown[ev->data1] = true;
return true; // eat key down events
case ev_keyup:
if (ev->data1 < NUMKEYS)
gamekeydown[ev->data1] = false;
return false; // always let key up events filter down
case ev_mouse:
mousebuttons[0] = ev->data1 & 1;
mousebuttons[1] = ev->data1 & 2;
mousebuttons[2] = ev->data1 & 4;
mousex = ev->data2*(mouseSensitivity+5)/10;
mousey = ev->data3*(mouseSensitivity+5)/10;
return true; // eat events
case ev_joystick:
joybuttons[0] = ev->data1 & 1;
joybuttons[1] = ev->data1 & 2;
joybuttons[2] = ev->data1 & 4;
joybuttons[3] = ev->data1 & 8;
joyxmove = ev->data2;
joyymove = ev->data3;
return true; // eat events
default:
break;
}
return false;
}
//
// G_Ticker
// Make ticcmd_ts for the players.
//
void G_Ticker(void)
{
int i;
int buf;
ticcmd_t* cmd;
/* 11.9.98 dlw speed optimized below
// do player reborns if needed
for(i=0 ; i<MAXPLAYERS ; i++)
if (playeringame[i] && players[i].playerstate == PST_REBORN)
{
//WriteDebug("Players being \"reborn\"\n");
G_DoReborn(i);
}
*/
for(i=0; i<doomcom->numplayers; i++)
if(players[i].playerstate == PST_REBORN)
G_DoReborn(i);
// do things to change the game state
while(gameaction != ga_nothing)
{
switch(gameaction)
{
case ga_loadlevel:
G_DoLoadLevel(); break;
case ga_newgame:
G_DoNewGame(); break;
case ga_loadgame:
G_DoLoadGame(); break;
case ga_savegame:
G_DoSaveGame(); break;
case ga_playdemo:
//WriteDebug("Playing demo...\n");
if(demotype == DEMO_I) G_DoPlayDemo();
else G_DoPlayDemo_II();
break;
case ga_completed:
G_DoCompleted(); break;
case ga_victory:
F_StartFinale(); break;
case ga_worlddone:
G_DoWorldDone(); break;
case ga_screenshot:
M_ScreenShot();
gameaction = ga_nothing;
break;
case ga_nothing:
break;
}
}
// get commands, check consistancy,
// and build new consistancy check
buf = (gametic/ticdup)%BACKUPTICS;
/* 11.9.98 optimized
for(i=0 ; i<MAXPLAYERS ; i++)
{
if (playeringame[i])
{
*/
for(i=0; i<doomcom->numplayers; i++)
{
cmd = &players[i].cmd;
memcpy(cmd, &netcmds[i][buf], sizeof(ticcmd_t));
if(demoplayback)
{
//WriteDebug("G_ReadDemoTiccmd\n");
G_ReadDemoTiccmd(cmd);
}
if(demorecording)
G_WriteDemoTiccmd(cmd);
// check for turbo cheats
if(cmd->forwardmove > TURBOTHRESHOLD
&& !(gametic&31) && ((gametic>>5)&3) == i )
{
static char turbomessage[80];
extern char *player_names[4];
sprintf (turbomessage, "%s is turbo!",player_names[i]);
players[consoleplayer].message = turbomessage;
}
if(netgame && !netdemo && !(gametic%ticdup) )
{
if(gametic > BACKUPTICS
&& consistancy[i][buf] != cmd->consistancy)
{
I_Error("consistency failure (%i should be %i)",
cmd->consistancy, consistancy[i][buf]);
}
if(players[i].mo)
consistancy[i][buf] = players[i].mo->x;
else
consistancy[i][buf] = rndindex;
}
} //end for
//}
// check for special buttons
/* 11.9.98 dlw optimized
for (i=0 ; i<MAXPLAYERS ; i++)
{
if (playeringame[i])
{
*/
for(i=0; i<doomcom->numplayers; i++)
{
if(players[i].cmd.buttons & BT_SPECIAL)
{
switch(players[i].cmd.buttons & BT_SPECIALMASK)
{
case BTS_PAUSE:
paused ^= 1;
if(paused)
S_PauseSound();
else
S_ResumeSound();
break;
case BTS_SAVEGAME:
if(!savedescription[0])
strcpy(savedescription, "NET GAME");
savegameslot =
(players[i].cmd.buttons & BTS_SAVEMASK)>>BTS_SAVESHIFT;
gameaction = ga_savegame;
break;
}
}
}//for
//} original now optimized
// do main actions
switch(gamestate)
{
case GS_LEVEL:
//WriteDebug("P_Ticker...\n");
P_Ticker();
//WriteDebug("ST_Ticker...\n");
ST_Ticker();
//WriteDebug("AM_Ticker...\n");
AM_Ticker();
//WriteDebug("HU_Ticker...\n");
HU_Ticker();
break;
case GS_INTERMISSION:
//WriteDebug("WI_Ticker...\n");
WI_Ticker ();
break;
case GS_FINALE:
//WriteDebug("F_Ticker...\n");
F_Ticker ();
break;
case GS_DEMOSCREEN:
//WriteDebug("D_PageTicker...\n");
D_PageTicker();
break;
}
}
//
// PLAYER STRUCTURE FUNCTIONS
// also see P_SpawnPlayer in P_Things
//
//
// G_InitPlayer
// Called at the start.
// Called by the game initialization functions.
//
void G_InitPlayer (int player)
{
player_t* p;
// set up the saved info
p = &players[player];
// clear everything else to defaults
G_PlayerReborn (player);
}
//
// G_PlayerFinishLevel
// Can when a player completes a level.
//
void G_PlayerFinishLevel (int player)
{
player_t* p;
p = &players[player];
memset (p->powers, 0, sizeof (p->powers));
memset (p->cards, 0, sizeof (p->cards));
p->mo->flags &= ~MF_SHADOW; // cancel invisibility
p->extralight = 0; // cancel gun flashes
p->fixedcolormap = 0; // cancel ir gogles
p->damagecount = 0; // no palette changes
p->bonuscount = 0;
}
//
// G_PlayerReborn
// Called after a player dies
// almost everything is cleared and initialized
//
void G_PlayerReborn (int player)
{
player_t* p;
int i;
int frags[MAXPLAYERS];
int killcount;
int itemcount;
int secretcount;
memcpy (frags,players[player].frags,sizeof(frags));
killcount = players[player].killcount;
itemcount = players[player].itemcount;
secretcount = players[player].secretcount;
p = &players[player];
memset (p, 0, sizeof(*p));
memcpy (players[player].frags, frags, sizeof(players[player].frags));
players[player].killcount = killcount;
players[player].itemcount = itemcount;
players[player].secretcount = secretcount;
p->usedown = p->attackdown = true; // don't do anything immediately
p->playerstate = PST_LIVE;
p->health = MAXHEALTH;
p->readyweapon = p->pendingweapon = wp_pistol;
p->weaponowned[wp_fist] = true;
p->weaponowned[wp_pistol] = true;
p->ammo[am_clip] = 50;
for (i=0 ; i<NUMAMMO ; i++)
p->maxammo[i] = maxammo[i];
}
//
// G_CheckSpot
// Returns false if the player cannot be respawned
// at the given mapthing_t spot
// because something is occupying it
//
void P_SpawnPlayer (mapthing_t* mthing);
boolean
G_CheckSpot
( int playernum,
mapthing_t* mthing )
{
fixed_t x;
fixed_t y;
subsector_t* ss;
unsigned an;
mobj_t* mo;
int i;
if (players[playernum].mo == NULL)
{
// first spawn of level, before corpses
for (i=0 ; i<playernum ; i++)
{
if (players[i].mo != NULL)
{
if (players[i].mo->x == mthing->x << FRACBITS && players[i].mo->y == mthing->y << FRACBITS)
{
return false;
}
}
}
return true;
}
x = mthing->x << FRACBITS;
y = mthing->y << FRACBITS;
if (!P_CheckPosition (players[playernum].mo, x, y) )
return false;
// flush an old corpse if needed
if (bodyqueslot >= BODYQUESIZE)
P_RemoveMobj (bodyque[bodyqueslot%BODYQUESIZE]);
bodyque[bodyqueslot%BODYQUESIZE] = players[playernum].mo;
bodyqueslot++;
// spawn a teleport fog
ss = R_PointInSubsector (x,y);
an = ( ANG45 * (mthing->angle/45) ) >> ANGLETOFINESHIFT;
mo = P_SpawnMobj (x+20*finecosine[an], y+20*finesine[an]
, ss->sector->floorheight
, MT_TFOG);
if (players[consoleplayer].viewz != 1)
S_StartSound (mo, sfx_telept); // don't start sound on first frame
return true;
}
//
// G_DeathMatchSpawnPlayer
// Spawns a player at one of the random death match spots
// called at level load and each death
//
void G_DeathMatchSpawnPlayer (int playernum)
{
int i,j;
int selections;
selections = deathmatch_p - deathmatchstarts;
if (selections < 4)
{
I_Error ("Only %i deathmatch spots, 4 required", selections);
}
for (j=0 ; j<20 ; j++)
{
i = P_Random() % selections;
if (G_CheckSpot (playernum, &deathmatchstarts[i]) )
{
deathmatchstarts[i].type = playernum+1;
//WriteDebug("F\n");
P_SpawnPlayer (&deathmatchstarts[i]);
return;
}
}
// no good spot, so the player will probably get stuck
//WriteDebug("Y\n");
P_SpawnPlayer (&playerstarts[playernum]);
//WriteDebug("Z\n");
}
//
// G_DoReborn
//
void G_DoReborn (int playernum)
{
int i;
if (!netgame)
{
// reload the level from scratch
gameaction = ga_loadlevel;
}
else
{
// respawn at the start
// first dissasociate the corpse
players[playernum].mo->player = NULL;
// spawn at random spot if in death match
if (deathmatch)
{
G_DeathMatchSpawnPlayer (playernum);
return;
}
if (G_CheckSpot (playernum, &playerstarts[playernum]) )
{
P_SpawnPlayer (&playerstarts[playernum]);
return;
}
// try to spawn at one of the other players spots
for (i=0 ; i<MAXPLAYERS ; i++)
{
if (G_CheckSpot (playernum, &playerstarts[i]) )
{
playerstarts[i].type = playernum+1; // fake as other player
P_SpawnPlayer (&playerstarts[i]);
playerstarts[i].type = i+1; // restore
return;
}
// he's going to be inside something. Too bad.
}
P_SpawnPlayer (&playerstarts[playernum]);
}
}
void G_ScreenShot (void)
{
gameaction = ga_screenshot;
}
// DOOM Par Times
int pars[4][10] =
{
{0},
{0,30,75,120,90,165,180,180,30,165},
{0,90,90,90,120,90,360,240,30,170},
{0,90,45,90,150,90,90,165,30,135}
};
// DOOM II Par Times
int cpars[32] =
{
30,90,120,120,90,150,120,120,270,90, // 1-10
210,150,150,150,210,150,420,150,210,150, // 11-20
240,150,180,150,150,300,330,420,300,180, // 21-30
120,30 // 31-32
};
//
// G_DoCompleted
//
boolean secretexit;
extern char* pagename;
void G_ExitLevel (void)
{
secretexit = false;
gameaction = ga_completed;
}
// Here's for the german edition.
void G_SecretExitLevel (void)
{
// IF NO WOLF3D LEVELS, NO SECRET EXIT!
if ( (gamemode == commercial)
&& (W_CheckNumForName("map31")<0))
secretexit = false;
else
secretexit = true;
gameaction = ga_completed;
}
void G_DoCompleted (void)
{
int i;
gameaction = ga_nothing;
for (i=0 ; i<MAXPLAYERS ; i++)
if (playeringame[i])
G_PlayerFinishLevel (i); // take away cards and stuff
if (automapactive)
AM_Stop ();
if ( gamemode != commercial)
switch(gamemap)
{
case 8:
gameaction = ga_victory;
return;
case 9:
for (i=0 ; i<MAXPLAYERS ; i++)
players[i].didsecret = true;
break;
}
//#if 0 Hmmm - why?
if ( (gamemap == 8)
&& (gamemode != commercial) )
{
// victory
gameaction = ga_victory;
return;
}
if ( (gamemap == 9)
&& (gamemode != commercial) )
{
// exit secret level
for (i=0 ; i<MAXPLAYERS ; i++)
players[i].didsecret = true;
}
//#endif
wminfo.didsecret = players[consoleplayer].didsecret;
wminfo.epsd = gameepisode -1;
wminfo.last = gamemap -1;
// wminfo.next is 0 biased, unlike gamemap
if ( gamemode == commercial)
{
if (secretexit)
switch(gamemap)
{
case 15: wminfo.next = 30; break;
case 31: wminfo.next = 31; break;
}
else
switch(gamemap)
{
case 31:
case 32: wminfo.next = 15; break;
default: wminfo.next = gamemap;
}
}
else
{
if (secretexit)
wminfo.next = 8; // go to secret level
else if (gamemap == 9)
{
// returning from secret level
switch (gameepisode)
{
case 1:
wminfo.next = 3;
break;
case 2:
wminfo.next = 5;
break;
case 3:
wminfo.next = 6;
break;
case 4:
wminfo.next = 2;
break;
}
}
else
wminfo.next = gamemap; // go to next level
}
wminfo.maxkills = totalkills;
wminfo.maxitems = totalitems;
wminfo.maxsecret = totalsecret;
wminfo.maxfrags = 0;
if ( gamemode == commercial )
wminfo.partime = 35*cpars[gamemap-1];
else
wminfo.partime = 35*pars[gameepisode][gamemap];
wminfo.pnum = consoleplayer;
for (i=0 ; i<MAXPLAYERS ; i++)
{
wminfo.plyr[i].in = playeringame[i];
wminfo.plyr[i].skills = players[i].killcount;
wminfo.plyr[i].sitems = players[i].itemcount;
wminfo.plyr[i].ssecret = players[i].secretcount;
wminfo.plyr[i].stime = leveltime;
memcpy (wminfo.plyr[i].frags, players[i].frags
, sizeof(wminfo.plyr[i].frags));
}
gamestate = GS_INTERMISSION;
viewactive = false;
automapactive = false;
if (statcopy)
memcpy (statcopy, &wminfo, sizeof(wminfo));
WI_Start (&wminfo);
}
//
// G_WorldDone
//
void G_WorldDone(void)
{
gameaction = ga_worlddone;
if (secretexit)
players[consoleplayer].didsecret = true;
if ( gamemode == commercial )
{
switch (gamemap)
{
case 15:
case 31:
if (!secretexit)
break;
case 6:
case 11:
case 20:
case 30:
F_StartFinale();
break;
}
}
}
void G_DoWorldDone (void)
{
gamestate = GS_LEVEL;
gamemap = wminfo.next+1;
G_DoLoadLevel();
gameaction = ga_nothing;
viewactive = true;
}
//
// G_InitFromSavegame
// Can be called by the startup code or the menu task.
//
extern boolean setsizeneeded;
void R_ExecuteSetViewSize (void);
char savename[256];
void G_LoadGame (char* name)
{
strcpy (savename, name);
gameaction = ga_loadgame;
}
#define VERSIONSIZE 16
extern char DoomDir[128]; // msvc 5 gone mad again 10.31.98
void G_DoLoadGame (void)
{
int length;
int i;
int a,b,c;
char vcheck[VERSIONSIZE];
gameaction = ga_nothing;
length = M_ReadFile(savename, &savebuffer);
save_p = savebuffer + SAVESTRINGSIZE;
// skip the description field
memset(vcheck,0,sizeof(vcheck));
sprintf(vcheck,"version %i",VERSION);
if (strcmp (save_p, vcheck))
return; // bad version
save_p += VERSIONSIZE;
gameskill = *save_p++;
gameepisode = *save_p++;
gamemap = *save_p++;
for (i=0 ; i<MAXPLAYERS ; i++)
playeringame[i] = *save_p++;
// load a base level
G_InitNew (gameskill, gameepisode, gamemap);
// get the times
a = *save_p++;
b = *save_p++;
c = *save_p++;
leveltime = (a<<16) + (b<<8) + c;
// dearchive all the modifications
P_UnArchivePlayers();
P_UnArchiveWorld();
P_UnArchiveThinkers();
P_UnArchiveSpecials();
if (*save_p != 0x1d)
I_Error ("Bad savegame");
// done
Z_Free(savebuffer);
if (setsizeneeded)
R_ExecuteSetViewSize();
// draw the pattern into the back screen
// WriteDebug("Calling R_FileBackScreen...\n");
R_FillBackScreen();
// WriteDebug("Calling R_DrawViewBorder...\n");
R_DrawViewBorder();
// 10.31.98 dlw Save/Load Score using .ini file
// maintains x-compat of save/load while allowing
// scores to be s/l also
if(keepscore)
{
for(i=0; i<VERSIONSIZE; i++) vcheck[i]=0; //no garbage
sprintf(vcheck, "Slot%d", 0); // pad the string
vcheck[4]=savename[7]; // slot number
totalscore = GetPrivateProfileInt("SCORES", vcheck, 0, DoomDir);
}
}
//
// G_SaveGame
// Called by the menu task.
// Description is a 24 byte text string
//
void
G_SaveGame
( int slot,
char* description )
{
savegameslot = slot;
strcpy (savedescription, description);
sendsave = true;
}
void G_DoSaveGame (void)
{
char name[100];
char name2[VERSIONSIZE];
char* description;
int length;
int i;
if (M_CheckParm("-cdrom"))
sprintf(name,"c:\\doomdata\\"SAVEGAMENAME"%d.dsg",savegameslot);
else
sprintf (name,SAVEGAMENAME"%d.dsg",savegameslot);
description = savedescription;
save_p = savebuffer = screens[1]+0x4000;
memcpy (save_p, description, SAVESTRINGSIZE);
save_p += SAVESTRINGSIZE;
memset (name2,0,sizeof(name2));
sprintf (name2,"version %i",VERSION);
memcpy (save_p, name2, VERSIONSIZE);
save_p += VERSIONSIZE;
*save_p++ = gameskill;
*save_p++ = gameepisode;
*save_p++ = gamemap;
for (i=0 ; i<MAXPLAYERS ; i++)
*save_p++ = playeringame[i];
*save_p++ = leveltime>>16;
*save_p++ = leveltime>>8;
*save_p++ = leveltime;
P_ArchivePlayers ();
P_ArchiveWorld ();
P_ArchiveThinkers ();
P_ArchiveSpecials ();
*save_p++ = 0x1d; // consistancy marker
length = save_p - savebuffer;
if (length > SAVEGAMESIZE)
I_Error ("Savegame buffer overrun");
M_WriteFile (name, savebuffer, length);
gameaction = ga_nothing;
savedescription[0] = 0;
players[consoleplayer].message = GGSAVED;
// draw the pattern into the back screen
R_FillBackScreen();
// 10.31.98 dlw Save/Load Score using .ini file
// maintains x-compat of save/load while allowing
// scores to be s/l also
for(i=0; i<VERSIONSIZE; i++) name2[i]=0; //no garbage
for(i=0; i<100; i++) name[i]=0; //no garbage
sprintf(name2, "Slot%d", savegameslot); //get position
if(keepscore) //if keeping score write the score
{
sprintf(name, "%d", totalscore);
WritePrivateProfileString("SCORES", name2, name, DoomDir);
}
else //otherwise zero it out
{
sprintf(name, "%d", 0);
WritePrivateProfileString("SCORES", name2, name, DoomDir);
}
}
//
// G_InitNew
// Can be called by the startup code or the menu task,
// consoleplayer, displayplayer, playeringame[] should be set.
//
skill_t d_skill;
int d_episode;
int d_map;
void
G_DeferedInitNew
( skill_t skill,
int episode,
int map)
{
d_skill = skill;
d_episode = episode;
d_map = map;
gameaction = ga_newgame;
}
void G_DoNewGame (void)
{
demoplayback = false;
netdemo = false;
netgame = false;
deathmatch = false;
playeringame[1] = playeringame[2] = playeringame[3] = 0;
respawnparm = false;
fastparm = false;
nomonsters = false;
consoleplayer = 0;
G_InitNew (d_skill, d_episode, d_map);
gameaction = ga_nothing;
}
// The sky texture to be used instead of the F_SKY1 dummy.
extern int skytexture;
void
G_InitNew
( skill_t skill,
int episode,
int map )
{
int i;
if (paused)
{
paused = false;
S_ResumeSound();
}
if(skill > sk_nightmare) skill = sk_nightmare;
// This was quite messy with SPECIAL and commented parts.
// Supposedly hacks to make the latest edition work.
// It might not work properly.
if(episode < 1) episode = 1;
if( gamemode == retail )
{
if (episode > 4) episode = 4;
}
else if( gamemode == shareware )
{
if (episode > 1)
episode = 1; // only start episode 1 on shareware
}
else
{
if (episode > 3) episode = 3;
}
if(map < 1) map = 1;
if ( (map > 9) && ( gamemode != commercial) ) map = 9;
//WriteDebug("M_ClearRandom\n");
M_ClearRandom();
if (skill == sk_nightmare || respawnparm )
respawnmonsters = true;
else
respawnmonsters = false;
if (fastparm || (skill == sk_nightmare && gameskill != sk_nightmare) )
{
for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++)
states[i].tics >>= 1;
mobjinfo[MT_BRUISERSHOT].speed = 20*FRACUNIT;
mobjinfo[MT_HEADSHOT].speed = 20*FRACUNIT;
mobjinfo[MT_TROOPSHOT].speed = 20*FRACUNIT;
}
else if (skill != sk_nightmare && gameskill == sk_nightmare)
{
for (i=S_SARG_RUN1 ; i<=S_SARG_PAIN2 ; i++)
states[i].tics <<= 1;
mobjinfo[MT_BRUISERSHOT].speed = 15*FRACUNIT;
mobjinfo[MT_HEADSHOT].speed = 10*FRACUNIT;
mobjinfo[MT_TROOPSHOT].speed = 10*FRACUNIT;
}
// force players to be initialized upon first level load
for (i=0 ; i<MAXPLAYERS ; i++)
players[i].playerstate = PST_REBORN;
usergame = true; // will be set false if a demo
paused = false;
demoplayback = false;
automapactive = false;
viewactive = true;
gameepisode = episode;
gamemap = map;
gameskill = skill;
viewactive = true;
// set the sky map for the episode
if( gamemode == commercial )
{
skytexture = R_TextureNumForName ("SKY3");
if(gamemap < 12)
skytexture = R_TextureNumForName ("SKY1");
else
if (gamemap < 21)
skytexture = R_TextureNumForName ("SKY2");
}
else
switch(episode)
{
case 1:
skytexture = R_TextureNumForName ("SKY1"); break;
case 2: skytexture = R_TextureNumForName ("SKY2"); break;
case 3: skytexture = R_TextureNumForName ("SKY3"); break;
case 4: // Special Edition sky
skytexture = R_TextureNumForName ("SKY4"); break;
}
//WriteDebug("G_DoLoadLevel\n");
setsizeneeded = TRUE;
G_DoLoadLevel();
}
//
// DEMO RECORDING
//
#define DEMOMARKER 0x80
void G_ReadDemoTiccmd (ticcmd_t* cmd)
{
if (*demo_p == DEMOMARKER)
{
// end of demo data stream
G_CheckDemoStatus ();
return;
}
cmd->forwardmove = ((signed char)*demo_p++);
cmd->sidemove = ((signed char)*demo_p++);
cmd->angleturn = ((unsigned char)*demo_p++)<<8;
cmd->buttons = (unsigned char)*demo_p++;
}
void G_WriteDemoTiccmd (ticcmd_t* cmd)
{
if (gamekeydown[KEY_Q]) // press q to end demo recording
G_CheckDemoStatus ();
*demo_p++ = cmd->forwardmove;
*demo_p++ = cmd->sidemove;
*demo_p++ = (cmd->angleturn+128)>>8;
*demo_p++ = cmd->buttons;
demo_p -= 4;
if (demo_p > demoend - 16)
{
// no more space
G_CheckDemoStatus ();
return;
}
G_ReadDemoTiccmd (cmd); // make SURE it is exactly the same
}
//
// G_RecordDemo
//
void G_RecordDemo (char* name)
{
int i;
int maxsize;
usergame = false;
strcpy (demoname, name);
strcat (demoname, ".lmp");
sprintf(MsgText, "Record demo : %s\n", demoname);
WriteDebug(MsgText);
maxsize = 0x20000;
i = M_CheckParm ("-maxdemo");
if (i && i<myargc-1)
maxsize = atoi(myargv[i+1])*1024;
demobuffer = Z_Malloc (maxsize,PU_STATIC,NULL);
demoend = demobuffer + maxsize;
demotype = DEMO_I;
demorecording = true;
}
//
// New Demo Recording stuff...
//
// Doom demos assume that the demo starts at the
// beginning of a level and that the normal level
// state will apply - any deviation from that
// and playback will be out of "sync". Synchronization
// information must be written out to the demo file
// so that the state of the entire game is saved
// Probably it should use the save game function to
// save the game state then save the demo data after
// it... A new extension of "DEM" should also be used.
//
// G_RecordDemo_II
//
void G_RecordDemo_II (char* name)
{
int i;
int maxsize;
usergame = false;
strcpy (demoname, name);
strcat (demoname, ".dem");
sprintf(MsgText, "Record demo II : %s\n", demoname);
WriteDebug(MsgText);
maxsize = 0x20000;
i = M_CheckParm ("-maxdemo");
if (i && i < myargc-1)
maxsize = atoi(myargv[i+1])*1024;
demobuffer = Z_Malloc (maxsize,PU_STATIC,NULL);
demoend = demobuffer + maxsize;
demotype = DEMO_II;
demorecording = true;
}
void G_BeginRecording_II (void)
{
char name2[VERSIONSIZE];
char description[] = "WINDOOM: DEMO VERSION II";
int length;
int i;
save_p = demobuffer;
memcpy (save_p, description, SAVESTRINGSIZE);
save_p += SAVESTRINGSIZE;
memset (name2,0,sizeof(name2));
sprintf (name2,"version %i",VERSION);
memcpy (save_p, name2, VERSIONSIZE);
save_p += VERSIONSIZE;
*save_p++ = gameskill;
*save_p++ = gameepisode;
*save_p++ = gamemap;
for (i = 0; i < MAXPLAYERS; i++)
*save_p++ = playeringame[i];
*save_p++ = deathmatch;
*save_p++ = respawnparm;
*save_p++ = fastparm;
*save_p++ = nomonsters;
*save_p++ = consoleplayer;
*save_p++ = leveltime >> 16;
*save_p++ = leveltime >> 8;
*save_p++ = leveltime;
P_ArchivePlayers();
P_ArchiveWorld();
P_ArchiveThinkers();
P_ArchiveSpecials();
*save_p++ = 0x1d; // consistancy marker
length = save_p - demobuffer;
if (length > SAVEGAMESIZE)
I_Error ("Savegame buffer overrun");
M_WriteFile (demoname, demobuffer, length);
gameaction = ga_nothing;
demo_p = demobuffer;
// *demo_p++ = VERSION;
// *demo_p++ = gameskill;
// *demo_p++ = gameepisode;
// *demo_p++ = gamemap;
/*
*demo_p++ = deathmatch;
*demo_p++ = respawnparm;
*demo_p++ = fastparm;
*demo_p++ = nomonsters;
*demo_p++ = consoleplayer;
*/
// for (i = 0; i < MAXPLAYERS; i++)
// {
// *demo_p++ = playeringame[i];
// }
// draw the pattern into the back screen
R_FillBackScreen ();
}
void G_BeginRecording (void)
{
int i;
demo_p = demobuffer;
*demo_p++ = VERSION;
*demo_p++ = gameskill;
*demo_p++ = gameepisode;
*demo_p++ = gamemap;
*demo_p++ = deathmatch;
*demo_p++ = respawnparm;
*demo_p++ = fastparm;
*demo_p++ = nomonsters;
*demo_p++ = consoleplayer;
for (i=0 ; i<MAXPLAYERS ; i++)
*demo_p++ = playeringame[i];
demotype = DEMO_I;
}
//
// G_PlayDemo
//
int access( const char *path, int mode );
char* defdemoname;
boolean G_DeferedPlayDemo_II (char* name)
{
static char demofilename[128];
sprintf(demofilename, "%s.dem", name);
if (access(demofilename, 0) != 0)
return false;
sprintf(MsgText, "-playdemo2: %s\n", demofilename);
WriteDebug(MsgText);
defdemoname = demofilename;
gameaction = ga_playdemo;
demotype = DEMO_II;
return true;
}
void G_DoPlayDemo_II(void)
{
int length;
int i;
int a,b,c;
char vcheck[VERSIONSIZE];
//everything below (comments) by others - dlw
// commented these to get rid of comp warning
//skill_t skill;
//int episode, map, dversion, tversion;
demotype = DEMO_II;
gameaction = ga_nothing;
sprintf(MsgText, "Playing demo II : %s\n", defdemoname);
WriteDebug(MsgText);
length = M_GetFileSize(defdemoname);
demobuffer = (unsigned char *)malloc(length);
demoend = demobuffer + length;
length = M_ReadFile(defdemoname, &demobuffer);
save_p = demobuffer + SAVESTRINGSIZE;
// skip the description field
memset (vcheck,0,sizeof(vcheck));
sprintf (vcheck,"version %i",VERSION);
if (strcmp (save_p, vcheck))
return; // bad version
save_p += VERSIONSIZE;
gameskill = *save_p++;
gameepisode = *save_p++;
gamemap = *save_p++;
for (i = 0; i < MAXPLAYERS; i++)
playeringame[i] = *save_p++;
deathmatch = *save_p++;
respawnparm = *save_p++;
fastparm = *save_p++;
nomonsters = *save_p++;
consoleplayer = *save_p++;
// for (i=0 ; i<MAXPLAYERS ; i++)
// playeringame[i] = *demo_p++;
if (playeringame[1])
{
netgame = true;
netdemo = true;
}
// load a base level
G_InitNew (gameskill, gameepisode, gamemap);
// get the times
a = *save_p++;
b = *save_p++;
c = *save_p++;
leveltime = (a << 16) + (b << 8) + c;
// dearchive all the modifications
P_UnArchivePlayers ();
P_UnArchiveWorld ();
P_UnArchiveThinkers ();
P_UnArchiveSpecials ();
if (*save_p++ != 0x1d)
I_Error ("Bad savegame");
// done
// Z_Free (savebuffer);
if (setsizeneeded)
R_ExecuteSetViewSize();
// draw the pattern into the back screen
// WriteDebug("Calling R_FillBackScreen...\n");
R_FillBackScreen();
// WriteDebug("Calling R_DrawViewBorder...\n");
R_DrawViewBorder();
// tversion = VERSION;
// gameaction = ga_nothing;
// demobuffer = demo_p = W_CacheLumpName(defdemoname, PU_STATIC);
// if (demobuffer == NULL)
// {
// sprintf(MsgText,"Demo %s is not in the WAD...\n", defdemoname);
// WriteDebug(MsgText);
// gameaction = ga_nothing;
// return;
// }
demo_p = save_p;
/*
dversion = *demo_p;
if ( *demo_p++ != tversion)
{
sprintf(MsgText, "Demo version : %d.%d Game version : %d.%d\n",
dversion/100, dversion %100, VERSION/100, VERSION%100);
WriteDebug(MsgText);
gameaction = ga_nothing;
return;
}
*/
// skill = *demo_p++;
// episode = *demo_p++;
// map = *demo_p++;
/*
deathmatch = *demo_p++;
respawnparm = *demo_p++;
fastparm = *demo_p++;
nomonsters = *demo_p++;
consoleplayer = *demo_p++;
// for (i=0 ; i<MAXPLAYERS ; i++)
// playeringame[i] = *demo_p++;
if (playeringame[1])
{
netgame = true;
netdemo = true;
}
// don't spend a lot of time in loadlevel
// precache = false;
// G_InitNew (skill, episode, map);
// precache = true;
*/
usergame = false;
demoplayback = true;
}
void G_DeferedPlayDemo (char* name)
{
sprintf(MsgText, "-playdemo: %s\n", name);
WriteDebug(MsgText);
defdemoname = name;
gameaction = ga_playdemo;
demotype = DEMO_I;
}
void G_DoPlayDemo (void)
{
skill_t skill;
int i, episode, map, dversion, tversion;
demotype = DEMO_I;
tversion = VERSION;
gameaction = ga_nothing;
demobuffer = demo_p = W_CacheLumpName(defdemoname, PU_STATIC);
if (demobuffer == NULL)
{
sprintf(MsgText,"Demo %s is not in the WAD...\n", defdemoname);
WriteDebug(MsgText);
gameaction = ga_nothing;
return;
}
dversion = *demo_p;
if ( *demo_p++ != tversion)
{
sprintf(MsgText, "Demo version : %d.%d Game version : %d.%d\n",
dversion/100, dversion %100, VERSION/100, VERSION%100);
WriteDebug(MsgText);
gameaction = ga_nothing;
return;
}
skill = *demo_p++;
episode = *demo_p++;
map = *demo_p++;
deathmatch = *demo_p++;
respawnparm = *demo_p++;
fastparm = *demo_p++;
nomonsters = *demo_p++;
consoleplayer = *demo_p++;
for (i=0 ; i<MAXPLAYERS ; i++)
playeringame[i] = *demo_p++;
if (playeringame[1])
{
netgame = true;
netdemo = true;
}
// don't spend a lot of time in loadlevel
precache = false;
G_InitNew (skill, episode, map);
precache = true;
usergame = false;
demoplayback = true;
}
//
// G_TimeDemo
//
boolean G_TimeDemo_II(char* name)
{
static char demofilename[128];
sprintf(demofilename, "%s.dem", name);
if (access(demofilename, 0) != 0)
return false;
nodrawers = M_CheckParm ("-nodraw");
noblit = M_CheckParm ("-noblit");
timingdemo = true;
singletics = true;
defdemoname = demofilename;
gameaction = ga_playdemo;
demotype = DEMO_II;
sprintf(MsgText, "Playing timedemo II %s -noblit %d -nodraw %d\n", name, noblit, nodrawers);
WriteDebug(MsgText);
return true;
}
//
// G_TimeDemo
//
void G_TimeDemo(char* name)
{
nodrawers = M_CheckParm("-nodraw");
noblit = M_CheckParm("-noblit");
timingdemo = true;
singletics = true;
defdemoname = name;
gameaction = ga_playdemo;
sprintf(MsgText, "Playing timedemo %s -noblit %d -nodraw %d\n", name, noblit, nodrawers);
WriteDebug(MsgText);
}
/*
===================
=
= G_CheckDemoStatus
=
= Called after a death or level completion to allow demos to be cleaned up
= Returns true if a new demo loop action will take place
===================
*/
boolean G_CheckDemoStatus (void)
{
int endtime;
WriteDebug("G_CheckDemoStatus...\n");
if (timingdemo)
{
endtime = I_GetTime ();
I_Error ("timed %i gametics in %i realtics : %d FPS" ,gametic, endtime-starttime, (gametic*TICRATE)/(endtime-starttime));
}
if (demoplayback)
{
if (singledemo)
I_Quit ();
Z_ChangeTag (demobuffer, PU_CACHE);
demoplayback = false;
netdemo = false;
netgame = false;
deathmatch = false;
playeringame[1] = playeringame[2] = playeringame[3] = 0;
respawnparm = false;
fastparm = false;
nomonsters = false;
consoleplayer = 0;
D_AdvanceDemo ();
return true;
}
if (demorecording)
{
G_EndDemo();
I_Error ("Demo %s recorded",demoname);
}
return false;
}
void G_EndDemo_II()
{
*demo_p++ = DEMOMARKER;
M_AppendFile(demoname, demobuffer, demo_p - demobuffer);
Z_Free (demobuffer);
demorecording = false;
}
void G_EndDemo()
{
*demo_p++ = DEMOMARKER;
M_WriteFile (demoname, demobuffer, demo_p - demobuffer);
Z_Free (demobuffer);
demorecording = false;
}