id/doom3-bfg
0
0
Fork 0
mirror of https://github.com/id-Software/DOOM-3-BFG.git synced 2024-11-22 04:12:09 +00:00
Code Issues Projects Releases Packages Wiki Activity
doom3-bfg/doomclassic/doom/p_map.cpp

1354 lines
30 KiB
C++
Raw Normal View History

Initial commit
2012-11-26 18:58:24 +00:00
/*
===========================================================================
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
Doom 3 BFG Edition Source Code 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 3 of the License, or
(at your option) any later version.
Doom 3 BFG Edition Source Code 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.
You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#include "Precompiled.h"
#include "globaldata.h"
#include <stdlib.h>
#include "m_bbox.h"
#include "m_random.h"
#include "i_system.h"
#include "doomdef.h"
#include "p_local.h"
#include "s_sound.h"
// State.
#include "doomstat.h"
#include "r_state.h"
// Data.
#include "sounds.h"
#include "Main.h"
// 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
// keep track of special ::g->lines as they are hit,
// but don't process them until the move is proven valid
//
// TELEPORT MOVE
//
//
// PIT_StompThing
//
qboolean PIT_StompThing (mobj_t* thing)
{
fixed_t blockdist;
if (!(thing->flags & MF_SHOOTABLE) )
return true;
blockdist = thing->radius + ::g->tmthing->radius;
if ( abs(thing->x - ::g->tmx) >= blockdist
|| abs(thing->y - ::g->tmy) >= blockdist )
{
// didn't hit it
return true;
}
// don't clip against self
if (thing == ::g->tmthing)
return true;
// monsters don't stomp things except on boss level
if ( !::g->tmthing->player && ::g->gamemap != 30)
return false;
P_DamageMobj (thing, ::g->tmthing, ::g->tmthing, 10000);
return true;
}
//
// P_TeleportMove
//
qboolean
P_TeleportMove
( mobj_t* thing,
fixed_t x,
fixed_t y )
{
int xl;
int xh;
int yl;
int yh;
int bx;
int by;
subsector_t* newsubsec;
// kill anything occupying the position
::g->tmthing = thing;
::g->tmflags = thing->flags;
::g->tmx = x;
::g->tmy = y;
::g->tmbbox[BOXTOP] = y + ::g->tmthing->radius;
::g->tmbbox[BOXBOTTOM] = y - ::g->tmthing->radius;
::g->tmbbox[BOXRIGHT] = x + ::g->tmthing->radius;
::g->tmbbox[BOXLEFT] = x - ::g->tmthing->radius;
newsubsec = R_PointInSubsector (x,y);
::g->ceilingline = NULL;
// The base floor/ceiling is from the subsector
// that contains the point.
// Any contacted ::g->lines the step closer together
// will adjust them.
::g->tmfloorz = ::g->tmdropoffz = newsubsec->sector->floorheight;
::g->tmceilingz = newsubsec->sector->ceilingheight;
::g->validcount++;
::g->numspechit = 0;
// stomp on any things contacted
xl = (::g->tmbbox[BOXLEFT] - ::g->bmaporgx - MAXRADIUS)>>MAPBLOCKSHIFT;
xh = (::g->tmbbox[BOXRIGHT] - ::g->bmaporgx + MAXRADIUS)>>MAPBLOCKSHIFT;
yl = (::g->tmbbox[BOXBOTTOM] - ::g->bmaporgy - MAXRADIUS)>>MAPBLOCKSHIFT;
yh = (::g->tmbbox[BOXTOP] - ::g->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 = ::g->tmfloorz;
thing->ceilingz = ::g->tmceilingz;
thing->x = x;
thing->y = y;
P_SetThingPosition (thing);
return true;
}
//
// MOVEMENT ITERATOR FUNCTIONS
//
//
// PIT_CheckLine
// Adjusts ::g->tmfloorz and ::g->tmceilingz as ::g->lines are contacted
//
qboolean PIT_CheckLine (line_t* ld)
{
if (::g->tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT]
|| ::g->tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT]
|| ::g->tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM]
|| ::g->tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP] )
return true;
if (P_BoxOnLineSide (::g->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 ::g->lines that are only 8 pixels apart
// could be crossed in either order.
if (!ld->backsector)
return false; // one sided line
if (!(::g->tmthing->flags & MF_MISSILE) )
{
if ( ld->flags & ML_BLOCKING )
return false; // explicitly blocking everything
if ( !::g->tmthing->player && ld->flags & ML_BLOCKMONSTERS )
return false; // block monsters only
}
// set ::g->openrange, ::g->opentop, ::g->openbottom
P_LineOpening (ld);
// adjust floor / ceiling heights
if (::g->opentop < ::g->tmceilingz)
{
::g->tmceilingz = ::g->opentop;
::g->ceilingline = ld;
}
if (::g->openbottom > ::g->tmfloorz)
::g->tmfloorz = ::g->openbottom;
if (::g->lowfloor < ::g->tmdropoffz)
::g->tmdropoffz = ::g->lowfloor;
// if contacted a special line, add it to the list
if (ld->special && ::g->numspechit < MAXSPECIALCROSS )
{
::g->spechit[::g->numspechit] = ld;
::g->numspechit++;
}
return true;
}
//
// PIT_CheckThing
//
qboolean PIT_CheckThing (mobj_t* thing)
{
fixed_t blockdist;
qboolean solid;
int damage;
if (!(thing->flags & (MF_SOLID|MF_SPECIAL|MF_SHOOTABLE) ))
return true;
blockdist = thing->radius + ::g->tmthing->radius;
if ( abs(thing->x - ::g->tmx) >= blockdist
|| abs(thing->y - ::g->tmy) >= blockdist )
{
// didn't hit it
return true;
}
// don't clip against self
if (thing == ::g->tmthing)
return true;
// check for skulls slamming into things
if (::g->tmthing->flags & MF_SKULLFLY)
{
damage = ((P_Random()%8)+1)*::g->tmthing->info->damage;
P_DamageMobj (thing, ::g->tmthing, ::g->tmthing, damage);
::g->tmthing->flags &= ~MF_SKULLFLY;
::g->tmthing->momx = ::g->tmthing->momy = ::g->tmthing->momz = 0;
P_SetMobjState (::g->tmthing, (statenum_t)::g->tmthing->info->spawnstate);
return false; // stop moving
}
// missiles can hit other things
if (::g->tmthing->flags & MF_MISSILE)
{
// see if it went over / under
if (::g->tmthing->z > thing->z + thing->height)
return true; // overhead
if (::g->tmthing->z+::g->tmthing->height < thing->z)
return true; // underneath
if (::g->tmthing->target && (
::g->tmthing->target->type == thing->type ||
(::g->tmthing->target->type == MT_KNIGHT && thing->type == MT_BRUISER)||
(::g->tmthing->target->type == MT_BRUISER && thing->type == MT_KNIGHT) ) )
{
// Don't hit same species as originator.
if (thing == ::g->tmthing->target)
return true;
if (thing->type != MT_PLAYER)
{
// Explode, but do no damage.
// Let ::g->players missile other ::g->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)*::g->tmthing->info->damage;
P_DamageMobj (thing, ::g->tmthing, ::g->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 (::g->tmflags&MF_PICKUP)
{
// can remove thing
P_TouchSpecialThing (thing, ::g->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
// ::g->tmdropoffz
// the lowest point contacted
// (monsters won't move to a dropoff)
// speciallines[]
// numspeciallines
//
qboolean
P_CheckPosition
( mobj_t* thing,
fixed_t x,
fixed_t y )
{
int xl;
int xh;
int yl;
int yh;
int bx;
int by;
subsector_t* newsubsec;
::g->tmthing = thing;
::g->tmflags = thing->flags;
::g->tmx = x;
::g->tmy = y;
::g->tmbbox[BOXTOP] = y + ::g->tmthing->radius;
::g->tmbbox[BOXBOTTOM] = y - ::g->tmthing->radius;
::g->tmbbox[BOXRIGHT] = x + ::g->tmthing->radius;
::g->tmbbox[BOXLEFT] = x - ::g->tmthing->radius;
newsubsec = R_PointInSubsector (x,y);
::g->ceilingline = NULL;
// The base floor / ceiling is from the subsector
// that contains the point.
// Any contacted ::g->lines the step closer together
// will adjust them.
::g->tmfloorz = ::g->tmdropoffz = newsubsec->sector->floorheight;
::g->tmceilingz = newsubsec->sector->ceilingheight;
::g->validcount++;
::g->numspechit = 0;
if ( ::g->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 = (::g->tmbbox[BOXLEFT] - ::g->bmaporgx - MAXRADIUS)>>MAPBLOCKSHIFT;
xh = (::g->tmbbox[BOXRIGHT] - ::g->bmaporgx + MAXRADIUS)>>MAPBLOCKSHIFT;
yl = (::g->tmbbox[BOXBOTTOM] - ::g->bmaporgy - MAXRADIUS)>>MAPBLOCKSHIFT;
yh = (::g->tmbbox[BOXTOP] - ::g->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 ::g->lines
xl = (::g->tmbbox[BOXLEFT] - ::g->bmaporgx)>>MAPBLOCKSHIFT;
xh = (::g->tmbbox[BOXRIGHT] - ::g->bmaporgx)>>MAPBLOCKSHIFT;
yl = (::g->tmbbox[BOXBOTTOM] - ::g->bmaporgy)>>MAPBLOCKSHIFT;
yh = (::g->tmbbox[BOXTOP] - ::g->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 ::g->lines unless MF_TELEPORT is set.
//
qboolean
P_TryMove
( mobj_t* thing,
fixed_t x,
fixed_t y )
{
fixed_t oldx;
fixed_t oldy;
int side;
int oldside;
line_t* ld;
::g->floatok = false;
if (!P_CheckPosition (thing, x, y))
return false; // solid wall or thing
if ( !(thing->flags & MF_NOCLIP) )
{
if (::g->tmceilingz - ::g->tmfloorz < thing->height)
return false; // doesn't fit
::g->floatok = true;
if ( !(thing->flags&MF_TELEPORT)
&&::g->tmceilingz - thing->z < thing->height)
return false; // mobj must lower itself to fit
if ( !(thing->flags&MF_TELEPORT)
&& ::g->tmfloorz - thing->z > 24*FRACUNIT )
return false; // too big a step up
if ( !(thing->flags&(MF_DROPOFF|MF_FLOAT))
&& ::g->tmfloorz - ::g->tmdropoffz > 24*FRACUNIT )
return false; // don't stand over a dropoff
}
// the move is ok,
// so link the thing into its new position
P_UnsetThingPosition (thing);
oldx = thing->x;
oldy = thing->y;
thing->floorz = ::g->tmfloorz;
thing->ceilingz = ::g->tmceilingz;
thing->x = x;
thing->y = y;
P_SetThingPosition (thing);
// if any special ::g->lines were hit, do the effect
if (! (thing->flags&(MF_TELEPORT|MF_NOCLIP)) )
{
while (::g->numspechit--)
{
// see if the line was crossed
ld = ::g->spechit[::g->numspechit];
side = P_PointOnLineSide (thing->x, thing->y, ld);
oldside = P_PointOnLineSide (oldx, oldy, ld);
if (side != oldside)
{
if (ld->special)
P_CrossSpecialLine (ld-::g->lines, oldside, thing);
}
}
}
return true;
}
//
// 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.
//
qboolean P_ThingHeightClip (mobj_t* thing)
{
qboolean onfloor;
onfloor = (thing->z == thing->floorz);
P_CheckPosition (thing, thing->x, thing->y);
// what about stranding a monster partially off an edge?
thing->floorz = ::g->tmfloorz;
thing->ceilingz = ::g->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.
//
void P_HitSlideLine (line_t* ld)
{
int side;
angle_t lineangle;
angle_t moveangle;
angle_t deltaangle;
fixed_t movelen;
fixed_t newlen;
if (ld->slopetype == ST_HORIZONTAL)
{
::g->tmymove = 0;
return;
}
if (ld->slopetype == ST_VERTICAL)
{
::g->tmxmove = 0;
return;
}
side = P_PointOnLineSide (::g->slidemo->x, ::g->slidemo->y, ld);
lineangle = R_PointToAngle2 (0,0, ld->dx, ld->dy);
if (side == 1)
lineangle += ANG180;
moveangle = R_PointToAngle2 (0,0, ::g->tmxmove, ::g->tmymove);
deltaangle = moveangle-lineangle;
if (deltaangle > ANG180)
deltaangle += ANG180;
// I_Error ("SlideLine: ang>ANG180");
lineangle >>= ANGLETOFINESHIFT;
deltaangle >>= ANGLETOFINESHIFT;
movelen = P_AproxDistance (::g->tmxmove, ::g->tmymove);
newlen = FixedMul (movelen, finecosine[deltaangle]);
::g->tmxmove = FixedMul (newlen, finecosine[lineangle]);
::g->tmymove = FixedMul (newlen, finesine[lineangle]);
}
//
// PTR_SlideTraverse
//
qboolean 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 (::g->slidemo->x, ::g->slidemo->y, li))
{
// don't hit the back side
return true;
}
goto isblocking;
}
// set ::g->openrange, ::g->opentop, ::g->openbottom
P_LineOpening (li);
if (::g->openrange < ::g->slidemo->height)
goto isblocking; // doesn't fit
if (::g->opentop - ::g->slidemo->z < ::g->slidemo->height)
goto isblocking; // mobj is too high
if (::g->openbottom - ::g->slidemo->z > 24*FRACUNIT )
goto isblocking; // too big a step up
// 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 < ::g->bestslidefrac)
{
::g->secondslidefrac = ::g->bestslidefrac;
::g->secondslideline = ::g->bestslideline;
::g->bestslidefrac = in->frac;
::g->bestslideline = li;
}
return false; // stop
}
//
// 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)
{
fixed_t leadx;
fixed_t leady;
fixed_t trailx;
fixed_t traily;
fixed_t newx;
fixed_t newy;
int hitcount;
::g->slidemo = mo;
hitcount = 0;
retry:
if (++hitcount == 3)
goto stairstep; // don't loop forever
// ::g->trace along the three leading corners
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;
}
::g->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 (::g->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
::g->bestslidefrac -= 0x800;
if (::g->bestslidefrac > 0)
{
newx = FixedMul (mo->momx, ::g->bestslidefrac);
newy = FixedMul (mo->momy, ::g->bestslidefrac);
if (!P_TryMove (mo, mo->x+newx, mo->y+newy))
goto stairstep;
}
// Now continue along the wall.
// First calculate remainder.
::g->bestslidefrac = FRACUNIT-(::g->bestslidefrac+0x800);
if (::g->bestslidefrac > FRACUNIT)
::g->bestslidefrac = FRACUNIT;
if (::g->bestslidefrac <= 0)
return;
::g->tmxmove = FixedMul (mo->momx, ::g->bestslidefrac);
::g->tmymove = FixedMul (mo->momy, ::g->bestslidefrac);
P_HitSlideLine (::g->bestslideline); // clip the moves
mo->momx = ::g->tmxmove;
mo->momy = ::g->tmymove;
if (!P_TryMove (mo, mo->x+::g->tmxmove, mo->y+::g->tmymove))
{
goto retry;
}
}
//
// P_LineAttack
//
// Height if not aiming up or down
// ???: use slope for monsters?
// slopes to top and bottom of target
//
// PTR_AimTraverse
// Sets linetaget and ::g->aimslope when a target is aimed at.
//
qboolean
PTR_AimTraverse (intercept_t* in)
{
line_t* li;
mobj_t* th;
fixed_t slope;
fixed_t thingtopslope;
fixed_t thingbottomslope;
fixed_t dist;
if (in->isaline)
{
li = in->d.line;
if ( !(li->flags & ML_TWOSIDED) )
return false; // stop
// Crosses a two sided line.
// A two sided line will restrict
// the possible target ranges.
P_LineOpening (li);
if (::g->openbottom >= ::g->opentop)
return false; // stop
dist = FixedMul (::g->attackrange, in->frac);
if (li->frontsector->floorheight != li->backsector->floorheight)
{
slope = FixedDiv (::g->openbottom - ::g->shootz , dist);
if (slope > ::g->bottomslope)
::g->bottomslope = slope;
}
if (li->frontsector->ceilingheight != li->backsector->ceilingheight)
{
slope = FixedDiv (::g->opentop - ::g->shootz , dist);
if (slope < ::g->topslope)
::g->topslope = slope;
}
if (::g->topslope <= ::g->bottomslope)
return false; // stop
return true; // shot continues
}
// shoot a thing
th = in->d.thing;
if (th == ::g->shootthing)
return true; // can't shoot self
if (!(th->flags&MF_SHOOTABLE))
return true; // corpse or something
// check angles to see if the thing can be aimed at
dist = FixedMul (::g->attackrange, in->frac);
thingtopslope = FixedDiv (th->z+th->height - ::g->shootz , dist);
if (thingtopslope < ::g->bottomslope)
return true; // shot over the thing
thingbottomslope = FixedDiv (th->z - ::g->shootz, dist);
if (thingbottomslope > ::g->topslope)
return true; // shot under the thing
// this thing can be hit!
if (thingtopslope > ::g->topslope)
thingtopslope = ::g->topslope;
if (thingbottomslope < ::g->bottomslope)
thingbottomslope = ::g->bottomslope;
::g->aimslope = (thingtopslope+thingbottomslope)/2;
::g->linetarget = th;
return false; // don't go any farther
}
//
// PTR_ShootTraverse
//
qboolean PTR_ShootTraverse (intercept_t* in)
{
fixed_t x;
fixed_t y;
fixed_t z;
fixed_t frac;
line_t* li;
mobj_t* th;
fixed_t slope;
fixed_t dist;
fixed_t thingtopslope;
fixed_t thingbottomslope;
if (in->isaline)
{
li = in->d.line;
if (li->special)
P_ShootSpecialLine (::g->shootthing, li);
if ( !(li->flags & ML_TWOSIDED) )
goto hitline;
// crosses a two sided line
P_LineOpening (li);
dist = FixedMul (::g->attackrange, in->frac);
if (li->frontsector->floorheight != li->backsector->floorheight)
{
slope = FixedDiv (::g->openbottom - ::g->shootz , dist);
if (slope > ::g->aimslope)
goto hitline;
}
if (li->frontsector->ceilingheight != li->backsector->ceilingheight)
{
slope = FixedDiv (::g->opentop - ::g->shootz , dist);
if (slope < ::g->aimslope)
goto hitline;
}
// shot continues
return true;
// hit line
hitline:
// position a bit closer
frac = in->frac - FixedDiv (4*FRACUNIT,::g->attackrange);
x = ::g->trace.x + FixedMul (::g->trace.dx, frac);
y = ::g->trace.y + FixedMul (::g->trace.dy, frac);
z = ::g->shootz + FixedMul (::g->aimslope, FixedMul(frac, ::g->attackrange));
if (li->frontsector->ceilingpic == ::g->skyflatnum)
{
// don't shoot the sky!
if (z > li->frontsector->ceilingheight)
return false;
// it's a sky hack wall
if (li->backsector && li->backsector->ceilingpic == ::g->skyflatnum)
return false;
}
mobj_t * sourceObject = ::g->shootthing;
if( sourceObject ) {
if( ( sourceObject->player) == &(::g->players[DoomLib::GetPlayer()]) ) {
// Fist Punch.
if( ::g->attackrange == MELEERANGE ) {
}
}
}
// Spawn bullet puffs.
P_SpawnPuff (x,y,z);
// don't go any farther
return false;
}
// shoot a thing
th = in->d.thing;
if (th == ::g->shootthing)
return true; // can't shoot self
if (!(th->flags&MF_SHOOTABLE))
return true; // corpse or something
// check angles to see if the thing can be aimed at
dist = FixedMul (::g->attackrange, in->frac);
thingtopslope = FixedDiv (th->z+th->height - ::g->shootz , dist);
if (thingtopslope < ::g->aimslope)
return true; // shot over the thing
thingbottomslope = FixedDiv (th->z - ::g->shootz, dist);
if (thingbottomslope > ::g->aimslope)
return true; // shot under the thing
// hit thing
// position a bit closer
frac = in->frac - FixedDiv (10*FRACUNIT,::g->attackrange);
x = ::g->trace.x + FixedMul (::g->trace.dx, frac);
y = ::g->trace.y + FixedMul (::g->trace.dy, frac);
z = ::g->shootz + FixedMul (::g->aimslope, FixedMul(frac, ::g->attackrange));
// check for friendly fire.
#ifdef ID_ENABLE_DOOM_CLASSIC_NETWORKING
if( th && gameLocal->GetMatchParms().GetGameType() != GAME_TYPE_PVP ) {
player_t * hitPlayer = th->player;
if( hitPlayer ) {
mobj_t * sourceObject = ::g->shootthing;
if( sourceObject ) {
player_t* sourcePlayer = sourceObject->player;
if( sourcePlayer != NULL && sourcePlayer != hitPlayer && !gameLocal->GetMatchParms().AllowFriendlyFire() ) {
return true;
}
}
}
}
#endif
mobj_t * sourceObject = ::g->shootthing;
if( sourceObject ) {
if( ( sourceObject->player) == &(::g->players[DoomLib::GetPlayer()]) ) {
// Fist Punch.
if( ::g->attackrange == MELEERANGE ) {
}
}
}
// 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, ::g->la_damage);
if (::g->la_damage)
P_DamageMobj (th, ::g->shootthing, ::g->shootthing, ::g->la_damage);
// don't go any farther
return false;
}
//
// P_AimLineAttack
//
fixed_t
P_AimLineAttack
( mobj_t* t1,
angle_t angle,
fixed_t distance )
{
fixed_t x2;
fixed_t y2;
angle >>= ANGLETOFINESHIFT;
::g->shootthing = t1;
x2 = t1->x + (distance>>FRACBITS)*finecosine[angle];
y2 = t1->y + (distance>>FRACBITS)*finesine[angle];
::g->shootz = t1->z + (t1->height>>1) + 8*FRACUNIT;
// can't shoot outside view angles
::g->topslope = 100*FRACUNIT/160;
::g->bottomslope = -100*FRACUNIT/160;
::g->attackrange = distance;
::g->linetarget = NULL;
P_PathTraverse ( t1->x, t1->y,
x2, y2,
PT_ADDLINES|PT_ADDTHINGS,
PTR_AimTraverse );
if (::g->linetarget)
return ::g->aimslope;
return 0;
}
//
// P_LineAttack
// If damage == 0, it is just a test ::g->trace
// that will leave ::g->linetarget set.
//
void
P_LineAttack
( mobj_t* t1,
angle_t angle,
fixed_t distance,
fixed_t slope,
int damage )
{
fixed_t x2;
fixed_t y2;
angle >>= ANGLETOFINESHIFT;
::g->shootthing = t1;
::g->la_damage = damage;
x2 = t1->x + (distance>>FRACBITS)*finecosine[angle];
y2 = t1->y + (distance>>FRACBITS)*finesine[angle];
::g->shootz = t1->z + (t1->height>>1) + 8*FRACUNIT;
::g->attackrange = distance;
::g->aimslope = slope;
P_PathTraverse ( t1->x, t1->y,
x2, y2,
PT_ADDLINES|PT_ADDTHINGS,
PTR_ShootTraverse );
}
//
// USE LINES
//
qboolean PTR_UseTraverse (intercept_t* in)
{
int side;
if (!in->d.line->special)
{
P_LineOpening (in->d.line);
if (::g->openrange <= 0)
{
S_StartSound (::g->usething, sfx_noway);
// can't use through a wall
return false;
}
// not a special line, but keep checking
return true ;
}
side = 0;
if (P_PointOnLineSide (::g->usething->x, ::g->usething->y, in->d.line) == 1)
side = 1;
// return false; // don't use back side
P_UseSpecialLine (::g->usething, in->d.line, side);
// can't use for than one special line in a row
return false;
}
//
// P_UseLines
// Looks for special ::g->lines in front of the player to activate.
//
void P_UseLines (player_t* player)
{
int angle;
fixed_t x1;
fixed_t y1;
fixed_t x2;
fixed_t y2;
::g->usething = player->mo;
angle = player->mo->angle >> ANGLETOFINESHIFT;
x1 = player->mo->x;
y1 = player->mo->y;
x2 = x1 + (USERANGE>>FRACBITS)*finecosine[angle];
y2 = y1 + (USERANGE>>FRACBITS)*finesine[angle];
P_PathTraverse ( x1, y1, x2, y2, PT_ADDLINES, PTR_UseTraverse );
}
//
// RADIUS ATTACK
//
//
// PIT_RadiusAttack
// "bombsource" is the creature
// that caused the explosion at "bombspot".
//
qboolean PIT_RadiusAttack (mobj_t* thing)
{
fixed_t dx;
fixed_t dy;
fixed_t dist;
if (!(thing->flags & MF_SHOOTABLE) )
return true;
// Boss spider and cyborg
// take no damage from concussion.
if (thing->type == MT_CYBORG
|| thing->type == MT_SPIDER)
return true;
dx = abs(thing->x - ::g->bombspot->x);
dy = abs(thing->y - ::g->bombspot->y);
dist = dx>dy ? dx : dy;
dist = (dist - thing->radius) >> FRACBITS;
if (dist < 0)
dist = 0;
if (dist >= ::g->bombdamage)
return true; // out of range
if ( P_CheckSight (thing, ::g->bombspot) )
{
// must be in direct path
P_DamageMobj (thing, ::g->bombspot, ::g->bombsource, ::g->bombdamage - dist);
}
return true;
}
//
// P_RadiusAttack
// Source is the creature that caused the explosion at spot.
//
void
P_RadiusAttack
( mobj_t* spot,
mobj_t* source,
int damage )
{
int x;
int y;
int xl;
int xh;
int yl;
int yh;
fixed_t dist;
dist = (damage+MAXRADIUS)<<FRACBITS;
yh = (spot->y + dist - ::g->bmaporgy)>>MAPBLOCKSHIFT;
yl = (spot->y - dist - ::g->bmaporgy)>>MAPBLOCKSHIFT;
xh = (spot->x + dist - ::g->bmaporgx)>>MAPBLOCKSHIFT;
xl = (spot->x - dist - ::g->bmaporgx)>>MAPBLOCKSHIFT;
::g->bombspot = spot;
::g->bombsource = source;
::g->bombdamage = damage;
for (y=yl ; y<=yh ; y++)
for (x=xl ; x<=xh ; x++)
P_BlockThingsIterator (x, y, PIT_RadiusAttack );
}
//
// SECTOR HEIGHT CHANGING
// After modifying a ::g->sectors floor or ceiling height,
// call this routine to adjust the positions
// of all things that touch the sector.
//
// If anything doesn't fit anymore, true will be returned.
// If crunch is true, they will take damage
// as they are being crushed.
// If Crunch is false, you should set the sector height back
// the way it was and call P_ChangeSector again
// to undo the changes.
//
//
// PIT_ChangeSector
//
qboolean PIT_ChangeSector (mobj_t* thing)
{
mobj_t* mo;
if (P_ThingHeightClip (thing))
{
// keep checking
return true;
}
// crunch bodies to giblets
if (thing->health <= 0)
{
P_SetMobjState (thing, S_GIBS);
thing->flags &= ~MF_SOLID;
thing->height = 0;
thing->radius = 0;
// keep checking
return true;
}
// crunch dropped items
if (thing->flags & MF_DROPPED)
{
P_RemoveMobj (thing);
// keep checking
return true;
}
if (! (thing->flags & MF_SHOOTABLE) )
{
// assume it is bloody gibs or something
return true;
}
::g->nofit = true;
if (::g->crushchange && !(::g->leveltime&3) )
{
P_DamageMobj(thing,NULL,NULL,10);
// spray blood in a random direction
mo = P_SpawnMobj (thing->x,
thing->y,
thing->z + thing->height/2, MT_BLOOD);
mo->momx = (P_Random() - P_Random ())<<12;
mo->momy = (P_Random() - P_Random ())<<12;
}
// keep checking (crush other things)
return true;
}
//
// P_ChangeSector
//
qboolean
P_ChangeSector
( sector_t* sector,
qboolean crunch )
{
int x;
int y;
::g->nofit = false;
::g->crushchange = crunch;
// re-check heights for all things near the moving sector
for (x=sector->blockbox[BOXLEFT] ; x<= sector->blockbox[BOXRIGHT] ; x++)
for (y=sector->blockbox[BOXBOTTOM];y<= sector->blockbox[BOXTOP] ; y++)
P_BlockThingsIterator (x, y, PIT_ChangeSector);
return ::g->nofit;
}
Reference in a new issue Copy permalink