Reformat (beautify) Raven sources and add GPL headers.

Subversion-branch: /branches/raven-branch
Subversion-revision: 1197

1 files changed, 1131 insertions, 1104 deletions

diff --git a/src/heretic/p_map.c b/src/heretic/p_map.c
index 768edda4..6e8502d4 100644
--- a/src/heretic/p_map.c
+++ b/src/heretic/p_map.c
@@ -1,3 +1,25 @@
+// Emacs style mode select   -*- C++ -*- 
+//-----------------------------------------------------------------------------
+//
+// Copyright(C) 1993-1996 Id Software, Inc.
+// Copyright(C) 1993-2008 Raven Software
+//
+// 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.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
+// 02111-1307, USA.
+//
+//-----------------------------------------------------------------------------
 // P_map.c
 
 #include "DoomDef.h"
@@ -38,27 +60,27 @@ A valid mobj_t is a mobj_t that has the proper subsector_t filled in for it's xy
 ===============================================================================
 */
 
-fixed_t		tmbbox[4];
-mobj_t		*tmthing;
-int			tmflags;
-fixed_t		tmx, tmy;
+fixed_t tmbbox[4];
+mobj_t *tmthing;
+int tmflags;
+fixed_t tmx, tmy;
 
-boolean		floatok;				// if true, move would be ok if
-									// within tmfloorz - tmceilingz
+boolean floatok;                // if true, move would be ok if
+                                                                        // within tmfloorz - tmceilingz
 
-fixed_t		tmfloorz, tmceilingz, tmdropoffz;
+fixed_t tmfloorz, tmceilingz, tmdropoffz;
 
 // keep track of the line that lowers the ceiling, so missiles don't explode
 // against sky hack walls
-line_t		*ceilingline;
+line_t *ceilingline;
 
 // keep track of special lines as they are hit, but don't process them
 // until the move is proven valid
 #define	MAXSPECIALCROSS		8
-line_t	*spechit[MAXSPECIALCROSS];
-int			 numspechit;
+line_t *spechit[MAXSPECIALCROSS];
+int numspechit;
 
-mobj_t *onmobj; //generic global onmobj...used for landing on pods/players
+mobj_t *onmobj;                 //generic global onmobj...used for landing on pods/players
 
 /*
 ===============================================================================
@@ -76,28 +98,28 @@ mobj_t *onmobj; //generic global onmobj...used for landing on pods/players
 ==================
 */
 
-boolean PIT_StompThing (mobj_t *thing)
+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 )
-		return true;		// didn't hit it
-		
-	if (thing == tmthing)
-		return true;		// don't clip against self
-
-	if(!(tmthing->flags2&MF2_TELESTOMP))
-	{ // Not allowed to stomp things
-		return(false);
-	}
-		
-	P_DamageMobj (thing, tmthing, tmthing, 10000);
-	
-	return true;
+    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)
+        return true;            // didn't hit it
+
+    if (thing == tmthing)
+        return true;            // don't clip against self
+
+    if (!(tmthing->flags2 & MF2_TELESTOMP))
+    {                           // Not allowed to stomp things
+        return (false);
+    }
+
+    P_DamageMobj(thing, tmthing, tmthing, 10000);
+
+    return true;
 }
 
 
@@ -109,65 +131,65 @@ boolean PIT_StompThing (mobj_t *thing)
 ===================
 */
 
-boolean P_TeleportMove (mobj_t *thing, fixed_t x, fixed_t y)
+boolean P_TeleportMove(mobj_t * thing, fixed_t x, fixed_t y)
 {
-	int			xl,xh,yl,yh,bx,by;
-	subsector_t		*newsubsec;
+    int xl, xh, yl, yh, bx, by;
+    subsector_t *newsubsec;
 
 //
 // kill anything occupying the position
 //
 
-	tmthing = thing;
-	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;
+    tmthing = thing;
+    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;
 
-	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;
+    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;
+    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;
 
-	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);
+//      
+    P_UnsetThingPosition(thing);
+
+    thing->floorz = tmfloorz;
+    thing->ceilingz = tmceilingz;
+    thing->x = x;
+    thing->y = y;
 
-	thing->floorz = tmfloorz;
-	thing->ceilingz = tmceilingz;	
-	thing->x = x;
-	thing->y = y;
+    P_SetThingPosition(thing);
 
-	P_SetThingPosition (thing);
-	
-	return true;
+    return true;
 }
 
 /*
@@ -187,19 +209,19 @@ boolean P_TeleportMove (mobj_t *thing, fixed_t x, fixed_t y)
 ==================
 */
 
-boolean PIT_CheckLine(line_t *ld)
+boolean PIT_CheckLine(line_t * ld)
 {
-	if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT]
-		||	tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT]
-		||	tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM]
-		||	tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
-	{
-		return(true);
-	}
-	if(P_BoxOnLineSide(tmbbox, ld) != -1)
-	{
-		return(true);
-	}
+    if (tmbbox[BOXRIGHT] <= ld->bbox[BOXLEFT]
+        || tmbbox[BOXLEFT] >= ld->bbox[BOXRIGHT]
+        || tmbbox[BOXTOP] <= ld->bbox[BOXBOTTOM]
+        || tmbbox[BOXBOTTOM] >= ld->bbox[BOXTOP])
+    {
+        return (true);
+    }
+    if (P_BoxOnLineSide(tmbbox, ld) != -1)
+    {
+        return (true);
+    }
 
 // a line has been hit
 /*
@@ -211,51 +233,51 @@ boolean PIT_CheckLine(line_t *ld)
 = 	that are only 8 pixels apart could be crossed in either order.
 */
 
-	if(!ld->backsector)
-	{ // One sided line
-		if(tmthing->flags&MF_MISSILE)
-		{ // Missiles can trigger impact specials
-			if(ld->special)
-			{
-				spechit[numspechit] = ld;
-				numspechit++;
-			}
-		}
-		return false;
-	}
-	if(!(tmthing->flags&MF_MISSILE))
-	{
-		if(ld->flags&ML_BLOCKING)
-		{ // Explicitly blocking everything
-			return(false);
-		}
-		if(!tmthing->player && ld->flags&ML_BLOCKMONSTERS
-			&& tmthing->type != MT_POD)
-		{ // Block monsters only
-			return(false);
-		}
-	}
-	P_LineOpening(ld);		// set openrange, opentop, openbottom
-	// adjust floor / ceiling heights
-	if(opentop < tmceilingz)
-	{
-		tmceilingz = opentop;
-		ceilingline = ld;
-	}
-	if(openbottom > tmfloorz)
-	{
-		tmfloorz = openbottom;
-	}
-	if(lowfloor < tmdropoffz)
-	{
-		tmdropoffz = lowfloor;
-	}
-	if(ld->special)
-	{ // Contacted a special line, add it to the list
-		spechit[numspechit] = ld;
-		numspechit++;
-	}
-	return(true);
+    if (!ld->backsector)
+    {                           // One sided line
+        if (tmthing->flags & MF_MISSILE)
+        {                       // Missiles can trigger impact specials
+            if (ld->special)
+            {
+                spechit[numspechit] = ld;
+                numspechit++;
+            }
+        }
+        return false;
+    }
+    if (!(tmthing->flags & MF_MISSILE))
+    {
+        if (ld->flags & ML_BLOCKING)
+        {                       // Explicitly blocking everything
+            return (false);
+        }
+        if (!tmthing->player && ld->flags & ML_BLOCKMONSTERS
+            && tmthing->type != MT_POD)
+        {                       // Block monsters only
+            return (false);
+        }
+    }
+    P_LineOpening(ld);          // set openrange, opentop, openbottom
+    // adjust floor / ceiling heights
+    if (opentop < tmceilingz)
+    {
+        tmceilingz = opentop;
+        ceilingline = ld;
+    }
+    if (openbottom > tmfloorz)
+    {
+        tmfloorz = openbottom;
+    }
+    if (lowfloor < tmdropoffz)
+    {
+        tmdropoffz = lowfloor;
+    }
+    if (ld->special)
+    {                           // Contacted a special line, add it to the list
+        spechit[numspechit] = ld;
+        numspechit++;
+    }
+    return (true);
 }
 
 //---------------------------------------------------------------------------
