Cleanup. I removed the PLOT_PATHS blocks since they depended on some

functions we don't have, and since I didn't deem them useful to us. But
feel free to put them back if you like to.

I'd also like to take this opportunity to say that while I deeply admire
how smoothly BS2 handles the transition between stock animations (e.g.
walking) and special-purpose animations, it certainly needs an unholy
amount of code to do so.

svn-id: r10336

2 files changed, 1730 insertions, 1934 deletions

diff --git a/sword2/router.cpp b/sword2/router.cpp
index b6518c12c4..c136258cf5 100644
--- a/sword2/router.cpp
+++ b/sword2/router.cpp
@@ -17,21 +17,23 @@
  * $Header$
  */
 
-//--------------------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
 // ROUTER.CPP by James
-
-// A rehash of Jeremy's original jrouter.c, containing low-level system routines
-// for calculating routes between points inside a walk-grid, and constructing
-// walk animations from mega-sets.
-
-// jrouter.c undwent 2 major reworks from the original:
-// (1)	Restructured to allow more flexibility in the mega-sets, ie. more info taken from the walk-data
-//		- the new George & Nico mega-sets & walk-data were then tested & tweaked in the Sword1 system
+//
+// A rehash of Jeremy's original jrouter.c, containing low-level system
+// routines for calculating routes between points inside a walk-grid, and
+// constructing walk animations from mega-sets.
+//
+// jrouter.c underwent 2 major reworks from the original:
+// (1)	Restructured to allow more flexibility in the mega-sets, ie. more info
+//      taken from the walk-data
+//	- the new George & Nico mega-sets & walk-data were then tested &
+//        tweaked in the Sword1 system
 // (2)	Updated for the new Sword2 system, ie. new object structures
-//		- now compatible with Sword2, the essential code already having been tested
-
-//--------------------------------------------------------------------------------------
-
+//	- now compatible with Sword2, the essential code already having been
+//        tested
+//
+// ---------------------------------------------------------------------------
 
 /****************************************************************************
  *    JROUTER.C				polygon router with modular walks
@@ -69,18 +71,12 @@
  *  TOTALLY REHASHED BY JAMES FOR NEW MEGAS USING OLD SYSTEM
  *  THEN REINCARNATED BY JAMES FOR NEW MEGAS USING NEW SYSTEM
  *
- ****************************************************************************
  ****************************************************************************/
 
-
-//#define PLOT_PATHS 1
-
- 
 /*
  * Include Files
  */
 
-
 #include "stdafx.h"
 #include "driver/driver96.h"
 #include "console.h"
@@ -93,161 +89,154 @@
 #include "resman.h"
 #include "router.h"
 
-//#ifdef PLOT_PATHS
-//#include "grengine.h"
-//#endif
-
 #define MAX_FRAMES_PER_CYCLE	16
-#define NO_DIRECTIONS			8
-#define MAX_FRAMES_PER_CHAR		(MAX_FRAMES_PER_CYCLE * NO_DIRECTIONS)
-#define ROUTE_END_FLAG			255
-
-
-
+#define NO_DIRECTIONS		8
+#define MAX_FRAMES_PER_CHAR	(MAX_FRAMES_PER_CYCLE * NO_DIRECTIONS)
+#define ROUTE_END_FLAG		255
 
 //---------------------------------------
 // TEMP!
-int8 forceSlidy;	// 1 = force the use of slidy router (so solid path not used when ending walk in ANY direction)
+// 1 = force the use of slidy router (so solid path not used when ending walk
+// in ANY direction)
+int8 forceSlidy;
 //---------------------------------------
 
 /*
  * Type Defines
  */
 
