// // Copyright(C) 1993-1996 Id Software, Inc. // Copyright(C) 1993-2008 Raven Software // Copyright(C) 2005-2014 Simon Howard // // This program is free software; you can redistribute it and/or // modify it under the terms of the GNU General Public License // as published by the Free Software Foundation; either version 2 // of the License, or (at your option) any later version. // // This program is distributed in the hope that it will be useful, // but WITHOUT ANY WARRANTY; without even the implied warranty of // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the // GNU General Public License for more details. // // HEADER FILES ------------------------------------------------------------ #include #include #include "h2def.h" #include "i_system.h" #include "m_argv.h" #include "m_bbox.h" #include "m_misc.h" #include "i_swap.h" #include "s_sound.h" #include "p_local.h" // MACROS ------------------------------------------------------------------ #define MAPINFO_SCRIPT_NAME "MAPINFO" #define MCMD_SKY1 1 #define MCMD_SKY2 2 #define MCMD_LIGHTNING 3 #define MCMD_FADETABLE 4 #define MCMD_DOUBLESKY 5 #define MCMD_CLUSTER 6 #define MCMD_WARPTRANS 7 #define MCMD_NEXT 8 #define MCMD_CDTRACK 9 #define MCMD_CD_STARTTRACK 10 #define MCMD_CD_END1TRACK 11 #define MCMD_CD_END2TRACK 12 #define MCMD_CD_END3TRACK 13 #define MCMD_CD_INTERTRACK 14 #define MCMD_CD_TITLETRACK 15 #define UNKNOWN_MAP_NAME "DEVELOPMENT MAP" #define DEFAULT_SKY_NAME "SKY1" #define DEFAULT_SONG_LUMP "DEFSONG" #define DEFAULT_FADE_TABLE "COLORMAP" // TYPES ------------------------------------------------------------------- typedef struct mapInfo_s mapInfo_t; struct mapInfo_s { short cluster; short warpTrans; short nextMap; short cdTrack; char name[32]; short sky1Texture; short sky2Texture; fixed_t sky1ScrollDelta; fixed_t sky2ScrollDelta; boolean doubleSky; boolean lightning; int fadetable; char songLump[10]; }; // EXTERNAL FUNCTION PROTOTYPES -------------------------------------------- void P_SpawnMapThing(mapthing_t * mthing); // PUBLIC FUNCTION PROTOTYPES ---------------------------------------------- // PRIVATE FUNCTION PROTOTYPES --------------------------------------------- static int QualifyMap(int map); // EXTERNAL DATA DECLARATIONS ---------------------------------------------- // PUBLIC DATA DEFINITIONS ------------------------------------------------- int MapCount; mapthing_t deathmatchstarts[MAXDEATHMATCHSTARTS], *deathmatch_p; mapthing_t playerstarts[MAX_PLAYER_STARTS][MAXPLAYERS]; int numvertexes; vertex_t *vertexes; int numsegs; seg_t *segs; int numsectors; sector_t *sectors; int numsubsectors; subsector_t *subsectors; int numnodes; node_t *nodes; int numlines; line_t *lines; int numsides; side_t *sides; short *blockmaplump; // offsets in blockmap are from here short *blockmap; int bmapwidth, bmapheight; // in mapblocks fixed_t bmaporgx, bmaporgy; // origin of block map mobj_t **blocklinks; // for thing chains byte *rejectmatrix; // for fast sight rejection // PRIVATE DATA DEFINITIONS ------------------------------------------------ static mapInfo_t MapInfo[99]; static char *MapCmdNames[] = { "SKY1", "SKY2", "DOUBLESKY", "LIGHTNING", "FADETABLE", "CLUSTER", "WARPTRANS", "NEXT", "CDTRACK", "CD_START_TRACK", "CD_END1_TRACK", "CD_END2_TRACK", "CD_END3_TRACK", "CD_INTERMISSION_TRACK", "CD_TITLE_TRACK", NULL }; static int MapCmdIDs[] = { MCMD_SKY1, MCMD_SKY2, MCMD_DOUBLESKY, MCMD_LIGHTNING, MCMD_FADETABLE, MCMD_CLUSTER, MCMD_WARPTRANS, MCMD_NEXT, MCMD_CDTRACK, MCMD_CD_STARTTRACK, MCMD_CD_END1TRACK, MCMD_CD_END2TRACK, MCMD_CD_END3TRACK, MCMD_CD_INTERTRACK, MCMD_CD_TITLETRACK }; static int cd_NonLevelTracks[6]; // Non-level specific song cd track numbers // CODE -------------------------------------------------------------------- /* ================= = = P_LoadVertexes = ================= */ void P_LoadVertexes(int lump) { byte *data; int i; mapvertex_t *ml; vertex_t *li; numvertexes = W_LumpLength(lump) / sizeof(mapvertex_t); vertexes = Z_Malloc(numvertexes * sizeof(vertex_t), PU_LEVEL, 0); data = W_CacheLumpNum(lump, PU_STATIC); ml = (mapvertex_t *) data; li = vertexes; for (i = 0; i < numvertexes; i++, li++, ml++) { li->x = SHORT(ml->x) << FRACBITS; li->y = SHORT(ml->y) << FRACBITS; } W_ReleaseLumpNum(lump); } /* ================= = = P_LoadSegs = ================= */ void P_LoadSegs(int lump) { byte *data; int i; mapseg_t *ml; seg_t *li; line_t *ldef; int linedef, side; numsegs = W_LumpLength(lump) / sizeof(mapseg_t); segs = Z_Malloc(numsegs * sizeof(seg_t), PU_LEVEL, 0); memset(segs, 0, numsegs * sizeof(seg_t)); data = W_CacheLumpNum(lump, PU_STATIC); ml = (mapseg_t *) data; li = segs; for (i = 0; i < numsegs; i++, li++, ml++) { li->v1 = &vertexes[SHORT(ml->v1)]; li->v2 = &vertexes[SHORT(ml->v2)]; li->angle = (SHORT(ml->angle)) << 16; li->offset = (SHORT(ml->offset)) << 16; linedef = SHORT(ml->linedef); ldef = &lines[linedef]; li->linedef = ldef; side = SHORT(ml->side); li->sidedef = &sides[ldef->sidenum[side]]; li->frontsector = sides[ldef->sidenum[side]].sector; if (ldef->flags & ML_TWOSIDED) li->backsector = sides[ldef->sidenum[side ^ 1]].sector; else li->backsector = 0; } W_ReleaseLumpNum(lump); } /* ================= = = P_LoadSubsectors = ================= */ void P_LoadSubsectors(int lump) { byte *data; int i; mapsubsector_t *ms; subsector_t *ss; numsubsectors = W_LumpLength(lump) / sizeof(mapsubsector_t); subsectors = Z_Malloc(numsubsectors * sizeof(subsector_t), PU_LEVEL, 0); data = W_CacheLumpNum(lump, PU_STATIC); ms = (mapsubsector_t *) data; memset(subsectors, 0, numsubsectors * sizeof(subsector_t)); ss = subsectors; for (i = 0; i < numsubsectors; i++, ss++, ms++) { ss->numlines = SHORT(ms->numsegs); ss->firstline = SHORT(ms->firstseg); } W_ReleaseLumpNum(lump); } /* ================= = = P_LoadSectors = ================= */ void P_LoadSectors(int lump) { byte *data; int i; mapsector_t *ms; sector_t *ss; numsectors = W_LumpLength(lump) / sizeof(mapsector_t); sectors = Z_Malloc(numsectors * sizeof(sector_t), PU_LEVEL, 0); memset(sectors, 0, numsectors * sizeof(sector_t)); data = W_CacheLumpNum(lump, PU_STATIC); ms = (mapsector_t *) data; ss = sectors; for (i = 0; i < numsectors; i++, ss++, ms++) { ss->floorheight = SHORT(ms->floorheight) << FRACBITS; ss->ceilingheight = SHORT(ms->ceilingheight) << FRACBITS; ss->floorpic = R_FlatNumForName(ms->floorpic); ss->ceilingpic = R_FlatNumForName(ms->ceilingpic); ss->lightlevel = SHORT(ms->lightlevel); ss->special = SHORT(ms->special); ss->tag = SHORT(ms->tag); ss->thinglist = NULL; ss->seqType = SEQTYPE_STONE; // default seqType } W_ReleaseLumpNum(lump); } /* ================= = = P_LoadNodes = ================= */ void P_LoadNodes(int lump) { byte *data; int i, j, k; mapnode_t *mn; node_t *no; numnodes = W_LumpLength(lump) / sizeof(mapnode_t); nodes = Z_Malloc(numnodes * sizeof(node_t), PU_LEVEL, 0); data = W_CacheLumpNum(lump, PU_STATIC); mn = (mapnode_t *) data; no = nodes; for (i = 0; i < numnodes; i++, no++, mn++) { no->x = SHORT(mn->x) << FRACBITS; no->y = SHORT(mn->y) << FRACBITS; no->dx = SHORT(mn->dx) << FRACBITS; no->dy = SHORT(mn->dy) << FRACBITS; for (j = 0; j < 2; j++) { no->children[j] = SHORT(mn->children[j]); for (k = 0; k < 4; k++) no->bbox[j][k] = SHORT(mn->bbox[j][k]) << FRACBITS; } } W_ReleaseLumpNum(lump); } //========================================================================== // // P_LoadThings // //========================================================================== void P_LoadThings(int lump) { byte *data; int i; mapthing_t spawnthing; mapthing_t *mt; int numthings; int playerCount; int deathSpotsCount; data = W_CacheLumpNum(lump, PU_STATIC); numthings = W_LumpLength(lump) / sizeof(mapthing_t); mt = (mapthing_t *) data; for (i = 0; i < numthings; i++, mt++) { spawnthing.tid = SHORT(mt->tid); spawnthing.x = SHORT(mt->x); spawnthing.y = SHORT(mt->y); spawnthing.height = SHORT(mt->height); spawnthing.angle = SHORT(mt->angle); spawnthing.type = SHORT(mt->type); spawnthing.options = SHORT(mt->options); spawnthing.special = mt->special; spawnthing.arg1 = mt->arg1; spawnthing.arg2 = mt->arg2; spawnthing.arg3 = mt->arg3; spawnthing.arg4 = mt->arg4; spawnthing.arg5 = mt->arg5; P_SpawnMapThing(&spawnthing); } P_CreateTIDList(); P_InitCreatureCorpseQueue(false); // false = do NOT scan for corpses W_ReleaseLumpNum(lump); if (!deathmatch) { // Don't need to check deathmatch spots return; } playerCount = 0; for (i = 0; i < MAXPLAYERS; i++) { playerCount += playeringame[i]; } deathSpotsCount = deathmatch_p - deathmatchstarts; if (deathSpotsCount < playerCount) { I_Error("P_LoadThings: Player count (%d) exceeds deathmatch " "spots (%d)", playerCount, deathSpotsCount); } } /* ================= = = P_LoadLineDefs = ================= */ void P_LoadLineDefs(int lump) { byte *data; int i; maplinedef_t *mld; line_t *ld; vertex_t *v1, *v2; numlines = W_LumpLength(lump) / sizeof(maplinedef_t); lines = Z_Malloc(numlines * sizeof(line_t), PU_LEVEL, 0); memset(lines, 0, numlines * sizeof(line_t)); data = W_CacheLumpNum(lump, PU_STATIC); mld = (maplinedef_t *) data; ld = lines; for (i = 0; i < numlines; i++, mld++, ld++) { ld->flags = SHORT(mld->flags); // Old line special info ... //ld->special = SHORT(mld->special); //ld->tag = SHORT(mld->tag); // New line special info ... ld->special = mld->special; ld->arg1 = mld->arg1; ld->arg2 = mld->arg2; ld->arg3 = mld->arg3; ld->arg4 = mld->arg4; ld->arg5 = mld->arg5; v1 = ld->v1 = &vertexes[SHORT(mld->v1)]; v2 = ld->v2 = &vertexes[SHORT(mld->v2)]; ld->dx = v2->x - v1->x; ld->dy = v2->y - v1->y; if (!ld->dx) ld->slopetype = ST_VERTICAL; else if (!ld->dy) ld->slopetype = ST_HORIZONTAL; else { if (FixedDiv(ld->dy, ld->dx) > 0) ld->slopetype = ST_POSITIVE; else ld->slopetype = ST_NEGATIVE; } if (v1->x < v2->x) { ld->bbox[BOXLEFT] = v1->x; ld->bbox[BOXRIGHT] = v2->x; } else { ld->bbox[BOXLEFT] = v2->x; ld->bbox[BOXRIGHT] = v1->x; } if (v1->y < v2->y) { ld->bbox[BOXBOTTOM] = v1->y; ld->bbox[BOXTOP] = v2->y; } else { ld->bbox[BOXBOTTOM] = v2->y; ld->bbox[BOXTOP] = v1->y; } ld->sidenum[0] = SHORT(mld->sidenum[0]); ld->sidenum[1] = SHORT(mld->sidenum[1]); if (ld->sidenum[0] != -1) ld->frontsector = sides[ld->sidenum[0]].sector; else ld->frontsector = 0; if (ld->sidenum[1] != -1) ld->backsector = sides[ld->sidenum[1]].sector; else ld->backsector = 0; } W_ReleaseLumpNum(lump); } /* ================= = = P_LoadSideDefs = ================= */ void P_LoadSideDefs(int lump) { byte *data; int i; mapsidedef_t *msd; side_t *sd; numsides = W_LumpLength(lump) / sizeof(mapsidedef_t); sides = Z_Malloc(numsides * sizeof(side_t), PU_LEVEL, 0); memset(sides, 0, numsides * sizeof(side_t)); data = W_CacheLumpNum(lump, PU_STATIC); msd = (mapsidedef_t *) data; sd = sides; for (i = 0; i < numsides; i++, msd++, sd++) { sd->textureoffset = SHORT(msd->textureoffset) << FRACBITS; sd->rowoffset = SHORT(msd->rowoffset) << FRACBITS; sd->toptexture = R_TextureNumForName(msd->toptexture); sd->bottomtexture = R_TextureNumForName(msd->bottomtexture); sd->midtexture = R_TextureNumForName(msd->midtexture); sd->sector = §ors[SHORT(msd->sector)]; } W_ReleaseLumpNum(lump); } /* ================= = = P_LoadBlockMap = ================= */ void P_LoadBlockMap(int lump) { int i, count; int lumplen; lumplen = W_LumpLength(lump); blockmaplump = Z_Malloc(lumplen, PU_LEVEL, NULL); W_ReadLump(lump, blockmaplump); blockmap = blockmaplump + 4; // Swap all short integers to native byte ordering: count = lumplen / 2; for (i = 0; i < count; i++) blockmaplump[i] = SHORT(blockmaplump[i]); bmaporgx = blockmaplump[0] << FRACBITS; bmaporgy = blockmaplump[1] << FRACBITS; bmapwidth = blockmaplump[2]; bmapheight = blockmaplump[3]; // clear out mobj chains count = sizeof(*blocklinks) * bmapwidth * bmapheight; blocklinks = Z_Malloc(count, PU_LEVEL, 0); memset(blocklinks, 0, count); } /* ================= = = P_GroupLines = = Builds sector line lists and subsector sector numbers = Finds block bounding boxes for sectors ================= */ void P_GroupLines(void) { line_t **linebuffer; int i, j, total; line_t *li; sector_t *sector; subsector_t *ss; seg_t *seg; fixed_t bbox[4]; int block; // look up sector number for each subsector ss = subsectors; for (i = 0; i < numsubsectors; i++, ss++) { seg = &segs[ss->firstline]; ss->sector = seg->sidedef->sector; } // count number of lines in each sector li = lines; total = 0; for (i = 0; i < numlines; i++, li++) { total++; li->frontsector->linecount++; if (li->backsector && li->backsector != li->frontsector) { li->backsector->linecount++; total++; } } // build line tables for each sector linebuffer = Z_Malloc(total * sizeof(line_t *), PU_LEVEL, 0); sector = sectors; for (i = 0; i < numsectors; i++, sector++) { M_ClearBox(bbox); sector->lines = linebuffer; li = lines; for (j = 0; j < numlines; j++, li++) { if (li->frontsector == sector || li->backsector == sector) { *linebuffer++ = li; M_AddToBox(bbox, li->v1->x, li->v1->y); M_AddToBox(bbox, li->v2->x, li->v2->y); } } if (linebuffer - sector->lines != sector->linecount) I_Error("P_GroupLines: miscounted"); // set the degenmobj_t to the middle of the bounding box sector->soundorg.x = (bbox[BOXRIGHT] + bbox[BOXLEFT]) / 2; sector->soundorg.y = (bbox[BOXTOP] + bbox[BOXBOTTOM]) / 2; // adjust bounding box to map blocks block = (bbox[BOXTOP] - bmaporgy + MAXRADIUS) >> MAPBLOCKSHIFT; block = block >= bmapheight ? bmapheight - 1 : block; sector->blockbox[BOXTOP] = block; block = (bbox[BOXBOTTOM] - bmaporgy - MAXRADIUS) >> MAPBLOCKSHIFT; block = block < 0 ? 0 : block; sector->blockbox[BOXBOTTOM] = block; block = (bbox[BOXRIGHT] - bmaporgx + MAXRADIUS) >> MAPBLOCKSHIFT; block = block >= bmapwidth ? bmapwidth - 1 : block; sector->blockbox[BOXRIGHT] = block; block = (bbox[BOXLEFT] - bmaporgx - MAXRADIUS) >> MAPBLOCKSHIFT; block = block < 0 ? 0 : block; sector->blockbox[BOXLEFT] = block; } } //============================================================================= /* ================= = = P_SetupLevel = ================= */ void P_SetupLevel(int episode, int map, int playermask, skill_t skill) { int i; int parm; char lumpname[9]; int lumpnum; mobj_t *mobj; for (i = 0; i < MAXPLAYERS; i++) { players[i].killcount = players[i].secretcount = players[i].itemcount = 0; } players[consoleplayer].viewz = 1; // will be set by player think // Waiting-for-level-load song; not played if playing music from CD // (the seek time will be so long it will just make loading take // longer) if (!cdmusic) { S_StartSongName("chess", true); } Z_FreeTags(PU_LEVEL, PU_PURGELEVEL - 1); P_InitThinkers(); leveltime = 0; M_snprintf(lumpname, sizeof(lumpname), "MAP%02d", map); lumpnum = W_GetNumForName(lumpname); // // Begin processing map lumps // Note: most of this ordering is important // P_LoadBlockMap(lumpnum + ML_BLOCKMAP); P_LoadVertexes(lumpnum + ML_VERTEXES); P_LoadSectors(lumpnum + ML_SECTORS); P_LoadSideDefs(lumpnum + ML_SIDEDEFS); P_LoadLineDefs(lumpnum + ML_LINEDEFS); P_LoadSubsectors(lumpnum + ML_SSECTORS); P_LoadNodes(lumpnum + ML_NODES); P_LoadSegs(lumpnum + ML_SEGS); rejectmatrix = W_CacheLumpNum(lumpnum + ML_REJECT, PU_LEVEL); P_GroupLines(); bodyqueslot = 0; po_NumPolyobjs = 0; deathmatch_p = deathmatchstarts; P_LoadThings(lumpnum + ML_THINGS); PO_Init(lumpnum + ML_THINGS); // Initialize the polyobjs P_LoadACScripts(lumpnum + ML_BEHAVIOR); // ACS object code // // End of map lump processing // // If deathmatch, randomly spawn the active players TimerGame = 0; if (deathmatch) { for (i = 0; i < MAXPLAYERS; i++) { if (playeringame[i]) { // must give a player spot before deathmatchspawn mobj = P_SpawnMobj(playerstarts[0][i].x << 16, playerstarts[0][i].y << 16, 0, MT_PLAYER_FIGHTER); players[i].mo = mobj; G_DeathMatchSpawnPlayer(i); P_RemoveMobj(mobj); } } //! // @arg // @category net // @vanilla // // For multiplayer games: exit each level after n minutes. // parm = M_CheckParmWithArgs("-timer", 1); if (parm) { TimerGame = atoi(myargv[parm + 1]) * 35 * 60; } } // set up world state P_SpawnSpecials(); // build subsector connect matrix // P_ConnectSubsectors (); // Load colormap and set the fullbright flag i = P_GetMapFadeTable(gamemap); W_ReadLump(i, colormaps); if (i == W_GetNumForName("COLORMAP")) { LevelUseFullBright = true; } else { // Probably fog ... don't use fullbright sprites LevelUseFullBright = false; } // preload graphics if (precache) R_PrecacheLevel(); // Check if the level is a lightning level P_InitLightning(); S_StopAllSound(); SN_StopAllSequences(); S_StartSong(gamemap, true); //printf ("free memory: 0x%x\n", Z_FreeMemory()); } //========================================================================== // // InitMapInfo // //========================================================================== static void InitMapInfo(void) { int map; int mapMax; int mcmdValue; mapInfo_t *info; char songMulch[10]; char *default_sky_name = DEFAULT_SKY_NAME; mapMax = 1; if (gamemode == shareware) { default_sky_name = "SKY2"; } // Put defaults into MapInfo[0] info = MapInfo; info->cluster = 0; info->warpTrans = 0; info->nextMap = 1; // Always go to map 1 if not specified info->cdTrack = 1; info->sky1Texture = R_TextureNumForName(default_sky_name); info->sky2Texture = info->sky1Texture; info->sky1ScrollDelta = 0; info->sky2ScrollDelta = 0; info->doubleSky = false; info->lightning = false; info->fadetable = W_GetNumForName(DEFAULT_FADE_TABLE); M_StringCopy(info->name, UNKNOWN_MAP_NAME, sizeof(info->name)); // M_StringCopy(info->songLump, DEFAULT_SONG_LUMP, sizeof(info->songLump)); SC_Open(MAPINFO_SCRIPT_NAME); while (SC_GetString()) { if (SC_Compare("MAP") == false) { SC_ScriptError(NULL); } SC_MustGetNumber(); if (sc_Number < 1 || sc_Number > 99) { // SC_ScriptError(NULL); } map = sc_Number; info = &MapInfo[map]; // Save song lump name M_StringCopy(songMulch, info->songLump, sizeof(songMulch)); // Copy defaults to current map definition memcpy(info, &MapInfo[0], sizeof(*info)); // Restore song lump name M_StringCopy(info->songLump, songMulch, sizeof(info->songLump)); // The warp translation defaults to the map number info->warpTrans = map; // Map name must follow the number SC_MustGetString(); M_StringCopy(info->name, sc_String, sizeof(info->name)); // Process optional tokens while (SC_GetString()) { if (SC_Compare("MAP")) { // Start next map definition SC_UnGet(); break; } mcmdValue = MapCmdIDs[SC_MustMatchString(MapCmdNames)]; switch (mcmdValue) { case MCMD_CLUSTER: SC_MustGetNumber(); info->cluster = sc_Number; break; case MCMD_WARPTRANS: SC_MustGetNumber(); info->warpTrans = sc_Number; break; case MCMD_NEXT: SC_MustGetNumber(); info->nextMap = sc_Number; break; case MCMD_CDTRACK: SC_MustGetNumber(); info->cdTrack = sc_Number; break; case MCMD_SKY1: SC_MustGetString(); info->sky1Texture = R_TextureNumForName(sc_String); SC_MustGetNumber(); info->sky1ScrollDelta = sc_Number << 8; break; case MCMD_SKY2: SC_MustGetString(); info->sky2Texture = R_TextureNumForName(sc_String); SC_MustGetNumber(); info->sky2ScrollDelta = sc_Number << 8; break; case MCMD_DOUBLESKY: info->doubleSky = true; break; case MCMD_LIGHTNING: info->lightning = true; break; case MCMD_FADETABLE: SC_MustGetString(); info->fadetable = W_GetNumForName(sc_String); break; case MCMD_CD_STARTTRACK: case MCMD_CD_END1TRACK: case MCMD_CD_END2TRACK: case MCMD_CD_END3TRACK: case MCMD_CD_INTERTRACK: case MCMD_CD_TITLETRACK: SC_MustGetNumber(); cd_NonLevelTracks[mcmdValue - MCMD_CD_STARTTRACK] = sc_Number; break; } } mapMax = map > mapMax ? map : mapMax; } SC_Close(); MapCount = mapMax; } //========================================================================== // // P_GetMapCluster // //========================================================================== int P_GetMapCluster(int map) { return MapInfo[QualifyMap(map)].cluster; } //========================================================================== // // P_GetMapCDTrack // //========================================================================== int P_GetMapCDTrack(int map) { return MapInfo[QualifyMap(map)].cdTrack; } //========================================================================== // // P_GetMapWarpTrans // //========================================================================== int P_GetMapWarpTrans(int map) { return MapInfo[QualifyMap(map)].warpTrans; } //========================================================================== // // P_GetMapNextMap // //========================================================================== int P_GetMapNextMap(int map) { return MapInfo[QualifyMap(map)].nextMap; } //========================================================================== // // P_TranslateMap // // Returns the actual map number given a warp map number. // //========================================================================== int P_TranslateMap(int map) { int i; for (i = 1; i < 99; i++) // Make this a macro { if (MapInfo[i].warpTrans == map) { return i; } } // Not found return -1; } //========================================================================== // // P_GetMapSky1Texture // //========================================================================== int P_GetMapSky1Texture(int map) { return MapInfo[QualifyMap(map)].sky1Texture; } //========================================================================== // // P_GetMapSky2Texture // //========================================================================== int P_GetMapSky2Texture(int map) { return MapInfo[QualifyMap(map)].sky2Texture; } //========================================================================== // // P_GetMapName // //========================================================================== char *P_GetMapName(int map) { return MapInfo[QualifyMap(map)].name; } //========================================================================== // // P_GetMapSky1ScrollDelta // //========================================================================== fixed_t P_GetMapSky1ScrollDelta(int map) { return MapInfo[QualifyMap(map)].sky1ScrollDelta; } //========================================================================== // // P_GetMapSky2ScrollDelta // //========================================================================== fixed_t P_GetMapSky2ScrollDelta(int map) { return MapInfo[QualifyMap(map)].sky2ScrollDelta; } //========================================================================== // // P_GetMapDoubleSky // //========================================================================== boolean P_GetMapDoubleSky(int map) { return MapInfo[QualifyMap(map)].doubleSky; } //========================================================================== // // P_GetMapLightning // //========================================================================== boolean P_GetMapLightning(int map) { return MapInfo[QualifyMap(map)].lightning; } //========================================================================== // // P_GetMapFadeTable // //========================================================================== boolean P_GetMapFadeTable(int map) { return MapInfo[QualifyMap(map)].fadetable; } //========================================================================== // // P_GetMapSongLump // //========================================================================== char *P_GetMapSongLump(int map) { if (!strcasecmp(MapInfo[QualifyMap(map)].songLump, DEFAULT_SONG_LUMP)) { return NULL; } else { return MapInfo[QualifyMap(map)].songLump; } } //========================================================================== // // P_PutMapSongLump // //========================================================================== void P_PutMapSongLump(int map, char *lumpName) { if (map < 1 || map > MapCount) { return; } M_StringCopy(MapInfo[map].songLump, lumpName, sizeof(MapInfo[map].songLump)); } //========================================================================== // // P_GetCDStartTrack // //========================================================================== int P_GetCDStartTrack(void) { return cd_NonLevelTracks[MCMD_CD_STARTTRACK - MCMD_CD_STARTTRACK]; } //========================================================================== // // P_GetCDEnd1Track // //========================================================================== int P_GetCDEnd1Track(void) { return cd_NonLevelTracks[MCMD_CD_END1TRACK - MCMD_CD_STARTTRACK]; } //========================================================================== // // P_GetCDEnd2Track // //========================================================================== int P_GetCDEnd2Track(void) { return cd_NonLevelTracks[MCMD_CD_END2TRACK - MCMD_CD_STARTTRACK]; } //========================================================================== // // P_GetCDEnd3Track // //========================================================================== int P_GetCDEnd3Track(void) { return cd_NonLevelTracks[MCMD_CD_END3TRACK - MCMD_CD_STARTTRACK]; } //========================================================================== // // P_GetCDIntermissionTrack // //========================================================================== int P_GetCDIntermissionTrack(void) { return cd_NonLevelTracks[MCMD_CD_INTERTRACK - MCMD_CD_STARTTRACK]; } //========================================================================== // // P_GetCDTitleTrack // //========================================================================== int P_GetCDTitleTrack(void) { return cd_NonLevelTracks[MCMD_CD_TITLETRACK - MCMD_CD_STARTTRACK]; } //========================================================================== // // QualifyMap // //========================================================================== static int QualifyMap(int map) { return (map < 1 || map > MapCount) ? 0 : map; } //========================================================================== // // P_Init // //========================================================================== void P_Init(void) { InitMapInfo(); P_InitSwitchList(); P_InitFTAnims(); // Init flat and texture animations P_InitTerrainTypes(); P_InitLava(); R_InitSprites(sprnames); } // Special early initializer needed to start sound before R_Init() void InitMapMusicInfo(void) { int i; for (i = 0; i < 99; i++) { M_StringCopy(MapInfo[i].songLump, DEFAULT_SONG_LUMP, sizeof(MapInfo[i].songLump)); } MapCount = 98; } /* void My_Debug(void) { int i; printf("My debug stuff ----------------------\n"); printf("gamemap=%d\n",gamemap); for (i=0; i<10; i++) { printf("i=%d songlump=%s\n",i,MapInfo[i].songLump); } } */