// 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 // //----------------------------------------------------------------------------- #include "doom_config.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" #include "v_video.h" // Needs access to LFB. #include "w_wad.h" #include "p_local.h" #include "s_sound.h" #include "dstrings.h" // Data. #include "sounds.h" #include "r_data.h" // SKY handling - still the wrong place. #include "r_sky.h" #include "g_game.h" #define SAVEGAMESIZE 0x2c000 #define SAVESTRINGSIZE 24 #define MAXPLMOVE (forwardmove[1]) #define TURBOTHRESHOLD 0x32 #define SLOWTURNTICS 6 #define NUMKEYS 256 #define BODYQUESIZE 32 #define VERSIONSIZE 16 #define DEMOMARKER 0x80 // Prototypes doom_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_DoCompleted(void); void G_DoWorldDone(void); void G_DoSaveGame(void); void P_SpawnPlayer(mapthing_t* mthing); void R_ExecuteSetViewSize(void); gameaction_t gameaction; gamestate_t gamestate; skill_t gameskill; doom_boolean respawnmonsters; int gameepisode; int gamemap; doom_boolean paused; doom_boolean sendpause; // send a pause event next tic doom_boolean sendsave; // send a save event next tic doom_boolean usergame; // ok to save / end game doom_boolean timingdemo; // if true, exit with report on completion doom_boolean nodrawers; // for comparative timing purposes doom_boolean noblit; // for comparative timing purposes int starttime; // for comparative timing purposes doom_boolean viewactive; doom_boolean deathmatch; // only if started as net death doom_boolean netgame; // only true if packets are broadcast doom_boolean playeringame[MAXPLAYERS]; player_t players[MAXPLAYERS]; 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 char demoname[32]; doom_boolean demorecording; doom_boolean demoplayback; doom_boolean netdemo; byte* demobuffer; byte* demo_p; byte* demoend; doom_boolean singledemo; // quit after playing a demo from cmdline doom_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 mousebfire; int mousebstrafe; int mousebforward; int mousemove; int joybfire; int joybstrafe; int joybuse; int joybspeed; fixed_t forwardmove[2] = { 0x19, 0x32 }; fixed_t sidemove[2] = { 0x18, 0x28 }; fixed_t angleturn[3] = { 640, 1280, 320 }; // + slow turn doom_boolean gamekeydown[NUMKEYS]; int turnheld; // for accelerative turning doom_boolean mousearray[4]; doom_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; doom_boolean joyarray[5]; doom_boolean* joybuttons = &joyarray[1]; // allow [-1] int savegameslot; char savedescription[32]; mobj_t* bodyque[BODYQUESIZE]; int bodyqueslot; void* statcopy; // for statistics driver // 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 }; doom_boolean secretexit; char savename[256]; skill_t d_skill; int d_episode; int d_map; char* defdemoname; extern gamestate_t wipegamestate; extern char* pagename; extern doom_boolean setsizeneeded; // The sky texture to be used instead of the F_SKY1 dummy. extern int skytexture; 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; doom_boolean strafe; doom_boolean bstrafe; int speed; int tspeed; int forward; int side; ticcmd_t* base; base = I_BaseTiccmd(); // empty, or external driver doom_memcpy(cmd, base, sizeof(*cmd)); cmd->consistancy = consistancy[consoleplayer][maketic % BACKUPTICS]; strafe = gamekeydown[key_strafe] || mousebuttons[mousebstrafe] || joybuttons[joybstrafe]; extern int always_run; doom_boolean running = always_run ? (gamekeydown[key_speed] ? false : true) : (gamekeydown[key_speed] ? true : false); speed = running || joybuttons[joybspeed]; forward = side = 0; // use two stage accelerative turning // on the keyboard and joystick if (joyxmove < 0 || joyxmove > 0 || 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]) { side += sidemove[speed]; } if (gamekeydown[key_left]) { side -= sidemove[speed]; } 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 (joyxmove > 0) cmd->angleturn -= angleturn[tspeed]; if (joyxmove < 0) cmd->angleturn += angleturn[tspeed]; } if (gamekeydown[key_up]) { forward += forwardmove[speed]; } if (gamekeydown[key_down]) { forward -= forwardmove[speed]; } 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['1' + i]) { cmd->buttons |= BT_CHANGE; cmd->buttons |= i << BT_WEAPONSHIFT; break; } // mouse 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; } } // 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; } } if (mousemove) forward += mousey; if (strafe) side += mousex * 2; else cmd->angleturn -= mousex * 0x8; mousex = mousey = 0; 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 // 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) || (gamemode == pack_tnt) || (gamemode == pack_plut)) { skytexture = R_TextureNumForName("SKY3"); if (gamemap < 12) skytexture = R_TextureNumForName("SKY1"); else if (gamemap < 21) skytexture = R_TextureNumForName("SKY2"); } 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; doom_memset(players[i].frags, 0, sizeof(players[i].frags)); } P_SetupLevel(gameepisode, gamemap, 0, gameskill); displayplayer = consoleplayer; // view the guy you are playing starttime = I_GetTime(); gameaction = ga_nothing; Z_CheckHeap(); // clear cmd building stuff doom_memset(gamekeydown, 0, sizeof(gamekeydown)); joyxmove = joyymove = 0; mousex = mousey = 0; sendpause = sendsave = paused = false; doom_memset(mousebuttons, 0, sizeof(*mousebuttons) * 3); doom_memset(joybuttons, 0, sizeof(*joybuttons) * 4); } // // G_Responder // Get info needed to make ticcmd_ts for the players. // doom_boolean G_Responder(event_t* ev) { // allow spy mode changes even during the demo 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; } // 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)) { 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 (HU_Responder(ev)) return true; // chat ate the event if (ST_Responder(ev)) return true; // status window ate it if (AM_Responder(ev)) return true; // automap ate it } if (gamestate == GS_FINALE) { 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; // do player reborns if needed for (i = 0; i < MAXPLAYERS; i++) if (playeringame[i] && 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: G_DoPlayDemo(); 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; for (i = 0; i < MAXPLAYERS; i++) { if (playeringame[i]) { cmd = &players[i].cmd; doom_memcpy(cmd, &netcmds[i][buf], sizeof(ticcmd_t)); if (demoplayback) 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]; //doom_sprintf(turbomessage, "%s is turbo!", player_names[i]); doom_strcpy(turbomessage, player_names[i]); doom_concat(turbomessage, " is turbo!"); players[consoleplayer].message = turbomessage; } if (netgame && !netdemo && !(gametic % ticdup)) { if (gametic > BACKUPTICS && consistancy[i][buf] != cmd->consistancy) { //I_Error("Error: consistency failure (%i should be %i)", // cmd->consistancy, consistancy[i][buf]); doom_strcpy(error_buf, "Error: consistency failure ("); doom_concat(error_buf, doom_itoa(cmd->consistancy, 10)); doom_concat(error_buf, " should be "); doom_concat(error_buf, doom_itoa(consistancy[i][buf], 10)); doom_concat(error_buf, ")"); I_Error(error_buf); } if (players[i].mo) consistancy[i][buf] = players[i].mo->x; else consistancy[i][buf] = rndindex; } } } // check for special buttons for (i = 0; i < MAXPLAYERS; i++) { if (playeringame[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]) doom_strcpy(savedescription, "NET GAME"); savegameslot = (players[i].cmd.buttons & BTS_SAVEMASK) >> BTS_SAVESHIFT; gameaction = ga_savegame; break; } } } } // do main actions switch (gamestate) { case GS_LEVEL: P_Ticker(); ST_Ticker(); AM_Ticker(); HU_Ticker(); break; case GS_INTERMISSION: WI_Ticker(); break; case GS_FINALE: F_Ticker(); break; case GS_DEMOSCREEN: 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]; doom_memset(p->powers, 0, sizeof(p->powers)); doom_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; doom_memcpy(frags, players[player].frags, sizeof(frags)); killcount = players[player].killcount; itemcount = players[player].itemcount; secretcount = players[player].secretcount; p = &players[player]; doom_memset(p, 0, sizeof(*p)); doom_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 // doom_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) { // first spawn of level, before corpses for (i = 0; i < playernum; i++) 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 = (int)(deathmatch_p - deathmatchstarts); if (selections < 4) { //I_Error("Error: Only %i deathmatch spots, 4 required", selections); doom_strcpy(error_buf, "Error: Only "); doom_concat(error_buf, doom_itoa(selections, 10)); doom_concat(error_buf, " deathmatch spots, 4 required"); I_Error(error_buf); } for (j = 0; j < 20; j++) { i = P_Random() % selections; if (G_CheckSpot(playernum, &deathmatchstarts[i])) { deathmatchstarts[i].type = playernum + 1; P_SpawnPlayer(&deathmatchstarts[i]); return; } } // no good spot, so the player will probably get stuck P_SpawnPlayer(&playerstarts[playernum]); } // // 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 = 0; // 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; } // // G_DoCompleted // 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 ((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; } 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; doom_memcpy(wminfo.plyr[i].frags, players[i].frags , sizeof(wminfo.plyr[i].frags)); } gamestate = GS_INTERMISSION; viewactive = false; automapactive = false; if (statcopy) doom_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. // void G_LoadGame(char* name) { doom_strcpy(savename, name); gameaction = ga_loadgame; } 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 doom_memset(vcheck, 0, sizeof(vcheck)); //doom_sprintf(vcheck, "version %i", VERSION); doom_strcpy(vcheck, "version "); doom_concat(vcheck, doom_itoa(VERSION, 10)); if (doom_strcmp((const char*)save_p, (const char*)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("Error: Bad savegame"); // done Z_Free(savebuffer); if (setsizeneeded) R_ExecuteSetViewSize(); // draw the pattern into the back screen R_FillBackScreen(); } // // G_SaveGame // Called by the menu task. // Description is a 24 byte text string // void G_SaveGame(int slot, char* description) { savegameslot = slot; doom_strcpy(savedescription, description); sendsave = true; } void G_DoSaveGame(void) { char name[100]; char name2[VERSIONSIZE]; char* description; int length; int i; #if 0 if (M_CheckParm("-cdrom")) doom_sprintf(name, "c:\\doomdata\\"SAVEGAMENAME"%d.dsg", savegameslot); else #endif { //doom_sprintf(name, SAVEGAMENAME"%d.dsg", savegameslot); doom_strcpy(name, SAVEGAMENAME); doom_concat(name, doom_itoa(savegameslot, 10)); doom_concat(name, ".dsg"); } description = savedescription; save_p = savebuffer = screens[1] + 0x4000; doom_memcpy(save_p, description, SAVESTRINGSIZE); save_p += SAVESTRINGSIZE; doom_memset(name2, 0, sizeof(name2)); //doom_sprintf(name2, "version %i", VERSION); doom_strcpy(name2, "version "); doom_concat(name2, doom_itoa(VERSION, 10)); doom_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 = (int)(save_p - savebuffer); if (length > SAVEGAMESIZE) I_Error("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(); } // // G_InitNew // Can be called by the startup code or the menu task, // consoleplayer, displayplayer, playeringame[] should be set. // 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; } 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; 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; } G_DoLoadLevel(); } // // DEMO RECORDING // 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['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; doom_strcpy(demoname, name); doom_concat(demoname, ".lmp"); maxsize = 0x20000; i = M_CheckParm("-maxdemo"); if (i && i < myargc - 1) maxsize = doom_atoi(myargv[i + 1]) * 1024; demobuffer = Z_Malloc(maxsize, PU_STATIC, 0); demoend = demobuffer + maxsize; demorecording = true; } 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]; } // // G_PlayDemo // void G_DeferedPlayDemo(char* name) { defdemoname = name; gameaction = ga_playdemo; } void G_DoPlayDemo(void) { skill_t skill; int i, episode, map; gameaction = ga_nothing; demobuffer = demo_p = W_CacheLumpName(defdemoname, PU_STATIC); byte demo_version = *demo_p++; if (demo_version != VERSION && demo_version != 109) // Demos seem to run fine with version 109 { //doom_print("Demo is from a different game version! Demo Verson = %i, this version = %i\n", (int)demo_version, VERSION); doom_print("Demo is from a different game version! Demo Verson = "); doom_print(doom_itoa((int)demo_version, 10)); doom_print(", this version = "); doom_print(doom_itoa(VERSION, 10)); doom_print("\n"); 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 // void G_TimeDemo(char* name) { nodrawers = M_CheckParm("-nodraw"); noblit = M_CheckParm("-noblit"); timingdemo = true; singletics = true; defdemoname = name; gameaction = ga_playdemo; } /* =================== = = 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 =================== */ doom_boolean G_CheckDemoStatus(void) { int endtime; if (timingdemo) { endtime = I_GetTime(); //I_Error("Error: timed %i gametics in %i realtics", gametic // , endtime - starttime); doom_strcpy(error_buf, "Error: timed "); doom_concat(error_buf, doom_itoa(gametic, 10)); doom_concat(error_buf, " gametics in "); doom_concat(error_buf, doom_itoa(endtime - starttime, 10)); doom_concat(error_buf, " realtics"); I_Error(error_buf); } 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) { *demo_p++ = DEMOMARKER; M_WriteFile(demoname, demobuffer, (int)(demo_p - demobuffer)); Z_Free(demobuffer); demorecording = false; //I_Error("Error: Demo %s recorded", demoname); doom_strcpy(error_buf, "Error: Demo "); doom_concat(error_buf, demoname); doom_concat(error_buf, " recorded"); I_Error(error_buf); } return false; }