doom3-bfg/doomclassic/doom/p_map.cpp

/*
===========================================================================

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;
}