mirror of
https://github.com/ZDoom/gzdoom-gles.git
synced 2024-11-07 21:41:42 +00:00
2735 lines
65 KiB
C++
2735 lines
65 KiB
C++
/*
|
|
** g_level.cpp
|
|
** Parses MAPINFO and controls movement between levels
|
|
**
|
|
**---------------------------------------------------------------------------
|
|
** Copyright 1998-2005 Randy Heit
|
|
** All rights reserved.
|
|
**
|
|
** Redistribution and use in source and binary forms, with or without
|
|
** modification, are permitted provided that the following conditions
|
|
** are met:
|
|
**
|
|
** 1. Redistributions of source code must retain the above copyright
|
|
** notice, this list of conditions and the following disclaimer.
|
|
** 2. Redistributions in binary form must reproduce the above copyright
|
|
** notice, this list of conditions and the following disclaimer in the
|
|
** documentation and/or other materials provided with the distribution.
|
|
** 3. The name of the author may not be used to endorse or promote products
|
|
** derived from this software without specific prior written permission.
|
|
**
|
|
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
|
|
** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
|
|
** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
|
|
** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
|
|
** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
**---------------------------------------------------------------------------
|
|
**
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include "templates.h"
|
|
#include "d_main.h"
|
|
#include "m_alloc.h"
|
|
#include "g_level.h"
|
|
#include "g_game.h"
|
|
#include "s_sound.h"
|
|
#include "d_event.h"
|
|
#include "m_random.h"
|
|
#include "doomstat.h"
|
|
#include "wi_stuff.h"
|
|
#include "r_data.h"
|
|
#include "w_wad.h"
|
|
#include "am_map.h"
|
|
#include "c_dispatch.h"
|
|
#include "i_system.h"
|
|
#include "p_setup.h"
|
|
#include "p_local.h"
|
|
#include "r_sky.h"
|
|
#include "c_console.h"
|
|
#include "f_finale.h"
|
|
#include "gstrings.h"
|
|
#include "v_video.h"
|
|
#include "st_stuff.h"
|
|
#include "hu_stuff.h"
|
|
#include "p_saveg.h"
|
|
#include "p_acs.h"
|
|
#include "d_protocol.h"
|
|
#include "v_text.h"
|
|
#include "s_sndseq.h"
|
|
#include "b_bot.h"
|
|
#include "sc_man.h"
|
|
#include "sbar.h"
|
|
#include "a_lightning.h"
|
|
#include "m_png.h"
|
|
#include "m_random.h"
|
|
#include "version.h"
|
|
#include "m_menu.h"
|
|
#include "statnums.h"
|
|
|
|
#include "gi.h"
|
|
|
|
#include "g_hub.h"
|
|
|
|
EXTERN_CVAR (Float, sv_gravity)
|
|
EXTERN_CVAR (Float, sv_aircontrol)
|
|
EXTERN_CVAR (Int, disableautosave)
|
|
|
|
#define lioffset(x) myoffsetof(level_info_t,x)
|
|
#define cioffset(x) myoffsetof(cluster_info_t,x)
|
|
|
|
#define SNAP_ID MAKE_ID('s','n','A','p')
|
|
#define VIST_ID MAKE_ID('v','i','S','t')
|
|
#define ACSD_ID MAKE_ID('a','c','S','d')
|
|
#define RCLS_ID MAKE_ID('r','c','L','s')
|
|
#define PCLS_ID MAKE_ID('p','c','L','s')
|
|
|
|
static int FindEndSequence (int type, const char *picname);
|
|
static void SetEndSequence (char *nextmap, int type);
|
|
static void InitPlayerClasses ();
|
|
static void ParseEpisodeInfo ();
|
|
static void G_DoParseMapInfo (int lump);
|
|
static void SetLevelNum (level_info_t *info, int num);
|
|
|
|
static FRandom pr_classchoice ("RandomPlayerClassChoice");
|
|
|
|
TArray<EndSequence> EndSequences;
|
|
|
|
extern int timingdemo;
|
|
|
|
// Start time for timing demos
|
|
int starttime;
|
|
|
|
|
|
// ACS variables with world scope
|
|
SDWORD ACS_WorldVars[NUM_WORLDVARS];
|
|
TAutoGrowArray<SDWORD> ACS_WorldArrays[NUM_WORLDVARS];
|
|
|
|
// ACS variables with global scope
|
|
SDWORD ACS_GlobalVars[NUM_GLOBALVARS];
|
|
TAutoGrowArray<SDWORD> ACS_GlobalArrays[NUM_GLOBALVARS];
|
|
|
|
extern bool netdemo;
|
|
extern string BackupSaveName;
|
|
|
|
BOOL savegamerestore;
|
|
|
|
extern int mousex, mousey;
|
|
extern bool sendpause, sendsave, sendturn180, SendLand;
|
|
extern const AInventory *SendItemUse, *SendItemDrop;
|
|
|
|
void *statcopy; // for statistics driver
|
|
|
|
level_locals_t level; // info about current level
|
|
|
|
static cluster_info_t *wadclusterinfos;
|
|
static int numwadclusterinfos = 0;
|
|
level_info_t *wadlevelinfos;
|
|
int numwadlevelinfos = 0;
|
|
|
|
// MAPINFO is parsed slightly differently when the map name is just a number.
|
|
static bool HexenHack;
|
|
|
|
static level_info_t TheDefaultLevelInfo = { "", 0, "", "", "", "SKY1", 0, 0, 0, 0, NULL, "Unnamed", "COLORMAP", +8, -8 };
|
|
|
|
static cluster_info_t TheDefaultClusterInfo = { 0 };
|
|
|
|
|
|
|
|
static const char *MapInfoTopLevel[] =
|
|
{
|
|
"map",
|
|
"defaultmap",
|
|
"clusterdef",
|
|
"episode",
|
|
"clearepisodes",
|
|
NULL
|
|
};
|
|
|
|
enum
|
|
{
|
|
MITL_MAP,
|
|
MITL_DEFAULTMAP,
|
|
MITL_CLUSTERDEF,
|
|
MITL_EPISODE,
|
|
MITL_CLEAREPISODES
|
|
};
|
|
|
|
static const char *MapInfoMapLevel[] =
|
|
{
|
|
"levelnum",
|
|
"next",
|
|
"secretnext",
|
|
"cluster",
|
|
"sky1",
|
|
"sky2",
|
|
"fade",
|
|
"outsidefog",
|
|
"titlepatch",
|
|
"par",
|
|
"sucktime",
|
|
"music",
|
|
"nointermission",
|
|
"intermission",
|
|
"doublesky",
|
|
"nosoundclipping",
|
|
"allowmonstertelefrags",
|
|
"map07special",
|
|
"baronspecial",
|
|
"cyberdemonspecial",
|
|
"spidermastermindspecial",
|
|
"minotaurspecial",
|
|
"dsparilspecial",
|
|
"ironlichspecial",
|
|
"specialaction_exitlevel",
|
|
"specialaction_opendoor",
|
|
"specialaction_lowerfloor",
|
|
"specialaction_killmonsters",
|
|
"lightning",
|
|
"fadetable",
|
|
"evenlighting",
|
|
"noautosequences",
|
|
"forcenoskystretch",
|
|
"allowfreelook",
|
|
"nofreelook",
|
|
"allowjump",
|
|
"nojump",
|
|
"fallingdamage", // Hexen falling damage
|
|
"oldfallingdamage", // Lesser ZDoom falling damage
|
|
"forcefallingdamage", // Skull Tag compatibility name for oldfallingdamage
|
|
"strifefallingdamage", // Strife's falling damage is really unforgiving
|
|
"nofallingdamage",
|
|
"noallies",
|
|
"cdtrack",
|
|
"cdid",
|
|
"cd_start_track",
|
|
"cd_end1_track",
|
|
"cd_end2_track",
|
|
"cd_end3_track",
|
|
"cd_intermission_track",
|
|
"cd_title_track",
|
|
"warptrans",
|
|
"vertwallshade",
|
|
"horizwallshade",
|
|
"gravity",
|
|
"aircontrol",
|
|
"filterstarts",
|
|
"activateowndeathspecials",
|
|
"killeractivatesdeathspecials",
|
|
"noinventorybar",
|
|
"deathslideshow",
|
|
"redirect",
|
|
"strictmonsteractivation",
|
|
"laxmonsteractivation",
|
|
"additive_scrollers",
|
|
"cod_level",
|
|
"interpic",
|
|
"exitpic",
|
|
"enterpic",
|
|
"intermusic",
|
|
"airsupply",
|
|
"specialaction",
|
|
"keepfullinventory",
|
|
"monsterfallingdamage",
|
|
"nomonsterfallingdamage",
|
|
"sndseq",
|
|
"sndinfo",
|
|
"soundinfo",
|
|
"clipmidtextures",
|
|
NULL
|
|
};
|
|
|
|
enum EMIType
|
|
{
|
|
MITYPE_EATNEXT,
|
|
MITYPE_IGNORE,
|
|
MITYPE_INT,
|
|
MITYPE_FLOAT,
|
|
MITYPE_HEX,
|
|
MITYPE_COLOR,
|
|
MITYPE_MAPNAME,
|
|
MITYPE_LUMPNAME,
|
|
MITYPE_SKY,
|
|
MITYPE_SETFLAG,
|
|
MITYPE_CLRFLAG,
|
|
MITYPE_SCFLAGS,
|
|
MITYPE_CLUSTER,
|
|
MITYPE_STRING,
|
|
MITYPE_MUSIC,
|
|
MITYPE_RELLIGHT,
|
|
MITYPE_CLRBYTES,
|
|
MITYPE_REDIRECT,
|
|
MITYPE_SPECIALACTION
|
|
};
|
|
|
|
struct MapInfoHandler
|
|
{
|
|
EMIType type;
|
|
QWORD data1, data2;
|
|
}
|
|
MapHandlers[] =
|
|
{
|
|
{ MITYPE_INT, lioffset(levelnum), 0 },
|
|
{ MITYPE_MAPNAME, lioffset(nextmap), 0 },
|
|
{ MITYPE_MAPNAME, lioffset(secretmap), 0 },
|
|
{ MITYPE_CLUSTER, lioffset(cluster), 0 },
|
|
{ MITYPE_SKY, lioffset(skypic1), lioffset(skyspeed1) },
|
|
{ MITYPE_SKY, lioffset(skypic2), lioffset(skyspeed2) },
|
|
{ MITYPE_COLOR, lioffset(fadeto), 0 },
|
|
{ MITYPE_COLOR, lioffset(outsidefog), 0 },
|
|
{ MITYPE_LUMPNAME, lioffset(pname), 0 },
|
|
{ MITYPE_INT, lioffset(partime), 0 },
|
|
{ MITYPE_INT, lioffset(sucktime), 0 },
|
|
{ MITYPE_MUSIC, lioffset(music), lioffset(musicorder) },
|
|
{ MITYPE_SETFLAG, LEVEL_NOINTERMISSION, 0 },
|
|
{ MITYPE_CLRFLAG, LEVEL_NOINTERMISSION, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_DOUBLESKY, 0 },
|
|
{ MITYPE_IGNORE, 0, 0 }, // was nosoundclipping
|
|
{ MITYPE_SETFLAG, LEVEL_MONSTERSTELEFRAG, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_MAP07SPECIAL, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_BRUISERSPECIAL, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_CYBORGSPECIAL, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_SPIDERSPECIAL, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_MINOTAURSPECIAL, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_SORCERER2SPECIAL, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_HEADSPECIAL, 0 },
|
|
{ MITYPE_SCFLAGS, 0, ~LEVEL_SPECACTIONSMASK },
|
|
{ MITYPE_SCFLAGS, LEVEL_SPECOPENDOOR, ~LEVEL_SPECACTIONSMASK },
|
|
{ MITYPE_SCFLAGS, LEVEL_SPECLOWERFLOOR, ~LEVEL_SPECACTIONSMASK },
|
|
{ MITYPE_SETFLAG, LEVEL_SPECKILLMONSTERS, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_STARTLIGHTNING, 0 },
|
|
{ MITYPE_LUMPNAME, lioffset(fadetable), 0 },
|
|
{ MITYPE_CLRBYTES, lioffset(WallVertLight), lioffset(WallHorizLight) },
|
|
{ MITYPE_SETFLAG, LEVEL_SNDSEQTOTALCTRL, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_FORCENOSKYSTRETCH, 0 },
|
|
{ MITYPE_SCFLAGS, LEVEL_FREELOOK_YES, ~LEVEL_FREELOOK_NO },
|
|
{ MITYPE_SCFLAGS, LEVEL_FREELOOK_NO, ~LEVEL_FREELOOK_YES },
|
|
{ MITYPE_SCFLAGS, LEVEL_JUMP_YES, ~LEVEL_JUMP_NO },
|
|
{ MITYPE_SCFLAGS, LEVEL_JUMP_NO, ~LEVEL_JUMP_YES },
|
|
{ MITYPE_SCFLAGS, LEVEL_FALLDMG_HX, ~LEVEL_FALLDMG_ZD },
|
|
{ MITYPE_SCFLAGS, LEVEL_FALLDMG_ZD, ~LEVEL_FALLDMG_HX },
|
|
{ MITYPE_SCFLAGS, LEVEL_FALLDMG_ZD, ~LEVEL_FALLDMG_HX },
|
|
{ MITYPE_SCFLAGS, LEVEL_FALLDMG_ZD|LEVEL_FALLDMG_HX, 0 },
|
|
{ MITYPE_SCFLAGS, 0, ~(LEVEL_FALLDMG_ZD|LEVEL_FALLDMG_HX) },
|
|
{ MITYPE_SETFLAG, LEVEL_NOALLIES, 0 },
|
|
{ MITYPE_INT, lioffset(cdtrack), 0 },
|
|
{ MITYPE_HEX, lioffset(cdid), 0 },
|
|
{ MITYPE_EATNEXT, 0, 0 },
|
|
{ MITYPE_EATNEXT, 0, 0 },
|
|
{ MITYPE_EATNEXT, 0, 0 },
|
|
{ MITYPE_EATNEXT, 0, 0 },
|
|
{ MITYPE_EATNEXT, 0, 0 },
|
|
{ MITYPE_EATNEXT, 0, 0 },
|
|
{ MITYPE_INT, lioffset(WarpTrans), 0 },
|
|
{ MITYPE_RELLIGHT, lioffset(WallVertLight), 0 },
|
|
{ MITYPE_RELLIGHT, lioffset(WallHorizLight), 0 },
|
|
{ MITYPE_FLOAT, lioffset(gravity), 0 },
|
|
{ MITYPE_FLOAT, lioffset(aircontrol), 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_FILTERSTARTS, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_ACTOWNSPECIAL, 0 },
|
|
{ MITYPE_CLRFLAG, LEVEL_ACTOWNSPECIAL, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_NOINVENTORYBAR, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_DEATHSLIDESHOW, 0 },
|
|
{ MITYPE_REDIRECT, lioffset(RedirectMap), 0 },
|
|
{ MITYPE_CLRFLAG, LEVEL_LAXMONSTERACTIVATION, LEVEL_LAXACTIVATIONMAPINFO },
|
|
{ MITYPE_SETFLAG, LEVEL_LAXMONSTERACTIVATION, LEVEL_LAXACTIVATIONMAPINFO },
|
|
{ MITYPE_SETFLAG, LEVEL_ADDITIVE_SCROLLERS, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_CAVERNS_OF_DARKNESS, 0 },
|
|
{ MITYPE_LUMPNAME, lioffset(exitpic), 0 },
|
|
{ MITYPE_LUMPNAME, lioffset(exitpic), 0 },
|
|
{ MITYPE_LUMPNAME, lioffset(enterpic), 0 },
|
|
{ MITYPE_LUMPNAME, lioffset(intermusic), 0 },
|
|
{ MITYPE_INT, lioffset(airsupply), 0 },
|
|
{ MITYPE_SPECIALACTION, lioffset(specialactions), 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_KEEPFULLINVENTORY, 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_MONSTERFALLINGDAMAGE, 0 },
|
|
{ MITYPE_CLRFLAG, LEVEL_MONSTERFALLINGDAMAGE, 0 },
|
|
{ MITYPE_LUMPNAME, lioffset(sndseq), 0 },
|
|
{ MITYPE_LUMPNAME, lioffset(soundinfo), 0 },
|
|
{ MITYPE_LUMPNAME, lioffset(soundinfo), 0 },
|
|
{ MITYPE_SETFLAG, LEVEL_CLIPMIDTEX, 0 },
|
|
};
|
|
|
|
static const char *MapInfoClusterLevel[] =
|
|
{
|
|
"entertext",
|
|
"exittext",
|
|
"music",
|
|
"flat",
|
|
"pic",
|
|
"hub",
|
|
"cdtrack",
|
|
"cdid",
|
|
"entertextislump",
|
|
"exittextislump",
|
|
"name",
|
|
NULL
|
|
};
|
|
|
|
MapInfoHandler ClusterHandlers[] =
|
|
{
|
|
{ MITYPE_STRING, cioffset(entertext), CLUSTER_LOOKUPENTERTEXT },
|
|
{ MITYPE_STRING, cioffset(exittext), CLUSTER_LOOKUPEXITTEXT },
|
|
{ MITYPE_MUSIC, cioffset(messagemusic), cioffset(musicorder) },
|
|
{ MITYPE_LUMPNAME, cioffset(finaleflat), 0 },
|
|
{ MITYPE_LUMPNAME, cioffset(finaleflat), CLUSTER_FINALEPIC },
|
|
{ MITYPE_SETFLAG, CLUSTER_HUB, 0 },
|
|
{ MITYPE_INT, cioffset(cdtrack), 0 },
|
|
{ MITYPE_HEX, cioffset(cdid), 0 },
|
|
{ MITYPE_SETFLAG, CLUSTER_ENTERTEXTINLUMP, 0 },
|
|
{ MITYPE_SETFLAG, CLUSTER_EXITTEXTINLUMP, 0 },
|
|
{ MITYPE_STRING, cioffset(clustername), 0 },
|
|
};
|
|
|
|
static void ParseMapInfoLower (MapInfoHandler *handlers,
|
|
const char *strings[],
|
|
level_info_t *levelinfo,
|
|
cluster_info_t *clusterinfo,
|
|
QWORD levelflags);
|
|
|
|
static int FindWadLevelInfo (char *name)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < numwadlevelinfos; i++)
|
|
if (!strnicmp (name, wadlevelinfos[i].mapname, 8))
|
|
return i;
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int FindWadClusterInfo (int cluster)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < numwadclusterinfos; i++)
|
|
if (wadclusterinfos[i].cluster == cluster)
|
|
return i;
|
|
|
|
return -1;
|
|
}
|
|
|
|
static void SetLevelDefaults (level_info_t *levelinfo)
|
|
{
|
|
memset (levelinfo, 0, sizeof(*levelinfo));
|
|
levelinfo->snapshot = NULL;
|
|
levelinfo->outsidefog = 0xff000000;
|
|
levelinfo->WallHorizLight = -8;
|
|
levelinfo->WallVertLight = +8;
|
|
strncpy (levelinfo->fadetable, "COLORMAP", 8);
|
|
strcpy (levelinfo->skypic1, "-NOFLAT-");
|
|
strcpy (levelinfo->skypic2, "-NOFLAT-");
|
|
if (gameinfo.gametype != GAME_Hexen)
|
|
{
|
|
// For maps without a BEHAVIOR, this will be cleared.
|
|
levelinfo->flags |= LEVEL_LAXMONSTERACTIVATION;
|
|
}
|
|
else
|
|
{
|
|
levelinfo->flags |= LEVEL_MONSTERFALLINGDAMAGE;
|
|
}
|
|
levelinfo->airsupply = 10;
|
|
}
|
|
|
|
//
|
|
// G_ParseMapInfo
|
|
// Parses the MAPINFO lumps of all loaded WADs and generates
|
|
// data for wadlevelinfos and wadclusterinfos.
|
|
//
|
|
void G_ParseMapInfo ()
|
|
{
|
|
int lump, lastlump = 0;
|
|
|
|
// Parse the default MAPINFO for the current game.
|
|
switch (gameinfo.gametype)
|
|
{
|
|
case GAME_Doom:
|
|
switch (gamemission)
|
|
{
|
|
case doom:
|
|
G_DoParseMapInfo (Wads.GetNumForName ("D1INFO"));
|
|
break;
|
|
case pack_plut:
|
|
G_DoParseMapInfo (Wads.GetNumForName ("PLUTINFO"));
|
|
break;
|
|
case pack_tnt:
|
|
G_DoParseMapInfo (Wads.GetNumForName ("TNTINFO"));
|
|
break;
|
|
default:
|
|
G_DoParseMapInfo (Wads.GetNumForName ("D2INFO"));
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case GAME_Heretic:
|
|
G_DoParseMapInfo (Wads.GetNumForName ("HERINFO"));
|
|
break;
|
|
|
|
case GAME_Hexen:
|
|
G_DoParseMapInfo (Wads.GetNumForName ("HEXNINFO"));
|
|
break;
|
|
|
|
case GAME_Strife:
|
|
G_DoParseMapInfo (Wads.GetNumForName ("STRFINFO"));
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
// Parse any extra MAPINFOs.
|
|
while ((lump = Wads.FindLump ("MAPINFO", &lastlump)) != -1)
|
|
{
|
|
G_DoParseMapInfo (lump);
|
|
}
|
|
EndSequences.ShrinkToFit ();
|
|
|
|
if (EpiDef.numitems == 0)
|
|
{
|
|
I_FatalError ("You cannot use clearepisodes in a MAPINFO if you do not define any new episodes after it.");
|
|
}
|
|
}
|
|
|
|
static void G_DoParseMapInfo (int lump)
|
|
{
|
|
level_info_t defaultinfo;
|
|
level_info_t *levelinfo;
|
|
int levelindex;
|
|
cluster_info_t *clusterinfo;
|
|
int clusterindex;
|
|
QWORD levelflags;
|
|
|
|
SetLevelDefaults (&defaultinfo);
|
|
SC_OpenLumpNum (lump, "MAPINFO");
|
|
HexenHack=false;
|
|
|
|
while (SC_GetString ())
|
|
{
|
|
switch (SC_MustMatchString (MapInfoTopLevel))
|
|
{
|
|
case MITL_DEFAULTMAP:
|
|
SetLevelDefaults (&defaultinfo);
|
|
ParseMapInfoLower (MapHandlers, MapInfoMapLevel, &defaultinfo, NULL, defaultinfo.flags);
|
|
break;
|
|
|
|
case MITL_MAP: // map <MAPNAME> <Nice Name>
|
|
levelflags = defaultinfo.flags;
|
|
SC_MustGetString ();
|
|
if (IsNum (sc_String))
|
|
{ // MAPNAME is a number; assume a Hexen wad
|
|
int map = atoi (sc_String);
|
|
sprintf (sc_String, "MAP%02d", map);
|
|
HexenHack = true;
|
|
// Hexen levels are automatically nointermission,
|
|
// no auto sound sequences, falling damage, and
|
|
// monsters activate their own specials.
|
|
levelflags |= LEVEL_NOINTERMISSION
|
|
| LEVEL_SNDSEQTOTALCTRL
|
|
| LEVEL_FALLDMG_HX
|
|
| LEVEL_ACTOWNSPECIAL;
|
|
}
|
|
levelindex = FindWadLevelInfo (sc_String);
|
|
if (levelindex == -1)
|
|
{
|
|
levelindex = numwadlevelinfos++;
|
|
wadlevelinfos = (level_info_t *)Realloc (wadlevelinfos, sizeof(level_info_t)*numwadlevelinfos);
|
|
}
|
|
levelinfo = wadlevelinfos + levelindex;
|
|
memcpy (levelinfo, &defaultinfo, sizeof(*levelinfo));
|
|
if (HexenHack)
|
|
{
|
|
levelinfo->WallHorizLight = levelinfo->WallVertLight = 0;
|
|
}
|
|
uppercopy (levelinfo->mapname, sc_String);
|
|
SC_MustGetString ();
|
|
if (SC_Compare ("lookup"))
|
|
{
|
|
SC_MustGetString ();
|
|
ReplaceString (&levelinfo->level_name, sc_String);
|
|
levelflags |= LEVEL_LOOKUPLEVELNAME;
|
|
}
|
|
else
|
|
{
|
|
ReplaceString (&levelinfo->level_name, sc_String);
|
|
}
|
|
// Set up levelnum now so that you can use Teleport_NewMap specials
|
|
// to teleport to maps with standard names without needing a levelnum.
|
|
if (!strnicmp (levelinfo->mapname, "MAP", 3) && levelinfo->mapname[5] == 0)
|
|
{
|
|
int mapnum = atoi (levelinfo->mapname + 3);
|
|
|
|
if (mapnum >= 1 && mapnum <= 99)
|
|
levelinfo->levelnum = mapnum;
|
|
}
|
|
else if (levelinfo->mapname[0] == 'E' &&
|
|
levelinfo->mapname[1] >= '0' && levelinfo->mapname[1] <= '9' &&
|
|
levelinfo->mapname[2] == 'M' &&
|
|
levelinfo->mapname[3] >= '0' && levelinfo->mapname[3] <= '9')
|
|
{
|
|
int epinum = levelinfo->mapname[1] - '1';
|
|
int mapnum = levelinfo->mapname[3] - '0';
|
|
levelinfo->levelnum = epinum*10 + mapnum;
|
|
}
|
|
ParseMapInfoLower (MapHandlers, MapInfoMapLevel, levelinfo, NULL, levelflags);
|
|
// When the second sky is -NOFLAT-, make it a copy of the first sky
|
|
if (strcmp (levelinfo->skypic2, "-NOFLAT-") == 0)
|
|
{
|
|
strcpy (levelinfo->skypic2, levelinfo->skypic1);
|
|
}
|
|
SetLevelNum (levelinfo, levelinfo->levelnum); // Wipe out matching levelnums from other maps.
|
|
if (levelinfo->pname[0] != 0 && TexMan.CheckForTexture (levelinfo->pname, FTexture::TEX_MiscPatch) < 0)
|
|
{
|
|
int lumpnum = Wads.CheckNumForName (levelinfo->pname);
|
|
if (lumpnum >= 0)
|
|
{
|
|
TexMan.CreateTexture (lumpnum, FTexture::TEX_MiscPatch);
|
|
}
|
|
else
|
|
{
|
|
levelinfo->pname[0] = 0;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MITL_CLUSTERDEF: // clusterdef <clusternum>
|
|
SC_MustGetNumber ();
|
|
clusterindex = FindWadClusterInfo (sc_Number);
|
|
if (clusterindex == -1)
|
|
{
|
|
clusterindex = numwadclusterinfos++;
|
|
wadclusterinfos = (cluster_info_t *)Realloc (wadclusterinfos, sizeof(cluster_info_t)*numwadclusterinfos);
|
|
clusterinfo = wadclusterinfos + clusterindex;
|
|
}
|
|
else
|
|
{
|
|
clusterinfo = wadclusterinfos + clusterindex;
|
|
if (clusterinfo->entertext != NULL)
|
|
{
|
|
delete[] clusterinfo->entertext;
|
|
}
|
|
if (clusterinfo->exittext != NULL)
|
|
{
|
|
delete[] clusterinfo->exittext;
|
|
}
|
|
if (clusterinfo->messagemusic != NULL)
|
|
{
|
|
delete[] clusterinfo->messagemusic;
|
|
}
|
|
}
|
|
memset (clusterinfo, 0, sizeof(cluster_info_t));
|
|
clusterinfo->cluster = sc_Number;
|
|
ParseMapInfoLower (ClusterHandlers, MapInfoClusterLevel, NULL, clusterinfo, 0);
|
|
break;
|
|
|
|
case MITL_EPISODE:
|
|
ParseEpisodeInfo ();
|
|
break;
|
|
|
|
case MITL_CLEAREPISODES:
|
|
for (int i = 0; i < EpiDef.numitems; ++i)
|
|
{
|
|
delete[] const_cast<char *>(EpisodeMenu[i].name);
|
|
EpisodeMenu[i].name = NULL;
|
|
}
|
|
EpiDef.numitems = 0;
|
|
break;
|
|
}
|
|
}
|
|
SC_Close ();
|
|
}
|
|
|
|
static void ParseMapInfoLower (MapInfoHandler *handlers,
|
|
const char *strings[],
|
|
level_info_t *levelinfo,
|
|
cluster_info_t *clusterinfo,
|
|
QWORD flags)
|
|
{
|
|
int entry;
|
|
MapInfoHandler *handler;
|
|
byte *info;
|
|
|
|
info = levelinfo ? (byte *)levelinfo : (byte *)clusterinfo;
|
|
|
|
while (SC_GetString ())
|
|
{
|
|
if (SC_MatchString (MapInfoTopLevel) != -1)
|
|
{
|
|
SC_UnGet ();
|
|
break;
|
|
}
|
|
entry = SC_MustMatchString (strings);
|
|
handler = handlers + entry;
|
|
switch (handler->type)
|
|
{
|
|
case MITYPE_EATNEXT:
|
|
SC_MustGetString ();
|
|
break;
|
|
|
|
case MITYPE_IGNORE:
|
|
break;
|
|
|
|
case MITYPE_INT:
|
|
SC_MustGetNumber ();
|
|
*((int *)(info + handler->data1)) = sc_Number;
|
|
break;
|
|
|
|
case MITYPE_FLOAT:
|
|
SC_MustGetFloat ();
|
|
*((float *)(info + handler->data1)) = sc_Float;
|
|
break;
|
|
|
|
case MITYPE_HEX:
|
|
SC_MustGetString ();
|
|
*((int *)(info + handler->data1)) = strtoul (sc_String, NULL, 16);
|
|
break;
|
|
|
|
case MITYPE_COLOR:
|
|
SC_MustGetString ();
|
|
*((DWORD *)(info + handler->data1)) = V_GetColor (NULL, sc_String);
|
|
break;
|
|
|
|
case MITYPE_REDIRECT:
|
|
SC_MustGetString ();
|
|
levelinfo->RedirectType = TypeInfo::IFindType (sc_String);
|
|
if (levelinfo->RedirectType == NULL ||
|
|
!(levelinfo->RedirectType->IsDescendantOf (RUNTIME_CLASS(AInventory))))
|
|
{
|
|
SC_ScriptError ("%s is not an inventory item", sc_String);
|
|
}
|
|
// Intentional fall-through
|
|
|
|
case MITYPE_MAPNAME: {
|
|
EndSequence newSeq;
|
|
bool useseq = false;
|
|
|
|
SC_MustGetString ();
|
|
if (IsNum (sc_String))
|
|
{
|
|
int map = atoi (sc_String);
|
|
|
|
if (HexenHack)
|
|
{
|
|
sprintf (sc_String, "&wt@%02d", map);
|
|
}
|
|
else
|
|
{
|
|
sprintf (sc_String, "MAP%02d", map);
|
|
}
|
|
}
|
|
if (strnicmp (sc_String, "EndGame", 7) == 0)
|
|
{
|
|
int type;
|
|
switch (sc_String[7])
|
|
{
|
|
case '1': type = END_Pic1; break;
|
|
case '2': type = END_Pic2; break;
|
|
case '3': type = END_Bunny; break;
|
|
case 'C': type = END_Cast; break;
|
|
case 'W': type = END_Underwater; break;
|
|
case 'S': type = END_Strife; break;
|
|
default: type = END_Pic3; break;
|
|
}
|
|
newSeq.EndType = type;
|
|
useseq = true;
|
|
}
|
|
else if (SC_Compare ("endpic"))
|
|
{
|
|
SC_MustGetString ();
|
|
newSeq.EndType = END_Pic;
|
|
strncpy (newSeq.PicName, sc_String, 8);
|
|
newSeq.PicName[8] = 0;
|
|
useseq = true;
|
|
}
|
|
else if (SC_Compare ("endbunny"))
|
|
{
|
|
newSeq.EndType = END_Bunny;
|
|
useseq = true;
|
|
}
|
|
else if (SC_Compare ("endcast"))
|
|
{
|
|
newSeq.EndType = END_Cast;
|
|
useseq = true;
|
|
}
|
|
else if (SC_Compare ("enddemon"))
|
|
{
|
|
newSeq.EndType = END_Demon;
|
|
useseq = true;
|
|
}
|
|
else if (SC_Compare ("endchess"))
|
|
{
|
|
newSeq.EndType = END_Chess;
|
|
useseq = true;
|
|
}
|
|
else if (SC_Compare ("endunderwater"))
|
|
{
|
|
newSeq.EndType = END_Underwater;
|
|
useseq = true;
|
|
}
|
|
else if (SC_Compare ("endbuystrife"))
|
|
{
|
|
newSeq.EndType = END_BuyStrife;
|
|
useseq = true;
|
|
}
|
|
else
|
|
{
|
|
strncpy ((char *)(info + handler->data1), sc_String, 8);
|
|
}
|
|
if (useseq)
|
|
{
|
|
int seqnum = FindEndSequence (newSeq.EndType, newSeq.PicName);
|
|
if (seqnum == -1)
|
|
{
|
|
seqnum = (int)EndSequences.Push (newSeq);
|
|
}
|
|
strcpy ((char *)(info + handler->data1), "enDSeQ");
|
|
*((WORD *)(info + handler->data1 + 6)) = (WORD)seqnum;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case MITYPE_LUMPNAME:
|
|
SC_MustGetString ();
|
|
uppercopy ((char *)(info + handler->data1), sc_String);
|
|
flags |= handler->data2;
|
|
break;
|
|
|
|
case MITYPE_SKY:
|
|
SC_MustGetString (); // get texture name;
|
|
uppercopy ((char *)(info + handler->data1), sc_String);
|
|
SC_MustGetFloat (); // get scroll speed
|
|
if (HexenHack)
|
|
{
|
|
*((fixed_t *)(info + handler->data2)) = sc_Number << 8;
|
|
}
|
|
else
|
|
{
|
|
*((fixed_t *)(info + handler->data2)) = (fixed_t)(sc_Float * 65536.0f);
|
|
}
|
|
break;
|
|
|
|
case MITYPE_SETFLAG:
|
|
flags |= handler->data1;
|
|
flags |= handler->data2;
|
|
break;
|
|
|
|
case MITYPE_CLRFLAG:
|
|
flags &= ~handler->data1;
|
|
flags |= handler->data2;
|
|
break;
|
|
|
|
case MITYPE_SCFLAGS:
|
|
flags = (flags & handler->data2) | handler->data1;
|
|
break;
|
|
|
|
case MITYPE_CLUSTER:
|
|
SC_MustGetNumber ();
|
|
*((int *)(info + handler->data1)) = sc_Number;
|
|
// If this cluster hasn't been defined yet, add it. This is especially needed
|
|
// for Hexen, because it doesn't have clusterdefs. If we don't do this, every
|
|
// level on Hexen will sometimes be considered as being on the same hub,
|
|
// depending on the check done.
|
|
if (FindWadClusterInfo (sc_Number) == -1)
|
|
{
|
|
int clusterindex = numwadclusterinfos++;
|
|
wadclusterinfos = (cluster_info_t *)Realloc (wadclusterinfos, sizeof(cluster_info_t)*numwadclusterinfos);
|
|
clusterinfo = wadclusterinfos + clusterindex;
|
|
memset (clusterinfo, 0, sizeof(cluster_info_t));
|
|
clusterinfo->cluster = sc_Number;
|
|
if (gameinfo.gametype == GAME_Hexen)
|
|
{
|
|
clusterinfo->flags |= CLUSTER_HUB;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MITYPE_STRING:
|
|
SC_MustGetString ();
|
|
if (SC_Compare ("lookup"))
|
|
{
|
|
flags |= handler->data2;
|
|
SC_MustGetString ();
|
|
}
|
|
ReplaceString ((char **)(info + handler->data1), sc_String);
|
|
break;
|
|
|
|
case MITYPE_MUSIC:
|
|
SC_MustGetString ();
|
|
{
|
|
char *colon = strchr (sc_String, ':');
|
|
if (colon)
|
|
{
|
|
*colon = 0;
|
|
}
|
|
ReplaceString ((char **)(info + handler->data1), sc_String);
|
|
*((int *)(info + handler->data2)) = colon ? atoi (colon + 1) : 0;
|
|
if (levelinfo != NULL)
|
|
{
|
|
// Flag the level so that the $MAP command doesn't override this.
|
|
flags|=LEVEL_MUSICDEFINED;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MITYPE_RELLIGHT:
|
|
SC_MustGetNumber ();
|
|
*((SBYTE *)(info + handler->data1)) = (SBYTE)clamp (sc_Number / 2, -128, 127);
|
|
break;
|
|
|
|
case MITYPE_CLRBYTES:
|
|
*((BYTE *)(info + handler->data1)) = 0;
|
|
*((BYTE *)(info + handler->data2)) = 0;
|
|
break;
|
|
|
|
case MITYPE_SPECIALACTION:
|
|
{
|
|
int FindLineSpecial(const char *str);
|
|
|
|
FSpecialAction **so = (FSpecialAction**)(info + handler->data1);
|
|
FSpecialAction *sa = new FSpecialAction;
|
|
sa->Next = *so;
|
|
*so = sa;
|
|
SC_SetCMode(true);
|
|
SC_MustGetString();
|
|
sa->Type = name(sc_String);
|
|
SC_CheckString(",");
|
|
SC_MustGetString();
|
|
strlwr(sc_String);
|
|
sa->Action = FindLineSpecial(sc_String);
|
|
int j = 0;
|
|
while (j < 5 && SC_CheckString(","))
|
|
{
|
|
SC_MustGetNumber();
|
|
sa->Args[j++] = sc_Number;
|
|
}
|
|
SC_SetCMode(false);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
if (levelinfo)
|
|
{
|
|
levelinfo->flags = flags;
|
|
}
|
|
else
|
|
{
|
|
clusterinfo->flags = flags;
|
|
}
|
|
}
|
|
|
|
// Episode definitions start with the header "episode <start-map>"
|
|
// and then can be followed by any of the following:
|
|
//
|
|
// name "Episode name as text"
|
|
// picname "Picture to display the episode name"
|
|
// key "Shortcut key for the menu"
|
|
// remove
|
|
|
|
static void ParseEpisodeInfo ()
|
|
{
|
|
int i;
|
|
char map[9];
|
|
char *pic = NULL;
|
|
bool picisgfx = false; // Shut up, GCC!!!!
|
|
bool remove = false;
|
|
char key = 0;
|
|
bool addedgfx = false;
|
|
|
|
// Get map name
|
|
SC_MustGetString ();
|
|
uppercopy (map, sc_String);
|
|
map[8] = 0;
|
|
|
|
SC_MustGetString ();
|
|
if (SC_Compare ("teaser"))
|
|
{
|
|
SC_MustGetString ();
|
|
if (gameinfo.flags & GI_SHAREWARE)
|
|
{
|
|
uppercopy (map, sc_String);
|
|
}
|
|
SC_MustGetString ();
|
|
}
|
|
do
|
|
{
|
|
if (SC_Compare ("name"))
|
|
{
|
|
SC_MustGetString ();
|
|
ReplaceString (&pic, sc_String);
|
|
picisgfx = false;
|
|
}
|
|
else if (SC_Compare ("picname"))
|
|
{
|
|
SC_MustGetString ();
|
|
ReplaceString (&pic, sc_String);
|
|
picisgfx = true;
|
|
}
|
|
else if (SC_Compare ("remove"))
|
|
{
|
|
remove = true;
|
|
}
|
|
else if (SC_Compare ("key"))
|
|
{
|
|
SC_MustGetString ();
|
|
key = sc_String[0];
|
|
}
|
|
else
|
|
{
|
|
SC_UnGet ();
|
|
break;
|
|
}
|
|
}
|
|
while (SC_GetString ());
|
|
|
|
for (i = 0; i < EpiDef.numitems; ++i)
|
|
{
|
|
if (strncmp (EpisodeMaps[i], map, 8) == 0)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (remove)
|
|
{
|
|
// If the remove property is given for an episode, remove it.
|
|
if (i < EpiDef.numitems)
|
|
{
|
|
if (i+1 < EpiDef.numitems)
|
|
{
|
|
memmove (&EpisodeMaps[i], &EpisodeMaps[i+1],
|
|
sizeof(EpisodeMaps[0])*(EpiDef.numitems - i - 1));
|
|
memmove (&EpisodeMenu[i], &EpisodeMenu[i+1],
|
|
sizeof(EpisodeMenu[0])*(EpiDef.numitems - i - 1));
|
|
}
|
|
EpiDef.numitems--;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pic == NULL)
|
|
{
|
|
pic = copystring (map);
|
|
picisgfx = false;
|
|
}
|
|
|
|
if (i == EpiDef.numitems)
|
|
{
|
|
if (EpiDef.numitems == MAX_EPISODES)
|
|
{
|
|
i = EpiDef.numitems - 1;
|
|
}
|
|
else
|
|
{
|
|
i = EpiDef.numitems++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
delete[] const_cast<char *>(EpisodeMenu[i].name);
|
|
}
|
|
|
|
EpisodeMenu[i].name = pic;
|
|
EpisodeMenu[i].alphaKey = tolower(key);
|
|
EpisodeMenu[i].fulltext = !picisgfx;
|
|
strncpy (EpisodeMaps[i], map, 8);
|
|
|
|
if (picisgfx)
|
|
{
|
|
if (TexMan.CheckForTexture (pic, FTexture::TEX_MiscPatch, 0) == -1)
|
|
{
|
|
TexMan.AddPatch (pic);
|
|
addedgfx = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
static int FindEndSequence (int type, const char *picname)
|
|
{
|
|
unsigned int i, num;
|
|
|
|
num = EndSequences.Size ();
|
|
for (i = 0; i < num; i++)
|
|
{
|
|
if (EndSequences[i].EndType == type &&
|
|
(type != END_Pic || stricmp (EndSequences[i].PicName, picname) == 0))
|
|
{
|
|
return (int)i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
static void SetEndSequence (char *nextmap, int type)
|
|
{
|
|
int seqnum;
|
|
|
|
seqnum = FindEndSequence (type, NULL);
|
|
if (seqnum == -1)
|
|
{
|
|
EndSequence newseq;
|
|
newseq.EndType = type;
|
|
memset (newseq.PicName, 0, sizeof(newseq.PicName));
|
|
seqnum = (int)EndSequences.Push (newseq);
|
|
}
|
|
strcpy (nextmap, "enDSeQ");
|
|
*((WORD *)(nextmap + 6)) = (WORD)seqnum;
|
|
}
|
|
|
|
void G_SetForEndGame (char *nextmap)
|
|
{
|
|
if (!strncmp(nextmap, "enDSeQ",6)) return; // If there is already an end sequence please leave it alone!!!
|
|
|
|
if (gameinfo.gametype == GAME_Strife)
|
|
{
|
|
SetEndSequence (nextmap, gameinfo.flags & GI_SHAREWARE ? END_BuyStrife : END_Strife);
|
|
}
|
|
else if (gameinfo.gametype == GAME_Hexen)
|
|
{
|
|
SetEndSequence (nextmap, END_Chess);
|
|
}
|
|
else if (gamemode == commercial)
|
|
{
|
|
SetEndSequence (nextmap, END_Cast);
|
|
}
|
|
else
|
|
{ // The ExMx games actually have different ends based on the episode,
|
|
// but I want to keep this simple.
|
|
SetEndSequence (nextmap, END_Pic1);
|
|
}
|
|
}
|
|
|
|
level_info_t *FindLevelByWarpTrans (int num)
|
|
{
|
|
int i;
|
|
|
|
for (i = numwadlevelinfos - 1; i >= 0; --i)
|
|
if (wadlevelinfos[i].WarpTrans == num)
|
|
return (level_info_t *)(wadlevelinfos + i);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static void zapDefereds (acsdefered_t *def)
|
|
{
|
|
while (def)
|
|
{
|
|
acsdefered_t *next = def->next;
|
|
delete def;
|
|
def = next;
|
|
}
|
|
}
|
|
|
|
void P_RemoveDefereds (void)
|
|
{
|
|
int i;
|
|
|
|
// Remove any existing defereds
|
|
for (i = 0; i < numwadlevelinfos; i++)
|
|
{
|
|
if (wadlevelinfos[i].defered)
|
|
{
|
|
zapDefereds (wadlevelinfos[i].defered);
|
|
wadlevelinfos[i].defered = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CheckWarpTransMap (char mapname[9], bool substitute)
|
|
{
|
|
if (mapname[0] == '&' && mapname[1] == 'w' &&
|
|
mapname[2] == 't' && mapname[3] == '@')
|
|
{
|
|
level_info_t *lev = FindLevelByWarpTrans (atoi (mapname + 4));
|
|
if (lev != NULL)
|
|
{
|
|
strncpy (mapname, lev->mapname, 8);
|
|
mapname[8] = 0;
|
|
return true;
|
|
}
|
|
else if (substitute)
|
|
{
|
|
mapname[0] = 'M';
|
|
mapname[1] = 'A';
|
|
mapname[2] = 'P';
|
|
mapname[3] = mapname[4];
|
|
mapname[4] = mapname[5];
|
|
mapname[5] = 0;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// G_InitNew
|
|
// Can be called by the startup code or the menu task,
|
|
// consoleplayer, playeringame[] should be set.
|
|
//
|
|
static char d_mapname[9];
|
|
|
|
void G_DeferedInitNew (char *mapname)
|
|
{
|
|
strncpy (d_mapname, mapname, 8);
|
|
CheckWarpTransMap (d_mapname, true);
|
|
gameaction = ga_newgame2;
|
|
}
|
|
|
|
CCMD (map)
|
|
{
|
|
if (netgame)
|
|
{
|
|
Printf ("Use "TEXTCOLOR_BOLD"changemap"TEXTCOLOR_NORMAL" instead. "TEXTCOLOR_BOLD"Map"
|
|
TEXTCOLOR_NORMAL" is for single-player only.\n");
|
|
return;
|
|
}
|
|
if (argv.argc() > 1)
|
|
{
|
|
if (Wads.CheckNumForName (argv[1]) == -1)
|
|
Printf ("No map %s\n", argv[1]);
|
|
else
|
|
G_DeferedInitNew (argv[1]);
|
|
}
|
|
else
|
|
{
|
|
Printf ("Usage: map <map name>\n");
|
|
}
|
|
}
|
|
|
|
void G_NewInit ()
|
|
{
|
|
int i;
|
|
|
|
G_ClearSnapshots ();
|
|
SB_state = screen->GetPageCount ();
|
|
netgame = false;
|
|
netdemo = false;
|
|
multiplayer = false;
|
|
if (demoplayback)
|
|
{
|
|
C_RestoreCVars ();
|
|
demoplayback = false;
|
|
D_SetupUserInfo ();
|
|
}
|
|
memset (playeringame, 0, sizeof(playeringame));
|
|
for (i = 0; i < MAXPLAYERS; ++i)
|
|
{
|
|
players[i].playerstate = PST_DEAD;
|
|
}
|
|
BackupSaveName = "";
|
|
consoleplayer = 0;
|
|
NextSkill = -1;
|
|
}
|
|
|
|
void G_DoNewGame (void)
|
|
{
|
|
G_NewInit ();
|
|
playeringame[consoleplayer] = 1;
|
|
G_InitNew (d_mapname, false);
|
|
gameaction = ga_nothing;
|
|
}
|
|
|
|
void G_InitNew (char *mapname, bool bTitleLevel)
|
|
{
|
|
EGameSpeed oldSpeed;
|
|
bool wantFast;
|
|
int i;
|
|
|
|
if (!savegamerestore)
|
|
G_ClearSnapshots ();
|
|
|
|
// [RH] Mark all levels as not visited
|
|
if (!savegamerestore)
|
|
{
|
|
for (i = 0; i < numwadlevelinfos; i++)
|
|
wadlevelinfos[i].flags = wadlevelinfos[i].flags & ~LEVEL_VISITED;
|
|
}
|
|
|
|
UnlatchCVars ();
|
|
|
|
if (gameskill > sk_nightmare)
|
|
gameskill = sk_nightmare;
|
|
else if (gameskill < sk_baby)
|
|
gameskill = sk_baby;
|
|
|
|
UnlatchCVars ();
|
|
|
|
if (paused)
|
|
{
|
|
paused = 0;
|
|
S_ResumeSound ();
|
|
}
|
|
|
|
if (StatusBar != NULL)
|
|
{
|
|
delete StatusBar;
|
|
}
|
|
if (bTitleLevel)
|
|
{
|
|
StatusBar = new FBaseStatusBar (0);
|
|
}
|
|
else if (gameinfo.gametype == GAME_Doom)
|
|
{
|
|
StatusBar = CreateDoomStatusBar ();
|
|
}
|
|
else if (gameinfo.gametype == GAME_Heretic)
|
|
{
|
|
StatusBar = CreateHereticStatusBar ();
|
|
}
|
|
else if (gameinfo.gametype == GAME_Hexen)
|
|
{
|
|
StatusBar = CreateHexenStatusBar ();
|
|
}
|
|
else if (gameinfo.gametype == GAME_Strife)
|
|
{
|
|
StatusBar = CreateStrifeStatusBar ();
|
|
}
|
|
else
|
|
{
|
|
StatusBar = new FBaseStatusBar (0);
|
|
}
|
|
StatusBar->AttachToPlayer (&players[consoleplayer]);
|
|
StatusBar->NewGame ();
|
|
setsizeneeded = true;
|
|
|
|
// Set the initial quest log text for Strife.
|
|
for (i = 0; i < MAXPLAYERS; ++i)
|
|
{
|
|
players[i].SetLogText ("Find help");
|
|
}
|
|
|
|
// [RH] If this map doesn't exist, bomb out
|
|
if (Wads.CheckNumForName (mapname) == -1)
|
|
{
|
|
I_Error ("Could not find map %s\n", mapname);
|
|
}
|
|
|
|
if (dmflags & DF_MONSTERS_RESPAWN)
|
|
{
|
|
respawnmonsters = TICRATE;
|
|
}
|
|
else if (gameinfo.gametype & (GAME_Doom|GAME_Strife) && gameskill == sk_nightmare)
|
|
{
|
|
respawnmonsters = TICRATE;
|
|
}
|
|
else
|
|
{
|
|
respawnmonsters = 0;
|
|
}
|
|
// Monsters wait longer before respawning in Strife.
|
|
respawnmonsters *= gameinfo.gametype != GAME_Strife ? 12 : 16;
|
|
|
|
oldSpeed = GameSpeed;
|
|
wantFast = (dmflags & DF_FAST_MONSTERS) || (gameskill == sk_nightmare);
|
|
GameSpeed = wantFast ? SPEED_Fast : SPEED_Normal;
|
|
|
|
if (oldSpeed != GameSpeed)
|
|
{
|
|
FActorInfo::StaticSpeedSet ();
|
|
}
|
|
|
|
if (!savegamerestore)
|
|
{
|
|
if (!netgame)
|
|
{ // [RH] Change the random seed for each new single player game
|
|
rngseed = rngseed*3/2;
|
|
}
|
|
FRandom::StaticClearRandom ();
|
|
memset (ACS_WorldVars, 0, sizeof(ACS_WorldVars));
|
|
memset (ACS_GlobalVars, 0, sizeof(ACS_GlobalVars));
|
|
for (i = 0; i < NUM_WORLDVARS; ++i)
|
|
{
|
|
ACS_WorldArrays[i].Clear ();
|
|
}
|
|
for (i = 0; i < NUM_GLOBALVARS; ++i)
|
|
{
|
|
ACS_GlobalArrays[i].Clear ();
|
|
}
|
|
level.time = 0;
|
|
level.maptime = 0;
|
|
level.totaltime = 0;
|
|
|
|
if (!multiplayer || !deathmatch)
|
|
{
|
|
InitPlayerClasses ();
|
|
}
|
|
|
|
// force players to be initialized upon first level load
|
|
for (i = 0; i < MAXPLAYERS; i++)
|
|
players[i].playerstate = PST_ENTER; // [BC]
|
|
}
|
|
|
|
usergame = !bTitleLevel; // will be set false if a demo
|
|
paused = 0;
|
|
demoplayback = false;
|
|
automapactive = false;
|
|
viewactive = true;
|
|
BorderNeedRefresh = screen->GetPageCount ();
|
|
|
|
//Added by MC: Initialize bots.
|
|
if (!deathmatch)
|
|
{
|
|
bglobal.Init ();
|
|
}
|
|
|
|
strncpy (level.mapname, mapname, 8);
|
|
level.mapname[8] = 0;
|
|
if (bTitleLevel)
|
|
{
|
|
gamestate = GS_TITLELEVEL;
|
|
}
|
|
else if (gamestate != GS_STARTUP)
|
|
{
|
|
gamestate = GS_LEVEL;
|
|
}
|
|
G_DoLoadLevel (0, false);
|
|
}
|
|
|
|
//
|
|
// G_DoCompleted
|
|
//
|
|
BOOL secretexit;
|
|
static int startpos; // [RH] Support for multiple starts per level
|
|
extern BOOL NoWipe; // [RH] Don't wipe when travelling in hubs
|
|
static bool startkeepfacing; // [RH] Support for keeping your facing angle
|
|
|
|
// [RH] The position parameter to these next three functions should
|
|
// match the first parameter of the single player start spots
|
|
// that should appear in the next map.
|
|
static void goOn (int position, bool keepFacing, bool secret)
|
|
{
|
|
static bool unloading;
|
|
|
|
if (unloading)
|
|
{
|
|
Printf (TEXTCOLOR_RED "Unloading scripts cannot exit the level again.\n");
|
|
return;
|
|
}
|
|
|
|
cluster_info_t *thiscluster = FindClusterInfo (level.cluster);
|
|
cluster_info_t *nextcluster = FindClusterInfo (CheckLevelRedirect (FindLevelInfo (level.nextmap))->cluster);
|
|
|
|
startpos = position;
|
|
startkeepfacing = keepFacing;
|
|
gameaction = ga_completed;
|
|
secretexit = secret;
|
|
bglobal.End(); //Added by MC:
|
|
|
|
// [RH] Give scripts a chance to do something
|
|
unloading = true;
|
|
FBehavior::StaticStartTypedScripts (SCRIPT_Unloading, NULL, false, 0, true);
|
|
unloading = false;
|
|
|
|
if (thiscluster && (thiscluster->flags & CLUSTER_HUB))
|
|
{
|
|
if ((level.flags & LEVEL_NOINTERMISSION) || (nextcluster == thiscluster))
|
|
NoWipe = 4;
|
|
D_DrawIcon = "TELEICON";
|
|
}
|
|
}
|
|
|
|
void G_ExitLevel (int position, bool keepFacing)
|
|
{
|
|
goOn (position, keepFacing, false);
|
|
}
|
|
|
|
// Here's for the german edition.
|
|
void G_SecretExitLevel (int position)
|
|
{
|
|
// [RH] Check for secret levels is done in
|
|
// G_DoCompleted()
|
|
|
|
goOn (position, false, true);
|
|
}
|
|
|
|
void G_DoCompleted (void)
|
|
{
|
|
int i;
|
|
|
|
gameaction = ga_nothing;
|
|
|
|
if (gamestate == GS_TITLELEVEL)
|
|
{
|
|
strncpy (level.mapname, level.nextmap, 8);
|
|
G_DoLoadLevel (startpos, false);
|
|
startpos = 0;
|
|
viewactive = true;
|
|
return;
|
|
}
|
|
|
|
// [RH] Mark this level as having been visited
|
|
if (!(level.flags & LEVEL_CHANGEMAPCHEAT))
|
|
FindLevelInfo (level.mapname)->flags |= LEVEL_VISITED;
|
|
|
|
if (automapactive)
|
|
AM_Stop ();
|
|
|
|
wminfo.finished_ep = level.cluster - 1;
|
|
strncpy (wminfo.lname0, level.info->pname, 8);
|
|
strncpy (wminfo.current, level.mapname, 8);
|
|
|
|
if (deathmatch &&
|
|
(dmflags & DF_SAME_LEVEL) &&
|
|
!(level.flags & LEVEL_CHANGEMAPCHEAT))
|
|
{
|
|
strncpy (wminfo.next, level.mapname, 8);
|
|
strncpy (wminfo.lname1, level.info->pname, 8);
|
|
}
|
|
else
|
|
{
|
|
wminfo.next[0] = 0;
|
|
if (secretexit)
|
|
{
|
|
if (Wads.CheckNumForName (level.secretmap) != -1)
|
|
{
|
|
strncpy (wminfo.next, level.secretmap, 8);
|
|
strncpy (wminfo.lname1, FindLevelInfo (level.secretmap)->pname, 8);
|
|
}
|
|
else
|
|
{
|
|
secretexit = false;
|
|
}
|
|
}
|
|
if (!wminfo.next[0])
|
|
{
|
|
if (strncmp (level.nextmap, "enDSeQ", 6) == 0)
|
|
{
|
|
strncpy (wminfo.next, level.nextmap, 8);
|
|
wminfo.lname1[0] = 0;
|
|
}
|
|
else
|
|
{
|
|
level_info_t *nextinfo = CheckLevelRedirect (FindLevelInfo (level.nextmap));
|
|
strncpy (wminfo.next, nextinfo->mapname, 8);
|
|
strncpy (wminfo.lname1, nextinfo->pname, 8);
|
|
}
|
|
}
|
|
}
|
|
|
|
CheckWarpTransMap (wminfo.next, true);
|
|
|
|
wminfo.next_ep = FindLevelInfo (wminfo.next)->cluster - 1;
|
|
wminfo.maxkills = level.total_monsters;
|
|
wminfo.maxitems = level.total_items;
|
|
wminfo.maxsecret = level.total_secrets;
|
|
wminfo.maxfrags = 0;
|
|
wminfo.partime = TICRATE * level.partime;
|
|
wminfo.sucktime = level.sucktime;
|
|
wminfo.pnum = consoleplayer;
|
|
wminfo.totaltime = level.totaltime;
|
|
|
|
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 = level.time;
|
|
memcpy (wminfo.plyr[i].frags, players[i].frags
|
|
, sizeof(wminfo.plyr[i].frags));
|
|
wminfo.plyr[i].fragcount = players[i].fragcount;
|
|
}
|
|
|
|
// [RH] If we're in a hub and staying within that hub, take a snapshot
|
|
// of the level. If we're traveling to a new hub, take stuff from
|
|
// the player and clear the world vars. If this is just an
|
|
// ordinary cluster (not a hub), take stuff from the player, but
|
|
// leave the world vars alone.
|
|
cluster_info_t *thiscluster = FindClusterInfo (level.cluster);
|
|
cluster_info_t *nextcluster = FindClusterInfo (CheckLevelRedirect (FindLevelInfo (level.nextmap))->cluster);
|
|
EFinishLevelType mode;
|
|
|
|
if (thiscluster != nextcluster || deathmatch ||
|
|
!(thiscluster->flags & CLUSTER_HUB))
|
|
{
|
|
if (nextcluster->flags & CLUSTER_HUB)
|
|
{
|
|
mode = FINISH_NextHub;
|
|
}
|
|
else
|
|
{
|
|
mode = FINISH_NoHub;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
mode = FINISH_SameHub;
|
|
}
|
|
|
|
// Intermission stats for entire hubs
|
|
G_LeavingHub(mode, thiscluster, &wminfo);
|
|
|
|
for (i = 0; i < MAXPLAYERS; i++)
|
|
{
|
|
if (playeringame[i])
|
|
{ // take away appropriate inventory
|
|
G_PlayerFinishLevel (i, mode);
|
|
}
|
|
}
|
|
|
|
if (mode == FINISH_SameHub)
|
|
{ // Remember the level's state for re-entry.
|
|
G_SnapshotLevel ();
|
|
}
|
|
else
|
|
{ // Forget the states of all existing levels.
|
|
G_ClearSnapshots ();
|
|
|
|
if (mode == FINISH_NextHub)
|
|
{ // Reset world variables for the new hub.
|
|
memset (ACS_WorldVars, 0, sizeof(ACS_WorldVars));
|
|
for (i = 0; i < NUM_WORLDVARS; ++i)
|
|
{
|
|
ACS_WorldArrays[i].Clear ();
|
|
}
|
|
}
|
|
// With hub statistics the time should be per hub.
|
|
// Additionally there is a global time counter now so nothing is missed by changing it
|
|
//else if (mode == FINISH_NoHub)
|
|
{ // Reset time to zero if not entering/staying in a hub.
|
|
level.time = 0;
|
|
}
|
|
level.maptime = 0;
|
|
}
|
|
|
|
if (!deathmatch &&
|
|
((level.flags & LEVEL_NOINTERMISSION) ||
|
|
((nextcluster == thiscluster) && (thiscluster->flags & CLUSTER_HUB))))
|
|
{
|
|
G_WorldDone ();
|
|
return;
|
|
}
|
|
|
|
gamestate = GS_INTERMISSION;
|
|
viewactive = false;
|
|
automapactive = false;
|
|
|
|
// [RH] If you ever get a statistics driver operational, adapt this.
|
|
// if (statcopy)
|
|
// memcpy (statcopy, &wminfo, sizeof(wminfo));
|
|
|
|
WI_Start (&wminfo);
|
|
}
|
|
|
|
class DAutosaver : public DThinker
|
|
{
|
|
DECLARE_CLASS (DAutosaver, DThinker)
|
|
public:
|
|
void Tick ();
|
|
};
|
|
|
|
IMPLEMENT_CLASS (DAutosaver)
|
|
|
|
void DAutosaver::Tick ()
|
|
{
|
|
gameaction = ga_autosave;
|
|
Destroy ();
|
|
}
|
|
|
|
//
|
|
// G_DoLoadLevel
|
|
//
|
|
extern gamestate_t wipegamestate;
|
|
|
|
void G_DoLoadLevel (int position, bool autosave)
|
|
{
|
|
static int lastposition = 0;
|
|
gamestate_t oldgs = gamestate;
|
|
int i;
|
|
|
|
if (NextSkill >= 0)
|
|
{
|
|
UCVarValue val;
|
|
val.Int = NextSkill;
|
|
gameskill.ForceSet (val, CVAR_Int);
|
|
NextSkill = -1;
|
|
}
|
|
|
|
if (position == -1)
|
|
position = lastposition;
|
|
else
|
|
lastposition = position;
|
|
|
|
G_InitLevelLocals ();
|
|
StatusBar->DetachAllMessages ();
|
|
|
|
Printf (
|
|
"\n\35\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36\36"
|
|
"\36\36\36\36\36\36\36\36\36\36\36\36\37\n\n"
|
|
TEXTCOLOR_BOLD "%s - %s\n\n",
|
|
level.mapname, level.level_name);
|
|
|
|
if (wipegamestate == GS_LEVEL)
|
|
wipegamestate = GS_FORCEWIPE;
|
|
|
|
if (gamestate != GS_TITLELEVEL)
|
|
{
|
|
gamestate = GS_LEVEL;
|
|
}
|
|
|
|
// 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 = TexMan.GetTexture (gameinfo.SkyFlatName, FTexture::TEX_Flat, FTextureManager::TEXMAN_Overridable);
|
|
|
|
// DOOM determines the sky texture to be used
|
|
// depending on the current episode and the game version.
|
|
// [RH] Fetch sky parameters from level_locals_t.
|
|
sky1texture = TexMan.GetTexture (level.skypic1, FTexture::TEX_Wall, FTextureManager::TEXMAN_Overridable);
|
|
sky2texture = TexMan.GetTexture (level.skypic2, FTexture::TEX_Wall, FTextureManager::TEXMAN_Overridable);
|
|
sky1pos = sky2pos = 0;
|
|
|
|
// [RH] Set up details about sky rendering
|
|
R_InitSkyMap ();
|
|
|
|
for (i = 0; i < MAXPLAYERS; i++)
|
|
{
|
|
if (playeringame[i] && (deathmatch || players[i].playerstate == PST_DEAD))
|
|
players[i].playerstate = PST_ENTER; // [BC]
|
|
memset (players[i].frags,0,sizeof(players[i].frags));
|
|
players[i].fragcount = 0;
|
|
}
|
|
|
|
SN_StopAllSequences ();
|
|
P_SetupLevel (level.mapname, position);
|
|
|
|
// [RH] Start lightning, if MAPINFO tells us to
|
|
if (level.flags & LEVEL_STARTLIGHTNING)
|
|
{
|
|
P_StartLightning ();
|
|
}
|
|
|
|
gameaction = ga_nothing;
|
|
|
|
// clear cmd building stuff
|
|
ResetButtonStates ();
|
|
|
|
SendItemUse = NULL;
|
|
SendItemDrop = NULL;
|
|
mousex = mousey = 0;
|
|
sendpause = sendsave = sendturn180 = SendLand = false;
|
|
LocalViewAngle = 0;
|
|
LocalViewPitch = 0;
|
|
paused = 0;
|
|
|
|
//Added by MC: Initialize bots.
|
|
if (deathmatch)
|
|
{
|
|
bglobal.Init ();
|
|
}
|
|
|
|
if (timingdemo)
|
|
{
|
|
static BOOL firstTime = true;
|
|
|
|
if (firstTime)
|
|
{
|
|
starttime = I_GetTime (false);
|
|
firstTime = false;
|
|
}
|
|
}
|
|
|
|
level.starttime = gametic;
|
|
G_UnSnapshotLevel (!savegamerestore); // [RH] Restore the state of the level.
|
|
G_FinishTravel ();
|
|
if (players[consoleplayer].camera == NULL ||
|
|
players[consoleplayer].camera->player != NULL)
|
|
{ // If we are viewing through a player, make sure it is us.
|
|
players[consoleplayer].camera = players[consoleplayer].mo;
|
|
}
|
|
StatusBar->AttachToPlayer (&players[consoleplayer]);
|
|
P_DoDeferedScripts (); // [RH] Do script actions that were triggered on another map.
|
|
|
|
if (demoplayback || oldgs == GS_STARTUP || oldgs == GS_TITLELEVEL)
|
|
C_HideConsole ();
|
|
|
|
C_FlushDisplay ();
|
|
|
|
// [RH] Always save the game when entering a new level.
|
|
if (autosave && !savegamerestore && disableautosave < 1)
|
|
{
|
|
DAutosaver GCCNOWARN *dummy = new DAutosaver;
|
|
}
|
|
}
|
|
|
|
|
|
//
|
|
// G_WorldDone
|
|
//
|
|
void G_WorldDone (void)
|
|
{
|
|
cluster_info_t *nextcluster;
|
|
cluster_info_t *thiscluster;
|
|
char *nextmap;
|
|
|
|
gameaction = ga_worlddone;
|
|
|
|
if (level.flags & LEVEL_CHANGEMAPCHEAT)
|
|
return;
|
|
|
|
thiscluster = FindClusterInfo (level.cluster);
|
|
nextmap = !secretexit || !level.secretmap[0] ? level.nextmap : level.secretmap;
|
|
|
|
if (strncmp (nextmap, "enDSeQ", 6) == 0)
|
|
{
|
|
F_StartFinale (thiscluster->messagemusic, thiscluster->musicorder,
|
|
thiscluster->cdtrack, thiscluster->cdid,
|
|
thiscluster->finaleflat, thiscluster->exittext,
|
|
thiscluster->flags & CLUSTER_EXITTEXTINLUMP,
|
|
thiscluster->flags & CLUSTER_FINALEPIC,
|
|
thiscluster->flags & CLUSTER_LOOKUPEXITTEXT);
|
|
}
|
|
else
|
|
{
|
|
nextcluster = FindClusterInfo (CheckLevelRedirect (FindLevelInfo (nextmap))->cluster);
|
|
|
|
if (nextcluster->cluster != level.cluster && !deathmatch)
|
|
{
|
|
// Only start the finale if the next level's cluster is different
|
|
// than the current one and we're not in deathmatch.
|
|
if (nextcluster->entertext)
|
|
{
|
|
F_StartFinale (nextcluster->messagemusic, nextcluster->musicorder,
|
|
nextcluster->cdtrack, nextcluster->cdid,
|
|
nextcluster->finaleflat, nextcluster->entertext,
|
|
nextcluster->flags & CLUSTER_ENTERTEXTINLUMP,
|
|
nextcluster->flags & CLUSTER_FINALEPIC,
|
|
nextcluster->flags & CLUSTER_LOOKUPENTERTEXT);
|
|
}
|
|
else if (thiscluster->exittext)
|
|
{
|
|
F_StartFinale (thiscluster->messagemusic, thiscluster->musicorder,
|
|
thiscluster->cdtrack, nextcluster->cdid,
|
|
thiscluster->finaleflat, thiscluster->exittext,
|
|
thiscluster->flags & CLUSTER_EXITTEXTINLUMP,
|
|
thiscluster->flags & CLUSTER_FINALEPIC,
|
|
thiscluster->flags & CLUSTER_LOOKUPEXITTEXT);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void G_DoWorldDone (void)
|
|
{
|
|
gamestate = GS_LEVEL;
|
|
if (wminfo.next[0] == 0)
|
|
{
|
|
// Don't crash if no next map is given. Just repeat the current one.
|
|
Printf ("No next map specified.\n");
|
|
}
|
|
else
|
|
{
|
|
strncpy (level.mapname, wminfo.next, 8);
|
|
}
|
|
G_StartTravel ();
|
|
G_DoLoadLevel (startpos, true);
|
|
startpos = 0;
|
|
gameaction = ga_nothing;
|
|
viewactive = true;
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// G_StartTravel
|
|
//
|
|
// Moves players (and eventually their inventory) to a different statnum,
|
|
// so they will not be destroyed when switching levels. This only applies
|
|
// to real players, not voodoo dolls.
|
|
//
|
|
//==========================================================================
|
|
|
|
void G_StartTravel ()
|
|
{
|
|
if (deathmatch)
|
|
return;
|
|
|
|
for (int i = 0; i < MAXPLAYERS; ++i)
|
|
{
|
|
if (playeringame[i])
|
|
{
|
|
AActor *pawn = players[i].mo;
|
|
AInventory *inv;
|
|
|
|
// Only living players travel. Dead ones get a new body on the new level.
|
|
if (players[i].health > 0)
|
|
{
|
|
pawn->UnlinkFromWorld ();
|
|
pawn->RemoveFromHash ();
|
|
pawn->ChangeStatNum (STAT_TRAVELLING);
|
|
|
|
for (inv = pawn->Inventory; inv != NULL; inv = inv->Inventory)
|
|
{
|
|
inv->ChangeStatNum (STAT_TRAVELLING);
|
|
inv->UnlinkFromWorld ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//==========================================================================
|
|
//
|
|
// G_FinishTravel
|
|
//
|
|
// Moves any travelling players so that they occupy their newly-spawned
|
|
// copies' locations, destroying the new players in the process (because
|
|
// they are really fake placeholders to show where the travelling players
|
|
// should go).
|
|
//
|
|
//==========================================================================
|
|
|
|
void G_FinishTravel ()
|
|
{
|
|
TThinkerIterator<APlayerPawn> it (STAT_TRAVELLING);
|
|
APlayerPawn *pawn, *pawndup, *next;
|
|
AInventory *inv;
|
|
|
|
next = it.Next ();
|
|
while ( (pawn = next) != NULL)
|
|
{
|
|
next = it.Next ();
|
|
pawn->ChangeStatNum (STAT_PLAYER);
|
|
pawndup = pawn->player->mo;
|
|
assert (pawn != pawndup);
|
|
if (pawndup == NULL)
|
|
{ // Oh no! there was no start for this player!
|
|
pawn->flags |= MF_NOSECTOR|MF_NOBLOCKMAP;
|
|
pawn->Destroy ();
|
|
}
|
|
else
|
|
{
|
|
if (!startkeepfacing)
|
|
{
|
|
pawn->angle = pawndup->angle;
|
|
pawn->pitch = pawndup->pitch;
|
|
}
|
|
pawn->x = pawndup->x;
|
|
pawn->y = pawndup->y;
|
|
pawn->z = pawndup->z;
|
|
pawn->momx = pawndup->momx;
|
|
pawn->momy = pawndup->momy;
|
|
pawn->momz = pawndup->momz;
|
|
pawn->Sector = pawndup->Sector;
|
|
pawn->floorz = pawndup->floorz;
|
|
pawn->ceilingz = pawndup->ceilingz;
|
|
pawn->dropoffz = pawndup->dropoffz;
|
|
pawn->floorsector = pawndup->floorsector;
|
|
pawn->floorpic = pawndup->floorpic;
|
|
pawn->ceilingsector = pawndup->ceilingsector;
|
|
pawn->ceilingpic = pawndup->ceilingpic;
|
|
pawn->floorclip = pawndup->floorclip;
|
|
pawn->waterlevel = pawndup->waterlevel;
|
|
pawn->target = NULL;
|
|
pawn->lastenemy = NULL;
|
|
pawn->AddToHash ();
|
|
pawn->player->mo = pawn;
|
|
DObject::PointerSubstitution (pawndup, pawn);
|
|
pawndup->Destroy ();
|
|
pawn->LinkToWorld ();
|
|
pawn->AddToHash ();
|
|
|
|
for (inv = pawn->Inventory; inv != NULL; inv = inv->Inventory)
|
|
{
|
|
inv->ChangeStatNum (STAT_INVENTORY);
|
|
inv->LinkToWorld ();
|
|
inv->Travelled ();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void G_InitLevelLocals ()
|
|
{
|
|
level_info_t *info;
|
|
|
|
BaseBlendA = 0.0f; // Remove underwater blend effect, if any
|
|
NormalLight.Maps = realcolormaps;
|
|
NormalLight.Color = PalEntry (255, 255, 255);
|
|
|
|
level.gravity = sv_gravity * 35/TICRATE;
|
|
level.aircontrol = (fixed_t)(sv_aircontrol * 65536.f);
|
|
level.flags = 0;
|
|
|
|
info = FindLevelInfo (level.mapname);
|
|
|
|
level.info = info;
|
|
level.skyspeed1 = info->skyspeed1;
|
|
level.skyspeed2 = info->skyspeed2;
|
|
info = (level_info_t *)info;
|
|
strncpy (level.skypic2, info->skypic2, 8);
|
|
level.fadeto = info->fadeto;
|
|
level.cdtrack = info->cdtrack;
|
|
level.cdid = info->cdid;
|
|
if (level.fadeto == 0)
|
|
{
|
|
R_SetDefaultColormap (info->fadetable);
|
|
if (strnicmp (info->fadetable, "COLORMAP", 8) != 0)
|
|
{
|
|
level.flags |= LEVEL_HASFADETABLE;
|
|
}
|
|
/*
|
|
}
|
|
else
|
|
{
|
|
NormalLight.ChangeFade (level.fadeto);
|
|
*/
|
|
}
|
|
level.airsupply = info->airsupply*TICRATE;
|
|
level.outsidefog = info->outsidefog;
|
|
level.WallVertLight = info->WallVertLight;
|
|
level.WallHorizLight = info->WallHorizLight;
|
|
if (info->gravity != 0.f)
|
|
{
|
|
level.gravity = info->gravity * 35/TICRATE;
|
|
}
|
|
if (info->aircontrol != 0.f)
|
|
{
|
|
level.aircontrol = (fixed_t)(info->aircontrol * 65536.f);
|
|
}
|
|
|
|
G_AirControlChanged ();
|
|
|
|
if (info->level_name)
|
|
{
|
|
cluster_info_t *clus = FindClusterInfo (info->cluster);
|
|
|
|
level.partime = info->partime;
|
|
level.sucktime = info->sucktime;
|
|
level.cluster = info->cluster;
|
|
level.clusterflags = clus ? clus->flags : 0;
|
|
level.flags |= info->flags;
|
|
level.levelnum = info->levelnum;
|
|
level.music = info->music;
|
|
level.musicorder = info->musicorder;
|
|
|
|
strncpy (level.level_name, info->level_name, 63);
|
|
G_MaybeLookupLevelName (NULL);
|
|
strncpy (level.nextmap, info->nextmap, 8);
|
|
level.nextmap[8] = 0;
|
|
strncpy (level.secretmap, info->secretmap, 8);
|
|
level.secretmap[8] = 0;
|
|
strncpy (level.skypic1, info->skypic1, 8);
|
|
level.skypic1[8] = 0;
|
|
if (!level.skypic2[0])
|
|
strncpy (level.skypic2, level.skypic1, 8);
|
|
level.skypic2[8] = 0;
|
|
}
|
|
else
|
|
{
|
|
level.partime = level.cluster = 0;
|
|
level.sucktime = 0;
|
|
strcpy (level.level_name, "Unnamed");
|
|
level.nextmap[0] =
|
|
level.secretmap[0] = 0;
|
|
level.music = NULL;
|
|
strcpy (level.skypic1, "SKY1");
|
|
strcpy (level.skypic2, "SKY1");
|
|
level.flags = 0;
|
|
level.levelnum = 1;
|
|
}
|
|
|
|
int clear = 0, set = 0;
|
|
|
|
if (level.flags & LEVEL_JUMP_YES)
|
|
clear = DF_NO_JUMP;
|
|
if (level.flags & LEVEL_JUMP_NO)
|
|
set = DF_NO_JUMP;
|
|
if (level.flags & LEVEL_FREELOOK_YES)
|
|
clear |= DF_NO_FREELOOK;
|
|
if (level.flags & LEVEL_FREELOOK_NO)
|
|
set |= DF_NO_FREELOOK;
|
|
|
|
dmflags = (dmflags & ~clear) | set;
|
|
|
|
NormalLight.ChangeFade (level.fadeto);
|
|
|
|
if (level.Scrolls != NULL)
|
|
{
|
|
delete[] level.Scrolls;
|
|
level.Scrolls = NULL;
|
|
}
|
|
}
|
|
|
|
char *CalcMapName (int episode, int level)
|
|
{
|
|
static char lumpname[9];
|
|
|
|
if (gameinfo.flags & GI_MAPxx)
|
|
{
|
|
sprintf (lumpname, "MAP%02d", level);
|
|
}
|
|
else
|
|
{
|
|
lumpname[0] = 'E';
|
|
lumpname[1] = '0' + episode;
|
|
lumpname[2] = 'M';
|
|
lumpname[3] = '0' + level;
|
|
lumpname[4] = 0;
|
|
}
|
|
return lumpname;
|
|
}
|
|
|
|
level_info_t *FindLevelInfo (char *mapname)
|
|
{
|
|
int i;
|
|
|
|
if ((i = FindWadLevelInfo (mapname)) > -1)
|
|
return (level_info_t *)(wadlevelinfos + i);
|
|
else
|
|
return &TheDefaultLevelInfo;
|
|
}
|
|
|
|
level_info_t *FindLevelByNum (int num)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < numwadlevelinfos; i++)
|
|
if (wadlevelinfos[i].levelnum == num)
|
|
return (level_info_t *)(wadlevelinfos + i);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
level_info_t *CheckLevelRedirect (level_info_t *info)
|
|
{
|
|
if (info->RedirectType != NULL)
|
|
{
|
|
for (int i = 0; i < MAXPLAYERS; ++i)
|
|
{
|
|
if (playeringame[i] && players[i].mo->FindInventory (info->RedirectType))
|
|
{
|
|
level_info_t *newinfo = FindLevelInfo (info->RedirectMap);
|
|
if (newinfo != NULL)
|
|
{
|
|
info = newinfo;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return info;
|
|
}
|
|
|
|
static void SetLevelNum (level_info_t *info, int num)
|
|
{
|
|
// Avoid duplicate levelnums. The level being set always has precedence.
|
|
for (int i = 0; i < numwadlevelinfos; ++i)
|
|
{
|
|
if (wadlevelinfos[i].levelnum == num)
|
|
wadlevelinfos[i].levelnum = 0;
|
|
}
|
|
info->levelnum = num;
|
|
}
|
|
|
|
cluster_info_t *FindClusterInfo (int cluster)
|
|
{
|
|
int i;
|
|
|
|
if ((i = FindWadClusterInfo (cluster)) > -1)
|
|
return wadclusterinfos + i;
|
|
else
|
|
return &TheDefaultClusterInfo;
|
|
}
|
|
|
|
const char *G_MaybeLookupLevelName (level_info_t *ininfo)
|
|
{
|
|
level_info_t *info;
|
|
|
|
if (ininfo == NULL)
|
|
{
|
|
info = level.info;
|
|
}
|
|
else
|
|
{
|
|
info = ininfo;
|
|
}
|
|
|
|
if (info != NULL && info->flags & LEVEL_LOOKUPLEVELNAME)
|
|
{
|
|
const char *thename;
|
|
const char *lookedup;
|
|
|
|
lookedup = GStrings[info->level_name];
|
|
if (lookedup == NULL)
|
|
{
|
|
thename = info->level_name;
|
|
}
|
|
else
|
|
{
|
|
char checkstring[32];
|
|
|
|
// Strip out the header from the localized string
|
|
if (info->mapname[0] == 'E' && info->mapname[2] == 'M')
|
|
{
|
|
sprintf (checkstring, "%s: ", info->mapname);
|
|
}
|
|
else if (info->mapname[0] == 'M' && info->mapname[1] == 'A' && info->mapname[2] == 'P')
|
|
{
|
|
sprintf (checkstring, "%d: ", atoi(info->mapname + 3));
|
|
}
|
|
thename = strstr (lookedup, checkstring);
|
|
if (thename == NULL)
|
|
{
|
|
thename = lookedup;
|
|
}
|
|
else
|
|
{
|
|
thename += strlen (checkstring);
|
|
}
|
|
}
|
|
if (ininfo == NULL)
|
|
{
|
|
strncpy (level.level_name, thename, 63);
|
|
}
|
|
return thename;
|
|
}
|
|
return info != NULL ? info->level_name : NULL;
|
|
}
|
|
|
|
void G_MakeEpisodes ()
|
|
{
|
|
int i;
|
|
|
|
// Set the default episodes
|
|
if (EpiDef.numitems == 0)
|
|
{
|
|
static const char eps[5][8] =
|
|
{
|
|
"E1M1", "E2M1", "E3M1", "E4M1", "E5M1"
|
|
};
|
|
static const char depinames[4][7] =
|
|
{
|
|
"M_EPI1", "M_EPI2", "M_EPI3", "M_EPI4"
|
|
};
|
|
static const char depikeys[4] = { 'k', 't', 'i', 't' };
|
|
|
|
static const char *hepinames[5] =
|
|
{
|
|
"CITY OF THE DAMNED",
|
|
"HELL'S MAW",
|
|
"THE DOME OF D'SPARIL",
|
|
"THE OSSUARY",
|
|
"THE STAGNANT DEMESNE",
|
|
};
|
|
static const char hepikeys[5] = { 'c', 'h', 'd', 'o', 's' };
|
|
|
|
if (gameinfo.flags & GI_MAPxx)
|
|
{
|
|
if (gameinfo.gametype == GAME_Hexen)
|
|
{
|
|
// "&wt@01" is a magic name that will become whatever map has
|
|
// warptrans 1.
|
|
strcpy (EpisodeMaps[0], "&wt@01");
|
|
EpisodeMenu[0].name = copystring ("Hexen");
|
|
}
|
|
else
|
|
{
|
|
strcpy (EpisodeMaps[0], "MAP01");
|
|
EpisodeMenu[0].name = copystring ("Hell on Earth");
|
|
}
|
|
EpisodeMenu[0].alphaKey = 'h';
|
|
EpisodeMenu[0].fulltext = true;
|
|
EpiDef.numitems = 1;
|
|
}
|
|
else if (gameinfo.gametype == GAME_Doom)
|
|
{
|
|
memcpy (EpisodeMaps, eps, 4*8);
|
|
for (i = 0; i < 4; ++i)
|
|
{
|
|
EpisodeMenu[i].name = copystring (depinames[i]);
|
|
EpisodeMenu[i].fulltext = false;
|
|
EpisodeMenu[i].alphaKey = depikeys[i];
|
|
}
|
|
if (gameinfo.flags & GI_MENUHACK_RETAIL)
|
|
{
|
|
EpiDef.numitems = 4;
|
|
}
|
|
else
|
|
{
|
|
EpiDef.numitems = 3;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
memcpy (EpisodeMaps, eps, 5*8);
|
|
for (i = 0; i < 5; ++i)
|
|
{
|
|
EpisodeMenu[i].name = copystring (hepinames[i]);
|
|
EpisodeMenu[i].fulltext = true;
|
|
EpisodeMenu[i].alphaKey = hepikeys[i];
|
|
}
|
|
if (gameinfo.flags & GI_MENUHACK_EXTENDED)
|
|
{
|
|
EpiDef.numitems = 5;
|
|
}
|
|
else
|
|
{
|
|
EpiDef.numitems = 3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void G_AirControlChanged ()
|
|
{
|
|
if (level.aircontrol <= 256)
|
|
{
|
|
level.airfriction = FRACUNIT;
|
|
}
|
|
else
|
|
{
|
|
// Friction is inversely proportional to the amount of control
|
|
float fric = ((float)level.aircontrol/65536.f) * -0.0941f + 1.0004f;
|
|
level.airfriction = (fixed_t)(fric * 65536.f);
|
|
}
|
|
}
|
|
|
|
void G_SerializeLevel (FArchive &arc, bool hubLoad)
|
|
{
|
|
int i = level.totaltime;
|
|
|
|
arc << level.flags
|
|
<< level.fadeto
|
|
<< level.found_secrets
|
|
<< level.found_items
|
|
<< level.killed_monsters
|
|
<< level.gravity
|
|
<< level.aircontrol
|
|
<< level.maptime
|
|
<< i;
|
|
|
|
// Hub transitions must keep the current total time
|
|
if (!hubLoad)
|
|
level.totaltime=i;
|
|
|
|
if (arc.IsStoring ())
|
|
{
|
|
arc.WriteName (level.skypic1);
|
|
arc.WriteName (level.skypic2);
|
|
}
|
|
else
|
|
{
|
|
strncpy (level.skypic1, arc.ReadName(), 8);
|
|
strncpy (level.skypic2, arc.ReadName(), 8);
|
|
sky1texture = TexMan.GetTexture (level.skypic1, FTexture::TEX_Wall, FTextureManager::TEXMAN_Overridable);
|
|
sky2texture = TexMan.GetTexture (level.skypic2, FTexture::TEX_Wall, FTextureManager::TEXMAN_Overridable);
|
|
sky1pos = sky2pos = 0;
|
|
R_InitSkyMap ();
|
|
}
|
|
|
|
G_AirControlChanged ();
|
|
|
|
BYTE t;
|
|
|
|
// Does this level have scrollers?
|
|
if (arc.IsStoring ())
|
|
{
|
|
t = level.Scrolls ? 1 : 0;
|
|
arc << t;
|
|
}
|
|
else
|
|
{
|
|
arc << t;
|
|
if (level.Scrolls)
|
|
{
|
|
delete[] level.Scrolls;
|
|
level.Scrolls = NULL;
|
|
}
|
|
if (t)
|
|
{
|
|
level.Scrolls = new FSectorScrollValues[numsectors];
|
|
memset (level.Scrolls, 0, sizeof(level.Scrolls)*numsectors);
|
|
}
|
|
}
|
|
|
|
FBehavior::StaticSerializeModuleStates (arc);
|
|
P_SerializeThinkers (arc, hubLoad);
|
|
P_SerializeWorld (arc);
|
|
P_SerializePolyobjs (arc);
|
|
P_SerializeSounds (arc);
|
|
StatusBar->Serialize (arc);
|
|
SerializeInterpolations (arc);
|
|
|
|
arc << level.total_monsters << level.total_items << level.total_secrets;
|
|
|
|
// Does this level have custom translations?
|
|
if (arc.IsStoring ())
|
|
{
|
|
for (i = 0; i < MAX_ACS_TRANSLATIONS; ++i)
|
|
{
|
|
BYTE *trans = &translationtables[TRANSLATION_LevelScripted][i*256];
|
|
int j;
|
|
for (j = 0; j < 256; ++j)
|
|
{
|
|
if (trans[j] != j)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
if (j < 256)
|
|
{
|
|
t = i;
|
|
arc << t;
|
|
arc.Write (trans, 256);
|
|
}
|
|
}
|
|
t = 255;
|
|
arc << t;
|
|
}
|
|
else
|
|
{
|
|
arc << t;
|
|
while (t != 255)
|
|
{
|
|
if (t >= MAX_ACS_TRANSLATIONS)
|
|
{ // hack hack to avoid crashing
|
|
t = 0;
|
|
}
|
|
arc.Read (&translationtables[TRANSLATION_LevelScripted][t*256], 256);
|
|
arc << t;
|
|
}
|
|
}
|
|
|
|
// This must be saved, too, of course!
|
|
FCanvasTextureInfo::Serialize (arc);
|
|
|
|
if (!hubLoad)
|
|
{
|
|
P_SerializePlayers (arc);
|
|
}
|
|
}
|
|
|
|
// Archives the current level
|
|
void G_SnapshotLevel ()
|
|
{
|
|
if (level.info->snapshot)
|
|
delete level.info->snapshot;
|
|
|
|
if (level.info->mapname[0] != 0)
|
|
{
|
|
level.info->snapshotVer = SAVEVER;
|
|
level.info->snapshot = new FCompressedMemFile;
|
|
level.info->snapshot->Open ();
|
|
|
|
FArchive arc (*level.info->snapshot);
|
|
|
|
SaveVersion = SAVEVER;
|
|
G_SerializeLevel (arc, false);
|
|
}
|
|
}
|
|
|
|
// Unarchives the current level based on its snapshot
|
|
// The level should have already been loaded and setup.
|
|
void G_UnSnapshotLevel (bool hubLoad)
|
|
{
|
|
if (level.info->snapshot == NULL)
|
|
return;
|
|
|
|
if (level.info->mapname[0] != 0)
|
|
{
|
|
SaveVersion = level.info->snapshotVer;
|
|
level.info->snapshot->Reopen ();
|
|
FArchive arc (*level.info->snapshot);
|
|
if (hubLoad)
|
|
arc.SetHubTravel ();
|
|
G_SerializeLevel (arc, hubLoad);
|
|
arc.Close ();
|
|
|
|
TThinkerIterator<APlayerPawn> it;
|
|
APlayerPawn *pawn, *next;
|
|
|
|
next = it.Next();
|
|
while ((pawn = next) != 0)
|
|
{
|
|
next = it.Next();
|
|
if (pawn->player == NULL || pawn->player->mo == NULL || !playeringame[pawn->player - players])
|
|
{
|
|
pawn->Destroy ();
|
|
}
|
|
}
|
|
}
|
|
// No reason to keep the snapshot around once the level's been entered.
|
|
delete level.info->snapshot;
|
|
level.info->snapshot = NULL;
|
|
}
|
|
|
|
void G_ClearSnapshots (void)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < numwadlevelinfos; i++)
|
|
{
|
|
if (wadlevelinfos[i].snapshot)
|
|
{
|
|
delete wadlevelinfos[i].snapshot;
|
|
wadlevelinfos[i].snapshot = NULL;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void writeMapName (FArchive &arc, const char *name)
|
|
{
|
|
BYTE size;
|
|
if (name[7] != 0)
|
|
{
|
|
size = 8;
|
|
}
|
|
else
|
|
{
|
|
size = (BYTE)strlen (name);
|
|
}
|
|
arc << size;
|
|
arc.Write (name, size);
|
|
}
|
|
|
|
static void writeSnapShot (FArchive &arc, level_info_t *i)
|
|
{
|
|
arc << i->snapshotVer;
|
|
writeMapName (arc, i->mapname);
|
|
i->snapshot->Serialize (arc);
|
|
}
|
|
|
|
void G_WriteSnapshots (FILE *file)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < numwadlevelinfos; i++)
|
|
{
|
|
if (wadlevelinfos[i].snapshot)
|
|
{
|
|
FPNGChunkArchive arc (file, SNAP_ID);
|
|
writeSnapShot (arc, (level_info_t *)&wadlevelinfos[i]);
|
|
}
|
|
}
|
|
|
|
FPNGChunkArchive *arc = NULL;
|
|
|
|
// Write out which levels have been visited
|
|
for (i = 0; i < numwadlevelinfos; ++i)
|
|
{
|
|
if (wadlevelinfos[i].flags & LEVEL_VISITED)
|
|
{
|
|
if (arc == NULL)
|
|
{
|
|
arc = new FPNGChunkArchive (file, VIST_ID);
|
|
}
|
|
writeMapName (*arc, wadlevelinfos[i].mapname);
|
|
}
|
|
}
|
|
|
|
if (arc != NULL)
|
|
{
|
|
BYTE zero = 0;
|
|
*arc << zero;
|
|
delete arc;
|
|
}
|
|
|
|
// Store player classes to be used when spawning a random class
|
|
if (multiplayer)
|
|
{
|
|
FPNGChunkArchive arc2 (file, RCLS_ID);
|
|
for (i = 0; i < MAXPLAYERS; ++i)
|
|
{
|
|
SBYTE cnum = SinglePlayerClass[i];
|
|
arc2 << cnum;
|
|
}
|
|
}
|
|
|
|
// Store player classes that are currently in use
|
|
FPNGChunkArchive arc3 (file, PCLS_ID);
|
|
for (i = 0; i < MAXPLAYERS; ++i)
|
|
{
|
|
BYTE pnum;
|
|
if (playeringame[i])
|
|
{
|
|
pnum = i;
|
|
arc3 << pnum;
|
|
arc3.UserWriteClass (players[i].cls);
|
|
}
|
|
pnum = 255;
|
|
arc3 << pnum;
|
|
}
|
|
}
|
|
|
|
void G_ReadSnapshots (PNGHandle *png)
|
|
{
|
|
DWORD chunkLen;
|
|
BYTE namelen;
|
|
char mapname[256];
|
|
level_info_t *i;
|
|
|
|
G_ClearSnapshots ();
|
|
|
|
chunkLen = (DWORD)M_FindPNGChunk (png, SNAP_ID);
|
|
while (chunkLen != 0)
|
|
{
|
|
FPNGChunkArchive arc (png->File->GetFile(), SNAP_ID, chunkLen);
|
|
DWORD snapver;
|
|
|
|
arc << snapver;
|
|
arc << namelen;
|
|
arc.Read (mapname, namelen);
|
|
mapname[namelen] = 0;
|
|
i = FindLevelInfo (mapname);
|
|
i->snapshotVer = snapver;
|
|
i->snapshot = new FCompressedMemFile;
|
|
i->snapshot->Serialize (arc);
|
|
chunkLen = (DWORD)M_NextPNGChunk (png, SNAP_ID);
|
|
}
|
|
|
|
chunkLen = (DWORD)M_FindPNGChunk (png, VIST_ID);
|
|
if (chunkLen != 0)
|
|
{
|
|
FPNGChunkArchive arc (png->File->GetFile(), VIST_ID, chunkLen);
|
|
|
|
arc << namelen;
|
|
while (namelen != 0)
|
|
{
|
|
arc.Read (mapname, namelen);
|
|
mapname[namelen] = 0;
|
|
i = FindLevelInfo (mapname);
|
|
i->flags |= LEVEL_VISITED;
|
|
arc << namelen;
|
|
}
|
|
}
|
|
|
|
chunkLen = (DWORD)M_FindPNGChunk (png, RCLS_ID);
|
|
if (chunkLen != 0)
|
|
{
|
|
FPNGChunkArchive arc (png->File->GetFile(), PCLS_ID, chunkLen);
|
|
SBYTE cnum;
|
|
|
|
for (DWORD j = 0; j < chunkLen; ++j)
|
|
{
|
|
arc << cnum;
|
|
SinglePlayerClass[j] = cnum;
|
|
}
|
|
}
|
|
|
|
chunkLen = (DWORD)M_FindPNGChunk (png, PCLS_ID);
|
|
if (chunkLen != 0)
|
|
{
|
|
FPNGChunkArchive arc (png->File->GetFile(), RCLS_ID, chunkLen);
|
|
BYTE pnum;
|
|
|
|
arc << pnum;
|
|
while (pnum != 255)
|
|
{
|
|
arc.UserReadClass (players[pnum].cls);
|
|
arc << pnum;
|
|
}
|
|
}
|
|
png->File->ResetFilePtr();
|
|
}
|
|
|
|
|
|
static void writeDefereds (FArchive &arc, level_info_t *i)
|
|
{
|
|
writeMapName (arc, i->mapname);
|
|
arc << i->defered;
|
|
}
|
|
|
|
void P_WriteACSDefereds (FILE *file)
|
|
{
|
|
FPNGChunkArchive *arc = NULL;
|
|
int i;
|
|
|
|
for (i = 0; i < numwadlevelinfos; i++)
|
|
{
|
|
if (wadlevelinfos[i].defered)
|
|
{
|
|
if (arc == NULL)
|
|
{
|
|
arc = new FPNGChunkArchive (file, ACSD_ID);
|
|
}
|
|
writeDefereds (*arc, (level_info_t *)&wadlevelinfos[i]);
|
|
}
|
|
}
|
|
|
|
if (arc != NULL)
|
|
{
|
|
// Signal end of defereds
|
|
BYTE zero = 0;
|
|
*arc << zero;
|
|
delete arc;
|
|
}
|
|
}
|
|
|
|
void P_ReadACSDefereds (PNGHandle *png)
|
|
{
|
|
BYTE namelen;
|
|
char mapname[256];
|
|
size_t chunklen;
|
|
|
|
P_RemoveDefereds ();
|
|
|
|
if ((chunklen = M_FindPNGChunk (png, ACSD_ID)) != 0)
|
|
{
|
|
FPNGChunkArchive arc (png->File->GetFile(), ACSD_ID, chunklen);
|
|
|
|
arc << namelen;
|
|
while (namelen)
|
|
{
|
|
arc.Read (mapname, namelen);
|
|
mapname[namelen] = 0;
|
|
level_info_t *i = FindLevelInfo (mapname);
|
|
if (i == NULL)
|
|
{
|
|
I_Error ("Unknown map '%s' in savegame", mapname);
|
|
}
|
|
arc << i->defered;
|
|
arc << namelen;
|
|
}
|
|
}
|
|
png->File->ResetFilePtr();
|
|
}
|
|
|
|
|
|
void level_locals_s::Tick ()
|
|
{
|
|
// Reset carry sectors
|
|
if (Scrolls != NULL)
|
|
{
|
|
memset (Scrolls, 0, sizeof(*Scrolls)*numsectors);
|
|
}
|
|
}
|
|
|
|
void level_locals_s::AddScroller (DScroller *scroller, int secnum)
|
|
{
|
|
if (secnum < 0)
|
|
{
|
|
return;
|
|
}
|
|
if (Scrolls == NULL)
|
|
{
|
|
Scrolls = new FSectorScrollValues[numsectors];
|
|
memset (Scrolls, 0, sizeof(*Scrolls)*numsectors);
|
|
}
|
|
}
|
|
|
|
// Initializes player classes in case they are random.
|
|
// This gets called at the start of a new game, and the classes
|
|
// chosen here are used for the remainder of a single-player
|
|
// or coop game. These are ignored for deathmatch.
|
|
|
|
static void InitPlayerClasses ()
|
|
{
|
|
if (!savegamerestore)
|
|
{
|
|
for (int i = 0; i < MAXPLAYERS; ++i)
|
|
{
|
|
SinglePlayerClass[i] = players[i].userinfo.PlayerClass;
|
|
if (SinglePlayerClass[i] < 0 || !playeringame[i])
|
|
{
|
|
SinglePlayerClass[i] = (pr_classchoice() >> 6) % 3;
|
|
}
|
|
players[i].cls = NULL;
|
|
players[i].CurrentPlayerClass = SinglePlayerClass[i];
|
|
}
|
|
}
|
|
}
|