@@ -264,131 +286,131 @@ boolean PIT_CheckLine(line_t *ld)
 //
 //---------------------------------------------------------------------------
 
-boolean PIT_CheckThing(mobj_t *thing)
+boolean PIT_CheckThing(mobj_t * thing)
 {
-	fixed_t blockdist;
-	boolean solid;
-	int damage;
-
-	if(!(thing->flags&(MF_SOLID|MF_SPECIAL|MF_SHOOTABLE)))
-	{ // Can't hit thing
-		return(true);
-	}
-	blockdist = thing->radius+tmthing->radius;
-	if(abs(thing->x-tmx) >= blockdist || abs(thing->y-tmy) >= blockdist)
-	{ // Didn't hit thing
-		return(true);
-	}
-	if(thing == tmthing)
-	{ // Don't clip against self
-		return(true);
-	}
-	if(tmthing->flags2&MF2_PASSMOBJ)
-	{ // check if a mobj passed over/under another object
-		if((tmthing->type == MT_IMP || tmthing->type == MT_WIZARD)
-			&& (thing->type == MT_IMP || thing->type == MT_WIZARD))
-		{ // don't let imps/wizards fly over other imps/wizards
-			return false;
-		}
-		if(tmthing->z > thing->z+thing->height 
-			&& !(thing->flags&MF_SPECIAL))
-		{	
-			return(true);
-		}
-		else if(tmthing->z+tmthing->height < thing->z 
-			&& !(thing->flags&MF_SPECIAL))
-		{ // under thing
-			return(true);
-		}
-	}
-	// Check for skulls slamming into things
-	if(tmthing->flags&MF_SKULLFLY)
-	{
-		damage = ((P_Random()%8)+1)*tmthing->damage;
-		P_DamageMobj(thing, tmthing, tmthing, damage);
-		tmthing->flags &= ~MF_SKULLFLY;
-		tmthing->momx = tmthing->momy = tmthing->momz = 0;
-		P_SetMobjState(tmthing, tmthing->info->seestate);
-		return(false);
-	}
-	// Check for missile
-	if(tmthing->flags&MF_MISSILE)
-	{
-		// Check for passing through a ghost
-		if((thing->flags&MF_SHADOW) && (tmthing->flags2&MF2_THRUGHOST))
-		{
-			return(true);
-		}
-		// Check if it went over / under
-		if(tmthing->z > thing->z+thing->height)
-		{ // Over thing
-			return(true);
-		}
-		if(tmthing->z+tmthing->height < thing->z)
-		{ // Under thing
-			return(true);
-		}
-		if(tmthing->target && tmthing->target->type == thing->type)
-		{ // Don't hit same species as originator
-			if(thing == tmthing->target)
-			{ // Don't missile self
-				return(true);
-			}
-			if(thing->type != MT_PLAYER)
-			{ // Hit same species as originator, explode, no damage
-				return(false);
-			}
-		}
-		if(!(thing->flags&MF_SHOOTABLE))
-		{ // Didn't do any damage
-			return!(thing->flags&MF_SOLID);
-		}
-		if(tmthing->flags2&MF2_RIP)
-		{
-			if(!(thing->flags&MF_NOBLOOD))
-			{ // Ok to spawn some blood
-				P_RipperBlood(tmthing);
-			}
-			S_StartSound(tmthing, sfx_ripslop);
-			damage = ((P_Random()&3)+2)*tmthing->damage;
-			P_DamageMobj(thing, tmthing, tmthing->target, damage);
-			if(thing->flags2&MF2_PUSHABLE
-				&& !(tmthing->flags2&MF2_CANNOTPUSH))
-			{ // Push thing
-				thing->momx += tmthing->momx>>2;
-				thing->momy += tmthing->momy>>2;
-			}
-			numspechit = 0;
-			return(true);
-		}
-		// Do damage
-		damage = ((P_Random()%8)+1)*tmthing->damage;
-		if(damage)
-		{
-			if(!(thing->flags&MF_NOBLOOD) && P_Random() < 192)
-			{
-				P_BloodSplatter(tmthing->x, tmthing->y, tmthing->z, thing);
-			}
-			P_DamageMobj(thing, tmthing, tmthing->target, damage);
-		}
-		return(false);
-	}
-	if(thing->flags2&MF2_PUSHABLE && !(tmthing->flags2&MF2_CANNOTPUSH))
-	{ // Push thing
-		thing->momx += tmthing->momx>>2;
-		thing->momy += tmthing->momy>>2;
-	}
-	// Check for special thing
-	if(thing->flags&MF_SPECIAL)
-	{
-		solid = thing->flags&MF_SOLID;
-		if(tmflags&MF_PICKUP)
-		{ // Can be picked up by tmthing
-			P_TouchSpecialThing(thing, tmthing); // Can remove thing
-		}
-		return(!solid);
-	}
-	return(!(thing->flags&MF_SOLID));
+    fixed_t blockdist;
+    boolean solid;
+    int damage;
+
+    if (!(thing->flags & (MF_SOLID | MF_SPECIAL | MF_SHOOTABLE)))
+    {                           // Can't hit thing
+        return (true);
+    }
+    blockdist = thing->radius + tmthing->radius;
+    if (abs(thing->x - tmx) >= blockdist || abs(thing->y - tmy) >= blockdist)
+    {                           // Didn't hit thing
+        return (true);
+    }
+    if (thing == tmthing)
+    {                           // Don't clip against self
+        return (true);
+    }
+    if (tmthing->flags2 & MF2_PASSMOBJ)
+    {                           // check if a mobj passed over/under another object
+        if ((tmthing->type == MT_IMP || tmthing->type == MT_WIZARD)
+            && (thing->type == MT_IMP || thing->type == MT_WIZARD))
+        {                       // don't let imps/wizards fly over other imps/wizards
+            return false;
+        }
+        if (tmthing->z > thing->z + thing->height
+            && !(thing->flags & MF_SPECIAL))
+        {
+            return (true);
+        }
+        else if (tmthing->z + tmthing->height < thing->z
+                 && !(thing->flags & MF_SPECIAL))
+        {                       // under thing
+            return (true);
+        }
+    }
+    // Check for skulls slamming into things
+    if (tmthing->flags & MF_SKULLFLY)
+    {
+        damage = ((P_Random() % 8) + 1) * tmthing->damage;
+        P_DamageMobj(thing, tmthing, tmthing, damage);
+        tmthing->flags &= ~MF_SKULLFLY;
+        tmthing->momx = tmthing->momy = tmthing->momz = 0;
+        P_SetMobjState(tmthing, tmthing->info->seestate);
+        return (false);
+    }
+    // Check for missile
+    if (tmthing->flags & MF_MISSILE)
+    {
+        // Check for passing through a ghost
+        if ((thing->flags & MF_SHADOW) && (tmthing->flags2 & MF2_THRUGHOST))
+        {
+            return (true);
+        }
+        // Check if it went over / under
+        if (tmthing->z > thing->z + thing->height)
+        {                       // Over thing
+            return (true);
+        }
+        if (tmthing->z + tmthing->height < thing->z)
+        {                       // Under thing
+            return (true);
+        }
+        if (tmthing->target && tmthing->target->type == thing->type)
+        {                       // Don't hit same species as originator
+            if (thing == tmthing->target)
+            {                   // Don't missile self
+                return (true);
+            }
+            if (thing->type != MT_PLAYER)
+            {                   // Hit same species as originator, explode, no damage
+                return (false);
+            }
+        }
+        if (!(thing->flags & MF_SHOOTABLE))
+        {                       // Didn't do any damage
+            return !(thing->flags & MF_SOLID);
+        }
+        if (tmthing->flags2 & MF2_RIP)
+        {
+            if (!(thing->flags & MF_NOBLOOD))
+            {                   // Ok to spawn some blood
+                P_RipperBlood(tmthing);
+            }
+            S_StartSound(tmthing, sfx_ripslop);
+            damage = ((P_Random() & 3) + 2) * tmthing->damage;
+            P_DamageMobj(thing, tmthing, tmthing->target, damage);
+            if (thing->flags2 & MF2_PUSHABLE
+                && !(tmthing->flags2 & MF2_CANNOTPUSH))
+            {                   // Push thing
+                thing->momx += tmthing->momx >> 2;
+                thing->momy += tmthing->momy >> 2;
+            }
+            numspechit = 0;
+            return (true);
+        }
+        // Do damage
+        damage = ((P_Random() % 8) + 1) * tmthing->damage;
+        if (damage)
+        {
+            if (!(thing->flags & MF_NOBLOOD) && P_Random() < 192)
+            {
+                P_BloodSplatter(tmthing->x, tmthing->y, tmthing->z, thing);
+            }
+            P_DamageMobj(thing, tmthing, tmthing->target, damage);
+        }
+        return (false);
+    }
+    if (thing->flags2 & MF2_PUSHABLE && !(tmthing->flags2 & MF2_CANNOTPUSH))
+    {                           // Push thing
+        thing->momx += tmthing->momx >> 2;
+        thing->momy += tmthing->momy >> 2;
+    }
+    // Check for special thing
+    if (thing->flags & MF_SPECIAL)
+    {
+        solid = thing->flags & MF_SOLID;
+        if (tmflags & MF_PICKUP)
+        {                       // Can be picked up by tmthing
+            P_TouchSpecialThing(thing, tmthing);        // Can remove thing
+        }
+        return (!solid);
+    }
+    return (!(thing->flags & MF_SOLID));
 }
 
 //---------------------------------------------------------------------------
