开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 射击游戏 > 查看源码
p_setup.c
资源名称：21.rar　[点击查看]
上传用户：xuyinpeng
上传日期：2021-05-12
资源大小：455k
文件大小：16k
源码类别：

射击游戏

开发平台：

Visual C++

p_setup.c：源码内容
  1. // Emacs style mode select   -*- C++ -*- 
  2. //-----------------------------------------------------------------------------
  3. //
  4. // $Id:$
  5. //
  6. // Copyright (C) 1993-1996 by id Software, Inc.
  7. //
  8. // This source is available for distribution and/or modification
  9. // only under the terms of the DOOM Source Code License as
  10. // published by id Software. All rights reserved.
  11. //
  12. // The source is distributed in the hope that it will be useful,
  13. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  14. // FITNESS FOR A PARTICULAR PURPOSE. See the DOOM Source Code License
  15. // for more details.
  16. //
  17. // $Log:$
  18. //
  19. // DESCRIPTION:
  20. // Do all the WAD I/O, get map description,
  21. // set up initial state and misc. LUTs.
  22. //
  23. //-----------------------------------------------------------------------------
  25. static const char
  26. rcsid[] = "$Id: p_setup.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
  29. #include <math.h>
  31. #include "z_zone.h"
  33. #include "m_swap.h"
  34. #include "m_bbox.h"
  36. #include "g_game.h"
  38. #include "i_system.h"
  39. #include "w_wad.h"
  41. #include "doomdef.h"
  42. #include "p_local.h"
  44. #include "s_sound.h"
  46. #include "doomstat.h"
  48. char MsgText[256];
  49. void WriteDebug(char *);
  51. void P_SpawnMapThing (mapthing_t* mthing);
  53. //
  54. // MAP related Lookup tables.
  55. // Store VERTEXES, LINEDEFS, SIDEDEFS, etc.
  56. //
  57. int numvertexes;
  58. vertex_t* vertexes;
  60. int numsegs;
  61. seg_t* segs;
  63. int numsectors;
  64. sector_t* sectors;
  66. int numsubsectors;
  67. subsector_t* subsectors;
  69. int numnodes;
  70. node_t* nodes;
  72. int numlines;
  73. line_t* lines;
  75. int numsides;
  76. side_t* sides;
  79. // BLOCKMAP
  80. // Created from axis aligned bounding box
  81. // of the map, a rectangular array of
  82. // blocks of size ...
  83. // Used to speed up collision detection
  84. // by spatial subdivision in 2D.
  85. //
  86. // Blockmap size.
  87. int bmapwidth;
  88. int bmapheight; // size in mapblocks
  89. short* blockmap; // int for larger maps
  90. // offsets in blockmap are from here
  91. short* blockmaplump;
  92. // origin of block map
  93. fixed_t bmaporgx;
  94. fixed_t bmaporgy;
  95. // for thing chains
  96. mobj_t** blocklinks;
  99. // REJECT
  100. // For fast sight rejection.
  101. // Speeds up enemy AI by skipping detailed
  102. //  LineOf Sight calculation.
  103. // Without special effect, this could be
  104. //  used as a PVS lookup as well.
  105. //
  106. byte* rejectmatrix;
  109. // Maintain single and multi player starting spots.
  110. #define MAX_DEATHMATCH_STARTS 10
  112. mapthing_t deathmatchstarts[MAX_DEATHMATCH_STARTS];
  113. mapthing_t* deathmatch_p;
  114. mapthing_t playerstarts[MAXPLAYERS];
  120. //
  121. // P_LoadVertexes
  122. //
  123. void P_LoadVertexes (int lump)
  124. {
  125.     byte* data;
  126.     int i;
  127.     mapvertex_t* ml;
  128.     vertex_t* li;
  130.     // Determine number of lumps:
  131.     //  total lump length / vertex record length.
  132.     numvertexes = W_LumpLength (lump) / sizeof(mapvertex_t);
  134.     // Allocate zone memory for buffer.
  135.     vertexes = Z_Malloc (numvertexes*sizeof(vertex_t),PU_LEVEL,0);
  137.     // Load data into cache.
  138.     data = W_CacheLumpNum (lump,PU_STATIC);
  140.     ml = (mapvertex_t *)data;
  141.     li = vertexes;
  143.     // Copy and convert vertex coordinates,
  144.     // internal representation as fixed.
  145.     for (i=0 ; i<numvertexes ; i++, li++, ml++)
  146.     {
  147. li->x = SHORT(ml->x)<<FRACBITS;
  148. li->y = SHORT(ml->y)<<FRACBITS;
  149.     }
  151.     // Free buffer memory.
  152.     Z_Free (data);
  153. }
  157. //
  158. // P_LoadSegs
  159. //
  160. void P_LoadSegs (int lump)
  161. {
  162.     byte* data;
  163.     int i;
  164.     mapseg_t* ml;
  165.     seg_t* li;
  166.     line_t* ldef;
  167.     int linedef;
  168.     int side;
  170.     numsegs = W_LumpLength (lump) / sizeof(mapseg_t);
  171.     segs = Z_Malloc (numsegs*sizeof(seg_t),PU_LEVEL,0);
  172.     memset (segs, 0, numsegs*sizeof(seg_t));
  173.     data = W_CacheLumpNum (lump,PU_STATIC);
  175.     ml = (mapseg_t *)data;
  176.     li = segs;
  177.     for (i=0 ; i<numsegs ; i++, li++, ml++)
  178.     {
  179. li->v1 = &vertexes[SHORT(ml->v1)];
  180. li->v2 = &vertexes[SHORT(ml->v2)];
  182. li->angle = (SHORT(ml->angle))<<16;
  183. li->offset = (SHORT(ml->offset))<<16;
  184. linedef = SHORT(ml->linedef);
  185. ldef = &lines[linedef];
  186. li->linedef = ldef;
  187. side = SHORT(ml->side);
  188. li->sidedef = &sides[ldef->sidenum[side]];
  189. li->frontsector = sides[ldef->sidenum[side]].sector;
  190. if (ldef-> flags & ML_TWOSIDED)
  191.     li->backsector = sides[ldef->sidenum[side^1]].sector;
  192. else
  193.     li->backsector = 0;
  194.     }
  196.     Z_Free (data);
  197. }
  200. //
  201. // P_LoadSubsectors
  202. //
  203. void P_LoadSubsectors (int lump)
  204. {
  205.     byte* data;
  206.     int i;
  207.     mapsubsector_t* ms;
  208.     subsector_t* ss;
  210.     numsubsectors = W_LumpLength (lump) / sizeof(mapsubsector_t);
  211.     subsectors = Z_Malloc (numsubsectors*sizeof(subsector_t),PU_LEVEL,0);
  212.     data = W_CacheLumpNum (lump,PU_STATIC);
  214.     ms = (mapsubsector_t *)data;
  215.     memset (subsectors,0, numsubsectors*sizeof(subsector_t));
  216.     ss = subsectors;
  217.     
  218.     for (i=0 ; i<numsubsectors ; i++, ss++, ms++)
  219.     {
  220. ss->numlines = SHORT(ms->numsegs);
  221. ss->firstline = SHORT(ms->firstseg);
  222.     }
  224.     Z_Free (data);
  225. }
  229. //
  230. // P_LoadSectors
  231. //
  232. void P_LoadSectors (int lump)
  233. {
  234.     byte* data;
  235.     int i;
  236.     mapsector_t* ms;
  237.     sector_t* ss;
  239.     numsectors = W_LumpLength (lump) / sizeof(mapsector_t);
  240.     sectors = Z_Malloc (numsectors*sizeof(sector_t),PU_LEVEL,0);
  241.     memset (sectors, 0, numsectors*sizeof(sector_t));
  242.     data = W_CacheLumpNum (lump,PU_STATIC);
  244.     ms = (mapsector_t *)data;
  245.     ss = sectors;
  246.     for (i=0 ; i<numsectors ; i++, ss++, ms++)
  247.     {
  248. ss->floorheight = SHORT(ms->floorheight)<<FRACBITS;
  249. ss->ceilingheight = SHORT(ms->ceilingheight)<<FRACBITS;
  250. ss->floorpic = R_FlatNumForName(ms->floorpic);
  251. ss->ceilingpic = R_FlatNumForName(ms->ceilingpic);
  252. ss->lightlevel = SHORT(ms->lightlevel);
  253. ss->special = SHORT(ms->special);
  254. ss->tag = SHORT(ms->tag);
  255. ss->thinglist = NULL;
  256.     }
  258.     Z_Free (data);
  259. }
  262. //
  263. // P_LoadNodes
  264. //
  265. void P_LoadNodes (int lump)
  266. {
  267.     byte* data;
  268.     int i;
  269.     int j;
  270.     int k;
  271.     mapnode_t* mn;
  272.     node_t* no;
  274.     numnodes = W_LumpLength (lump) / sizeof(mapnode_t);
  275.     nodes = Z_Malloc (numnodes*sizeof(node_t),PU_LEVEL,0);
  276.     data = W_CacheLumpNum (lump,PU_STATIC);
  278.     mn = (mapnode_t *)data;
  279.     no = nodes;
  280.     
  281.     for (i=0 ; i<numnodes ; i++, no++, mn++)
  282.     {
  283. no->x = SHORT(mn->x)<<FRACBITS;
  284. no->y = SHORT(mn->y)<<FRACBITS;
  285. no->dx = SHORT(mn->dx)<<FRACBITS;
  286. no->dy = SHORT(mn->dy)<<FRACBITS;
  287. for (j=0 ; j<2 ; j++)
  288. {
  289.     no->children[j] = SHORT(mn->children[j]);
  290.     for (k=0 ; k<4 ; k++)
  291. no->bbox[j][k] = SHORT(mn->bbox[j][k])<<FRACBITS;
  292. }
  293.     }
  295.     Z_Free (data);
  296. }
  299. //
  300. // P_LoadThings
  301. //
  302. void P_LoadThings (int lump)
  303.    {
  304.     byte* data;
  305.     int i;
  306.     mapthing_t* mt;
  307.     int numthings;
  308.     boolean spawn;
  310.     data = W_CacheLumpNum (lump,PU_STATIC);
  311.     numthings = W_LumpLength (lump) / sizeof(mapthing_t);
  313.     mt = (mapthing_t *)data;
  314.     for (i=0 ; i<numthings ; i++, mt++)
  315.        {
  316.         spawn = true;
  318.         // Do not spawn cool, new monsters if !commercial
  319.         if ( gamemode != commercial)
  320.            {
  321.             switch(mt->type)
  322.                {
  323.                 case 68: // Arachnotron
  324.                 case 64: // Archvile
  325.                 case 88: // Boss Brain
  326.                 case 89: // Boss Shooter
  327.                 case 69: // Hell Knight
  328.                 case 67: // Mancubus
  329.                 case 71: // Pain Elemental
  330.                 case 65: // Former Human Commando
  331.                 case 66: // Revenant
  332.                 case 84: // Wolf SS
  333.                      spawn = false;
  334.                      break;
  335.                }
  336.            }
  337.         if (spawn == false)
  338.             break;
  340.         // Do spawn all other stuff. 
  341.         mt->x = SHORT(mt->x);
  342.         mt->y = SHORT(mt->y);
  343.         mt->angle = SHORT(mt->angle);
  344.         mt->type = SHORT(mt->type);
  345.         mt->options = SHORT(mt->options);
  347.         P_SpawnMapThing (mt);
  348.        }
  350.     Z_Free (data);
  351.    }
  354. //
  355. // P_LoadLineDefs
  356. // Also counts secret lines for intermissions.
  357. //
  358. void P_LoadLineDefs (int lump)
  359. {
  360.     byte* data;
  361.     int i;
  362.     maplinedef_t* mld;
  363.     line_t* ld;
  364.     vertex_t* v1;
  365.     vertex_t* v2;
  367.     numlines = W_LumpLength (lump) / sizeof(maplinedef_t);
  368.     lines = Z_Malloc (numlines*sizeof(line_t),PU_LEVEL,0);
  369.     memset (lines, 0, numlines*sizeof(line_t));
  370.     data = W_CacheLumpNum (lump,PU_STATIC);
  372.     mld = (maplinedef_t *)data;
  373.     ld = lines;
  374.     for (i=0 ; i<numlines ; i++, mld++, ld++)
  375.     {
  376. ld->flags = SHORT(mld->flags);
  377. ld->special = SHORT(mld->special);
  378. ld->tag = SHORT(mld->tag);
  379. v1 = ld->v1 = &vertexes[SHORT(mld->v1)];
  380. v2 = ld->v2 = &vertexes[SHORT(mld->v2)];
  381. ld->dx = v2->x - v1->x;
  382. ld->dy = v2->y - v1->y;
  384. if (!ld->dx)
  385.     ld->slopetype = ST_VERTICAL;
  386. else if (!ld->dy)
  387.     ld->slopetype = ST_HORIZONTAL;
  388. else
  389. {
  390.     if (FixedDiv (ld->dy , ld->dx) > 0)
  391. ld->slopetype = ST_POSITIVE;
  392.     else
  393. ld->slopetype = ST_NEGATIVE;
  394. }
  396. if (v1->x < v2->x)
  397. {
  398.     ld->bbox[BOXLEFT] = v1->x;
  399.     ld->bbox[BOXRIGHT] = v2->x;
  400. }
  401. else
  402. {
  403.     ld->bbox[BOXLEFT] = v2->x;
  404.     ld->bbox[BOXRIGHT] = v1->x;
  405. }
  407. if (v1->y < v2->y)
  408. {
  409.     ld->bbox[BOXBOTTOM] = v1->y;
  410.     ld->bbox[BOXTOP] = v2->y;
  411. }
  412. else
  413. {
  414.     ld->bbox[BOXBOTTOM] = v2->y;
  415.     ld->bbox[BOXTOP] = v1->y;
  416. }
  418. ld->sidenum[0] = SHORT(mld->sidenum[0]);
  419. ld->sidenum[1] = SHORT(mld->sidenum[1]);
  421. if (ld->sidenum[0] != -1)
  422.     ld->frontsector = sides[ld->sidenum[0]].sector;
  423. else
  424.     ld->frontsector = 0;
  426. if (ld->sidenum[1] != -1)
  427.     ld->backsector = sides[ld->sidenum[1]].sector;
  428. else
  429.     ld->backsector = 0;
  430.     }
  432.     Z_Free (data);
  433. }
  435. //
  436. // P_LoadSideDefs
  437. //
  438. void P_LoadSideDefs (int lump)
  439. {
  440.     byte* data;
  441.     int i;
  442.     mapsidedef_t* msd;
  443.     side_t* sd;
  445.     numsides = W_LumpLength (lump) / sizeof(mapsidedef_t);
  446.     sides = Z_Malloc (numsides*sizeof(side_t),PU_LEVEL,0);
  447.     memset (sides, 0, numsides*sizeof(side_t));
  448.     data = W_CacheLumpNum (lump,PU_STATIC);
  450.     msd = (mapsidedef_t *)data;
  451.     sd = sides;
  452.     for (i=0 ; i<numsides ; i++, msd++, sd++)
  453.     {
  454. sd->textureoffset = SHORT(msd->textureoffset)<<FRACBITS;
  455. sd->rowoffset = SHORT(msd->rowoffset)<<FRACBITS;
  456. sd->toptexture = R_TextureNumForName(msd->toptexture);
  457. sd->bottomtexture = R_TextureNumForName(msd->bottomtexture);
  458. sd->midtexture = R_TextureNumForName(msd->midtexture);
  459. sd->sector = &sectors[SHORT(msd->sector)];
  460.     }
  462.     Z_Free (data);
  463. }
  466. //
  467. // P_LoadBlockMap
  468. //
  469. void P_LoadBlockMap (int lump)
  470. {
  471.     int i;
  472.     int count;
  474.     blockmaplump = W_CacheLumpNum (lump,PU_LEVEL);
  475.     blockmap = blockmaplump+4;
  476.     count = W_LumpLength (lump)/2;
  478.     for (i=0 ; i<count ; i++)
  479.        blockmaplump[i] = SHORT(blockmaplump[i]);
  481.     bmaporgx = blockmaplump[0]<<FRACBITS;
  482.     bmaporgy = blockmaplump[1]<<FRACBITS;
  483.     bmapwidth = blockmaplump[2];
  484.     bmapheight = blockmaplump[3];
  486.     // clear out mobj chains
  487.     count = sizeof(*blocklinks)* bmapwidth*bmapheight;
  488.     blocklinks = Z_Malloc (count,PU_LEVEL, 0);
  489.     memset (blocklinks, 0, count);
  490. }
  494. //
  495. // P_GroupLines
  496. // Builds sector line lists and subsector sector numbers.
  497. // Finds block bounding boxes for sectors.
  498. //
  499. void P_GroupLines (void)
  500. {
  501.     line_t** linebuffer;
  502.     int i;
  503.     int j;
  504.     int total;
  505.     line_t* li;
  506.     sector_t* sector;
  507.     subsector_t* ss;
  508.     seg_t* seg;
  509.     fixed_t bbox[4];
  510.     int block;
  512.     // look up sector number for each subsector
  513.     ss = subsectors;
  514.     for (i=0 ; i<numsubsectors ; i++, ss++)
  515.     {
  516. seg = &segs[ss->firstline];
  517. ss->sector = seg->sidedef->sector;
  518.     }
  520.     // count number of lines in each sector
  521.     li = lines;
  522.     total = 0;
  523.     for (i=0 ; i<numlines ; i++, li++)
  524.     {
  525. total++;
  526. li->frontsector->linecount++;
  528. if (li->backsector && li->backsector != li->frontsector)
  529. {
  530.     li->backsector->linecount++;
  531.     total++;
  532. }
  533.     }
  535.     // build line tables for each sector
  536.     linebuffer = Z_Malloc (total*4, PU_LEVEL, 0);
  537.     sector = sectors;
  538.     for (i=0 ; i<numsectors ; i++, sector++)
  539.     {
  540. M_ClearBox (bbox);
  541. sector->lines = linebuffer;
  542. li = lines;
  543. for (j=0 ; j<numlines ; j++, li++)
  544. {
  545.     if (li->frontsector == sector || li->backsector == sector)
  546.     {
  547. *linebuffer++ = li;
  548. M_AddToBox (bbox, li->v1->x, li->v1->y);
  549. M_AddToBox (bbox, li->v2->x, li->v2->y);
  550.     }
  551. }
  552. if (linebuffer - sector->lines != sector->linecount)
  553.     I_Error ("P_GroupLines: miscounted");
  555. // set the degenmobj_t to the middle of the bounding box
  556. sector->soundorg.x = (bbox[BOXRIGHT]+bbox[BOXLEFT])/2;
  557. sector->soundorg.y = (bbox[BOXTOP]+bbox[BOXBOTTOM])/2;
  559. // adjust bounding box to map blocks
  560. block = (bbox[BOXTOP]-bmaporgy+MAXRADIUS)>>MAPBLOCKSHIFT;
  561. block = block >= bmapheight ? bmapheight-1 : block;
  562. sector->blockbox[BOXTOP]=block;
  564. block = (bbox[BOXBOTTOM]-bmaporgy-MAXRADIUS)>>MAPBLOCKSHIFT;
  565. block = block < 0 ? 0 : block;
  566. sector->blockbox[BOXBOTTOM]=block;
  568. block = (bbox[BOXRIGHT]-bmaporgx+MAXRADIUS)>>MAPBLOCKSHIFT;
  569. block = block >= bmapwidth ? bmapwidth-1 : block;
  570. sector->blockbox[BOXRIGHT]=block;
  572. block = (bbox[BOXLEFT]-bmaporgx-MAXRADIUS)>>MAPBLOCKSHIFT;
  573. block = block < 0 ? 0 : block;
  574. sector->blockbox[BOXLEFT]=block;
  575.     }
  577. }
  579. void WriteDebug(char *);
  581. //
  582. // P_SetupLevel
  583. //
  584. void
  585. P_SetupLevel
  586. ( int episode,
  587.   int map,
  588.   int playermask,
  589.   skill_t skill)
  590. {
  591.     int i;
  592.     char lumpname[9];
  593.     int lumpnum;
  595.     totalkills = totalitems = totalsecret = wminfo.maxfrags = 0;
  596.     wminfo.partime = 180;
  597.     for (i=0 ; i<MAXPLAYERS ; i++)
  598.     {
  599. players[i].killcount = players[i].secretcount 
  600.     = players[i].itemcount = 0;
  601.     }
  603.     // Initial height of PointOfView
  604.     // will be set by player think.
  605.     players[consoleplayer].viewz = 1; 
  607.     // Make sure all sounds are stopped before Z_FreeTags.
  608.     S_Start ();
  610.     
  611. #if 0 // UNUSED
  612.     if (debugfile)
  613.     {
  614. Z_FreeTags (PU_LEVEL, MAXINT);
  615. Z_FileDumpHeap (debugfile);
  616.     }
  617.     else
  618. #endif
  619.        {
  620. Z_FreeTags (PU_LEVEL, PU_PURGELEVEL-1);
  621.        }
  624.     // UNUSED W_Profile ();
  625.     P_InitThinkers ();
  627.     // if working with a devlopment map, reload it
  628.     W_Reload ();
  629.    
  630.     // find map name
  631.     if ( gamemode == commercial)
  632.     {
  633. if (map<10)
  634.     sprintf (lumpname,"map0%i", map);
  635. else
  636.     sprintf (lumpname,"map%i", map);
  637.     }
  638.     else
  639.     {
  640. lumpname[0] = 'E';
  641. lumpname[1] = '0' + episode;
  642. lumpname[2] = 'M';
  643. lumpname[3] = '0' + map;
  644. lumpname[4] = 0;
  645.     }
  647.     lumpnum = W_GetNumForName (lumpname);
  649.     leveltime = 0;
  651.     // note: most of this ordering is important
  652.     P_LoadBlockMap (lumpnum+ML_BLOCKMAP);
  653.     P_LoadVertexes (lumpnum+ML_VERTEXES);
  654.     P_LoadSectors (lumpnum+ML_SECTORS);
  655.     P_LoadSideDefs (lumpnum+ML_SIDEDEFS);
  657.     P_LoadLineDefs (lumpnum+ML_LINEDEFS);
  658.     P_LoadSubsectors (lumpnum+ML_SSECTORS);
  659.     P_LoadNodes (lumpnum+ML_NODES);
  660.     P_LoadSegs (lumpnum+ML_SEGS);
  662.     rejectmatrix = W_CacheLumpNum (lumpnum+ML_REJECT,PU_LEVEL);
  663.     P_GroupLines ();
  665.     bodyqueslot = 0;
  666.     deathmatch_p = deathmatchstarts;
  667.     P_LoadThings (lumpnum+ML_THINGS);
  668.     
  669.     // if deathmatch, randomly spawn the active players
  670.     if (deathmatch)
  671.     {
  672. for (i=0 ; i<MAXPLAYERS ; i++)
  673.     if (playeringame[i])
  674.     {
  675. players[i].mo = NULL;
  676. G_DeathMatchSpawnPlayer (i);
  677.     }
  679.     }
  681.     // clear special respawning que
  682.     iquehead = iquetail = 0;
  684.     // set up world state
  685.     P_SpawnSpecials ();
  687.     // build subsector connect matrix
  688.     // UNUSED P_ConnectSubsectors ();
  690.     // preload graphics
  691.     if (precache)
  692.        {
  693. R_PrecacheLevel ();
  694.        }
  696.     //printf ("free memory: 0x%xn", Z_FreeMemory());
  698. }
  702. //
  703. // P_Init
  704. //
  705. void P_Init (void)
  706. {
  707.     P_InitSwitchList ();
  708.     P_InitPicAnims ();
  709.     R_InitSprites (sprnames);
  710. }