Iskhodnyy_kod_Doom

tmflags = thing->flags;

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;

if ( tmflags & MF_NOCLIP ) return true;

//Check things first, possibly picking things up.

//The bounding box is extended by MAXRADIUS

//because mobj_ts are grouped into mapblocks

//based on their origin point, and can overlap

//into adjacent blocks by up to MAXRADIUS units.

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_CheckThing)) return false;

// check lines

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

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

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

if (!P_BlockLinesIterator (bx,by,PIT_CheckLine)) return false;

return true;

}

//

//P_TryMove

//Attempt to move to a new position,

//crossing special lines unless MF_TELEPORT is set.

boolean P_TryMove

( mobj_t* thing,

fixed_t x,

451

floatok = false;

if (!P_CheckPosition (thing, x, y))

if ( !(thing->flags&MF_TELEPORT)

&& tmfloorz - thing->z > 24*FRACUNIT )

return false; // too big a step up

if ( !(thing->flags&(MF_DROPOFF|MF_FLOAT))

&& tmfloorz - tmdropoffz > 24*FRACUNIT )

//the move is ok,

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

oldx = thing->x; oldy = thing->y;

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

thing->y = y;

P_SetThingPosition (thing);

// if any special lines were hit, do the effect if (! (thing->flags&(MF_TELEPORT|MF_NOCLIP)) )

{

while (numspechit--)

{

// see if the line was crossed ld = spechit[numspechit];

side = P_PointOnLineSide (thing->x, thing->y, ld); oldside = P_PointOnLineSide (oldx, oldy, ld);

if (side != oldside)

{

if (ld->special)

P_CrossSpecialLine (ld-lines, oldside, thing);

}

}

}

return true;

}

452

//

//P_ThingHeightClip

//Takes a valid thing and adjusts the thing->floorz,

//thing->ceilingz, and possibly thing->z.

//This is called for all nearby monsters

//whenever a sector changes height.

//If the thing doesn’t fit,

//the z will be set to the lowest value

//and false will be returned.

//

boolean P_ThingHeightClip (mobj_t* thing)

{

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

if (onfloor)

{

// walking monsters rise and fall with the floor thing->z = thing->floorz;

}

else

{

// don’t adjust a floating monster unless forced to if (thing->z+thing->height > thing->ceilingz)

thing->z = thing->ceilingz - thing->height;

}

if (thing->ceilingz - thing->floorz < thing->height) return false;

return true;

}

//

//SLIDE MOVE

//Allows the player to slide along any angled walls.

//

//P_HitSlideLine

//Adjusts the xmove / ymove

//so that the next move will slide along the wall.

453

void P_HitSlideLine (line_t* ld)

{

if (ld->slopetype == ST_HORIZONTAL)

{

tmymove = 0; return;

}

if (ld->slopetype == ST_VERTICAL)

{

tmxmove = 0; return;

}

side = P_PointOnLineSide (slidemo->x, slidemo->y, ld);

lineangle = R_PointToAngle2 (0,0, ld->dx, ld->dy);

if (side == 1)

lineangle += ANG180;

moveangle = R_PointToAngle2 (0,0, tmxmove, tmymove); deltaangle = moveangle-lineangle;

if (deltaangle > ANG180) deltaangle += ANG180;

//I_Error ("SlideLine: ang>ANG180");

lineangle >>= ANGLETOFINESHIFT; deltaangle >>= ANGLETOFINESHIFT;

movelen = P_AproxDistance (tmxmove, tmymove);

newlen = FixedMul (movelen, finecosine[deltaangle]);

tmxmove = FixedMul (newlen, finecosine[lineangle]); tmymove = FixedMul (newlen, finesine[lineangle]);

}

//

// PTR_SlideTraverse

//

boolean PTR_SlideTraverse (intercept_t* in)

{

line_t* li;

if (!in->isaline)

I_Error ("PTR_SlideTraverse: not a line?");

li = in->d.line;

if ( ! (li->flags & ML_TWOSIDED) )

{

if (P_PointOnLineSide (slidemo->x, slidemo->y, li))

{

454

// don’t hit the back side return true;

}

goto isblocking;

}

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

//this line doesn’t block movement return true;

//the line does block movement,

//see if it is closer than best so far isblocking:

if (in->frac < bestslidefrac)

{

secondslidefrac = bestslidefrac; secondslideline = bestslideline; bestslidefrac = in->frac; bestslideline = li;

}

}

//

//P_SlideMove

//The momx / momy move is bad, so try to slide

//along a wall.

//Find the first line hit, move flush to it,

//and slide along it

//

// This is a kludgy mess.

//

void P_SlideMove (mobj_t* mo)