@@ -397,36 +419,36 @@ boolean PIT_CheckThing(mobj_t *thing)
 //
 //---------------------------------------------------------------------------
 
-boolean PIT_CheckOnmobjZ(mobj_t *thing)
+boolean PIT_CheckOnmobjZ(mobj_t * thing)
 {
-	fixed_t blockdist;
-
-	if(!(thing->flags&(MF_SOLID|MF_SPECIAL|MF_SHOOTABLE)))
-	{ // Can't hit thing
-		return(true);
-	}
-	blockdist = thing->radius+tmthing->radius;
-	if(abs(thing->x-tmx) >= blockdist || abs(thing->y-tmy) >= blockdist)
-	{ // Didn't hit thing
-		return(true);
-	}
-	if(thing == tmthing)
-	{ // Don't clip against self
-		return(true);
-	}
-	if(tmthing->z > thing->z+thing->height)
-	{	
-		return(true);
-	}
-	else if(tmthing->z+tmthing->height < thing->z)
-	{ // under thing
-		return(true);
-	}
-	if(thing->flags&MF_SOLID)
-	{
-		onmobj = thing;
-	}
-	return(!(thing->flags&MF_SOLID));
+    fixed_t blockdist;
+
+    if (!(thing->flags & (MF_SOLID | MF_SPECIAL | MF_SHOOTABLE)))
+    {                           // Can't hit thing
+        return (true);
+    }
+    blockdist = thing->radius + tmthing->radius;
+    if (abs(thing->x - tmx) >= blockdist || abs(thing->y - tmy) >= blockdist)
+    {                           // Didn't hit thing
+        return (true);
+    }
+    if (thing == tmthing)
+    {                           // Don't clip against self
+        return (true);
+    }
+    if (tmthing->z > thing->z + thing->height)
+    {
+        return (true);
+    }
+    else if (tmthing->z + tmthing->height < thing->z)
+    {                           // under thing
+        return (true);
+    }
+    if (thing->flags & MF_SOLID)
+    {
+        onmobj = thing;
+    }
+    return (!(thing->flags & MF_SOLID));
 }
 
 /*
@@ -446,24 +468,24 @@ boolean PIT_CheckOnmobjZ(mobj_t *thing)
 //
 //----------------------------------------------------------------------------
 
-boolean P_TestMobjLocation(mobj_t *mobj)
+boolean P_TestMobjLocation(mobj_t * mobj)
 {
-	int flags;
-
-	flags = mobj->flags;
-	mobj->flags &= ~MF_PICKUP;
-	if(P_CheckPosition(mobj, mobj->x, mobj->y))
-	{ // XY is ok, now check Z
-		mobj->flags = flags;
-		if((mobj->z < mobj->floorz)
-			|| (mobj->z+mobj->height > mobj->ceilingz))
-		{ // Bad Z
-			return(false);
-		}
-		return(true);
-	}
-	mobj->flags = flags;
-	return(false);
+    int flags;
+
+    flags = mobj->flags;
+    mobj->flags &= ~MF_PICKUP;
+    if (P_CheckPosition(mobj, mobj->x, mobj->y))
+    {                           // XY is ok, now check Z
+        mobj->flags = flags;
+        if ((mobj->z < mobj->floorz)
+            || (mobj->z + mobj->height > mobj->ceilingz))
+        {                       // Bad Z
+            return (false);
+        }
+        return (true);
+    }
+    mobj->flags = flags;
+    return (false);
 }
 
 /*
@@ -492,37 +514,37 @@ numspeciallines
 ==================
 */
 
-boolean P_CheckPosition (mobj_t *thing, fixed_t x, fixed_t y)
+boolean P_CheckPosition(mobj_t * thing, fixed_t x, fixed_t y)
 {
-	int			xl,xh,yl,yh,bx,by;
-	subsector_t		*newsubsec;
-
-	tmthing = thing;
-	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;
-	
+    int xl, xh, yl, yh, bx, by;
+    subsector_t *newsubsec;
+
+    tmthing = thing;
+    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;
+    tmfloorz = tmdropoffz = newsubsec->sector->floorheight;
+    tmceilingz = newsubsec->sector->ceilingheight;
 
-	if ( tmflags & MF_NOCLIP )
-		return true;
+    validcount++;
+    numspechit = 0;
+
+    if (tmflags & MF_NOCLIP)
+        return true;
 
 //
 // check things first, possibly picking things up
@@ -530,76 +552,76 @@ boolean P_CheckPosition (mobj_t *thing, fixed_t x, fixed_t y)
 // 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;
+    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;
+    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;
+    for (bx = xl; bx <= xh; bx++)
+        for (by = yl; by <= yh; by++)
+            if (!P_BlockLinesIterator(bx, by, PIT_CheckLine))
+                return false;
 
-	return true;
+    return true;
 }
 
 //=============================================================================
 //
 // P_CheckOnmobj(mobj_t *thing)
 //
-// 		Checks if the new Z position is legal
+//              Checks if the new Z position is legal
 //=============================================================================
 
