Reformat (beautify) Raven sources and add GPL headers.

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

1 files changed, 1696 insertions, 1648 deletions

diff --git a/src/heretic/p_enemy.c b/src/heretic/p_enemy.c
index 196dd492..77ecff41 100644
--- a/src/heretic/p_enemy.c
+++ b/src/heretic/p_enemy.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_enemy.c
 
@@ -13,9 +35,9 @@
 
 typedef struct
 {
-	fixed_t x;
-	fixed_t y;
-	angle_t angle;
+    fixed_t x;
+    fixed_t y;
+    angle_t angle;
 } BossSpot_t;
 
 // Private Data
@@ -33,7 +55,7 @@ static BossSpot_t BossSpots[MAX_BOSS_SPOTS];
 
 void P_InitMonsters(void)
 {
-	BossSpotCount = 0;
+    BossSpotCount = 0;
 }
 
 //----------------------------------------------------------------------------
@@ -44,14 +66,14 @@ void P_InitMonsters(void)
 
 void P_AddBossSpot(fixed_t x, fixed_t y, angle_t angle)
 {
-	if(BossSpotCount == MAX_BOSS_SPOTS)
-	{
-		I_Error("Too many boss spots.");
-	}
-	BossSpots[BossSpotCount].x = x;
-	BossSpots[BossSpotCount].y = y;
-	BossSpots[BossSpotCount].angle = angle;
-	BossSpotCount++;
+    if (BossSpotCount == MAX_BOSS_SPOTS)
+    {
+        I_Error("Too many boss spots.");
+    }
+    BossSpots[BossSpotCount].x = x;
+    BossSpots[BossSpotCount].y = y;
+    BossSpots[BossSpotCount].angle = angle;
+    BossSpotCount++;
 }
 
 //----------------------------------------------------------------------------
@@ -62,52 +84,53 @@ void P_AddBossSpot(fixed_t x, fixed_t y, angle_t angle)
 
 mobj_t *soundtarget;
 