{

// trace along the three leading corners

455

if (mo->momx > 0)

{

leadx = mo->x + mo->radius; trailx = mo->x - mo->radius;

}

else

{

leadx = mo->x - mo->radius; trailx = mo->x + mo->radius;

}

if (mo->momy > 0)

{

leady = mo->y + mo->radius; traily = mo->y - mo->radius;

}

else

{

leady = mo->y - mo->radius; traily = mo->y + mo->radius;

}

bestslidefrac = FRACUNIT+1;

P_PathTraverse ( leadx, leady, leadx+mo->momx, leady+mo->momy, PT_ADDLINES, PTR_SlideTraverse );

P_PathTraverse ( trailx, leady, trailx+mo->momx, leady+mo->momy, PT_ADDLINES, PTR_SlideTraverse );

P_PathTraverse ( leadx, traily, leadx+mo->momx, traily+mo->momy, PT_ADDLINES, PTR_SlideTraverse );

// move up to the wall

if (bestslidefrac == FRACUNIT+1)

{

// the move most have hit the middle, so stairstep stairstep:

if (!P_TryMove (mo, mo->x, mo->y + mo->momy)) P_TryMove (mo, mo->x + mo->momx, mo->y);

return;

}

// fudge a bit to make sure it doesn’t hit bestslidefrac -= 0x800;

if (bestslidefrac > 0)

{

newx = FixedMul (mo->momx, bestslidefrac); newy = FixedMul (mo->momy, bestslidefrac);

if (!P_TryMove (mo, mo->x+newx, mo->y+newy)) goto stairstep;

}

//Now continue along the wall.

//First calculate remainder.

bestslidefrac = FRACUNIT-(bestslidefrac+0x800);

if (bestslidefrac > FRACUNIT) bestslidefrac = FRACUNIT;

if (bestslidefrac <= 0) return;

tmxmove = FixedMul (mo->momx, bestslidefrac); tmymove = FixedMul (mo->momy, bestslidefrac);

456

mo->momx = tmxmove; mo->momy = tmymove;

if (!P_TryMove (mo, mo->x+tmxmove, mo->y+tmymove))

{

goto retry;

}

}

// slopes to top and bottom of target

//

//PTR_AimTraverse

//Sets linetaget and aimslope when a target is aimed at.

boolean

PTR_AimTraverse (intercept_t* in)

{

//Crosses a two sided line.

//A two sided line will restrict

//the possible target ranges.

P_LineOpening (li);

dist = FixedMul (attackrange, in->frac);

if (li->frontsector->floorheight != li->backsector->floorheight)

{

457

slope = FixedDiv (openbottom - shootz , dist); if (slope > bottomslope)

bottomslope = slope;

}

if (li->frontsector->ceilingheight != li->backsector->ceilingheight)

{

slope = FixedDiv (opentop - shootz , dist); if (slope < topslope)

topslope = slope;

// check angles to see if the thing can be aimed at dist = FixedMul (attackrange, in->frac);

thingtopslope = FixedDiv (th->z+th->height - shootz , dist);

thingbottomslope = FixedDiv (th->z - shootz, dist);

if (thingbottomslope > topslope)

if (thingbottomslope < bottomslope) thingbottomslope = bottomslope;

aimslope = (thingtopslope+thingbottomslope)/2; linetarget = th;

}

//

// PTR_ShootTraverse

//

boolean PTR_ShootTraverse (intercept_t* in)

{

458

if (li->special)

P_ShootSpecialLine (shootthing, li);

if ( !(li->flags & ML_TWOSIDED) ) goto hitline;

// crosses a two sided line P_LineOpening (li);

dist = FixedMul (attackrange, in->frac);

if (li->frontsector->floorheight != li->backsector->floorheight)

{

slope = FixedDiv (openbottom - shootz , dist); if (slope > aimslope)

goto hitline;

}

if (li->frontsector->ceilingheight != li->backsector->ceilingheight)

{

slope = FixedDiv (opentop - shootz , dist); if (slope < aimslope)

goto hitline;

}

//shot continues return true;

//hit line hitline:

//position a bit closer

frac = in->frac - FixedDiv (4*FRACUNIT,attackrange); x = trace.x + FixedMul (trace.dx, frac);

y = trace.y + FixedMul (trace.dy, frac);

z = shootz + FixedMul (aimslope, FixedMul(frac, attackrange));

if (li->frontsector->ceilingpic == skyflatnum)

{

// don’t shoot the sky!

if (z > li->frontsector->ceilingheight)

}

//Spawn bullet puffs. P_SpawnPuff (x,y,z);

//don’t go any farther return false;

}

459

// check angles to see if the thing can be aimed at dist = FixedMul (attackrange, in->frac);

thingtopslope = FixedDiv (th->z+th->height - shootz , dist);

//hit thing

//position a bit closer

frac = in->frac - FixedDiv (10*FRACUNIT,attackrange);

x = trace.x + FixedMul (trace.dx, frac); y = trace.y + FixedMul (trace.dy, frac);

z = shootz + FixedMul (aimslope, FixedMul(frac, attackrange));

//Spawn bullet puffs or blod spots,

//depending on target type.

if (in->d.thing->flags & MF_NOBLOOD) P_SpawnPuff (x,y,z);

else

P_SpawnBlood (x,y,z, la_damage);

if (la_damage)

P_DamageMobj (th, shootthing, shootthing, la_damage);

// don’t go any farther return false;

}

//

// P_AimLineAttack

angle >>= ANGLETOFINESHIFT; shootthing = t1;

x2 = t1->x + (distance>>FRACBITS)*finecosine[angle];

y2 = t1->y + (distance>>FRACBITS)*finesine[angle]; shootz = t1->z + (t1->height>>1) + 8*FRACUNIT;

// can’t shoot outside view angles

460