-mobj_t *P_CheckOnmobj(mobj_t *thing)
+mobj_t *P_CheckOnmobj(mobj_t * thing)
 {
-	int			xl,xh,yl,yh,bx,by;
-	subsector_t		*newsubsec;
-	fixed_t x;
-	fixed_t y;
-	mobj_t oldmo;
-	
-	x = thing->x;
-	y = thing->y;
-	tmthing = thing;
-	tmflags = thing->flags;
-	oldmo = *thing; // save the old mobj before the fake zmovement
-	P_FakeZMovement(tmthing);
-		
-	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;
-	
+    int xl, xh, yl, yh, bx, by;
+    subsector_t *newsubsec;
+    fixed_t x;
+    fixed_t y;
+    mobj_t oldmo;
+
+    x = thing->x;
+    y = thing->y;
+    tmthing = thing;
+    tmflags = thing->flags;
+    oldmo = *thing;             // save the old mobj before the fake zmovement
+    P_FakeZMovement(tmthing);
+
+    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;
+    tmfloorz = tmdropoffz = newsubsec->sector->floorheight;
+    tmceilingz = newsubsec->sector->ceilingheight;
 
-	if ( tmflags & MF_NOCLIP )
-		return NULL;
+    validcount++;
+    numspechit = 0;
+
+    if (tmflags & MF_NOCLIP)
+        return NULL;
 
 //
 // check things first, possibly picking things up
@@ -607,99 +629,100 @@ mobj_t *P_CheckOnmobj(mobj_t *thing)
 // 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_CheckOnmobjZ))
-			{
-				*tmthing = oldmo;
-				return onmobj;
-			}
-	*tmthing = oldmo;
-	return NULL;
+    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_CheckOnmobjZ))
+            {
+                *tmthing = oldmo;
+                return onmobj;
+            }
+    *tmthing = oldmo;
+    return NULL;
 }
 
 //=============================================================================
 //
 // P_FakeZMovement
 //
-// 		Fake the zmovement so that we can check if a move is legal
+//              Fake the zmovement so that we can check if a move is legal
 //=============================================================================
 
-void P_FakeZMovement(mobj_t *mo)
+void P_FakeZMovement(mobj_t * mo)
 {
-	int dist;
-	int delta;
+    int dist;
+    int delta;
 //
 // adjust height
 //
-	mo->z += mo->momz;
-	if(mo->flags&MF_FLOAT && mo->target)
-	{	// float down towards target if too close
-		if(!(mo->flags&MF_SKULLFLY) && !(mo->flags&MF_INFLOAT))
-		{
-			dist = P_AproxDistance(mo->x-mo->target->x, mo->y-mo->target->y);
-			delta =( mo->target->z+(mo->height>>1))-mo->z;
-			if (delta < 0 && dist < -(delta*3))
-				mo->z -= FLOATSPEED;
-			else if (delta > 0 && dist < (delta*3))
-				mo->z += FLOATSPEED;			
-		}
-	}
-	if(mo->player && mo->flags2&MF2_FLY && !(mo->z <= mo->floorz)
-		&& leveltime&2)
-	{
-		mo->z += finesine[(FINEANGLES/20*leveltime>>2)&FINEMASK];
-	}
+    mo->z += mo->momz;
+    if (mo->flags & MF_FLOAT && mo->target)
+    {                           // float down towards target if too close
+        if (!(mo->flags & MF_SKULLFLY) && !(mo->flags & MF_INFLOAT))
+        {
+            dist =
+                P_AproxDistance(mo->x - mo->target->x, mo->y - mo->target->y);
+            delta = (mo->target->z + (mo->height >> 1)) - mo->z;
+            if (delta < 0 && dist < -(delta * 3))
+                mo->z -= FLOATSPEED;
+            else if (delta > 0 && dist < (delta * 3))
+                mo->z += FLOATSPEED;
+        }
+    }
+    if (mo->player && mo->flags2 & MF2_FLY && !(mo->z <= mo->floorz)
+        && leveltime & 2)
+    {
+        mo->z += finesine[(FINEANGLES / 20 * leveltime >> 2) & FINEMASK];
+    }
 
 //
 // clip movement
 //
-	if(mo->z <= mo->floorz)
-	{ // Hit the floor
-		mo->z = mo->floorz;
-		if(mo->momz < 0)
-		{
-			mo->momz = 0;
-		}
-		if(mo->flags&MF_SKULLFLY)
-		{ // The skull slammed into something
-			mo->momz = -mo->momz;
-		}
-		if(mo->info->crashstate && (mo->flags&MF_CORPSE))
-		{
-			return;
-		}
-	}
-	else if(mo->flags2&MF2_LOGRAV)
-	{
-		if(mo->momz == 0)
-			mo->momz = -(GRAVITY>>3)*2;
-		else
-			mo->momz -= GRAVITY>>3;
-	}
-	else if (! (mo->flags & MF_NOGRAVITY) )
-	{
-		if (mo->momz == 0)
-			mo->momz = -GRAVITY*2;
-		else
-			mo->momz -= GRAVITY;
-	}
-	
-	if (mo->z + mo->height > mo->ceilingz)
-	{	// hit the ceiling
-		if (mo->momz > 0)
-			mo->momz = 0;
-		mo->z = mo->ceilingz - mo->height;		
-		if (mo->flags & MF_SKULLFLY)
-		{	// the skull slammed into something
-			mo->momz = -mo->momz;
-		}
-	}
+    if (mo->z <= mo->floorz)
+    {                           // Hit the floor
+        mo->z = mo->floorz;
+        if (mo->momz < 0)
+        {
+            mo->momz = 0;
+        }
+        if (mo->flags & MF_SKULLFLY)
+        {                       // The skull slammed into something
+            mo->momz = -mo->momz;
+        }
+        if (mo->info->crashstate && (mo->flags & MF_CORPSE))
+        {
+            return;
+        }
+    }
+    else if (mo->flags2 & MF2_LOGRAV)
+    {
+        if (mo->momz == 0)
+            mo->momz = -(GRAVITY >> 3) * 2;
+        else
+            mo->momz -= GRAVITY >> 3;
+    }
+    else if (!(mo->flags & MF_NOGRAVITY))
+    {
+        if (mo->momz == 0)
+            mo->momz = -GRAVITY * 2;
+        else
+            mo->momz -= GRAVITY;
+    }
+
+    if (mo->z + mo->height > mo->ceilingz)
+    {                           // hit the ceiling
+        if (mo->momz > 0)
+            mo->momz = 0;
+        mo->z = mo->ceilingz - mo->height;
+        if (mo->flags & MF_SKULLFLY)
+        {                       // the skull slammed into something
+            mo->momz = -mo->momz;
+        }
+    }
 }
 
 //==========================================================================
@@ -708,22 +731,22 @@ void P_FakeZMovement(mobj_t *mo)
 //
 //==========================================================================
 
-void CheckMissileImpact(mobj_t *mobj)
+void CheckMissileImpact(mobj_t * mobj)
 {
-	int i;
-
-	if(!numspechit || !(mobj->flags&MF_MISSILE) || !mobj->target)
-	{
-		return;
-	}
-	if(!mobj->target->player)
-	{
-		return;
-	}
-	for(i = numspechit-1; i >= 0; i--)
-	{
-		P_ShootSpecialLine(mobj->target, spechit[i]);
-	}
+    int i;
+
+    if (!numspechit || !(mobj->flags & MF_MISSILE) || !mobj->target)
+    {
+        return;
+    }
+    if (!mobj->target->player)
+    {
+        return;
+    }
+    for (i = numspechit - 1; i >= 0; i--)
+    {
+        P_ShootSpecialLine(mobj->target, spechit[i]);
+    }
 }
 
 /*
@@ -737,106 +760,108 @@ void CheckMissileImpact(mobj_t *mobj)
 ===================
 */
 
-boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y)
+boolean P_TryMove(mobj_t * thing, fixed_t x, fixed_t y)
 {
-	fixed_t		oldx, oldy;
-	int			side, oldside;
-	line_t		*ld;
-
-	floatok = false;
-	if(!P_CheckPosition(thing, x, y))
-	{ // Solid wall or thing
-		CheckMissileImpact(thing);
-		return false;
-	}
-	if(!(thing->flags&MF_NOCLIP))
-	{
-		if(tmceilingz-tmfloorz < thing->height)
-		{ // Doesn't fit
-			CheckMissileImpact(thing);
-			return false;
-		}
-		floatok = true;
-		if(!(thing->flags&MF_TELEPORT)
-			&& tmceilingz-thing->z < thing->height
-			&& !(thing->flags2&MF2_FLY))
-		{ // mobj must lower itself to fit
-			CheckMissileImpact(thing);
-			return false;
-		}
-		if(thing->flags2&MF2_FLY)
-		{
-			if(thing->z+thing->height > tmceilingz)
-			{
-				thing->momz = -8*FRACUNIT;
-				return false;
-			}
-			else if(thing->z < tmfloorz && tmfloorz-tmdropoffz > 24*FRACUNIT)
-			{
-				thing->momz = 8*FRACUNIT;
-				return false;
-			}
-		}
-		if(!(thing->flags&MF_TELEPORT)
-			// The Minotaur floor fire (MT_MNTRFX2) can step up any amount
-			&& thing->type != MT_MNTRFX2
-			&& tmfloorz-thing->z > 24*FRACUNIT)
-		{ // Too big a step up
-			CheckMissileImpact(thing);
-			return false;
-		}
-		if((thing->flags&MF_MISSILE) && tmfloorz > thing->z)
-		{
-			CheckMissileImpact(thing);
-		}
-		if(!(thing->flags&(MF_DROPOFF|MF_FLOAT))
-			&& tmfloorz-tmdropoffz > 24*FRACUNIT)
-		{ // Can't move over a dropoff
-			return false;
-		}
-	}
+    fixed_t oldx, oldy;
+    int side, oldside;
+    line_t *ld;
+
+    floatok = false;
+    if (!P_CheckPosition(thing, x, y))
+    {                           // Solid wall or thing
+        CheckMissileImpact(thing);
+        return false;
+    }
+    if (!(thing->flags & MF_NOCLIP))
+    {
+        if (tmceilingz - tmfloorz < thing->height)
+        {                       // Doesn't fit
+            CheckMissileImpact(thing);
+            return false;
+        }
+        floatok = true;
+        if (!(thing->flags & MF_TELEPORT)
+            && tmceilingz - thing->z < thing->height
+            && !(thing->flags2 & MF2_FLY))
+        {                       // mobj must lower itself to fit
+            CheckMissileImpact(thing);
+            return false;
+        }
+        if (thing->flags2 & MF2_FLY)
+        {
+            if (thing->z + thing->height > tmceilingz)
+            {
+                thing->momz = -8 * FRACUNIT;
+                return false;
+            }
+            else if (thing->z < tmfloorz
+                     && tmfloorz - tmdropoffz > 24 * FRACUNIT)
+            {
+                thing->momz = 8 * FRACUNIT;
+                return false;
+            }
+        }
+        if (!(thing->flags & MF_TELEPORT)
+            // The Minotaur floor fire (MT_MNTRFX2) can step up any amount
+            && thing->type != MT_MNTRFX2
+            && tmfloorz - thing->z > 24 * FRACUNIT)
+        {                       // Too big a step up
+            CheckMissileImpact(thing);
+            return false;
+        }
+        if ((thing->flags & MF_MISSILE) && tmfloorz > thing->z)
+        {
+            CheckMissileImpact(thing);
+        }
+        if (!(thing->flags & (MF_DROPOFF | MF_FLOAT))
+            && tmfloorz - tmdropoffz > 24 * FRACUNIT)
+        {                       // Can't move over a dropoff
+            return false;
+        }
+    }
 
 //
 // 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(thing->flags2&MF2_FOOTCLIP && P_GetThingFloorType(thing) != FLOOR_SOLID)
-	{
-		thing->flags2 |= MF2_FEETARECLIPPED;
-	}
-	else if(thing->flags2&MF2_FEETARECLIPPED)
-	{
-		thing->flags2 &= ~MF2_FEETARECLIPPED;
-	}
-		
+    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 (thing->flags2 & MF2_FOOTCLIP
+        && P_GetThingFloorType(thing) != FLOOR_SOLID)
+    {
+        thing->flags2 |= MF2_FEETARECLIPPED;
+    }
+    else if (thing->flags2 & MF2_FEETARECLIPPED)
+    {
+        thing->flags2 &= ~MF2_FEETARECLIPPED;
+    }
+
 //
 // 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;
+    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;
 }
 
 /*
@@ -854,49 +879,49 @@ boolean P_TryMove(mobj_t *thing, fixed_t x, fixed_t y)
 ==================
 */
 
-boolean P_ThingHeightClip (mobj_t *thing)
+boolean P_ThingHeightClip(mobj_t * thing)
 {
-	boolean		onfloor;
-	
-	onfloor = (thing->z == thing->floorz);
-	
-	P_CheckPosition (thing, thing->x, thing->y);	
-	// what about stranding a monster partially off an edge?
-	
-	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;
+    boolean onfloor;
+
+    onfloor = (thing->z == thing->floorz);
+
+    P_CheckPosition(thing, thing->x, thing->y);
+    // what about stranding a monster partially off an edge?
+
+    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
 
-==============================================================================

-*/

+==============================================================================
+*/
 
-fixed_t		bestslidefrac, secondslidefrac;
-line_t		*bestslideline, *secondslideline;
-mobj_t		*slidemo;
+fixed_t bestslidefrac, secondslidefrac;
+line_t *bestslideline, *secondslideline;
+mobj_t *slidemo;
 
-fixed_t		tmxmove, tmymove;
+fixed_t tmxmove, tmymove;
 
 /*
 ==================
@@ -907,42 +932,42 @@ fixed_t		tmxmove, tmymove;
 ==================
 */
 
-void P_HitSlideLine (line_t *ld)
+void P_HitSlideLine(line_t * ld)
 {
-	int			side;
-	angle_t		lineangle, moveangle, deltaangle;
-	fixed_t		movelen, newlen;
-	
-	
-	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]);	
+    int side;
+    angle_t lineangle, moveangle, deltaangle;
+    fixed_t movelen, newlen;
+
+
+    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]);
 }
 
 /*
@@ -953,44 +978,44 @@ void P_HitSlideLine (line_t *ld)
 ==============
 */
 
-boolean		PTR_SlideTraverse (intercept_t *in)
+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))
-			return true;		// don't hit the back side
-		goto isblocking;
-	}
-
-	P_LineOpening (li);			// set openrange, opentop, openbottom
-	if (openrange < slidemo->height)
-		goto isblocking;		// doesn't fit
-		
-	if (opentop - slidemo->z < slidemo->height)
-		goto isblocking;		// mobj is too high
-
-	if (openbottom - slidemo->z > 24*FRACUNIT )
-		goto isblocking;		// too big a step up
-
-	return true;		// this line doesn't block movement
-	
+    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))
+            return true;        // don't hit the back side
+        goto isblocking;
+    }
+
+    P_LineOpening(li);          // set openrange, opentop, openbottom
+    if (openrange < slidemo->height)
+        goto isblocking;        // doesn't fit
+
+    if (opentop - slidemo->z < slidemo->height)
+        goto isblocking;        // mobj is too high
+
+    if (openbottom - slidemo->z > 24 * FRACUNIT)
+        goto isblocking;        // too big a step up
+
+    return true;                // this line doesn't block movement
+
 // 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;
-	}
-	
-	return false;	// stop
+  isblocking:
+    if (in->frac < bestslidefrac)
+    {
+        secondslidefrac = bestslidefrac;
+        secondslideline = bestslideline;
+        bestslidefrac = in->frac;
+        bestslideline = li;
+    }
+
+    return false;               // stop
 }
 
 
@@ -1007,117 +1032,117 @@ isblocking:
 ==================
 */
 
-void P_SlideMove (mobj_t *mo)
+void P_SlideMove(mobj_t * mo)
 {
-	fixed_t		leadx, leady;
-	fixed_t		trailx, traily;
-	fixed_t		newx, newy;
-	int			hitcount;
-		
-	slidemo = mo;
-	hitcount = 0;
-retry:
-	if (++hitcount == 3)
-		goto stairstep;			// don't loop forever
-			
+    fixed_t leadx, leady;
+    fixed_t trailx, traily;
+    fixed_t newx, newy;
+    int hitcount;
+
+    slidemo = mo;
+    hitcount = 0;
+  retry:
+    if (++hitcount == 3)
+        goto stairstep;         // don't loop forever
+
 //
 // 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;
-	}
-		
-	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 );
+    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;
-	}
-	
-	bestslidefrac -= 0x800;	// fudge a bit to make sure it doesn't hit
-	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;
-	}
-		
+    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;
+    }
+
+    bestslidefrac -= 0x800;     // fudge a bit to make sure it doesn't hit
+    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
 //
