Iskhodnyy_kod_Doom

//mapblocks are used to check movement

//against lines and things

//MAXRADIUS is for precalculated sector block boxes

//the spider demon is larger,

//but we do not have any moving sectors nearby

//

//P_TICK

//both the head and tail of the thinker list

//

// P_PSPR

//

void P_SetupPsprites (player_t* curplayer); void P_MovePsprites (player_t* curplayer); void P_DropWeapon (player_t* player);

441

void P_RespawnSpecials (void);

mobj_t* P_SpawnMobj

(fixed_t x, fixed_t y, fixed_t z,

mobj_t* P_SpawnMissile (mobj_t* source, mobj_t* dest, mobjtype_t type);

void P_SpawnPlayerMissile (mobj_t* source, mobjtype_t type);

//

// P_ENEMY

//

void P_NoiseAlert (mobj_t* target, mobj_t* emmiter);

typedef boolean (*traverser_t) (intercept_t *in);

442

boolean P_BlockLinesIterator (int x, int y, boolean(*func)(line_t*) ); boolean P_BlockThingsIterator (int x, int y, boolean(*func)(mobj_t*) );

boolean P_PathTraverse

(fixed_t x1, fixed_t y1, fixed_t x2,

void P_UnsetThingPosition (mobj_t* thing); void P_SetThingPosition (mobj_t* thing);

//

//P_MAP

//If "floatok" true, move would be ok

//if within "tmfloorz - tmceilingz".

extern line_t* ceilingline;

boolean P_CheckPosition (mobj_t *thing, fixed_t x, fixed_t y); boolean P_TryMove (mobj_t* thing, fixed_t x, fixed_t y); boolean P_TeleportMove (mobj_t* thing, fixed_t x, fixed_t y);

(mobj_t* t1, angle_t angle,

443

void P_TouchSpecialThing

( mobj_t* special, mobj_t* toucher );

void P_DamageMobj

(mobj_t* target, mobj_t* inflictor,

//

// P_SPEC

//

#include "p_spec.h"

444

9.11 p map.c

// Emacs style mode select -*- C++ -*- //-----------------------------------------------------------------------------

//

//$Id:$

//Copyright (C) 1993-1996 by id Software, Inc.

//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.

//

//$Log:$

//DESCRIPTION:

//Movement, collision handling.

//Shooting and aiming.

//

//-----------------------------------------------------------------------------

static const char

rcsid[] = "$Id: p_map.c,v 1.5 1997/02/03 22:45:11 b1 Exp $";

//If "floatok" true, move would be ok

//if within "tmfloorz - tmceilingz".

//keep track of the line that lowers the ceiling,

//so missiles don’t explode against sky hack walls

445

//keep track of special lines as they are hit,

//but don’t process them until the move is proven valid

//

// TELEPORT MOVE

//

//

// PIT_StompThing

//

boolean PIT_StompThing (mobj_t* thing)

{

fixed_t blockdist;

if (!(thing->flags & MF_SHOOTABLE) ) return true;

blockdist = thing->radius + tmthing->radius;

if ( abs(thing->x - tmx) >= blockdist

|| abs(thing->y - tmy) >= blockdist )

{

// didn’t hit it return true;

}

//don’t clip against self if (thing == tmthing)

return true;

//monsters don’t stomp things except on boss level if ( !tmthing->player && gamemap != 30)

return false;

P_DamageMobj (thing, tmthing, tmthing, 10000);

return true;

446

tmx = x; tmy = y;

tmbbox[BOXTOP] = y + tmthing->radius; tmbbox[BOXBOTTOM] = y - tmthing->radius; tmbbox[BOXRIGHT] = x + tmthing->radius; tmbbox[BOXLEFT] = x - tmthing->radius;

newsubsec = R_PointInSubsector (x,y); ceilingline = NULL;

//The base floor/ceiling is from the subsector

//that contains the point.

//Any contacted lines the step closer together

//will adjust them.

tmfloorz = tmdropoffz = newsubsec->sector->floorheight; tmceilingz = newsubsec->sector->ceilingheight;

validcount++; numspechit = 0;

// stomp on any things contacted

xl = (tmbbox[BOXLEFT] - bmaporgx - MAXRADIUS)>>MAPBLOCKSHIFT; xh = (tmbbox[BOXRIGHT] - bmaporgx + MAXRADIUS)>>MAPBLOCKSHIFT; yl = (tmbbox[BOXBOTTOM] - bmaporgy - MAXRADIUS)>>MAPBLOCKSHIFT; yh = (tmbbox[BOXTOP] - bmaporgy + MAXRADIUS)>>MAPBLOCKSHIFT;

for (bx=xl ; bx<=xh ; bx++)

for (by=yl ; by<=yh ; by++)

if (!P_BlockThingsIterator(bx,by,PIT_StompThing)) return false;

//the move is ok,

//so link the thing into its new position P_UnsetThingPosition (thing);

thing->floorz = tmfloorz; thing->ceilingz = tmceilingz; thing->x = x;

thing->y = y;

P_SetThingPosition (thing);

return true;

}

//

// MOVEMENT ITERATOR FUNCTIONS

//

//

//PIT_CheckLine

//Adjusts tmfloorz and tmceilingz as lines are contacted

boolean PIT_CheckLine (line_t* ld)

{

if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT]

||tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT]

||tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM]

447

|| tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP] ) return true;