-#define	O_WALKANIM_SIZE	600			// max number of nodes in router output
-#define	O_GRID_SIZE		200			// max 200 lines & 200 points
-#define	EXTRA_GRID_SIZE	20			// max 20 lines & 20 points
-#define	O_ROUTE_SIZE	50			// max number of modules in a route
-
-typedef	struct
-{
-	int32	x;
-	int32	y;
-	int32	dirS;
-	int32	dirD;
+#define	O_WALKANIM_SIZE		600	// max number of nodes in router output
+#define	O_GRID_SIZE		200	// max 200 lines & 200 points
+#define	EXTRA_GRID_SIZE		20	// max 20 lines & 20 points
+#define	O_ROUTE_SIZE		50	// max number of modules in a route
+
+typedef	struct {
+	int32 x;
+	int32 y;
+	int32 dirS;
+	int32 dirD;
 } _routeData;
 
-typedef	struct
-{
-	int32	x;
-	int32	y;
-	int32	dir;
-	int32	num;
+typedef	struct {
+	int32 x;
+	int32 y;
+	int32 dir;
+	int32 num;
 } _pathData;
 
-
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
 // Function prototypes
 
-static int32	GetRoute(void);
-static void		ExtractRoute(void);
-static void		LoadWalkGrid(void);
-static void		SetUpWalkGrid(Object_mega *ob_mega, int32 x, int32 y, int32 dir);
-static void		LoadWalkData(Object_walkdata *ob_walkdata);
-static void		PlotCross(int16 x, int16 y, uint8 colour);
-
-static int32	Scan(int32);     
-static int32	NewCheck(int32, int32 , int32 , int32 , int32);
-static int32	LineCheck(int32 , int32 , int32 , int32);
-static int32	VertCheck(int32 , int32 , int32);
-static int32	HorizCheck(int32 , int32 , int32);
-static int32	Check(int32 , int32 , int32 , int32);
-static int32	CheckTarget(int32 , int32);
-
-static int32	SmoothestPath();
-static int32	SlidyPath();
-static int32	SolidPath();
-
-static int32	SmoothCheck(int32 best, int32 p, int32 dirS, int32 dirD);
-
-static int32	AddSlowInFrames(_walkData *walkAnim);
-static void		AddSlowOutFrames(_walkData *walkAnim);
-static void		SlidyWalkAnimator(_walkData *walkAnim);
-static int32	SolidWalkAnimator(_walkData *walkAnim);
-#ifdef PLOT_PATHS
-static void		RouteLine(int32 x1,int32 y1,int32 x2,int32 y2 ,int32 colour);
-#endif
+static int32 GetRoute(void);
+static void ExtractRoute(void);
+static void LoadWalkGrid(void);
+static void SetUpWalkGrid(Object_mega *ob_mega, int32 x, int32 y, int32 dir);
+static void LoadWalkData(Object_walkdata *ob_walkdata);
+static void PlotCross(int16 x, int16 y, uint8 colour);
+
+static int32 Scan(int32 level);
+static int32 NewCheck(int32 status, int32 x1, int32 y1, int32 x2, int32 y2);
+static int32 LineCheck(int32 x1, int32 x2, int32 y1, int32 y2);
+static int32 VertCheck(int32 x, int32 y1, int32 y2);
+static int32 HorizCheck(int32 x1, int32 y, int32 x2);
+static int32 Check(int32 x1, int32 y1, int32 x2, int32 y2);
+static int32 CheckTarget(int32 x, int32 y);
+
+static int32 SmoothestPath(void);
+static int32 SlidyPath(void);
+static int32 SolidPath(void);
+
+static int32 SmoothCheck(int32 best, int32 p, int32 dirS, int32 dirD);
+
+static int32 AddSlowInFrames(_walkData *walkAnim);
+static void AddSlowOutFrames(_walkData *walkAnim);
+static void SlidyWalkAnimator(_walkData *walkAnim);
+static int32 SolidWalkAnimator(_walkData *walkAnim);
 
-//--------------------------------------------------------------------------------------
 #define MAX_WALKGRIDS		10
 
-static int32	walkGridList[MAX_WALKGRIDS];
+static int32 walkGridList[MAX_WALKGRIDS];
 
-//--------------------------------------------------------------------------------------
-#define TOTAL_ROUTE_SLOTS	2				// because we only have 2 megas in the game!
+// because we only have 2 megas in the game!
+#define TOTAL_ROUTE_SLOTS	2
 
-static mem		*route_slots[TOTAL_ROUTE_SLOTS];	// stores pointers to mem blocks containing routes created & used by megas (NULL if slot not in use)
+// stores pointers to mem blocks containing routes created & used by megas
+// (NULL if slot not in use)
+static mem *route_slots[TOTAL_ROUTE_SLOTS];
 
-//--------------------------------------------------------------------------------------
 // Local Variables
 
-static	int32		nbars;
-static	int32		nnodes;
-static	_barData	bars[O_GRID_SIZE+EXTRA_GRID_SIZE];	// because extra bars will be copied into here afer walkgrid loaded
-static	_nodeData	node[O_GRID_SIZE+EXTRA_GRID_SIZE];
+static int32 nbars;
+static int32 nnodes;
+
+// because extra bars will be copied into here afer walkgrid loaded
+static _barData bars[O_GRID_SIZE+EXTRA_GRID_SIZE];
+
+static _nodeData node[O_GRID_SIZE+EXTRA_GRID_SIZE];
 
-// area for extra route data to block parts of floors and enable routing round mega charaters
-static	int32		nExtraBars	= 0;
-static	int32		nExtraNodes	= 0;
-static	_barData		extraBars[EXTRA_GRID_SIZE];
-static	_nodeData	extraNode[EXTRA_GRID_SIZE];
+// area for extra route data to block parts of floors and enable routing
+// round mega charaters
 
-static	int32	startX;
-static	int32	startY;
-static	int32	startDir;
-static	int32	targetX;
-static	int32	targetY;
-static	int32	targetDir;
-static	int32	scaleA;
-static	int32	scaleB;
-static	_routeData	route[O_ROUTE_SIZE];
-static	_pathData	smoothPath[O_ROUTE_SIZE];
-static	_pathData	modularPath[O_ROUTE_SIZE];
-static	int32   	routeLength;
+static int32 nExtraBars = 0;
+static int32 nExtraNodes = 0;
+static _barData extraBars[EXTRA_GRID_SIZE];
+static _nodeData extraNode[EXTRA_GRID_SIZE];
 
+static int32 startX;
+static int32 startY;
+static int32 startDir;
+static int32 targetX;
+static int32 targetY;
+static int32 targetDir;
+static int32 scaleA;
+static int32 scaleB;
+static _routeData route[O_ROUTE_SIZE];
+static _pathData smoothPath[O_ROUTE_SIZE];
+static _pathData modularPath[O_ROUTE_SIZE];
+static int32 routeLength;
 
-static	int32	framesPerStep;
-static	int32	framesPerChar;
+static int32 framesPerStep;
+static int32 framesPerChar;
 
-static	uint8	nWalkFrames;				// no. of frames per walk cycle
-static	uint8	usingStandingTurnFrames;	// any standing turn frames?
-static	uint8	usingWalkingTurnFrames;		// any walking turn frames?
-static	uint8	usingSlowInFrames;			// any slow-in frames?
-static	uint8	usingSlowOutFrames;			// any slow-out frames?
-static	int32 	dx[NO_DIRECTIONS + MAX_FRAMES_PER_CHAR];
-static	int32	dy[NO_DIRECTIONS + MAX_FRAMES_PER_CHAR];
-static	int8	modX[NO_DIRECTIONS];
-static	int8	modY[NO_DIRECTIONS];
-static	int32	diagonalx = 0;
-static	int32	diagonaly = 0;
+static uint8 nWalkFrames;			// no. of frames per walk cycle
+static uint8 usingStandingTurnFrames;		// any standing turn frames?
+static uint8 usingWalkingTurnFrames;		// any walking turn frames?
+static uint8 usingSlowInFrames;			// any slow-in frames?
+static uint8 usingSlowOutFrames;		// any slow-out frames?
+static int32 dx[NO_DIRECTIONS + MAX_FRAMES_PER_CHAR];
+static int32 dy[NO_DIRECTIONS + MAX_FRAMES_PER_CHAR];
+static int8 modX[NO_DIRECTIONS];
+static int8 modY[NO_DIRECTIONS];
+static int32 diagonalx = 0;
+static int32 diagonaly = 0;
 
-static	int32	firstStandFrame;
+static int32 firstStandFrame;
 
-static	int32	firstStandingTurnLeftFrame;
-static	int32	firstStandingTurnRightFrame;
+static int32 firstStandingTurnLeftFrame;
+static int32 firstStandingTurnRightFrame;
 
-static	int32	firstWalkingTurnLeftFrame;	// left walking turn
-static	int32	firstWalkingTurnRightFrame; // right walking turn
+static int32 firstWalkingTurnLeftFrame;		// left walking turn
+static int32 firstWalkingTurnRightFrame;	// right walking turn
 
-static	uint32	firstSlowInFrame[NO_DIRECTIONS];
-static	uint32	numberOfSlowInFrames[NO_DIRECTIONS];
+static uint32 firstSlowInFrame[NO_DIRECTIONS];
+static uint32 numberOfSlowInFrames[NO_DIRECTIONS];
 
-static	uint32	leadingLeg[NO_DIRECTIONS];
+static uint32 leadingLeg[NO_DIRECTIONS];
 
-static	int32	firstSlowOutFrame;
-static	int32	numberOfSlowOutFrames;	// number of slow-out frames on for each leading-leg in each direction
+static int32 firstSlowOutFrame;
 
+// number of slow-out frames on for each leading-leg in each direction
+// ie. total number of slow-out frames = (numberOfSlowOutFrames * 2 *
+// NO_DIRECTIONS)
 
-static	int32	stepCount;
+static int32 numberOfSlowOutFrames;
 
-static	int32	moduleX;
-static	int32	moduleY;
-static	int32	currentDir;
-static	int32	lastCount;
-static	int32	frame;
+static int32 stepCount;
 
-// ie. total number of slow-out frames = (numberOfSlowOutFrames * 2 * NO_DIRECTIONS)
+static int32 moduleX;
+static int32 moduleY;
+static int32 currentDir;
+static int32 lastCount;
+static int32 frame;
 
 /*
  *    CODE
@@ -255,406 +244,383 @@ static	int32	frame;
 
 // **************************************************************************
 
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
-uint8 CheckForCollision(void)
-{
-//	static uint32 player_pc;
-//	static uint32 non_player_pc;
-
-
-	uint8 collision=0;
-
-	return (collision);
-}
-//--------------------------------------------------------------------------------------
-uint8 ReturnSlotNo(uint32 megaId)
-{
-	if (ID==CUR_PLAYER_ID)	// George (8)
-		return(0);
-	else					// One of Nico's mega id's
-		return(1);
+uint8 ReturnSlotNo(uint32 megaId) {
+	if (ID == CUR_PLAYER_ID) {
+		// George (8)
+		return 0;
+	} else {
+		// One of Nico's mega id's
+		return 1;
+	}
 }
-//--------------------------------------------------------------------------------------
-void AllocateRouteMem(void)
-{
-//	uint8 slotNo=0;
+
+void AllocateRouteMem(void) {
 	uint8 slotNo;
 
-	//------------------------------------------
-	// removed (James23June96)
-	/*
-	while (route_slots[slotNo] > 0)
-	{
-		slotNo++;
-
-	#ifdef _SWORD2_DEBUG
-		if (slotNo == TOTAL_ROUTE_SLOTS)
-			Con_fatal_error("ERROR: route_slots[] full in AllocateRouteMem() (%s line %u)",__FILE__,__LINE__);
-	#endif
-	}
-	*/
-	//------------------------------------------
 	// added (James23June96)
-	// Player character always always slot 0, while the other mega (normally Nico) always uses slot 1
-	// Better this way, so that if mega object removed from memory while in middle of route,
-	// the old route will be safely cleared from memory just before they create a new one
+	// Player character always always slot 0, while the other mega
+	// (normally Nico) always uses slot 1
+	// Better this way, so that if mega object removed from memory while
+	// in middle of route, the old route will be safely cleared from
+	// memory just before they create a new one
 
 	slotNo = ReturnSlotNo(ID); 
 
 	// if this slot is already used, then it can't be needed any more
 	// because this id is creating a new route!
+
 	if (route_slots[slotNo])
-	{
 		FreeRouteMem();
-	}
-	//------------------------------------------
 
-	route_slots[slotNo] = Twalloc( sizeof(_walkData)*O_WALKANIM_SIZE, MEM_locked, UID_walk_anim );
-	// 12000 bytes were used for this in Sword1 mega compacts, based on 20 bytes per '_walkData' frame
+	route_slots[slotNo] = Twalloc(sizeof(_walkData) * O_WALKANIM_SIZE, MEM_locked, UID_walk_anim);
+
+	// 12000 bytes were used for this in Sword1 mega compacts, based on
+	// 20 bytes per '_walkData' frame
 	// ie. allowing for 600 frames including end-marker
 	// Now '_walkData' is 8 bytes, so 8*600 = 4800 bytes.
-	// Note that a 600 frame walk lasts about 48 seconds! (600fps / 12.5s = 48s)
+	// Note that a 600 frame walk lasts about 48 seconds!
+	// (600fps / 12.5s = 48s)
 
-//	megaObject->route_slot_id = slotNo+1;	// mega keeps note of which slot contains the pointer to it's walk animation mem block
-											// +1 so that '0' can mean "not walking"
+	// mega keeps note of which slot contains the pointer to it's walk
+	// animation mem block
+	// +1 so that '0' can mean "not walking"
+	// megaObject->route_slot_id = slotNo + 1;
 }
-//--------------------------------------------------------------------------------------
-_walkData* LockRouteMem(void)
-{
+
+_walkData* LockRouteMem(void) {
 	uint8 slotNo = ReturnSlotNo(ID); 
 	
-	Lock_mem( route_slots[slotNo] );
-	return (_walkData *)route_slots[slotNo]->ad;
+	Lock_mem(route_slots[slotNo]);
+	return (_walkData *) route_slots[slotNo]->ad;
 }
-//--------------------------------------------------------------------------------------
-void FloatRouteMem(void)
-{
+
+void FloatRouteMem(void) {
 	uint8 slotNo = ReturnSlotNo(ID); 
 
-	Float_mem( route_slots[slotNo] );
+	Float_mem(route_slots[slotNo]);
 }
-//--------------------------------------------------------------------------------------
-void FreeRouteMem(void)
-{
+
+void FreeRouteMem(void) {
 	uint8 slotNo = ReturnSlotNo(ID); 
 
-	Free_mem( route_slots[slotNo] );	// free the mem block pointed to from this entry of route_slots[]
-	route_slots[slotNo] = NULL;			// clear this route_slots[] entry
+	// free the mem block pointed to from this entry of route_slots[]
+
+	Free_mem(route_slots[slotNo]);
+	route_slots[slotNo] = NULL;
 }
-//--------------------------------------------------------------------------------------
-void FreeAllRouteMem(void)
-{
-	uint8 slotNo;
 
-	for (slotNo=0; slotNo < TOTAL_ROUTE_SLOTS; slotNo++)
-	{
-		if (route_slots[slotNo])
-		{
-			Free_mem( route_slots[slotNo] );	// free the mem block pointed to from this entry of route_slots[]
+void FreeAllRouteMem(void) {
+	for (int slotNo = 0; slotNo < TOTAL_ROUTE_SLOTS; slotNo++) {
+		if (route_slots[slotNo]) {
+			// free the mem block pointed to from this entry of
+			// route_slots[]
+			Free_mem(route_slots[slotNo]);
 			route_slots[slotNo] = NULL;
 		}
 	}
 }
-//--------------------------------------------------------------------------------------
-//--------------------------------------------------------------------------------------
-
-// **************************************************************************
-// **************************************************************************
-// **************************************************************************
-// **************************************************************************
-
-int32 RouteFinder(Object_mega *ob_mega, Object_walkdata *ob_walkdata, int32 x, int32 y, int32 dir)
-{
-/****************************************************************************
- *    RouteFinder.C				polygon router with modular walks
- *    		   							21 august 94  
- *    3  november 94  
- *		RouteFinder creates a list of modules that enables HardWalk to create
- *		an animation list.
- *
- *    RouteFinder currently works by scanning grid data and coming up with a ROUTE
- *    as a series of way points(nodes), the smoothest eight directional PATH
- * 		through these nodes is then found, this information is made available to
- *		HardWalk for a WALK to be created to fit the PATH.
- *    
- *    30 november 94 return values modified
- *    
- *    return 	0 = failed to find a route
- *    
- *    				1 = found a route
- *
- *    				2 = mega already at target
- *    
- ****************************************************************************/
 
-	int32		routeFlag = 0;
-	int32		solidFlag = 0;
+int32 RouteFinder(Object_mega *ob_mega, Object_walkdata *ob_walkdata, int32 x, int32 y, int32 dir) {
+	/*********************************************************************
+	 * RouteFinder.C		polygon router with modular walks
+	 * 						21 august 94  
+	 *						3  november 94  
+	 * RouteFinder creates a list of modules that enables HardWalk to
+	 * create an animation list.
+	 *
+	 * RouteFinder currently works by scanning grid data and coming up
+	 * with a ROUTE as a series of way points(nodes), the smoothest eight
+	 * directional PATH through these nodes is then found, this
+	 * information is made available to HardWalk for a WALK to be created
+	 * to fit the PATH.
+	 *    
+	 * 30 november 94 return values modified
+	 *    
+	 * return	0 = failed to find a route
+	 *    
+	 *    		1 = found a route
+	 *
+	 *    		2 = mega already at target
+	 *    
+	 *********************************************************************/
+
+	int32 routeFlag = 0;
+	int32 solidFlag = 0;
 	_walkData *walkAnim;
 
-//	megaId = id;
-
+	// megaId = id;
 
 	SetUpWalkGrid(ob_mega, x, y, dir);
 	LoadWalkData(ob_walkdata);
 
-	walkAnim = LockRouteMem();	// lock the _walkData array (NB. AFTER loading walkgrid & walkdata!)
+	// lock the _walkData array (NB. AFTER loading walkgrid & walkdata!)
+	walkAnim = LockRouteMem();
 
-// **************************************************************************
-// All route data now loaded start finding a route
-// **************************************************************************
-// **************************************************************************
-// Check if we can get a route through the floor 		changed 12 Oct95 JPS 
-// **************************************************************************
+	// All route data now loaded start finding a route
+
+	// Check if we can get a route through the floor. changed 12 Oct95 JPS 
 
 	routeFlag = GetRoute();
 
+	if (routeFlag == 2) {
+		// special case for zero length route
 
-	if (routeFlag == 2)  //special case for zero length route
-	{
-		if (targetDir >7)// if target direction specified as any
-		{
+		// if target direction specified as any
+		if (targetDir > 7)
 			targetDir = startDir;
-		} 
-		// just a turn on the spot is required set an end module for the route let the animator deal with it
+
+		// just a turn on the spot is required set an end module for
+		// the route let the animator deal with it
 		// modularPath is normally set by ExtractRoute
-		modularPath[0].dir	= startDir;
- 		modularPath[0].num	= 0;
- 		modularPath[0].x	= startX;
- 		modularPath[0].y	= startY;
-		modularPath[1].dir	= targetDir;
- 		modularPath[1].num	= 0;
- 		modularPath[1].x	= startX;
- 		modularPath[1].y	= startY;
- 		modularPath[2].dir	= 9;
- 		modularPath[2].num	= ROUTE_END_FLAG;
+
+		modularPath[0].dir = startDir;
+ 		modularPath[0].num = 0;
+ 		modularPath[0].x = startX;
+ 		modularPath[0].y = startY;
+		modularPath[1].dir = targetDir;
+ 		modularPath[1].num = 0;
+ 		modularPath[1].x = startX;
+ 		modularPath[1].y = startY;
+ 		modularPath[2].dir = 9;
+ 		modularPath[2].num = ROUTE_END_FLAG;
 
  		SlidyWalkAnimator(walkAnim);
  		routeFlag = 2;
-	}
-	else if (routeFlag == 1) // a normal route
-	{
-		SmoothestPath();//Converts the route to an exact path
-																			// The Route had waypoints and direction options
-																			// The Path is an exact set of lines in 8 directions that reach the target.
-																			// The path is in module format, but steps taken in each direction are not accurate   
+	} else if (routeFlag == 1) {
+		// a normal route
+
+		// Convert the route to an exact path
+		SmoothestPath();
+
+		// The Route had waypoints and direction options
+
+		// The Path is an exact set of lines in 8 directions that
+		// reach the target.
+
+		// The path is in module format, but steps taken in each
+		// direction are not accurate
+
 		// if target dir = 8 then the walk isn't linked to an anim so 
-		// we can create a route without sliding and miss the exact target
+		// we can create a route without sliding and miss the exact
+		// target
+
+		if (!forceSlidy) {
+			if (targetDir == 8) {
+				// can end facing ANY direction (ie. exact end
+				// position not vital) - so use SOLID walk to
+				// avoid sliding to exact position
 
-		if (!forceSlidy)
-		{
-			if (targetDir == 8)	// can end facing ANY direction (ie. exact end position not vital) - so use SOLID walk to avoid sliding to exact position
-			{
 				SolidPath();
 				solidFlag = SolidWalkAnimator(walkAnim);
 			}
 		}
 
-		if(!solidFlag)	// if we failed to create a SOLID route, do a SLIDY one instead
-		{
+		if (!solidFlag) {
+			// if we failed to create a SOLID route, do a SLIDY
+			// one instead
+
 			SlidyPath();
 			SlidyWalkAnimator(walkAnim);
 		}
+	} else {
+		// Route didn't reach target so assume point was off the floor
+		// routeFlag = 0;
 	}
-	else // Route didn't reach target so assume point was off the floor
-	{
-//		routeFlag = 0;
-	}
-
-
-	#ifdef PLOT_PATHS
-		#ifdef _WIN32
-		RenderScreenGDK( screenDef.buffer, scroll_offset_x, scroll_offset_y, screenDef.width * XBLOCKSIZE );
-		#else
-		RenderOffScreenBuffer( scroll_offset_x, scroll_offset_y, SCREEN_WIDTH, SCREEN_DEPTH );
-		#endif
-
-		FlushMouseEvents();	// clear mouse buffer
-		while (!TestForMouseEvent());	// wait for a button press or release
-		FlushMouseEvents();	// clear mouse buffer again to prevent rapid fire!
-	#endif
-
 
    	FloatRouteMem();	// float the _walkData array again
 
 	return routeFlag;	// send back null route
 }
 
-/*******************************************************************************
- *******************************************************************************
- * 														GET A ROUTE
- *******************************************************************************
- *******************************************************************************/
-
-
-int32 GetRoute(void)
-{
- /****************************************************************************
-  *    GetRoute.C				extract a path from walk grid
-  *    		   							12 october 94  
-  *
-  *    GetRoute currently works by scanning grid data and coming up with a ROUTE
-  *    as a series of way points(nodes).
-	*		 static	_routeData			route[O_ROUTE_SIZE];
-  *    
-  *    return 	0 = failed to find a route
-  *    
-  *    				1 = found a route
-  *
-  *    				2 = mega already at target
-  *    
-  *    				3 = failed to find a route because target was on a line
-  *    
-  ****************************************************************************/
-	int32		routeGot = 0;
-	int32		level;
-	int32		changed;
-
-	if ((startX == targetX) && (startY == targetY)) 
+int32 GetRoute(void) {
+	/*********************************************************************
+	 * GetRoute.C				extract a path from walk grid
+	 *							12 october 94  
+	 *
+	 * GetRoute currently works by scanning grid data and coming up with
+	 * a ROUTE as a series of way points(nodes).
+	 *
+	 * static _routeData route[O_ROUTE_SIZE];
+	 *    
+	 * return 	0 = failed to find a route
+	 *    
+	 *		1 = found a route
+	 *
+	 *		2 = mega already at target
+	 *
+	 *		3 = failed to find a route because target was on a line
+	 *
+	 *********************************************************************/
+
+	int32 routeGot = 0;
+	int32 level;
+	int32 changed;
+
+	if (startX == targetX && startY == targetY)
 		routeGot = 2;
+	else {
+		// 'else' added by JEL (23jan96) otherwise 'routeGot' affected
+		// even when already set to '2' above - causing some 'turns'
+		// to walk downwards on the spot
+
+		// returns 3 if target on a line ( +- 1 pixel )
+		routeGot = CheckTarget(targetX,targetY);
+	}
 
-	else	// 'else' added by JEL (23jan96) otherwise 'routeGot' affected even when already set to '2' above - causing some 'turns' to walk downwards on the spot
-		routeGot = CheckTarget(targetX,targetY);// returns 3 if target on a line ( +- 1 pixel )
+	if (routeGot == 0) {
+		// still looking for a route check if target is within a pixel
+		// of a line 
 
+		// scan through the nodes linking each node to its nearest
+		// neighbour until no more nodes change
 
-	if (routeGot == 0) //still looking for a route check if target is within a pixel of a line 
-	{
-		// scan through the nodes linking each node to its nearest neighbour until no more nodes change
 		// This is the routine that finds a route using Scan()
+
 		level = 1;
-		do
-		{
+
+		do {
 			changed = Scan(level);
-			level =level + 1;
-		}
-		while(changed == 1);
+			level++;
+		} while(changed == 1);
 
 		// Check to see if the route reached the target
-		if (node[nnodes].dist < 9999)
-		{
+
+		if (node[nnodes].dist < 9999) {
+			// it did so extract the route as nodes and the
+			// directions to go between each node
+
 			routeGot = 1;
-			ExtractRoute();	// it did so extract the route as nodes and the directions to go between each node
-											// route.X,route.Y and route.Dir now hold all the route infomation with the target dir or route continuation
+			ExtractRoute();
+
+			// route.X,route.Y and route.Dir now hold all the
+			// route infomation with the target dir or route
+			// continuation
 		}
 	}
 
 	return routeGot;
 }
 
+// THE SLIDY PATH ROUTINES
+
+int32 SmoothestPath() {
+	// This is the second big part of the route finder and the the only
+	// bit that tries to be clever (the other bits are clever).
+	//
+	// This part of the autorouter creates a list of modules from a set of
+	// lines running across the screen. The task is complicated by two
+	// things:
+	//
+	// Firstly in choosing a route through the maze of nodes the routine
+	// tries to minimise the amount of each individual turn avoiding 90
+	// degree and greater turns (where possible) and reduces the total
+	// number of turns (subject to two 45 degree turns being better than
+	// one 90 degree turn).
+	//
+	// Secondly when walking in a given direction the number of steps
+	// required to reach the end of that run is not calculated accurately.
+	// This is because I was unable to derive a function to relate number
+	// of steps taken between two points to the shrunken step size   
+
+	int32 p;     
+	int32 dirS;
+	int32 dirD;
+	int32 dS;
+	int32 dD;
+	int32 dSS;
+	int32 dSD;
+	int32 dDS;
+	int32 dDD;
+	int32 SS;
+	int32 SD;
+	int32 DS;
+	int32 DD;
+	int32 i;
+	int32 j;
+	int32 temp;
+	int32 steps;
+	int32 option;
+	int32 options;
+	int32 lastDir;
+	int32 nextDirS;
+	int32 nextDirD;
+	int32 tempturns[4];     
+	int32 turns[4];     
+	int32 turntable[NO_DIRECTIONS] = { 0, 1, 3, 5, 7, 5, 3, 1 };
 
-/*******************************************************************************
- *******************************************************************************
- * 														THE SLIDY PATH ROUTINES
- *******************************************************************************
- *******************************************************************************/
+	// route.X route.Y and route.Dir start at far end
 
+	smoothPath[0].x = startX;
+	smoothPath[0].y = startY;
+	smoothPath[0].dir = startDir;
+	smoothPath[0].num = 0;
 
-int32 SmoothestPath()
-{
-/*
- *	This is the second big part of the route finder and the the only bit that tries to be clever
- *	(the other bits are clever).
- *  This part of the autorouter creates a list of modules from a set of lines running across the screen
- *	The task is complicated by two things;
- *	Firstly in choosing a route through the maze of nodes	the routine tries to minimise	the amount of each
- *	individual turn avoiding 90 degree and greater turns (where possible) and reduces the total number of
- *	turns (subject to two 45 degree turns being better than one 90 degree turn).
- *  Secondly when walking in a given direction the number of steps required to reach the end of that run
- *	is not calculated accurately. This is because I was unable to derive a function to relate number of
- *	steps taken between two points to the shrunken step size   
- *
- */
-	int32	p;     
-	int32	dirS;
-	int32	dirD;
-	int32	dS;
-	int32	dD;
-	int32	dSS;
-	int32	dSD;
-	int32	dDS;
-	int32	dDD;
-	int32	SS;
-	int32	SD;
-	int32	DS;
-	int32	DD;
-	int32	i;
-	int32	j;
-	int32	temp;
-	int32	steps;
-	int32	option;
-	int32	options;
-	int32	lastDir;
-	int32	nextDirS;
-	int32	nextDirD;
-	int32	tempturns[4];     
-	int32	turns[4];     
-	int32	turntable[NO_DIRECTIONS] = {0,1,3,5,7,5,3,1};
+	p = 0;
+	lastDir = startDir;
 
-	// route.X route.Y and route.Dir start at far end
-	smoothPath[0].x		= startX;
-	smoothPath[0].y		= startY;
-	smoothPath[0].dir	= startDir;
-	smoothPath[0].num	= 0;
-  p = 0;
-  lastDir = startDir;
-  // for each section of the route
-  do
-  {     
+	// for each section of the route
 
+	do {     
 		dirS = route[p].dirS;
 		dirD = route[p].dirD;
 		nextDirS = route[p+1].dirS;
 		nextDirD = route[p+1].dirD;
 
-		// Check directions into and out of a pair of nodes
-		// going in
+		// Check directions into and out of a pair of nodes going in
 		dS = dirS - lastDir;
-		if ( dS < 0)
+		if (dS < 0)
 			dS = dS + NO_DIRECTIONS;
 
 		dD = dirD - lastDir;
-		if ( dD < 0)
+		if (dD < 0)
 			dD = dD + NO_DIRECTIONS;
 
 		// coming out
 		dSS = dirS - nextDirS;
-		if ( dSS < 0)
+		if (dSS < 0)
 			dSS = dSS + NO_DIRECTIONS;
 
 		dDD = dirD - nextDirD;
-		if ( dDD < 0)
+		if (dDD < 0)
 			dDD = dDD + NO_DIRECTIONS;
 
 		dSD = dirS - nextDirD;
-		if ( dSD < 0)
+		if (dSD < 0)
 			dSD = dSD + NO_DIRECTIONS;
 
 		dDS = dirD - nextDirS;
-		if ( dDS < 0)
+		if (dDS < 0)
 			dDS = dDS + NO_DIRECTIONS;
 
-		// Determine the amount of turning involved in each possible path 
-		dS	= turntable[dS];
-		dD	= turntable[dD];
+		// Determine the amount of turning involved in each possible
+		// path 
+
+		dS = turntable[dS];
+		dD = turntable[dD];
 		dSS = turntable[dSS];
 		dDD = turntable[dDD];
-		dSD	= turntable[dSD];
-		dDS	= turntable[dDS];
-		// get the best path out ie assume next section uses best direction 
+		dSD = turntable[dSD];
+		dDS = turntable[dDS];
+
+		// get the best path out ie assume next section uses best
+		// direction 
+
 		if (dSD < dSS)
-		{
 			dSS = dSD;
-		}
+
 		if (dDS < dDD)
-		{
 			dDD = dDS;
-		}
-		// rate each option
-		SS = dS + dSS + 3;		// Split routes look crap so weight against them
+
+		// Rate each option. Split routes look crap so weight against
+		// them
+
+		SS = dS + dSS + 3;
 		SD = dS + dDD;
 		DS = dD + dSS;
 		DD = dD + dDD + 3;
-		// set up turns as a sorted	array of the turn values
+
+		// set up turns as a sorted array of the turn values
+
 		tempturns[0] = SS;
 		turns[0] = 0;
 		tempturns[1] = SD;
@@ -664,124 +630,96 @@ int32 SmoothestPath()
 		tempturns[3] = DD;
 		turns[3] = 3;
 		i = 0;
-		do 
-		{
-			j = 0;
-			do 
-			{
-				if (tempturns[j] > tempturns[j + 1])
-				{
-					temp			= turns[j];
-					turns[j]		= turns[j+1];
-					turns[j+1]		= temp;
-					temp			= tempturns[j];
-					tempturns[j]	= tempturns[j+1];
-					tempturns[j+1]	= temp;
+
+		for (i = 0; i < 3; i++) {
+			for (j = 0; j < 3; j++) {
+				if (tempturns[j] > tempturns[j + 1]) {
+					temp = turns[j];
+					turns[j] = turns[j + 1];
+					turns[j + 1] = temp;
+					temp = tempturns[j];
+					tempturns[j] = tempturns[j + 1];
+					tempturns[j + 1] = temp;
 				}
-				j = j + 1;
 			}
-			while (j < 3); 
-			i = i + 1;
 		}
-		while (i < 3);
 
-		// best option matched in order of the priority we would like to see on the screen
-		// but each option must be checked to see if it can be walked
+		// best option matched in order of the priority we would like
+		// to see on the screen but each option must be checked to see
+		// if it can be walked
 
 		options = NewCheck(1, route[p].x, route[p].y, route[p + 1].x, route[p + 1].y);
 
 #ifdef _SWORD2_DEBUG
-		if (options == 0)
-		{
-			Zdebug("BestTurns fail %d %d %d %d",route[p].x, route[p].y, route[p + 1].x, route[p + 1].y);
-			Zdebug("BestTurns fail %d %d %d %d",turns[0],turns[1],turns[2],options);
-			Con_fatal_error("BestTurns failed (%s line %u)",__FILE__,__LINE__);
+		if (options == 0) {
+			Zdebug("BestTurns fail %d %d %d %d", route[p].x, route[p].y, route[p + 1].x, route[p + 1].y);
+			Zdebug("BestTurns fail %d %d %d %d", turns[0], turns[1], turns[2], options);
+			Con_fatal_error("BestTurns failed (%s line %u)", __FILE__, __LINE__);
 		}
 #endif
 
 		i = 0; 
 		steps = 0; 
-		do
-		{
+
+		do {
 			option = 1 << turns[i];
 			if (option & options)
-				steps = SmoothCheck(turns[i],p,dirS,dirD);
-			i = i + 1;
-		}
-		while ((steps == 0) && (i < 4));
-
-#ifdef PLOT_PATHS	// plot the best path
-	if (steps != 0)
-	{
-		i = 0; 
-		do
-		{
-			RouteLine(smoothPath[i].x, smoothPath[i].y, smoothPath[i+1].x, smoothPath[i+1].y, 228);
-			i = i + 1;
-		}
-		while (i < steps);
-	}
-#endif
-
+				steps = SmoothCheck(turns[i], p, dirS, dirD);
+			i++;
+		} while (steps == 0 && i < 4);
 
 #ifdef _SWORD2_DEBUG
-		if (steps == 0)
-		{
-			Zdebug("BestTurns failed %d %d %d %d",route[p].x, route[p].y, route[p + 1].x, route[p + 1].y);
-			Zdebug("BestTurns failed %d %d %d %d",turns[0],turns[1],turns[2],options);
-			Con_fatal_error("BestTurns failed (%s line %u)",__FILE__,__LINE__);
+		if (steps == 0) {
+			Zdebug("BestTurns failed %d %d %d %d", route[p].x, route[p].y, route[p + 1].x, route[p + 1].y);
+			Zdebug("BestTurns failed %d %d %d %d", turns[0], turns[1], turns[2], options);
+			Con_fatal_error("BestTurns failed (%s line %u)", __FILE__, __LINE__);
 		}
 #endif
 
 		// route.X route.Y route.dir and bestTurns start at far end
-		p = p + 1;
+		p++;
+	} while (p < (routeLength));
 
+	// best turns will end heading as near as possible to target dir rest
+	// is down to anim for now
 
-	}
-	while (p < (routeLength));
-	// best turns will end heading as near as possible to target dir rest is down to anim for now
 	smoothPath[steps].dir = 9;
 	smoothPath[steps].num = ROUTE_END_FLAG;
-		return 1;				 
+	return 1;				 
 }
 
-
-
-
-int32 SmoothCheck(int32 best, int32 p, int32 dirS, int32 dirD)
-/****************************************************************************
- *	Slip sliding away
- *  This path checker checks to see if a walk that exactly follows the path
- *  would be valid. This should be inherently true for atleast one of the turn
- *	options.
- *  No longer checks the data it only creates the smoothPath array JPS
- ****************************************************************************/
-{
-	static	int32  k;   
-	int32	x;   
-	int32	y;   
-	int32	x2;   
-	int32	y2;   
-	int32	ldx;   
-	int32	ldy;   
-	int32	dsx;
-	int32	dsy;
-	int32	ddx;
-	int32	ddy;
-	int32	dirX;
-	int32	dirY;
-	int32	ss0;
-	int32	ss1;
-	int32	ss2;
-	int32	sd0;
-	int32	sd1;
-	int32	sd2;
-
+int32 SmoothCheck(int32 best, int32 p, int32 dirS, int32 dirD) {
+	/*********************************************************************
+	 * Slip sliding away
+	 * This path checker checks to see if a walk that exactly follows the
+	 * path would be valid. This should be inherently true for atleast one
+	 * of the turn options.
+	 * No longer checks the data it only creates the smoothPath array JPS
+	 *********************************************************************/
+
+	static int32 k;   
+	int32 x;
+	int32 y;
+	int32 x2;
+	int32 y2;
+	int32 ldx;
+	int32 ldy;
+	int32 dsx;
+	int32 dsy;
+	int32 ddx;
+	int32 ddy;
+	int32 dirX;
+	int32 dirY;
+	int32 ss0;
+	int32 ss1;
+	int32 ss2;
+	int32 sd0;
+	int32 sd1;
+	int32 sd2;
 
 	if (p == 0)
-	{
 		k = 1;
-	}
+
 	x = route[p].x;
 	y = route[p].y;
 	x2 = route[p + 1].x;
@@ -790,110 +728,106 @@ int32 SmoothCheck(int32 best, int32 p, int32 dirS, int32 dirD)
 	ldy = y2 - y;
 	dirX = 1;
 	dirY = 1;
-	if (ldx < 0)
-	{
+
+	if (ldx < 0) {
 		ldx = -ldx;
 		dirX = -1;
 	}
 
-	if (ldy < 0)
-	{
+	if (ldy < 0) {
 		ldy = -ldy;
 		dirY = -1;
 	}
 
-// set up sd0-ss2 to reflect possible movement in each direction
-	if ((dirS == 0) || (dirS == 4))// vert and diag
-	{
+	// set up sd0-ss2 to reflect possible movement in each direction
+
+	if (dirS == 0 || dirS == 4) {	// vert and diag
 		ddx = ldx;
-		ddy = (ldx*diagonaly)/diagonalx;
+		ddy = (ldx * diagonaly) / diagonalx;
 		dsy = ldy - ddy;
 		ddx = ddx * dirX;
 		ddy = ddy * dirY;
 		dsy = dsy * dirY;
 		dsx = 0;
 
-		sd0 = (ddx + modX[dirD]/2)/ modX[dirD];
-		ss0 = (dsy + modY[dirS]/2) / modY[dirS];
-		sd1 = sd0/2;
-		ss1 = ss0/2;
+		sd0 = (ddx + modX[dirD] / 2) / modX[dirD];
+		ss0 = (dsy + modY[dirS] / 2) / modY[dirS];
+		sd1 = sd0 / 2;
+		ss1 = ss0 / 2;
 		sd2 = sd0 - sd1;
 		ss2 = ss0 - ss1;
-	}
-	else
-	{
+	} else {
 		ddy = ldy;
-		ddx = (ldy*diagonalx)/diagonaly;
+		ddx = (ldy * diagonalx) / diagonaly;
 		dsx = ldx - ddx;
 		ddy = ddy * dirY;
 		ddx = ddx * dirX;
 		dsx = dsx * dirX;
 		dsy = 0;
 
-		sd0 = (ddy + modY[dirD]/2)/ modY[dirD];
-		ss0 = (dsx + modX[dirS]/2)/ modX[dirS];
-		sd1 = sd0/2;
-		ss1 = ss0/2;
+		sd0 = (ddy + modY[dirD] / 2) / modY[dirD];
+		ss0 = (dsx + modX[dirS] / 2) / modX[dirS];
+		sd1 = sd0 / 2;
+		ss1 = ss0 / 2;
 		sd2 = sd0 - sd1;
 		ss2 = ss0 - ss1;
 	}
 
-	if (best == 0) //halfsquare, diagonal,	halfsquare
-	{
-		smoothPath[k].x		= x+dsx/2;
-		smoothPath[k].y		= y+dsy/2;
-		smoothPath[k].dir	= dirS;
-		smoothPath[k].num	= ss1;
+	if (best == 0) {	// halfsquare, diagonal, halfsquare
+		smoothPath[k].x = x + dsx / 2;
+		smoothPath[k].y = y + dsy / 2;
+		smoothPath[k].dir = dirS;
+		smoothPath[k].num = ss1;
 		k++;
-		smoothPath[k].x		= x+dsx/2+ddx;
-		smoothPath[k].y		= y+dsy/2+ddy;
-		smoothPath[k].dir	= dirD;
-		smoothPath[k].num	= sd0;
+
+		smoothPath[k].x = x + dsx / 2 + ddx;
+		smoothPath[k].y = y + dsy / 2 + ddy;
+		smoothPath[k].dir = dirD;
+		smoothPath[k].num = sd0;
 		k++;
-		smoothPath[k].x		= x+dsx+ddx;
-		smoothPath[k].y		= y+dsy+ddy;
-		smoothPath[k].dir	= dirS;
-		smoothPath[k].num	= ss2;
+
+		smoothPath[k].x = x + dsx + ddx;
+		smoothPath[k].y = y + dsy + ddy;
+		smoothPath[k].dir = dirS;
+		smoothPath[k].num = ss2;
 		k++;
-	}
-	else if (best == 1) //square, diagonal
-	{
-		smoothPath[k].x = x+dsx;
-		smoothPath[k].y = y+dsy;
+	} else if (best == 1) {	// square, diagonal
+		smoothPath[k].x = x + dsx;
+		smoothPath[k].y = y + dsy;
 		smoothPath[k].dir = dirS;
 		smoothPath[k].num = ss0;
 		k++;
+
 		smoothPath[k].x = x2;
 		smoothPath[k].y = y2;
 		smoothPath[k].dir = dirD;
 		smoothPath[k].num = sd0;
 		k++;
-	}
-	else if (best == 2) //diagonal square
-	{
-		smoothPath[k].x = x+ddx;
-		smoothPath[k].y = y+ddy;
+	} else if (best == 2) {	// diagonal square
+		smoothPath[k].x = x + ddx;
+		smoothPath[k].y = y + ddy;
 		smoothPath[k].dir = dirD;
 		smoothPath[k].num = sd0;
 		k++;
+
 		smoothPath[k].x = x2;
 		smoothPath[k].y = y2;
 		smoothPath[k].dir = dirS;
 		smoothPath[k].num = ss0;
 		k++;
-	}
-	else //halfdiagonal, square, halfdiagonal
-	{
-		smoothPath[k].x = x+ddx/2;
-		smoothPath[k].y = y+ddy/2;
+	} else {		// halfdiagonal, square, halfdiagonal
+		smoothPath[k].x = x + ddx / 2;
+		smoothPath[k].y = y + ddy / 2;
 		smoothPath[k].dir = dirD;
 		smoothPath[k].num = sd1;
 		k++;
-		smoothPath[k].x = x+dsx+ddx/2;
-		smoothPath[k].y = y+dsy+ddy/2;
+
+		smoothPath[k].x = x + dsx + ddx / 2;
+		smoothPath[k].y = y + dsy + ddy / 2;
 		smoothPath[k].dir = dirS;
 		smoothPath[k].num = ss0;
 		k++;
+
 		smoothPath[k].x = x2;
 		smoothPath[k].y = y2;
 		smoothPath[k].dir = dirD;
@@ -904,25 +838,27 @@ int32 SmoothCheck(int32 best, int32 p, int32 dirS, int32 dirD)
 	return k;	
 }
 
-int32 SlidyPath()
-{
-/****************************************************************************
- *  SlidyPath creates a path based on part steps with no sliding to get
- *	as near as possible to the target without any sliding this routine is
- *	currently unused, but is intended for use when just clicking about.
- *
- *	produce a module list from the line data
- *
- ****************************************************************************/
-int32 smooth;
-int32 slidy;
-int32 scale;
-int32 stepX;
-int32 stepY;
-int32 deltaX;
-int32 deltaY;
+int32 SlidyPath() {
+	/*********************************************************************
+	 * SlidyPath creates a path based on part steps with no sliding to get
+	 * as near as possible to the target without any sliding this routine
+	 * is currently unused, but is intended for use when just clicking
+	 * about.
+	 *
+	 * produce a module list from the line data
+	 *
+	 *********************************************************************/
+
+	int32 smooth;
+	int32 slidy;
+	int32 scale;
+	int32 stepX;
+	int32 stepY;
+	int32 deltaX;
+	int32 deltaY;
 
 	// strip out the short sections
+
 	slidy = 1;
 	smooth = 1;
 	modularPath[0].x = smoothPath[0].x;
@@ -930,204 +866,221 @@ int32 deltaY;
 	modularPath[0].dir = smoothPath[0].dir;
 	modularPath[0].num = 0;
 
-	while (smoothPath[smooth].num < ROUTE_END_FLAG)
-	{
+	while (smoothPath[smooth].num < ROUTE_END_FLAG) {
 		scale = scaleA * smoothPath[smooth].y + scaleB;
-		deltaX = smoothPath[smooth].x - modularPath[slidy-1].x;
-		deltaY = smoothPath[smooth].y - modularPath[slidy-1].y;
+		deltaX = smoothPath[smooth].x - modularPath[slidy - 1].x;
+		deltaY = smoothPath[smooth].y - modularPath[slidy - 1].y;
 		stepX = modX[smoothPath[smooth].dir];
 		stepY = modY[smoothPath[smooth].dir];
 		stepX = stepX * scale;
 		stepY = stepY * scale;
-		stepX = stepX >> 19;// quarter a step minimum
+		stepX = stepX >> 19;	// quarter a step minimum
 		stepY = stepY >> 19;
-		if ((abs(deltaX)>=abs(stepX)) &&	(abs(deltaY)>=abs(stepY)))
-		{									
+
+		if (abs(deltaX) >= abs(stepX) && abs(deltaY) >= abs(stepY)) {
 	 		modularPath[slidy].x = smoothPath[smooth].x;
 			modularPath[slidy].y = smoothPath[smooth].y;
 			modularPath[slidy].dir = smoothPath[smooth].dir;
 			modularPath[slidy].num = 1;
-			slidy += 1;
+			slidy++;
 		}
-		smooth += 1;
+		smooth++;
 	}
-	// in	case the last bit had no steps
-	if (slidy > 1)
-	{
-		modularPath[slidy-1].x = smoothPath[smooth-1].x;
-		modularPath[slidy-1].y = smoothPath[smooth-1].y;
+
+	// in case the last bit had no steps
+
+	if (slidy > 1) {
+		modularPath[slidy - 1].x = smoothPath[smooth - 1].x;
+		modularPath[slidy - 1].y = smoothPath[smooth - 1].y;
 	}
+
 	// set up the end of the walk
-	modularPath[slidy].x = smoothPath[smooth-1].x;
-	modularPath[slidy].y = smoothPath[smooth-1].y;
+
+	modularPath[slidy].x = smoothPath[smooth - 1].x;
+	modularPath[slidy].y = smoothPath[smooth - 1].y;
 	modularPath[slidy].dir = targetDir;
 	modularPath[slidy].num = 0;
-	slidy += 1;
-	modularPath[slidy].x = smoothPath[smooth-1].x;
-	modularPath[slidy].y = smoothPath[smooth-1].y;
+	slidy++;
+
+	modularPath[slidy].x = smoothPath[smooth - 1].x;
+	modularPath[slidy].y = smoothPath[smooth - 1].y;
 	modularPath[slidy].dir = 9;
 	modularPath[slidy].num = ROUTE_END_FLAG;
+
 	return 1;
 }
 
-//****************************************************************************
 // SLOW IN
 
-int32 AddSlowInFrames(_walkData *walkAnim)
-{
+int32 AddSlowInFrames(_walkData *walkAnim) {
 	uint32 slowInFrameNo;
 
-
-	if ((usingSlowInFrames) && (modularPath[1].num > 0))
-	{
-		for (slowInFrameNo=0; slowInFrameNo<numberOfSlowInFrames[currentDir]; slowInFrameNo++)
-		{
-			walkAnim[stepCount].frame	= firstSlowInFrame[currentDir] + slowInFrameNo;
-			walkAnim[stepCount].step	= 0;
-			walkAnim[stepCount].dir		= currentDir;
-			walkAnim[stepCount].x		= moduleX;
-			walkAnim[stepCount].y		= moduleY;
-			stepCount += 1;
+	if (usingSlowInFrames && modularPath[1].num > 0) {
+		for (slowInFrameNo = 0; slowInFrameNo < numberOfSlowInFrames[currentDir]; slowInFrameNo++) {
+			walkAnim[stepCount].frame = firstSlowInFrame[currentDir] + slowInFrameNo;
+			walkAnim[stepCount].step = 0;
+			walkAnim[stepCount].dir = currentDir;
+			walkAnim[stepCount].x = moduleX;
+			walkAnim[stepCount].y = moduleY;
+			stepCount++;
 		}
-		return(1);
-	}
-	else
-	{
-		return(0);
+		return 1;
 	}
+
+	return 0;
 }
-//----------------------------------------------------------------------------
-void EarlySlowOut(Object_mega *ob_mega, Object_walkdata *ob_walkdata)
-{
+
+void EarlySlowOut(Object_mega *ob_mega, Object_walkdata *ob_walkdata) {
 	int32 slowOutFrameNo;
 	int32 walk_pc;
 	_walkData *walkAnim;
 
-	
-	//Zdebug("\nEARLY SLOW-OUT");
+	// Zdebug("\nEARLY SLOW-OUT");
 
 	LoadWalkData(ob_walkdata);
 
-	//Zdebug("********************************");
-	//Zdebug("framesPerStep              =%d",framesPerStep);								// 6;
-	//Zdebug("numberOfSlowOutFrames      =%d",numberOfSlowOutFrames);				// 7;
-	//Zdebug("firstWalkingTurnLeftFrame  =%d",firstWalkingTurnLeftFrame);		// 120;
-	//Zdebug("firstWalkingTurnRightFrame =%d",firstWalkingTurnRightFrame);	// 216;
-	//Zdebug("firstSlowOutFrame          =%d",firstSlowOutFrame);						// 344;
-	//Zdebug("********************************");
-
+	// Zdebug("********************************");
+	// Zdebug("framesPerStep              =%d", framesPerStep);
+	// Zdebug("numberOfSlowOutFrames      =%d", numberOfSlowOutFrames);
+	// Zdebug("firstWalkingTurnLeftFrame  =%d", firstWalkingTurnLeftFrame);
+	// Zdebug("firstWalkingTurnRightFrame =%d", firstWalkingTurnRightFrame);
+	// Zdebug("firstSlowOutFrame          =%d", firstSlowOutFrame);
+	// Zdebug("********************************");
 
  	walk_pc  = ob_mega->walk_pc;
 
-	walkAnim = LockRouteMem();	// lock the _walkData array (NB. AFTER loading walkgrid & walkdata!)
+	// lock the _walkData array (NB. AFTER loading walkgrid & walkdata!)
+	walkAnim = LockRouteMem();
 
+	// if this mega does actually have slow-out frames
+	if (usingSlowOutFrames) {
+		// overwrite the next step (half a cycle) of the walk 
+		// (ie .step - 0..5)
 
-	if (usingSlowOutFrames)	// if this mega does actually have slow-out frames
-	{
-		do	// overwrite the next step (half a cycle) of the walk (ie .step - 0..5
-		{
-			//Zdebug("\nSTEP NUMBER:    walkAnim[%d].step  = %d",walk_pc,walkAnim[walk_pc].step);
-			//Zdebug("ORIGINAL FRAME: walkAnim[%d].frame = %d",walk_pc,walkAnim[walk_pc].frame);
-			// map from existing walk frame across to correct frame number of slow-out - remember, there may be more slow-out frames than walk-frames!
+		do {
+			// Zdebug("\nSTEP NUMBER:    walkAnim[%d].step  = %d", walk_pc, walkAnim[walk_pc].step);
+			// Zdebug("ORIGINAL FRAME: walkAnim[%d].frame = %d", walk_pc, walkAnim[walk_pc].frame);
 
-			if (walkAnim[walk_pc].frame >= firstWalkingTurnRightFrame)	// if it's a walking turn-right, rather than a normal step
-			{
-				walkAnim[walk_pc].frame -= firstWalkingTurnRightFrame;		// then map it to a normal step frame first
-				//Zdebug("MAPPED TO WALK: walkAnim[%d].frame = %d  (walking turn-right frame --> walk frame)",walk_pc,walkAnim[walk_pc].frame);
-			}
+			// map from existing walk frame across to correct
+			// frame number of slow-out - remember, there may be
+			// more slow-out frames than walk-frames!
+
+			if (walkAnim[walk_pc].frame >= firstWalkingTurnRightFrame) {
+				// if it's a walking turn-right, rather than a
+				// normal step, then map it to a normal step
+				// frame first
 
-			else if (walkAnim[walk_pc].frame >= firstWalkingTurnLeftFrame)	// if it's a walking turn-left, rather than a normal step
-			{
-				walkAnim[walk_pc].frame -= firstWalkingTurnLeftFrame;		// then map it to a normal step frame first
-				//Zdebug("MAPPED TO WALK: walkAnim[%d].frame = %d  (walking turn-left frame --> walk frame)",walk_pc,walkAnim[walk_pc].frame);
+				walkAnim[walk_pc].frame -= firstWalkingTurnRightFrame;
+				// Zdebug("MAPPED TO WALK: walkAnim[%d].frame = %d  (walking turn-right frame --> walk frame)", walk_pc, walkAnim[walk_pc].frame);
+			} else if (walkAnim[walk_pc].frame >= firstWalkingTurnLeftFrame) {
+				// if it's a walking turn-left, rather than a
+				// normal step, then map it to a normal step
+				// frame first
+
+				walkAnim[walk_pc].frame -= firstWalkingTurnLeftFrame;
+				// Zdebug("MAPPED TO WALK: walkAnim[%d].frame = %d  (walking turn-left frame --> walk frame)", walk_pc, walkAnim[walk_pc].frame);
 			}
 
-			walkAnim[walk_pc].frame += firstSlowOutFrame + ((walkAnim[walk_pc].frame / framesPerStep) * (numberOfSlowOutFrames-framesPerStep));
+			walkAnim[walk_pc].frame += firstSlowOutFrame + ((walkAnim[walk_pc].frame / framesPerStep) * (numberOfSlowOutFrames - framesPerStep));
 			walkAnim[walk_pc].step = 0;
-			//Zdebug("SLOW-OUT FRAME: walkAnim[%d].frame = %d",walk_pc,walkAnim[walk_pc].frame);
-			walk_pc += 1;
-		}
-		while(walkAnim[walk_pc].step > 0 );
+			// Zdebug("SLOW-OUT FRAME: walkAnim[%d].frame = %d",walk_pc, walkAnim[walk_pc].frame);
+			walk_pc++;
+		} while(walkAnim[walk_pc].step > 0);
+
+		// Zdebug("\n");
 
-		//Zdebug("\n");
+		// add stationary frame(s) (OPTIONAL)
 
-		for (slowOutFrameNo=framesPerStep; slowOutFrameNo < numberOfSlowOutFrames; slowOutFrameNo++)	// add stationary frame(s) (OPTIONAL)
-		{
-			walkAnim[walk_pc].frame = walkAnim[walk_pc-1].frame + 1;
-			//Zdebug("EXTRA FRAME:    walkAnim[%d].frame = %d",walk_pc,walkAnim[walk_pc].frame);
+		for (slowOutFrameNo = framesPerStep; slowOutFrameNo < numberOfSlowOutFrames; slowOutFrameNo++) {
+			walkAnim[walk_pc].frame = walkAnim[walk_pc - 1].frame + 1;
+			// Zdebug("EXTRA FRAME:    walkAnim[%d].frame = %d", walk_pc, walkAnim[walk_pc].frame);
 			walkAnim[walk_pc].step = 0;
-			walkAnim[walk_pc].dir = walkAnim[walk_pc-1].dir;
-			walkAnim[walk_pc].x = walkAnim[walk_pc-1].x;
-			walkAnim[walk_pc].y = walkAnim[walk_pc-1].y;
+			walkAnim[walk_pc].dir = walkAnim[walk_pc - 1].dir;
+			walkAnim[walk_pc].x = walkAnim[walk_pc - 1].x;
+			walkAnim[walk_pc].y = walkAnim[walk_pc - 1].y;
 			walk_pc++;
 		}
-	}
-	else	// this mega doesn't have slow-out frames
-	{
-		walkAnim[walk_pc].frame	= firstStandFrame + walkAnim[walk_pc-1].dir;	// stand in current direction
-		walkAnim[walk_pc].step	= 0;
-		walkAnim[walk_pc].dir		= walkAnim[walk_pc-1].dir;
-		walkAnim[walk_pc].x			= walkAnim[walk_pc-1].x;
-		walkAnim[walk_pc].y			= walkAnim[walk_pc-1].y;
+	} else {
+		// this mega doesn't have slow-out frames
+		// stand in current direction
+
+		walkAnim[walk_pc].frame = firstStandFrame + walkAnim[walk_pc - 1].dir;
+		walkAnim[walk_pc].step = 0;
+		walkAnim[walk_pc].dir = walkAnim[walk_pc - 1].dir;
+		walkAnim[walk_pc].x = walkAnim[walk_pc - 1].x;
+		walkAnim[walk_pc].y = walkAnim[walk_pc - 1].y;
 		walk_pc++;
 	}
 
-	walkAnim[walk_pc].frame	= 512;	// end of sequence
-	walkAnim[walk_pc].step	= 99;	// so that this doesn't happen again while 'george_walking' is still '2'
+	// end of sequence
+	walkAnim[walk_pc].frame	= 512;
+
+	// so that this doesn't happen again while 'george_walking' is still
+	// '2'
+	walkAnim[walk_pc].step = 99;
 }
-//----------------------------------------------------------------------------
+
 // SLOW OUT
 
-void AddSlowOutFrames(_walkData *walkAnim)
-{
+void AddSlowOutFrames(_walkData *walkAnim) {
 	int32 slowOutFrameNo;
 
+	// if the mega did actually walk, we overwrite the last step (half a
+	// cycle) with slow-out frames + add any necessary stationary frames
 
- 	if ((usingSlowOutFrames)&&(lastCount>=framesPerStep))	// if the mega did actually walk, we overwrite the last step (half a cycle) with slow-out frames + add any necessary stationary frames
-	{
+ 	if (usingSlowOutFrames && lastCount >= framesPerStep) {
 		// place stop frames here
 		// slowdown at the end of the last walk
 	
 		slowOutFrameNo = lastCount - framesPerStep;
 
-
-		//Zdebug("SLOW OUT: slowOutFrameNo(%d) = lastCount(%d) - framesPerStep(%d)",slowOutFrameNo,lastCount,framesPerStep);
+		// Zdebug("SLOW OUT: slowOutFrameNo(%d) = lastCount(%d) - framesPerStep(%d)", slowOutFrameNo, lastCount, framesPerStep);
 	
-		do	// overwrite the last step (half a cycle) of the walk
-		{
-			// map from existing walk frame across to correct frame number of slow-out - remember, there may be more slow-out frames than walk-frames!
-			walkAnim[slowOutFrameNo].frame += firstSlowOutFrame + ((walkAnim[slowOutFrameNo].frame / framesPerStep) * (numberOfSlowOutFrames-framesPerStep));
-			walkAnim[slowOutFrameNo].step = 0;	// because no longer a normal walk-step
+		// overwrite the last step (half a cycle) of the walk
+
+		do {
+			// map from existing walk frame across to correct
+			// frame number of slow-out - remember, there may be
+			// more slow-out frames than walk-frames!
+
+			walkAnim[slowOutFrameNo].frame += firstSlowOutFrame + ((walkAnim[slowOutFrameNo].frame / framesPerStep) * (numberOfSlowOutFrames - framesPerStep));
+
+			// because no longer a normal walk-step
+			walkAnim[slowOutFrameNo].step = 0;
+
 			//Zdebug("walkAnim[%d].frame = %d",slowOutFrameNo,walkAnim[slowOutFrameNo].frame);
-			slowOutFrameNo += 1;
-		}
-		while(slowOutFrameNo < lastCount );
+			slowOutFrameNo++;
+		} while(slowOutFrameNo < lastCount);
 	
-		for (slowOutFrameNo=framesPerStep; slowOutFrameNo < numberOfSlowOutFrames; slowOutFrameNo++)	// add stationary frame(s) (OPTIONAL)
-		{
-			walkAnim[stepCount].frame = walkAnim[stepCount-1].frame + 1;
-			//Zdebug("EXTRA FRAMES: walkAnim[%d].frame = %d",stepCount,walkAnim[stepCount].frame);
+		// add stationary frame(s) (OPTIONAL)
+
+		for (slowOutFrameNo = framesPerStep; slowOutFrameNo < numberOfSlowOutFrames; slowOutFrameNo++) {
+			walkAnim[stepCount].frame = walkAnim[stepCount - 1].frame + 1;
+
+			// Zdebug("EXTRA FRAMES: walkAnim[%d].frame = %d", stepCount, walkAnim[stepCount].frame);
+
 			walkAnim[stepCount].step = 0;
-			walkAnim[stepCount].dir	= walkAnim[stepCount-1].dir;
-			walkAnim[stepCount].x		= walkAnim[stepCount-1].x;
-			walkAnim[stepCount].y		= walkAnim[stepCount-1].y;
-			stepCount += 1;
+			walkAnim[stepCount].dir = walkAnim[stepCount - 1].dir;
+			walkAnim[stepCount].x = walkAnim[stepCount - 1].x;
+			walkAnim[stepCount].y = walkAnim[stepCount - 1].y;
+			stepCount++;
 		}
 	}
 }
-//----------------------------------------------------------------------------
 
-void SlidyWalkAnimator(_walkData *walkAnim)
-/****************************************************************************
- *  Skidding every where HardWalk creates an animation that exactly fits the
- *	smoothPath and uses foot slipping to fit whole steps into the route
- *	Parameters: georgeg,mouseg
- *	Returns:		rout 
- *
- *	produce a module list from the line data
- *
- ****************************************************************************/
-{
+void SlidyWalkAnimator(_walkData *walkAnim) {
+	/*********************************************************************
+	 * Skidding every where HardWalk creates an animation that exactly
+	 * fits the smoothPath and uses foot slipping to fit whole steps into
+	 * the route
+	 *
+	 *	Parameters:	georgeg, mouseg
+	 *	Returns:	rout 
+	 *
+	 * produce a module list from the line data
+	 *
+	 *********************************************************************/
+
 	static int32 left = 0;
 	int32 p;
 	int32 lastDir;
@@ -1148,46 +1101,42 @@ void SlidyWalkAnimator(_walkData *walkAnim)
 	int32 frameCount;
 	int32 frames;
 
-
 	p = 0;
 	lastDir = modularPath[0].dir;
 	currentDir = modularPath[1].dir;
+
 	if (currentDir == NO_DIRECTIONS)
-	{
 		currentDir = lastDir;
-	}
+
 	moduleX = startX;
 	moduleY = startY;
 	module16X = moduleX << 16;
 	module16Y = moduleY << 16;
 	stepCount = 0;
 
-	//****************************************************************************
-	// SLIDY
 	// START THE WALK WITH THE FIRST STANDFRAME THIS MAY CAUSE A DELAY
 	// BUT IT STOPS THE PLAYER MOVING FOR COLLISIONS ARE DETECTED
-	//****************************************************************************
-	//Zdebug("\nSLIDY: STARTING THE WALK");
-	module =	framesPerChar + lastDir;
+
+	// Zdebug("\nSLIDY: STARTING THE WALK");
+
+	module = framesPerChar + lastDir;
 	walkAnim[stepCount].frame = module;
 	walkAnim[stepCount].step = 0;
 	walkAnim[stepCount].dir = lastDir;
 	walkAnim[stepCount].x = moduleX;
 	walkAnim[stepCount].y = moduleY;
-	stepCount += 1;
+	stepCount++;
 
-	//****************************************************************************
-	// SLIDY
 	// TURN TO START THE WALK
-	//****************************************************************************
-	//Zdebug("\nSLIDY: TURNING TO START THE WALK");
+
+	// Zdebug("\nSLIDY: TURNING TO START THE WALK");
 	// rotate if we need to
-	if (lastDir != currentDir)
-	{
+
+	if (lastDir != currentDir) {
 		// get the direction to turn
 		turnDir = currentDir - lastDir;
-		if ( turnDir < 0)
-				turnDir += NO_DIRECTIONS;
+		if (turnDir < 0)
+			turnDir += NO_DIRECTIONS;
 
 		if (turnDir > 4)
 			turnDir = -1;
@@ -1196,106 +1145,115 @@ void SlidyWalkAnimator(_walkData *walkAnim)
 
 		// rotate to new walk direction
 		// for george and nico put in a head turn at the start
-		if (usingStandingTurnFrames)
-		{
-			if ( turnDir < 0)	// new frames for turn frames	29oct95jps
-			{
+
+		if (usingStandingTurnFrames) {
+			// new frames for turn frames	29oct95jps
+			if (turnDir < 0)
 				module = firstStandingTurnLeftFrame + lastDir;
-			}
 			else
-			{
 				module = firstStandingTurnRightFrame + lastDir;
-			}
+
 			walkAnim[stepCount].frame = module;
 			walkAnim[stepCount].step = 0;
 			walkAnim[stepCount].dir = lastDir;
 			walkAnim[stepCount].x = moduleX;
 			walkAnim[stepCount].y = moduleY;
-			stepCount += 1;
+			stepCount++;
 		}
 
 		// rotate till were facing new dir then go back 45 degrees
-		while (lastDir != currentDir)
-		{
+		while (lastDir != currentDir) {
 			lastDir += turnDir;
-			if ( turnDir < 0)	// new frames for turn frames	29oct95jps
-			{
+
+			// new frames for turn frames	29oct95jps
+			if (turnDir < 0) {
 				if ( lastDir < 0)
 					lastDir += NO_DIRECTIONS;
 				module = firstStandingTurnLeftFrame + lastDir;
-			}
-			else
-			{
+			} else {
 				if ( lastDir > 7)
 					lastDir -= NO_DIRECTIONS;
 				module = firstStandingTurnRightFrame + lastDir;
 			}
+
 			walkAnim[stepCount].frame = module;
 			walkAnim[stepCount].step = 0;
 			walkAnim[stepCount].dir = lastDir;
 			walkAnim[stepCount].x = moduleX;
 			walkAnim[stepCount].y = moduleY;
-			stepCount += 1;
+			stepCount++;
 		}
+
 		// the back 45 degrees bit
-		stepCount -= 1;// step back one because new head turn for george takes us past the new dir
+		// step back one because new head turn for george takes us
+		// past the new dir
+		stepCount--;
 	}
+
 	// his head is in the right direction
 	lastRealDir = currentDir;
 
-	//****************************************************************************
 	// SLIDY: THE SLOW IN
 
 	AddSlowInFrames(walkAnim);
-	//****************************************************************************
 
-	//****************************************************************************
-	// SLIDY
 	// THE WALK
-	//****************************************************************************
 
-	//Zdebug("\nSLIDY: THE WALK");
+	// Zdebug("\nSLIDY: THE WALK");
 
-	//---------------------------------------------------
-	// start the walk on the left or right leg, depending on how the slow-in frames were drawn
+	// start the walk on the left or right leg, depending on how the
+	// slow-in frames were drawn
 
-	if (leadingLeg[currentDir]==0)	// (0=left; 1=right)
-		left = 0;							//  start the walk on the left leg (ie. at beginning of the first step of the walk cycle)
-	else
-		left = framesPerStep;	//  start the walk on the right leg (ie. at beginning of the second step of the walk cycle)
-	//---------------------------------------------------
+	// (0 = left; 1 = right)
 
+	if (leadingLeg[currentDir] == 0) {
+		// start the walk on the left leg (ie. at beginning of the
+		// first step of the walk cycle)
+		left = 0;
+	} else {
+		// start the walk on the right leg (ie. at beginning of the
+		// second step of the walk cycle)
+		left = framesPerStep;
+	}
 
 	lastCount = stepCount;
-	lastDir = 99;// this ensures that we don't put in turn frames for the start		
-	currentDir = 99;// this ensures that we don't put in turn frames for the start		
-	do
-	{
+
+	// this ensures that we don't put in turn frames for the start
+	lastDir = 99;
+
+	// this ensures that we don't put in turn frames for the start
+	currentDir = 99;
+
+	do {
 		assert(stepCount < O_WALKANIM_SIZE);
-		while (modularPath[p].num == 0)
-		{
-			p = p + 1;
+		while (modularPath[p].num == 0) {
+			p++;
 			if (currentDir != 99)
 				lastRealDir = currentDir;
 			lastDir = currentDir;
 			lastCount = stepCount;
 		}
-		//calculate	average amount to lose in each step on the way to the next node
+
+		// calculate average amount to lose in each step on the way
+		// to the next node
+
 		currentDir = modularPath[p].dir;
-		if (currentDir < NO_DIRECTIONS)
-		{
-			module =	currentDir * framesPerStep * 2 + left;
+
+		if (currentDir < NO_DIRECTIONS) {
+			module = currentDir * framesPerStep * 2 + left;
+
 			if (left == 0)
-			 left = framesPerStep;
+				left = framesPerStep;
 			else
-			 left = 0;
+				left = 0;
+
 			moduleEnd = module + framesPerStep;
 			step = 0;
 			scale = (scaleA * moduleY + scaleB);
-			do
-			{
-				module16X += dx[module]*scale;
-				module16Y += dy[module]*scale;
+
+			do {
+				module16X += dx[module] * scale;
+				module16Y += dy[module] * scale;
 				moduleX = module16X >> 16;
 				moduleY = module16Y >> 16;
 				walkAnim[stepCount].frame = module;
@@ -1303,44 +1261,46 @@ void SlidyWalkAnimator(_walkData *walkAnim)
 				walkAnim[stepCount].dir = currentDir;
 				walkAnim[stepCount].x = moduleX;
 				walkAnim[stepCount].y = moduleY;
-				stepCount += 1;
-				step += 1;
-				module += 1;
-			}
-			while( module < moduleEnd) ;
+				stepCount++;
+				step++;
+				module++;
+			} while(module < moduleEnd);
+
 			stepX = modX[modularPath[p].dir];
 			stepY = modY[modularPath[p].dir];
-			errorX = modularPath[p].x -	moduleX;
+			errorX = modularPath[p].x - moduleX;
 			errorX = errorX * stepX;
-			errorY = modularPath[p].y -	moduleY;
+			errorY = modularPath[p].y - moduleY;
 			errorY = errorY * stepY;
-			if ((errorX < 0) || (errorY < 0))
-			{
+
+			if (errorX < 0 || errorY < 0) {
 				modularPath[p].num = 0;	// the end of the path
-				// okay those last steps took us past our target but do we want to scoot or moonwalk
+
+				// okay those last steps took us past our
+				// target but do we want to scoot or moonwalk
+
 				frames = stepCount - lastCount;
-				errorX = modularPath[p].x - walkAnim[stepCount-1].x;
-				errorY = modularPath[p].y - walkAnim[stepCount-1].y;
+				errorX = modularPath[p].x - walkAnim[stepCount - 1].x;
+				errorY = modularPath[p].y - walkAnim[stepCount - 1].y;
 
-				if (frames > framesPerStep)
-				{
-					lastErrorX = modularPath[p].x - walkAnim[stepCount-7].x;
-					lastErrorY = modularPath[p].y - walkAnim[stepCount-7].y;
-					if (stepX==0)
-					{
-						if (3*abs(lastErrorY) < abs(errorY)) //the last stop was closest
-						{
+				if (frames > framesPerStep) {
+					lastErrorX = modularPath[p].x - walkAnim[stepCount - 7].x;
+					lastErrorY = modularPath[p].y - walkAnim[stepCount - 7].y;
+
+					if (stepX == 0) {
+						if (3 * abs(lastErrorY) < abs(errorY)) {
+							// the last stop was
+							// closest
 							stepCount -= framesPerStep;
 							if (left == 0)
 						 		left = framesPerStep;
 							else
 							 	left = 0;
 						}
-					}
-					else
-					{
-						if (3*abs(lastErrorX) < abs(errorX)) //the last stop was closest
-						{
+					} else {
+						if (3 * abs(lastErrorX) < abs(errorX)) {
+							//the last stop was
+							// closest
 							stepCount -= framesPerStep;
 							if (left == 0)
 						 		left = framesPerStep;
@@ -1349,127 +1309,129 @@ void SlidyWalkAnimator(_walkData *walkAnim)
 						}
 					}
 				}
+
 				errorX = modularPath[p].x - walkAnim[stepCount-1].x;
 				errorY = modularPath[p].y - walkAnim[stepCount-1].y;
-				// okay we've reached the end but we still have an error
-				if (errorX != 0)
-				{
+
+				// okay we've reached the end but we still
+				// have an error
+
+				if (errorX != 0) {
 					frameCount = 0;
 					frames = stepCount - lastCount;
-					do
-					{
-						frameCount += 1;
-						walkAnim[lastCount + frameCount - 1].x +=	errorX*frameCount/frames;
-					}
-					while(frameCount<frames);	
+
+					do {
+						frameCount++;
+						walkAnim[lastCount + frameCount - 1].x += errorX * frameCount / frames;
+					} while(frameCount < frames);	
 				}
-				if (errorY != 0)
-				{
+
+				if (errorY != 0) {
 					frameCount = 0;
 					frames = stepCount - lastCount;
-					do
-					{
-						frameCount += 1;
-						walkAnim[lastCount + frameCount-1].y +=	errorY*frameCount/frames;
-					}
-					while(frameCount<frames);	
+					do {
+						frameCount++;
+						walkAnim[lastCount + frameCount - 1].y += errorY * frameCount / frames;
+					} while(frameCount < frames);	
 				}
-				// Now is the time to put in the turn frames for the last turn
-				if (frames < framesPerStep)
-					currentDir = 99;// this ensures that we don't put in turn frames for this walk or the next		
+
+				// Now is the time to put in the turn frames
+				// for the last turn
+
+				if (frames < framesPerStep) {
+					// this ensures that we don't put in
+					// turn frames for this walk or the
+					// next		
+					currentDir = 99;
+				}
+
 				if (currentDir != 99)
 					lastRealDir = currentDir;
+
 				// check each turn condition in turn
-				if (((lastDir != 99) && (currentDir != 99)) && (usingWalkingTurnFrames)) // only for george
-				{	
-				  lastDir = currentDir - lastDir;//1 and -7 going right -1 and 7 going left
-					if (((lastDir == -1) || (lastDir == 7)) || ((lastDir == -2) || (lastDir == 6)))
-					{
-						// turn at the end of the last walk
+
+				 // only for george
+				if (lastDir != 99 && currentDir != 99 && usingWalkingTurnFrames) {
+					// 1 and -7 going right -1 and 7 going
+					// left
+					lastDir = currentDir - lastDir;
+
+					if (lastDir == -1 || lastDir == 7 || lastDir == -2 || lastDir == 6) {
+						// turn at the end of the last
+						// walk
+
 						frame = lastCount - framesPerStep;
-						do
-						{
-							walkAnim[frame].frame += firstWalkingTurnLeftFrame;	//was 104;	//turning left 
-							frame += 1;
-						}
-						while(frame < lastCount );
-					}
-					if (((lastDir == 1) || (lastDir == -7)) || ((lastDir == 2) || (lastDir == -6)))
-					{	
-						// turn at the end of the current walk
+						do {
+							// turning left 
+							walkAnim[frame].frame += firstWalkingTurnLeftFrame;
+							frame++;
+						} while (frame < lastCount);
+					} else if (lastDir == 1 || lastDir == -7 || lastDir == 2 || lastDir == -6) {	
+						// turn at the end of the
+						// current walk
+
 						frame = lastCount - framesPerStep;
-						do
-						{
-							walkAnim[frame].frame += firstWalkingTurnRightFrame;	// was 200;	// turning right
-							frame += 1;
-						}
-						while(frame < lastCount );
+						do {
+							// turning right
+							walkAnim[frame].frame += firstWalkingTurnRightFrame;
+							frame++;
+						} while(frame < lastCount);
 					}
 					lastDir = currentDir;
 				}
+
 				// all turns checked
 
 				lastCount = stepCount;
-				moduleX = walkAnim[stepCount-1].x;
-				moduleY =	walkAnim[stepCount-1].y;
+				moduleX = walkAnim[stepCount - 1].x;
+				moduleY = walkAnim[stepCount - 1].y;
 				module16X = moduleX << 16;
 				module16Y = moduleY << 16;
 			}
 		}
-	}
-	while (modularPath[p].dir < NO_DIRECTIONS);
-
-
+	} while (modularPath[p].dir < NO_DIRECTIONS);
 
 #ifdef _SWORD2_DEBUG
 	if (lastRealDir == 99)
-	{
-		Con_fatal_error("SlidyWalkAnimatorlast direction error (%s line %u)",__FILE__,__LINE__);
-	}
+		Con_fatal_error("SlidyWalkAnimatorlast direction error (%s line %u)", __FILE__, __LINE__);
 #endif
 
-	//****************************************************************************
-	// SLIDY: THE SLOW OUT
+	// THE SLOW OUT
 	AddSlowOutFrames(walkAnim);
 
-	//****************************************************************************
-	// SLIDY
 	// TURNS TO END THE WALK ?
-	//****************************************************************************
 
 	// We've done the walk now put in any turns at the end
 
+	if (targetDir == 8) {
+		// ANY direction -> stand in the last direction
 
-	if (targetDir == 8)	// ANY direction -> stand in the last direction
-	{
-		module =	firstStandFrame + lastRealDir;
-		targetDir =	lastRealDir;
+		module = firstStandFrame + lastRealDir;
+		targetDir = lastRealDir;
 		walkAnim[stepCount].frame = module;
 		walkAnim[stepCount].step = 0;
 		walkAnim[stepCount].dir = lastRealDir;
 		walkAnim[stepCount].x = moduleX;
 		walkAnim[stepCount].y = moduleY;
-		stepCount += 1;
+		stepCount++;
 	}
-	if (targetDir == 9)	// 'stance' was non-zero
-	{
-		if (stepCount == 0)
-		{
-			module =	framesPerChar + lastRealDir;
+
+	if (targetDir == 9) {
+		// 'stance' was non-zero
+		if (stepCount == 0) {
+			module = framesPerChar + lastRealDir;
 			walkAnim[stepCount].frame = module;
 			walkAnim[stepCount].step = 0;
 			walkAnim[stepCount].dir = lastRealDir;
 			walkAnim[stepCount].x = moduleX;
 			walkAnim[stepCount].y = moduleY;
-			stepCount += 1;
+			stepCount++;
 		}
-	}
-	else if (targetDir != lastRealDir) // rotate to targetDir
-	{
+	} else if (targetDir != lastRealDir) {
 		// rotate to target direction
 		turnDir = targetDir - lastRealDir;
 		if ( turnDir < 0)
-				turnDir += NO_DIRECTIONS;
+			turnDir += NO_DIRECTIONS;
 
 		if (turnDir > 4)
 			turnDir = -1;
@@ -1478,112 +1440,108 @@ void SlidyWalkAnimator(_walkData *walkAnim)
 
 		// rotate to target direction
 		// for george and nico put in a head turn at the start
-		if (usingStandingTurnFrames)
-		{
-			if ( turnDir < 0)	// new frames for turn frames	29oct95jps
-			{
+
+		if (usingStandingTurnFrames) {
+			// new frames for turn frames	29oct95jps
+			if (turnDir < 0)
 				module = firstStandingTurnLeftFrame + lastDir;
-			}
 			else
-			{
 				module = firstStandingTurnRightFrame + lastDir;
-			}
+
 			walkAnim[stepCount].frame = module;
 			walkAnim[stepCount].step = 0;
 			walkAnim[stepCount].dir = lastRealDir;
 			walkAnim[stepCount].x = moduleX;
 			walkAnim[stepCount].y = moduleY;
-			stepCount += 1;
+			stepCount++;
 		}
 
 		// rotate if we need to
-		while (lastRealDir != targetDir)
-		{
+
+		while (lastRealDir != targetDir) {
 			lastRealDir += turnDir;
-			if ( turnDir < 0)	// new frames for turn frames	29oct95jps
-			{
-				if ( lastRealDir < 0)
+
+			// new frames for turn frames	29oct95jps
+			if (turnDir < 0) {
+				if (lastRealDir < 0)
 					lastRealDir += NO_DIRECTIONS;
 				module = firstStandingTurnLeftFrame + lastRealDir;
-			}
-			else
-			{
-				if ( lastRealDir > 7)
+			} else {
+				if (lastRealDir > 7)
 					lastRealDir -= NO_DIRECTIONS;
 				module = firstStandingTurnRightFrame + lastRealDir;
 			}
+
 			walkAnim[stepCount].frame = module;
 			walkAnim[stepCount].step = 0;
 			walkAnim[stepCount].dir = lastRealDir;
 			walkAnim[stepCount].x = moduleX;
 			walkAnim[stepCount].y = moduleY;
-			stepCount += 1;
+			stepCount++;
 		}
-		module =	firstStandFrame + lastRealDir;
-		walkAnim[stepCount-1].frame = module;
-	}
-	else // just stand at the end
-	{
-		module =	firstStandFrame + lastRealDir;
+
+		module = firstStandFrame + lastRealDir;
+		walkAnim[stepCount - 1].frame = module;
+	} else {
+		// just stand at the end
+		module = firstStandFrame + lastRealDir;
 		walkAnim[stepCount].frame = module;
 		walkAnim[stepCount].step = 0;
 		walkAnim[stepCount].dir = lastRealDir;
 		walkAnim[stepCount].x = moduleX;
 		walkAnim[stepCount].y = moduleY;
-		stepCount += 1;
+		stepCount++;
 	}
 
-	walkAnim[stepCount].frame	= 512;
-	walkAnim[stepCount].step	= 99;
-	stepCount += 1;
-	walkAnim[stepCount].frame	= 512;
-	walkAnim[stepCount].step	= 99;
-	stepCount += 1;
-	walkAnim[stepCount].frame	= 512;
-	walkAnim[stepCount].step	= 99;
+	walkAnim[stepCount].frame = 512;
+	walkAnim[stepCount].step = 99;
+	stepCount++;
 
+	walkAnim[stepCount].frame = 512;
+	walkAnim[stepCount].step = 99;
+	stepCount++;
 
-	//-------------------------------------------
-	// write all the frames to "debug.txt"
+	walkAnim[stepCount].frame = 512;
+	walkAnim[stepCount].step = 99;
 
-	//Zdebug("\nTHE WALKDATA:");
-	for (frame=0; frame<=stepCount; frame++)
-	{
-		//Zdebug("walkAnim[%d].frame=%d",frame,walkAnim[frame].frame);
-	}
-	//-------------------------------------------
+#ifdef _SWORD2_DEBUG
+	// write all the frames to "debug.txt"
+	// Zdebug("\nTHE WALKDATA:");
 
+	for (frame = 0; frame <= stepCount; frame++)
+		Zdebug("walkAnim[%d].frame=%d", frame, walkAnim[frame].frame);
+#endif
 
-//	Zdebug("RouteFinder RouteSize is %d", stepCount);
+	// Zdebug("RouteFinder RouteSize is %d", stepCount);
 	return;
 }
 
+// THE SOLID PATH ROUTINES
 
-/*******************************************************************************
- *******************************************************************************
- * 														THE SOLID PATH ROUTINES
- *******************************************************************************
- *******************************************************************************/
+int32 SolidPath() {
+	/*********************************************************************
+	 * SolidPath creates a path based on whole steps with no sliding to
+	 * get as near as possible to the target without any sliding this
+	 * routine is currently unused, but is intended for use when just
+	 * clicking about.
+	 *
+	 * produce a module list from the line data
+	 *
+	 *********************************************************************/
 
-int32 SolidPath()
-{
-/****************************************************************************
- *  SolidPath creates a path based on whole steps with no sliding to get
- *	as near as possible to the target without any sliding this routine is
- *	currently unused, but is intended for use when just clicking about.
- *
- *	produce a module list from the line data
- *
- ****************************************************************************/
-int32 smooth;
-int32 solid;
-int32 scale;
-int32 stepX;
-int32 stepY;
-int32 deltaX;
-int32 deltaY;
+	// FIXME: It says in the comment about that this function is currently
+	// unused, but is it really?
+
+	int32 smooth;
+	int32 solid;
+	int32 scale;
+	int32 stepX;
+	int32 stepY;
+	int32 deltaX;
+	int32 deltaY;
 
 	// strip out the short sections
+
 	solid = 1;
 	smooth = 1;
 	modularPath[0].x = smoothPath[0].x;
@@ -1591,57 +1549,58 @@ int32 deltaY;
 	modularPath[0].dir = smoothPath[0].dir;
 	modularPath[0].num = 0;
 
-	do
-	{
+	do {
 		scale = scaleA * smoothPath[smooth].y + scaleB;
-		deltaX = smoothPath[smooth].x - modularPath[solid-1].x;
-		deltaY = smoothPath[smooth].y - modularPath[solid-1].y;
+		deltaX = smoothPath[smooth].x - modularPath[solid - 1].x;
+		deltaY = smoothPath[smooth].y - modularPath[solid - 1].y;
 		stepX = modX[smoothPath[smooth].dir];
 		stepY = modY[smoothPath[smooth].dir];
 		stepX = stepX * scale;
 		stepY = stepY * scale;
 		stepX = stepX >> 16;
 		stepY = stepY >> 16;
-		if ((abs(deltaX)>=abs(stepX)) &&	(abs(deltaY)>=abs(stepY)))
-		{
+
+		if (abs(deltaX) >= abs(stepX) && abs(deltaY) >= abs(stepY)) {
 			modularPath[solid].x = smoothPath[smooth].x;
 			modularPath[solid].y = smoothPath[smooth].y;
 			modularPath[solid].dir = smoothPath[smooth].dir;
 			modularPath[solid].num = 1;
-			solid += 1;
+			solid++;
 		}
-		smooth += 1;
-	}
-	while (smoothPath[smooth].num < ROUTE_END_FLAG);
-	// in	case the last bit had no steps
-	if (solid == 1) //there were no paths so put in a dummy end
-	{
-			solid = 2;
-			modularPath[1].dir = smoothPath[0].dir;
-			modularPath[1].num = 0;
+		smooth++;
+	} while (smoothPath[smooth].num < ROUTE_END_FLAG);
+
+	// in case the last bit had no steps
+
+	if (solid == 1) {
+		// there were no paths so put in a dummy end
+		solid = 2;
+		modularPath[1].dir = smoothPath[0].dir;
+		modularPath[1].num = 0;
 	}	
-	modularPath[solid-1].x = smoothPath[smooth-1].x;
-	modularPath[solid-1].y = smoothPath[smooth-1].y;
+
+	modularPath[solid - 1].x = smoothPath[smooth - 1].x;
+	modularPath[solid - 1].y = smoothPath[smooth - 1].y;
+
 	// set up the end of the walk
-	modularPath[solid].x = smoothPath[smooth-1].x;
-	modularPath[solid].y = smoothPath[smooth-1].y;
+	modularPath[solid].x = smoothPath[smooth - 1].x;
+	modularPath[solid].y = smoothPath[smooth - 1].y;
 	modularPath[solid].dir = 9;
 	modularPath[solid].num = ROUTE_END_FLAG;
-	return 1;
 
+	return 1;
 }
 
-int32 SolidWalkAnimator(_walkData *walkAnim)
-{
-/****************************************************************************
- *  SolidWalk creates an animation based on whole steps with no sliding to get
- *	as near as possible to the target without any sliding this routine is
- *	is intended for use when just clicking about.
- *
- *	produce a module list from the line data
- *
- *	returns 0 if solid route not found
- ****************************************************************************/
+int32 SolidWalkAnimator(_walkData *walkAnim) {
+	/*********************************************************************
+	 * SolidWalk creates an animation based on whole steps with no sliding
+	 * to get as near as possible to the target without any sliding. This
+	 * routine is is intended for use when just clicking about.
+	 *
+	 * produce a module list from the line data
+	 *
+	 * returns 0 if solid route not found
+	 *********************************************************************/
 
 	int32 p;
 	int32 i;
@@ -1656,26 +1615,22 @@ int32 SolidWalkAnimator(_walkData *walkAnim)
 	int32 errorX;
 	int32 errorY;
 	int32 moduleEnd;
-	int32 slowStart=0;
-
-
+	int32 slowStart = 0;
 
 	// start at the beginning for a change
+
 	lastDir = modularPath[0].dir;
 	p = 1;
 	currentDir = modularPath[1].dir;
-	module =	framesPerChar + lastDir;
+	module = framesPerChar + lastDir;
 	moduleX = startX;
 	moduleY = startY;
 	module16X = moduleX << 16;
 	module16Y = moduleY << 16;
 	stepCount = 0;
 
-	//****************************************************************************
-	// SOLID
 	// START THE WALK WITH THE FIRST STANDFRAME THIS MAY CAUSE A DELAY
 	// BUT IT STOPS THE PLAYER MOVING FOR COLLISIONS ARE DETECTED
-	//****************************************************************************
 
 	//Zdebug("\nSOLID: STARTING THE WALK");
 	walkAnim[stepCount].frame = module;
@@ -1683,20 +1638,19 @@ int32 SolidWalkAnimator(_walkData *walkAnim)
 	walkAnim[stepCount].dir = lastDir;
 	walkAnim[stepCount].x = moduleX;
 	walkAnim[stepCount].y = moduleY;
-	stepCount += 1;
+	stepCount++;
 
-	//****************************************************************************
-	// SOLID
 	// TURN TO START THE WALK
-	//****************************************************************************
-	//Zdebug("\nSOLID: TURNING TO START THE WALK");
+
+	// Zdebug("\nSOLID: TURNING TO START THE WALK");
+
 	// rotate if we need to
-	if (lastDir != currentDir)
-	{
+
+	if (lastDir != currentDir) {
 		// get the direction to turn
 		turnDir = currentDir - lastDir;
-		if ( turnDir < 0)
-				turnDir += NO_DIRECTIONS;
+		if (turnDir < 0)
+			turnDir += NO_DIRECTIONS;
 
 		if (turnDir > 4)
 			turnDir = -1;
@@ -1705,97 +1659,101 @@ int32 SolidWalkAnimator(_walkData *walkAnim)
 
 		// rotate to new walk direction
 		// for george and nico put in a head turn at the start
-		if (usingStandingTurnFrames)
-		{
-			if ( turnDir < 0)	// new frames for turn frames	29oct95jps
-			{
-				module =	firstStandingTurnLeftFrame + lastDir;
-			}
+
+		if (usingStandingTurnFrames) {
+			// new frames for turn frames	29oct95jps
+			if (turnDir < 0)
+				module = firstStandingTurnLeftFrame + lastDir;
 			else
-			{
-				module =	firstStandingTurnRightFrame + lastDir;
-			}
+				module = firstStandingTurnRightFrame + lastDir;
+
 			walkAnim[stepCount].frame = module;
 			walkAnim[stepCount].step = 0;
 			walkAnim[stepCount].dir = lastDir;
 			walkAnim[stepCount].x = moduleX;
 			walkAnim[stepCount].y = moduleY;
-			stepCount += 1;
+			stepCount++;
 		}
 
 		// rotate till were facing new dir then go back 45 degrees
-		while (lastDir != currentDir)
-		{
+
+		while (lastDir != currentDir) {
 			lastDir += turnDir;
-			if ( turnDir < 0)	// new frames for turn frames	29oct95jps
-			{
-				if ( lastDir < 0)
-						lastDir += NO_DIRECTIONS;
-				module =	firstStandingTurnLeftFrame + lastDir;
-			}
-			else
-			{
+
+			// new frames for turn frames	29oct95jps
+			if (turnDir < 0) {
+				if (lastDir < 0)
+					lastDir += NO_DIRECTIONS;
+				module = firstStandingTurnLeftFrame + lastDir;
+			} else {
 				if ( lastDir > 7)
-						lastDir -= NO_DIRECTIONS;
-				module =	firstStandingTurnRightFrame + lastDir;
+					lastDir -= NO_DIRECTIONS;
+				module = firstStandingTurnRightFrame + lastDir;
 			}
+
 			walkAnim[stepCount].frame = module;
 			walkAnim[stepCount].step = 0;
 			walkAnim[stepCount].dir = lastDir;
 			walkAnim[stepCount].x = moduleX;
 			walkAnim[stepCount].y = moduleY;
-			stepCount += 1;
+			stepCount++;
 		}
+
 		// the back 45 degrees bit
-		stepCount -= 1;// step back one because new head turn for george takes us past the new dir
+		// step back one because new head turn for george takes us
+		// past the new dir
+
+		stepCount--;
 	}
 
-	//****************************************************************************
-	// SOLID: THE SLOW IN
+	// THE SLOW IN
 
 	slowStart = AddSlowInFrames(walkAnim);
 
-	//****************************************************************************
-	// SOLID
 	// THE WALK
-	//****************************************************************************
-
-	//Zdebug("\nSOLID: THE WALK");
 
-	//---------------------------------------------------
-	// start the walk on the left or right leg, depending on how the slow-in frames were drawn
+	// Zdebug("\nSOLID: THE WALK");
 
-	if (leadingLeg[currentDir]==0)	// (0=left; 1=right)
-		left = 0;							//  start the walk on the left leg (ie. at beginning of the first step of the walk cycle)
-	else
-		left = framesPerStep;	//  start the walk on the right leg (ie. at beginning of the second step of the walk cycle)
-	//---------------------------------------------------
+	// start the walk on the left or right leg, depending on how the
+	// slow-in frames were drawn
 
+	// (0 = left; 1 = right)
+	if (leadingLeg[currentDir] == 0) {
+		// start the walk on the left leg (ie. at beginning of the
+		// first step of the walk cycle)
+		left = 0;
+	} else {
+		// start the walk on the right leg (ie. at beginning of the
+		// second step of the walk cycle)
+		left = framesPerStep;
+	}
 
 	lastCount = stepCount;
-	lastDir = 99;// this ensures that we don't put in turn frames for the start		
-	currentDir = 99;// this ensures that we don't put in turn frames for the start		
 
-	do
-	{
-		while(modularPath[p].num > 0)
-		{
+	// this ensures that we don't put in turn frames for the start
+	lastDir = 99;
+
+	// this ensures that we don't put in turn frames for the start
+	currentDir = 99;
+
+	do {
+		while(modularPath[p].num > 0) {
 			currentDir = modularPath[p].dir;
-			if (currentDir< NO_DIRECTIONS)
-			{
+			if (currentDir< NO_DIRECTIONS) {
+				module = currentDir * framesPerStep * 2 + left;
 
-				module =	currentDir * framesPerStep * 2 + left;
 				if (left == 0)
 					left = framesPerStep;
 				else
 					left = 0;
+
 				moduleEnd = module + framesPerStep;
 				step = 0;
 				scale = (scaleA * moduleY + scaleB);
-				do
-				{
-					module16X += dx[module]*scale;
-					module16Y += dy[module]*scale;
+
+				do {
+					module16X += dx[module] * scale;
+					module16Y += dy[module] * scale;
 					moduleX = module16X >> 16;
 					moduleY = module16Y >> 16;
 					walkAnim[stepCount].frame = module;
@@ -1803,274 +1761,271 @@ int32 SolidWalkAnimator(_walkData *walkAnim)
 					walkAnim[stepCount].dir = currentDir;
 					walkAnim[stepCount].x = moduleX;
 					walkAnim[stepCount].y = moduleY;
-					stepCount += 1;
-					module += 1;
-					step += 1;
-				}
-				while( module < moduleEnd) ;
-				errorX = modularPath[p].x -	moduleX;
+					stepCount++;
+					module++;
+					step++;
+				} while( module < moduleEnd);
+
+				errorX = modularPath[p].x - moduleX;
 				errorX = errorX * modX[modularPath[p].dir];
-				errorY = modularPath[p].y -	moduleY;
+				errorY = modularPath[p].y - moduleY;
 				errorY = errorY * modY[modularPath[p].dir];
-				if ((errorX < 0) || (errorY < 0))
-				{
+
+				if (errorX < 0 || errorY < 0) {
 					modularPath[p].num = 0;
 					stepCount -= framesPerStep;
+
 					if (left == 0)
 						left = framesPerStep;
 					else
 						left = 0;
+
 					// Okay this is the end of a section
-					moduleX = walkAnim[stepCount-1].x;
-					moduleY =	walkAnim[stepCount-1].y;
+
+					moduleX = walkAnim[stepCount - 1].x;
+					moduleY = walkAnim[stepCount - 1].y;
 					module16X = moduleX << 16;
 					module16Y = moduleY << 16;
 					modularPath[p].x =moduleX;
 					modularPath[p].y =moduleY;
-					// Now is the time to put in the turn frames for the last turn
-					if ((stepCount - lastCount) < framesPerStep)// no step taken
-					{
-						if (slowStart == 1)// clean up if a slow in but no walk
-						{
-							//stepCount -= 3;
+
+					// Now is the time to put in the turn
+					// frames for the last turn
+
+					if (stepCount - lastCount < framesPerStep) {
+						// no step taken
+
+						// clean up if a slow in but no
+						// walk
+
+						if (slowStart == 1) {
 							stepCount -= numberOfSlowInFrames[currentDir];	// (James08sep97)
-							//lastCount -= 3;
 							lastCount -= numberOfSlowInFrames[currentDir];	// (James08sep97)
 							slowStart = 0;
 						}
-						currentDir = 99;// this ensures that we don't put in turn frames for this walk or the next		
+
+						// this ensures that we don't
+						// put in turn frames for this
+						// walk or the next
+
+						currentDir = 99;
 					}
+
 					// check each turn condition in turn
-					if (((lastDir != 99) && (currentDir != 99)) && (usingWalkingTurnFrames)) // only for george
-					{	
-					  lastDir = currentDir - lastDir;//1 and -7 going right -1 and 7 going left
-						if (((lastDir == -1) || (lastDir == 7)) || ((lastDir == -2) || (lastDir == 6)))
-						{
-							// turn at the end of the last walk
+					if (lastDir != 99 && currentDir != 99 && usingWalkingTurnFrames) {	
+						// only for george
+						// 1 and -7 going right -1 and
+						// 7 going left
+
+						lastDir = currentDir - lastDir;
+
+						if (lastDir == -1 || lastDir == 7 || lastDir == -2 || lastDir == 6) {
+							// turn at the end of
+							// the last walk
+
 							frame = lastCount - framesPerStep;
-							do
-							{
-								walkAnim[frame].frame += firstWalkingTurnLeftFrame;	// was 104;	//turning left 
-								frame += 1;
-							}
-							while(frame < lastCount );
-						}
-						if (((lastDir == 1) || (lastDir == -7)) || ((lastDir == 2) || (lastDir == -6)))
-						{	
-							// turn at the end of the current walk
+
+							do {
+								// turning left
+								walkAnim[frame].frame += firstWalkingTurnLeftFrame;
+								frame++;
+							} while (frame < lastCount);
+						} else if (lastDir == 1 || lastDir == -7 || lastDir == 2 || lastDir == -6) {	
+							// turn at the end of
+							// the current walk
+
 							frame = lastCount - framesPerStep;
-							do
-							{
-								walkAnim[frame].frame += firstWalkingTurnRightFrame;	// was 200;	// turning right
-								frame += 1;
-							}
-							while(frame < lastCount );
+							do {
+								// turning right
+								walkAnim[frame].frame += firstWalkingTurnRightFrame;
+								frame++;
+							} while (frame < lastCount);
 						}
 					}
+
 					// all turns checked
 					lastCount = stepCount;
 				}
 			}
 		}
-		p = p + 1;
+		p++;
 		lastDir = currentDir;
-		slowStart = 0; //can only be valid first time round 
-	}
-	while (modularPath[p].dir < NO_DIRECTIONS);
 
+		// can only be valid first time round 
+		slowStart = 0;
+	} while (modularPath[p].dir < NO_DIRECTIONS);
 
-	//****************************************************************************
-	// SOLID: THE SLOW OUT
-	AddSlowOutFrames(walkAnim);
 
-	//****************************************************************************
+	// THE SLOW OUT
 
-	module =	framesPerChar + modularPath[p-1].dir;
+	AddSlowOutFrames(walkAnim);
+
+	module = framesPerChar + modularPath[p - 1].dir;
 	walkAnim[stepCount].frame = module;
 	walkAnim[stepCount].step = 0;
-	walkAnim[stepCount].dir = modularPath[p-1].dir;
+	walkAnim[stepCount].dir = modularPath[p - 1].dir;
 	walkAnim[stepCount].x = moduleX;
 	walkAnim[stepCount].y = moduleY;
-	stepCount += 1;
-
-	walkAnim[stepCount].frame	= 512;
-	walkAnim[stepCount].step	= 99;
-	stepCount += 1;
-	walkAnim[stepCount].frame	= 512;
-	walkAnim[stepCount].step	= 99;
-	stepCount += 1;
-	walkAnim[stepCount].frame	= 512;
-	walkAnim[stepCount].step	= 99;
-
-	//-------------------------------------------
-	// write all the frames to "debug.txt"
+	stepCount++;
+
+	walkAnim[stepCount].frame = 512;
+	walkAnim[stepCount].step = 99;
+	stepCount++;
 
+	walkAnim[stepCount].frame = 512;
+	walkAnim[stepCount].step = 99;
+	stepCount++;
+
+	walkAnim[stepCount].frame = 512;
+	walkAnim[stepCount].step = 99;
+
+#ifdef _SWORD2_DEBUG
+	// write all the frames to "debug.txt"
 	//Zdebug("\nTHE WALKDATA:");
-	for (frame=0; frame<=stepCount; frame++)
-	{
-		//Zdebug("walkAnim[%d].frame=%d",frame,walkAnim[frame].frame);
-	}
-	//-------------------------------------------
 
-	//****************************************************************************
-	// SOLID
+	for (frame = 0; frame <= stepCount; frame++)
+		Zdebug("walkAnim[%d].frame=%d", frame, walkAnim[frame].frame);
+#endif
+
 	// NO END TURNS
-	//****************************************************************************
 
-//	Zdebug("RouteFinder RouteSize is %d", stepCount);
-//	now check the route
-		i = 0;
-		do
-		{
-			if (!Check(modularPath[i].x, modularPath[i].y, modularPath[i+1].x, modularPath[i+1].y))
-				p=0;
-		#ifdef PLOT_PATHS
-			RouteLine(modularPath[i].x, modularPath[i].y, modularPath[i+1].x, modularPath[i+1].y, 227);
-    #endif   
-			i += 1;
-		}
-		while(i<p-1);
-		if (p != 0)
-		{
-			targetDir =	modularPath[p-1].dir;
-		}
-		if (p != 0)
-		{
-			if (CheckTarget(moduleX,moduleY) == 3)// new target on a line
-			{
-				p = 0;
-				//Zdebug("Solid walk target was on a line %d %d", moduleX, moduleY);
-			}
+	// Zdebug("RouteFinder RouteSize is %d", stepCount);
+	// now check the route
+
+	i = 0;
+
+	do {
+		if (!Check(modularPath[i].x, modularPath[i].y, modularPath[i + 1].x, modularPath[i + 1].y))
+			p = 0;
+		i++;
+	} while (i < p - 1);
+
+	if (p != 0) {
+		targetDir = modularPath[p - 1].dir;
+		if (CheckTarget(moduleX, moduleY) == 3) {
+			// new target on a line
+			p = 0;
+			// Zdebug("Solid walk target was on a line %d %d", moduleX, moduleY);
 		}
+	}
 
 	return p;
 }
 
+// THE SCAN ROUTINES
+
+int32 Scan(int32 level) {
+	/*********************************************************************
+	 * Called successively from RouteFinder	until no more changes take
+	 * place in the grid array, ie he best path has been found
+	 *
+	 * Scans through every point in the node array and checks if there is
+	 * a route between each point and if this route gives a new route.
+	 *
+	 * This routine could probably halve its processing time if it doubled
+	 * up on the checks after each route check
+	 *
+	 *********************************************************************/
 
-/*******************************************************************************
- *******************************************************************************
- * 														THE SCAN ROUTINES
- *******************************************************************************
- *******************************************************************************/
+	int32 i;
+	int32 k;
+	int32 x1;
+	int32 y1;
+	int32 x2;
+	int32 y2;
+	int32 distance;
+	int32 changed = 0;
+
+ 	// For all the nodes that have new values and a distance less than
+	// enddist, ie dont check for new routes from a point we checked
+	// before or from a point that is already further away than the best
+	// route so far. 
 
-int32 Scan(int32 level)
-/*******************************************************************************
- * Called successively from RouteFinder	until no more changes take place in the
- * grid array	ie he best path has been found
- *
- * Scans through every point in the node array and checks if there is a route
- * between each point and if this route gives a new route.
- *
- * This routine could probably halve its processing time if it doubled up on the
- * checks after	each route check
- *
- *******************************************************************************/
-{
-	int32	i;
-	int32	k;
-  int32 x1;
-  int32 y1;
-  int32 x2;
-  int32 y2;
-	int32	distance;
-	int32	changed = 0;
- 	// For all the nodes that have new values and a distance less than enddist
-	// ie dont check for new routes from a point we checked before or from a point
-	// that is already further away than the best route so far. 
 	i = 0;
-	do
-	{
-		if ((node[i].dist < node[nnodes].dist) && (node[i].level == level))
-		{
+
+	do {
+		if (node[i].dist < node[nnodes].dist && node[i].level == level) {
 			x1 = node[i].x;
 			y1 = node[i].y;
-			k=nnodes;
-			do
-			{
-				if (node[k].dist > node[i].dist)
-				{
+			k = nnodes;
+
+			do {
+				if (node[k].dist > node[i].dist) {
 					x2 = node[k].x;
 					y2 = node[k].y;
 
-					if (abs(x2-x1)>(4.5*abs(y2-y1)))
-					{
-						distance = (8*abs(x2-x1)+18*abs(y2-y1))/(54*8)+1;
-					}
+					if (abs(x2 - x1) > 4.5 * abs(y2-y1))
+						distance = (8 * abs(x2 - x1) + 18 * abs(y2 - y1)) / (54 * 8) + 1;
 					else
-					{
-						distance = (6*abs(x2-x1)+36*abs(y2-y1))/(36*14)+1;
-					}
+						distance = (6 * abs(x2 - x1) + 36 * abs(y2 - y1)) / (36 * 14) + 1;
 
-					if ((distance + node[i].dist < node[nnodes].dist) && (distance + node[i].dist < node[k].dist))
-					{
-						if (NewCheck(0, x1,y1,x2,y2))
-						{
+					if (distance + node[i].dist < node[nnodes].dist && distance + node[i].dist < node[k].dist) {
+						if (NewCheck(0, x1, y1, x2, y2)) {
 							node[k].level = level + 1;
-							node[k].dist  = distance + node[i].dist;
-							node[k].prev  = i;
+							node[k].dist = distance + node[i].dist;
+							node[k].prev = i;
 							changed = 1;
 						}
 					}
 				}
-				k-=1;
-			}
-			while(k > 0);	
+				k--;
+			} while (k > 0);
 		}
-		i=i+1;
-	}
-	while(i < nnodes);	
+		i++;
+	} while (i < nnodes);
+
 	return changed;
 }
 
-
-int32 NewCheck(int32 status, int32 x1 , int32 y1 , int32 x2 ,int32 y2)
-/*******************************************************************************
- * NewCheck routine checks if the route between two points can be achieved
- * without crossing any of the bars in the Bars array. 
- *
- * NewCheck differs from check in that that 4 route options are considered
- * corresponding to actual walked routes.
- *
- * Note distance doesnt take account of shrinking ??? 
- *
- * Note Bars array must be properly calculated ie min max dx dy co
- *******************************************************************************/
-{
-  int32   ldx;
-  int32   ldy;
-  int32   dlx;
-  int32   dly;
-  int32   dirX;
-  int32   dirY;
-  int32   step1;   
-  int32   step2;   
-  int32   step3;   
-  int32   steps;   
-  int32   options;   
+int32 NewCheck(int32 status, int32 x1, int32 y1, int32 x2, int32 y2) {
+	/*********************************************************************
+	 * NewCheck routine checks if the route between two points can be
+	 * achieved without crossing any of the bars in the Bars array. 
+	 *
+	 * NewCheck differs from check in that that 4 route options are
+	 * considered corresponding to actual walked routes.
+	 *
+	 * Note distance doesnt take account of shrinking ??? 
+	 *
+	 * Note Bars array must be properly calculated ie min max dx dy co
+	 *********************************************************************/
+
+	int32 ldx;
+	int32 ldy;
+	int32 dlx;
+	int32 dly;
+	int32 dirX;
+	int32 dirY;
+	int32 step1;   
+	int32 step2;   
+	int32 step3;   
+	int32 steps;   
+	int32 options;   
 
 	steps = 0;
 	options = 0;
-  ldx = x2 - x1;
-  ldy = y2 - y1;
+	ldx = x2 - x1;
+	ldy = y2 - y1;
 	dirX = 1;
 	dirY = 1;
-	if (ldx < 0)
-	{
+
+	if (ldx < 0) {
 		ldx = -ldx;
 		dirX = -1;
 	}
 
-	if (ldy < 0)
-	{
+	if (ldy < 0) {
 		ldy = -ldy;
 		dirY = -1;
 	}
 
-	//make the route options
-	if ((diagonaly * ldx) > (diagonalx * ldy))	// dir  = 1,2 or 2,3 or 5,6 or 6,7
-	{
-	  dly = ldy;
-		dlx = (ldy*diagonalx)/diagonaly;
+	// make the route options
+
+	if (diagonaly * ldx > diagonalx * ldy) {
+		// dir  = 1,2 or 2,3 or 5,6 or 6,7
+
+		dly = ldy;
+		dlx = (ldy * diagonalx) / diagonaly;
 		ldx = ldx - dlx;
 		dlx = dlx * dirX;
 		dly = dly * dirY;
@@ -2079,101 +2034,65 @@ int32 NewCheck(int32 status, int32 x1 , int32 y1 , int32 x2 ,int32 y2)
 
 	 	//options are
 		//square, diagonal a code 1 route
-		step1 = Check(x1, y1, x1+ldx, y1);
-		if (step1 != 0)
-		{
-			step2 = Check(x1+ldx, y1, x2, y2);
-			if (step2 != 0)
-			{
-				steps = step1 + step2;	// yes
+
+		step1 = Check(x1, y1, x1 + ldx, y1);
+		if (step1 != 0) {
+			step2 = Check(x1 + ldx, y1, x2, y2);
+			if (step2 != 0) {
+				steps = step1 + step2;
 				options = options + 2;
-		#ifdef PLOT_PATHS
-		if (status == 1)
-		{
-			RouteLine(x1, y1, x1+ldx, y1, 231);
-			RouteLine(x1+ldx, y1, x2, y2, 231);
-		}
-    #endif   
 			}
 		}
+
 		//diagonal, square a code 2 route
-		if ((steps == 0) || (status == 1))
-		{
-			step1 = Check(x1, y1, x1+dlx,y1+dly);
-			if (step1 != 0)
-			{
-				step2 = Check(x1+dlx, y2, x2, y2);
-				if (step2 != 0)
-				{
-					steps = step1 + step2;	// yes
+
+		if (steps == 0 || status == 1) {
+			step1 = Check(x1, y1, x1 + dlx, y1 + dly);
+			if (step1 != 0) {
+				step2 = Check(x1 + dlx, y2, x2, y2);
+				if (step2 != 0) {
+					steps = step1 + step2;
 					options = options + 4;
-		#ifdef PLOT_PATHS
-		if (status == 1)
-		{
-			RouteLine(x1, y1, x1+dlx,y1+dly, 231);
-			RouteLine(x1+dlx, y2, x2, y2, 231);
-		}
-    #endif   
 				}
 			}
 		}
+
 		//halfsquare, diagonal, halfsquare a code 0 route
-		if ((steps == 0) || (status == 1))
-		{
-			step1 = Check(x1, y1, x1+ldx/2, y1);
-			if (step1 != 0)
-			{
-				step2 = Check(x1+ldx/2, y1, x1+ldx/2+dlx, y2);
-				if (step2 != 0)
-				{
-					step3 = Check(x1+ldx/2+dlx, y2, x2, y2);
-					if (step3 != 0)
-					{
-						steps = step1 + step2 + step3;	// yes
-					options = options + 1;
-		#ifdef PLOT_PATHS
-		if (status == 1)
-		{
-			RouteLine(x1, y1, x1+ldx/2, y1, 231);
-			RouteLine(x1+ldx/2, y1, x1+ldx/2+dlx, y2, 231);
-			RouteLine(x1+ldx/2+dlx, y2, x2, y2, 231);
-		}
-    #endif   
+
+		if (steps == 0 || status == 1) {
+			step1 = Check(x1, y1, x1 + ldx / 2, y1);
+			if (step1 != 0) {
+				step2 = Check(x1 + ldx / 2, y1, x1 + ldx / 2 + dlx, y2);
+				if (step2 != 0) {
+					step3 = Check(x1 + ldx / 2 + dlx, y2, x2, y2);
+					if (step3 != 0)	{
+						steps = step1 + step2 + step3;
+						options++;
 					}
 				}
 			}
 		}
+
 		//halfdiagonal, square, halfdiagonal a code 3 route
-		if ((steps == 0) || (status == 1))
-		{
-			step1 = Check(x1, y1, x1+dlx/2, y1+dly/2);
-			if (step1 != 0)
-			{
-				step2 = Check(x1+dlx/2, y1+dly/2, x1+ldx+dlx/2, y1+dly/2);
-				if (step2 != 0)
-				{
-					step3 = Check(x1+ldx+dlx/2, y1+dly/2, x2, y2);
-					if (step3 != 0)
-					{
-						steps = step1 + step2 + step3;	// yes
-		#ifdef PLOT_PATHS
-		if (status == 1)
-		{
-			RouteLine(x1, y1, x1+dlx/2, y1+dly/2, 231);
-			RouteLine(x1+dlx/2, y1+dly/2, x1+ldx+dlx/2, y1+dly/2, 231);
-			RouteLine(x1+ldx+dlx/2, y1+dly/2, x2, y2, 231);
-		}
-    #endif   
+
+		if (steps == 0 || status == 1) {
+			step1 = Check(x1, y1, x1 + dlx / 2, y1 + dly / 2);
+			if (step1 != 0) {
+				step2 = Check(x1 + dlx / 2, y1 + dly / 2, x1 + ldx + dlx / 2, y1 + dly / 2);
+				if (step2 != 0) {
+					step3 = Check(x1 + ldx + dlx / 2, y1 + dly / 2, x2, y2);
+					if (step3 != 0) {
+						steps = step1 + step2 + step3;
 						options = options + 8;
 					}
 				}
 			}
 		}
-	}
-	else // dir  = 7,0 or 0,1 or 3,4 or 4,5
-	{
-	  dlx = ldx;
-		dly = (ldx*diagonaly)/diagonalx;
+	} else {
+		// dir  = 7,0 or 0,1 or 3,4 or 4,5
+
+		dlx = ldx;
+		dly = (ldx * diagonaly) / diagonalx;
 		ldy = ldy - dly;
 		dlx = dlx * dirX;
 		dly = dly * dirY;
@@ -2182,213 +2101,156 @@ int32 NewCheck(int32 status, int32 x1 , int32 y1 , int32 x2 ,int32 y2)
 
 	 	//options are
 		//square, diagonal a code 1 route
-		step1 = Check(x1 ,y1 ,x1 ,y1+ldy );
-		if (step1 != 0)
-		{
-			step2 = Check(x1 ,y1+ldy ,x2,y2);
-			if (step2 != 0)
-			{
-				steps = step1 + step2;	// yes
-		#ifdef PLOT_PATHS
-		if (status == 1)
-		{
-			RouteLine(x1 ,y1 ,x1 ,y1+ldy, 231);
-			RouteLine(x1 ,y1+ldy ,x2, y2, 231);
-		}
-    #endif   
+
+		step1 = Check(x1 ,y1, x1, y1 + ldy);
+		if (step1 != 0)	{
+			step2 = Check(x1, y1 + ldy, x2, y2);
+			if (step2 != 0) {
+				steps = step1 + step2;
 				options = options + 2;
 			}
 		}
+
 		//diagonal, square a code 2 route
-		if ((steps == 0) || (status == 1))
-		{
-			step1 = Check(x1, y1, x2, y1+dly);
-			if (step1 != 0)
-			{
-				step2 = Check(x2, y1+dly, x2, y2);
-				if (step2 != 0)
-				{
-					steps = step1 + step2;	// yes
-		#ifdef PLOT_PATHS
-		if (status == 1)
-		{
-			RouteLine(x1, y1, x2, y1+dly, 231);
-			RouteLine(x2, y1+dly, x2, y2, 231);
-		}
-    #endif   
+
+		if (steps == 0 || status == 1) {
+			step1 = Check(x1, y1, x2, y1 + dly);
+			if (step1 != 0) {
+				step2 = Check(x2, y1 + dly, x2, y2);
+				if (step2 != 0) {
+					steps = step1 + step2;
 					options = options + 4;
 				}
 			}
 		}
+
 		//halfsquare, diagonal, halfsquare a code 0 route
-		if ((steps == 0) || (status == 1))
-		{
-			step1 = Check(x1, y1, x1, y1+ldy/2);
-			if (step1 != 0)
-			{
-				step2 = Check(x1, y1+ldy/2, x2, y1+ldy/2+dly);
-				if (step2 != 0)
-				{
-					step3 = Check(x2, y1+ldy/2+dly, x2, y2);
-					if (step3 != 0)
-					{
-						steps = step1 + step2 + step3;	// yes
-		#ifdef PLOT_PATHS
-		if (status == 1)
-		{
-			RouteLine(x1, y1, x1, y1+ldy/2, 231);
-			RouteLine(x1, y1+ldy/2, x2, y1+ldy/2+dly, 231);
-			RouteLine(x2, y1+ldy/2+dly, x2, y2, 231);
-		}
-    #endif   
-						options = options + 1;
+
+		if (steps == 0 || status == 1) {
+			step1 = Check(x1, y1, x1, y1 + ldy / 2);
+			if (step1 != 0) {
+				step2 = Check(x1, y1 + ldy / 2, x2, y1 + ldy / 2 + dly);
+				if (step2 != 0) {
+					step3 = Check(x2, y1 + ldy / 2 + dly, x2, y2);
+					if (step3 != 0) {
+						steps = step1 + step2 + step3;
+						options++;
 					}
 				}
 			}
 		}
+
 		//halfdiagonal, square, halfdiagonal a code 3 route
-		if ((steps == 0) || (status == 1))
-		{
-			step1 = Check(x1, y1, x1+dlx/2, y1+dly/2);
-			if (step1 != 0)
-			{
-				step2 = Check(x1+dlx/2, y1+dly/2, x1+dlx/2, y1+ldy+dly/2);
-				if (step2 != 0)
-				{
-					step3 = Check(x1+dlx/2, y1+ldy+dly/2, x2, y2);
-					if (step3 != 0)
-					{
-						steps = step1 + step2 + step3;	// yes
+
+		if (steps == 0 || status == 1) {
+			step1 = Check(x1, y1, x1 + dlx / 2, y1 + dly / 2);
+			if (step1 != 0) {
+				step2 = Check(x1 + dlx / 2, y1 + dly / 2, x1 + dlx / 2, y1 + ldy + dly / 2);
+				if (step2 != 0) {
+					step3 = Check(x1 + dlx / 2, y1 + ldy + dly / 2, x2, y2);
+					if (step3 != 0)	{
+						steps = step1 + step2 + step3;
 						options = options + 8;
-		#ifdef PLOT_PATHS
-		if (status == 1)
-		{
-			RouteLine(x1, y1, x1+dlx/2, y1+dly/2, 231);
-			RouteLine(x1+dlx/2, y1+dly/2, x1+dlx/2, y1+ldy+dly/2, 231);
-			RouteLine(x1+dlx/2, y1+ldy+dly/2, x2, y2, 231);
-		}
-    #endif   
 					}
 				}
 			}
 		}
 	}
+
 	if (status == 0)
-	{
 		status = steps;
-	}
 	else
-	{
 		status = options;
-	}
+
 	return status;
 }
 
+// CHECK ROUTINES
 
-/*******************************************************************************
- *******************************************************************************
- * 														CHECK ROUTINES
- *******************************************************************************
- *******************************************************************************/
+int32 Check(int32 x1, int32 y1, int32 x2, int32 y2) {
+	// call the fastest line check for the given line 
+	// returns 1 if line didn't cross any bars
 
+	if (x1 == x2 && y1 == y2)
+		return 1;
 
-int32 Check(int32 x1 , int32 y1 , int32 x2 ,int32 y2)
-{
-//call the fastest line check for the given line 
-//returns 1 if line didn't cross any bars
-  int32   steps;
+	if (x1 == x2)
+		return VertCheck(x1, y1, y2);
 
-	if ((x1 == x2) && (y1 == y2))
-	{
-		steps = 1;
-	}
-	else if (x1 == x2)
-	{
-		steps = VertCheck(x1, y1, y2);
-	}
-	else if (y1 == y2)
-	{
-		steps = HorizCheck(x1, y1, x2);
-	}
-	else
-	{
-		steps = LineCheck(x1, y1, x2, y2);
-	}
-	return steps;
+	if (y1 == y2)
+		return HorizCheck(x1, y1, x2);
 
+	return LineCheck(x1, y1, x2, y2);
 }
 
-
-int32 LineCheck(int32 x1 , int32 y1 , int32 x2 ,int32 y2)
-{
-  int32   dirx;
-  int32   diry;
-  int32   co;
-  int32   slope;   
-  int32   i;
-  int32   xc;
-  int32   yc;
-  int32   xmin;
-  int32   ymin;
-  int32   xmax;
-  int32   ymax;
-  int32   linesCrossed = 1;   
-
-
-  if (x1 > x2)
-  {
-  	xmin = x2;    
-  	xmax = x1;
-  }
-  else
-  {
-  	xmin = x1;    
-  	xmax = x2;    
-	}
-  if (y1 > y2)
-  {
-  	ymin = y2;    
-  	ymax = y1;
-  }
-  else
-  {
-  	ymin = y1;    
-  	ymax = y2;    
-	}
-  //line set to go one step in chosen direction
-  //so ignore if it hits anything
-  dirx = x2 - x1;
+int32 LineCheck(int32 x1, int32 y1, int32 x2, int32 y2) {
+	int32 dirx;
+	int32 diry;
+	int32 co;
+	int32 slope;   
+	int32 i;
+	int32 xc;
+	int32 yc;
+	int32 xmin;
+	int32 ymin;
+	int32 xmax;
+	int32 ymax;
+	int32 linesCrossed = 1;   
+
+	if (x1 > x2) {
+		xmin = x2;    
+		xmax = x1;
+	} else {
+		xmin = x1;    
+		xmax = x2;    
+	}
+
+	if (y1 > y2) {
+		ymin = y2;    
+		ymax = y1;
+	} else {
+		ymin = y1;    
+		ymax = y2;    
+	}
+
+	// line set to go one step in chosen direction
+	// so ignore if it hits anything
+
+	dirx = x2 - x1;
 	diry = y2 - y1;
-  co = (y1 *dirx)- (x1*diry);       //new line equation
-
-  i = 0;          
-  do
-  {
-		// this is the inner inner loop
-	  if ((xmax >= bars[i].xmin) && ( xmin <= bars[i].xmax))  //skip if not on module 
-    {
-			if ((ymax >= bars[i].ymin) && ( ymin <= bars[i].ymax))  //skip if not on module 
-	    {
+
+	co = (y1 * dirx)- (x1 * diry);		// new line equation
+
+	i = 0;          
+
+	do {
+		// skip if not on module 
+		if (xmax >= bars[i].xmin && xmin <= bars[i].xmax) {
+			// skip if not on module 
+			if (ymax >= bars[i].ymin && ymin <= bars[i].ymax) {
 				// okay its a valid line calculate an intersept
-				// wow but all this arithmatic we must have loads of time
-		    slope = (bars[i].dx * diry) - (bars[i].dy *dirx);// slope it he slope between the two lines
-		    if (slope != 0)//assuming parallel lines don't cross
-		    {
-					//calculate x intercept and check its on both lines
-			    xc = ((bars[i].co * dirx) - (co * bars[i].dx)) / slope;
-
-			    if ((xc >= xmin-1) && (xc <= xmax+1))   //skip if not on module 
-			    {
-					  if ((xc >= bars[i].xmin-1) && (xc <= bars[i].xmax+1))   //skip if not on line 
-				    {
-
-					    yc = ((bars[i].co * diry) - (co * bars[i].dy)) / slope;
-
-					    if ((yc >= ymin-1) && (yc <= ymax+1))   //skip if not on module 
-					    {
-						    if ((yc >= bars[i].ymin-1) && (yc <= bars[i].ymax+1))   //skip if not on line 
-						    {
-							 	  linesCrossed = 0;
+				// wow but all this arithmatic we must have
+				// loads of time
+
+				// slope it he slope between the two lines
+				slope = (bars[i].dx * diry) - (bars[i].dy *dirx);
+				// assuming parallel lines don't cross
+				if (slope != 0) {
+					// calculate x intercept and check its
+					// on both lines
+					xc = ((bars[i].co * dirx) - (co * bars[i].dx)) / slope;
+
+					// skip if not on module
+					if (xc >= xmin - 1 &&  xc <= xmax + 1) {
+						// skip if not on line 
+						if (xc >= bars[i].xmin - 1 && xc <= bars[i].xmax + 1) {
+							yc = ((bars[i].co * diry) - (co * bars[i].dy)) / slope;
+
+							// skip if not on module
+							if (yc >= ymin - 1 && yc <= ymax + 1) {
+								// skip if not on line 
+								if (yc >= bars[i].ymin - 1 && yc <= bars[i].ymax + 1) {
+									linesCrossed = 0;
 								}
 							}
 						}
@@ -2396,135 +2258,120 @@ int32 LineCheck(int32 x1 , int32 y1 , int32 x2 ,int32 y2)
 				}
 			}
 		}
-    i = i + 1;
-  }
-  while((i < nbars) && linesCrossed);
+		i++;
+	} while(i < nbars && linesCrossed);
 
-  return linesCrossed;
+	return linesCrossed;
 }
 
-
-int32 HorizCheck(int32 x1 , int32 y , int32 x2)
-{
-  int32   ldy;
-  int32   i;
-  int32   xc;
-  int32   xmin;
-  int32   xmax;
-  int32   linesCrossed = 1;   
-
-  if (x1 > x2)
-  {
-  	xmin = x2;    
-  	xmax = x1;
-  }
-  else
-  {
-  	xmin = x1;    
-  	xmax = x2;    
-	}
-  //line set to go one step in chosen direction
-  //so ignore if it hits anything
-
-  i = 0;          
-  do
-  {
-		// this is the inner inner loop
-	  if ((xmax >= bars[i].xmin) && ( xmin <= bars[i].xmax))  //skip if not on module 
-    {
-			if ((y >= bars[i].ymin) && ( y <= bars[i].ymax))  //skip if not on module 
-	    {
-				// okay its a valid line calculate an intersept
-				// wow but all this arithmatic we must have loads of time
-		    if (bars[i].dy == 0)
-		    {
-			    linesCrossed = 0;          
-		    }
-				else
-				{
-					ldy = y-bars[i].y1;
-					xc = bars[i].x1 + (bars[i].dx * ldy)/bars[i].dy;
-		    	if ((xc >= xmin-1) && (xc <= xmax+1))   //skip if not on module 
-		    	{
-				    linesCrossed = 0;          
-		    	}
+int32 HorizCheck(int32 x1, int32 y, int32 x2) {
+	int32 ldy;
+	int32 i;
+	int32 xc;
+	int32 xmin;
+	int32 xmax;
+	int32 linesCrossed = 1;   
+
+	if (x1 > x2) {
+		xmin = x2;    
+		xmax = x1;
+	} else {
+		xmin = x1;    
+		xmax = x2;    
+	}
+
+	// line set to go one step in chosen direction
+	// so ignore if it hits anything
+
+	i = 0;          
+
+	do {
+		// skip if not on module 
+		if (xmax >= bars[i].xmin && xmin <= bars[i].xmax) {
+			// skip if not on module 
+			if (y >= bars[i].ymin && y <= bars[i].ymax) {
+				// okay its a valid line calculate an intercept
+				// wow but all this arithmatic we must have
+				// loads of time
+
+				if (bars[i].dy == 0)
+					linesCrossed = 0;          
+				else {
+					ldy = y - bars[i].y1;
+					xc = bars[i].x1 + (bars[i].dx * ldy) / bars[i].dy;
+					// skip if not on module 
+				    	if (xc >= xmin - 1 && xc <= xmax + 1)
+						linesCrossed = 0;          
 				}
 			}
 		}
-    i = i + 1;
-  }
-  while((i < nbars) && linesCrossed);
+		i++;
+	} while(i < nbars && linesCrossed);
 
-  return linesCrossed;
+	return linesCrossed;
 }
 
-
-int32 VertCheck(int32 x, int32 y1, int32 y2)
-{
-  int32   ldx;
-  int32   i;
-  int32   yc;
-  int32   ymin;
-  int32   ymax;
-  int32   linesCrossed = 1;   
-
-  if (y1 > y2)
-  {
-  	ymin = y2;    
-  	ymax = y1;
-  }
-  else
-  {
-  	ymin = y1;    
-  	ymax = y2;    
-	}
-  //line set to go one step in chosen direction
-  //so ignore if it hits anything
-  i = 0;          
-  do		// this is the inner inner loop
-  {
-	  if ((x >= bars[i].xmin) && ( x <= bars[i].xmax))  //overlapping
-    {
-			if ((ymax >= bars[i].ymin) && ( ymin <= bars[i].ymax))  //skip if not on module 
-		  {
-				// okay its a valid line calculate an intersept
-				// wow but all this arithmatic we must have loads of time
-		    if (bars[i].dx == 0)//both lines vertical and overlap in x and y so they cross
-		    {
-			    linesCrossed = 0;
-		    }
-				else
-				{
-			 		ldx = x-bars[i].x1;
-					yc = bars[i].y1 + (bars[i].dy * ldx)/bars[i].dx;
-			    if ((yc >= ymin-1) && (yc <= ymax+1))   //the intersept overlaps 
-			    {
-				    linesCrossed = 0;
-			    }
+int32 VertCheck(int32 x, int32 y1, int32 y2) {
+	int32 ldx;
+	int32 i;
+	int32 yc;
+	int32 ymin;
+	int32 ymax;
+	int32 linesCrossed = 1;   
+
+	if (y1 > y2) {
+		ymin = y2;    
+		ymax = y1;
+	} else {
+		ymin = y1;    
+		ymax = y2;    
+	}
+
+	// line set to go one step in chosen direction
+	// so ignore if it hits anything
+
+	i = 0;          
+
+	do {
+		if (x >= bars[i].xmin && x <= bars[i].xmax) {
+			// overlapping
+			// skip if not on module 
+			if (ymax >= bars[i].ymin && ymin <= bars[i].ymax) {
+				// okay its a valid line calculate an intercept
+				// wow but all this arithmatic we must have
+				// loads of time
+
+				// both lines vertical and overlap in x and y
+				// so they cross
+
+				if (bars[i].dx == 0)
+					linesCrossed = 0;
+				else {
+			 		ldx = x - bars[i].x1;
+					yc = bars[i].y1 + (bars[i].dy * ldx) / bars[i].dx;
+					// the intercept overlaps 
+					if (yc >= ymin - 1 && yc <= ymax + 1)
+						linesCrossed = 0;
 				}
 			}
-    }
-    i = i + 1;
-  }
-  while((i < nbars) && linesCrossed);
+		}
+		i++;
+	} while(i < nbars && linesCrossed);
 
-  return linesCrossed;
+	return linesCrossed;
 }
 
-int32 CheckTarget(int32 x , int32 y)
-/*******************************************************************************
- *******************************************************************************/
-{
-  int32   ldx;
-  int32   ldy;
-  int32   i;
-  int32   xc;
-  int32   yc;
-  int32   xmin;
-  int32   xmax;
-  int32   ymin;
-  int32   ymax;
-  int32   onLine = 0;   
+int32 CheckTarget(int32 x, int32 y) {
+	int32 ldx;
+	int32 ldy;
+	int32 i;
+	int32 xc;
+	int32 yc;
+	int32 xmin;
+	int32 xmax;
+	int32 ymin;
+	int32 ymax;
+	int32 onLine = 0;   
 
  	xmin = x - 1;    
  	xmax = x + 1;
@@ -2532,104 +2379,89 @@ int32 CheckTarget(int32 x , int32 y)
  	ymax = y + 1;
 
 	// check if point +- 1 is on the line
-  //so ignore if it hits anything
+	//so ignore if it hits anything
 
-  i = 0;          
-  do
-  {
+	i = 0;          
 
-		// this is the inner inner loop
+	do {
+		// overlapping line 
+		if (xmax >= bars[i].xmin && xmin <= bars[i].xmax) {
+			//overlapping line 
+			if (ymax >= bars[i].ymin && ymin <= bars[i].ymax) {
+				// okay this line overlaps the target calculate
+				// an y intercept for x 
 
-	  if ((xmax >= bars[i].xmin) && ( xmin <= bars[i].xmax))  //overlapping line 
-    {
-			if ((ymax >= bars[i].ymin) && ( ymin <= bars[i].ymax))  //overlapping line 
-	    {
-
-				// okay this line overlaps the target calculate an y intersept for x 
-
-		    if (bars[i].dx == 0)// vertical line so we know it overlaps y
-		    {
+				// vertical line so we know it overlaps y
+				if (bars[i].dx == 0)
 					yc = 0; 	
-		    }
-				else
-				{
-					ldx = x-bars[i].x1;
-					yc = bars[i].y1 + (bars[i].dy * ldx)/bars[i].dx;
+				else {
+					ldx = x - bars[i].x1;
+					yc = bars[i].y1 + (bars[i].dy * ldx) / bars[i].dx;
 				}
 
-		    if ((yc >= ymin) && (yc <= ymax))   //overlapping point for y 
-		    {
-			    onLine = 3;// target on a line so drop out
-					//Zdebug("RouteFail due to target on a line %d %d",x,y);
-				}
-				else
-				{
-			    if (bars[i].dy == 0)// vertical line so we know it overlaps y
-					{
+				// overlapping point for y 
+				if (yc >= ymin && yc <= ymax) {
+					// target on a line so drop out
+					onLine = 3;
+					// Zdebug("RouteFail due to target on a line %d %d", x, y);
+				} else {
+					// vertical line so we know it overlaps y
+					if (bars[i].dy == 0)
 						xc = 0;
-					}
-					else
-					{
-						ldy = y-bars[i].y1;
-						xc = bars[i].x1 + (bars[i].dx * ldy)/bars[i].dy;
+					else {
+						ldy = y - bars[i].y1;
+						xc = bars[i].x1 + (bars[i].dx * ldy) / bars[i].dy;
 					}
 
-				  if ((xc >= xmin) && (xc <= xmax))   //skip if not on module 
-				  {
-				    onLine = 3;// target on a line so drop out
-						//Zdebug("RouteFail due to target on a line %d %d",x,y);
-			    }
+					// skip if not on module 
+					if (xc >= xmin && xc <= xmax) {
+						// target on a line so drop out
+						onLine = 3;
+						// Zdebug("RouteFail due to target on a line %d %d", x, y);
+					}
 				}
-	    }
-    }
-    i = i + 1;
-  }
-  while((i < nbars) && (onLine == 0));
-
+			}
+		}
+	 	i++;
+	} while(i < nbars && onLine == 0);
 
-  return onLine;
+	return onLine;
 }
 
-/*******************************************************************************
- *******************************************************************************
- * 														THE SETUP ROUTINES
- *******************************************************************************
- *******************************************************************************/
-//------------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------------
-
-void LoadWalkData(Object_walkdata *ob_walkdata)
-{
-	uint8	direction;
-	uint16	firstFrameOfDirection;
-	uint16	walkFrameNo;
-	uint32	frameCounter = 0;	// starts at frame 0 of mega set (16sep96 JEL)
+// THE SETUP ROUTINES
+
+void LoadWalkData(Object_walkdata *ob_walkdata) {
+	uint8 direction;
+	uint16 firstFrameOfDirection;
+	uint16 walkFrameNo;
+	uint32 frameCounter = 0; // starts at frame 0 of mega set (16sep96 JEL)
       
+	nWalkFrames = ob_walkdata->nWalkFrames;
+	usingStandingTurnFrames = ob_walkdata->usingStandingTurnFrames;
+	usingWalkingTurnFrames = ob_walkdata->usingWalkingTurnFrames;
+	usingSlowInFrames = ob_walkdata->usingSlowInFrames;
+	usingSlowOutFrames = ob_walkdata->usingSlowOutFrames;
 
-	nWalkFrames				= ob_walkdata->nWalkFrames;
-	usingStandingTurnFrames	= ob_walkdata->usingStandingTurnFrames;
-	usingWalkingTurnFrames	= ob_walkdata->usingWalkingTurnFrames;
-	usingSlowInFrames		= ob_walkdata->usingSlowInFrames;
-	usingSlowOutFrames		= ob_walkdata->usingSlowOutFrames;
-	numberOfSlowOutFrames	= usingSlowOutFrames;	// 0 = not using slow out frames; non-zero = using that many frames for each leading leg for each direction
+	// 0 = not using slow out frames; non-zero = using that many frames
+	// for each leading leg for each direction
 
- 	memcpy(&numberOfSlowInFrames[0],ob_walkdata->nSlowInFrames,NO_DIRECTIONS*sizeof(numberOfSlowInFrames[0]));
- 	memcpy(&leadingLeg[0],ob_walkdata->leadingLeg,NO_DIRECTIONS*sizeof(leadingLeg[0]));
- 	memcpy(&dx[0],ob_walkdata->dx,NO_DIRECTIONS*(nWalkFrames+1)*sizeof(dx[0]));
- 	memcpy(&dy[0],ob_walkdata->dy,NO_DIRECTIONS*(nWalkFrames+1)*sizeof(dy[0]));
+	numberOfSlowOutFrames = usingSlowOutFrames;
 
-	//---------------------------------------------------------
+ 	memcpy(&numberOfSlowInFrames[0], ob_walkdata->nSlowInFrames, NO_DIRECTIONS * sizeof(numberOfSlowInFrames[0]));
+ 	memcpy(&leadingLeg[0], ob_walkdata->leadingLeg, NO_DIRECTIONS * sizeof(leadingLeg[0]));
+ 	memcpy(&dx[0], ob_walkdata->dx, NO_DIRECTIONS * (nWalkFrames + 1) * sizeof(dx[0]));
+ 	memcpy(&dy[0], ob_walkdata->dy, NO_DIRECTIONS * (nWalkFrames + 1) * sizeof(dy[0]));
 
-	for (direction=0; direction<NO_DIRECTIONS; direction++)
-	{
+	for (direction=0; direction < NO_DIRECTIONS; direction++) {
 		firstFrameOfDirection = direction * nWalkFrames;
 
-		modX[direction]=0;
-		modY[direction]=0;
+		modX[direction] = 0;
+		modY[direction] = 0;
 
-		for (walkFrameNo=firstFrameOfDirection; walkFrameNo < (firstFrameOfDirection + (nWalkFrames/2)); walkFrameNo++ )
-		{
-			modX[direction] += dx[walkFrameNo];	// eg. modX[0] is the sum of the x-step sizes for the first half of the walk cycle for direction 0
+		for (walkFrameNo = firstFrameOfDirection; walkFrameNo < firstFrameOfDirection + nWalkFrames / 2; walkFrameNo++) {
+			// eg. modX[0] is the sum of the x-step sizes for the
+			// first half of the walk cycle for direction 0
+			modX[direction] += dx[walkFrameNo];
 			modY[direction] += dy[walkFrameNo];
 		}
 	}
@@ -2637,416 +2469,389 @@ void LoadWalkData(Object_walkdata *ob_walkdata)
 	diagonalx =  modX[3];
 	diagonaly =  modY[3];
 
-	//----------------------------------------------------
 	// interpret the walk data
-	//----------------------------------------------------
 
-	framesPerStep = nWalkFrames/2;
+	framesPerStep = nWalkFrames / 2;
 	framesPerChar = nWalkFrames * NO_DIRECTIONS;
 
 	// offset pointers added Oct 30 95 JPS
 	// mega id references removed 16sep96 by JEL
 
-	//---------------------
 	// WALK FRAMES
 	// start on frame 0
+
 	frameCounter += framesPerChar;
 
-	//---------------------
 	// STAND FRAMES
-	firstStandFrame = frameCounter;	// stand frames come after the walk frames
-	frameCounter += NO_DIRECTIONS;	// one stand frame for each direction
+	// stand frames come after the walk frames
+	// one stand frame for each direction
+
+	firstStandFrame = frameCounter;
+	frameCounter += NO_DIRECTIONS;
 
-	//---------------------
 	// STANDING TURN FRAMES - OPTIONAL!
-	if (usingStandingTurnFrames)
-	{
-		firstStandingTurnLeftFrame	= frameCounter;	// standing turn-left frames come after the slow-out frames
-		frameCounter += NO_DIRECTIONS;							// one for each direction
+	// standing turn-left frames come after the slow-out frames
+	// one for each direction
+	// standing turn-left frames come after the standing turn-right frames
+	// one for each direction
 
-		firstStandingTurnRightFrame = frameCounter;	// standing turn-left frames come after the standing turn-right frames
-		frameCounter += NO_DIRECTIONS;							// one for each direction
-	}
-	else
-	{
-		firstStandingTurnLeftFrame	= firstStandFrame;	// refer instead to the normal stand frames
-		firstStandingTurnRightFrame	= firstStandFrame;	// -"-
+	if (usingStandingTurnFrames) {
+		firstStandingTurnLeftFrame = frameCounter;
+		frameCounter += NO_DIRECTIONS;
+
+		firstStandingTurnRightFrame = frameCounter;
+		frameCounter += NO_DIRECTIONS;
+	} else {
+		// refer instead to the normal stand frames
+		firstStandingTurnLeftFrame = firstStandFrame;
+		firstStandingTurnRightFrame = firstStandFrame;
 	}
-	//---------------------
+
 	// WALKING TURN FRAMES - OPTIONAL!
-	if (usingWalkingTurnFrames)
-	{
-		firstWalkingTurnLeftFrame		= frameCounter;	// walking left-turn frames come after the stand frames
+	// walking left-turn frames come after the stand frames
+	// walking right-turn frames come after the walking left-turn frames
+
+	if (usingWalkingTurnFrames) {
+		firstWalkingTurnLeftFrame = frameCounter;
 		frameCounter += framesPerChar;
 
-		firstWalkingTurnRightFrame	= frameCounter;	// walking right-turn frames come after the walking left-turn frames
+		firstWalkingTurnRightFrame = frameCounter;
 		frameCounter += framesPerChar;
+	} else {
+		firstWalkingTurnLeftFrame = 0;
+		firstWalkingTurnRightFrame = 0;
 	}
-	else
-	{
-		firstWalkingTurnLeftFrame		= 0;
-		firstWalkingTurnRightFrame	= 0;
-	}
-	//---------------------
+
 	// SLOW-IN FRAMES - OPTIONAL!
+	// slow-in frames come after the walking right-turn frames
 
-	if (usingSlowInFrames)	// slow-in frames come after the walking right-turn frames
-	{
-		for (direction=0; direction<NO_DIRECTIONS; direction++)
-		{
-			firstSlowInFrame[direction] = frameCounter;				// make note of frame number of first slow-in frame for each direction
-			frameCounter += numberOfSlowInFrames[direction];	// can be a different number of slow-in frames in each direction
+	if (usingSlowInFrames) {
+		// Make note of frame number of first slow-in frame for each
+		// direction. There may be a different number of slow-in
+		// frames in each direction
+
+		for (direction = 0; direction < NO_DIRECTIONS; direction++) {
+			firstSlowInFrame[direction] = frameCounter;
+			frameCounter += numberOfSlowInFrames[direction];
 		}
 	}
-	//---------------------
+
 	// SLOW-OUT FRAMES - OPTIONAL!
+	// slow-out frames come after the slow-in frames
 
 	if (usingSlowOutFrames)
-	{
-		firstSlowOutFrame	= frameCounter;	// slow-out frames come after the slow-in frames
-	}
-	//---------------------
+		firstSlowOutFrame = frameCounter;
 }
 
+// THE ROUTE EXTRACTOR
 
-/*******************************************************************************
- *******************************************************************************
- * 														THE ROUTE EXTRACTOR
- *******************************************************************************
- *******************************************************************************/
+void ExtractRoute() {
+	/*********************************************************************
+	 * ExtractRoute gets route from the node data after a full scan, route
+	 * is written with just the basic way points and direction options for
+	 * heading to the next point. 
+	 *********************************************************************/
 
-void	ExtractRoute()
-/****************************************************************************
- *    ExtractRoute	gets route from the node data after a full scan, route is
- *		written with just the basic way points and direction options for heading
- *		to the next point. 
- ****************************************************************************/
-{
-	int32	prev;
-	int32	prevx;
-	int32	prevy;
-	int32	last;
-	int32	point;
+	int32 prev;
+	int32 prevx;
+	int32 prevy;
+	int32 last;
+	int32 point;
 	int32 p;     
-	int32	dirx;
-	int32	diry;
-	int32	dir;
-	int32	ldx;
-	int32	ldy;
-
+	int32 dirx;
+	int32 diry;
+	int32 dir;
+	int32 ldx;
+	int32 ldy;
 
  	// extract the route from the node data
+
 	prev = nnodes;
 	last = prev;
 	point = O_ROUTE_SIZE - 1;
 	route[point].x = node[last].x;
 	route[point].y = node[last].y;
-	do
-	{
-		point = point -	1;
+
+	do {
+		point--;
 		prev = node[last].prev;
 		prevx = node[prev].x;
 		prevy = node[prev].y;
 		route[point].x = prevx;
 		route[point].y = prevy;
 		last = prev;
-	}
-	while (prev > 0);
+	} while (prev > 0);
 
 	// now shuffle route down in the buffer
+
 	routeLength = 0;
-	do
-	{
+
+	do {
 		route[routeLength].x = route[point].x;
 		route[routeLength].y = route[point].y;
-		point = point + 1;
-		routeLength = routeLength + 1;
-	}
-	while (point < O_ROUTE_SIZE);
+		point++;
+		routeLength++;
+	} while (point < O_ROUTE_SIZE);
+
 	routeLength = routeLength - 1;
 
 	// okay the route exists as a series point now put in some directions
-  p = 0;
-  do
-  {
-		#ifdef PLOT_PATHS
-			BresenhamLine(route[p+1].x-128,route[p+1].y-128, route[p].x-128,route[p].y-128, (uint8*)screen_ad, true_pixel_size_x, pixel_size_y, ROUTE_END_FLAG);
-    #endif   
-		ldx = route[p+1].x - route[p].x;
-		ldy = route[p+1].y - route[p].y;
+
+	p = 0;
+
+	do {
+		ldx = route[p + 1].x - route[p].x;
+		ldy = route[p + 1].y - route[p].y;
 		dirx = 1;
 		diry = 1;
-		if (ldx < 0)
-		{
+
+		if (ldx < 0) {
 			ldx = -ldx;
 			dirx = -1;
 		}
-		if (ldy < 0)
-		{
+
+		if (ldy < 0) {
 			ldy = -ldy;
 			diry = -1;
 		}
 
-		if ((diagonaly * ldx) > (diagonalx * ldy))	// dir  = 1,2 or 2,3 or 5,6 or 6,7
-		{
-			dir = 4 - 2 * dirx;	 // 2 or 6
+		if (diagonaly * ldx > diagonalx * ldy) {
+			// dir  = 1,2 or 2,3 or 5,6 or 6,7
+
+			// 2 or 6
+			dir = 4 - 2 * dirx;
 			route[p].dirS = dir;
-			dir = dir + diry * dirx; // 1,3,5 or 7
+
+			// 1, 3, 5 or 7
+			dir = dir + diry * dirx;
 			route[p].dirD = dir;
-		}
-		else // dir  = 7,0 or 0,1 or 3,4 or 4,5
-		{
-			dir = 2 + 2 * diry;	// 0 or 4
+		} else {
+			// dir  = 7,0 or 0,1 or 3,4 or 4,5
+
+			// 0 or 4
+			dir = 2 + 2 * diry;
 			route[p].dirS = dir;
-			dir = 4 - 2 * dirx;	 // 2 or 6
-			dir = dir + diry * dirx; // 1,3,5 or 7
+
+			// 2 or 6
+			dir = 4 - 2 * dirx;
+
+			// 1, 3, 5 or 7
+			dir = dir + diry * dirx;
 			route[p].dirD = dir;
 		}
-		p = p + 1;	
-	}
-	while (p < (routeLength));
+		p++;
+	} while (p < routeLength);
+
 	// set the last dir to continue previous route unless specified
-	if (targetDir == 8)	// ANY direction
-	{ 
-		route[p].dirS = route[p-1].dirS;
-		route[p].dirD = route[p-1].dirD;
-	}
-	else
-	{ 
+
+	if (targetDir == 8) {
+		// ANY direction
+		route[p].dirS = route[p - 1].dirS;
+		route[p].dirD = route[p - 1].dirD;
+	} else { 
 		route[p].dirS = targetDir;
 		route[p].dirD = targetDir;
 	}
-	return;
-}
-
-//*******************************************************************************
 
-void RouteLine(int32 x1,int32 y1,int32 x2,int32 y2 ,int32 colour)
-{
-	if (x1);
-	if (x2);
-	if (y1);
-	if (y2);
-	if (colour);
-//	BresenhamLine(x1-128, y1-128, x2-128, y2-128, (uint8*)screen_ad, true_pixel_size_x, pixel_size_y, colour);
 	return;
 }
 
-//*******************************************************************************
-
-void SetUpWalkGrid(Object_mega *ob_mega, int32 x, int32 y, int32 dir)
-{
+void SetUpWalkGrid(Object_mega *ob_mega, int32 x, int32 y, int32 dir) {
 	int32 i;
 
+	// get walk grid file + extra grid into 'bars' & 'node' arrays
+	LoadWalkGrid();
 
-	LoadWalkGrid();	// get walk grid file + extra grid into 'bars' & 'node' arrays
-
+	// copy the mega structure into the local variables for use in all
+	// subroutines
 
-	// copy the mega structure into the local variables for use in all subroutines
-
-	startX		= ob_mega->feet_x;
-	startY		= ob_mega->feet_y;
-	startDir	= ob_mega->current_dir;
-	targetX		= x;
-	targetY		= y;
-	targetDir	= dir;
-
-	scaleA		= ob_mega->scale_a;
-	scaleB		= ob_mega->scale_b;
+	startX = ob_mega->feet_x;
+	startY = ob_mega->feet_y;
+	startDir = ob_mega->current_dir;
+	targetX = x;
+	targetY = y;
+	targetDir = dir;
 
+	scaleA = ob_mega->scale_a;
+	scaleB = ob_mega->scale_b;
 
 	// mega's current position goes into first node
-	node[0].x		= startX;
-	node[0].y		= startY;
-	node[0].level	= 1;
-	node[0].prev	= 0;
-	node[0].dist	= 0;
+
+	node[0].x = startX;
+	node[0].y = startY;
+	node[0].level = 1;
+	node[0].prev = 0;
+	node[0].dist = 0;
 
 	// reset other nodes
-	for (i=1; i<nnodes; i++)
-	{
-		node[i].level	= 0;
-	  	node[i].prev	= 0;
-	  	node[i].dist	= 9999;
+
+	for (i = 1; i < nnodes; i++) {
+		node[i].level = 0;
+	  	node[i].prev = 0;
+	  	node[i].dist = 9999;
 	}
 
 	// target position goes into final node
-	node[nnodes].x		= targetX;
-	node[nnodes].y		= targetY;
-	node[nnodes].level	= 0;
-	node[nnodes].prev	= 0;
-	node[nnodes].dist	= 9999;
+	node[nnodes].x = targetX;
+	node[nnodes].y = targetY;
+	node[nnodes].level = 0;
+	node[nnodes].prev = 0;
+	node[nnodes].dist = 9999;
 }
 
-//------------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------------
-void PlotWalkGrid(void)
-{
+void PlotWalkGrid(void) {
 	int32 j;
       
+	// get walk grid file + extra grid into 'bars' & 'node' arrays
+	LoadWalkGrid();
 
-	LoadWalkGrid();	// get walk grid file + extra grid into 'bars' & 'node' arrays
-
-	//-------------------------------
 	// lines
 
-	for (j=0; j<nbars; j++)
-	{
-		DrawLine(bars[j].x1,bars[j].y1, bars[j].x2,bars[j].y2, 254);
-	}
-	//-------------------------------
+	for (j = 0; j < nbars; j++)
+		DrawLine(bars[j].x1, bars[j].y1, bars[j].x2, bars[j].y2, 254);
+
 	// nodes
 
-	for (j=1; j<nnodes; j++)	// leave node 0 for start node
-	{
-		PlotCross(node[j].x,node[j].y, 184);
-	}
-	//-------------------------------
+	// leave node 0 for start node
+	for (j = 1; j < nnodes; j++)
+		PlotCross(node[j].x, node[j].y, 184);
 }
-//------------------------------------------------------------------------------------------
-void PlotCross(int16 x, int16 y, uint8 colour)
-{
-	DrawLine(x-1, y-1, x+1, y+1, colour);
-	DrawLine(x+1, y-1, x-1, y+1, colour);	
+
+void PlotCross(int16 x, int16 y, uint8 colour) {
+	DrawLine(x - 1, y - 1, x + 1, y + 1, colour);
+	DrawLine(x + 1, y - 1, x - 1, y + 1, colour);	
 }
-//------------------------------------------------------------------------------------------
-//------------------------------------------------------------------------------------------
-
-void LoadWalkGrid(void)
-{
-//	_standardHeader	header;
-	_walkGridHeader	floorHeader;
-	uint32 	j;
-	uint8  *fPolygrid;
+
+void LoadWalkGrid(void) {
+	_walkGridHeader floorHeader;
+	uint32 j;
+	uint8 *fPolygrid;
  	int entry;
 	uint32 theseBars;
 	uint32 theseNodes;
 
-
 	nbars	= 0;	// reset counts
 	nnodes	= 1;	// leave node 0 for start-node
 
-	//-------------------------------
 	// STATIC GRIDS (added/removed by object logics)
 
-	for (entry=0; entry < MAX_WALKGRIDS; entry++)	// go through walkgrid list
-	{
-		if (walkGridList[entry])
-		{
-			fPolygrid = res_man.Res_open(walkGridList[entry]);	// open walk grid file
-
- //			memmove( (uint8*)&header, fPolygrid, sizeof(_standardHeader) );
+	// go through walkgrid list
+	for (entry = 0; entry < MAX_WALKGRIDS; entry++) {
+		if (walkGridList[entry]) {
+			// open walk grid file
+			fPolygrid = res_man.Res_open(walkGridList[entry]);
  			fPolygrid += sizeof(_standardHeader);
-
- 			memmove( (uint8*)&floorHeader, fPolygrid, sizeof(_walkGridHeader) );
+ 			memmove((uint8 *) &floorHeader, fPolygrid, sizeof(_walkGridHeader));
  			fPolygrid += sizeof(_walkGridHeader);
 
-			//-------------------------------
-			// how many bars & nodes are we getting from this walkgrid file
-
-			theseBars	= floorHeader.numBars;
-			theseNodes	= floorHeader.numNodes;
+			// how many bars & nodes are we getting from this
+			// walkgrid file
 
-			//-------------------------------
-			// check that we're not going to exceed the max allowed in the complete walkgrid arrays
+			theseBars = floorHeader.numBars;
+			theseNodes = floorHeader.numNodes;
 
-			#ifdef _SWORD2_DEBUG
-			if ((nbars+theseBars) >= O_GRID_SIZE)
-				Con_fatal_error("Adding walkgrid(%d): %d+%d bars exceeds max %d (%s line %u)", walkGridList[entry], nbars, theseBars, O_GRID_SIZE, __FILE__, __LINE__);
-
-			if ((nnodes+theseNodes) >= O_GRID_SIZE)
-				Con_fatal_error("Adding walkgrid(%d): %d+%d nodes exceeds max %d (%s line %u)", walkGridList[entry], nnodes, theseBars, O_GRID_SIZE, __FILE__, __LINE__);
-			#endif
+#ifdef _SWORD2_DEBUG
+			// check that we're not going to exceed the max
+			// allowed in the complete walkgrid arrays
+
+			if (nbars + theseBars >= O_GRID_SIZE)
+				Con_fatal_error("Adding walkgrid(%d): %d+%d bars exceeds max %d (%s line %u)",
+					walkGridList[entry], nbars, theseBars,
+					O_GRID_SIZE, __FILE__, __LINE__);
+
+			if (nnodes + theseNodes >= O_GRID_SIZE)
+				Con_fatal_error("Adding walkgrid(%d): %d+%d nodes exceeds max %d (%s line %u)",
+					walkGridList[entry], nnodes, theseBars,
+					O_GRID_SIZE, __FILE__, __LINE__);
+#endif
 
-			//-------------------------------
 			// lines
 
- 			memmove( (uint8*)&bars[nbars], fPolygrid, theseBars*sizeof(_barData) );
-			fPolygrid += theseBars*sizeof(_barData);//move pointer to start of node data
+ 			memmove((uint8 *) &bars[nbars], fPolygrid, theseBars * sizeof(_barData));
+
+			//move pointer to start of node data
+			fPolygrid += theseBars * sizeof(_barData);
 
-			//-------------------------------
 			// nodes
 
-			for (j=0; j<theseNodes; j++)	// leave node 0 for start node
-			{
-				memmove( (uint8*)&node[nnodes+j].x, fPolygrid, 2*sizeof(int16) );
-				fPolygrid += 2*sizeof(int16);
+			// leave node 0 for start node
+			for (j = 0; j < theseNodes; j++) {
+				memmove((uint8 *) &node[nnodes + j].x, fPolygrid, 2 * sizeof(int16));
+				fPolygrid += 2 * sizeof(int16);
 			}
 
- 			//-------------------------------
+			// close walk grid file
+			res_man.Res_close(walkGridList[entry]);
 
-			res_man.Res_close(walkGridList[entry]);	// close walk grid file
+			// increment counts of total bars & nodes in whole
+			// walkgrid
 
-			nbars	+= theseBars;	// increment counts of total bars & nodes in whole walkgrid
+			nbars += theseBars;
 			nnodes	+= theseNodes;
 		}
 	}
 
-	//-------------------------------
 	// EXTRA GRIDS (moveable grids added by megas)
 
-	// Note that these will be checked against allowed max at the time of creating them
+	// Note that these will be checked against allowed max at the time of
+	// creating them
 
-	//-------------------------------
 	// extra lines
 
- 	memmove((uint8 *) &bars[nbars], (uint8 *) &extraBars[0], nExtraBars*sizeof(_barData));
+ 	memmove((uint8 *) &bars[nbars], (uint8 *) &extraBars[0], nExtraBars * sizeof(_barData));
 	nbars += nExtraBars;
 
-	//-------------------------------
 	// extra nodes
 
- 	memmove((uint8 *) &node[nnodes], (uint8 *) &extraNode[0], nExtraNodes*sizeof(_nodeData));
+ 	memmove((uint8 *) &node[nnodes], (uint8 *) &extraNode[0], nExtraNodes * sizeof(_nodeData));
 	nnodes += nExtraNodes;
-
-	//-------------------------------
 }
 
-//------------------------------------------------------------------------------------------
-void ClearWalkGridList(void)
-{
-	int entry;
-
-	for (entry=0; entry < MAX_WALKGRIDS; entry++)
+void ClearWalkGridList(void) {
+	for (int entry=0; entry < MAX_WALKGRIDS; entry++)
 		walkGridList[entry] = 0;
 }
-//------------------------------------------------------------------------------------------
+
 // called from FN_add_walkgrid
-void AddWalkGrid(int32 gridResource)
-{
+
+void AddWalkGrid(int32 gridResource) {
 	int entry;
 
 	// first, scan list to see if this grid is already included
-	entry=0;
-	while ((entry < MAX_WALKGRIDS) && (walkGridList[entry] != gridResource))
+
+	entry = 0;
+	while (entry < MAX_WALKGRIDS && walkGridList[entry] != gridResource)
 		entry++;
 
-	if (entry == MAX_WALKGRIDS)	// if this new resource isn't already in the list, then add it, (otherwise finish)
-	{
+	// if this new resource isn't already in the list, then add it,
+	// (otherwise finish)
+
+	if (entry == MAX_WALKGRIDS) {
 		// scan the list for a free slot
-		entry=0;
-		while ((entry < MAX_WALKGRIDS) && (walkGridList[entry]))
+		entry = 0;
+		while (entry < MAX_WALKGRIDS && walkGridList[entry])
 			entry++;
 
-		if (entry < MAX_WALKGRIDS)	// if we found a free slot
+		// if we found a free slot
+		if (entry < MAX_WALKGRIDS)
 			walkGridList[entry] = gridResource;
 		else
-			Con_fatal_error("ERROR: walkGridList[] full in %s line %d",__FILE__,__LINE__);
+			Con_fatal_error("ERROR: walkGridList[] full in %s line %d", __FILE__, __LINE__);
 	}
 }
-//--------------------------------------------------------------------------------------
+
 // called from FN_remove_walkgrid
-void RemoveWalkGrid(int32 gridResource)
-{
+
+void RemoveWalkGrid(int32 gridResource) {
 	int entry;
 
 	// first, scan list to see if this grid is actually there
-	entry=0;
-	while ((entry < MAX_WALKGRIDS) && (walkGridList[entry] != gridResource))
+	entry = 0;
+	while (entry < MAX_WALKGRIDS && walkGridList[entry] != gridResource)
 		entry++;
 
-	if (entry < MAX_WALKGRIDS)	// if we've found it in the list, reset entry to zero (otherwise just ignore the request)
+	// if we've found it in the list, reset entry to zero (otherwise just
+	// ignore the request)
+	if (entry < MAX_WALKGRIDS)
 		walkGridList[entry] = 0;
 }
-//--------------------------------------------------------------------------------------
-
diff --git a/sword2/router.h b/sword2/router.h
index 364b884a61..b22a23fef1 100644
--- a/sword2/router.h
+++ b/sword2/router.h
@@ -20,7 +20,6 @@
 #ifndef _ROUTER_H
 #define _ROUTER_H
 
-//#include "src\driver96.h"
 #include "memory.h"
 #include "object.h"
 
@@ -28,44 +27,40 @@
 	#pragma START_PACK_STRUCTS
 #endif
 
-typedef	struct _walkData
-{
-	uint16	frame;
-	int16	x;
-	int16	y;
-	uint8	step;
-	uint8	dir;
+typedef	struct _walkData {
+	uint16 frame;
+	int16 x;
+	int16 y;
+	uint8 step;
+	uint8 dir;
 } GCC_PACK _walkData;
 
-typedef struct
-{
-	int16   x1;
-  	int16   y1;
-  	int16   x2;
-	int16   y2;
-	int16   xmin;
-	int16   ymin;
-	int16   xmax;
-	int16   ymax;
-	int16   dx;	   // x2 - x1
-	int16   dy;	   // y2 - y1
-	int32   co;	   // co = (y1 *dx)- (x1*dy) from an equation for a line y*dx = x*dy + co
+typedef struct {
+	int16 x1;
+  	int16 y1;
+  	int16 x2;
+	int16 y2;
+	int16 xmin;
+	int16 ymin;
+	int16 xmax;
+	int16 ymax;
+	int16 dx;	// x2 - x1
+	int16 dy;	// y2 - y1
+	int32 co;	// co = (y1 *dx)- (x1*dy) from an equation for a line y*dx = x*dy + co
 } GCC_PACK _barData;
 
-typedef struct
-{
-	int16   x;
-	int16   y;
-	int16	level;
-	int16   prev;
-	int16   dist;
+typedef struct {
+	int16 x;
+	int16 y;
+	int16 level;
+	int16 prev;
+	int16 dist;
 } GCC_PACK _nodeData;
 
 #if !defined(__GNUC__)
 	#pragma END_PACK_STRUCTS
 #endif
 
-
 int32 RouteFinder(Object_mega *ob_mega, Object_walkdata *ob_walkdata, int32 x, int32 y, int32 dir);
 
 void EarlySlowOut(Object_mega *ob_mega, Object_walkdata *ob_walkdata);
@@ -79,9 +74,5 @@ void PlotWalkGrid(void);
 void AddWalkGrid(int32 gridResource);
 void RemoveWalkGrid(int32 gridResource);
 void ClearWalkGridList(void);
-uint8 CheckForCollision(void);
-
-//--------------------------------------------------------------------------------------
-
 
 #endif