-	bestslidefrac = FRACUNIT-(bestslidefrac+0x800);	// remainder
-	if (bestslidefrac > FRACUNIT)
-		bestslidefrac = FRACUNIT;
-	if (bestslidefrac <= 0)
-		return;
-		
-	tmxmove = FixedMul (mo->momx, bestslidefrac);
-	tmymove = FixedMul (mo->momy, bestslidefrac);
-
-	P_HitSlideLine (bestslideline);				// clip the moves
-
-	mo->momx = tmxmove;
-	mo->momy = tmymove;
-		
-	if (!P_TryMove (mo, mo->x+tmxmove, mo->y+tmymove))
-	{
-		goto retry;
-	}
+    bestslidefrac = FRACUNIT - (bestslidefrac + 0x800); // remainder
+    if (bestslidefrac > FRACUNIT)
+        bestslidefrac = FRACUNIT;
+    if (bestslidefrac <= 0)
+        return;
+
+    tmxmove = FixedMul(mo->momx, bestslidefrac);
+    tmymove = FixedMul(mo->momy, bestslidefrac);
+
+    P_HitSlideLine(bestslideline);      // clip the moves
+
+    mo->momx = tmxmove;
+    mo->momy = tmymove;
+
+    if (!P_TryMove(mo, mo->x + tmxmove, mo->y + tmymove))
+    {
+        goto retry;
+    }
 }
 
 
 
-/*

-==============================================================================

+/*
+==============================================================================
 
 							P_LineAttack
 
-==============================================================================

-*/

+==============================================================================
+*/
 
 
-mobj_t		*linetarget;			// who got hit (or NULL)
-mobj_t		*shootthing;
-fixed_t		shootz;					// height if not aiming up or down
-									// ???: use slope for monsters?
-int			la_damage;
-fixed_t		attackrange;
+mobj_t *linetarget;             // who got hit (or NULL)
+mobj_t *shootthing;
+fixed_t shootz;                 // height if not aiming up or down
+                                                                        // ???: use slope for monsters?
+int la_damage;
+fixed_t attackrange;
 
-fixed_t		aimslope;
+fixed_t aimslope;
 
-extern	fixed_t		topslope, bottomslope;	// slopes to top and bottom of target
+extern fixed_t topslope, bottomslope;   // slopes to top and bottom of target
 
 /*
 ===============================================================================
@@ -1128,209 +1153,209 @@ extern	fixed_t		topslope, bottomslope;	// slopes to top and bottom of target
 ===============================================================================
 */
 
-boolean		PTR_AimTraverse (intercept_t *in)
+boolean PTR_AimTraverse(intercept_t * in)
 {
-	line_t		*li;
-	mobj_t		*th;
-	fixed_t		slope, thingtopslope, thingbottomslope;
-	fixed_t		dist;
-		
-	if (in->isaline)
-	{
-		li = in->d.line;
-		if ( !(li->flags & ML_TWOSIDED) )
-			return false;		// stop
+    line_t *li;
+    mobj_t *th;
+    fixed_t slope, thingtopslope, 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 (openbottom >= opentop)
-			return false;		// stop
-	
-		dist = FixedMul (attackrange, in->frac);
-
-		if (li->frontsector->floorheight != li->backsector->floorheight)
-		{
-			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;
-		}
-		
-		if (topslope <= bottomslope)
-			return false;		// stop
-			
-		return true;		// shot continues
-	}
-	
+        P_LineOpening(li);
+
+        if (openbottom >= opentop)
+            return false;       // stop
+
+        dist = FixedMul(attackrange, in->frac);
+
+        if (li->frontsector->floorheight != li->backsector->floorheight)
+        {
+            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;
+        }
+
+        if (topslope <= bottomslope)
+            return false;       // stop
+
+        return true;            // shot continues
+    }
+
 //
 // shoot a thing
 //
-	th = in->d.thing;
-	if (th == shootthing)
-		return true;		// can't shoot self
-	if (!(th->flags&MF_SHOOTABLE))
-		return true;		// corpse or something
-	if(th->type == MT_POD)
-	{ // Can't auto-aim at pods
-		return(true);
-	}
+    th = in->d.thing;
+    if (th == shootthing)
+        return true;            // can't shoot self
+    if (!(th->flags & MF_SHOOTABLE))
+        return true;            // corpse or something
+    if (th->type == MT_POD)
+    {                           // Can't auto-aim at pods
+        return (true);
+    }
 
 // check angles to see if the thing can be aimed at
 
-	dist = FixedMul (attackrange, in->frac);
-	thingtopslope = FixedDiv (th->z+th->height - shootz , dist);
-	if (thingtopslope < bottomslope)
-		return true;		// shot over the thing
-	thingbottomslope = FixedDiv (th->z - shootz, dist);
-	if (thingbottomslope > topslope)
-		return true;		// shot under the thing
+    dist = FixedMul(attackrange, in->frac);
+    thingtopslope = FixedDiv(th->z + th->height - shootz, dist);
+    if (thingtopslope < bottomslope)
+        return true;            // shot over the thing
+    thingbottomslope = FixedDiv(th->z - shootz, dist);
+    if (thingbottomslope > topslope)
+        return true;            // shot under the thing
 
 //
 // this thing can be hit!
 //
-	if (thingtopslope > topslope)
-		thingtopslope = topslope;
-	if (thingbottomslope < bottomslope)
-		thingbottomslope = bottomslope;
+    if (thingtopslope > topslope)
+        thingtopslope = topslope;
+    if (thingbottomslope < bottomslope)
+        thingbottomslope = bottomslope;
 
-	aimslope = (thingtopslope+thingbottomslope)/2;
-	linetarget = th;
+    aimslope = (thingtopslope + thingbottomslope) / 2;
+    linetarget = th;
 
-	return false;			// don't go any farther
+    return false;               // don't go any farther
 }
 
 
 /*
-==============================================================================

+==============================================================================
 =
 = PTR_ShootTraverse
 =
-==============================================================================

+==============================================================================
 */
 
-boolean		PTR_ShootTraverse (intercept_t *in)
+boolean PTR_ShootTraverse(intercept_t * in)
 {
-	fixed_t		x,y,z;
-	fixed_t		frac;
-	line_t		*li;
-	mobj_t		*th;
-	fixed_t		slope;
-	fixed_t		dist;
-	fixed_t		thingtopslope, thingbottomslope;
-	mobj_t *mo;
-
-	if (in->isaline)
-	{
-		li = in->d.line;
-		if (li->special)
-			P_ShootSpecialLine (shootthing, li);
-		if ( !(li->flags & ML_TWOSIDED) )
-			goto hitline;
+    fixed_t x, y, z;
+    fixed_t frac;
+    line_t *li;
+    mobj_t *th;
+    fixed_t slope;
+    fixed_t dist;
+    fixed_t thingtopslope, thingbottomslope;
+    mobj_t *mo;
+
+    if (in->isaline)
+    {
+        li = in->d.line;
+        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;
-		}
-			
-		return true;		// shot continues
+        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;
+        }
+
+        return true;            // shot continues
 //
 // 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)
-		{
-			if (z > li->frontsector->ceilingheight)
-				return false;		// don't shoot the sky!
-			if	(li->backsector && li->backsector->ceilingpic == skyflatnum)
-				return false;		// it's a sky hack wall
-		}
-				
-		P_SpawnPuff (x,y,z);
-		return false;			// don't go any farther
-	}
-	
+      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)
+        {
+            if (z > li->frontsector->ceilingheight)
+                return false;   // don't shoot the sky!
+            if (li->backsector && li->backsector->ceilingpic == skyflatnum)
+                return false;   // it's a sky hack wall
+        }
+
+        P_SpawnPuff(x, y, z);
+        return false;           // don't go any farther
+    }
+
 //
 // shoot a thing
 //
