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

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

射击游戏

开发平台：

Visual C++

p_mobj.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. // Moving object handling. Spawn functions.
  21. //
  22. //-----------------------------------------------------------------------------
  24. static const char
  25. rcsid[] = "$Id: p_mobj.c,v 1.5 1997/02/03 22:45:12 b1 Exp $";
  27. #include "i_system.h"
  28. #include "z_zone.h"
  29. #include "m_random.h"
  31. #include "doomdef.h"
  32. #include "p_local.h"
  33. #include "sounds.h"
  35. #include "st_stuff.h"
  36. #include "hu_stuff.h"
  38. #include "s_sound.h"
  40. #include "doomstat.h"
  43. void WriteDebug(char *);
  44. char MsgText[256];
  46. void G_PlayerReborn (int player);
  47. void P_SpawnMapThing (mapthing_t* mthing);
  50. //
  51. // P_SetMobjState
  52. // Returns true if the mobj is still present.
  53. //
  54. int test;
  56. boolean
  57. P_SetMobjState
  58. ( mobj_t* mobj,
  59.   statenum_t state )
  60. {
  61.     state_t* st;
  63.     do
  64.     {
  65. if (state == S_NULL)
  66. {
  67.     mobj->state = (state_t *) S_NULL;
  68.     P_RemoveMobj (mobj);
  69.     return false;
  70. }
  72. st = &states[state];
  73. mobj->state = st;
  74. mobj->tics = st->tics;
  75. mobj->sprite = st->sprite;
  76. mobj->frame = st->frame;
  78. // Modified handling.
  79. // Call action functions when the state is set
  80. if (st->action.acp1)
  81.     st->action.acp1(mobj);
  83. state = st->nextstate;
  84.     } while (!mobj->tics);
  86.     return true;
  87. }
  90. //
  91. // P_ExplodeMissile  
  92. //
  93. void P_ExplodeMissile (mobj_t* mo)
  94. {
  95.     mo->momx = mo->momy = mo->momz = 0;
  97.     P_SetMobjState (mo, mobjinfo[mo->type].deathstate);
  99.     mo->tics -= P_Random()&3;
  101.     if (mo->tics < 1)
  102. mo->tics = 1;
  104.     mo->flags &= ~MF_MISSILE;
  106.     if (mo->info->deathsound)
  107. S_StartSound (mo, mo->info->deathsound);
  108. }
  111. //
  112. // P_XYMovement  
  113. //
  114. #define STOPSPEED 0x1000
  115. #define FRICTION 0xe800
  117. void P_XYMovement (mobj_t* mo) 
  118. { 
  119.     fixed_t  ptryx;
  120.     fixed_t ptryy;
  121.     player_t* player;
  122.     fixed_t xmove;
  123.     fixed_t ymove;
  125.     if (!mo->momx && !mo->momy)
  126.     {
  127. if (mo->flags & MF_SKULLFLY)
  128. {
  129.     // the skull slammed into something
  130.     mo->flags &= ~MF_SKULLFLY;
  131.     mo->momx = mo->momy = mo->momz = 0;
  133.     P_SetMobjState (mo, mo->info->spawnstate);
  134. }
  135. return;
  136.     }
  138.     player = mo->player;
  140.     if (mo->momx > MAXMOVE)
  141. mo->momx = MAXMOVE;
  142.     else if (mo->momx < -MAXMOVE)
  143. mo->momx = -MAXMOVE;
  145.     if (mo->momy > MAXMOVE)
  146. mo->momy = MAXMOVE;
  147.     else if (mo->momy < -MAXMOVE)
  148. mo->momy = -MAXMOVE;
  150.     xmove = mo->momx;
  151.     ymove = mo->momy;
  153.     do
  154.     {
  155. if (xmove > MAXMOVE/2 || ymove > MAXMOVE/2)
  156. {
  157.     ptryx = mo->x + xmove/2;
  158.     ptryy = mo->y + ymove/2;
  159.     xmove >>= 1;
  160.     ymove >>= 1;
  161. }
  162. else
  163. {
  164.     ptryx = mo->x + xmove;
  165.     ptryy = mo->y + ymove;
  166.     xmove = ymove = 0;
  167. }
  169. if (!P_TryMove (mo, ptryx, ptryy))
  170. {
  171.     // blocked move
  172.     if (mo->player)
  173.     { // try to slide along it
  174. P_SlideMove (mo);
  175.     }
  176.     else if (mo->flags & MF_MISSILE)
  177.     {
  178. // explode a missile
  179. if (ceilingline &&
  180.     ceilingline->backsector &&
  181.     ceilingline->backsector->ceilingpic == skyflatnum)
  182. {
  183.     // Hack to prevent missiles exploding
  184.     // against the sky.
  185.     // Does not handle sky floors.
  186.     P_RemoveMobj (mo);
  187.     return;
  188. }
  189. P_ExplodeMissile (mo);
  190.     }
  191.     else
  192. mo->momx = mo->momy = 0;
  193. }
  194.     } while (xmove || ymove);
  195.     
  196.     // slow down
  197.     if (player && player->cheats & CF_NOMOMENTUM)
  198.     {
  199. // debug option for no sliding at all
  200. mo->momx = mo->momy = 0;
  201. return;
  202.     }
  204.     if (mo->flags & (MF_MISSILE | MF_SKULLFLY) )
  205. return;  // no friction for missiles ever
  207.     if (mo->z > mo->floorz)
  208. return; // no friction when airborne
  210.     if (mo->flags & MF_CORPSE)
  211.     {
  212. // do not stop sliding
  213. //  if halfway off a step with some momentum
  214. if (mo->momx > FRACUNIT/4
  215.     || mo->momx < -FRACUNIT/4
  216.     || mo->momy > FRACUNIT/4
  217.     || mo->momy < -FRACUNIT/4)
  218. {
  219.     if (mo->floorz != mo->subsector->sector->floorheight)
  220. return;
  221. }
  222.     }
  224.     if (mo->momx > -STOPSPEED
  225. && mo->momx < STOPSPEED
  226. && mo->momy > -STOPSPEED
  227. && mo->momy < STOPSPEED
  228. && (!player
  229.     || (player->cmd.forwardmove== 0
  230. && player->cmd.sidemove == 0 ) ) )
  231.     {
  232. // if in a walking frame, stop moving
  233. if ( player&&(unsigned)((player->mo->state - states)- S_PLAY_RUN1) < 4)
  234.     P_SetMobjState (player->mo, S_PLAY);
  236. mo->momx = 0;
  237. mo->momy = 0;
  238.     }
  239.     else
  240.     {
  241. mo->momx = FixedMul (mo->momx, FRICTION);
  242. mo->momy = FixedMul (mo->momy, FRICTION);
  243.     }
  244. }
  246. //
  247. // P_ZMovement
  248. //
  249. void P_ZMovement (mobj_t* mo)
  250. {
  251.     fixed_t dist;
  252.     fixed_t delta;
  253.     
  254.     // check for smooth step up
  255.     if (mo->player && mo->z < mo->floorz)
  256.     {
  257. mo->player->viewheight -= mo->floorz-mo->z;
  259. mo->player->deltaviewheight
  260.     = (VIEWHEIGHT - mo->player->viewheight)>>3;
  261.     }
  262.     
  263.     // adjust height
  264.     mo->z += mo->momz;
  266.     if ( mo->flags & MF_FLOAT
  267.  && mo->target)
  268.     {
  269. // float down towards target if too close
  270. if ( !(mo->flags & MF_SKULLFLY)
  271.      && !(mo->flags & MF_INFLOAT) )
  272. {
  273.     dist = P_AproxDistance (mo->x - mo->target->x,
  274.     mo->y - mo->target->y);
  275.     
  276.     delta =(mo->target->z + (mo->height>>1)) - mo->z;
  278.     if (delta<0 && dist < -(delta*3) )
  279. mo->z -= FLOATSPEED;
  280.     else if (delta>0 && dist < (delta*3) )
  281. mo->z += FLOATSPEED;
  282. }
  284.     }
  285.     
  286.     // clip movement
  287.     if (mo->z <= mo->floorz)
  288.     {
  289. // hit the floor
  291. // Note (id):
  292. //  somebody left this after the setting momz to 0,
  293. //  kinda useless there.
  294. if (mo->flags & MF_SKULLFLY)
  295. {
  296.     // the skull slammed into something
  297.     mo->momz = -mo->momz;
  298. }
  300. if (mo->momz < 0)
  301. {
  302.     if (mo->player
  303. && mo->momz < -GRAVITY*8)
  304.     {
  305. // Squat down.
  306. // Decrease viewheight for a moment
  307. // after hitting the ground (hard),
  308. // and utter appropriate sound.
  309. mo->player->deltaviewheight = mo->momz>>3;
  310. S_StartSound (mo, sfx_oof);
  311.     }
  312.     mo->momz = 0;
  313. }
  314. mo->z = mo->floorz;
  316. if ( (mo->flags & MF_MISSILE)
  317.      && !(mo->flags & MF_NOCLIP) )
  318. {
  319.     P_ExplodeMissile (mo);
  320.     return;
  321. }
  322.     }
  323.     else if (! (mo->flags & MF_NOGRAVITY) )
  324.     {
  325. if (mo->momz == 0)
  326.     mo->momz = -GRAVITY*2;
  327. else
  328.     mo->momz -= GRAVITY;
  329.     }
  331.     if (mo->z + mo->height > mo->ceilingz)
  332.     {
  333. // hit the ceiling
  334. if (mo->momz > 0)
  335.     mo->momz = 0;
  336. {
  337.     mo->z = mo->ceilingz - mo->height;
  338. }
  340. if (mo->flags & MF_SKULLFLY)
  341. { // the skull slammed into something
  342.     mo->momz = -mo->momz;
  343. }
  345. if ( (mo->flags & MF_MISSILE)
  346.      && !(mo->flags & MF_NOCLIP) )
  347. {
  348.     P_ExplodeMissile (mo);
  349.     return;
  350. }
  351.     }
  352. } 
  356. //
  357. // P_NightmareRespawn
  358. //
  359. void
  360. P_NightmareRespawn (mobj_t* mobj)
  361. {
  362.     fixed_t x;
  363.     fixed_t y;
  364.     fixed_t z; 
  365.     subsector_t* ss; 
  366.     mobj_t* mo;
  367.     mapthing_t* mthing;
  369.     x = mobj->spawnpoint.x << FRACBITS; 
  370.     y = mobj->spawnpoint.y << FRACBITS; 
  372.     // somthing is occupying it's position?
  373.     if (!P_CheckPosition (mobj, x, y) ) 
  374. return; // no respwan
  376.     // spawn a teleport fog at old spot
  377.     // because of removal of the body?
  378.     mo = P_SpawnMobj (mobj->x,
  379.       mobj->y,
  380.       mobj->subsector->sector->floorheight , MT_TFOG); 
  381.     // initiate teleport sound
  382.     S_StartSound (mo, sfx_telept);
  384.     // spawn a teleport fog at the new spot
  385.     ss = R_PointInSubsector (x,y); 
  387.     mo = P_SpawnMobj (x, y, ss->sector->floorheight , MT_TFOG); 
  389.     S_StartSound (mo, sfx_telept);
  391.     // spawn the new monster
  392.     mthing = &mobj->spawnpoint;
  394.     // spawn it
  395.     if (mobj->info->flags & MF_SPAWNCEILING)
  396. z = ONCEILINGZ;
  397.     else
  398. z = ONFLOORZ;
  400.     // inherit attributes from deceased one
  401.     mo = P_SpawnMobj (x,y,z, mobj->type);
  402.     mo->spawnpoint = mobj->spawnpoint;
  403.     mo->angle = ANG45 * (mthing->angle/45);
  405.     if (mthing->options & MTF_AMBUSH)
  406. mo->flags |= MF_AMBUSH;
  408.     mo->reactiontime = 18;
  410.     // remove the old monster,
  411.     P_RemoveMobj (mobj);
  412. }
  415. //
  416. // P_MobjThinker
  417. //
  418. void P_MobjThinker (mobj_t* mobj)
  419. {
  420.     // momentum movement
  421.     if (mobj->momx
  422. || mobj->momy
  423. || (mobj->flags&MF_SKULLFLY) )
  424.     {
  425. P_XYMovement (mobj);
  427. // FIXME: decent NOP/NULL/Nil function pointer please.
  428. if (mobj->thinker.function.acv == (actionf_v) (-1))
  429.     return; // mobj was removed
  430.     }
  431.     if ( (mobj->z != mobj->floorz)
  432.  || mobj->momz )
  433.     {
  434. P_ZMovement (mobj);
  436. // FIXME: decent NOP/NULL/Nil function pointer please.
  437. if (mobj->thinker.function.acv == (actionf_v) (-1))
  438.     return; // mobj was removed
  439.     }
  441.     
  442.     // cycle through states,
  443.     // calling action functions at transitions
  444.     if (mobj->tics != -1)
  445.     {
  446. mobj->tics--;
  448. // you can cycle through multiple states in a tic
  449. if (!mobj->tics)
  450.     if (!P_SetMobjState (mobj, mobj->state->nextstate) )
  451. return; // freed itself
  452.     }
  453.     else
  454.     {
  455. // check for nightmare respawn
  456. if (! (mobj->flags & MF_COUNTKILL) )
  457.     return;
  459. if (!respawnmonsters)
  460.     return;
  462. mobj->movecount++;
  464. if (mobj->movecount < 12*35)
  465.     return;
  467. if ( leveltime&31 )
  468.     return;
  470. if (P_Random () > 4)
  471.     return;
  473. P_NightmareRespawn (mobj);
  474.     }
  476. }
  479. //
  480. // P_SpawnMobj
  481. //
  482. mobj_t*
  483. P_SpawnMobj
  484. ( fixed_t x,
  485.   fixed_t y,
  486.   fixed_t z,
  487.   mobjtype_t type )
  488. {
  489.     mobj_t* mobj;
  490.     state_t* st;
  491.     mobjinfo_t* info;
  493.     mobj = Z_Malloc (sizeof(*mobj), PU_LEVEL, NULL);
  494.     memset (mobj, 0, sizeof (*mobj));
  495.     info = &mobjinfo[type];
  497.     mobj->type = type;
  498.     mobj->info = info;
  499.     mobj->x = x;
  500.     mobj->y = y;
  501.     mobj->radius = info->radius;
  502.     mobj->height = info->height;
  503.     mobj->flags = info->flags;
  504.     mobj->health = info->spawnhealth;
  506.     if (gameskill != sk_nightmare)
  507. mobj->reactiontime = info->reactiontime;
  508.     
  509.     mobj->lastlook = P_Random () % MAXPLAYERS;
  510.     // do not set the state with P_SetMobjState,
  511.     // because action routines can not be called yet
  512.     st = &states[info->spawnstate];
  514.     mobj->state = st;
  515.     mobj->tics = st->tics;
  516.     mobj->sprite = st->sprite;
  517.     mobj->frame = st->frame;
  519.     // set subsector and/or block links
  520.     P_SetThingPosition (mobj);
  522.     mobj->floorz = mobj->subsector->sector->floorheight;
  523.     mobj->ceilingz = mobj->subsector->sector->ceilingheight;
  525.     if (z == ONFLOORZ)
  526. mobj->z = mobj->floorz;
  527.     else if (z == ONCEILINGZ)
  528. mobj->z = mobj->ceilingz - mobj->info->height;
  529.     else 
  530. mobj->z = z;
  532.     mobj->thinker.function.acp1 = (actionf_p1)P_MobjThinker;
  534.     P_AddThinker (&mobj->thinker);
  536.     return mobj;
  537. }
  540. //
  541. // P_RemoveMobj
  542. //
  543. mapthing_t itemrespawnque[ITEMQUESIZE];
  544. int itemrespawntime[ITEMQUESIZE];
  545. int iquehead;
  546. int iquetail;
  549. void P_RemoveMobj (mobj_t* mobj)
  550. {
  551.     if ((mobj->flags & MF_SPECIAL)
  552. && !(mobj->flags & MF_DROPPED)
  553. && (mobj->type != MT_INV)
  554. && (mobj->type != MT_INS))
  555.     {
  556. itemrespawnque[iquehead] = mobj->spawnpoint;
  557. itemrespawntime[iquehead] = leveltime;
  558. iquehead = (iquehead+1)&(ITEMQUESIZE-1);
  560. // lose one off the end?
  561. if (iquehead == iquetail)
  562.     iquetail = (iquetail+1)&(ITEMQUESIZE-1);
  563.     }
  565.     // unlink from sector and block lists
  566.     P_UnsetThingPosition (mobj);
  567.     
  568.     // stop any playing sound
  569.     S_StopSound (mobj);
  570.     
  571.     // free block
  572.     P_RemoveThinker ((thinker_t*)mobj);
  573. }
  578. //
  579. // P_RespawnSpecials
  580. //
  581. void P_RespawnSpecials (void)
  582. {
  583.     fixed_t x;
  584.     fixed_t y;
  585.     fixed_t z;
  586.     
  587.     subsector_t* ss; 
  588.     mobj_t* mo;
  589.     mapthing_t* mthing;
  590.     
  591.     int i;
  593.     // only respawn items in deathmatch
  594.     if (deathmatch != 2)
  595. return; // 
  597.     // nothing left to respawn?
  598.     if (iquehead == iquetail)
  599. return;
  601.     // wait at least 30 seconds
  602.     if (leveltime - itemrespawntime[iquetail] < 30*35)
  603. return;
  605.     mthing = &itemrespawnque[iquetail];
  607.     x = mthing->x << FRACBITS; 
  608.     y = mthing->y << FRACBITS; 
  609.   
  610.     // spawn a teleport fog at the new spot
  611.     ss = R_PointInSubsector (x,y); 
  612.     mo = P_SpawnMobj (x, y, ss->sector->floorheight , MT_IFOG); 
  613.     S_StartSound (mo, sfx_itmbk);
  615.     // find which type to spawn
  616.     for (i=0 ; i< NUMMOBJTYPES ; i++)
  617.     {
  618. if (mthing->type == mobjinfo[i].doomednum)
  619.     break;
  620.     }
  621.     
  622.     // spawn it
  623.     if (mobjinfo[i].flags & MF_SPAWNCEILING)
  624. z = ONCEILINGZ;
  625.     else
  626. z = ONFLOORZ;
  628.     mo = P_SpawnMobj (x,y,z, i);
  629.     mo->spawnpoint = *mthing;
  630.     mo->angle = ANG45 * (mthing->angle/45);
  632.     // pull it from the que
  633.     iquetail = (iquetail+1)&(ITEMQUESIZE-1);
  634. }
  639. //
  640. // P_SpawnPlayer
  641. // Called when a player is spawned on the level.
  642. // Most of the player structure stays unchanged
  643. //  between levels.
  644. //
  645. void P_SpawnPlayer (mapthing_t* mthing)
  646. {
  647.     player_t* p;
  648.     fixed_t x;
  649.     fixed_t y;
  650.     fixed_t z;
  652.     mobj_t* mobj;
  654.     int i;
  656.     // not playing?
  657.     if (!playeringame[mthing->type-1])
  658. return;
  660.     p = &players[mthing->type-1];
  662.     if (p->playerstate == PST_REBORN)
  663. G_PlayerReborn (mthing->type-1);
  665.     x  = mthing->x << FRACBITS;
  666.     y  = mthing->y << FRACBITS;
  667.     z = ONFLOORZ;
  668.     mobj = P_SpawnMobj (x,y,z, MT_PLAYER);
  670.     // set color translations for player sprites
  671.     if (mthing->type > 1)
  672. mobj->flags |= (mthing->type-1)<<MF_TRANSSHIFT;
  674.     mobj->angle = ANG45 * (mthing->angle/45);
  675.     mobj->player = p;
  676.     mobj->health = p->health;
  678.     p->mo = mobj;
  679.     p->playerstate = PST_LIVE;
  680.     p->refire = 0;
  681.     p->message = NULL;
  682.     p->damagecount = 0;
  683.     p->bonuscount = 0;
  684.     p->extralight = 0;
  685.     p->fixedcolormap = 0;
  686.     p->viewheight = VIEWHEIGHT;
  688.     // setup gun psprite
  689.     P_SetupPsprites (p);
  690.     
  691.     // give all cards in death match mode
  692.     if (deathmatch)
  693. for (i=0 ; i<NUMCARDS ; i++)
  694.     p->cards[i] = true;
  696.     if (mthing->type-1 == consoleplayer)
  697.     {
  698. // wake up the status bar
  699. ST_Start ();
  700. // wake up the heads up text
  701. HU_Start ();
  702.     }
  703. }
  706. //
  707. // P_SpawnMapThing
  708. // The fields of the mapthing should
  709. // already be in host byte order.
  710. //
  711. void P_SpawnMapThing (mapthing_t* mthing)
  712. {
  713.     int i;
  714.     int bit;
  715.     mobj_t* mobj;
  716.     fixed_t x;
  717.     fixed_t y;
  718.     fixed_t z;
  720.     // count deathmatch start positions
  721.     if (mthing->type == 11)
  722.     {
  723. if (deathmatch_p < &deathmatchstarts[10])
  724. {
  725.     memcpy (deathmatch_p, mthing, sizeof(*mthing));
  726.     deathmatch_p++;
  727. }
  728. return;
  729.     }
  731.     // check for players specially
  732.     if (mthing->type <= 4)
  733.     {
  734. // save spots for respawning in network games
  735. playerstarts[mthing->type-1] = *mthing;
  736. if (!deathmatch)
  737.     P_SpawnPlayer (mthing);
  739. return;
  740.     }
  742.     // check for apropriate skill level
  743.     if (!netgame && (mthing->options & 16) )
  744. return;
  746.     if (gameskill == sk_baby)
  747. bit = 1;
  748.     else if (gameskill == sk_nightmare)
  749. bit = 4;
  750.     else
  751. bit = 1<<(gameskill-1);
  753.     if (!(mthing->options & bit) )
  754. return;
  756.     // find which type to spawn
  757.     for (i=0 ; i< NUMMOBJTYPES ; i++)
  758. if (mthing->type == mobjinfo[i].doomednum)
  759.     break;
  761.     if (i==NUMMOBJTYPES)
  762. I_Error ("P_SpawnMapThing: Unknown type %i at (%i, %i)",
  763.  mthing->type,
  764.  mthing->x, mthing->y);
  766.     // don't spawn keycards and players in deathmatch
  767.     if (deathmatch && mobjinfo[i].flags & MF_NOTDMATCH)
  768. return;
  770.     // don't spawn any monsters if -nomonsters
  771.     if (nomonsters
  772. && ( i == MT_SKULL
  773.      || (mobjinfo[i].flags & MF_COUNTKILL)) )
  774.     {
  775. return;
  776.     }
  777.     
  778.     // spawn it
  779.     x = mthing->x << FRACBITS;
  780.     y = mthing->y << FRACBITS;
  782.     if (mobjinfo[i].flags & MF_SPAWNCEILING)
  783. z = ONCEILINGZ;
  784.     else
  785. z = ONFLOORZ;
  786.     
  787.     mobj = P_SpawnMobj (x,y,z, i);
  788.     mobj->spawnpoint = *mthing;
  790.     if (mobj->tics > 0)
  791. mobj->tics = 1 + (P_Random () % mobj->tics);
  792.     if (mobj->flags & MF_COUNTKILL)
  793. totalkills++;
  794.     if (mobj->flags & MF_COUNTITEM)
  795. totalitems++;
  797.     mobj->angle = ANG45 * (mthing->angle/45);
  798.     if (mthing->options & MTF_AMBUSH)
  799. mobj->flags |= MF_AMBUSH;
  800. }
  804. //
  805. // GAME SPAWN FUNCTIONS
  806. //
  809. //
  810. // P_SpawnPuff
  811. //
  812. extern fixed_t attackrange;
  814. void
  815. P_SpawnPuff
  816. ( fixed_t x,
  817.   fixed_t y,
  818.   fixed_t z )
  819. {
  820.     mobj_t* th;
  822.     z += ((P_Random()-P_Random())<<10);
  824.     th = P_SpawnMobj (x,y,z, MT_PUFF);
  825.     th->momz = FRACUNIT;
  826.     th->tics -= P_Random()&3;
  828.     if (th->tics < 1)
  829. th->tics = 1;
  831.     // don't make punches spark on the wall
  832.     if (attackrange == MELEERANGE)
  833. P_SetMobjState (th, S_PUFF3);
  834. }
  838. //
  839. // P_SpawnBlood
  840. // 
  841. void
  842. P_SpawnBlood
  843. ( fixed_t x,
  844.   fixed_t y,
  845.   fixed_t z,
  846.   int damage )
  847. {
  848.     mobj_t* th;
  850.     z += ((P_Random()-P_Random())<<10);
  851.     th = P_SpawnMobj (x,y,z, MT_BLOOD);
  852.     th->momz = FRACUNIT*2;
  853.     th->tics -= P_Random()&3;
  855.     if (th->tics < 1)
  856. th->tics = 1;
  858.     if (damage <= 12 && damage >= 9)
  859. P_SetMobjState (th,S_BLOOD2);
  860.     else if (damage < 9)
  861. P_SetMobjState (th,S_BLOOD3);
  862. }
  866. //
  867. // P_CheckMissileSpawn
  868. // Moves the missile forward a bit
  869. //  and possibly explodes it right there.
  870. //
  871. void P_CheckMissileSpawn (mobj_t* th)
  872. {
  873.     th->tics -= P_Random()&3;
  874.     if (th->tics < 1)
  875. th->tics = 1;
  876.     
  877.     // move a little forward so an angle can
  878.     // be computed if it immediately explodes
  879.     th->x += (th->momx>>1);
  880.     th->y += (th->momy>>1);
  881.     th->z += (th->momz>>1);
  883.     if (!P_TryMove (th, th->x, th->y))
  884. P_ExplodeMissile (th);
  885. }
  888. //
  889. // P_SpawnMissile
  890. //
  891. mobj_t*
  892. P_SpawnMissile
  893. ( mobj_t* source,
  894.   mobj_t* dest,
  895.   mobjtype_t type )
  896. {
  897.     mobj_t* th;
  898.     angle_t an;
  899.     int dist;
  901.     th = P_SpawnMobj (source->x,
  902.       source->y,
  903.       source->z + 4*8*FRACUNIT, type);
  904.     
  905.     if (th->info->seesound)
  906. S_StartSound (th, th->info->seesound);
  908.     th->target = source; // where it came from
  909.     an = R_PointToAngle2 (source->x, source->y, dest->x, dest->y);
  911.     // fuzzy player
  912.     if (dest->flags & MF_SHADOW)
  913. an += (P_Random()-P_Random())<<20;
  915.     th->angle = an;
  916.     an >>= ANGLETOFINESHIFT;
  917.     th->momx = FixedMul (th->info->speed, finecosine[an]);
  918.     th->momy = FixedMul (th->info->speed, finesine[an]);
  920.     dist = P_AproxDistance (dest->x - source->x, dest->y - source->y);
  921.     dist = dist / th->info->speed;
  923.     if (dist < 1)
  924. dist = 1;
  926.     th->momz = (dest->z - source->z) / dist;
  927.     P_CheckMissileSpawn (th);
  929.     return th;
  930. }
  933. //
  934. // P_SpawnPlayerMissile
  935. // Tries to aim at a nearby monster
  936. //
  937. void
  938. P_SpawnPlayerMissile
  939. ( mobj_t* source,
  940.   mobjtype_t type )
  941. {
  942.     mobj_t* th;
  943.     angle_t an;
  944.     
  945.     fixed_t x;
  946.     fixed_t y;
  947.     fixed_t z;
  948.     fixed_t slope;
  949.     
  950.     // see which target is to be aimed at
  951.     an = source->angle;
  952.     slope = P_AimLineAttack (source, an, 16*64*FRACUNIT);
  953.     
  954.     if (!linetarget)
  955.     {
  956. an += 1<<26;
  957. slope = P_AimLineAttack (source, an, 16*64*FRACUNIT);
  959. if (!linetarget)
  960. {
  961.     an -= 2<<26;
  962.     slope = P_AimLineAttack (source, an, 16*64*FRACUNIT);
  963. }
  965. if (!linetarget)
  966. {
  967.     an = source->angle;
  968.     slope = 0;
  969. }
  970.     }
  972.     x = source->x;
  973.     y = source->y;
  974.     z = source->z + 4*8*FRACUNIT;
  976.     th = P_SpawnMobj (x,y,z, type);
  978.     if (th->info->seesound)
  979. S_StartSound (th, th->info->seesound);
  981.     th->target = source;
  982.     th->angle = an;
  983.     th->momx = FixedMul( th->info->speed,
  984.  finecosine[an>>ANGLETOFINESHIFT]);
  985.     th->momy = FixedMul( th->info->speed,
  986.  finesine[an>>ANGLETOFINESHIFT]);
  987.     th->momz = FixedMul( th->info->speed, slope);
  989.     P_CheckMissileSpawn (th);
  990. }