if (P_BoxOnLineSide (tmbbox, ld) != -1) return true;

//A line has been hit

//The moving thing’s destination position will cross

//the given line.

//If this should not be allowed, return false.

//If the line is special, keep track of it

//to process later if the move is proven ok.

//NOTE: specials are NOT sorted by order,

//so two special lines that are only 8 pixels apart

//could be crossed in either order.

if (!(tmthing->flags & MF_MISSILE) )

{

if ( ld->flags & ML_BLOCKING )

}

//set openrange, opentop, openbottom P_LineOpening (ld);

//adjust floor / ceiling heights

if (opentop < tmceilingz)

{

tmceilingz = opentop; ceilingline = ld;

}

if (openbottom > tmfloorz) tmfloorz = openbottom;

if (lowfloor < tmdropoffz) tmdropoffz = lowfloor;

// if contacted a special line, add it to the list if (ld->special)

{

spechit[numspechit] = ld; numspechit++;

}

return true;

}

//

// PIT_CheckThing

//

boolean PIT_CheckThing (mobj_t* thing)

{

if (!(thing->flags & (MF_SOLID|MF_SPECIAL|MF_SHOOTABLE) ))

448

return true;

blockdist = thing->radius + tmthing->radius;

if ( abs(thing->x - tmx) >= blockdist

|| abs(thing->y - tmy) >= blockdist )

{

// didn’t hit it return true;

}

//don’t clip against self if (thing == tmthing)

return true;

//check for skulls slamming into things if (tmthing->flags & MF_SKULLFLY)

{

damage = ((P_Random()%8)+1)*tmthing->info->damage;

P_DamageMobj (thing, tmthing, tmthing, damage);

tmthing->flags &= ~MF_SKULLFLY;

tmthing->momx = tmthing->momy = tmthing->momz = 0;

P_SetMobjState (tmthing, tmthing->info->spawnstate);

// missiles can hit other things if (tmthing->flags & MF_MISSILE)

{

if (tmthing->target && ( tmthing->target->type == thing->type ||

(tmthing->target->type == MT_KNIGHT && thing->type == MT_BRUISER)|| (tmthing->target->type == MT_BRUISER && thing->type == MT_KNIGHT) ) )

{

// Don’t hit same species as originator. if (thing == tmthing->target)

return true;

if (thing->type != MT_PLAYER)

{

//Explode, but do no damage.

//Let players missile other players. return false;

}

}

if (! (thing->flags & MF_SHOOTABLE) )

{

// didn’t do any damage

return !(thing->flags & MF_SOLID);

}

// damage / explode

damage = ((P_Random()%8)+1)*tmthing->info->damage;

449

P_DamageMobj (thing, tmthing, tmthing->target, damage);

// don’t traverse any more return false;

}

// check for special pickup

if (thing->flags & MF_SPECIAL)

{

solid = thing->flags&MF_SOLID; if (tmflags&MF_PICKUP)

{

// can remove thing P_TouchSpecialThing (thing, tmthing);

}

return !solid;

}

return !(thing->flags & MF_SOLID);

}

//

// MOVEMENT CLIPPING

//

//

//P_CheckPosition

//This is purely informative, nothing is modified

//(except things picked up).

//

//in:

//a mobj_t (can be valid or invalid)

//a position to be checked

//(doesn’t need to be related to the mobj_t->x,y)

//during:

//special things are touched if MF_PICKUP

//early out on solid lines?

//

//out:

//newsubsec

//floorz

//ceilingz

//tmdropoffz

//the lowest point contacted

//(monsters won’t move to a dropoff)

//speciallines[]

//numspeciallines

450