ref: a11819e2f42b1a05251f19b9c9ed41e516eec5f3
dir: /src/doom/p_setup.c/
// // Copyright(C) 1993-1996 Id Software, Inc. // 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. // // DESCRIPTION: // Do all the WAD I/O, get map description, // set up initial state and misc. LUTs. // #include <math.h> #include <stdlib.h> #include "z_zone.h" #include "deh_main.h" #include "i_swap.h" #include "m_argv.h" #include "m_bbox.h" #include "g_game.h" #include "i_system.h" #include "w_wad.h" #include "doomdef.h" #include "p_local.h" #include "s_sound.h" #include "doomstat.h" void P_SpawnMapThing (mapthing_t* mthing); // // MAP related Lookup tables. // Store VERTEXES, LINEDEFS, SIDEDEFS, etc. // 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; static int totallines; // BLOCKMAP // Created from axis aligned bounding box // of the map, a rectangular array of // blocks of size ... // Used to speed up collision detection // by spatial subdivision in 2D. // // Blockmap size. int bmapwidth; int bmapheight; // size in mapblocks short* blockmap; // int for larger maps // offsets in blockmap are from here short* blockmaplump; // origin of block map fixed_t bmaporgx; fixed_t bmaporgy; // for thing chains mobj_t** blocklinks; // REJECT // For fast sight rejection. // Speeds up enemy AI by skipping detailed // LineOf Sight calculation. // Without special effect, this could be // used as a PVS lookup as well. // byte* rejectmatrix; // Maintain single and multi player starting spots. #define MAX_DEATHMATCH_STARTS 10 mapthing_t deathmatchstarts[MAX_DEATHMATCH_STARTS]; mapthing_t* deathmatch_p; mapthing_t playerstarts[MAXPLAYERS]; boolean playerstartsingame[MAXPLAYERS]; // // P_LoadVertexes // void P_LoadVertexes (int lump) { byte* data; int i; mapvertex_t* ml; vertex_t* li; // Determine number of lumps: // total lump length / vertex record length. numvertexes = W_LumpLength (lump) / sizeof(mapvertex_t); // Allocate zone memory for buffer. vertexes = Z_Malloc (numvertexes*sizeof(vertex_t),PU_LEVEL,0); // Load data into cache. data = W_CacheLumpNum (lump, PU_STATIC); ml = (mapvertex_t *)data; li = vertexes; // Copy and convert vertex coordinates, // internal representation as fixed. for (i=0 ; i<numvertexes ; i++, li++, ml++) { li->x = SHORT(ml->x)<<FRACBITS; li->y = SHORT(ml->y)<<FRACBITS; } // Free buffer memory. W_ReleaseLumpNum(lump); } // // GetSectorAtNullAddress // sector_t* GetSectorAtNullAddress(void) { static boolean null_sector_is_initialized = false; static sector_t null_sector; if (!null_sector_is_initialized) { memset(&null_sector, 0, sizeof(null_sector)); I_GetMemoryValue(0, &null_sector.floorheight, 4); I_GetMemoryValue(4, &null_sector.ceilingheight, 4); null_sector_is_initialized = true; } return &null_sector; } // // P_LoadSegs // void P_LoadSegs (int lump) { byte* data; int i; mapseg_t* ml; seg_t* li; line_t* ldef; int linedef; int side; int sidenum; 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))<<FRACBITS; li->offset = (SHORT(ml->offset))<<FRACBITS; linedef = SHORT(ml->linedef); ldef = &lines[linedef]; li->linedef = ldef; side = SHORT(ml->side); // e6y: check for wrong indexes if ((unsigned)ldef->sidenum[side] >= (unsigned)numsides) { I_Error("P_LoadSegs: linedef %d for seg %d references a non-existent sidedef %d", linedef, i, (unsigned)ldef->sidenum[side]); } li->sidedef = &sides[ldef->sidenum[side]]; li->frontsector = sides[ldef->sidenum[side]].sector; if (ldef-> flags & ML_TWOSIDED) { sidenum = ldef->sidenum[side ^ 1]; // If the sidenum is out of range, this may be a "glass hack" // impassible window. Point at side #0 (this may not be // the correct Vanilla behavior; however, it seems to work for // OTTAWAU.WAD, which is the one place I've seen this trick // used). if (sidenum < 0 || sidenum >= numsides) { li->backsector = GetSectorAtNullAddress(); } else { li->backsector = sides[sidenum].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; } W_ReleaseLumpNum(lump); } // // P_LoadNodes // void P_LoadNodes (int lump) { byte* data; int i; int j; int 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 *mt; mapthing_t spawnthing; int numthings; boolean spawn; data = W_CacheLumpNum (lump,PU_STATIC); numthings = W_LumpLength (lump) / sizeof(mapthing_t); mt = (mapthing_t *)data; for (i=0 ; i<numthings ; i++, mt++) { spawn = true; // Do not spawn cool, new monsters if !commercial if (gamemode != commercial) { switch (SHORT(mt->type)) { case 68: // Arachnotron case 64: // Archvile case 88: // Boss Brain case 89: // Boss Shooter case 69: // Hell Knight case 67: // Mancubus case 71: // Pain Elemental case 65: // Former Human Commando case 66: // Revenant case 84: // Wolf SS spawn = false; break; } } if (spawn == false) break; // Do spawn all other stuff. spawnthing.x = SHORT(mt->x); spawnthing.y = SHORT(mt->y); spawnthing.angle = SHORT(mt->angle); spawnthing.type = SHORT(mt->type); spawnthing.options = SHORT(mt->options); P_SpawnMapThing(&spawnthing); } if (!deathmatch) { for (i = 0; i < MAXPLAYERS; i++) { if (playeringame[i] && !playerstartsingame[i]) { I_Error("P_LoadThings: Player %d start missing (vanilla crashes here)", i + 1); } playerstartsingame[i] = false; } } W_ReleaseLumpNum(lump); } // // P_LoadLineDefs // Also counts secret lines for intermissions. // void P_LoadLineDefs (int lump) { byte* data; int i; maplinedef_t* mld; line_t* ld; vertex_t* v1; vertex_t* 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); ld->special = SHORT(mld->special); ld->tag = SHORT(mld->tag); 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; int count; int lumplen; lumplen = W_LumpLength(lump); count = lumplen / 2; blockmaplump = Z_Malloc(lumplen, PU_LEVEL, NULL); W_ReadLump(lump, blockmaplump); blockmap = blockmaplump + 4; // Swap all short integers to native byte ordering. for (i=0; i<count; i++) { blockmaplump[i] = SHORT(blockmaplump[i]); } // Read the header 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; int j; 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; totallines = 0; for (i=0 ; i<numlines ; i++, li++) { totallines++; li->frontsector->linecount++; if (li->backsector && li->backsector != li->frontsector) { li->backsector->linecount++; totallines++; } } // build line tables for each sector linebuffer = Z_Malloc (totallines*sizeof(line_t *), PU_LEVEL, 0); for (i=0; i<numsectors; ++i) { // Assign the line buffer for this sector sectors[i].lines = linebuffer; linebuffer += sectors[i].linecount; // Reset linecount to zero so in the next stage we can count // lines into the list. sectors[i].linecount = 0; } // Assign lines to sectors for (i=0; i<numlines; ++i) { li = &lines[i]; if (li->frontsector != NULL) { sector = li->frontsector; sector->lines[sector->linecount] = li; ++sector->linecount; } if (li->backsector != NULL && li->frontsector != li->backsector) { sector = li->backsector; sector->lines[sector->linecount] = li; ++sector->linecount; } } // Generate bounding boxes for sectors sector = sectors; for (i=0 ; i<numsectors ; i++, sector++) { M_ClearBox (bbox); for (j=0 ; j<sector->linecount; j++) { li = sector->lines[j]; M_AddToBox (bbox, li->v1->x, li->v1->y); M_AddToBox (bbox, li->v2->x, li->v2->y); } // 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; } } // Pad the REJECT lump with extra data when the lump is too small, // to simulate a REJECT buffer overflow in Vanilla Doom. static void PadRejectArray(byte *array, unsigned int len) { unsigned int i; unsigned int byte_num; byte *dest; unsigned int padvalue; // Values to pad the REJECT array with: unsigned int rejectpad[4] = { 0, // Size 0, // Part of z_zone block header 50, // PU_LEVEL 0x1d4a11 // DOOM_CONST_ZONEID }; rejectpad[0] = ((totallines * 4 + 3) & ~3) + 24; // Copy values from rejectpad into the destination array. dest = array; for (i=0; i<len && i<sizeof(rejectpad); ++i) { byte_num = i % 4; *dest = (rejectpad[i / 4] >> (byte_num * 8)) & 0xff; ++dest; } // We only have a limited pad size. Print a warning if the // REJECT lump is too small. if (len > sizeof(rejectpad)) { fprintf(stderr, "PadRejectArray: REJECT lump too short to pad! (%u > %i)\n", len, (int) sizeof(rejectpad)); // Pad remaining space with 0 (or 0xff, if specified on command line). if (M_CheckParm("-reject_pad_with_ff")) { padvalue = 0xff; } else { padvalue = 0x00; } memset(array + sizeof(rejectpad), padvalue, len - sizeof(rejectpad)); } } static void P_LoadReject(int lumpnum) { int minlength; int lumplen; // Calculate the size that the REJECT lump *should* be. minlength = (numsectors * numsectors + 7) / 8; // If the lump meets the minimum length, it can be loaded directly. // Otherwise, we need to allocate a buffer of the correct size // and pad it with appropriate data. lumplen = W_LumpLength(lumpnum); if (lumplen >= minlength) { rejectmatrix = W_CacheLumpNum(lumpnum, PU_LEVEL); } else { rejectmatrix = Z_Malloc(minlength, PU_LEVEL, &rejectmatrix); W_ReadLump(lumpnum, rejectmatrix); PadRejectArray(rejectmatrix + lumplen, minlength - lumplen); } } // pointer to the current map lump info struct lumpinfo_t *maplumpinfo; // // P_SetupLevel // void P_SetupLevel ( int episode, int map, int playermask, skill_t skill) { int i; char lumpname[9]; int lumpnum; totalkills = totalitems = totalsecret = wminfo.maxfrags = 0; wminfo.partime = 180; for (i=0 ; i<MAXPLAYERS ; i++) { players[i].killcount = players[i].secretcount = players[i].itemcount = 0; } // Initial height of PointOfView // will be set by player think. players[consoleplayer].viewz = 1; // Make sure all sounds are stopped before Z_FreeTags. S_Start (); Z_FreeTags (PU_LEVEL, PU_PURGELEVEL-1); // UNUSED W_Profile (); P_InitThinkers (); // if working with a devlopment map, reload it W_Reload (); // find map name if ( gamemode == commercial) { if (map<10) DEH_snprintf(lumpname, 9, "map0%i", map); else DEH_snprintf(lumpname, 9, "map%i", map); } else { lumpname[0] = 'E'; lumpname[1] = '0' + episode; lumpname[2] = 'M'; lumpname[3] = '0' + map; lumpname[4] = 0; } lumpnum = W_GetNumForName (lumpname); maplumpinfo = lumpinfo[lumpnum]; leveltime = 0; // 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); P_GroupLines (); P_LoadReject (lumpnum+ML_REJECT); bodyqueslot = 0; deathmatch_p = deathmatchstarts; P_LoadThings (lumpnum+ML_THINGS); // if deathmatch, randomly spawn the active players if (deathmatch) { for (i=0 ; i<MAXPLAYERS ; i++) if (playeringame[i]) { players[i].mo = NULL; G_DeathMatchSpawnPlayer (i); } } // clear special respawning que iquehead = iquetail = 0; // set up world state P_SpawnSpecials (); // build subsector connect matrix // UNUSED P_ConnectSubsectors (); // preload graphics if (precache) R_PrecacheLevel (); //printf ("free memory: 0x%x\n", Z_FreeMemory()); } // // P_Init // void P_Init (void) { P_InitSwitchList (); P_InitPicAnims (); R_InitSprites (sprnames); }