-	th = in->d.thing;
-	if (th == shootthing)
-		return true;		// can't shoot self
-	if (!(th->flags&MF_SHOOTABLE))
-		return true;		// corpse or something
+    th = in->d.thing;
+    if (th == shootthing)
+        return true;            // can't shoot self
+    if (!(th->flags & MF_SHOOTABLE))
+        return true;            // corpse or something
 
 //
 // check for physical attacks on a ghost
 //
-	if(th->flags&MF_SHADOW && shootthing->player->readyweapon == wp_staff)
-	{
-		return(true);
-	}
+    if (th->flags & MF_SHADOW && shootthing->player->readyweapon == wp_staff)
+    {
+        return (true);
+    }
 
 // check angles to see if the thing can be aimed at
-	dist = FixedMul (attackrange, in->frac);
-	thingtopslope = FixedDiv (th->z+th->height - shootz , dist);
-	if (thingtopslope < aimslope)
-		return true;		// shot over the thing
-	thingbottomslope = FixedDiv (th->z - shootz, dist);
-	if (thingbottomslope > aimslope)
-		return true;		// shot under the thing
+    dist = FixedMul(attackrange, in->frac);
+    thingtopslope = FixedDiv(th->z + th->height - shootz, dist);
+    if (thingtopslope < aimslope)
+        return true;            // shot over the thing
+    thingbottomslope = FixedDiv(th->z - shootz, dist);
+    if (thingbottomslope > aimslope)
+        return true;            // shot under the thing
 
 //
 // 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));
-	if(PuffType == MT_BLASTERPUFF1)
-	{ // Make blaster big puff
-		mo = P_SpawnMobj(x, y, z, MT_BLASTERPUFF2);
-		S_StartSound(mo, sfx_blshit);
-	}
-	else
-	{
-		P_SpawnPuff(x, y, z);
-	}
-	if(la_damage)
-	{
-		if(!(in->d.thing->flags&MF_NOBLOOD) && P_Random() < 192)
-		{
-			P_BloodSplatter(x, y, z, in->d.thing);
-		}
-		P_DamageMobj(th, shootthing, shootthing, la_damage);
-	}
-	return(false); // don't go any farther
+    // 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));
+    if (PuffType == MT_BLASTERPUFF1)
+    {                           // Make blaster big puff
+        mo = P_SpawnMobj(x, y, z, MT_BLASTERPUFF2);
+        S_StartSound(mo, sfx_blshit);
+    }
+    else
+    {
+        P_SpawnPuff(x, y, z);
+    }
+    if (la_damage)
+    {
+        if (!(in->d.thing->flags & MF_NOBLOOD) && P_Random() < 192)
+        {
+            P_BloodSplatter(x, y, z, in->d.thing);
+        }
+        P_DamageMobj(th, shootthing, shootthing, la_damage);
+    }
+    return (false);             // don't go any farther
 }
 
 /*
@@ -1341,28 +1366,28 @@ hitline:
 =================
 */
 
-fixed_t P_AimLineAttack (mobj_t *t1, angle_t angle, fixed_t distance)
+fixed_t P_AimLineAttack(mobj_t * t1, angle_t angle, fixed_t distance)
 {
-	fixed_t		x2, y2;
-	
-	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;
-	topslope = 100*FRACUNIT/160;	// can't shoot outside view angles
-	bottomslope = -100*FRACUNIT/160;
-	attackrange = distance;
-	linetarget = NULL;
-	
-	P_PathTraverse ( t1->x, t1->y, x2, y2
-		, PT_ADDLINES|PT_ADDTHINGS, PTR_AimTraverse );
-		
-	if (linetarget)
-		return aimslope;
-	return 0;
+    fixed_t x2, y2;
+
+    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;
+    topslope = 100 * FRACUNIT / 160;    // can't shoot outside view angles
+    bottomslope = -100 * FRACUNIT / 160;
+    attackrange = distance;
+    linetarget = NULL;
+
+    P_PathTraverse(t1->x, t1->y, x2, y2, PT_ADDLINES | PT_ADDTHINGS,
+                   PTR_AimTraverse);
+
+    if (linetarget)
+        return aimslope;
+    return 0;
 }
-

+
 
 
 /*
@@ -1375,99 +1400,100 @@ fixed_t P_AimLineAttack (mobj_t *t1, angle_t angle, fixed_t distance)
 =================
 */
 
-void P_LineAttack (mobj_t *t1, angle_t angle, fixed_t distance, fixed_t slope, int damage)
+void P_LineAttack(mobj_t * t1, angle_t angle, fixed_t distance, fixed_t slope,
+                  int damage)
 {
-	fixed_t		x2, y2;
-	
-	angle >>= ANGLETOFINESHIFT;
-	shootthing = t1;
-	la_damage = damage;
-	x2 = t1->x + (distance>>FRACBITS)*finecosine[angle];
-	y2 = t1->y + (distance>>FRACBITS)*finesine[angle];
-	shootz = t1->z + (t1->height>>1) + 8*FRACUNIT;
-	if(t1->flags2&MF2_FEETARECLIPPED)
-	{
-		shootz -= FOOTCLIPSIZE;
-	}
-	attackrange = distance;
-	aimslope = slope;
-		
-	P_PathTraverse ( t1->x, t1->y, x2, y2
-		, PT_ADDLINES|PT_ADDTHINGS, PTR_ShootTraverse );
+    fixed_t x2, y2;
+
+    angle >>= ANGLETOFINESHIFT;
+    shootthing = t1;
+    la_damage = damage;
+    x2 = t1->x + (distance >> FRACBITS) * finecosine[angle];
+    y2 = t1->y + (distance >> FRACBITS) * finesine[angle];
+    shootz = t1->z + (t1->height >> 1) + 8 * FRACUNIT;
+    if (t1->flags2 & MF2_FEETARECLIPPED)
+    {
+        shootz -= FOOTCLIPSIZE;
+    }
+    attackrange = distance;
+    aimslope = slope;
+
+    P_PathTraverse(t1->x, t1->y, x2, y2, PT_ADDLINES | PT_ADDTHINGS,
+                   PTR_ShootTraverse);
 }
-

 
 
-/*

-==============================================================================

+
+/*
+==============================================================================
 
 							USE LINES
 
-==============================================================================

-*/

-

-mobj_t		*usething;
+==============================================================================
+*/
+
+mobj_t *usething;
 
-boolean		PTR_UseTraverse (intercept_t *in)
+boolean PTR_UseTraverse(intercept_t * in)
 {
-	if (!in->d.line->special)
-	{
-		P_LineOpening (in->d.line);
-		if (openrange <= 0)
-		{
-			//S_StartSound (usething, sfx_noway);
-			return false;	// can't use through a wall
-		}
-		return true ;		// not a special line, but keep checking
-	}
-		
-	if (P_PointOnLineSide (usething->x, usething->y, in->d.line) == 1)
-		return false;		// don't use back sides
-		
-	P_UseSpecialLine (usething, in->d.line);
-
-	return false;			// can't use for than one special line in a row
+    if (!in->d.line->special)
+    {
+        P_LineOpening(in->d.line);
+        if (openrange <= 0)
+        {
+            //S_StartSound (usething, sfx_noway);
+            return false;       // can't use through a wall
+        }
+        return true;            // not a special line, but keep checking
+    }
+
+    if (P_PointOnLineSide(usething->x, usething->y, in->d.line) == 1)
+        return false;           // don't use back sides
+
+    P_UseSpecialLine(usething, in->d.line);
+
+    return false;               // can't use for than one special line in a row
 }
 
 