-void P_RecursiveSound(sector_t *sec, int soundblocks)
-{
-	int i;
-	line_t *check;
-	sector_t *other;
-
-	// Wake up all monsters in this sector
-	if(sec->validcount == validcount && sec->soundtraversed <= soundblocks+1)
-	{ // Already flooded
-		return;
-	}
-	sec->validcount = validcount;
-	sec->soundtraversed = soundblocks+1;
-	sec->soundtarget = soundtarget;
-	for(i = 0; i < sec->linecount; i++)
-	{
-		check = sec->lines[i];
-		if(!(check->flags&ML_TWOSIDED))
-		{
-			continue;
-		}
-		P_LineOpening(check);
-		if(openrange <= 0)
-		{ // Closed door
-			continue;
-		}
-		if(sides[check->sidenum[0]].sector == sec)
-		{
-			other = sides[check->sidenum[1]].sector;
-		}
-		else
-		{
-			other = sides[check->sidenum[0]].sector;
-		}
-		if(check->flags&ML_SOUNDBLOCK)
-		{
-			if(!soundblocks)
-			{
-				P_RecursiveSound(other, 1);
-			}
-		}
-		else
-		{
-			P_RecursiveSound(other, soundblocks);
-		}
-	}
+void P_RecursiveSound(sector_t * sec, int soundblocks)
+{
+    int i;
+    line_t *check;
+    sector_t *other;
+
+    // Wake up all monsters in this sector
+    if (sec->validcount == validcount
+        && sec->soundtraversed <= soundblocks + 1)
+    {                           // Already flooded
+        return;
+    }
+    sec->validcount = validcount;
+    sec->soundtraversed = soundblocks + 1;
+    sec->soundtarget = soundtarget;
+    for (i = 0; i < sec->linecount; i++)
+    {
+        check = sec->lines[i];
+        if (!(check->flags & ML_TWOSIDED))
+        {
+            continue;
+        }
+        P_LineOpening(check);
+        if (openrange <= 0)
+        {                       // Closed door
+            continue;
+        }
+        if (sides[check->sidenum[0]].sector == sec)
+        {
+            other = sides[check->sidenum[1]].sector;
+        }
+        else
+        {
+            other = sides[check->sidenum[0]].sector;
+        }
+        if (check->flags & ML_SOUNDBLOCK)
+        {
+            if (!soundblocks)
+            {
+                P_RecursiveSound(other, 1);
+            }
+        }
+        else
+        {
+            P_RecursiveSound(other, soundblocks);
+        }
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -119,11 +142,11 @@ void P_RecursiveSound(sector_t *sec, int soundblocks)
 //
 //----------------------------------------------------------------------------
 
-void P_NoiseAlert(mobj_t *target, mobj_t *emmiter)
+void P_NoiseAlert(mobj_t * target, mobj_t * emmiter)
 {
-	soundtarget = target;
-	validcount++;
-	P_RecursiveSound(emmiter->subsector->sector, 0);
+    soundtarget = target;
+    validcount++;
+    P_RecursiveSound(emmiter->subsector->sector, 0);
 }
 
 //----------------------------------------------------------------------------
@@ -132,34 +155,34 @@ void P_NoiseAlert(mobj_t *target, mobj_t *emmiter)
 //
 //----------------------------------------------------------------------------
 
-boolean P_CheckMeleeRange(mobj_t *actor)
+boolean P_CheckMeleeRange(mobj_t * actor)
 {
-	mobj_t *mo;
-	fixed_t dist;
+    mobj_t *mo;
+    fixed_t dist;
 
-	if(!actor->target)
-	{
-		return(false);
-	}
-	mo = actor->target;
-	dist = P_AproxDistance(mo->x-actor->x, mo->y-actor->y);
-	if(dist >= MELEERANGE)
-	{
-		return(false);
-	}
-	if(!P_CheckSight(actor, mo))
-	{
-		return(false);
-	}
-	if(mo->z > actor->z+actor->height)
-	{ // Target is higher than the attacker
-		return(false);
-	}
-	else if(actor->z > mo->z+mo->height)
-	{ // Attacker is higher
-		return(false);
-	}
-	return(true);
+    if (!actor->target)
+    {
+        return (false);
+    }
+    mo = actor->target;
+    dist = P_AproxDistance(mo->x - actor->x, mo->y - actor->y);
+    if (dist >= MELEERANGE)
+    {
+        return (false);
+    }
+    if (!P_CheckSight(actor, mo))
+    {
+        return (false);
+    }
+    if (mo->z > actor->z + actor->height)
+    {                           // Target is higher than the attacker
+        return (false);
+    }
+    else if (actor->z > mo->z + mo->height)
+    {                           // Attacker is higher
+        return (false);
+    }
+    return (true);
 }
 
 //----------------------------------------------------------------------------
@@ -168,42 +191,42 @@ boolean P_CheckMeleeRange(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-boolean P_CheckMissileRange(mobj_t *actor)
-{
-	fixed_t dist;
-
-	if(!P_CheckSight(actor, actor->target))
-	{
-		return(false);
-	}
-	if(actor->flags&MF_JUSTHIT)
-	{ // The target just hit the enemy, so fight back!
-		actor->flags &= ~MF_JUSTHIT;
-		return(true);
-	}
-	if(actor->reactiontime)
-	{ // Don't attack yet
-		return(false);
-	}
-	dist = (P_AproxDistance(actor->x-actor->target->x,
-		actor->y-actor->target->y)>>FRACBITS)-64;
-	if(!actor->info->meleestate)
-	{ // No melee attack, so fire more frequently
-		dist -= 128;
-	}
-	if(actor->type == MT_IMP)
-	{ // Imp's fly attack from far away
-		dist >>= 1;
-	}
-	if(dist > 200)
-	{
-		dist = 200;
-	}
-	if(P_Random() < dist)
-	{
-		return(false);
-	}
-	return(true);
+boolean P_CheckMissileRange(mobj_t * actor)
+{
+    fixed_t dist;
+
+    if (!P_CheckSight(actor, actor->target))
+    {
+        return (false);
+    }
+    if (actor->flags & MF_JUSTHIT)
+    {                           // The target just hit the enemy, so fight back!
+        actor->flags &= ~MF_JUSTHIT;
+        return (true);
+    }
+    if (actor->reactiontime)
+    {                           // Don't attack yet
+        return (false);
+    }
+    dist = (P_AproxDistance(actor->x - actor->target->x,
+                            actor->y - actor->target->y) >> FRACBITS) - 64;
+    if (!actor->info->meleestate)
+    {                           // No melee attack, so fire more frequently
+        dist -= 128;
+    }
+    if (actor->type == MT_IMP)
+    {                           // Imp's fly attack from far away
+        dist >>= 1;
+    }
+    if (dist > 200)
+    {
+        dist = 200;
+    }
+    if (P_Random() < dist)
+    {
+        return (false);
+    }
+    return (true);
 }
 
 /*
@@ -216,70 +239,72 @@ boolean P_CheckMissileRange(mobj_t *actor)
 ================
 */
 
-fixed_t	xspeed[8] = {FRACUNIT,47000,0,-47000,-FRACUNIT,-47000,0,47000};
-fixed_t yspeed[8] = {0,47000,FRACUNIT,47000,0,-47000,-FRACUNIT,-47000};
+fixed_t xspeed[8] =
+    { FRACUNIT, 47000, 0, -47000, -FRACUNIT, -47000, 0, 47000 };
+fixed_t yspeed[8] =
+    { 0, 47000, FRACUNIT, 47000, 0, -47000, -FRACUNIT, -47000 };
 
 #define	MAXSPECIALCROSS		8
-extern	line_t	*spechit[MAXSPECIALCROSS];
-extern	int			 numspechit;
-
-boolean P_Move(mobj_t *actor)
-{
-	fixed_t tryx, tryy;
-	line_t *ld;
-	boolean good;
-
-	if(actor->movedir == DI_NODIR)
-	{
-		return(false);
-	}
-	tryx = actor->x+actor->info->speed*xspeed[actor->movedir];
-	tryy = actor->y+actor->info->speed*yspeed[actor->movedir];
-	if(!P_TryMove(actor, tryx, tryy))
-	{ // open any specials
-		if(actor->flags&MF_FLOAT && floatok)
-		{ // must adjust height
-			if(actor->z < tmfloorz)
-			{
-				actor->z += FLOATSPEED;
-			}
-			else
-			{
-				actor->z -= FLOATSPEED;
-			}
-			actor->flags |= MF_INFLOAT;
-			return(true);
-		}
-		if(!numspechit)
-		{
-			return false;
-		}
-		actor->movedir = DI_NODIR;
-		good = false;
-		while(numspechit--)
-		{
-			ld = spechit[numspechit];
-			// if the special isn't a door that can be opened, return false
-			if(P_UseSpecialLine(actor, ld))
-			{
-				good = true;
-			}
-		}
-		return(good);
-	}
-	else
-	{
-		actor->flags &= ~MF_INFLOAT;
-	}
-	if(!(actor->flags&MF_FLOAT))
-	{
-		if(actor->z > actor->floorz)
-		{
-			P_HitFloor(actor);
-		}
-		actor->z = actor->floorz;
-	}
-	return(true);
+extern line_t *spechit[MAXSPECIALCROSS];
+extern int numspechit;
+
+boolean P_Move(mobj_t * actor)
+{
+    fixed_t tryx, tryy;
+    line_t *ld;
+    boolean good;
+
+    if (actor->movedir == DI_NODIR)
+    {
+        return (false);
+    }
+    tryx = actor->x + actor->info->speed * xspeed[actor->movedir];
+    tryy = actor->y + actor->info->speed * yspeed[actor->movedir];
+    if (!P_TryMove(actor, tryx, tryy))
+    {                           // open any specials
+        if (actor->flags & MF_FLOAT && floatok)
+        {                       // must adjust height
+            if (actor->z < tmfloorz)
+            {
+                actor->z += FLOATSPEED;
+            }
+            else
+            {
+                actor->z -= FLOATSPEED;
+            }
+            actor->flags |= MF_INFLOAT;
+            return (true);
+        }
+        if (!numspechit)
+        {
+            return false;
+        }
+        actor->movedir = DI_NODIR;
+        good = false;
+        while (numspechit--)
+        {
+            ld = spechit[numspechit];
+            // if the special isn't a door that can be opened, return false
+            if (P_UseSpecialLine(actor, ld))
+            {
+                good = true;
+            }
+        }
+        return (good);
+    }
+    else
+    {
+        actor->flags &= ~MF_INFLOAT;
+    }
+    if (!(actor->flags & MF_FLOAT))
+    {
+        if (actor->z > actor->floorz)
+        {
+            P_HitFloor(actor);
+        }
+        actor->z = actor->floorz;
+    }
+    return (true);
 }
 
 //----------------------------------------------------------------------------
@@ -293,14 +318,14 @@ boolean P_Move(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-boolean P_TryWalk(mobj_t *actor)
+boolean P_TryWalk(mobj_t * actor)
 {
-	if(!P_Move(actor))
-	{
-		return(false);
-	}
-	actor->movecount = P_Random()&15;
-	return(true);
+    if (!P_Move(actor))
+    {
+        return (false);
+    }
+    actor->movecount = P_Random() & 15;
+    return (true);
 }
 
 /*
@@ -312,115 +337,117 @@ boolean P_TryWalk(mobj_t *actor)
 */
 
 dirtype_t opposite[] =
-{DI_WEST, DI_SOUTHWEST, DI_SOUTH, DI_SOUTHEAST, DI_EAST, DI_NORTHEAST,
-DI_NORTH, DI_NORTHWEST, DI_NODIR};
-
-dirtype_t diags[] = {DI_NORTHWEST,DI_NORTHEAST,DI_SOUTHWEST,DI_SOUTHEAST};
-
-void P_NewChaseDir (mobj_t *actor)
-{
-	fixed_t		deltax,deltay;
-	dirtype_t	d[3];
-	dirtype_t	tdir, olddir, turnaround;
-
-	if (!actor->target)
-		I_Error ("P_NewChaseDir: called with no target");
-		
-	olddir = actor->movedir;
-	turnaround=opposite[olddir];
-
-	deltax = actor->target->x - actor->x;
-	deltay = actor->target->y - actor->y;
-	if (deltax>10*FRACUNIT)
-		d[1]= DI_EAST;
-	else if (deltax<-10*FRACUNIT)
-		d[1]= DI_WEST;
-	else
-		d[1]=DI_NODIR;
-	if (deltay<-10*FRACUNIT)
-		d[2]= DI_SOUTH;
-	else if (deltay>10*FRACUNIT)
-		d[2]= DI_NORTH;
-	else
-		d[2]=DI_NODIR;
+    { DI_WEST, DI_SOUTHWEST, DI_SOUTH, DI_SOUTHEAST, DI_EAST, DI_NORTHEAST,
+    DI_NORTH, DI_NORTHWEST, DI_NODIR
+};
+
+dirtype_t diags[] =
+    { DI_NORTHWEST, DI_NORTHEAST, DI_SOUTHWEST, DI_SOUTHEAST };
+
+void P_NewChaseDir(mobj_t * actor)
+{
+    fixed_t deltax, deltay;
+    dirtype_t d[3];
+    dirtype_t tdir, olddir, turnaround;
+
+    if (!actor->target)
+        I_Error("P_NewChaseDir: called with no target");
+
+    olddir = actor->movedir;
+    turnaround = opposite[olddir];
+
+    deltax = actor->target->x - actor->x;
+    deltay = actor->target->y - actor->y;
+    if (deltax > 10 * FRACUNIT)
+        d[1] = DI_EAST;
+    else if (deltax < -10 * FRACUNIT)
+        d[1] = DI_WEST;
+    else
+        d[1] = DI_NODIR;
+    if (deltay < -10 * FRACUNIT)
+        d[2] = DI_SOUTH;
+    else if (deltay > 10 * FRACUNIT)
+        d[2] = DI_NORTH;
+    else
+        d[2] = DI_NODIR;
 
 // try direct route
-	if (d[1] != DI_NODIR && d[2] != DI_NODIR)
-	{
-		actor->movedir = diags[((deltay<0)<<1)+(deltax>0)];
-		if (actor->movedir != turnaround && P_TryWalk(actor))
-			return;
-	}
+    if (d[1] != DI_NODIR && d[2] != DI_NODIR)
+    {
+        actor->movedir = diags[((deltay < 0) << 1) + (deltax > 0)];
+        if (actor->movedir != turnaround && P_TryWalk(actor))
+            return;
+    }
 
 // try other directions
-	if (P_Random() > 200 ||  abs(deltay)>abs(deltax))
-	{
-		tdir=d[1];
-		d[1]=d[2];
-		d[2]=tdir;
-	}
-
-	if (d[1]==turnaround)
-		d[1]=DI_NODIR;
-	if (d[2]==turnaround)
-		d[2]=DI_NODIR;
-	
-	if (d[1]!=DI_NODIR)
-	{
-		actor->movedir = d[1];
-		if (P_TryWalk(actor))
-			return;     /*either moved forward or attacked*/
-	}
-
-	if (d[2]!=DI_NODIR)
-	{
-		actor->movedir =d[2];
-		if (P_TryWalk(actor))
-			return;
-	}
+    if (P_Random() > 200 || abs(deltay) > abs(deltax))
+    {
+        tdir = d[1];
+        d[1] = d[2];
+        d[2] = tdir;
+    }
+
+    if (d[1] == turnaround)
+        d[1] = DI_NODIR;
+    if (d[2] == turnaround)
+        d[2] = DI_NODIR;
+
+    if (d[1] != DI_NODIR)
+    {
+        actor->movedir = d[1];
+        if (P_TryWalk(actor))
+            return;             /*either moved forward or attacked */
+    }
+
+    if (d[2] != DI_NODIR)
+    {
+        actor->movedir = d[2];
+        if (P_TryWalk(actor))
+            return;
+    }
 
 /* there is no direct path to the player, so pick another direction */
 
-	if (olddir!=DI_NODIR)
-	{
-		actor->movedir =olddir;
-		if (P_TryWalk(actor))
-			return;
-	}
-
-	if (P_Random()&1) 	/*randomly determine direction of search*/
-	{
-		for (tdir=DI_EAST ; tdir<=DI_SOUTHEAST ; tdir++)
-		{
-			if (tdir!=turnaround)
-			{
-				actor->movedir =tdir;
-				if ( P_TryWalk(actor) )
-					return;
-			}
-		}
-	}
-	else
-	{
-		for (tdir=DI_SOUTHEAST ; tdir >= DI_EAST;tdir--)
-		{
-			if (tdir!=turnaround)
-			{
-				actor->movedir =tdir;
-				if ( P_TryWalk(actor) )
-				return;
-			}
-		}
-	}
-
-	if (turnaround !=  DI_NODIR)
-	{
-		actor->movedir =turnaround;
-		if ( P_TryWalk(actor) )
-			return;
-	}
-
-	actor->movedir = DI_NODIR;		// can't move
+    if (olddir != DI_NODIR)
+    {
+        actor->movedir = olddir;
+        if (P_TryWalk(actor))
+            return;
+    }
+
+    if (P_Random() & 1)         /*randomly determine direction of search */
+    {
+        for (tdir = DI_EAST; tdir <= DI_SOUTHEAST; tdir++)
+        {
+            if (tdir != turnaround)
+            {
+                actor->movedir = tdir;
+                if (P_TryWalk(actor))
+                    return;
+            }
+        }
+    }
+    else
+    {
+        for (tdir = DI_SOUTHEAST; tdir >= DI_EAST; tdir--)
+        {
+            if (tdir != turnaround)
+            {
+                actor->movedir = tdir;
+                if (P_TryWalk(actor))
+                    return;
+            }
+        }
+    }
+
+    if (turnaround != DI_NODIR)
+    {
+        actor->movedir = turnaround;
+        if (P_TryWalk(actor))
+            return;
+    }
+
+    actor->movedir = DI_NODIR;  // can't move
 }
 
 //---------------------------------------------------------------------------
@@ -432,50 +459,50 @@ void P_NewChaseDir (mobj_t *actor)
 #define MONS_LOOK_RANGE (20*64*FRACUNIT)
 #define MONS_LOOK_LIMIT 64
 
-boolean P_LookForMonsters(mobj_t *actor)
-{
-	int count;
-	mobj_t *mo;
-	thinker_t *think;
-
-	if(!P_CheckSight(players[0].mo, actor))
-	{ // Player can't see monster
-		return(false);
-	}
-	count = 0;
-	for(think = thinkercap.next; think != &thinkercap; think = think->next)
-	{
-		if(think->function != P_MobjThinker)
-		{ // Not a mobj thinker
-			continue;
-		}
-		mo = (mobj_t *)think;
-		if(!(mo->flags&MF_COUNTKILL) || (mo == actor) || (mo->health <= 0))
-		{ // Not a valid monster
-			continue;
-		}
-		if(P_AproxDistance(actor->x-mo->x, actor->y-mo->y)
-			> MONS_LOOK_RANGE)
-		{ // Out of range
-			continue;
-		}
-		if(P_Random() < 16)
-		{ // Skip
-			continue;
-		}
-		if(count++ > MONS_LOOK_LIMIT)
-		{ // Stop searching
-			return(false);
-		}
-		if(!P_CheckSight(actor, mo))
-		{ // Out of sight
-			continue;
-		}
-		// Found a target monster
-		actor->target = mo;
-		return(true);
-	}
-	return(false);
+boolean P_LookForMonsters(mobj_t * actor)
+{
+    int count;
+    mobj_t *mo;
+    thinker_t *think;
+
+    if (!P_CheckSight(players[0].mo, actor))
+    {                           // Player can't see monster
+        return (false);
+    }
+    count = 0;
+    for (think = thinkercap.next; think != &thinkercap; think = think->next)
+    {
+        if (think->function != P_MobjThinker)
+        {                       // Not a mobj thinker
+            continue;
+        }
+        mo = (mobj_t *) think;
+        if (!(mo->flags & MF_COUNTKILL) || (mo == actor) || (mo->health <= 0))
+        {                       // Not a valid monster
+            continue;
+        }
+        if (P_AproxDistance(actor->x - mo->x, actor->y - mo->y)
+            > MONS_LOOK_RANGE)
+        {                       // Out of range
+            continue;
+        }
+        if (P_Random() < 16)
+        {                       // Skip
+            continue;
+        }
+        if (count++ > MONS_LOOK_LIMIT)
+        {                       // Stop searching
+            return (false);
+        }
+        if (!P_CheckSight(actor, mo))
+        {                       // Out of sight
+            continue;
+        }
+        // Found a target monster
+        actor->target = mo;
+        return (true);
+    }
+    return (false);
 }
 
 /*
@@ -488,67 +515,67 @@ boolean P_LookForMonsters(mobj_t *actor)
 ================
 */
 
-boolean P_LookForPlayers(mobj_t *actor, boolean allaround)
-{
-	int c;
-	int stop;
-	player_t *player;
-	sector_t *sector;
-	angle_t an;
-	fixed_t dist;
-
-	if(!netgame && players[0].health <= 0)
-	{ // Single player game and player is dead, look for monsters
-		return(P_LookForMonsters(actor));
-	}
-	sector = actor->subsector->sector;
-	c = 0;
-	stop = (actor->lastlook-1)&3;
-	for( ; ; actor->lastlook = (actor->lastlook+1)&3 )
-	{
-		if (!playeringame[actor->lastlook])
-			continue;
-			
-		if (c++ == 2 || actor->lastlook == stop)
-			return false;		// done looking
-
-		player = &players[actor->lastlook];
-		if (player->health <= 0)
-			continue;		// dead
-		if (!P_CheckSight (actor, player->mo))
-			continue;		// out of sight
-			
-		if (!allaround)
-		{
-			an = R_PointToAngle2 (actor->x, actor->y, 
-			player->mo->x, player->mo->y) - actor->angle;
-			if (an > ANG90 && an < ANG270)
-			{
-				dist = P_AproxDistance (player->mo->x - actor->x,
-					player->mo->y - actor->y);
-				// if real close, react anyway
-				if (dist > MELEERANGE)
-					continue;		// behind back
-			}
-		}
-		if(player->mo->flags&MF_SHADOW)
-		{ // Player is invisible
-			if((P_AproxDistance(player->mo->x-actor->x,
-				player->mo->y-actor->y) > 2*MELEERANGE)
-				&& P_AproxDistance(player->mo->momx, player->mo->momy)
-				< 5*FRACUNIT)
-			{ // Player is sneaking - can't detect
-				return(false);
-			}
-			if(P_Random() < 225)
-			{ // Player isn't sneaking, but still didn't detect
-				return(false);
-			}
-		}
-		actor->target = player->mo;
-		return(true);
-	}
-	return(false);
+boolean P_LookForPlayers(mobj_t * actor, boolean allaround)
+{
+    int c;
+    int stop;
+    player_t *player;
+    sector_t *sector;
+    angle_t an;
+    fixed_t dist;
+
+    if (!netgame && players[0].health <= 0)
+    {                           // Single player game and player is dead, look for monsters
+        return (P_LookForMonsters(actor));
+    }
+    sector = actor->subsector->sector;
+    c = 0;
+    stop = (actor->lastlook - 1) & 3;
+    for (;; actor->lastlook = (actor->lastlook + 1) & 3)
+    {
+        if (!playeringame[actor->lastlook])
+            continue;
+
+        if (c++ == 2 || actor->lastlook == stop)
+            return false;       // done looking
+
+        player = &players[actor->lastlook];
+        if (player->health <= 0)
+            continue;           // dead
+        if (!P_CheckSight(actor, player->mo))
+            continue;           // out of sight
+
+        if (!allaround)
+        {
+            an = R_PointToAngle2(actor->x, actor->y,
+                                 player->mo->x, player->mo->y) - actor->angle;
+            if (an > ANG90 && an < ANG270)
+            {
+                dist = P_AproxDistance(player->mo->x - actor->x,
+                                       player->mo->y - actor->y);
+                // if real close, react anyway
+                if (dist > MELEERANGE)
+                    continue;   // behind back
+            }
+        }
+        if (player->mo->flags & MF_SHADOW)
+        {                       // Player is invisible
+            if ((P_AproxDistance(player->mo->x - actor->x,
+                                 player->mo->y - actor->y) > 2 * MELEERANGE)
+                && P_AproxDistance(player->mo->momx, player->mo->momy)
+                < 5 * FRACUNIT)
+            {                   // Player is sneaking - can't detect
+                return (false);
+            }
+            if (P_Random() < 225)
+            {                   // Player isn't sneaking, but still didn't detect
+                return (false);
+            }
+        }
+        actor->target = player->mo;
+        return (true);
+    }
+    return (false);
 }
 
 /*
@@ -569,34 +596,34 @@ boolean P_LookForPlayers(mobj_t *actor, boolean allaround)
 ==============
 */
 
-void A_Look (mobj_t *actor)
+void A_Look(mobj_t * actor)
 {
-	mobj_t		*targ;
-	
-	actor->threshold = 0;		// any shot will wake up
-	targ = actor->subsector->sector->soundtarget;
-	if (targ && (targ->flags & MF_SHOOTABLE) )
-	{
-		actor->target = targ;
-		if ( actor->flags & MF_AMBUSH )
-		{
-			if (P_CheckSight (actor, actor->target))
-				goto seeyou;
-		}
-		else
-			goto seeyou;
-	}
-	
-	
-	if (!P_LookForPlayers (actor, false) )
-		return;
-		
+    mobj_t *targ;
+
+    actor->threshold = 0;       // any shot will wake up
+    targ = actor->subsector->sector->soundtarget;
+    if (targ && (targ->flags & MF_SHOOTABLE))
+    {
+        actor->target = targ;
+        if (actor->flags & MF_AMBUSH)
+        {
+            if (P_CheckSight(actor, actor->target))
+                goto seeyou;
+        }
+        else
+            goto seeyou;
+    }
+
+
+    if (!P_LookForPlayers(actor, false))
+        return;
+
 // go into chase state
-seeyou:
-	if (actor->info->seesound)
-	{
-		int		sound;
-		
+  seeyou:
+    if (actor->info->seesound)
+    {
+        int sound;
+
 /*
 		switch (actor->info->seesound)
 		{
@@ -614,17 +641,17 @@ seeyou:
 			break;
 		}
 */
-		sound = actor->info->seesound;
-		if(actor->flags2&MF2_BOSS)
-		{ // Full volume
-			S_StartSound(NULL, sound);
-		}
-		else
-		{
-			S_StartSound(actor, sound);
-		}
-	}
-	P_SetMobjState(actor, actor->info->seestate);
+        sound = actor->info->seesound;
+        if (actor->flags2 & MF2_BOSS)
+        {                       // Full volume
+            S_StartSound(NULL, sound);
+        }
+        else
+        {
+            S_StartSound(actor, sound);
+        }
+    }
+    P_SetMobjState(actor, actor->info->seestate);
 }
 
 
@@ -638,129 +665,129 @@ seeyou:
 ==============
 */
 
-void A_Chase(mobj_t *actor)
+void A_Chase(mobj_t * actor)
 {
-	int delta;
+    int delta;
 
-	if(actor->reactiontime)
-	{
-		actor->reactiontime--;
-	}
+    if (actor->reactiontime)
+    {
+        actor->reactiontime--;
+    }
 
-	// Modify target threshold
-	if(actor->threshold)
-	{
-		actor->threshold--;
-	}
+    // Modify target threshold
+    if (actor->threshold)
+    {
+        actor->threshold--;
+    }
 
-	if(gameskill == sk_nightmare)
-	{ // Monsters move faster in nightmare mode
-		actor->tics -= actor->tics/2;
-		if(actor->tics < 3)
-		{
-			actor->tics = 3;
-		}
-	}
+    if (gameskill == sk_nightmare)
+    {                           // Monsters move faster in nightmare mode
+        actor->tics -= actor->tics / 2;
+        if (actor->tics < 3)
+        {
+            actor->tics = 3;
+        }
+    }
 
 //
 // turn towards movement direction if not there yet
 //
-	if(actor->movedir < 8)
-	{
-		actor->angle &= (7<<29);
-		delta = actor->angle-(actor->movedir << 29);
-		if(delta > 0)
-		{
-			actor->angle -= ANG90/2;
-		}
-		else if(delta < 0)
-		{
-			actor->angle += ANG90/2;
-		}
-	}
+    if (actor->movedir < 8)
+    {
+        actor->angle &= (7 << 29);
+        delta = actor->angle - (actor->movedir << 29);
+        if (delta > 0)
+        {
+            actor->angle -= ANG90 / 2;
+        }
+        else if (delta < 0)
+        {
+            actor->angle += ANG90 / 2;
+        }
+    }
+
+    if (!actor->target || !(actor->target->flags & MF_SHOOTABLE))
+    {                           // look for a new target
+        if (P_LookForPlayers(actor, true))
+        {                       // got a new target
+            return;
+        }
+        P_SetMobjState(actor, actor->info->spawnstate);
+        return;
+    }
 
-	if(!actor->target || !(actor->target->flags&MF_SHOOTABLE))
-	{ // look for a new target
-		if(P_LookForPlayers(actor, true))
-		{ // got a new target
-			return;
-		}
-		P_SetMobjState(actor, actor->info->spawnstate);
-		return;
-	}
-	
 //
 // don't attack twice in a row
 //
-	if(actor->flags & MF_JUSTATTACKED)
-	{
-		actor->flags &= ~MF_JUSTATTACKED;
-		if (gameskill != sk_nightmare)
-			P_NewChaseDir (actor);
-		return;
-	}
-	
+    if (actor->flags & MF_JUSTATTACKED)
+    {
+        actor->flags &= ~MF_JUSTATTACKED;
+        if (gameskill != sk_nightmare)
+            P_NewChaseDir(actor);
+        return;
+    }
+
 //
 // check for melee attack
-//	
-	if (actor->info->meleestate && P_CheckMeleeRange (actor))
-	{
-		if (actor->info->attacksound)
-			S_StartSound (actor, actor->info->attacksound);
-		P_SetMobjState (actor, actor->info->meleestate);
-		return;
-	}
+//      
+    if (actor->info->meleestate && P_CheckMeleeRange(actor))
+    {
+        if (actor->info->attacksound)
+            S_StartSound(actor, actor->info->attacksound);
+        P_SetMobjState(actor, actor->info->meleestate);
+        return;
+    }
 
 //
 // check for missile attack
 //
-	if (actor->info->missilestate)
-	{
-		if (gameskill < sk_nightmare && actor->movecount)
-			goto nomissile;
-		if (!P_CheckMissileRange (actor))
-			goto nomissile;
-		P_SetMobjState (actor, actor->info->missilestate);
-		actor->flags |= MF_JUSTATTACKED;
-		return;
-	}
-nomissile:
+    if (actor->info->missilestate)
+    {
+        if (gameskill < sk_nightmare && actor->movecount)
+            goto nomissile;
+        if (!P_CheckMissileRange(actor))
+            goto nomissile;
+        P_SetMobjState(actor, actor->info->missilestate);
+        actor->flags |= MF_JUSTATTACKED;
+        return;
+    }
+  nomissile:
 
 //
 // possibly choose another target
 //
-	if (netgame && !actor->threshold && !P_CheckSight (actor, actor->target) )
-	{
-		if (P_LookForPlayers(actor,true))
-			return;		// got a new target
-	}
-	
+    if (netgame && !actor->threshold && !P_CheckSight(actor, actor->target))
+    {
+        if (P_LookForPlayers(actor, true))
+            return;             // got a new target
+    }
+
 //
 // chase towards player
 //
-	if (--actor->movecount<0 || !P_Move (actor))
-	{
-		P_NewChaseDir (actor);
-	}
+    if (--actor->movecount < 0 || !P_Move(actor))
+    {
+        P_NewChaseDir(actor);
+    }
 
 //
 // make active sound
 //
-	if(actor->info->activesound && P_Random() < 3)
-	{
-		if(actor->type == MT_WIZARD && P_Random() < 128)
-		{
-			S_StartSound(actor, actor->info->seesound);
-		}
-		else if(actor->type == MT_SORCERER2)
-		{
-			S_StartSound(NULL, actor->info->activesound);
-		}
-		else
-		{
-			S_StartSound(actor, actor->info->activesound);
-		}
-	}
+    if (actor->info->activesound && P_Random() < 3)
+    {
+        if (actor->type == MT_WIZARD && P_Random() < 128)
+        {
+            S_StartSound(actor, actor->info->seesound);
+        }
+        else if (actor->type == MT_SORCERER2)
+        {
+            S_StartSound(NULL, actor->info->activesound);
+        }
+        else
+        {
+            S_StartSound(actor, actor->info->activesound);
+        }
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -769,19 +796,19 @@ nomissile:
 //
 //----------------------------------------------------------------------------
 
-void A_FaceTarget(mobj_t *actor)
+void A_FaceTarget(mobj_t * actor)
 {
-	if(!actor->target)
-	{
-		return;
-	}
-	actor->flags &= ~MF_AMBUSH;
-	actor->angle = R_PointToAngle2(actor->x, actor->y, actor->target->x,
-		actor->target->y);
-	if(actor->target->flags&MF_SHADOW)
-	{ // Target is a ghost
-		actor->angle += (P_Random()-P_Random())<<21;
-	}
+    if (!actor->target)
+    {
+        return;
+    }
+    actor->flags &= ~MF_AMBUSH;
+    actor->angle = R_PointToAngle2(actor->x, actor->y, actor->target->x,
+                                   actor->target->y);
+    if (actor->target->flags & MF_SHADOW)
+    {                           // Target is a ghost
+        actor->angle += (P_Random() - P_Random()) << 21;
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -790,12 +817,12 @@ void A_FaceTarget(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Pain(mobj_t *actor)
+void A_Pain(mobj_t * actor)
 {
-	if(actor->info->painsound)
-	{
-		S_StartSound(actor, actor->info->painsound);
-	}
+    if (actor->info->painsound)
+    {
+        S_StartSound(actor, actor->info->painsound);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -804,15 +831,16 @@ void A_Pain(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_DripBlood(mobj_t *actor)
+void A_DripBlood(mobj_t * actor)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	mo = P_SpawnMobj(actor->x+((P_Random()-P_Random())<<11),
-		actor->y+((P_Random()-P_Random())<<11), actor->z, MT_BLOOD);
-	mo->momx = (P_Random()-P_Random())<<10;
-	mo->momy = (P_Random()-P_Random())<<10;
-	mo->flags2 |= MF2_LOGRAV;
+    mo = P_SpawnMobj(actor->x + ((P_Random() - P_Random()) << 11),
+                     actor->y + ((P_Random() - P_Random()) << 11), actor->z,
+                     MT_BLOOD);
+    mo->momx = (P_Random() - P_Random()) << 10;
+    mo->momy = (P_Random() - P_Random()) << 10;
+    mo->flags2 |= MF2_LOGRAV;
 }
 
 //----------------------------------------------------------------------------
@@ -821,27 +849,27 @@ void A_DripBlood(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_KnightAttack(mobj_t *actor)
+void A_KnightAttack(mobj_t * actor)
 {
-	if(!actor->target)
-	{
-		return;
-	}
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(3));
-		S_StartSound(actor, sfx_kgtat2);
-		return;
-	}
-	// Throw axe
-	S_StartSound(actor, actor->info->attacksound);
-	if(actor->type == MT_KNIGHTGHOST || P_Random() < 40)
-	{ // Red axe
-		P_SpawnMissile(actor, actor->target, MT_REDAXE);
-		return;
-	}
-	// Green axe
-	P_SpawnMissile(actor, actor->target, MT_KNIGHTAXE);
+    if (!actor->target)
+    {
+        return;
+    }
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(3));
+        S_StartSound(actor, sfx_kgtat2);
+        return;
+    }
+    // Throw axe
+    S_StartSound(actor, actor->info->attacksound);
+    if (actor->type == MT_KNIGHTGHOST || P_Random() < 40)
+    {                           // Red axe
+        P_SpawnMissile(actor, actor->target, MT_REDAXE);
+        return;
+    }
+    // Green axe
+    P_SpawnMissile(actor, actor->target, MT_KNIGHTAXE);
 }
 
 //----------------------------------------------------------------------------
@@ -850,22 +878,22 @@ void A_KnightAttack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ImpExplode(mobj_t *actor)
+void A_ImpExplode(mobj_t * actor)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_IMPCHUNK1);
-	mo->momx = (P_Random() - P_Random ())<<10;
-	mo->momy = (P_Random() - P_Random ())<<10;
-	mo->momz = 9*FRACUNIT;
-	mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_IMPCHUNK2);
-	mo->momx = (P_Random() - P_Random ())<<10;
-	mo->momy = (P_Random() - P_Random ())<<10;
-	mo->momz = 9*FRACUNIT;
-	if(actor->special1 == 666)
-	{ // Extreme death crash
-		P_SetMobjState(actor, S_IMP_XCRASH1);
-	}
+    mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_IMPCHUNK1);
+    mo->momx = (P_Random() - P_Random()) << 10;
+    mo->momy = (P_Random() - P_Random()) << 10;
+    mo->momz = 9 * FRACUNIT;
+    mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_IMPCHUNK2);
+    mo->momx = (P_Random() - P_Random()) << 10;
+    mo->momy = (P_Random() - P_Random()) << 10;
+    mo->momz = 9 * FRACUNIT;
+    if (actor->special1 == 666)
+    {                           // Extreme death crash
+        P_SetMobjState(actor, S_IMP_XCRASH1);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -874,14 +902,14 @@ void A_ImpExplode(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_BeastPuff(mobj_t *actor)
+void A_BeastPuff(mobj_t * actor)
 {
-	if(P_Random() > 64)
-	{
-		P_SpawnMobj(actor->x+((P_Random()-P_Random())<<10),
-			actor->y+((P_Random()-P_Random())<<10),
-			actor->z+((P_Random()-P_Random())<<10), MT_PUFFY);
-	}
+    if (P_Random() > 64)
+    {
+        P_SpawnMobj(actor->x + ((P_Random() - P_Random()) << 10),
+                    actor->y + ((P_Random() - P_Random()) << 10),
+                    actor->z + ((P_Random() - P_Random()) << 10), MT_PUFFY);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -890,17 +918,17 @@ void A_BeastPuff(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ImpMeAttack(mobj_t *actor)
+void A_ImpMeAttack(mobj_t * actor)
 {
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(actor, actor->info->attacksound);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, 5+(P_Random()&7));
-	}
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(actor, actor->info->attacksound);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, 5 + (P_Random() & 7));
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -909,31 +937,31 @@ void A_ImpMeAttack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ImpMsAttack(mobj_t *actor)
+void A_ImpMsAttack(mobj_t * actor)
 {
-	mobj_t *dest;
-	angle_t an;
-	int dist;
+    mobj_t *dest;
+    angle_t an;
+    int dist;
 
-	if(!actor->target || P_Random() > 64)
-	{
-		P_SetMobjState(actor, actor->info->seestate);
-		return;
-	}
-	dest = actor->target;
-	actor->flags |= MF_SKULLFLY;
-	S_StartSound(actor, actor->info->attacksound);
-	A_FaceTarget(actor);
-	an = actor->angle >> ANGLETOFINESHIFT;
-	actor->momx = FixedMul(12*FRACUNIT, finecosine[an]);
-	actor->momy = FixedMul(12*FRACUNIT, finesine[an]);
-	dist = P_AproxDistance(dest->x-actor->x, dest->y-actor->y);
-	dist = dist/(12*FRACUNIT);
-	if(dist < 1)
-	{
-		dist = 1;
-	}
-	actor->momz = (dest->z+(dest->height>>1)-actor->z)/dist;
+    if (!actor->target || P_Random() > 64)
+    {
+        P_SetMobjState(actor, actor->info->seestate);
+        return;
+    }
+    dest = actor->target;
+    actor->flags |= MF_SKULLFLY;
+    S_StartSound(actor, actor->info->attacksound);
+    A_FaceTarget(actor);
+    an = actor->angle >> ANGLETOFINESHIFT;
+    actor->momx = FixedMul(12 * FRACUNIT, finecosine[an]);
+    actor->momy = FixedMul(12 * FRACUNIT, finesine[an]);
+    dist = P_AproxDistance(dest->x - actor->x, dest->y - actor->y);
+    dist = dist / (12 * FRACUNIT);
+    if (dist < 1)
+    {
+        dist = 1;
+    }
+    actor->momz = (dest->z + (dest->height >> 1) - actor->z) / dist;
 }
 
 //----------------------------------------------------------------------------
@@ -944,19 +972,19 @@ void A_ImpMsAttack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ImpMsAttack2(mobj_t *actor)
+void A_ImpMsAttack2(mobj_t * actor)
 {
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(actor, actor->info->attacksound);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, 5+(P_Random()&7));
-		return;
-	}
-	P_SpawnMissile(actor, actor->target, MT_IMPBALL);
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(actor, actor->info->attacksound);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, 5 + (P_Random() & 7));
+        return;
+    }
+    P_SpawnMissile(actor, actor->target, MT_IMPBALL);
 }
 
 //----------------------------------------------------------------------------
@@ -965,14 +993,14 @@ void A_ImpMsAttack2(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ImpDeath(mobj_t *actor)
+void A_ImpDeath(mobj_t * actor)
 {
-	actor->flags &= ~MF_SOLID;
-	actor->flags2 |= MF2_FOOTCLIP;
-	if(actor->z <= actor->floorz)
-	{
-		P_SetMobjState(actor, S_IMP_CRASH1);
-	}
+    actor->flags &= ~MF_SOLID;
+    actor->flags2 |= MF2_FOOTCLIP;
+    if (actor->z <= actor->floorz)
+    {
+        P_SetMobjState(actor, S_IMP_CRASH1);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -981,12 +1009,12 @@ void A_ImpDeath(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ImpXDeath1(mobj_t *actor)
+void A_ImpXDeath1(mobj_t * actor)
 {
-	actor->flags &= ~MF_SOLID;
-	actor->flags |= MF_NOGRAVITY;
-	actor->flags2 |= MF2_FOOTCLIP;
-	actor->special1 = 666; // Flag the crash routine
+    actor->flags &= ~MF_SOLID;
+    actor->flags |= MF_NOGRAVITY;
+    actor->flags2 |= MF2_FOOTCLIP;
+    actor->special1 = 666;      // Flag the crash routine
 }
 
 //----------------------------------------------------------------------------
@@ -995,13 +1023,13 @@ void A_ImpXDeath1(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ImpXDeath2(mobj_t *actor)
+void A_ImpXDeath2(mobj_t * actor)
 {
-	actor->flags &= ~MF_NOGRAVITY;
-	if(actor->z <= actor->floorz)
-	{
-		P_SetMobjState(actor, S_IMP_CRASH1);
-	}
+    actor->flags &= ~MF_NOGRAVITY;
+    if (actor->z <= actor->floorz)
+    {
+        P_SetMobjState(actor, S_IMP_CRASH1);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1012,45 +1040,45 @@ void A_ImpXDeath2(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-boolean P_UpdateChicken(mobj_t *actor, int tics)
-{
-	mobj_t *fog;
-	fixed_t x;
-	fixed_t y;
-	fixed_t z;
-	mobjtype_t moType;
-	mobj_t *mo;
-	mobj_t oldChicken;
-
-	actor->special1 -= tics;
-	if(actor->special1 > 0)
-	{
-		return(false);
-	}
-	moType = actor->special2;
-	x = actor->x;
-	y = actor->y;
-	z = actor->z;
-	oldChicken = *actor;
-	P_SetMobjState(actor, S_FREETARGMOBJ);
-	mo = P_SpawnMobj(x, y, z, moType);
-	if(P_TestMobjLocation(mo) == false)
-	{ // Didn't fit
-		P_RemoveMobj(mo);
-		mo = P_SpawnMobj(x, y, z, MT_CHICKEN);
-		mo->angle = oldChicken.angle;
-		mo->flags = oldChicken.flags;
-		mo->health = oldChicken.health;
-		mo->target = oldChicken.target;
-		mo->special1 = 5*35; // Next try in 5 seconds
-		mo->special2 = moType;
-		return(false);
-	}
-	mo->angle = oldChicken.angle;
-	mo->target = oldChicken.target;
-	fog = P_SpawnMobj(x, y, z+TELEFOGHEIGHT, MT_TFOG);
-	S_StartSound(fog, sfx_telept);
-	return(true);
+boolean P_UpdateChicken(mobj_t * actor, int tics)
+{
+    mobj_t *fog;
+    fixed_t x;
+    fixed_t y;
+    fixed_t z;
+    mobjtype_t moType;
+    mobj_t *mo;
+    mobj_t oldChicken;
+
+    actor->special1 -= tics;
+    if (actor->special1 > 0)
+    {
+        return (false);
+    }
+    moType = actor->special2;
+    x = actor->x;
+    y = actor->y;
+    z = actor->z;
+    oldChicken = *actor;
+    P_SetMobjState(actor, S_FREETARGMOBJ);
+    mo = P_SpawnMobj(x, y, z, moType);
+    if (P_TestMobjLocation(mo) == false)
+    {                           // Didn't fit
+        P_RemoveMobj(mo);
+        mo = P_SpawnMobj(x, y, z, MT_CHICKEN);
+        mo->angle = oldChicken.angle;
+        mo->flags = oldChicken.flags;
+        mo->health = oldChicken.health;
+        mo->target = oldChicken.target;
+        mo->special1 = 5 * 35;  // Next try in 5 seconds
+        mo->special2 = moType;
+        return (false);
+    }
+    mo->angle = oldChicken.angle;
+    mo->target = oldChicken.target;
+    fog = P_SpawnMobj(x, y, z + TELEFOGHEIGHT, MT_TFOG);
+    S_StartSound(fog, sfx_telept);
+    return (true);
 }
 
 //----------------------------------------------------------------------------
@@ -1059,20 +1087,20 @@ boolean P_UpdateChicken(mobj_t *actor, int tics)
 //
 //----------------------------------------------------------------------------
 
-void A_ChicAttack(mobj_t *actor)
+void A_ChicAttack(mobj_t * actor)
 {
-	if(P_UpdateChicken(actor, 18))
-	{
-		return;
-	}
-	if(!actor->target)
-	{
-		return;
-	}
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, 1+(P_Random()&1));
-	}
+    if (P_UpdateChicken(actor, 18))
+    {
+        return;
+    }
+    if (!actor->target)
+    {
+        return;
+    }
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, 1 + (P_Random() & 1));
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1081,13 +1109,13 @@ void A_ChicAttack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ChicLook(mobj_t *actor)
+void A_ChicLook(mobj_t * actor)
 {
-	if(P_UpdateChicken(actor, 10))
-	{
-		return;
-	}
-	A_Look(actor);
+    if (P_UpdateChicken(actor, 10))
+    {
+        return;
+    }
+    A_Look(actor);
 }
 
 //----------------------------------------------------------------------------
@@ -1096,13 +1124,13 @@ void A_ChicLook(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ChicChase(mobj_t *actor)
+void A_ChicChase(mobj_t * actor)
 {
-	if(P_UpdateChicken(actor, 3))
-	{
-		return;
-	}
-	A_Chase(actor);
+    if (P_UpdateChicken(actor, 3))
+    {
+        return;
+    }
+    A_Chase(actor);
 }
 
 //----------------------------------------------------------------------------
@@ -1111,13 +1139,13 @@ void A_ChicChase(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ChicPain(mobj_t *actor)
+void A_ChicPain(mobj_t * actor)
 {
-	if(P_UpdateChicken(actor, 10))
-	{
-		return;
-	}
-	S_StartSound(actor, actor->info->painsound);
+    if (P_UpdateChicken(actor, 10))
+    {
+        return;
+    }
+    S_StartSound(actor, actor->info->painsound);
 }
 
 //----------------------------------------------------------------------------
@@ -1126,30 +1154,30 @@ void A_ChicPain(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Feathers(mobj_t *actor)
+void A_Feathers(mobj_t * actor)
 {
-	int i;
-	int count;
-	mobj_t *mo;
+    int i;
+    int count;
+    mobj_t *mo;
 
-	if(actor->health > 0)
-	{ // Pain
-		count = P_Random() < 32 ? 2 : 1;
-	}
-	else
-	{ // Death
-		count = 5+(P_Random()&3);
-	}
-	for(i = 0; i < count; i++)
-	{
-		mo = P_SpawnMobj(actor->x, actor->y, actor->z+20*FRACUNIT,
-			MT_FEATHER);
-		mo->target = actor;
-		mo->momx = (P_Random()-P_Random())<<8;
-		mo->momy = (P_Random()-P_Random())<<8;
-		mo->momz = FRACUNIT+(P_Random()<<9);
-		P_SetMobjState(mo, S_FEATHER1+(P_Random()&7));
-	}
+    if (actor->health > 0)
+    {                           // Pain
+        count = P_Random() < 32 ? 2 : 1;
+    }
+    else
+    {                           // Death
+        count = 5 + (P_Random() & 3);
+    }
+    for (i = 0; i < count; i++)
+    {
+        mo = P_SpawnMobj(actor->x, actor->y, actor->z + 20 * FRACUNIT,
+                         MT_FEATHER);
+        mo->target = actor;
+        mo->momx = (P_Random() - P_Random()) << 8;
+        mo->momy = (P_Random() - P_Random()) << 8;
+        mo->momz = FRACUNIT + (P_Random() << 9);
+        P_SetMobjState(mo, S_FEATHER1 + (P_Random() & 7));
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1158,20 +1186,20 @@ void A_Feathers(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_MummyAttack(mobj_t *actor)
+void A_MummyAttack(mobj_t * actor)
 {
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(actor, actor->info->attacksound);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(2));
-		S_StartSound(actor, sfx_mumat2);
-		return;
-	}
-	S_StartSound(actor, sfx_mumat1);
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(actor, actor->info->attacksound);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(2));
+        S_StartSound(actor, sfx_mumat2);
+        return;
+    }
+    S_StartSound(actor, sfx_mumat1);
 }
 
 //----------------------------------------------------------------------------
@@ -1182,26 +1210,26 @@ void A_MummyAttack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_MummyAttack2(mobj_t *actor)
+void A_MummyAttack2(mobj_t * actor)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	if(!actor->target)
-	{
-		return;
-	}
-	//S_StartSound(actor, actor->info->attacksound);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(2));
-		return;
-	}
-	mo = P_SpawnMissile(actor, actor->target, MT_MUMMYFX1);
-	//mo = P_SpawnMissile(actor, actor->target, MT_EGGFX);
-	if(mo != NULL)
-	{
-		mo->special1 = (int)actor->target;
-	}
+    if (!actor->target)
+    {
+        return;
+    }
+    //S_StartSound(actor, actor->info->attacksound);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(2));
+        return;
+    }
+    mo = P_SpawnMissile(actor, actor->target, MT_MUMMYFX1);
+    //mo = P_SpawnMissile(actor, actor->target, MT_EGGFX);
+    if (mo != NULL)
+    {
+        mo->special1 = (int) actor->target;
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1210,9 +1238,9 @@ void A_MummyAttack2(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_MummyFX1Seek(mobj_t *actor)
+void A_MummyFX1Seek(mobj_t * actor)
 {
-	P_SeekerMissile(actor, ANGLE_1*10, ANGLE_1*20);
+    P_SeekerMissile(actor, ANGLE_1 * 10, ANGLE_1 * 20);
 }
 
 //----------------------------------------------------------------------------
@@ -1221,12 +1249,13 @@ void A_MummyFX1Seek(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_MummySoul(mobj_t *mummy)
+void A_MummySoul(mobj_t * mummy)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	mo = P_SpawnMobj(mummy->x, mummy->y, mummy->z+10*FRACUNIT, MT_MUMMYSOUL);
-	mo->momz = FRACUNIT;
+    mo = P_SpawnMobj(mummy->x, mummy->y, mummy->z + 10 * FRACUNIT,
+                     MT_MUMMYSOUL);
+    mo->momz = FRACUNIT;
 }
 
 //----------------------------------------------------------------------------
@@ -1235,10 +1264,10 @@ void A_MummySoul(mobj_t *mummy)
 //
 //----------------------------------------------------------------------------
 
-void A_Sor1Pain(mobj_t *actor)
+void A_Sor1Pain(mobj_t * actor)
 {
-	actor->special1 = 20; // Number of steps to walk fast
-	A_Pain(actor);
+    actor->special1 = 20;       // Number of steps to walk fast
+    A_Pain(actor);
 }
 
 //----------------------------------------------------------------------------
@@ -1247,14 +1276,14 @@ void A_Sor1Pain(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Sor1Chase(mobj_t *actor)
+void A_Sor1Chase(mobj_t * actor)
 {
-	if(actor->special1)
-	{
-		actor->special1--;
-		actor->tics -= 3;
-	}
-	A_Chase(actor);
+    if (actor->special1)
+    {
+        actor->special1--;
+        actor->tics -= 3;
+    }
+    A_Chase(actor);
 }
 
 //----------------------------------------------------------------------------
@@ -1265,49 +1294,49 @@ void A_Sor1Chase(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Srcr1Attack(mobj_t *actor)
-{
-	mobj_t *mo;
-	fixed_t momz;
-	angle_t angle;
-
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(actor, actor->info->attacksound);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(8));
-		return;
-	}
-	if(actor->health > (actor->info->spawnhealth/3)*2)
-	{ // Spit one fireball
-		P_SpawnMissile(actor, actor->target, MT_SRCRFX1);
-	}
-	else
-	{ // Spit three fireballs
-		mo = P_SpawnMissile(actor, actor->target, MT_SRCRFX1);
-		if(mo)
-		{
-			momz = mo->momz;
-			angle = mo->angle;
-			P_SpawnMissileAngle(actor, MT_SRCRFX1, angle-ANGLE_1*3, momz);
-			P_SpawnMissileAngle(actor, MT_SRCRFX1, angle+ANGLE_1*3, momz);
-		}
-		if(actor->health < actor->info->spawnhealth/3)
-		{ // Maybe attack again
-			if(actor->special1)
-			{ // Just attacked, so don't attack again
-				actor->special1 = 0;
-			}
-			else
-			{ // Set state to attack again
-				actor->special1 = 1;
-				P_SetMobjState(actor, S_SRCR1_ATK4);
-			}
-		}
-	}
+void A_Srcr1Attack(mobj_t * actor)
+{
+    mobj_t *mo;
+    fixed_t momz;
+    angle_t angle;
+
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(actor, actor->info->attacksound);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(8));
+        return;
+    }
+    if (actor->health > (actor->info->spawnhealth / 3) * 2)
+    {                           // Spit one fireball
+        P_SpawnMissile(actor, actor->target, MT_SRCRFX1);
+    }
+    else
+    {                           // Spit three fireballs
+        mo = P_SpawnMissile(actor, actor->target, MT_SRCRFX1);
+        if (mo)
+        {
+            momz = mo->momz;
+            angle = mo->angle;
+            P_SpawnMissileAngle(actor, MT_SRCRFX1, angle - ANGLE_1 * 3, momz);
+            P_SpawnMissileAngle(actor, MT_SRCRFX1, angle + ANGLE_1 * 3, momz);
+        }
+        if (actor->health < actor->info->spawnhealth / 3)
+        {                       // Maybe attack again
+            if (actor->special1)
+            {                   // Just attacked, so don't attack again
+                actor->special1 = 0;
+            }
+            else
+            {                   // Set state to attack again
+                actor->special1 = 1;
+                P_SetMobjState(actor, S_SRCR1_ATK4);
+            }
+        }
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1316,15 +1345,15 @@ void A_Srcr1Attack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_SorcererRise(mobj_t *actor)
+void A_SorcererRise(mobj_t * actor)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	actor->flags &= ~MF_SOLID;
-	mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_SORCERER2);
-	P_SetMobjState(mo, S_SOR2_RISE1);
-	mo->angle = actor->angle;
-	mo->target = actor->target;
+    actor->flags &= ~MF_SOLID;
+    mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_SORCERER2);
+    P_SetMobjState(mo, S_SOR2_RISE1);
+    mo->angle = actor->angle;
+    mo->target = actor->target;
 }
 
 //----------------------------------------------------------------------------
@@ -1333,40 +1362,41 @@ void A_SorcererRise(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void P_DSparilTeleport(mobj_t *actor)
-{
-	int i;
-	fixed_t x;
-	fixed_t y;
-	fixed_t prevX;
-	fixed_t prevY;
-	fixed_t prevZ;
-	mobj_t *mo;
-
-	if(!BossSpotCount)
-	{ // No spots
-		return;
-	}
-	i = P_Random();
-	do
-	{
-		i++;
-		x = BossSpots[i%BossSpotCount].x;
-		y = BossSpots[i%BossSpotCount].y;
-	} while(P_AproxDistance(actor->x-x, actor->y-y) < 128*FRACUNIT);
-	prevX = actor->x;
-	prevY = actor->y;
-	prevZ = actor->z;
-	if(P_TeleportMove(actor, x, y))
-	{
-		mo = P_SpawnMobj(prevX, prevY, prevZ, MT_SOR2TELEFADE);
-		S_StartSound(mo, sfx_telept);
-		P_SetMobjState(actor, S_SOR2_TELE1);
-		S_StartSound(actor, sfx_telept);
-		actor->z = actor->floorz;
-		actor->angle = BossSpots[i%BossSpotCount].angle;
-		actor->momx = actor->momy = actor->momz = 0;
-	}
+void P_DSparilTeleport(mobj_t * actor)
+{
+    int i;
+    fixed_t x;
+    fixed_t y;
+    fixed_t prevX;
+    fixed_t prevY;
+    fixed_t prevZ;
+    mobj_t *mo;
+
+    if (!BossSpotCount)
+    {                           // No spots
+        return;
+    }
+    i = P_Random();
+    do
+    {
+        i++;
+        x = BossSpots[i % BossSpotCount].x;
+        y = BossSpots[i % BossSpotCount].y;
+    }
+    while (P_AproxDistance(actor->x - x, actor->y - y) < 128 * FRACUNIT);
+    prevX = actor->x;
+    prevY = actor->y;
+    prevZ = actor->z;
+    if (P_TeleportMove(actor, x, y))
+    {
+        mo = P_SpawnMobj(prevX, prevY, prevZ, MT_SOR2TELEFADE);
+        S_StartSound(mo, sfx_telept);
+        P_SetMobjState(actor, S_SOR2_TELE1);
+        S_StartSound(actor, sfx_telept);
+        actor->z = actor->floorz;
+        actor->angle = BossSpots[i % BossSpotCount].angle;
+        actor->momx = actor->momy = actor->momz = 0;
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1375,21 +1405,20 @@ void P_DSparilTeleport(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Srcr2Decide(mobj_t *actor)
+void A_Srcr2Decide(mobj_t * actor)
 {
-	static int chance[] =
-	{
-		192, 120, 120, 120, 64, 64, 32, 16, 0
-	};
+    static int chance[] = {
+        192, 120, 120, 120, 64, 64, 32, 16, 0
+    };
 
-	if(!BossSpotCount)
-	{ // No spots
-		return;
-	}
-	if(P_Random() < chance[actor->health/(actor->info->spawnhealth/8)])
-	{
-		P_DSparilTeleport(actor);
-	}
+    if (!BossSpotCount)
+    {                           // No spots
+        return;
+    }
+    if (P_Random() < chance[actor->health / (actor->info->spawnhealth / 8)])
+    {
+        P_DSparilTeleport(actor);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1398,32 +1427,32 @@ void A_Srcr2Decide(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Srcr2Attack(mobj_t *actor)
+void A_Srcr2Attack(mobj_t * actor)
 {
-	int chance;
+    int chance;
 
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(NULL, actor->info->attacksound);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(20));
-		return;
-	}
-	chance = actor->health < actor->info->spawnhealth/2 ? 96 : 48;
-	if(P_Random() < chance)
-	{ // Wizard spawners
-		P_SpawnMissileAngle(actor, MT_SOR2FX2,
-			actor->angle-ANG45, FRACUNIT/2);
-		P_SpawnMissileAngle(actor, MT_SOR2FX2,
-			actor->angle+ANG45, FRACUNIT/2);
-	}
-	else
-	{ // Blue bolt
-		P_SpawnMissile(actor, actor->target, MT_SOR2FX1);
-	}
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(NULL, actor->info->attacksound);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(20));
+        return;
+    }
+    chance = actor->health < actor->info->spawnhealth / 2 ? 96 : 48;
+    if (P_Random() < chance)
+    {                           // Wizard spawners
+        P_SpawnMissileAngle(actor, MT_SOR2FX2,
+                            actor->angle - ANG45, FRACUNIT / 2);
+        P_SpawnMissileAngle(actor, MT_SOR2FX2,
+                            actor->angle + ANG45, FRACUNIT / 2);
+    }
+    else
+    {                           // Blue bolt
+        P_SpawnMissile(actor, actor->target, MT_SOR2FX1);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1432,18 +1461,18 @@ void A_Srcr2Attack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_BlueSpark(mobj_t *actor)
+void A_BlueSpark(mobj_t * actor)
 {
-	int i;
-	mobj_t *mo;
+    int i;
+    mobj_t *mo;
 
-	for(i = 0; i < 2; i++)
-	{
-		mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_SOR2FXSPARK);
-		mo->momx = (P_Random()-P_Random())<<9;
-		mo->momy = (P_Random()-P_Random())<<9;
-		mo->momz = FRACUNIT+(P_Random()<<8);
-	}
+    for (i = 0; i < 2; i++)
+    {
+        mo = P_SpawnMobj(actor->x, actor->y, actor->z, MT_SOR2FXSPARK);
+        mo->momx = (P_Random() - P_Random()) << 9;
+        mo->momy = (P_Random() - P_Random()) << 9;
+        mo->momz = FRACUNIT + (P_Random() << 8);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1452,23 +1481,23 @@ void A_BlueSpark(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_GenWizard(mobj_t *actor)
+void A_GenWizard(mobj_t * actor)
 {
-	mobj_t *mo;
-	mobj_t *fog;
+    mobj_t *mo;
+    mobj_t *fog;
 
-	mo = P_SpawnMobj(actor->x, actor->y,
-		actor->z-mobjinfo[MT_WIZARD].height/2, MT_WIZARD);
-	if(P_TestMobjLocation(mo) == false)
-	{ // Didn't fit
-		P_RemoveMobj(mo);
-		return;
-	}
-	actor->momx = actor->momy = actor->momz = 0;
-	P_SetMobjState(actor, mobjinfo[actor->type].deathstate);
-	actor->flags &= ~MF_MISSILE;
-	fog = P_SpawnMobj(actor->x, actor->y, actor->z, MT_TFOG);
-	S_StartSound(fog, sfx_telept);
+    mo = P_SpawnMobj(actor->x, actor->y,
+                     actor->z - mobjinfo[MT_WIZARD].height / 2, MT_WIZARD);
+    if (P_TestMobjLocation(mo) == false)
+    {                           // Didn't fit
+        P_RemoveMobj(mo);
+        return;
+    }
+    actor->momx = actor->momy = actor->momz = 0;
+    P_SetMobjState(actor, mobjinfo[actor->type].deathstate);
+    actor->flags &= ~MF_MISSILE;
+    fog = P_SpawnMobj(actor->x, actor->y, actor->z, MT_TFOG);
+    S_StartSound(fog, sfx_telept);
 }
 
 //----------------------------------------------------------------------------
@@ -1477,10 +1506,10 @@ void A_GenWizard(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Sor2DthInit(mobj_t *actor)
+void A_Sor2DthInit(mobj_t * actor)
 {
-	actor->special1 = 7; // Animation loop counter
-	P_Massacre(); // Kill monsters early
+    actor->special1 = 7;        // Animation loop counter
+    P_Massacre();               // Kill monsters early
 }
 
 //----------------------------------------------------------------------------
@@ -1489,12 +1518,12 @@ void A_Sor2DthInit(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Sor2DthLoop(mobj_t *actor)
+void A_Sor2DthLoop(mobj_t * actor)
 {
-	if(--actor->special1)
-	{ // Need to loop
-		P_SetMobjState(actor, S_SOR2_DIE4);
-	}
+    if (--actor->special1)
+    {                           // Need to loop
+        P_SetMobjState(actor, S_SOR2_DIE4);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1503,12 +1532,35 @@ void A_Sor2DthLoop(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_SorZap(mobj_t *actor) {S_StartSound(NULL, sfx_sorzap);}
-void A_SorRise(mobj_t *actor) {S_StartSound(NULL, sfx_sorrise);}
-void A_SorDSph(mobj_t *actor) {S_StartSound(NULL, sfx_sordsph);}
-void A_SorDExp(mobj_t *actor) {S_StartSound(NULL, sfx_sordexp);}
-void A_SorDBon(mobj_t *actor) {S_StartSound(NULL, sfx_sordbon);}
-void A_SorSightSnd(mobj_t *actor) {S_StartSound(NULL, sfx_sorsit);}
+void A_SorZap(mobj_t * actor)
+{
+    S_StartSound(NULL, sfx_sorzap);
+}
+
+void A_SorRise(mobj_t * actor)
+{
+    S_StartSound(NULL, sfx_sorrise);
+}
+
+void A_SorDSph(mobj_t * actor)
+{
+    S_StartSound(NULL, sfx_sordsph);
+}
+
+void A_SorDExp(mobj_t * actor)
+{
+    S_StartSound(NULL, sfx_sordexp);
+}
+
+void A_SorDBon(mobj_t * actor)
+{
+    S_StartSound(NULL, sfx_sordbon);
+}
+
+void A_SorSightSnd(mobj_t * actor)
+{
+    S_StartSound(NULL, sfx_sorsit);
+}
 
 //----------------------------------------------------------------------------
 //
@@ -1518,23 +1570,23 @@ void A_SorSightSnd(mobj_t *actor) {S_StartSound(NULL, sfx_sorsit);}
 //
 //----------------------------------------------------------------------------
 
-void A_MinotaurAtk1(mobj_t *actor)
+void A_MinotaurAtk1(mobj_t * actor)
 {
-	player_t *player;
+    player_t *player;
 
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(actor, sfx_stfpow);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(4));
-		if((player = actor->target->player) != NULL)
-		{ // Squish the player
-			player->deltaviewheight = -16*FRACUNIT;
-		}
-	}
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(actor, sfx_stfpow);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(4));
+        if ((player = actor->target->player) != NULL)
+        {                       // Squish the player
+            player->deltaviewheight = -16 * FRACUNIT;
+        }
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1547,47 +1599,45 @@ void A_MinotaurAtk1(mobj_t *actor)
 
 #define MNTR_CHARGE_SPEED (13*FRACUNIT)
 
-void A_MinotaurDecide(mobj_t *actor)
-{
-	angle_t angle;
-	mobj_t *target;
-	int dist;
-
-	target = actor->target;
-	if(!target)
-	{
-		return;
-	}
-	S_StartSound(actor, sfx_minsit);
-	dist = P_AproxDistance(actor->x-target->x, actor->y-target->y);
-	if(target->z+target->height > actor->z
-		&& target->z+target->height < actor->z+actor->height
-		&& dist < 8*64*FRACUNIT
-		&& dist > 1*64*FRACUNIT
-		&& P_Random() < 150)
-	{ // Charge attack
-		// Don't call the state function right away
-		P_SetMobjStateNF(actor, S_MNTR_ATK4_1);
-		actor->flags |= MF_SKULLFLY;
-		A_FaceTarget(actor);
-		angle = actor->angle>>ANGLETOFINESHIFT;
-		actor->momx = FixedMul(MNTR_CHARGE_SPEED, finecosine[angle]);
-		actor->momy = FixedMul(MNTR_CHARGE_SPEED, finesine[angle]);
-		actor->special1 = 35/2; // Charge duration
-	}
-	else if(target->z == target->floorz
-		&& dist < 9*64*FRACUNIT
-		&& P_Random() < 220)
-	{ // Floor fire attack
-		P_SetMobjState(actor, S_MNTR_ATK3_1);
-		actor->special2 = 0;
-	}
-	else
-	{ // Swing attack
-		A_FaceTarget(actor);
-		// Don't need to call P_SetMobjState because the current state
-		// falls through to the swing attack
-	}
+void A_MinotaurDecide(mobj_t * actor)
+{
+    angle_t angle;
+    mobj_t *target;
+    int dist;
+
+    target = actor->target;
+    if (!target)
+    {
+        return;
+    }
+    S_StartSound(actor, sfx_minsit);
+    dist = P_AproxDistance(actor->x - target->x, actor->y - target->y);
+    if (target->z + target->height > actor->z
+        && target->z + target->height < actor->z + actor->height
+        && dist < 8 * 64 * FRACUNIT
+        && dist > 1 * 64 * FRACUNIT && P_Random() < 150)
+    {                           // Charge attack
+        // Don't call the state function right away
+        P_SetMobjStateNF(actor, S_MNTR_ATK4_1);
+        actor->flags |= MF_SKULLFLY;
+        A_FaceTarget(actor);
+        angle = actor->angle >> ANGLETOFINESHIFT;
+        actor->momx = FixedMul(MNTR_CHARGE_SPEED, finecosine[angle]);
+        actor->momy = FixedMul(MNTR_CHARGE_SPEED, finesine[angle]);
+        actor->special1 = 35 / 2;       // Charge duration
+    }
+    else if (target->z == target->floorz
+             && dist < 9 * 64 * FRACUNIT && P_Random() < 220)
+    {                           // Floor fire attack
+        P_SetMobjState(actor, S_MNTR_ATK3_1);
+        actor->special2 = 0;
+    }
+    else
+    {                           // Swing attack
+        A_FaceTarget(actor);
+        // Don't need to call P_SetMobjState because the current state
+        // falls through to the swing attack
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1596,21 +1646,21 @@ void A_MinotaurDecide(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_MinotaurCharge(mobj_t *actor)
+void A_MinotaurCharge(mobj_t * actor)
 {
-	mobj_t *puff;
+    mobj_t *puff;
 
-	if(actor->special1)
-	{
-		puff = P_SpawnMobj(actor->x, actor->y, actor->z, MT_PHOENIXPUFF);
-		puff->momz = 2*FRACUNIT;
-		actor->special1--;
-	}
-	else
-	{
-		actor->flags &= ~MF_SKULLFLY;
-		P_SetMobjState(actor, actor->info->seestate);
-	}
+    if (actor->special1)
+    {
+        puff = P_SpawnMobj(actor->x, actor->y, actor->z, MT_PHOENIXPUFF);
+        puff->momz = 2 * FRACUNIT;
+        actor->special1--;
+    }
+    else
+    {
+        actor->flags &= ~MF_SKULLFLY;
+        P_SetMobjState(actor, actor->info->seestate);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1621,33 +1671,33 @@ void A_MinotaurCharge(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_MinotaurAtk2(mobj_t *actor)
+void A_MinotaurAtk2(mobj_t * actor)
 {
-	mobj_t *mo;
-	angle_t angle;
-	fixed_t momz;
+    mobj_t *mo;
+    angle_t angle;
+    fixed_t momz;
 
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(actor, sfx_minat2);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(5));
-		return;
-	}
-	mo = P_SpawnMissile(actor, actor->target, MT_MNTRFX1);
-	if(mo)
-	{
-		S_StartSound(mo, sfx_minat2);
-		momz = mo->momz;
-		angle = mo->angle;
-		P_SpawnMissileAngle(actor, MT_MNTRFX1, angle-(ANG45/8), momz);
-		P_SpawnMissileAngle(actor, MT_MNTRFX1, angle+(ANG45/8), momz);
-		P_SpawnMissileAngle(actor, MT_MNTRFX1, angle-(ANG45/16), momz);
-		P_SpawnMissileAngle(actor, MT_MNTRFX1, angle+(ANG45/16), momz);
-	}
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(actor, sfx_minat2);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(5));
+        return;
+    }
+    mo = P_SpawnMissile(actor, actor->target, MT_MNTRFX1);
+    if (mo)
+    {
+        S_StartSound(mo, sfx_minat2);
+        momz = mo->momz;
+        angle = mo->angle;
+        P_SpawnMissileAngle(actor, MT_MNTRFX1, angle - (ANG45 / 8), momz);
+        P_SpawnMissileAngle(actor, MT_MNTRFX1, angle + (ANG45 / 8), momz);
+        P_SpawnMissileAngle(actor, MT_MNTRFX1, angle - (ANG45 / 16), momz);
+        P_SpawnMissileAngle(actor, MT_MNTRFX1, angle + (ANG45 / 16), momz);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1658,36 +1708,36 @@ void A_MinotaurAtk2(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_MinotaurAtk3(mobj_t *actor)
+void A_MinotaurAtk3(mobj_t * actor)
 {
-	mobj_t *mo;
-	player_t *player;
+    mobj_t *mo;
+    player_t *player;
 
-	if(!actor->target)
-	{
-		return;
-	}
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(5));
-		if((player = actor->target->player) != NULL)
-		{ // Squish the player
-			player->deltaviewheight = -16*FRACUNIT;
-		}
-	}
-	else
-	{
-		mo = P_SpawnMissile(actor, actor->target, MT_MNTRFX2);
-		if(mo != NULL)
-		{
-			S_StartSound(mo, sfx_minat1);
-		}
-	}
-	if(P_Random() < 192 && actor->special2 == 0)
-	{
-		P_SetMobjState(actor, S_MNTR_ATK3_4);
-		actor->special2 = 1;
-	}
+    if (!actor->target)
+    {
+        return;
+    }
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(5));
+        if ((player = actor->target->player) != NULL)
+        {                       // Squish the player
+            player->deltaviewheight = -16 * FRACUNIT;
+        }
+    }
+    else
+    {
+        mo = P_SpawnMissile(actor, actor->target, MT_MNTRFX2);
+        if (mo != NULL)
+        {
+            S_StartSound(mo, sfx_minat1);
+        }
+    }
+    if (P_Random() < 192 && actor->special2 == 0)
+    {
+        P_SetMobjState(actor, S_MNTR_ATK3_4);
+        actor->special2 = 1;
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1696,16 +1746,17 @@ void A_MinotaurAtk3(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_MntrFloorFire(mobj_t *actor)
+void A_MntrFloorFire(mobj_t * actor)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	actor->z = actor->floorz;
-	mo = P_SpawnMobj(actor->x+((P_Random()-P_Random())<<10),
-		actor->y+((P_Random()-P_Random())<<10), ONFLOORZ, MT_MNTRFX3);
-	mo->target = actor->target;
-	mo->momx = 1; // Force block checking
-	P_CheckMissileSpawn(mo);
+    actor->z = actor->floorz;
+    mo = P_SpawnMobj(actor->x + ((P_Random() - P_Random()) << 10),
+                     actor->y + ((P_Random() - P_Random()) << 10), ONFLOORZ,
+                     MT_MNTRFX3);
+    mo->target = actor->target;
+    mo->momx = 1;               // Force block checking
+    P_CheckMissileSpawn(mo);
 }
 
 //----------------------------------------------------------------------------
@@ -1714,19 +1765,19 @@ void A_MntrFloorFire(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_BeastAttack(mobj_t *actor)
+void A_BeastAttack(mobj_t * actor)
 {
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(actor, actor->info->attacksound);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(3));
-		return;
-	}
-	P_SpawnMissile(actor, actor->target, MT_BEASTBALL);
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(actor, actor->info->attacksound);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(3));
+        return;
+    }
+    P_SpawnMissile(actor, actor->target, MT_BEASTBALL);
 }
 
 //----------------------------------------------------------------------------
@@ -1735,79 +1786,79 @@ void A_BeastAttack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_HeadAttack(mobj_t *actor)
-{
-	int i;
-	mobj_t *fire;
-	mobj_t *baseFire;
-	mobj_t *mo;
-	mobj_t *target;
-	int randAttack;
-	static int atkResolve1[] = { 50, 150 };
-	static int atkResolve2[] = { 150, 200 };
-	int dist;
-
-	// Ice ball		(close 20% : far 60%)
-	// Fire column	(close 40% : far 20%)
-	// Whirlwind	(close 40% : far 20%)
-	// Distance threshold = 8 cells
-
-	target = actor->target;
-	if(target == NULL)
-	{
-		return;
-	}
-	A_FaceTarget(actor);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(target, actor, actor, HITDICE(6));
-		return;
-	}
-	dist = P_AproxDistance(actor->x-target->x, actor->y-target->y)
-		> 8*64*FRACUNIT;
-	randAttack = P_Random();
-	if(randAttack < atkResolve1[dist])
-	{ // Ice ball
-		P_SpawnMissile(actor, target, MT_HEADFX1);
-		S_StartSound(actor, sfx_hedat2);	
-	}
-	else if(randAttack < atkResolve2[dist])
-	{ // Fire column
-		baseFire = P_SpawnMissile(actor, target, MT_HEADFX3);
-		if(baseFire != NULL)
-		{
-			P_SetMobjState(baseFire, S_HEADFX3_4); // Don't grow
-			for(i = 0; i < 5; i++)
-			{
-				fire = P_SpawnMobj(baseFire->x, baseFire->y,
-					baseFire->z, MT_HEADFX3);
-				if(i == 0)
-				{
-					S_StartSound(actor, sfx_hedat1);
-				}
-				fire->target = baseFire->target;
-				fire->angle = baseFire->angle;
-				fire->momx = baseFire->momx;
-				fire->momy = baseFire->momy;
-				fire->momz = baseFire->momz;
-				fire->damage = 0;
-				fire->health = (i+1)*2;
-				P_CheckMissileSpawn(fire);
-			}
-		}
-	}
-	else
-	{ // Whirlwind
-		mo = P_SpawnMissile(actor, target, MT_WHIRLWIND);
-		if(mo != NULL)
-		{
-			mo->z -= 32*FRACUNIT;
-			mo->special1 = (int)target;
-			mo->special2 = 50; // Timer for active sound
-			mo->health = 20*TICSPERSEC; // Duration
-			S_StartSound(actor, sfx_hedat3);			
-		}
-	}
+void A_HeadAttack(mobj_t * actor)
+{
+    int i;
+    mobj_t *fire;
+    mobj_t *baseFire;
+    mobj_t *mo;
+    mobj_t *target;
+    int randAttack;
+    static int atkResolve1[] = { 50, 150 };
+    static int atkResolve2[] = { 150, 200 };
+    int dist;
+
+    // Ice ball             (close 20% : far 60%)
+    // Fire column  (close 40% : far 20%)
+    // Whirlwind    (close 40% : far 20%)
+    // Distance threshold = 8 cells
+
+    target = actor->target;
+    if (target == NULL)
+    {
+        return;
+    }
+    A_FaceTarget(actor);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(target, actor, actor, HITDICE(6));
+        return;
+    }
+    dist = P_AproxDistance(actor->x - target->x, actor->y - target->y)
+        > 8 * 64 * FRACUNIT;
+    randAttack = P_Random();
+    if (randAttack < atkResolve1[dist])
+    {                           // Ice ball
+        P_SpawnMissile(actor, target, MT_HEADFX1);
+        S_StartSound(actor, sfx_hedat2);
+    }
+    else if (randAttack < atkResolve2[dist])
+    {                           // Fire column
+        baseFire = P_SpawnMissile(actor, target, MT_HEADFX3);
+        if (baseFire != NULL)
+        {
+            P_SetMobjState(baseFire, S_HEADFX3_4);      // Don't grow
+            for (i = 0; i < 5; i++)
+            {
+                fire = P_SpawnMobj(baseFire->x, baseFire->y,
+                                   baseFire->z, MT_HEADFX3);
+                if (i == 0)
+                {
+                    S_StartSound(actor, sfx_hedat1);
+                }
+                fire->target = baseFire->target;
+                fire->angle = baseFire->angle;
+                fire->momx = baseFire->momx;
+                fire->momy = baseFire->momy;
+                fire->momz = baseFire->momz;
+                fire->damage = 0;
+                fire->health = (i + 1) * 2;
+                P_CheckMissileSpawn(fire);
+            }
+        }
+    }
+    else
+    {                           // Whirlwind
+        mo = P_SpawnMissile(actor, target, MT_WHIRLWIND);
+        if (mo != NULL)
+        {
+            mo->z -= 32 * FRACUNIT;
+            mo->special1 = (int) target;
+            mo->special2 = 50;  // Timer for active sound
+            mo->health = 20 * TICSPERSEC;       // Duration
+            S_StartSound(actor, sfx_hedat3);
+        }
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1816,27 +1867,27 @@ void A_HeadAttack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_WhirlwindSeek(mobj_t *actor)
+void A_WhirlwindSeek(mobj_t * actor)
 {
-	actor->health -= 3;
-	if(actor->health < 0)
-	{
-		actor->momx = actor->momy = actor->momz = 0;
-		P_SetMobjState(actor, mobjinfo[actor->type].deathstate);
-		actor->flags &= ~MF_MISSILE;
-		return;
-	}
-	if((actor->special2 -= 3) < 0)
-	{
-		actor->special2 = 58+(P_Random()&31);
-		S_StartSound(actor, sfx_hedat3);
-	}
-	if(actor->special1
-		&& (((mobj_t *)(actor->special1))->flags&MF_SHADOW))
-	{
-		return;
-	}
-	P_SeekerMissile(actor, ANGLE_1*10, ANGLE_1*30);
+    actor->health -= 3;
+    if (actor->health < 0)
+    {
+        actor->momx = actor->momy = actor->momz = 0;
+        P_SetMobjState(actor, mobjinfo[actor->type].deathstate);
+        actor->flags &= ~MF_MISSILE;
+        return;
+    }
+    if ((actor->special2 -= 3) < 0)
+    {
+        actor->special2 = 58 + (P_Random() & 31);
+        S_StartSound(actor, sfx_hedat3);
+    }
+    if (actor->special1
+        && (((mobj_t *) (actor->special1))->flags & MF_SHADOW))
+    {
+        return;
+    }
+    P_SeekerMissile(actor, ANGLE_1 * 10, ANGLE_1 * 30);
 }
 
 //----------------------------------------------------------------------------
@@ -1845,24 +1896,24 @@ void A_WhirlwindSeek(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_HeadIceImpact(mobj_t *ice)
+void A_HeadIceImpact(mobj_t * ice)
 {
-	int i;
-	angle_t angle;
-	mobj_t *shard;
+    int i;
+    angle_t angle;
+    mobj_t *shard;
 
-	for(i = 0; i < 8; i++)
-	{
-		shard = P_SpawnMobj(ice->x, ice->y, ice->z, MT_HEADFX2);
-		angle = i*ANG45;
-		shard->target = ice->target;
-		shard->angle = angle;
-		angle >>= ANGLETOFINESHIFT;
-		shard->momx = FixedMul(shard->info->speed, finecosine[angle]);
-		shard->momy = FixedMul(shard->info->speed, finesine[angle]);
-		shard->momz = -.6*FRACUNIT;
-		P_CheckMissileSpawn(shard);
-	}
+    for (i = 0; i < 8; i++)
+    {
+        shard = P_SpawnMobj(ice->x, ice->y, ice->z, MT_HEADFX2);
+        angle = i * ANG45;
+        shard->target = ice->target;
+        shard->angle = angle;
+        angle >>= ANGLETOFINESHIFT;
+        shard->momx = FixedMul(shard->info->speed, finecosine[angle]);
+        shard->momy = FixedMul(shard->info->speed, finesine[angle]);
+        shard->momz = -.6 * FRACUNIT;
+        P_CheckMissileSpawn(shard);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1871,15 +1922,15 @@ void A_HeadIceImpact(mobj_t *ice)
 //
 //----------------------------------------------------------------------------
 
-void A_HeadFireGrow(mobj_t *fire)
+void A_HeadFireGrow(mobj_t * fire)
 {
-	fire->health--;
-	fire->z += 9*FRACUNIT;
-	if(fire->health == 0)
-	{
-		fire->damage = fire->info->damage;
-		P_SetMobjState(fire, S_HEADFX3_4);
-	}
+    fire->health--;
+    fire->z += 9 * FRACUNIT;
+    if (fire->health == 0)
+    {
+        fire->damage = fire->info->damage;
+        P_SetMobjState(fire, S_HEADFX3_4);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1888,16 +1939,16 @@ void A_HeadFireGrow(mobj_t *fire)
 //
 //----------------------------------------------------------------------------
 
-void A_SnakeAttack(mobj_t *actor)
+void A_SnakeAttack(mobj_t * actor)
 {
-	if(!actor->target)
-	{
-		P_SetMobjState(actor, S_SNAKE_WALK1);
-		return;
-	}
-	S_StartSound(actor, actor->info->attacksound);
-	A_FaceTarget(actor);
-	P_SpawnMissile(actor, actor->target, MT_SNAKEPRO_A);
+    if (!actor->target)
+    {
+        P_SetMobjState(actor, S_SNAKE_WALK1);
+        return;
+    }
+    S_StartSound(actor, actor->info->attacksound);
+    A_FaceTarget(actor);
+    P_SpawnMissile(actor, actor->target, MT_SNAKEPRO_A);
 }
 
 //----------------------------------------------------------------------------
@@ -1906,16 +1957,16 @@ void A_SnakeAttack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_SnakeAttack2(mobj_t *actor)
+void A_SnakeAttack2(mobj_t * actor)
 {
-	if(!actor->target)
-	{
-		P_SetMobjState(actor, S_SNAKE_WALK1);
-		return;
-	}
-	S_StartSound(actor, actor->info->attacksound);
-	A_FaceTarget(actor);
-	P_SpawnMissile(actor, actor->target, MT_SNAKEPRO_B);
+    if (!actor->target)
+    {
+        P_SetMobjState(actor, S_SNAKE_WALK1);
+        return;
+    }
+    S_StartSound(actor, actor->info->attacksound);
+    A_FaceTarget(actor);
+    P_SpawnMissile(actor, actor->target, MT_SNAKEPRO_B);
 }
 
 //----------------------------------------------------------------------------
@@ -1924,20 +1975,20 @@ void A_SnakeAttack2(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ClinkAttack(mobj_t *actor)
+void A_ClinkAttack(mobj_t * actor)
 {
-	int damage;
+    int damage;
 
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(actor, actor->info->attacksound);
-	if(P_CheckMeleeRange(actor))
-	{
-		damage = ((P_Random()%7)+3);
-		P_DamageMobj(actor->target, actor, actor, damage);
-	}
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(actor, actor->info->attacksound);
+    if (P_CheckMeleeRange(actor))
+    {
+        damage = ((P_Random() % 7) + 3);
+        P_DamageMobj(actor->target, actor, actor, damage);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -1946,9 +1997,9 @@ void A_ClinkAttack(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_GhostOff(mobj_t *actor)
+void A_GhostOff(mobj_t * actor)
 {
-	actor->flags &= ~MF_SHADOW;
+    actor->flags &= ~MF_SHADOW;
 }
 
 //----------------------------------------------------------------------------
@@ -1957,10 +2008,10 @@ void A_GhostOff(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_WizAtk1(mobj_t *actor)
+void A_WizAtk1(mobj_t * actor)
 {
-	A_FaceTarget(actor);
-	actor->flags &= ~MF_SHADOW;
+    A_FaceTarget(actor);
+    actor->flags &= ~MF_SHADOW;
 }
 
 //----------------------------------------------------------------------------
@@ -1969,10 +2020,10 @@ void A_WizAtk1(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_WizAtk2(mobj_t *actor)
+void A_WizAtk2(mobj_t * actor)
 {
-	A_FaceTarget(actor);
-	actor->flags |= MF_SHADOW;
+    A_FaceTarget(actor);
+    actor->flags |= MF_SHADOW;
 }
 
 //----------------------------------------------------------------------------
@@ -1981,31 +2032,31 @@ void A_WizAtk2(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_WizAtk3(mobj_t *actor)
+void A_WizAtk3(mobj_t * actor)
 {
-	mobj_t *mo;
-	angle_t angle;
-	fixed_t momz;
+    mobj_t *mo;
+    angle_t angle;
+    fixed_t momz;
 
-	actor->flags &= ~MF_SHADOW;
-	if(!actor->target)
-	{
-		return;
-	}
-	S_StartSound(actor, actor->info->attacksound);
-	if(P_CheckMeleeRange(actor))
-	{
-		P_DamageMobj(actor->target, actor, actor, HITDICE(4));
-		return;
-	}
-	mo = P_SpawnMissile(actor, actor->target, MT_WIZFX1);
-	if(mo)
-	{
-		momz = mo->momz;
-		angle = mo->angle;
-		P_SpawnMissileAngle(actor, MT_WIZFX1, angle-(ANG45/8), momz);
-		P_SpawnMissileAngle(actor, MT_WIZFX1, angle+(ANG45/8), momz);
-	}
+    actor->flags &= ~MF_SHADOW;
+    if (!actor->target)
+    {
+        return;
+    }
+    S_StartSound(actor, actor->info->attacksound);
+    if (P_CheckMeleeRange(actor))
+    {
+        P_DamageMobj(actor->target, actor, actor, HITDICE(4));
+        return;
+    }
+    mo = P_SpawnMissile(actor, actor->target, MT_WIZFX1);
+    if (mo)
+    {
+        momz = mo->momz;
+        angle = mo->angle;
+        P_SpawnMissileAngle(actor, MT_WIZFX1, angle - (ANG45 / 8), momz);
+        P_SpawnMissileAngle(actor, MT_WIZFX1, angle + (ANG45 / 8), momz);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2014,39 +2065,39 @@ void A_WizAtk3(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Scream(mobj_t *actor)
-{
-	switch(actor->type)
-	{
-		case MT_CHICPLAYER:
-		case MT_SORCERER1:
-		case MT_MINOTAUR:
-			// Make boss death sounds full volume
-			S_StartSound(NULL, actor->info->deathsound);
-			break;
-		case MT_PLAYER:
-			// Handle the different player death screams
-			if(actor->special1 < 10)
-			{ // Wimpy death sound
-				S_StartSound(actor, sfx_plrwdth);
-			}
-			else if(actor->health > -50)
-			{ // Normal death sound
-				S_StartSound(actor, actor->info->deathsound);
-			}
-			else if(actor->health > -100)
-			{ // Crazy death sound
-				S_StartSound(actor, sfx_plrcdth);
-			}
-			else
-			{ // Extreme death sound
-				S_StartSound(actor, sfx_gibdth);
-			}
-			break;
-		default:
-			S_StartSound(actor, actor->info->deathsound);
-			break;
-	}
+void A_Scream(mobj_t * actor)
+{
+    switch (actor->type)
+    {
+        case MT_CHICPLAYER:
+        case MT_SORCERER1:
+        case MT_MINOTAUR:
+            // Make boss death sounds full volume
+            S_StartSound(NULL, actor->info->deathsound);
+            break;
+        case MT_PLAYER:
+            // Handle the different player death screams
+            if (actor->special1 < 10)
+            {                   // Wimpy death sound
+                S_StartSound(actor, sfx_plrwdth);
+            }
+            else if (actor->health > -50)
+            {                   // Normal death sound
+                S_StartSound(actor, actor->info->deathsound);
+            }
+            else if (actor->health > -100)
+            {                   // Crazy death sound
+                S_StartSound(actor, sfx_plrcdth);
+            }
+            else
+            {                   // Extreme death sound
+                S_StartSound(actor, sfx_gibdth);
+            }
+            break;
+        default:
+            S_StartSound(actor, actor->info->deathsound);
+            break;
+    }
 }
 
 //---------------------------------------------------------------------------
@@ -2055,21 +2106,21 @@ void A_Scream(mobj_t *actor)
 //
 //---------------------------------------------------------------------------
 
-void P_DropItem(mobj_t *source, mobjtype_t type, int special, int chance)
+void P_DropItem(mobj_t * source, mobjtype_t type, int special, int chance)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	if(P_Random() > chance)
-	{
-		return;
-	}
-	mo = P_SpawnMobj(source->x, source->y,
-		source->z+(source->height>>1), type);
-	mo->momx = (P_Random()-P_Random())<<8;
-	mo->momy = (P_Random()-P_Random())<<8;
-	mo->momz = FRACUNIT*5+(P_Random()<<10);
-	mo->flags |= MF_DROPPED;
-	mo->health = special;
+    if (P_Random() > chance)
+    {
+        return;
+    }
+    mo = P_SpawnMobj(source->x, source->y,
+                     source->z + (source->height >> 1), type);
+    mo->momx = (P_Random() - P_Random()) << 8;
+    mo->momy = (P_Random() - P_Random()) << 8;
+    mo->momz = FRACUNIT * 5 + (P_Random() << 10);
+    mo->flags |= MF_DROPPED;
+    mo->health = special;
 }
 
 //----------------------------------------------------------------------------
@@ -2078,46 +2129,46 @@ void P_DropItem(mobj_t *source, mobjtype_t type, int special, int chance)
 //
 //----------------------------------------------------------------------------
 
-void A_NoBlocking(mobj_t *actor)
-{
-	actor->flags &= ~MF_SOLID;
-	// Check for monsters dropping things
-	switch(actor->type)
-	{
-		case MT_MUMMY:
-		case MT_MUMMYLEADER:
-		case MT_MUMMYGHOST:
-		case MT_MUMMYLEADERGHOST:
-			P_DropItem(actor, MT_AMGWNDWIMPY, 3, 84);
-			break;
-		case MT_KNIGHT:
-		case MT_KNIGHTGHOST:
-			P_DropItem(actor, MT_AMCBOWWIMPY, 5, 84);
-			break;
-		case MT_WIZARD:
-			P_DropItem(actor, MT_AMBLSRWIMPY, 10, 84);
-			P_DropItem(actor, MT_ARTITOMEOFPOWER, 0, 4);
-			break;
-		case MT_HEAD:
-			P_DropItem(actor, MT_AMBLSRWIMPY, 10, 84);
-			P_DropItem(actor, MT_ARTIEGG, 0, 51);
-			break;
-		case MT_BEAST:
-			P_DropItem(actor, MT_AMCBOWWIMPY, 10, 84);
-			break;
-		case MT_CLINK:
-			P_DropItem(actor, MT_AMSKRDWIMPY, 20, 84);
-			break;
-		case MT_SNAKE:
-			P_DropItem(actor, MT_AMPHRDWIMPY, 5, 84);
-			break;
-		case MT_MINOTAUR:
-			P_DropItem(actor, MT_ARTISUPERHEAL, 0, 51);
-			P_DropItem(actor, MT_AMPHRDWIMPY, 10, 84);
-			break;
-		default:
-			break;
-	}
+void A_NoBlocking(mobj_t * actor)
+{
+    actor->flags &= ~MF_SOLID;
+    // Check for monsters dropping things
+    switch (actor->type)
+    {
+        case MT_MUMMY:
+        case MT_MUMMYLEADER:
+        case MT_MUMMYGHOST:
+        case MT_MUMMYLEADERGHOST:
+            P_DropItem(actor, MT_AMGWNDWIMPY, 3, 84);
+            break;
+        case MT_KNIGHT:
+        case MT_KNIGHTGHOST:
+            P_DropItem(actor, MT_AMCBOWWIMPY, 5, 84);
+            break;
+        case MT_WIZARD:
+            P_DropItem(actor, MT_AMBLSRWIMPY, 10, 84);
+            P_DropItem(actor, MT_ARTITOMEOFPOWER, 0, 4);
+            break;
+        case MT_HEAD:
+            P_DropItem(actor, MT_AMBLSRWIMPY, 10, 84);
+            P_DropItem(actor, MT_ARTIEGG, 0, 51);
+            break;
+        case MT_BEAST:
+            P_DropItem(actor, MT_AMCBOWWIMPY, 10, 84);
+            break;
+        case MT_CLINK:
+            P_DropItem(actor, MT_AMSKRDWIMPY, 20, 84);
+            break;
+        case MT_SNAKE:
+            P_DropItem(actor, MT_AMPHRDWIMPY, 5, 84);
+            break;
+        case MT_MINOTAUR:
+            P_DropItem(actor, MT_ARTISUPERHEAL, 0, 51);
+            P_DropItem(actor, MT_AMPHRDWIMPY, 10, 84);
+            break;
+        default:
+            break;
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2128,28 +2179,28 @@ void A_NoBlocking(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_Explode(mobj_t *actor)
+void A_Explode(mobj_t * actor)
 {
-	int damage;
+    int damage;
 
-	damage = 128;
-	switch(actor->type)
-	{
-		case MT_FIREBOMB: // Time Bombs
-			actor->z += 32*FRACUNIT;
-			actor->flags &= ~MF_SHADOW;
-			break;
-		case MT_MNTRFX2: // Minotaur floor fire
-			damage = 24;
-			break;
-		case MT_SOR2FX1: // D'Sparil missile
-			damage = 80+(P_Random()&31);
-			break;
-		default:
-			break;
-	}
-	P_RadiusAttack(actor, actor->target, damage);
-	P_HitFloor(actor);
+    damage = 128;
+    switch (actor->type)
+    {
+        case MT_FIREBOMB:      // Time Bombs
+            actor->z += 32 * FRACUNIT;
+            actor->flags &= ~MF_SHADOW;
+            break;
+        case MT_MNTRFX2:       // Minotaur floor fire
+            damage = 24;
+            break;
+        case MT_SOR2FX1:       // D'Sparil missile
+            damage = 80 + (P_Random() & 31);
+            break;
+        default:
+            break;
+    }
+    P_RadiusAttack(actor, actor->target, damage);
+    P_HitFloor(actor);
 }
 
 //----------------------------------------------------------------------------
@@ -2158,28 +2209,28 @@ void A_Explode(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_PodPain(mobj_t *actor)
+void A_PodPain(mobj_t * actor)
 {
-	int i;
-	int count;
-	int chance;
-	mobj_t *goo;
+    int i;
+    int count;
+    int chance;
+    mobj_t *goo;
 
-	chance = P_Random();
-	if(chance < 128)
-	{
-		return;
-	}
-	count = chance > 240 ? 2 : 1;
-	for(i = 0; i < count; i++)
-	{
-		goo = P_SpawnMobj(actor->x, actor->y,
-			actor->z+48*FRACUNIT, MT_PODGOO);
-		goo->target = actor;
-		goo->momx = (P_Random()-P_Random())<<9;
-		goo->momy = (P_Random()-P_Random())<<9;
-		goo->momz = FRACUNIT/2+(P_Random()<<9);
-	}
+    chance = P_Random();
+    if (chance < 128)
+    {
+        return;
+    }
+    count = chance > 240 ? 2 : 1;
+    for (i = 0; i < count; i++)
+    {
+        goo = P_SpawnMobj(actor->x, actor->y,
+                          actor->z + 48 * FRACUNIT, MT_PODGOO);
+        goo->target = actor;
+        goo->momx = (P_Random() - P_Random()) << 9;
+        goo->momy = (P_Random() - P_Random()) << 9;
+        goo->momz = FRACUNIT / 2 + (P_Random() << 9);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2188,18 +2239,18 @@ void A_PodPain(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_RemovePod(mobj_t *actor)
+void A_RemovePod(mobj_t * actor)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	if(actor->special2)
-	{
-		mo = (mobj_t *)actor->special2;
-		if(mo->special1 > 0)
-		{
-			mo->special1--;
-		}
-	}
+    if (actor->special2)
+    {
+        mo = (mobj_t *) actor->special2;
+        if (mo->special1 > 0)
+        {
+            mo->special1--;
+        }
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2210,32 +2261,32 @@ void A_RemovePod(mobj_t *actor)
 
 #define MAX_GEN_PODS 16
 
-void A_MakePod(mobj_t *actor)
+void A_MakePod(mobj_t * actor)
 {
-	mobj_t *mo;
-	fixed_t x;
-	fixed_t y;
-	fixed_t z;
+    mobj_t *mo;
+    fixed_t x;
+    fixed_t y;
+    fixed_t z;
 
-	if(actor->special1 == MAX_GEN_PODS)
-	{ // Too many generated pods
-		return;
-	}
-	x = actor->x;
-	y = actor->y;
-	z = actor->z;
-	mo = P_SpawnMobj(x, y, ONFLOORZ, MT_POD);
-	if(P_CheckPosition(mo, x, y) == false)
-	{ // Didn't fit
-		P_RemoveMobj(mo);
-		return;
-	}
-	P_SetMobjState(mo, S_POD_GROW1);
-	P_ThrustMobj(mo, P_Random()<<24, (fixed_t)(4.5*FRACUNIT));
-	S_StartSound(mo, sfx_newpod);
-	actor->special1++; // Increment generated pod count
-	mo->special2 = (int)actor; // Link the generator to the pod
-	return;
+    if (actor->special1 == MAX_GEN_PODS)
+    {                           // Too many generated pods
+        return;
+    }
+    x = actor->x;
+    y = actor->y;
+    z = actor->z;
+    mo = P_SpawnMobj(x, y, ONFLOORZ, MT_POD);
+    if (P_CheckPosition(mo, x, y) == false)
+    {                           // Didn't fit
+        P_RemoveMobj(mo);
+        return;
+    }
+    P_SetMobjState(mo, S_POD_GROW1);
+    P_ThrustMobj(mo, P_Random() << 24, (fixed_t) (4.5 * FRACUNIT));
+    S_StartSound(mo, sfx_newpod);
+    actor->special1++;          // Increment generated pod count
+    mo->special2 = (int) actor; // Link the generator to the pod
+    return;
 }
 
 //----------------------------------------------------------------------------
@@ -2248,22 +2299,21 @@ void A_MakePod(mobj_t *actor)
 
 void P_Massacre(void)
 {
-	mobj_t *mo;
-	thinker_t *think;
+    mobj_t *mo;
+    thinker_t *think;
 
-	for(think = thinkercap.next; think != &thinkercap;
-		think = think->next)
-	{
-		if(think->function != P_MobjThinker)
-		{ // Not a mobj thinker
-			continue;
-		}
-		mo = (mobj_t *)think;
-		if((mo->flags&MF_COUNTKILL) && (mo->health > 0))
-		{
-			P_DamageMobj(mo, NULL, NULL, 10000);
-		}
-	}
+    for (think = thinkercap.next; think != &thinkercap; think = think->next)
+    {
+        if (think->function != P_MobjThinker)
+        {                       // Not a mobj thinker
+            continue;
+        }
+        mo = (mobj_t *) think;
+        if ((mo->flags & MF_COUNTKILL) && (mo->health > 0))
+        {
+            P_DamageMobj(mo, NULL, NULL, 10000);
+        }
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2274,48 +2324,47 @@ void P_Massacre(void)
 //
 //----------------------------------------------------------------------------
 
-void A_BossDeath(mobj_t *actor)
-{
-	mobj_t *mo;
-	thinker_t *think;
-	line_t dummyLine;
-	static mobjtype_t bossType[6] =
-	{
-		MT_HEAD,
-		MT_MINOTAUR,
-		MT_SORCERER2,
-		MT_HEAD,
-		MT_MINOTAUR,
-		-1
-	};
-
-	if(gamemap != 8)
-	{ // Not a boss level
-		return;
-	}
-	if(actor->type != bossType[gameepisode-1])
-	{ // Not considered a boss in this episode
-		return;
-	}
-	// Make sure all bosses are dead
-	for(think = thinkercap.next; think != &thinkercap; think = think->next)
-	{
-		if(think->function != P_MobjThinker)
-		{ // Not a mobj thinker
-			continue;
-		}
-		mo = (mobj_t *)think;
-		if((mo != actor) && (mo->type == actor->type) && (mo->health > 0))
-		{ // Found a living boss
-			return;
-		}
-	}
-	if(gameepisode > 1)
-	{ // Kill any remaining monsters
-		P_Massacre();
-	}
-	dummyLine.tag = 666;
-	EV_DoFloor(&dummyLine, lowerFloor);
+void A_BossDeath(mobj_t * actor)
+{
+    mobj_t *mo;
+    thinker_t *think;
+    line_t dummyLine;
+    static mobjtype_t bossType[6] = {
+        MT_HEAD,
+        MT_MINOTAUR,
+        MT_SORCERER2,
+        MT_HEAD,
+        MT_MINOTAUR,
+        -1
+    };
+
+    if (gamemap != 8)
+    {                           // Not a boss level
+        return;
+    }
+    if (actor->type != bossType[gameepisode - 1])
+    {                           // Not considered a boss in this episode
+        return;
+    }
+    // Make sure all bosses are dead
+    for (think = thinkercap.next; think != &thinkercap; think = think->next)
+    {
+        if (think->function != P_MobjThinker)
+        {                       // Not a mobj thinker
+            continue;
+        }
+        mo = (mobj_t *) think;
+        if ((mo != actor) && (mo->type == actor->type) && (mo->health > 0))
+        {                       // Found a living boss
+            return;
+        }
+    }
+    if (gameepisode > 1)
+    {                           // Kill any remaining monsters
+        P_Massacre();
+    }
+    dummyLine.tag = 666;
+    EV_DoFloor(&dummyLine, lowerFloor);
 }
 
 //----------------------------------------------------------------------------
@@ -2324,22 +2373,22 @@ void A_BossDeath(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_ESound(mobj_t *mo)
+void A_ESound(mobj_t * mo)
 {
-	int sound;
+    int sound;
 
-	switch(mo->type)
-	{
-		case MT_SOUNDWATERFALL:
-			sound = sfx_waterfl;
-			break;
-		case MT_SOUNDWIND:
-			sound = sfx_wind;
-			break;
-		default:
-			break;
-	}
-	S_StartSound(mo, sound);
+    switch (mo->type)
+    {
+        case MT_SOUNDWATERFALL:
+            sound = sfx_waterfl;
+            break;
+        case MT_SOUNDWIND:
+            sound = sfx_wind;
+            break;
+        default:
+            break;
+    }
+    S_StartSound(mo, sound);
 }
 
 //----------------------------------------------------------------------------
@@ -2348,14 +2397,14 @@ void A_ESound(mobj_t *mo)
 //
 //----------------------------------------------------------------------------
 
-void A_SpawnTeleGlitter(mobj_t *actor)
+void A_SpawnTeleGlitter(mobj_t * actor)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	mo = P_SpawnMobj(actor->x+((P_Random()&31)-16)*FRACUNIT,
-		actor->y+((P_Random()&31)-16)*FRACUNIT,
-		actor->subsector->sector->floorheight, MT_TELEGLITTER);
-	mo->momz = FRACUNIT/4;
+    mo = P_SpawnMobj(actor->x + ((P_Random() & 31) - 16) * FRACUNIT,
+                     actor->y + ((P_Random() & 31) - 16) * FRACUNIT,
+                     actor->subsector->sector->floorheight, MT_TELEGLITTER);
+    mo->momz = FRACUNIT / 4;
 }
 
 //----------------------------------------------------------------------------
@@ -2364,14 +2413,14 @@ void A_SpawnTeleGlitter(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_SpawnTeleGlitter2(mobj_t *actor)
+void A_SpawnTeleGlitter2(mobj_t * actor)
 {
-	mobj_t *mo;
+    mobj_t *mo;
 
-	mo = P_SpawnMobj(actor->x+((P_Random()&31)-16)*FRACUNIT,
-		actor->y+((P_Random()&31)-16)*FRACUNIT,
-		actor->subsector->sector->floorheight, MT_TELEGLITTER2);
-	mo->momz = FRACUNIT/4;
+    mo = P_SpawnMobj(actor->x + ((P_Random() & 31) - 16) * FRACUNIT,
+                     actor->y + ((P_Random() & 31) - 16) * FRACUNIT,
+                     actor->subsector->sector->floorheight, MT_TELEGLITTER2);
+    mo->momz = FRACUNIT / 4;
 }
 
 //----------------------------------------------------------------------------
@@ -2380,12 +2429,12 @@ void A_SpawnTeleGlitter2(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_AccTeleGlitter(mobj_t *actor)
+void A_AccTeleGlitter(mobj_t * actor)
 {
-	if(++actor->health > 35)
-	{
-		actor->momz += actor->momz/2;
-	}
+    if (++actor->health > 35)
+    {
+        actor->momz += actor->momz / 2;
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2394,28 +2443,28 @@ void A_AccTeleGlitter(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_InitKeyGizmo(mobj_t *gizmo)
+void A_InitKeyGizmo(mobj_t * gizmo)
 {
-	mobj_t *mo;
-	statenum_t state;
+    mobj_t *mo;
+    statenum_t state;
 
-	switch(gizmo->type)
-	{
-		case MT_KEYGIZMOBLUE:
-			state = S_KGZ_BLUEFLOAT1;
-			break;
-		case MT_KEYGIZMOGREEN:
-			state = S_KGZ_GREENFLOAT1;
-			break;
-		case MT_KEYGIZMOYELLOW:
-			state = S_KGZ_YELLOWFLOAT1;
-			break;
-		default:
-			break;
-	}
-	mo = P_SpawnMobj(gizmo->x, gizmo->y, gizmo->z+60*FRACUNIT,
-		MT_KEYGIZMOFLOAT);
-	P_SetMobjState(mo, state);
+    switch (gizmo->type)
+    {
+        case MT_KEYGIZMOBLUE:
+            state = S_KGZ_BLUEFLOAT1;
+            break;
+        case MT_KEYGIZMOGREEN:
+            state = S_KGZ_GREENFLOAT1;
+            break;
+        case MT_KEYGIZMOYELLOW:
+            state = S_KGZ_YELLOWFLOAT1;
+            break;
+        default:
+            break;
+    }
+    mo = P_SpawnMobj(gizmo->x, gizmo->y, gizmo->z + 60 * FRACUNIT,
+                     MT_KEYGIZMOFLOAT);
+    P_SetMobjState(mo, state);
 }
 
 //----------------------------------------------------------------------------
@@ -2424,9 +2473,9 @@ void A_InitKeyGizmo(mobj_t *gizmo)
 //
 //----------------------------------------------------------------------------
 
-void A_VolcanoSet(mobj_t *volcano)
+void A_VolcanoSet(mobj_t * volcano)
 {
-	volcano->tics = 105+(P_Random()&127);
+    volcano->tics = 105 + (P_Random() & 127);
 }
 
 //----------------------------------------------------------------------------
@@ -2435,28 +2484,27 @@ void A_VolcanoSet(mobj_t *volcano)
 //
 //----------------------------------------------------------------------------
 
-void A_VolcanoBlast(mobj_t *volcano)
+void A_VolcanoBlast(mobj_t * volcano)
 {
-	int i;
-	int count;
-	mobj_t *blast;
-	angle_t angle;
+    int i;
+    int count;
+    mobj_t *blast;
+    angle_t angle;
 
-	count = 1+(P_Random()%3);
-	for(i = 0; i < count; i++)
-	{
-		blast = P_SpawnMobj(volcano->x, volcano->y,
-			volcano->z+44*FRACUNIT, MT_VOLCANOBLAST); // MT_VOLCANOBLAST
-		blast->target = volcano;
-		angle = P_Random()<<24;
-		blast->angle = angle;
-		angle >>= ANGLETOFINESHIFT;
-		blast->momx = FixedMul(1*FRACUNIT, finecosine[angle]);
-		blast->momy = FixedMul(1*FRACUNIT, finesine[angle]);
-		blast->momz = (2.5*FRACUNIT)+(P_Random()<<10);
-		S_StartSound(blast, sfx_volsht);
-		P_CheckMissileSpawn(blast);
-	}
+    count = 1 + (P_Random() % 3);
+    for (i = 0; i < count; i++)
+    {
+        blast = P_SpawnMobj(volcano->x, volcano->y, volcano->z + 44 * FRACUNIT, MT_VOLCANOBLAST);       // MT_VOLCANOBLAST
+        blast->target = volcano;
+        angle = P_Random() << 24;
+        blast->angle = angle;
+        angle >>= ANGLETOFINESHIFT;
+        blast->momx = FixedMul(1 * FRACUNIT, finecosine[angle]);
+        blast->momy = FixedMul(1 * FRACUNIT, finesine[angle]);
+        blast->momz = (2.5 * FRACUNIT) + (P_Random() << 10);
+        S_StartSound(blast, sfx_volsht);
+        P_CheckMissileSpawn(blast);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2465,32 +2513,32 @@ void A_VolcanoBlast(mobj_t *volcano)
 //
 //----------------------------------------------------------------------------
 
-void A_VolcBallImpact(mobj_t *ball)
+void A_VolcBallImpact(mobj_t * ball)
 {
-	int i;
-	mobj_t *tiny;
-	angle_t angle;
+    int i;
+    mobj_t *tiny;
+    angle_t angle;
 
-	if(ball->z <= ball->floorz)
-	{
-		ball->flags |= MF_NOGRAVITY;
-		ball->flags2 &= ~MF2_LOGRAV;
-		ball->z += 28*FRACUNIT;
-		//ball->momz = 3*FRACUNIT;
-	}
-	P_RadiusAttack(ball, ball->target, 25);
-	for(i = 0; i < 4; i++)
-	{
-		tiny = P_SpawnMobj(ball->x, ball->y, ball->z, MT_VOLCANOTBLAST);
-		tiny->target = ball;
-		angle = i*ANG90;
-		tiny->angle = angle;
-		angle >>= ANGLETOFINESHIFT;
-		tiny->momx = FixedMul(FRACUNIT*.7, finecosine[angle]);
-		tiny->momy = FixedMul(FRACUNIT*.7, finesine[angle]);
-		tiny->momz = FRACUNIT+(P_Random()<<9);
-		P_CheckMissileSpawn(tiny);
-	}
+    if (ball->z <= ball->floorz)
+    {
+        ball->flags |= MF_NOGRAVITY;
+        ball->flags2 &= ~MF2_LOGRAV;
+        ball->z += 28 * FRACUNIT;
+        //ball->momz = 3*FRACUNIT;
+    }
+    P_RadiusAttack(ball, ball->target, 25);
+    for (i = 0; i < 4; i++)
+    {
+        tiny = P_SpawnMobj(ball->x, ball->y, ball->z, MT_VOLCANOTBLAST);
+        tiny->target = ball;
+        angle = i * ANG90;
+        tiny->angle = angle;
+        angle >>= ANGLETOFINESHIFT;
+        tiny->momx = FixedMul(FRACUNIT * .7, finecosine[angle]);
+        tiny->momy = FixedMul(FRACUNIT * .7, finesine[angle]);
+        tiny->momz = FRACUNIT + (P_Random() << 9);
+        P_CheckMissileSpawn(tiny);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2499,27 +2547,27 @@ void A_VolcBallImpact(mobj_t *ball)
 //
 //----------------------------------------------------------------------------
 
-void A_SkullPop(mobj_t *actor)
+void A_SkullPop(mobj_t * actor)
 {
-	mobj_t *mo;
-	player_t *player;
+    mobj_t *mo;
+    player_t *player;
 
-	actor->flags &= ~MF_SOLID;
-	mo = P_SpawnMobj(actor->x, actor->y, actor->z+48*FRACUNIT,
-		MT_BLOODYSKULL);
-	//mo->target = actor;
-	mo->momx = (P_Random()-P_Random())<<9;
-	mo->momy = (P_Random()-P_Random())<<9;
-	mo->momz = FRACUNIT*2+(P_Random()<<6);
-	// Attach player mobj to bloody skull
-	player = actor->player;
-	actor->player = NULL;
-	mo->player = player;
-	mo->health = actor->health;
-	mo->angle = actor->angle;
-	player->mo = mo;
-	player->lookdir = 0;
-	player->damagecount = 32;
+    actor->flags &= ~MF_SOLID;
+    mo = P_SpawnMobj(actor->x, actor->y, actor->z + 48 * FRACUNIT,
+                     MT_BLOODYSKULL);
+    //mo->target = actor;
+    mo->momx = (P_Random() - P_Random()) << 9;
+    mo->momy = (P_Random() - P_Random()) << 9;
+    mo->momz = FRACUNIT * 2 + (P_Random() << 6);
+    // Attach player mobj to bloody skull
+    player = actor->player;
+    actor->player = NULL;
+    mo->player = player;
+    mo->health = actor->health;
+    mo->angle = actor->angle;
+    player->mo = mo;
+    player->lookdir = 0;
+    player->damagecount = 32;
 }
 
 //----------------------------------------------------------------------------
@@ -2528,12 +2576,12 @@ void A_SkullPop(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_CheckSkullFloor(mobj_t *actor)
+void A_CheckSkullFloor(mobj_t * actor)
 {
-	if(actor->z <= actor->floorz)
-	{
-		P_SetMobjState(actor, S_BLOODYSKULLX1);
-	}
+    if (actor->z <= actor->floorz)
+    {
+        P_SetMobjState(actor, S_BLOODYSKULLX1);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2542,12 +2590,12 @@ void A_CheckSkullFloor(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_CheckSkullDone(mobj_t *actor)
+void A_CheckSkullDone(mobj_t * actor)
 {
-	if(actor->special2 == 666)
-	{
-		P_SetMobjState(actor, S_BLOODYSKULLX2);
-	}
+    if (actor->special2 == 666)
+    {
+        P_SetMobjState(actor, S_BLOODYSKULLX2);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2556,12 +2604,12 @@ void A_CheckSkullDone(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_CheckBurnGone(mobj_t *actor)
+void A_CheckBurnGone(mobj_t * actor)
 {
-	if(actor->special2 == 666)
-	{
-		P_SetMobjState(actor, S_PLAY_FDTH20);
-	}
+    if (actor->special2 == 666)
+    {
+        P_SetMobjState(actor, S_PLAY_FDTH20);
+    }
 }
 
 //----------------------------------------------------------------------------
@@ -2570,14 +2618,14 @@ void A_CheckBurnGone(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_FreeTargMobj(mobj_t *mo)
+void A_FreeTargMobj(mobj_t * mo)
 {
-	mo->momx = mo->momy = mo->momz = 0;
-	mo->z = mo->ceilingz+4*FRACUNIT;
-	mo->flags &= ~(MF_SHOOTABLE|MF_FLOAT|MF_SKULLFLY|MF_SOLID);
-	mo->flags |= MF_CORPSE|MF_DROPOFF|MF_NOGRAVITY;
-	mo->flags2 &= ~(MF2_PASSMOBJ|MF2_LOGRAV);
-	mo->player = NULL;
+    mo->momx = mo->momy = mo->momz = 0;
+    mo->z = mo->ceilingz + 4 * FRACUNIT;
+    mo->flags &= ~(MF_SHOOTABLE | MF_FLOAT | MF_SKULLFLY | MF_SOLID);
+    mo->flags |= MF_CORPSE | MF_DROPOFF | MF_NOGRAVITY;
+    mo->flags2 &= ~(MF2_PASSMOBJ | MF2_LOGRAV);
+    mo->player = NULL;
 }
 
 //----------------------------------------------------------------------------
@@ -2590,14 +2638,14 @@ void A_FreeTargMobj(mobj_t *mo)
 mobj_t *bodyque[BODYQUESIZE];
 int bodyqueslot;
 
-void A_AddPlayerCorpse(mobj_t *actor)
+void A_AddPlayerCorpse(mobj_t * actor)
 {
-	if(bodyqueslot >= BODYQUESIZE)
-	{ // Too many player corpses - remove an old one
-		P_RemoveMobj(bodyque[bodyqueslot%BODYQUESIZE]);
-	}
-	bodyque[bodyqueslot%BODYQUESIZE] = actor;
-	bodyqueslot++;
+    if (bodyqueslot >= BODYQUESIZE)
+    {                           // Too many player corpses - remove an old one
+        P_RemoveMobj(bodyque[bodyqueslot % BODYQUESIZE]);
+    }
+    bodyque[bodyqueslot % BODYQUESIZE] = actor;
+    bodyqueslot++;
 }
 
 //----------------------------------------------------------------------------
@@ -2606,9 +2654,9 @@ void A_AddPlayerCorpse(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_FlameSnd(mobj_t *actor)
+void A_FlameSnd(mobj_t * actor)
 {
-	S_StartSound(actor, sfx_hedat1); // Burn sound
+    S_StartSound(actor, sfx_hedat1);    // Burn sound
 }
 
 //----------------------------------------------------------------------------
@@ -2617,10 +2665,10 @@ void A_FlameSnd(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_HideThing(mobj_t *actor)
+void A_HideThing(mobj_t * actor)
 {
-	//P_UnsetThingPosition(actor);
-	actor->flags2 |= MF2_DONTDRAW;
+    //P_UnsetThingPosition(actor);
+    actor->flags2 |= MF2_DONTDRAW;
 }
 
 //----------------------------------------------------------------------------
@@ -2629,8 +2677,8 @@ void A_HideThing(mobj_t *actor)
 //
 //----------------------------------------------------------------------------
 
-void A_UnHideThing(mobj_t *actor)
+void A_UnHideThing(mobj_t * actor)
 {
-	//P_SetThingPosition(actor);
-	actor->flags2 &= ~MF2_DONTDRAW;
+    //P_SetThingPosition(actor);
+    actor->flags2 &= ~MF2_DONTDRAW;
 }