-/*

+/*
 ================
-=

+=
 = P_UseLines
 =
-= Looks for special lines in front of the player to activate

-================ 

-*/

-

-void P_UseLines (player_t *player)

+= Looks for special lines in front of the player to activate
+================ 
+*/
+
+void P_UseLines(player_t * player)
 {
-	int			angle;
-	fixed_t		x1, y1, x2, y2;
-	
-	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 );
+    int angle;
+    fixed_t x1, y1, x2, y2;
+
+    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
 
-==============================================================================

-*/

-

-mobj_t		*bombsource;
-mobj_t		*bombspot;
-int			bombdamage;
+==============================================================================
+*/
+
+mobj_t *bombsource;
+mobj_t *bombspot;
+int bombdamage;
 
 /*
 =================
@@ -1478,36 +1504,36 @@ int			bombdamage;
 =================
 */
 
-boolean PIT_RadiusAttack (mobj_t *thing)
+boolean PIT_RadiusAttack(mobj_t * thing)
 {
-	fixed_t dx, dy, dist;
-
-	if(!(thing->flags&MF_SHOOTABLE))
-	{
-		return true;
-	}
-	if(thing->type == MT_MINOTAUR || thing->type == MT_SORCERER1
-		|| thing->type == MT_SORCERER2)
-	{ // Episode 2 and 3 bosses take no damage from PIT_RadiusAttack
-		return(true);
-	}
-	dx = abs(thing->x - bombspot->x);
-	dy = abs(thing->y - bombspot->y);
-	dist = dx > dy ? dx : dy;
-	dist = (dist - thing->radius) >> FRACBITS;
-	if(dist < 0)
-	{
-		dist = 0;
-	}
-	if(dist >= bombdamage)
-	{ // Out of range
-		return true;
-	}
-	if(P_CheckSight(thing, bombspot))
-	{ // OK to damage, target is in direct path
-		P_DamageMobj(thing, bombspot, bombsource, bombdamage - dist);
-	}
-	return(true);
+    fixed_t dx, dy, dist;
+
+    if (!(thing->flags & MF_SHOOTABLE))
+    {
+        return true;
+    }
+    if (thing->type == MT_MINOTAUR || thing->type == MT_SORCERER1
+        || thing->type == MT_SORCERER2)
+    {                           // Episode 2 and 3 bosses take no damage from PIT_RadiusAttack
+        return (true);
+    }
+    dx = abs(thing->x - bombspot->x);
+    dy = abs(thing->y - bombspot->y);
+    dist = dx > dy ? dx : dy;
+    dist = (dist - thing->radius) >> FRACBITS;
+    if (dist < 0)
+    {
+        dist = 0;
+    }
+    if (dist >= bombdamage)
+    {                           // Out of range
+        return true;
+    }
+    if (P_CheckSight(thing, bombspot))
+    {                           // OK to damage, target is in direct path
+        P_DamageMobj(thing, bombspot, bombsource, bombdamage - dist);
+    }
+    return (true);
 }
 
 /*
@@ -1519,34 +1545,34 @@ boolean PIT_RadiusAttack (mobj_t *thing)
 =================
 */
 
-void P_RadiusAttack (mobj_t *spot, mobj_t *source, int damage)
+void P_RadiusAttack(mobj_t * spot, mobj_t * source, int damage)
 {
-	int			x,y, xl, xh, yl, yh;
-	fixed_t		dist;
-	
-	dist = (damage+MAXRADIUS)<<FRACBITS;
-	yh = (spot->y + dist - bmaporgy)>>MAPBLOCKSHIFT;
-	yl = (spot->y - dist - bmaporgy)>>MAPBLOCKSHIFT;
-	xh = (spot->x + dist - bmaporgx)>>MAPBLOCKSHIFT;
-	xl = (spot->x - dist - bmaporgx)>>MAPBLOCKSHIFT;
-	bombspot = spot;
-	if(spot->type == MT_POD && spot->target)
-	{
-		bombsource = spot->target;
-	}
-	else
-	{
-		bombsource = source;
-	}
-	bombdamage = damage;
-	for (y=yl ; y<=yh ; y++)
-		for (x=xl ; x<=xh ; x++)
-			P_BlockThingsIterator (x, y, PIT_RadiusAttack );
+    int x, y, xl, xh, yl, yh;
+    fixed_t dist;
+
+    dist = (damage + MAXRADIUS) << FRACBITS;
+    yh = (spot->y + dist - bmaporgy) >> MAPBLOCKSHIFT;
+    yl = (spot->y - dist - bmaporgy) >> MAPBLOCKSHIFT;
+    xh = (spot->x + dist - bmaporgx) >> MAPBLOCKSHIFT;
+    xl = (spot->x - dist - bmaporgx) >> MAPBLOCKSHIFT;
+    bombspot = spot;
+    if (spot->type == MT_POD && spot->target)
+    {
+        bombsource = spot->target;
+    }
+    else
+    {
+        bombsource = source;
+    }
+    bombdamage = damage;
+    for (y = yl; y <= yh; y++)
+        for (x = xl; x <= xh; x++)
+            P_BlockThingsIterator(x, y, PIT_RadiusAttack);
 }
 
 
-/*

-==============================================================================

+/*
+==============================================================================
 
 						SECTOR HEIGHT CHANGING
 
@@ -1558,11 +1584,11 @@ void P_RadiusAttack (mobj_t *spot, mobj_t *source, int damage)
 = 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
-==============================================================================

-*/

-

-boolean		crushchange;
-boolean		nofit;
+==============================================================================
+*/
+
+boolean crushchange;
+boolean nofit;
 
 /*
 ===============
@@ -1572,43 +1598,44 @@ boolean		nofit;
 ===============
 */
 
-boolean PIT_ChangeSector (mobj_t *thing)
+boolean PIT_ChangeSector(mobj_t * thing)
 {
-	mobj_t		*mo;
-	
-	if (P_ThingHeightClip (thing))
-		return true;		// keep checking
-
-	// crunch bodies to giblets
-	if (thing->health <= 0)
-	{
-		//P_SetMobjState (thing, S_GIBS);
-		thing->height = 0;
-		thing->radius = 0;
-		return true;		// keep checking
-	}
-
-	// crunch dropped items
-	if (thing->flags & MF_DROPPED)
-	{
-		P_RemoveMobj (thing);
-		return true;		// keep checking
-	}
-
-	if (! (thing->flags & MF_SHOOTABLE) )
-		return true;				// assume it is bloody gibs or something
-		
-	nofit = true;
-	if (crushchange && !(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;
-	}
-		
-	return true;		// keep checking (crush other things)	
+    mobj_t *mo;
+
+    if (P_ThingHeightClip(thing))
+        return true;            // keep checking
+
+    // crunch bodies to giblets
+    if (thing->health <= 0)
+    {
+        //P_SetMobjState (thing, S_GIBS);
+        thing->height = 0;
+        thing->radius = 0;
+        return true;            // keep checking
+    }
+
+    // crunch dropped items
+    if (thing->flags & MF_DROPPED)
+    {
+        P_RemoveMobj(thing);
+        return true;            // keep checking
+    }
+
+    if (!(thing->flags & MF_SHOOTABLE))
+        return true;            // assume it is bloody gibs or something
+
+    nofit = true;
+    if (crushchange && !(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;
+    }
+
+    return true;                // keep checking (crush other things)   
 }
 
 /*
@@ -1619,20 +1646,20 @@ boolean PIT_ChangeSector (mobj_t *thing)
 ===============
 */
 
-boolean P_ChangeSector (sector_t *sector, boolean crunch)
+boolean P_ChangeSector(sector_t * sector, boolean crunch)
 {
-	int			x,y;
-	
-	nofit = false;
-	crushchange = crunch;
-	
+    int x, y;
+
+    nofit = false;
+    crushchange = crunch;
+
 // recheck 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 nofit;
-}
+    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 nofit;
+}